Healthcare IT EMR PMS: MVVM CRUD with Spring 3.1 and Hibernate 4 and ZK

This is the first of a series of articles about Persistence with Spring and ZK as presentation layer.

Technologies Used

    1. ZK 6.5.1 CE Version
    3. Hibernate Core Version 4.1.9 Final
    4. Spring ORM Version 3.2.0
    5. MySQL version 5

Step 1:

If you are new ZK, then you can setup the Development environment by downloading this document.

Step 2:
MySQL Setup. Let us create the following table in MySQL. Let us create the following table and insert two records by default.

CREATE TABLE `addressbook` (
  `ID` bigint(20) NOT NULL auto_increment,
  `FullName` varchar(255) default NULL,
  `Address1` varchar(255) default NULL,
  `Address2` varchar(255) default NULL,
  `City` varchar(255) default NULL,
  `State` varchar(255) default NULL,
  `ZipCode` varchar(255) default NULL,
  `Email` varchar(255) default NULL,
  `Mobile` varchar(255) default NULL,
  PRIMARY KEY  (`ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Step 3:
Now let us create ZK Maven Project. By default POM File will point ZK 6.0.1 Version. we will change this to latest version 6.5.1 and also we will remove Commercial version of ZK from the POM File. we will include all the other dependency. You can copy the below POM.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>AddressBook</groupId>
	<artifactId>AddressBook</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<properties>
		<zk.version>6.5.1</zk.version>
		<commons-io>1.3.1</commons-io>
		<maven.build.timestamp.format>yyyy-MM-dd</maven.build.timestamp.format>
		<packname>-${project.version}-FL-${maven.build.timestamp}</packname>
		<spring.version>3.2.0.RELEASE</spring.version>
	</properties>
	<packaging>war</packaging>
	<name>The AddressBook Project</name>
	<description>The AddressBook Project</description>
	<licenses>
		<license>
			<name>GNU LESSER GENERAL PUBLIC LICENSE, Version 3</name>
			<url>http://www.gnu.org/licenses/lgpl.html</url>
			<distribution>repo</distribution>
		</license>
	</licenses>
	<repositories>
		<repository>
			<id>ZK CE</id>
			<name>ZK CE Repository</name>
			<url>http://mavensync.zkoss.org/maven2</url>
		</repository>
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>zkmaven</id>
			<name>ZK Maven Plugin Repository</name>
			<url>http://mavensync.zkoss.org/maven2/</url>
		</pluginRepository>
	</pluginRepositories>
	<dependencies>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zkbind</artifactId>
			<version>${zk.version}</version>
		</dependency>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zkplus</artifactId>
			<version>${zk.version}</version>
		</dependency>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zhtml</artifactId>
			<version>${zk.version}</version>
		</dependency>

		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>${commons-io}</version>
		</dependency>

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

		<dependency> <!-- Used for Hibernate4 LocalSessionFactoryBean -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- AOP dependency -->
		<dependency>
			<groupId>cglib</groupId>
			<artifactId>cglib</artifactId>
			<version>2.2.2</version>
		</dependency>

		<!-- Persistence Management -->
		<dependency> <!-- Apache BasicDataSource -->
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.2.2</version>
		</dependency>

		<dependency> <!-- MySQL database driver -->
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.20</version>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>4.1.10.Final</version>
		</dependency>


		<!-- ZK 5 breeze theme <dependency> <groupId>org.zkoss.theme</groupId> 
			<artifactId>breeze</artifactId> <version>${zk.version}</version> <optional>true</optional> 
			</dependency> -->
	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>
			<!-- Run with Jetty -->
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>maven-jetty-plugin</artifactId>
				<version>6.1.10</version>
				<configuration>
					<scanIntervalSeconds>5</scanIntervalSeconds>
					<stopKey>foo</stopKey>
					<stopPort>9999</stopPort>
				</configuration>
				<executions>
					<execution>
						<id>start-jetty</id>
						<phase>pre-integration-test</phase>
						<goals>
							<goal>run</goal>
						</goals>
						<configuration>
							<scanIntervalSeconds>0</scanIntervalSeconds>
							<daemon>true</daemon>
						</configuration>
					</execution>
					<execution>
						<id>stop-jetty</id>
						<phase>post-integration-test</phase>
						<goals>
							<goal>stop</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<!-- Compile java -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.3.2</version>
				<configuration>
					<source>1.5</source>
					<target>1.5</target>
				</configuration>
			</plugin>
			<!-- Build war -->
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<groupId>org.apache.maven.plugins</groupId>
				<version>2.1.1</version>
			</plugin>
			<!-- Pack zips -->
			<plugin>
				<artifactId>maven-assembly-plugin</artifactId>
				<version>2.2</version>
				<executions>
					<execution>
						<id>webapp</id>
						<phase>package</phase>
						<goals>
							<goal>single</goal>
						</goals>
						<configuration>
							<finalName>AddressBook${packname}</finalName>
							<appendAssemblyId>false</appendAssemblyId>
							<descriptors>
								<descriptor>assembly/webapp.xml</descriptor>
							</descriptors>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
</project>

Step 4:
Our Next step to update the web.xml with spring ContextListner and load our own configuration file as follows


	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
		            /WEB-INF/applicationContext.xml
         </param-value>
	</context-param>
	<!-- Loads the Spring web application context -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

Step 5:
Now let us create the applicationContext.xml file under WEB-INF Folder as follows

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd
           http://www.springframework.org/schema/tx
                   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/addressbook" />
		<property name="username" value="root" />
		<property name="password" value="1234" />
	</bean>


	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="packagesToScan" value="AddressBook.domain" />
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
				<prop key="hibernate.show_sql">true</prop>
			</props>
		</property>
	</bean>

	<bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<context:annotation-config />
	<context:component-scan base-package="AddressBook" />

	<tx:annotation-driven transaction-manager="transactionManager" />

	<!-- This will ensure that hibernate or jpa exceptions are automatically 
		translated into Spring's generic DataAccessException hierarchy for those 
		classes annotated with Repository -->

	<bean
		class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />

	<bean id="CRUDService" class=" AddressBook.service.CRUDServiceImpl" />

</beans>

Step 6:
Now let us create the domain object for addressbook in the package AddressBook.domain

package AddressBook.domain;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="addressbook")
public class AddressBook  implements Serializable {

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

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private long id;
	
	private String fullName;
	private String address1;
	private String address2;
	private String city;
	private String zipCode;
	private String state;
	private String email;
	private String mobile;

	public String getFullName() {
		return fullName;
	}

	public void setFullName(String fullName) {
		this.fullName = fullName;
	}

	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 getZipCode() {
		return zipCode;
	}

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

	public String getState() {
		return state;
	}

	public void setState(String state) {
		this.state = state;
	}

	public String getEmail() {
		return email;
	}

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

	public String getMobile() {
		return mobile;
	}

	public void setMobile(String mobile) {
		this.mobile = mobile;
	}

	public long getId() {
		return id;
	}

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

}

Step 7:
Now let us create server and DAO Layer as follows
CRUDDao.java

package AddressBook.dao;

import java.util.List;

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

CRUDDaoImpl.java

package AddressBook.dao;

import java.util.List;

import org.hibernate.Criteria;
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();
	}

}

CRUDService.java

package AddressBook.service;

import java.util.List;

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

CRUDServiceImpl.java

package AddressBook.service;

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

import AddressBook.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);
	}

}

Step 8:
Now let us create listing screen using ZK as follows. Create AddressList.zul in the folder Pages(create this folder) under webapp as shown

<?page title="Attorney List" contentType="text/html;charset=UTF-8"?>
<zk>
	<window id="addressList" title="Address List" border="none"
		apply="org.zkoss.bind.BindComposer"
		viewModel="@id('vm') @init('zkoss.vm.AddressListVM')">
		<separator />
		<listbox id="" mold="paging" pageSize="11" pagingPosition="top"
			selectedItem="@bind(vm.selectedItem)" model="@load(vm.dataSet)">
			<listhead sizable="true">
				<listheader label="Full Name" sortDirection="ascending"
					sort="auto(fullName)" />
				<listheader label="Email" sort="auto(email)" />
				<listheader label="Mobile" sort="auto(mobile)" />
			</listhead>
			<template name="model" var="p1">
				<listitem>
					<listcell label="@load(p1.fullName)" />
					<listcell label="@load(p1.email)" />
					<listcell label="@load(p1.mobile)" />
				</listitem>
			</template>
		</listbox>
	</window>
</zk>

Step 9:
Now let us create the View model for the above ZUL File.

package zkoss.vm;

import java.util.List;

import org.zkoss.bind.annotation.AfterCompose;
import org.zkoss.bind.annotation.ContextParam;
import org.zkoss.bind.annotation.ContextType;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.select.Selectors;
import org.zkoss.zk.ui.select.annotation.WireVariable;
import org.zkoss.zkplus.spring.SpringUtil;

import AddressBook.domain.AddressBook;
import AddressBook.service.CRUDService;

public class AddressListVM {

	@WireVariable
	private CRUDService CRUDService;

	private AddressBook selectedItem;
	private List<AddressBook> allReordsInDB = null;
	
	public AddressBook getSelectedItem() {
		return selectedItem;
	}

	public void setSelectedItem(AddressBook selectedItem) {
		this.selectedItem = selectedItem;
	}

	@AfterCompose
	public void initSetup(@ContextParam(ContextType.VIEW) Component view) {
		Selectors.wireComponents(view, this, false);
		CRUDService = (CRUDService) SpringUtil.getBean("CRUDService");
		allReordsInDB = CRUDService.getAll(AddressBook.class);
	}

	public List<AddressBook> getDataSet() {
		return allReordsInDB;
	}

}

Step 10
Now right click on AddressList.zul and Select Run as “Run on Server” to see the following output.

Project Structure

You can download the source here

Reference:
1. Spring with Hibernate persistence and transactions example
2. The Persistence Layer with Spring 3.2 and Hibernate 4.1
3. Persisting Object with Spring 3.1 and Hibernate 4
4. Spring 3 and Hibernate 4 for beginners

X12 EDI Examples

MVVM CRUD with Spring 3.1 and Hibernate 4 and ZK - Part 1

Technologies Used