Social Icons

twitterfacebookgoogle pluslinkedinrss feed

Thursday, January 28, 2010

Spring-Hibernate Maven project- Part 3

Hibernate Configuration and Project Deployment


In the previous post I created the hibernate mapping files for the Person-Address domain classes. In here we are going to create the hibernate configuration file which creates the database connection according to the defined URL, credentials and other properties.

On the deplyment of the project, the hibernate configuration file is executed through the commands in pom.xml.

We have to put the hibernate configuration file inside the src/main/resources directory. For that right cick on the directory, select new, select other. From there expand the hibernate icon and select Hibernate Configuration file (cfg.xml).


Click Next


Keep the default name "hibernate.cfg.xml" same and click Next
Give the values in the appeared window give the values as follows.


Make sure to verify your mysql username and password, and enter the corret one according to your mysql configuration.

hibernate.cfg.xml

    
        
com.mysql.jdbc.Driver
        
root
        
jdbc:mysql://localhost:3306/testdb1
        
root
        
org.hibernate.dialect.MySQLDialect
        
        
        
    

Add the mapping resource entries to your hibernate.cfg.xml file as above.
Here is the directory structureof the project after the hibernate.config.xml file is being added.




Let's add the build elements to the pom.xml file to execute the mapping files and create the tables accordingly.

append the following etries to the pom.xml file inside the project tags.

  
   
    org.apache.maven.plugins
    maven-compiler-plugin
    
     1.5
     1.5
    
   
   
    maven-resources-plugin
   
   
    org.apache.maven.plugins
    maven-eclipse-plugin
    2.7
   
   
    org.codehaus.mojo
    hibernate3-maven-plugin
   
   
    org.apache.maven.plugins
    maven-source-plugin
    
     target
     
     false
    
    
     
      make-source-jar
      package
      
       jar
      
     
    
   
   
    org.codehaus.mojo
    hibernate3-maven-plugin 
    
    2.2
    
     
      process-classes
      
       hbm2ddl
      
     
    
    
     
      hsqldb
      hsqldb
      1.8.0.7
     
     
      mysql
      mysql-connector-java
      5.1.6
     
    
    
     
      hbm2ddl
     
     
      target/classes/hibernate.cfg.xml 
      
      schema.sql
      true
      true
      true
      false
     
    
   
   
    maven-checkstyle-plugin
   
  
 

It is ready to execute the project and one more thing left. Go to mysql command line and create a database called testdb1.



Deploying the project

Right click on the project and goto run as--maven install

In the maven console you can examine the execution. It will display the sql of the tables created. If you have followed the things correctly at the end it will display BUILD SUCCESSFUL.


Inside the target directory hibernate/sql will contain the scema.sql file which is a dump file of the created tables. Also the jar files are created. (testapp-0.0.1-SNAPSHOT.jar and tetsapp-0.0.1-SNAPSHOT-source.jar is created)

 
The tables can be viewed through mysql command line.




Comments and Questions are wel come

Friday, January 22, 2010

Spring-Hibernate Maven project- Part 2

Hibernate Mapping

Here the two domain classes have one-to-many relationship. One Person can have many Addresses while one Adress can have only one person. So there is a one-to-many relationship between Person and Address.

In hibernate we have to create the mapping file for each domain class. The mapping file represents the database table which is mapped with the domain class. The table will be created according to things indicated inside mapping classes.

Mapping file for Person.java: - Person.hbm.xml
Mapping file for Address.java: - Address.hbm.xml

Mapping files are located inside src/main/resources. If you have configured Hibernate to be used inside Eclipse you can simply use it. Otherwise let's configure eclpse for hibrenate.

Hibernate-Eclipse Configuration 

Download Hibernate tools from here.
Extract the HibernateTools-3.X.zip file and put all the files inside the features folder into the features folder of the eclipse installation directory and put all the files inside the plugins folder into the plugins folder of the ecilpse installation directory. Restart the eclipse.

Right click src/main/resource.
Create New --Package
Create a new package called hibernate.
Then right click on hibernate package and click  New--Other
In the New wizard Select Hibernate Icon and expand it.
Select Hibernate XML Mapping file (hbm.xml)







Click Next.


Type Person.hbm.xml as the file name.



Click Next.
In the Hibernate XML mapping file window, click Browse. A window will be opened named Select a class to map.
In the text field type Person.java. And select the correct class from the comming list of classes.


Click Ok and Click Finish


Similarly create the Addrees.hbm.xml file mapped with Address.java class.


Now the project structure will be as follows.







Let's put the content to mapping files.
Person.hbm.xml



  
   
  
  
  
  
   
   
  
 




