spring逐步整合orm实例--第四例：整合hibernate。

   之前的三个例子，分别使用spring整合或者使用别人整合的产品进行了演示。  这篇继续，整合，或者说使用整合的hibernate来进行数据库操作。

   与spring-jdbc类似，hibernate作为一个出名的orm映射框架，spring官方早将它列为了其它逻辑产品之一的spring-orm中。  因此我们直接使用spring-orm就行了，但是要自己整合估计也是可以的，只不过这大概就是那些架构师所作的事情吧。

   whatever，还是继续例子。

  这个时候的依赖：

<?xml version="1.0" encoding="UTF-8"?>
<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>com.automannn.springZhenghe</groupId>
    <artifactId>spirngZhenhe</artifactId>
    <version>1.0-SNAPSHOT</version>


    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.1.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.4.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.1.1.RELEASE</version>
        </dependency>

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

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.12</version>
        </dependency>
    </dependencies>
</project>

   关于依赖文件需要说明：

         一，spring-orm提供的是一套完整的orm映射框架，所以它不具体针对某一个数据库映射产品的实现。  因此它本身并不包含hibernate或者其它实现的依赖，所以我们自己导入了hibernate的包。  

         二，由于在实践的途中，hibernate的事务总是提示我无法增加在只读环境下做数据插入操作，因此花了不少力气，发现网上基本上都是通过声明式事务处理的，也就用到了切片，所以这里导入aspectweaver的依赖。（这个问题还可以通过过滤器解决，不过那是真多web环境，虽然这里也是可以实现，如监听它的上下文完成事件之后跑一下过滤器，应该也可以吧哈哈，至少逻辑上可以通过）。

   嗯嗯，继续看它的使用：

package com.automannn.springZhenhe.dao;

import com.automannn.springZhenhe.entity.Person;
import org.hibernate.FlushMode;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;

import java.sql.SQLException;

/**
 * @author 
 * @time 2018/10/16 13:53
 */
public class MyHibernatePersonDao extends HibernateDaoSupport {
    //父类非继承 核心方法:
    //setSessionFactory(SessionFactory)
    //getSessionFactory()
    //setHibernateTemplate(HibernateTemplate)
    //getHibernateTemplate()

    public void executeAdd(Person person) throws SQLException {
        getHibernateTemplate().save(person);
    }

}

   可以看到它的使用与jdbc的模板是极其类似的，都是提供操作模板的方式。

 它的配置文件：（因为这里涉及与Hibernate的集成，所以会使用hibernate是先觉条件，这里还包括了hibernate本身常规使用的一些配置，只是列出来就不一一说明了）。

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--
        引入properties配置文件
     -->

    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <value>classpath:jdbc.properties</value>
        </property>
    </bean>

    <bean id="dataSource" destroy-method="close" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    <!-- 配置Hibernate的SessionFactory -->
    <bean id="factory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" >
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
        <property name="mappingResources" value="mapping/Person.hbm.xml"></property>
    </bean>

    <!-- 配置spring的声明性事务 -->
    <bean class="org.springframework.orm.hibernate5.HibernateTransactionManager" id="transactionManager">
        <property name="sessionFactory" ref="factory"></property>
    </bean>
    <bean id="myHibernatePersonDao" class="com.automannn.springZhenhe.dao.MyHibernatePersonDao">
        <property name="sessionFactory" ref="factory"></property>
    </bean>

    <!-- 配置事务属性 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="execute*" isolation="READ_COMMITTED"/>
            <tx:method name="query*" isolation="READ_COMMITTED"/>
        </tx:attributes>
    </tx:advice>
    <!-- 配置事务切入点 -->
    <aop:config>
        <aop:pointcut expression="execution(* com.automannn.springZhenhe.dao.*.*(..))" id="pointCut"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut"/>
    </aop:config>
</beans>

   但是为了我日后方便回顾，还是提一下，这里配的关键是：LocalcalSessionFactoryBean，由orm提供。也就是spring官方提供的。  它实际提供的是一个sessionFactory。  因为有了这个sessionFactory，orm就可以创建一个模板HibernateTemplate。  而集成的关键也在于这个模板。

   当然，还包括hibernate本身所要求的一些配置：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="show_sql">true</property>
        <!--
            <mapping resource="com/automannn/zhenHe/mapping/Person.hbm.xml"/>
         -->
    </session-factory>
</hibernate-configuration>

package com.automannn.springZhenhe.entity;

/**
 * @author 
 */
public class Person {
    private Integer pid;

    private String pName;

    public Person() {
    }

    public Integer getPid() {
        return pid;
    }

    public void setPid(Integer pid) {
        this.pid = pid;
    }

    public String getpName() {
        return pName;
    }

    public void setpName(String pName) {
        this.pName = pName;
    }
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.automannn.springZhenhe.entity">
    <!-- 指明类和表的对应关系 table：表名 name：类名 -->
    <class table="person" name="Person">
        <!-- 配置我们的映射关系 -->
        <!-- 主键映射关系 -->
        <id name="pid" column="pid">
        </id>
        <!-- 配置非主键属性 -->
        <property name="pName" column="pname"></property>
    </class>
</hibernate-mapping>

它的入口测试类：

package com.automannn.springZhenhe;

import com.automannn.springZhenhe.dao.*;
import com.automannn.springZhenhe.entity.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author
 * @time 2018/10/16 11:31
 */
public class App {

    public static void main(String[] args) throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
        Person person = new Person();
        person.setPid(10);
        person.setpName("ee");
        MyHibernatePersonDao myHibernatePersonDao= (MyHibernatePersonDao) context.getBean("myHibernatePersonDao");
        myHibernatePersonDao.executeAdd(person);

    }
}

运行：

 最后总结一下：  hibernate的集成是基于模板模式的。