Spring 和 Jpa 整合过程

• Maven依赖准备

• Spring的主体依赖：spring-context,spring-beans,spring-core,spring-jdbc,
  spring-aop,spring-tx,spring-orm

• Hibernate的主体依赖：Hibernate-core,hibernate-entitymanager,hibernate-c3p0,c3p0（数据源）

• Hibernate缓存的主体依赖：ehcache-core,hibernate-ehcache

• Spring-data-Jpa 的主体依赖：spring-data-jpa

• Mysql的主体依赖：mysql-connector-java

• 日志记录的主体依赖：log4j,slf4j-log4j12

• 动态织入类：aspectjweaver

• 版本

• Spring主体依赖版本：4.2.5.RELEASE

• Hibernate的主体依赖版本：4.2.4.Final

• C3p0的主体依赖版本：0.9.2.1

• Hibernate缓存的主体依赖版本：2.4.3

• Spring-data-jpa的主体依赖版本：1.4.2.RELEASE

• Mysql的主体依赖版本：5.1.38

• Log4j的主体依赖版本：1.2.17

• slf4j-log4j12的主体依赖版本：1.7.5

• Aspectweaver的主体依赖版本：1.8.9

• Spring Data Jpa框架和Spring 框架的搭建

• 主要接口Repository
  Repository -> CurdRepository -> PagingAndSortingRepository -> JpaRepository

• 上述接口的实现类
  SimpleJpaRepository implements JpaRepository
  接口实现类，通过EntityManager这个类来实现对底层数据库的增删改查。

• 框架整合三种方式

• 第一种方式，整个Dao层全部使用Repository接口，具体实现由Spring Data Jpa中的SimpleJpaRepository类来实现。用户在编写Dao层时，只需要提供接口即可。

• 第二种方式，由于第一种方式中编写的Repository接口全部有Spring Data Jpa中的SimpleJpaRepository类来实现，例如要对UserInfoRepository接口自定义一些其他的方法。

• 第三种方法，第二种方式只是对某一个接口自定义一些其他的方法，第三种方式在为整个Repository接口自定义方法，在用户编写每一个接口时，只需要继承该自定义的接口即可，由spring data jpa和用户共同实现。

• 基于这三种方式的基本配置

<aop:aspectj-autoproxy proxy-target-class="true"/>
<!-- mysql 配置文件 -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:mysql.properties"></property>
</bean>
<!--dataSource-->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${mysql.driver}"></property>
        <property name="jdbcUrl" value="${mysql.url}"/>
        <property name="user" value="${mysql.username}"/>
        <property name="password" value="${mysql.password}"/>
</bean>
<!--entityManagerFactory-->
<bean name="entityManagerFactory" 
     class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>
        </property>
        <!--扫描 @Entity Domain类-->
        <property name="packagesToScan" value="com.data.domain"/>

        <property name="jpaPropertyMap">
            <props>
                <prop key="hibernate.dialect">
org.hibernate.dialect.MySQL5InnoDBDialect
</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.cache.use_second_level_cache">true</prop>
                <prop key="hibernate.cache.region.factory_class">
org.hibernate.cache.ehcache.EhCacheRegionFactory
            </prop>
                <prop key="hibernate.cache.use_query_cache">true</prop>
            </props>
        </property>
        <property name="sharedCacheMode" value="ENABLE_SELECTIVE"/>
</bean>
<!--transactionManager-->
<bean 
id="transactionManager" 
class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
<!--@Transactional-->
<tx:annotation-driven 
transaction-manager="transactionManager" proxy-target-class="true"/>

• 第一种实现方式

用户直接写Dao层接口，该接口要继承JpaRespository接口。那么Spring Data Jpa帮我们来实现这个Dao层的接口。具体的配置如下：

<jpa:repositories base-package="com.data.repository"
                      entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="transactionManager"/>

base-package 指明Dao层的接口，由Spring Data Jpa为这个包内的接口生成相应的实现类。
接口的编写如下：

public interface UserInfoDao extends JpaRepository<UserInfo,Integer>{}

第一种方式图解.png

• 第二种实现方式