Let's see the each an ever tag.
class tag: defines which is the class being used and table being mapped for the class.
id tag: An attribute inside class which is going to be primary key of the table (PersonID) 
         name: attribute name of the class
         type: type of the table column, to match with the class attribute type (Long=long)
         column: column name of the resulting table
property tag All the attributes in the class expect lists and id attribute
          name: attribute name of the class
         type: type of the table column, to match with the class attribute type (String=string)
         column: column name of the resulting table
 list tag: The lists inside class
         name: Name of the List inside the class
         key tag:Defines the column name of this table which goes as the foriegn key to the Address class
        one-to-many tag: This describes the one-to-many relationship which creats the List inside class. (One Project has many Addresses)
                 class : One-to-many relationship defining class (Address for Person)

Address.hbm.xml

 
  
   
  
  
  
  
  
  
  
 

Respond to the Project class set tag with one-to-many tag, here we have to define the many-to-one tag
     name: name of the attribute of class which reffers the Person class
     class: Class with whome this class makes the relationship
This will be added to the ADDRESS table as column name which defined in Person mapping file.(key column="PERSON_ID")  




Next

Spring-Hibernate Maven project- Part 1

 Here the maven project created in last post, will be extended to add new Persons in to system who has multiple Addresses.

Add the Spring Hibernate dependencies into pom.xml file inside project tags, after the version tag.

 4.0.0
 org.test.testapp
 testapp
 0.0.1-SNAPSHOT
 
  
   org.hibernate
   hibernate-core
   3.3.1.GA
  
  
   org.springframework
   spring
   ${springVersion}
  
 
Dependencies are added, so that once the project install goal is being executed the, needed libraries are added to the project. So we can access the spring and hibernate API's inside our project.

Now right click the project. Select Run As and then Select maven install. Or go to project location through command line and execute mvn install command. If no errors were found, and you got BUILD SUCCESSFULL, then you have added the dependencies successfully.

Let's add domain classes to the project. The domain is consist of Person and Address classes.
In maven project directory structure, all the source files will be located in src/main/java directory.

Right click on the src/main/java directory and clike New--Class

Give Person as the class name and org.test.testapp.domain as the package name.



Now create the Address class inside the same package.


Put the following code inside Address.java.


package org.test.testapp.domain;

public class Address {
    private Long AddressID;
    private String Street;
    private String City;
    private String AreaCode;
    private Person NewPerson;
   
    public Long getAddressID() {
        return AddressID;
    }

    public void setAddressID(Long addressID) {
        AddressID = addressID;
    }
    public Person getNewPerson() {
        return NewPerson;
    }

    public void setNewPerson(Person newPerson) {
        NewPerson = newPerson;
    }

    public String getStreet() {
        return Street;
    }
   
    public void setStreet(String street) {
        Street = street;
    }
   
    public String getCity() {
        return City;
    }
   
    public void setCity(String city) {
        City = city;
    }
   
    public String getAreaCode() {
        return AreaCode;
    }
   
    public void setAreaCode(String areaCode) {
        AreaCode = areaCode;
    }
  
}

Now put the following code inside Person.java

package org.test.testapp.domain;

import java.util.List;

public class Person {
    private Long PersonID;
    private String Name;
    private String TelNo;
    private List AddressList;
   
    public Long getPersonID() {
        return PersonID;
    }
    public void setPersonID(Long personID) {
        PersonID = personID;
    }
   
    public String getName() {
        return Name;
    }
    public void setName(String name) {
        Name = name;
    }
    public String getTelNo() {
        return TelNo;
    }
    public void setTelNo(String telNo) {
        TelNo = telNo;
    }
    public List
getAddressList() {
        return AddressList;
    }
    public void setAddressList(ListaddressList) {
        AddressList = addressList;
    }
   
}
 



Note: Here the both classes consist of their attributes and the getter setter methods for each attribute. For implemet the hibernate connction to thses classes you must follow this coding standard where attributes kept private and getter setter methods fr each attribute kept public.  


Here is the new structural view of the project after adding 2 domain classes.






In the next part let's see how to implement the hibernate mapping classes for these domain classes.

Create a Simple Maven Project



Open Eclipse.
Create a new maven project. File--New--Other
New Wizard will open. There go to maven icon and expand it. Then Select Maven Project item.




Click Next.
In the New Maven Project wizard, select the create a simple project (skip archetype selection) check box.



Click Next
In the New Maven Project wizard enter the following values.


Group Id: org.test.testapp
Artifact Id: testapp
Version: 0.0.1-SNAPSHOT
Packaging: jar




Click Finish.

