JavaHowTo

Data Retrieval & Classification using jsoup

2012-08-10T13:38:00.000+05:30

In the process of domain specific data retrieval, the main idea is to get the content which are within a certain domain & display to the user. So the relevant data may not be the whole website or even the web page instead it might be a small section within the webpage. Therefore a technological approach required to retrieve above mentioned data retrieval. There are few systems, libraries that can be used to retrieve specific data from websites, among them, jsoup looks promising for the purpose because of its features.

Jsoup is a java library for working with real world HTML. It provides a very convenient API for extracting & manipulating data, using the best of DOM, CSS, & jquery like methods. Jsoup is an open source application which makes it a perfect development tool for this project as it can be modified according to the purpose. As jsoup is specially developed for java environment, it makes a perfect candidate for the development process as well. In the project, need to extract some sections within a given website, where the URL will be available. In this case, jsoup is suitable for the process, as it can be used to extract data for a given URL, from a file, or from a given string. Thus jsoup can be used to extract data from the given URL & then store the data & also extract or scrape sections within the data.

Jsoup API has many sophisticated features that can be used to enhance the extraction process. For example, data extraction can be done by reading the DOM structure of the website. As all websites are using HTML, jsoup can read the structure of the websites & go through the DOM structure & get the content as intended. In the jsoup, the HTML tags & attributes can be easily identified & get data by referring to them. These are called elements & elements provide a range od DOM-like methods to find elements, & extract & manipulate their data. The DOM getters are contextual: called on a parent document & find matching elements under the document; called on a child element they find elements under that child. There are many elements & getters provided in jsoup. That makes the data extraction process very easy because, can extract only the intended sections without grabbing a bunch of web pages.

The extracted data need to be classified according to the content type. That means as text, images, videos, links, etc. & jsoup can be used for the categorization. It has the features to identify the content separately as text, links, and images & based on that the extraction process can be separated. It can identify the content type using the HTML tags & based on that use functions to extract each content type. Thus while extracting the data, the content classification also can be achieved using the jsoup.

So considering the requirements for data extraction process, jsoup can be mentioned as a highly sophisticated tool for data extraction. The features & functions provided for java based data extraction made the process very much easy & as it is an open source application, the cost effectiveness is also achieved.

Using OpenJPA in Development

2012-05-27T18:05:00.000+05:30

you know by now the use of openJPA but I havent mention you the way to use this in practice. Let me explain this using a simple example. I am using Netbeans IDE, which is easy for me to use openJPA as it will create the entity classes automatically. Study the following steps.
1. Create a new netbeans web project.
2. write click on the project & from the menu select New -->other--> persistence --> Persistence Unit.
you will get following dialog box.

3. let the name as it is & in the persistence provider section you need to select openJPA. If that is not in the list you need to create a new library. Go to new library & add your openjpa-all-2.1.0 jar. (you need to have openjpa unzipped in a folder).
4. Then click ok to complete the persistence creation.
5. Now you need to create a new package to insert the entity files. (example -com.openjpa.domain)
6.Right click on the package & select New -->other--> persistence --> Entity class from database.
Here you need to select your database connection. database schema is your db connection.
for example see below figure.

7. once the data source is selected, you can see the tables within the database will be displayed to you & you can select which tables you need to import as an entity class.
8. once you import the entity classes, netbeans will create them automatically.
8. If you take a look at these classes you can see table mapping & queries are generated.

9. then you can create your DAO files & access the data objects using the named queries or normal queries.
10. then you can use them in your servlets & jsps as you required.

So those are the steps to create a openJPA objects using netbeans. Hope this post helped you to understand the basics in openJPA. see you in next post.

MVC Architecture of OpenJPA

2012-05-27T11:33:00.001+05:30

In the development process the standard way is to use Model View Controller architecture, where the separation of each component comes into play.

1. Model – Model represents the data & rules that govern access & update of data. That means basically it will contain database objects to be accessed.

2. View – View is the web pages that we can display. The HTML, JSP pages are under the View category.

3. Controller – This is the controlling mechanism between model & view. This will communicate with Model & View & translate & transport data objects.

Figure MVC Architecture of JPA

1. DAO – DAO means Data Access Objects & it provides an abstract interface to the databases. Basically in DAO layer we write queries to access the database. We can write DAO’s & include methods as much as we wanted. When writing DAO we can use OpenJPA NamedQueries directly.

