Tuesday, 26 March 2013

ZK MVVM Form Binding CRUD with Spring and Hibernate - Part 2

Create domain object and create DAO/Service layer.

        


In the Previous Part 1, we created our project using Maven. Now we will see how to add our middle tier layers.
Step 1:
First the Delete Package named “ZKBeanValidation ” which is created by default.
Now Select “Java” folder and right click, Select New –> Other-> Package and enter the Package name as “zkexample.domain” as shown.
image
Now select the domain package and right click, Select New –> Other->Class and Enter the class name as UserProfile as shown here.
image
UserProfile.java Code.

package zkexample.domain;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@Table(name="userprofile")
public class UserProfile implements Serializable {

/**
*
*/
private static final long serialVersionUID = 1L;

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private long id;

private String firstName;
private String lastName;
private String middleName;
private String userAccountNumber;
private String SSN;
private String address1;
private String address2;
private String city;
private String State;
private String zipCode;
private String email;
private String userLoginID;
private String password;

@Temporal(TemporalType.DATE)
private Date DOB;
public long getId() {
return id;
}

public void setId(long id) {
this.id = id;
}

public String getFirstName() {
return firstName;
}

public void setFirstName(String firstName) {
this.firstName = firstName;
}

public String getLastName() {
return lastName;
}

public void setLastName(String lastName) {
this.lastName = lastName;
}

public String getMiddleName() {
return middleName;
}

public void setMiddleName(String middleName) {
this.middleName = middleName;
}

public String getUserAccountNumber() {
return userAccountNumber;
}

public void setUserAccountNumber(String userAccountNumber) {
this.userAccountNumber = userAccountNumber;
}


public Date getDOB() {
return DOB;
}

public void setDOB(Date dOB) {
DOB = dOB;
}

public String getSSN() {
return SSN;
}

public void setSSN(String sSN) {
SSN = sSN;
}

public String getAddress1() {
return address1;
}

public void setAddress1(String address1) {
this.address1 = address1;
}

public String getAddress2() {
return address2;
}

public void setAddress2(String address2) {
this.address2 = address2;
}

public String getCity() {
return city;
}

public void setCity(String city) {
this.city = city;
}

public String getState() {
return State;
}

public void setState(String state) {
State = state;
}

public String getZipCode() {
return zipCode;
}

public void setZipCode(String zipCode) {
this.zipCode = zipCode;
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

public String getUserLoginID() {
return userLoginID;
}

public void setUserLoginID(String userLoginID) {
this.userLoginID = userLoginID;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

}

Step 2:
Next we will create our DAO Layer.
Select the java folder and right click, Select New –> Other->Package and enter the package name as zkxample.dao. After package is created, select the package dao and right click, select New-> Other->Interface and enter the interface name as “CRUDDao”
image
image


package zkexample.dao;

import java.util.List;

public interface CRUDDao {
<T> List<T> getAll(Class<T> klass);

<T> void Save(T klass);

<T> void delete(T klass);
}


Now let us create the DAO Class which implement the above interface. Select the package dao and right click, select New-> Other->class  and enter the class name as "CRUDDaoImpl” as shown
image
image



package zkexample.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class CRUDDaoImpl implements CRUDDao {

@Autowired
SessionFactory sessionFactory;

@SuppressWarnings("unchecked")
public <T> List<T> getAll(Class<T> klass) {
return getCurrentSession().createQuery("from " + klass.getName())
.list();
}

protected final Session getCurrentSession() {
return sessionFactory.getCurrentSession();
}

public <T> void Save(T klass) {
getCurrentSession().save(klass);
}

public <T> void delete(T klass) {
getCurrentSession().delete(klass);

}

}

Hibernate 3 provides a feature called "contextual Sessions", where Hibernate itself manages one current Session per transaction. This is roughly equivalent to Spring's synchronization of one Hibernate Session per transaction.The main advantage of this DAO style is that it depends on Hibernate API only; no import of any Spring class is required.

For more information, Please refer the following links
1. The Persistence Layer with Spring 3.1 and Hibernate
2. Spring Integration with Hibernate
3. Implementing DAOs based on plain Hibernate 3 API

Step 3:
Now let us create our service layer.
Select the zkxample package, and right click, select New-> Other->Interface and enter the interface name as “CRUDService”


package zkexample.service;

import java.util.List;

public interface CRUDService {
<T> List<T> getAll(Class<T> klass);

<T> void Save(T klass);

<T> void delete(T klass);
}

Now let us create the Service Class which implement the above interface. Select the package service and right click, select New-> Other->class and enter the class name as "CRUDServiceImpl” as shown
image


package zkexample.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import zkexample.dao.CRUDDao;

@Service
public class CRUDServiceImpl implements CRUDService {

@Autowired
private CRUDDao CRUDDao;

@Transactional(readOnly = true)
public <T> List<T> getAll(Class<T> klass) {
return CRUDDao.getAll(klass);
}

@Transactional
public <T> void Save(T klass) {
CRUDDao.Save(klass);
}

@Transactional
public <T> void delete(T klass) {
CRUDDao.delete(klass);
}

}



In the next part 3, we will see how we can integrate Spring with Hibernate.



        

2 comments:

  1. Nice tutorial,
    but forgive me if I am asking stupid question.
    what is < T > mean for?

    ReplyDelete
  2. Thanks for this tutorial, i have an error about @Servicepublic annotation with the error message "Servicepublic cannot be resolved to a type". Any ideas please ?

    ReplyDelete