New Maven Project will be created and display in the Project Explore.
Here is the initial project structure of the created simple Maven project with a jar packaging. 




  Pom.xml file will contain the following initial details


	4.0.0
	org.test.testapp
	testapp
	0.0.1-SNAPSHOT









Run the Project

Executing Maven Goals.
Right Click on the testapp.
Select Run as
Here you can see the configured goals.
Maven install, Maven clean etc

maven install goal will install all the necessary dependancies inside pom.xml and create the packaging file which is jar or war file.

In this project we haven't done anything.

In the next post I will show you haow to create a simple spring-hibernate project.

After we creating the project inside eclipse we can run the application even through command line, if you have installed Apache Maven in to you PC.

For that you have to open commandline and go to the project directory thorugh command line and execute the mvn commands such as mvn clean, mvn install, etc.

ex: %testapp> mvn install


Thursday, January 21, 2010

Installing Apache Maven and Configuring Eclipse with Maven


Installing Maven into your PC - Windows

Download Maven from here.MavenDownload
Unzip the file and put into Program files. So the Maven path would be C:\Program Files\apache-maven-2.2.1

Setting the Maven Environment Varable


Right click My Computer
Go to advanced tab
Click “Environment Variables” button
In the System variables click new button. Set the path to Maven directory and give M2_HOME as variable name as follows.

Click ok.
Now from the System Variable set select “Path” variable and click edit.
Add the ;% M2_HOME%/bin; at the end of path value as follows.

Click ok.
Verify the Installation
Open command line and type mvn command.

 

Installing Maven into your PC - Ubuntu

Unzip maven archive in to what ever location and set the path using one of below option.

Using Command permanent:

sudo ln -s /your/maven/location/bin/mvn /usr/bin/mvn

Option Two Temporary:

export M2_HOME=/your/maven/location/
export M2=%M2_HOME%\bin

Eclipse-Maven Configuration


Note that for Eclipse Update for Maven does not require Apache Maven to be installed to your PC.
--> 
First download eclipse 3.4.0 from here Latest Eclipse Download
-->

Then after the Eclipse installation update the Eclipse for m2Eclipse plug-in. Then you can work with maven inside Eclipse IDE.
-->
  • Run Eclipse
  • Go to Help
  • Software Updates


  •   Click Add Sites and in the opening window give the following URL. 

                                      http://m2eclipse.sonatype.org/update/
http://download.eclipse.org/technology/m2e/releases

  • Click Ok
  • Then Select Maven Integration for Eclipse Update Site from the site list and click install 

 

-->
After the successful update the eclipse will be asked for restart. Restart it. Now you can ensure the maven update by opening maven console.
-->
  • Go to Window icon from the menu bar
  • Select Show view
  • Select Console
-->

Eclipse console will be opened. In the console click “Open Console menu”. There you can see maven console selection. Select it. Console will change to maven console.


Wednesday, January 06, 2010

Thread Synchronization

When multiple threads are accessing a common method through their run methods, the output of that particular program is unpredictable, because while one thread is gone half way through the common method, another thread would gain the common method.

Similarly the common method execution result of multiple threads can have a variety and also may attack to the accuracy of the expected result.

If you need to let the common method accessible by one thread at one time you have to done it through synchronization.

Imagine you expect to increase the value of number in Thread A, and the value of number Thread B by one via calling the common method count().

Examine the following code and see the result by executing it.

class SynchDemo{
    int common=7;
    public static void main(String args[]){

        SynchDemo demo=new SynchDemo();

        A a =new A();
        a.active(demo);
        a.start();

        B b=new B();
        b.active(demo);
        b.start();

    }

    public int count(int x){
        common=x;
        try{
            Thread.sleep(1000);
        }catch(Exception ee){
        }
        return ++common;
    }
}

class A extends Thread{
    int number=5;
    SynchDemo demo;

    public void run(){
        System.out.println("Start Thread A\n");
        System.out.println("A before increase:"+number+"\n");
        System.out.println("A after increase by one:"+demo.count(number)+"\n");
    }

    public void active(SynchDemo demo){
        this.demo=demo;

    }

}

class B extends Thread{
    int number=10;
    SynchDemo demo;

    public void run(){
        System.out.println("Start Thread B\n");
        System.out.println("B before increase:"+number+"\n");
        System.out.println("B after increase by one:"+demo.count(number)+"\n");
    }

    public void active(SynchDemo demo){
        this.demo=demo;

    }

} 

The result can be,
The result of the program is wired, try multiple times.

Increased value of Thread A or Thread B becomes incorrect most of the time.

That's because another thread enters to the method and the value will be updated by that thread. So the previous thread gets the updated value to increase. Let's use Synchronization....