2. Domain – Domain means the entity classes for the tables in the database. For each table in the database, we can create a mapping entity class & define the table entities as objects. It is much more efficient way than traditional relational database mapping. Domain also called as POJO (Plain Old Java Objects).

In order to create the connection between database & domains, need to create an xml file including such details. That xml file is named as “persistance.xml” by default. It is similar to the normal database connection establishment, but it is defined in xml format. A typical persistance.xml file would contain following details.

This holds the connection details & there are two ways to retrieve the data objects. One method is using Entity manager & other way is using Session factory. I used entity manager factory in the DAO layers.

Hope this post would help you to understand the MVC architecture of the OpenJPA. Stay in touch :)

What is Spring MVC Architecture

2011-11-24T18:44:00.001+05:30

As I mentioned earlier, Spring has a MVC architecture which make the Spring a high performance framework comparing to others. in the MVC architecture of Spring, there are important parts to be noted as dispatcher Servlet, handler mapping, view resolver & views. The abstract communication between these components is as follows. the communication steps are as follows.

1. The user request is received by the dispatcher servlet. This dispatcher servlet is the key for mapping the resources to the correct requests. It contains xml mapping codes defining each resource with the path to the resource.

2. Then the dispatcher servlet will invoke the controller for the request.

3. The Controller process the request by calling the appropriate service methods and returns a ModeAndView object to the DispatcherServlet. The ModeAndView object contains the model data and the view name.

4. The DispatcherServlet sends the view name to a ViewResolver to find the actual View to invoke.

5. Now the DispatcherServlet will pass the model object to the View to render the result & the View with the help of the model data will render the result back to the user.

What is a Controller in Spring Framework

2011-11-24T18:17:00.001+05:30

In Spring framework, all the requests sent by the dispatcher servlet normally directed to a controller class. This controller class is mapping those requests to each process & execute the requested inputs. In a project there can be multiple controllers defined for different purposes. All these controllers refers to the same dispatcher servlet. As I mentioned in the previous post, @RequestMapping keyword is used to map the dispatcher servlet with the controller class.

In a Controller mapping there are two types of mapping as GET & POST. Normally there can be many GET methods in a controller while one POST method is employed. GET request method is used to get the requests from the user do the desired work & output results into a view( jsp pages). A GET request is shown below.

A POST request is used to post the results in to a page as usual. A POST request is shown below.

So this is about the basic concept of the Spring controller. Hope the post is useful for you & feel free to make a comment.

What is Dispatcher-Servlet in Spring

2011-11-24T17:49:00.001+05:30

When you work with Spring framework, you will find an xml file called dispatcher-servlet is created when we create a new project. If we use Maven to build the project we can define the name for this servlet instead of the default name "dispatcher-servlet.xml". Normally we give the project name as the prefix & keep the servlet part as it is. For example, if the project name is Navigator, then dispatcher servlet can be "navigater-servlet.xml".

the purpose of the dispatcher is to receive the requests & map those requests to the correct resources such as models & views. that means when a request is received it should be handled to meet with the correct resources & output the results. therefore we define all the request mapping codes within the dispatcher servlet. It is an xml file which contains java beans.

when we define the beans tag, we must include all relevant bean URLs within it in order to map the resources. A sample beans tag definition is as follows.

After defining the beans, we can define the resource mapping tags. For example, we can define view resolvers, annotation URLs or any other DAO resource URLs within the xml.

In order to map the requests the request mapping code must be included within the java controller pages. such mapping code can be shown as follows.

@RequestMapping("/enterdetails")

This @RequestMapping denotes that the current page is mapped with the dispatcher servlet. so if the mapping is correct, the request will be directed to this controller & controller will do the rest if the things.

Now you may have a clear idea on the dispatcher servlet. Stay tuned for the next post.

How to Use Spring Framework With Maven

2011-09-10T15:19:00.002+05:30

In earlier post I was describing about Spring framework & its components. Now let me describe you how we can use this to our development process. I am using Ubuntu for the development form the beginning, so this is also going under Ubuntu.
First you need to download the latest version of the Spring framework from HERE.