由于第一种方式中，UserInfoDao继承了JpaRepostory<UserInfo,Integer> 接口，如果使用第一种方式，Spring Data Jpa实现了UserInfoDao接口，（实质上时候用SimpleJpaRepository类来实现）。那么我们只能使用JpaRepository接口中的方法，如果我们想要自定义方法，则使用第二种方式，为某一个Repository接口编写自定义的方法。

第二种方式图解.png 第二种方式图解.png

不同于第一种方式，则为我们的Dao层接口CropInfoRepository编写自定义的方法。应该这样实现，我们将自定义的方法封装到自定义的接口CropInfoCustomRepository中。同时，Dao层的CropInfoRepository接口同时继承两个接口JpaRepository和CropInfoCustomRepository接口。Spring Data Jpa 为CropInfoRepository接口生成实现类的代理类，使得这个接口既拥有一般的Spring Data Jpa的Repository中的curd方法，同时也拥有自定义的操作数据库的方法。注意：自定义接口的实现类的命名，需要为Dao层接口名+后缀名来实现，后缀名要在配置文件中进行配置。

<jpa:repositories base-package="com.data.repository"
                      entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="transactionManager"
                      repository-impl-postfix="Impl" />

• 第三种实现方式

第三种方式图解.png

JapRepository是一个全局的接口，我们要编写和domain相关的Repository接口，只要extends该接口（该接口中有最基本的curd方法），那么Spring Data Jpa会为这个domain相关的接口提供实现（实质由SimpleJpaRepository类实现最基本的curd功能）。第三种方式就是要编写一个类似JpaRepository接口，例如CustomJpaRepository接口，我们编写和domain相关的repository接口，只要我们继承这个CustomJpaRepository接口，即可。

第三种方式图解.png

在全局的接口CustomJpaRepository中，自定义方法，使得dao层的接口都继承这个接口，就如同在第一种方式中，所有的dao层接口来继承JpaRepository接口一样。编写这个全局接口需要：

public interface CustomJpaRepository extends JpaRepository

那么同样需要一个类来实现这个接口CustomJpaRepository，如同SimpleJpaRepository类实现了JpaRepository接口一样。

public class CustomJpaRepositoryImpl extends SimpleJpaRepository implements CustomJpaRepsotory

同时在编写某一个Domain对应的Dao接口时，需要继承这个目前成为全局的Repository接口。

@NoRepositoryBean
public interface CropInfoRepository extends CustomJpaRepository<CropInfo,Integer>

这就如同第一种传统的方式：

public interface CropInfoRepository extends JpaRepository<CropInfo,Integer>

但是这一切的前提是需要让Spring Data Jpa知道我们自定义了全局的接口。需要改写JpaRepositoryFactoryBean以及JpaRepositoryFactory。
同时，在配置文件中，需要进行如下的配置：

<jpa:repositories base-package="com.data.dao"
                      entity-manager-factory-ref="entityManagerFactory"
                      factory-class="com.data.dao.conf.CustomRepositoryFactoryBean"/>

同样需要指定base-package，使得spring data jpa该包下的dao层接口生成实现类。需要指定factory-class，需要让spring data jpa知道，开发者自定义了全局的Repository接口。
代码如下：

public class CustomRepositoryFactoryBean<T extends Repository<S, ID>, S, ID extends Serializable>   extends JpaRepositoryFactoryBean<T,S,ID> {
    @Override
    protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager)    {
        return new CustomRepositoryFactory(entityManager);
    }
}

class CustomRepositoryFactory extends JpaRepositoryFactory{
    public CustomRepositoryFactory(EntityManager entityManager){
        super(entityManager);
    }
    @Override
    protected <T, ID extends Serializable> JpaRepository<?, ?> getTargetRepository(
            RepositoryMetadata metadata, EntityManager entityManager) {
      CustomRepositoryImpl customRepository = new CustomRepositoryImpl<T,ID>((Class<T>)metadata.getDomainType(),entityManager);
      return customRepository;
    }

    @Override
    protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
        return CustomRepositoryImpl.class;
    }
}