springmvc、jpa（hibernate）、mybatis组合框架搭建（三）——加入JPA、单元测试

前情回顾

　　上回书说道，我们搭建起了基础的springmvc，可以通过mybatis进行数据库操作了。按理说吧，基本够用了。但是，对于实体对象操作，真心觉得hibernate更方便，不过，用它更新表就免了，不放心，但是，读取保存个对象啥的，方便得很呀。但是，hibernate毕竟只是个框架，所以，我们找来了jpa，用这个标准操作，虽然核心还是hibernate，目前别无他选。

引入依赖

<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-jpa -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.11.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-entitymanager -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>3.6.10.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.hibernate.javax.persistence/hibernate-jpa-2.0-api -->
<dependency>
<groupId>org.hibernate.javax.persistence</groupId>
<artifactId>hibernate-jpa-2.0-api</artifactId>
<version>1.0.1.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>3.6.10.Final</version>
</dependency>

　　 解释下，首先jpa，是由spring-data-jpa支持的，根据自己的spring版本选择对应的版本引入。然后可以在仓库的信息中看到hibernate-entitymanager和hibernate-jpa-2.0-api的依赖，其余的都是spring的依赖，引入后发现还依赖于hibernate-core，选择对应版本引入后，先这样。这是资料可以查到的最小依赖集合，后面缺，再补。

配置

　　加入spring-jpa.xml，然后把这个文件引入spring-context.xml中。spring-jpa.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"
xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
 http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd"
default-lazy-init="true">

<!-- JPA实体管理器工厂 -->
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" />
<!-- 加入定制化包路径 -->
<property name="packagesToScan" value="nature.demo" />

<property name="jpaProperties">
<props>
<prop key="hibernate.current_session_context_class">thread</prop>
<prop key="hibernate.hbm2ddl.auto">validate</prop><!-- validate/update/create -->
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>

<!-- 建表的命名规则 -->
<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>

</props>
</property>
</bean>

<!-- 设置JPA实现厂商的特定属性 -->
<bean id="hibernateJpaVendorAdapter"
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="databasePlatform" value="org.hibernate.dialect.MySQL5InnoDBDialect"/>
</bean>

<!-- Jpa 事务配置 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

<!-- Spring Data Jpa配置 -->
<jpa:repositories base-package="nature.demo"  transaction-manager-ref="transactionManager" entity-manager-factory-ref="entityManagerFactory"/>

<!-- 使用annotation定义事务 -->
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />
</beans>

　　说实话，这里的配置我也是从网上抄来的，然后删改了一部分。首先，datasource部分，我们重用了mybatis的配置，这里就没有重新来了，今天我们先把jpa引进来，后续还要观察mybatis和hibernate在同一事务下混合使用的表现。这里有基础的事务配置，我还没验证。后续我还会重新整理配置的结构，把datasource和transaction进行集中，否则很多东西扯不清楚，今天就先这样。

　　需要注意的是hibernate的hibernate.hbm2ddl.auto，我这里配的是validate，不太信得过它的自动更新，之后会后续跟进对应的创建数据库的方法，至于维护，就团队自己想办法吧。

　　注意配置包的范围，在这里坑了一小会儿。

编码

　　我们这里引入了JpaDemoDao,TestJpa,DemoJpaService三个类来完成本次的样例，很简单，我们就写一个实体，然后在service里用dao插进去。

实体类TestJpa

package nature.demo.entity.demo;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
import java.util.Date;

/**
* jpa的样例实体
* Created by nature on 17-8-6.
*/
@Entity
@Table(name="test_jpa")
public class TestJpa  implements Serializable{

private static final long serialVersionUID = -3421148517857545609L;

@Id
@Column(name="id")
private Long id;

@Column(name="name")
private String name;

@Column(name="createtime")
private Date createtime;

public Long getId() {
return id;
}

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

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Date getCreatetime() {
return createtime;
}

public void setCreatetime(Date createtime) {
this.createtime = createtime;
}
}

JpaDemoDao

package nature.demo.dao.jpademo;

import nature.demo.entity.demo.TestJpa;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
* Created by nature on 17-8-6.
*/
public interface JpaDemoDao extends JpaRepository<TestJpa,Long> {
}

DemoJpaService

package nature.demo.service.jpa;

import nature.demo.dao.jpademo.JpaDemoDao;
import nature.demo.entity.demo.TestJpa;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
* Created by nature on 17-8-6.
*/

@Service
public class DemoJpaService {

@Resource
private JpaDemoDao jpaDemoDao;

public void addRecord(TestJpa record){

jpaDemoDao.save(record);
}
}

至此，代码的编码就完结了。接下来我们进行测试。

测试

测试这事儿吧，我们这里使用的spring-test+junit，依赖如下：

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${version.spring}</version>
</dependency>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>

测试类是这样事儿的：

package nature.demo.service.jpa;

import nature.demo.entity.demo.TestJpa;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Date;

/**
* Created by nature on 17-8-6.
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value="classpath:spring/spring-context.xml")
public class DemoJpaServiceTest {
@Autowired
private DemoJpaService demoJpaService;

@Test
public void testAddRecord(){

TestJpa testJpa=new TestJpa();
testJpa.setId(1L);
testJpa.setName("test2");
testJpa.setCreatetime(new Date());
demoJpaService.addRecord(testJpa);
}
}

　　然后，你运行这个单元测试，他就会报错啦，原因呢，就是找不到servlet类，因为我们用tomcat启动的时候，它有，但是，我们自己做单元测试的时候没有，引入依赖：

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.0.1</version>
<scope>provided</scope>
</dependency>

　　好啦，打完收工。兄弟些，你成功了。