Then you need to untar the tar file & move the folder to your preferred place. In the installation process, you n=only need to do that.The folder will contain sub folders such as dist, projects & src which contains all the Spring dependencies required for the development.
In order to use Spring in your java projects with maven, you need to add the Spring to the POM file of the Maven. I think now all of you are aware of Maven & the POM as I've described them in my earlier posts.
so to add Spring to Maven you need to add it as a Dependency to the POM. This is how you need to do it.

1. Create a Maven based project using following code.
mvn archetype:create -DgroupId=com.maven.test -DartifactId=TestProject -DarchetypeArtifactId=maven-archetype-webapp

now this will create an empty POM in your project folder.

2. Open the pom & you will see something similar to this.

<?xml version="1.0" encoding="UTF-8"?>

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <modelVersion>4.0.0</modelVersion>

  <groupId>org.springsource.maven</groupId>

  <artifactId>example1</artifactId>

  <version>1.0-SNAPSHOT</version>

  <name>Our Simple Project</name>

</project>

3. Now insert the following code within the < dependencies > </dependencies > tags.

           <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>3.0.5.RELEASE</version>

       </dependency>

4. This tag will tell java that Spring framework is installed & ready to use for the project.

Now you can use all the Spring dependencies under this as required for the project. Following are the most used dependencies. The version can be varied so that it can be given like a variable & define it in the top of the POM under properties.

-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-expression</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> <version>${org.springframework.version}</version> </dependency>

-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-orm</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-oxm</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc-portlet</artifactId> <version>${org.springframework.version}</version> </dependency>


-<dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>${org.springframework.version}</version> <scope>test</scope> </dependency>

So this is how you integrate Spring into Maven using the POM dependencies. So enjoy development with Spring until the next post.

Spring Framework for J2EE Part 2 - Components & Features

2011-09-10T14:28:00.003+05:30

In the previous post, you've learned about the Spring Framework. Now let me tell you about the main components & the features of the Spring.
Spring framework has following modules as below.

1. Spring DAO
The DAO package provides a JDBC-abstraction layer that removes the need to do tedious JDBC coding and parsing of database-vendor specific error codes. Also, the JDBC package provides a way to do programmatic as well as declarative transaction management, not only for classes implementing special interfaces, but for all your POJOs (plain old Java objects).
The Spring JDBC DAO abstraction layer offers a meaningful exception hierarchy for managing the exception handling and error messages thrown by different database vendors. The exception hierarchy simplifies error handling and greatly reduces the amount of exception code you need to write, such as opening and closing connections. Spring DAO's JDBC-oriented exceptions comply to its generic DAO exception hierarchy.

2. Spring ORM
The ORM package provides integration layers for popular object-relational mapping APIs, including JPA, JDO, Hibernate, and iBatis. Using the ORM package you can use all those O/R-mappers in combination with all the other features Spring offers, such as the simple declarative transaction management feature mentioned previously.

3. Spring JEE -Spring Context
The Context package build on the solid base provided by the Core package: it provides a way to access objects in a framework-style manner in a fashion somewhat reminiscent of a JNDI-registry. The context package inherits its features from the beans package and adds support for internationalization (I18N) (using for example resource bundles), event-propagation, resource-loading, and the transparent creation of contexts by, for example, a servlet container.
The Spring context is a configuration file that provides context information to the Spring framework. The Spring context includes enterprise services such as JNDI, EJB, e-mail, internalization, validation, and scheduling functionality.

4. Spring Web
Spring's Web package provides basic web-oriented integration features, such as multipart file-upload functionality, the initialization of the IoC container using servlet listeners and a web-oriented application context. When using Spring together with WebWork or Struts, this is the package to integrate with.
The Web context module builds on top of the application context module, providing contexts for Web-based applications. As a result, the Spring framework supports integration with Jakarta Struts. The Web module also eases the tasks of handling multi-part requests and binding request parameters to domain objects.

5. Spring Web MVC
The Model-View-Controller (MVC) framework is a full-featured MVC implementation for building Web applications. The MVC framework is highly configurable via strategy interfaces and accommodates numerous view technologies including JSP, Velocity, Tiles, iText, and POI.
Spring's MVC package provides a Model-View-Controller (MVC) implementation for web-applications. Spring's MVC framework is not just any old implementation; it provides a clean separation between domain model code and web forms, and allows you to use all the other features of the Spring Framework.

