简单的Spring JPA实现例子

1. 使用maven创建一个jpa的测试工程

mvn archetype:create -DgroupId=myjpa -DartifactId=myjpa

 

2. 添加jpa所依赖的包，这里使用的hibernate的jpa实现，并且使用hsql数据库作为测试数据库

	<build>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.5</source>
					<target>1.5</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
	<dependencies>
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.4</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.5.8</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-jdk14</artifactId>
			<version>1.5.8</version>
		</dependency>
		
		<dependency>
			<groupId>hsqldb</groupId>
			<artifactId>hsqldb</artifactId>
			<version>1.8.0.7</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring</artifactId>
			<version>2.5</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>3.3.1.GA</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-annotations</artifactId>
			<version>3.3.1.GA</version>
		</dependency>
		<dependency>
			<groupId>hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>3.4.0.GA</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.3.1</version>
			<scope>test</scope>
		</dependency>
	<dependencies>

 

3. 创建两个model类

Customer.java

package myjpa.model;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
@Entity
public class Customer implements Serializable {
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.TABLE)
	private int id;
	private String name;
	private String email;
	@Temporal(TemporalType.DATE)
	private Date birthday;
	@OneToMany(mappedBy = "customer")
	private final List<Address> addresses = new ArrayList<Address>();
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	public List<Address> getAddresses() {
		return addresses;
	}
	public void addAddress(Address address) {
		this.addresses.add(address);
		address.setCustomer(this);
	}
	@Override
	public String toString() {
		return org.apache.commons.lang.builder.ToStringBuilder.reflectionToString(this);
	}
}

 

Address.java

package myjpa.model;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
@Entity
public class Address implements Serializable {
	private static final long serialVersionUID = 1L;
	@Id
	@GeneratedValue(strategy = GenerationType.TABLE)
	private int id;
	private String name;
	private String description;
	private String zipcode;
	@ManyToOne
	private Customer customer;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getDescription() {
		return description;
	}
	public void setDescription(String description) {
		this.description = description;
	}
	public String getZipcode() {
		return zipcode;
	}
	public void setZipcode(String zipcode) {
		this.zipcode = zipcode;
	}
	public Customer getCustomer() {
		return customer;
	}
	public void setCustomer(Customer customer) {
		this.customer = customer;
	}
	@Override
	public String toString() {
		return org.apache.commons.lang.builder.ToStringBuilder.reflectionToString(this);
	}
}

 

4. 创建DAO接口和实现类，这里为了简单，省去了异常处理的代码

CustomerDAO接口如下

package myjpa.dao;
import java.util.List;
import myjpa.model.Customer;
public interface CustomerDAO {
	
	Customer findById(int id);
	
	Customer add(Customer customer);
	
	List<Customer> list();
}

 

CustomerDAOJPAImpl实现类如下：

package myjpa.dao;
import java.util.List;
import org.springframework.orm.jpa.support.JpaDaoSupport;
import myjpa.model.Customer;
public class CustomerDAOJPAImpl extends JpaDaoSupport implements CustomerDAO {
	
	public Customer findById(int id) {
		return getJpaTemplate().find(Customer.class, id);
	}
	
	public Customer add(Customer customer) {
		getJpaTemplate().persist(customer);
		return getJpaTemplate().find(Customer.class, customer.getId());
	}
	@SuppressWarnings("unchecked")
	public List<Customer> list() {
		List<Customer> customers = getJpaTemplate().find("select c from Customer c");
		return customers;
	}
}

 

 

5. 配置persistence.xml文件

....................................................................

	<?xml version="1.0" encoding="UTF-8"?>
	<persistence version="1.0"
		xmlns="http://java.sun.com/xml/ns/persistence"
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
		<persistence-unit name="spring" transaction-type="RESOURCE_LOCAL">
			<class>myjpa.model.Customer</class>
			<class>myjpa.model.Address</class>
		</persistence-unit>
	</persistence>

 

注意：这里只有实体类的配置，所有关于数据库的配置都放到了spring的配置文件里统一处理。

 

6. 配置spring文件