In Synchronization we can make a code mutually exclusive to multiple threads through a common object. When we add the key word 'synchronized' before the common method, the Thread which calls the method will put a lock to the object it uses to call the method.

Examine the following code and see the result.

class SynchDemo{
   
    int common=7;
   
    public static void main(String args[]){
       
        SynchDemo demo=new SynchDemo();
       
        A a =new A();
        a.active(demo);
        a.start();

        B b=new B();
        b.active(demo);
        b.start();

    }

    public synchronized int count(int x){
        common=x;
        try{
            Thread.sleep(1000);
        }catch(Exception ee){
        }
        return ++common;
    }
 }

class A extends Thread{
    int number=5;
    SynchDemo demo;

    public void run(){
        System.out.println("Start Thread A\n");
        System.out.println("A before increase:"+number+"\n");
        System.out.println("A after increase by one:"+demo.count(number)+"\n");
    }

    public void active(SynchDemo demo){
        this.demo=demo;

    }

}

class B extends Thread{
    int number=10;
    SynchDemo demo;

    public void run(){
        System.out.println("Start Thread B\n");
        System.out.println("B before increase:"+number+"\n");
        System.out.println("B after increase by one:"+demo.count(number)+"\n");
    }

    public void active(SynchDemo demo){
        this.demo=demo;

    }

}


The result is guranteed to increase the valuse of threads by one.



Here the common method is count(). The object used to call the method is ‘demo’. So the first thread which calls the method count(), gain the lock of the object 'demo'.

As next thread also need 'demo' object to call method count() it has to wait until First thread come out of the synchronized method and release the lock. Soon The next thread can gain the lock in 'demo' and execute count().

The most important thing is,
Both methods have used the same object to call the common method. Otherwise synchronizing the method won't help. Try using different objects.

Article Prepared by : +Lakmali Baminiwatta  Blog

Tuesday, January 05, 2010

Thread join() method

method-void join()
class-java.lang.Thread
non-static
throws Interrupted Exception

The method join can be used to make one thread joined into the end of another thread. This is a guranteed method.

Examine the following code and see the result.

class Demo{
    public static void main(String args[]){

        A a=new A();
        B b=new B();

        a.start();
        b.start();

        }
}

class A extends Thread{
    public void run(){

        System.out.println("Thread A started");
        System.out.println("Thread A running");
        System.out.println("Thread A ending");
    }
}


class B extends Thread{
    public void run() {

        System.out.println("Thread B started");
        System.out.println("Thread B running");
        System.out.println("Thread B ending");

    }
}

Result can not be guessed, as two threads execute separately.


Imagine you want to execute Thread-B after the complete execution of Thread-A. (First Thread A, then Thread B) I am goin to show two comman ways to do that.

Method (1)
  • You can call join method of Thread-A from the Thread-B.
  • But make sure a thread A need to started, before calling join method.
  • Then start the Thread B.
class Demo{
    public static void main(String args[]){


        B b=new B();

        b.starting();

        }
}

class A extends Thread{
    public void run(){

        System.out.println("Thread A started");
        System.out.println("Thread A running");
        System.out.println("Thread A ending");
    }

    public void starting(){
            this.start();

        }

}


class B extends Thread{
    public void run() {

        System.out.println("Thread B started");
        System.out.println("Thread B running");
        System.out.println("Thread B ending");

    }

    public void starting(){
            A a=new A();
            a.starting();
            try{
                a.join();
            }catch(InterruptedException e){

                }

            this.start();


        }
}


Result can be gurantedd to be as follows.


Method (2) Join thread-A to another third thread , which executes both A, B threads. Here, Demo class starts A and B threads. Which means main thrad of Demo class. So first start the Thread A. Then join main thread or the current into thread thread A. Start Thread B.

class Demo{
    public static void main(String args[]){

        A a=new A();
        a.start();

        try{
            a.join();// Joins the main thread of class Demo which is the current thread into Thread A.
                       //The rest of the code below this point will continue after terminating the Thread A.
        }catch(InterruptedException e){

            }

        System.out.println(a.isAlive());//Thread A is terminated and returns false here

        B b=new B();

        b.start();

        }
}

class A extends Thread{
    public void run(){

        System.out.println("Thread A started");
        System.out.println("Thread A running");
        System.out.println("Thread A ending");
    }


}


class B extends Thread{
    public void run() {

        System.out.println("Thread B started");
        System.out.println("Thread B running");
        System.out.println("Thread B ending");

    }


}
Result can be gurantedd to be as follows,.



One important thing to know is that when we call,
a.join();
The current executing thread is joined onto the end of the the thread represented by 'a'. So the rest of the code beyond this point will execute only after 'a' is teminated (Finished executing its run method).