6. Spring AOP
Spring's AOP package provides an AOP Alliance-compliant aspect-oriented programming implementation allowing you to define, for example, method-interceptors and pointcuts to cleanly decouple code implementing functionality that should logically speaking be separated. Using source-level metadata functionality you can also incorporate all kinds of behavioral information into your code, in a manner similar to that of .NET attributes.
The Spring AOP module integrates aspect-oriented programming functionality directly into the Spring framework, through its configuration management feature. As a result you can easily AOP-enable any object managed by the Spring framework. The Spring AOP module provides transaction management services for objects in any Spring-based application. With Spring AOP you can incorporate declarative transaction management into your applications without relying on EJB components.

7. Spring Core
The Core package is the most fundamental part of the framework and provides the IoC and Dependency Injection features. The basic concept here is the BeanFactory, which provides a sophisticated implementation of the factory pattern which removes the need for programmatic singletons and allows you to decouple the configuration and specification of dependencies from your actual program logic.
The core container provides the essential functionality of the Spring framework. A primary component of the core container is the BeanFactory, an implementation of the Factory pattern. The BeanFactory applies the Inversion of Control (IOC) pattern to separate an application's configuration and dependency specification from the actual application code.

These are the main components in the Spring Framework that makes your life easy. The latest version of Spring is Spring 3.0. Here are some of the features in Spring 3.0

Spring Expression Language
IoC enhancements/Java based bean metadata
General-purpose type conversion system and field formatting system
Object to XML mapping functionality (OXM) moved from Spring Web Services project
Comprehensive REST support
@MVC additions
Declarative model validation
Early support for Java EE 6
Embedded database support

So now you know the basics of Spring framework. So lets get started with Spring in the next post.

Spring Framework for J2EE

2011-09-10T13:19:00.001+05:30

Well, it's being a while since I posted something here.All because I had lot of works related to these topics. So now it's time to give you what I've learned through the period. Lets start with Spring framework & go on with further developments.
So how many of you heard of Spring Framework? No doubt many of you have heard of it. Let me describe about it in simple words.
Spring framework is a gift for java developers that it makes the development lot easier than having a plain or pure java. As always frameworks give more than that of base (original) allowing developers to use extra features. So in the Spring also there are such features to allow development easy.
Spring is a free and opensource application designed for java development environment which licensed under Apache. The main focus of Spring is to have a Lightweight development environment together with solving the complexity of enterprise application development. One of the chief advantages of the Spring framework is its layered architecture, which allows you to be selective about which of its components you use while also providing a cohesive framework for J2EE application development.
Spring enables you to build applications from “plain old Java objects” (POJOs) and to apply enterprise services non-invasively to POJOs. This capability applies to the Java SE programming model and to full and partial Java EE.

Examples of how you, as an application developer, can use the Spring platform advantage:

Make a Java method execute in a database transaction without having to deal with transaction APIs.
Make a local Java method a remote procedure without having to deal with remote APIs.
Make a local Java method a management operation without having to deal with JMX APIs.
Make a local Java method a message handler without having to deal with JMS APIs.

so now you can understand that Spring framework is an excellent application framework for J2EE development which controls the infrastructure & allowing us to more focus on the application development.
In the next post let me introduce you to the key components & features in Spring framework.

OpenJPA Components

2011-07-24T10:28:00.001+05:30

Earlier I have explained about the concept of openJPA & its usage in the programming environment. So before going into development, let me describe about the architectural components in openJPA.
if we consider a web based project using openJPA, it will have web pages, source packages, libraries & configuration files.a typical openJPA based netbeans project folder structure would look like this.

In web pages we include all our views. that means in MVC architecture the View is the web pages. So .html, .jsp files goes to the web pages.
In source packages you need to define the packages required. In standard openJPA based development environment, you need to have following packages.

DAO - Data Access Object

DAO means objects that provides an abstract interface to databases. Separate logic within 2 parts of application can be done using same DAO interface & then changes does not affect to DAO clients. Basically what it does is separating the data access logic from business logic. Also DAO provides CRUD operations (Create/ Read/ Update/ Delete).

Domain

In the domain, we include the database object files. That means if we create a database having two tables, we need to import the table objects to the domain package. For example if we have a table called "employer" then in the domain package there will be a java file called employer.java containing the table objects.

