Spring ORM示例– JPA，Hibernate，事务
欢迎使用Spring ORM示例教程。
今天，我们将研究使用Hibernate JPA事务管理的Spring ORM示例。
我将向您展示一个具有以下功能的Spring独立应用程序的非常简单的示例。
- 依赖注入(@Autowired注释)
- JPA EntityManager(由Hibernate提供)
- 带注释的事务方法(@Transactional注释)
Spring ORM示例
我已经在Spring ORM示例中使用了内存数据库，因此不需要任何数据库设置(但是您可以在spring.xml数据源部分中将其更改为任何其他数据库)。
这是一个Spring ORM独立应用程序，用于最小化所有依赖性(但是，如果您熟悉spring，可以通过配置轻松地将其更改为Web项目)。
注意：对于基于Spring AOP的Transactional(无@Transactional批注)方法解析方法，请检查此教程：Spring ORM AOP事务管理。
下图显示了我们最终的Spring ORM示例项目。
让我们一个接一个地介绍每个Spring ORM示例项目组件。
Spring ORM Maven依赖项
以下是具有Spring ORM依赖项的最终pom.xml文件。
我们在Spring ORM示例中使用了Spring 4和Hibernate 4。
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>hu.daniel.hari.learn.spring</groupId>
<artifactId>Tutorial-SpringORMwithTX</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<!-- Generic properties -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.7</java.version>
<!-- SPRING & HIBERNATE/JPA -->
<spring.version>4.0.0.RELEASE</spring.version>
<hibernate.version>4.1.9.Final</hibernate.version>
</properties>
<dependencies>
<!-- LOG -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- JPA Vendor -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<!-- IN MEMORY Database and JDBC Driver -->
<dependency>
<groupId>hsqldb</groupId>
<artifactId>hsqldb</artifactId>
<version>1.8.0.7</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
我们需要
spring-context和spring-orm作为Spring的依赖。我们为Hibernate使用
hibernate-entitymanager作为JPA实现。
" hibernate-entitymanager"依赖于" hibernate-core"，这就是为什么我们不必将hibernate-core显式放入pom.xml的原因。
通过Maven传递依赖项将其引入我们的项目。我们还需要JDBC驱动程序作为数据库访问的依赖项。
我们正在使用包含JDBC驱动程序和内存数据库的HSQLDB。
Spring ORM模型类
因为Hibernate提供了JPA实现，所以我们可以在模型bean中使用标准的JPA批注进行映射。
package hu.daniel.hari.learn.spring.orm.model;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Product {
@Id
private Integer id;
private String name;
public Product() {
}
public Product(Integer id, String name) {
this.id = id;
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Product [id=" + id + ", name=" + name + "]";
}
}
我们使用@Entity和JId @JPA批注将POJO限定为Entity并定义其主键。
SpringORM DAO班
我们创建了一个非常简单的DAO类，该类提供了persist和findALL方法。
package hu.daniel.hari.learn.spring.orm.dao;
import hu.daniel.hari.learn.spring.orm.model.Product;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.stereotype.Component;
@Component
public class ProductDao {
@PersistenceContext
private EntityManager em;
public void persist(Product product) {
em.persist(product);
}
public List<Product> findAll() {
return em.createQuery("SELECT p FROM Product p").getResultList();
}
}
@Component是Spring注释，它告诉Spring容器我们可以通过Spring IoC(依赖注入)使用此类。
我们使用JPA
@ PersistenceContext批注来指示对EntityManager的依赖项注入。
Spring根据spring.xml配置注入适当的EntityManager实例。
SpringORM服务类别
我们的简单服务类具有2个写入方法和1个读取方法-add，addAll和listAll。
package hu.daniel.hari.learn.spring.orm.service;
import hu.daniel.hari.learn.spring.orm.dao.ProductDao;
import hu.daniel.hari.learn.spring.orm.model.Product;
import java.util.Collection;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
@Component
public class ProductService {
@Autowired
private ProductDao productDao;
@Transactional
public void add(Product product) {
productDao.persist(product);
}
@Transactional
public void addAll(Collection<Product> products) {
for (Product product : products) {
productDao.persist(product);
}
}
@Transactional(readOnly = true)
public List<Product> listAll() {
return productDao.findAll();
}
}
我们使用Spring @Autowired批注将ProductDao注入我们的服务类中。
我们要使用事务管理，因此方法使用@ Transactional Spring注释进行注释。
listAll方法仅读取数据库，因此我们将@Transactional批注设置为只读以进行优化。
Spring ORM示例Bean配置XML
我们的Spring ORM示例项目Java类已经准备就绪，现在让我们看一下我们的spring bean配置文件。
spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
xmlns:p="https://www.springframework.org/schema/p"
xmlns:context="https://www.springframework.org/schema/context"
xmlns:tx="https://www.springframework.org/schema/tx"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
https://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans-3.0.xsd
https://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context-3.0.xsd
https://www.springframework.org/schema/tx
https://www.springframework.org/schema/tx/spring-tx.xsd
">
<!-- Scans the classpath for annotated components that will be auto-registered as Spring beans -->
<context:component-scan base-package="hu.daniel.hari.learn.spring"
<!-- Activates various annotations to be detected in bean classes e.g: @Autowired -->
<context:annotation-config
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="org.hsqldb.jdbcDriver"
<property name="url" value="jdbc:hsqldb:mem://productDb"
<property name="username" value="sa"
<property name="password" value=""
</bean>
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
p:packagesToScan="hu.daniel.hari.learn.spring.orm.model"
p:dataSource-ref="dataSource"
>
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="generateDdl" value="true"
<property name="showSql" value="true"
</bean>
</property>
</bean>
<!-- Transactions -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"
</bean>
<!-- enable the configuration of transactional behavior based on annotations -->
<tx:annotation-driven transaction-manager="transactionManager"
</beans>
首先，我们告诉spring我们要对Spring组件(服务，DAO)使用类路径扫描，而不是在spring xml中一个接一个地定义它们。
我们还启用了Spring注释检测。添加数据源，即当前的HSQLDB内存数据库。
我们设置了一个JPA
EntityManagerFactory，应用程序将使用它来获取EntityManager。
Spring支持3种不同的实现方式，我们使用LocalContainerEntityManagerFactoryBean来实现完整的JPA功能。
我们将LocalContainerEntityManagerFactoryBean属性设置为：packagesToScan属性，该属性指向模型类包。Spring配置文件中先前定义的数据源。
将jpaVendorAdapter设置为Hibernate，并设置一些hibernate属性。
我们将Spring PlatformTransactionManager实例创建为JpaTransactionManager。
该事务管理器适用于使用单个JPA EntityManagerFactory进行事务数据访问的应用程序。我们启用基于注释的事务行为配置，并设置我们创建的transactionManager。
Spring ORM Hibernate JPA示例测试程序
我们的SpringORM JPA Hibernate示例项目已经准备就绪，因此让我们为我们的应用程序编写一个测试程序。
public class SpringOrmMain {
public static void main(String[] args) {
//Create Spring application context
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:/spring.xml");
//Get service from context. (service's dependency (ProductDAO) is autowired in ProductService)
ProductService productService = ctx.getBean(ProductService.class);
//Do some data operation
productService.add(new Product(1, "Bulb"));
productService.add(new Product(2, "Dijone mustard"));
System.out.println("listAll: " + productService.listAll());
//Test transaction rollback (duplicated key)
try {
productService.addAll(Arrays.asList(new Product(3, "Book"), new Product(4, "Soap"), new Product(1, "Computer")));
} catch (DataAccessException dataAccessException) {
}
//Test element list after rollback
System.out.println("listAll: " + productService.listAll());
ctx.close();
}
}
您可以看到我们可以很容易地从main方法启动Spring容器。
我们正在获取第一个依赖注入的入口点，即服务类实例。
在Spring 上下文初始化之后，将" ProductDao"类引用注入到" ProductService"类。
获得ProducService实例后，我们可以测试其方法，由于Spring的代理机制，所有方法调用都将是事务性的。
在此示例中，我们还将测试回滚。
如果您在spring ORM示例测试程序之上运行，则将获得以下日志。
Hibernate: insert into Product (name, id) values (?, ?) Hibernate: insert into Product (name, id) values (?, ?) Hibernate: select product0_.id as id0_, product0_.name as name0_ from Product product0_ listAll: [Product [id=1, name=Bulb], Product [id=2, name=Dijone mustard]] Hibernate: insert into Product (name, id) values (?, ?) Hibernate: insert into Product (name, id) values (?, ?) Hibernate: insert into Product (name, id) values (?, ?) Hibernate: select product0_.id as id0_, product0_.name as name0_ from Product product0_ listAll: [Product [id=1, name=Bulb], Product [id=2, name=Dijone mustard]]
请注意，第二笔交易已回滚，这就是产品列表未更改的原因。
如果您使用附件中的" log4j.properties"文件，则可以查看引擎盖下发生的情况。
