Step 1: Mysql employee Table Creation.
This is the employee table structure.
CREATE TABLE `employee` ( `ID` BIGINT(20) NOT NULL AUTO_INCREMENT, `ADDRESS` VARCHAR(255) NOT NULL, `CONTACT_NUMBER` VARCHAR(30) NOT NULL, `NAME` VARCHAR(20) NOT NULL, PRIMARY KEY (`ID`), UNIQUE KEY `ID` (`ID`) )ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1
Now create a Maven web project using eclipse or NetBeans.
Step 2: Pom.xml file configuration
4.0.0 com.sasika.pos Pos_server 1.0-SNAPSHOT war Pos_server http://maven.apache.org 3.2.1.RELEASE 3.1.2.RELEASE org.springframework spring-web ${org.springframework.version} org.springframework spring-webmvc ${org.springframework.version} org.springframework spring-context ${org.springframework.version} org.springframework spring-orm ${org.springframework.version} org.springframework spring-test ${org.springframework.version} org.springframework spring-jdbc ${org.springframework.version} org.apache.cxf cxf-api 2.6.0 compile org.apache.cxf cxf-rt-frontend-jaxws 2.6.0 compile org.apache.cxf cxf-rt-transports-http 2.6.0 compile javax.servlet javax.servlet-api 3.0.1 org.hibernate hibernate-core 4.1.12.Final org.hibernate hibernate-validator 4.2.0.Final junit junit 4.8.2 mysql mysql-connector-java 5.1.9 javax.servlet jstl 1.2 org.apache.maven.plugins maven-compiler-plugin 2.3.2 1.5 1.5 org.apache.maven.plugins maven-war-plugin 2.1.1 false
Some of dependencies
not need for this application (like Apache CXF for webservices), but I will put
it because this demonstration will be continue.
Step 3:
Hibernate annotation class for data model
we have to define Employee.java class and annotate it to data model.
package com.sasika.pos.entity;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
@Entity
@Table(name = "employee", catalog = "erp_pos")
public class Employee implements java.io.Serializable {
private Long id;
private String address;
private String name;
private String contactNumber;
public Employee() {
}
@Id
@GeneratedValue(strategy = IDENTITY)
@Column(name = "ID", unique = true, nullable = false)
public Long getId() {
return this.id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "ADDRESS", nullable = false)
public String getAddress() {
return this.address;
}
public void setAddress(String address) {
this.address = address;
}
@Column(name = "NAME", nullable = false, length = 20)
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "CONTACT_NUMBER", nullable = false, length = 30)
public String getContactNumber() {
return this.contactNumber;
}
public void setContactNumber(String contactNumber) {
this.contactNumber = contactNumber;
}
}
Step 4:
Generic Dao for data access
We can use generic DAO class for common methods such as save, update, delete, findAll.. which are required in every DAO class. We will create Genericdao and GenericDaoimpl for common methods.
public interface GenericDao <e extends serializable > {
List <e> findAll();
E findById(Long id);
void saveOrUpdate(E e);
void delete(E e);
List <e> findByCriteria(Criterion criterion);
}
package com.sasika.pos.generic.dao;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Criterion;
import org.springframework.beans.factory.annotation.Autowired;
import java.io.Serializable;
import java.util.List;
public abstract class GenericDaoImpl <e extends serializable > implements GenericDao <e> {
private Class<e> entityClass;
protected GenericDaoImpl(Class<e> entityClass) {
this.entityClass = entityClass;
}
@Autowired
private SessionFactory sessionFactory;
public Session getCurrentSession() {
return sessionFactory.getCurrentSession();
}
@Override
public List<e> findAll() {
return (List<e>) getCurrentSession().createQuery("from " + entityClass.getSimpleName()).list();
}
@Override
public E findById(Long id) {
return (E) getCurrentSession().get(entityClass, id);
}
@Override
public void saveOrUpdate(E e) {
getCurrentSession().saveOrUpdate(e);
}
@Override
public void delete(E e) {
getCurrentSession().delete(e);
}
@Override
public List<e> findByCriteria(Criterion criterion) {
Criteria criteria = getCurrentSession().createCriteria(entityClass);
criteria.add(criterion);
return criteria.list();
}
}
Step 5:Bo and Dao Implementation
Employee data access object
A Employee DAO interface and
implementation, the dao implementation class extends Generic Dao implementation class
package com.sasika.pos.employee.dao;
import com.sasika.pos.entity.Employee;
import com.sasika.pos.generic.dao.GenericDao;
public interface EmployeeDao extends GenericDao<employee<{
}
package com.sasika.pos.employee.dao;
import com.sasika.pos.entity.Employee;
import com.sasika.pos.generic.dao.GenericDaoImpl;
import org.springframework.stereotype.Repository;
@Repository
public class EmployeeDaoImpl extends GenericDaoImpl<employee> implements EmployeeDao{
public EmployeeDaoImpl() {
super(Employee.class);
}
}
There is a @Repository annotation and it Indicates DAO component in the persistence layer.
Employee Business Object(Bo)
Employee business object (BO) interface and implementation, it’s used to handle the project’s business function.
package com.sasika.pos.employee.bo;
import com.sasika.pos.entity.Employee;
import java.util.List;
public interface EmployeeBo {
public String saveOrUpdateEmployee(Employee employee);
public List<employee> findAllEmployee();
public void deleteEmployee(Employee employee);
}
package com.sasika.pos.employee.bo;
import com.sasika.pos.employee.dao.EmployeeDao;
import com.sasika.pos.entity.Employee;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class EmployeeBoImpl implements EmployeeBo {
@Autowired
private EmployeeDao employeeDao;
@Transactional
public String saveOrUpdateEmployee(Employee employee) {
try {
if (employee.getId() == 0) {
employee.setId(null);
}
employeeDao.saveOrUpdate(employee);
} catch (Exception e) {
return "Error";
}
return "success";
}
public List<employee> findAllEmployee() {
return employeeDao.findAll();
}
@Transactional
public void deleteEmployee(Employee employee) {
employeeDao.delete(employee);
}
}
There is a @ Service annotation and it Indicates a Service component in the business layer.
Step 6: 5. Resource Configuration
hibernateContext.Xml configuration
Create a HibernateContext file for Data source, transaction and hibernate session factory beans, put it under “resources/config/spring” folder
<property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/erp_pos"/> <property name="username" value="username"/> <property name="password" value="password"/> <property name="dataSource" ref="dataSource"/> <property name="packagesToScan" value="com.sasika.pos.entity"/> org.hibernate.dialect.MySQLDialect update <property name="sessionFactory" ref="sessionFactory"/>
Application Context file configuration
<context:component-scan base-package="com.sasika.pos"/> <tx:annotation-driven transaction-manager="transactionManager"/> <import resource="classes/config/spring/hibernateContext.xml"/>
Transaction will be handle by using annotation.
Web xml Configuration
org.springframework.web.context.ContextLoaderListener 30
Now all the configurations finished. We can test this application using Junit.I will show how to test this using junit in next post.
I will show you how to integrate this project with apache CXF web service in my next few post as well.