Service

In services package we define the mapping between DAO to web pages.

3. In Libraries you need to include all the jar files & other libraries required for the project. For example, in OpenJPA based project it will contain MYSQL JDBC Driver, persistence ejb-persistence.jar, openjpa-all-2.1.0.jar, tomcat 6.0, etc.

4. In the configuration files the important file is the Persistence.xml which holds the entire openJPA structure. persistence.xml is to define the service providers & the services to be provided. basically it will contain following details.

So I just mentioned the important things you need to know before starting a openJPA project. In the next post let's try this out & develop a MVC based project.

JSP Servlet HTML Communication

2011-07-02T19:38:00.001+05:30

When you are working with jsp & servlets you need to go from one page to another & that page may be a jsp, servlet, java page or html page. Well I know how I suffered from those basic stuff when I am at the basics. So to make you feel better let me give some hints on those conversions.

HTML to Sevlet

< form action ="/newservlet" method ="post" />
Here the form action will be the page you need to go after a submit. Here the servlet page is newservlet.java.

JSP to Servlet

<jsp:include page="/newservlet.java" Flush="true" />

This jsp:include will make a jsp page request to go to a servlet & do the logic within the request & return the values will be return to the jsp page again.

JSP to JSP

<jsp:forward page="/newjsp.jsp" />

The jsp:forward command will redirect the current page to another page (newjsp.jsp).

Servlet to JSP/HTML

String des = "/newjsp.jsp";

response.SendRedirect(response.encodedRedirect(des));

Another way.

RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/testin.html");

Dispatcher.include(request,response);

So hope you find this post helpful for you to begin work. :)

JSP & Servlets

2011-07-02T19:12:00.002+05:30

Java Servlets

Servlets are Java technology's answer to CGI programming. They are programs that run on a Web server and build Web pages. Building Web pages on the fly is useful (and commonly done) for a number of reasons:

The Web page is based on data submitted by the user. For example the results pages from search engines are generated this way, and programs that process orders for e-commerce sites do this as well.
The data changes frequently. For example, a weather-report or news headlines page might build the page dynamically, perhaps returning a previously built page if it is still up to date.
The Web page uses information from corporate databases or other such sources. For example, you would use this for making a Web page at an on-line store that lists current prices and number of items in stock.

Servlets don't have a main method & they are under the control of a container. Server sends the request to the container & then the container call for the correct servlet.

In order to get the service of a servlet you need to import following containers to your java file.

import javax.servlet.http.*

import javax.servlet.*

A Servlet has two methods.

Http.ServletRequest - this object is passed as arguments to servlets's service methods such as doGet, doPost

Http.ServletResponse - this object is passed as arguments to servlets's service methods such as doGet, doPost.

Java Server Pages

Java Server Pages (JSP) is a technology that lets you mix regular, static HTML with dynamically-generated HTML. Many Web pages that are built by CGI programs are mostly static, with the dynamic part limited to a few small locations. But most CGI variations, including servlets, make you generate the entire page via your program, even though most of it is always the same. JSP lets you create the two parts separately.

Here's an example:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>Welcome to Our Store</TITLE></HEAD>
<BODY>
<H1>Welcome to JSP</H1>
<SMALL>Welcome,
<!-- User name is "New User" for first-time visitors --> 
<% out.println(Utils.getUserNameFromCookie(request)); %>
To access your account settings, click
<A HREF="Account-Settings.html">here.</A></SMALL>
<P>
Regular HTML for all the rest of the on-line store's Web page.
</BODY></HTML>

In the next post let me tell you about JSP/Servlet communication. Stay tuned :)

Introduction to J2EE

2011-07-02T18:50:00.001+05:30

J2EE or Java 2 Platform, Enterprise Edition is one of the most powerful ways of developing Multitiered web applications. The J2EE platform uses a distributed multitiered application model for enterprise applications. Application logic is divided into components according to function, and the various application components that make up a J2EE application are installed on different machines depending on the tier in the multitiered J2EE environment to which the application component belongs. multitiered application can be describes as in the figure below.

As this is about web application development, there is always two sides as Client & Server. In the client side the java pages, html pages are running & in the server side, Java Server Pages (JSP) , Servlets, Enterprise Java Beans (EJB) are running. So tiers made them separate from each other & also give a clear way to communicate each other.