在工程的src/main/resources目录下创建spring.xml文件，内容如下：

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd">
		<bean id="customerDAOTarget" class="myjpa.dao.CustomerDAOJPAImpl">
			<property name="entityManagerFactory" ref="entityManagerFactory" />
		</bean>
		<bean id="customerDAO"
			class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
			<property name="transactionManager" ref="transactionManager" />
			<property name="target" ref="customerDAOTarget" />
			<property name="transactionAttributes">
				<props>
					<prop key="save*">PROPAGATION_REQUIRED</prop>
					<prop key="del*">PROPAGATION_REQUIRED</prop>
					<prop key="update*">PROPAGATION_REQUIRED</prop>
					<prop key="create*">PROPAGATION_REQUIRED</prop>
					<prop key="add*">PROPAGATION_REQUIRED</prop>
					<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
					<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
					<prop key="*">PROPAGATION_REQUIRED</prop>
				</props>
			</property>
		</bean>
		<bean id="entityManagerFactory"
			class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
			<property name="persistenceUnitName" value="spring" />
			<property name="dataSource" ref="dataSource" />
			<property name="jpaVendorAdapter">
				<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
					<property name="showSql" value="false" />
					<property name="generateDdl" value="true" />
					<property name="databasePlatform" value="org.hibernate.dialect.HSQLDialect" />
				</bean>
			</property>
			<property name="loadTimeWeaver">
				<bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver" />
			</property>
		</bean>
		<bean id="dataSource"
			class="org.springframework.jdbc.datasource.DriverManagerDataSource">
			<property name="driverClassName" value="org.hsqldb.jdbcDriver" />
			<property name="url" value="jdbc:hsqldb:mem:." />
			<property name="username" value="sa" />
			<property name="password" value="" />
		</bean>
		<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
			<property name="entityManagerFactory" ref="entityManagerFactory" />
			<property name="dataSource" ref="dataSource" />
		</bean>
	</beans>

 

 

7. 编写测试类，这里简单起见就没有再引入别的数据库测试包，而是使用的CustomerDAO自己的添加和查询方法测试自己，通常情况应该是使用第三方的JDBC测试工具来做这些测试。在src/test/java目录下创建测试类CustomerDAOJPAImplTest

package myjpa.dao;
import java.util.Calendar;
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import myjpa.model.Address;
import myjpa.model.Customer;
public class CustomerDAOJPAImplTest {
	private static CustomerDAO customerDAO;
	
	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("/spring.xml");
		customerDAO = (CustomerDAO)ctx.getBean("customerDAO");
		
		for (int i = 0; i < 10; i++) {
			Customer customer = new Customer();
			customer.setName("customer_" + i);
			customer.setEmail("customer_" + i + "@my.com");
			customer.setBirthday(Calendar.getInstance().getTime());
			
			Address addressHome = new Address();
			addressHome.setName("Home");
			addressHome.setDescription("Home");
			addressHome.setZipcode("123456");
			
			Address addressOffice = new Address();
			addressOffice.setName("Office");
			addressOffice.setDescription("Office");
			addressOffice.setZipcode("654321");
			
			customer.addAddress(addressHome);
			customer.addAddress(addressOffice);
			customerDAO.add(customer);
		}
	}
	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}
	@Before
	public void setUp() throws Exception {
		
	}
	@After
	public void tearDown() throws Exception {
	}
	@Test
	public void testFindById() {
		List<Customer> customers = customerDAO.list();
		for (Customer customer : customers) {
			Customer anotherCustomer = customerDAO.findById(customer.getId());
			Assert.assertNotNull(anotherCustomer);
			Assert.assertEquals(customer.getId(), anotherCustomer.getId());
			Assert.assertEquals(customer.getName(), anotherCustomer.getName());
		}
	}
	
	@Test
	public void testAdd() {
		Customer customer = new Customer();
		customer.setName("customer_abc");
		customer.setEmail("customer_abc" + "@my.com");
		customer.setBirthday(Calendar.getInstance().getTime());
		
		Address addressHome = new Address();
		addressHome.setName("Home");
		addressHome.setDescription("Home");
		addressHome.setZipcode("123456");
		
		Address addressOffice = new Address();
		addressOffice.setName("Office");
		addressOffice.setDescription("Office");
		addressOffice.setZipcode("654321");
		
		customer.addAddress(addressHome);
		customer.addAddress(addressOffice);
		Customer persistedCustomer = customerDAO.add(customer);
		
		Assert.assertNotNull(customer);
		Assert.assertEquals(customer.getName(), persistedCustomer.getName());
	}
	@Test
	public void testList() {
		List<Customer> customers = customerDAO.list();
		Assert.assertEquals(true, customers.size() > 0);
	}
}

 

 

8. 运行测试类，JPA会自动创建所要使用的数据库和表，然后就会执行相应的添加和查询操作，并使用断言来验证测试的正确性。

 

 

 

 

 

 

来源：http://www.verydemo.com/demo_c143_i21056.html