J2EE Containers

The component-based and platform-independent J2EE architecture makes J2EE applications easy to write because business logic is organized into reusable components. In addition, the J2EE server provides underlying services in the form of a container for every component type. Because you do not have to develop these services yourself, you are free to concentrate on solving the business problem at hand.So the container is doing the controlling part of the web components in the web development. Container is the interface between a component & its functional behavior. So in order to execute an application the container should be loaded before hand.
the relationship between container & J2EE can be shown as follows.

There are mainly 5 containers available in J2EE, namely
J2EE Server , Enterprise JavaBeans (EJB) container, Web container, Application client container & Applet container.

Web Service Support

The J2EE platform provides the XML APIs and tools you need to quickly design, develop, test, and deploy web services and clients that fully interoperate with other web services and clients running on Java-based or non-Java-based platforms. Basically J2EE has XML , WSDL , SOAP & UDDI standards support in order to have a complete web service application development environment.

So this is just a brief description of J2EE environment. In the next posts, I'm hoping to tell more about JSP, Servlets & its implementation process in action. Stay tuned until then ;)

How to Connect JDBC Driver to a Java Program

2011-06-27T20:39:00.004+05:30

Well, when you do programming, its quite common to work with databases. So many people use mysql as their database in most of the cases. So I thought it will be useful for the newcomers to learn how to connect mysql to a java program.

Assuming you have installed mysql in your machine lets look at how we write our codes.
or here are the links for you to get them. :)
Get JDBC Driver for Ubuntu
MySQL-Query-Browser

First you need to create a database for your purpose.

Here is the code for creating a database using mysql -

In Query Browser

CREATE DATABASE testdb;

in phpmyadmin

CREATE DATABASE testdb;

USE testdb;

Then you need to define the tables. Lets create a table called Student including student id, name, address as the fields.

create table student(

stu_id int (2),

stu_name varchar (20),

stu_address varchar (50)

);

Now you need to open your IDE, in my case its Netbeans.

Now create a New Java project giving a name - i.e. testdb
Now goto Libraries in the left panel & right click to get the menu & select add a librabry
From the menu select
MYSQL JDBC Driver - mysql-connector-java-5.1.6-bin.jar
(you need to download this first from the site)

Then in the java file you need to import below package.
import java.sql.*;

Now within the main method, write these codes

      Connection con = null;
       String url = "jdbc:mysql://localhost:3306/testdb";
       String user = "root";
       String password = "root";

Here you should give your database username & password.
Then within a try block you need to write this.
          con = DriverManager.getConnection(url, user, password);
           Statement st = con.createStatement();

Now you are ready to write queries to insert/upadate & delete records in the table.

1. Insert data to the Database table.

String sql = ("INSERT student VALUES ('1','Saman','Colombo')");

st.executeUpdate(sql);

System.out.println("Entered");

2. Selecting & Displaying Results

ResultSet rs = st.executeQuery("SELECT * FROM student WHERE user_id ='1'");

while(rs.next()) {

int id = rs.getInt("userstu_id");

String name = rs.getString("stu_name");

String address = rs.getString("stu_address");

System.out.println("ID :" + id);

System.out.println("Name :" + name);

System.out.println("Address :" + address);

}

3. Deleting Data from the Table

String sql1 = ("DELETE FROM user_info");

st.executeUpdate(sql1);

So hope this little push would help you out guyz. Try more things your own :)

What is pom.xml

2011-06-26T19:45:00.002+05:30

POM is a xml file which contains the project configuration details used by Maven. It provides all the configuration required for a project. POM means Project Object Model & as the name suggests it defines the model of the project as well. In the normal project development you will add jar files & libraries as required. In maven based development, those jars, libraries are added to the project using this pom.xml. In the pom context we call those jars, libraries as Dependencies.
A sample pom.xml would be like this.

Useful Maven Commands

2011-06-26T17:59:00.002+05:30

1. Compiling Maven Project

To compile a maven project open terminal & go to project folder & type
mvn compile
or

mvn clean compile

Both commands will compile the maven project but mvn clean compile will always compile the project as newer project so that older compiled versions will be cleaned. So it is good to use clean compile to have a CLEAN project ;)

2. Installing or building the project

Type the following

mvn install

mvn clean install

This will compile, test & package the project into war or jar.

3. Offline usage

To work offline use commands as follows

mvn -o compile

mvn -o install

mvn -o test

Creating a Maven based project

2011-06-26T17:36:00.003+05:30

Open the terminal & go to the folder where you need to create the project.
Type the following command.

mvn archetype:create -DgroupId=com.maven.test -DartifactId=TestProject -DarchetypeArtifactId=maven-archetype-webapp

Here DgroupId means the group ID of the project & artifact Id is the project name. you can define both these & remember to give groupId seperated by the dot(.). so the output would be like this.

This will create a nice looking folder structure :)
Within your project folder you can see a POM file & src folder. before opening this using netbeans you need to add another folder named "java" inside main folder.so your main folder would look like this.

Now you can add the java, jsp, servelts, as required & also you can use any ORM like openJPA or Hibernate.

Now open the pom.xml file in the project folder. I will tell about pom.xml more in my next post. Till then this quick guide will help you out to develop a maven project :)
Initially your pom.xml would look like below.

Here you need to define the dependencies as per your requirements. for example of you are using Spring & Hibernate you need to add all the dependencies here. These dependencies will be the jar files & the libraries in the project.

After that you can open the maven based project using Netbeans.
1. Go to Netbeans & go to Open Project menu
2. browse for the location of the project & you will see ma symbols in front of the project name.
3. open the project

Then your project folder in the Netbeans would be look like this.

Then you need to build a war file in order to run the project. I am using tomcat as my server.
Now type the below to clean & build a war file

mvn clean install

Then goto your project folder & you will see a new folder called target is created & open the folder & you can see a .war file is created. (TestProject.war)
Copy this .war & goto web apps folder in tomcat & paste it.
You can do this using tomcat manager as well. There you will find at the bottom a place to browse for .war file & upload. you can do it either ways :)

now you need to compile the project using mvn compile & type the url of the home page of your project to run the project.
Now you will see the output like this :)

So thats it. Follow the steps & enjoy maven developments :)

A Quick Guide to Maven 3.0

2011-06-26T17:33:00.002+05:30

In a previous post, I told you guys how to set up maven in your machine. Now let me give you a brief introduction about apache maven & how to use it in your developments.
Apache Maven is a software project management tool where programmers can easily manage the development process. Maven allows us to maintain & stick into a certain building structure & work according to a guided pattern.Maven gives a standard way of building java projects & we can use ORM (Object Relational Mapping) methods together with the Maven.
Basically Maven will create a project folder structure which is very clean & clear. standard programmers always looking for structured development techniques & thus Maven is the best solution for them.

What is JPA

2011-06-11T17:23:00.002+05:30

JPA means Java Persistence API & it is a framework used to manage the relational data in applications. JPA will allow programmers to change the traditional database approach by giving a newer way of accessing the database entities.

in the normal database context, you will have a database created using mysql, sql or oracle & you gonna need to write queries to access the database entities & do whatever the transactions. but when the database is too large & the queries getting complex, the access will be time consuming & complex as well. So that developers needed a light weight method to access database objects in a faster way. Thats where the concept of JPA come in to play.

Before JPA there were several persistence units such as JDBC, ODB, JDO, etc. JPA combines all the best features of all & present in a sophisticated manner. Following are the comparison of JPA with others.

In JPA, the database objects are created & programmer access these objects not the database entities itself. As java is Object Oriented, this method is quite faster than traditional relational database approach. JPA will map the database entities to database objects so that you can access the data via the objects. There are many ORM methods such as openJPA, Hibernate, etc.

To use JPA you need to import the package javax.persistence to your working environment.

How To Install Eclipse IDE in Ubuntu

2011-06-11T16:58:00.000+05:30

Right. last time you installed Netbeans IDE & this time I'm gonna tell you how to install Eclipse in Ubuntu.

Step 1

Download the latest Eclipse IDE from here - Eclipse Home Page

Here you can select the suitable IDE that you are looking for, for example java-developers , eclipse-ide-java-ee-developers, etc.

There are multiple versions as well such as Helios, Galileo, Classic, etc. I use Helios SR2 version.

Step 2

After the download completed, you will have a tar.gz file like this - eclipse-jee-helios-SR2-linux-gtk.tar.gz

Now select the partitions where you want Eclipse to be installed & copy the .gz file there.

Step 3

Now right click on the .gz file & select Extract here.

This will create a folder containing the Eclipse IDE & its components.

Step 4

In Eclipse you don't need any special installations series like in Netbeans, extracting will do the installation itself.

Now all you need to do is to open the extracted folder & double click on the eclipse.exe.

you will see eclipse is loading.

Step5

You will be Prompted to select the workspace for Eclipse to work with.

There you need to select a place in your home folder.

By default the path will be like yourhomefoldername/workspace, but you can always change this to your own.

Now you have configured Eclipse IDE successfully. Feel free to enjoy the IDE & show your colors :)

How to Install Netbeans IDE in Ubuntu

2011-06-04T20:24:00.000+05:30

Lets see how to install Netbeans IDE in Ubuntu step by step.

Step1
First you need to download the IDE from Netbeans Download page

Step 2
Select platform as Linux(x86/x64) from the upper right corner tab.

Step 3
Select the type of version you need. For example you can select java, javaFX, complete, etc .

Step 4
Then you are clear to press Download button. It will start downloading a xx.sh file

Step 5
When the downloading finished, copy the downloaded file to the directory where you wish to install Netbeans.

Step 6
Then open the terminal & enter this command to run the installation by Ubuntu.
sh netbeans-6.9.1-ml-linux.sh
(note that here you should copy the name of your downloaded netbeans IDE)

Step 7
After some initial steps Ubuntu will give the control to the IDE itself to continue the installation.
Please follow the on-screen instructions carefully by clicking Next button respectively.

Step 8
It will take some time to install the IDE & when its done, you can open the IDE & thats it.
Now you are going to be a java expert ;)

How to Install Maven in Ubuntu

2011-06-04T17:43:00.000+05:30

Step 1
First you need to download Maven from the maven site : http://maven.apache.org/download.html
Select the latest version of Maven & make sure to download the *.tar.gz version.
eg : apache-maven-3.0.3-bin.tar.gz

Step 2
Now you have the gz file with you & copy the gz file to the place where you want it to be installed.

Step 3
right click on the .gz file & select Extract Here option.

Step 4
Now copy the path of the Maven folder.
You can do this by right clicking the folder tab & select copy; it will copy the path.

Step 4
Now go to your Home Folder

Step 5
go to View menu & click on Show hidden Files menu. View -> Show hidden Files
or press ctrl+H

Step 6
Now start typing .bashrc in the Home Folder & then .bashrc file will be selected.

Step 7
Double click to open it & goto the bottom of the page.

Step 8
Insert these two commands to set the path for the Maven.

EXPORT MAVEN HOME =/home/yourname/foldername/apache-maven-3.0.3
EXPORT PATH = $MAVEN_HOME/bin:$PATH

Step 9
Right now you are done with maven. check whether it is working correctly by inserting this command in the terminal.
mvn -v

This will display a set of statements as below.

Apache Maven 3.0.3 (r1075438; 2011-02-28 23:01:09+0530)
Maven home: /home/xxxxxxxxx/myprograms/apache-maven-3.0.3
Java version: 1.6.0_25, vendor: Sun Microsystems Inc.
Java home: /usr/lib/jvm/java-6-sun-1.6.0.25/jre
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "2.6.38-8-generic", arch: "amd64", family: "unix"

If you can see something similar to above, be happy. because oyu have successfully installed maven in your machine. :)

how to Install java in Ubuntu

2011-06-04T17:23:00.000+05:30

Step 1
Make sure you are connected to Internet.

Step 2
Open the terminal (normally it is in the upper panel right after the firefox).

Step 3
type this command or copy & paste.
sudo apt-get install sun-java6-jdk

Step 4
Enter your account password in front of "[sudo] password for yourname"

Step 5
Then the rest is up to Internet & it will download the java from the source.

When you install this way, you don't need to set the path in .bashrc file for java. So that's how you install java. Now you are ready to explore the java world :)

Welcome Friends !!!

2011-06-04T15:48:00.000+05:30

Well, this is for the people who come up with some problems when working with java & java related technologies. You will be exposed to java, hibernate, openJPA, jsp, servlets , databases, & many more from this "JavaHowTo". So, stay up-to-date to get solutions for your mind blowing problems.
Cheers,