Spring学习(十）

需要的jar包

1、Spring核心必须依赖的库：commons-logging-1.1.1.jar
2、Spring IoC部分核心库：

• spring-beans-4.3.9.RELEASE.jar
• spring-context-4.3.9.RELEASE.jar
• spring-context-support-4.3.9.RELEASE.jar
• spring-core-4.3.9.RELEASE.jar
• spring-expression-4.3.9.RELEASE.jar
• spring-web-4.3.9.RELEASE.jar      ------> 支持在Web环境中使用Spring IoC容器

3、Spring AOP部分核心库：

• spring-aop-4.3.9.RELEASE.jar
• spring-aspects-4.3.9.RELEASE.jar

4、Spring AOP需要依赖于aspectj库:

• aspectjrt.jar
• aspectjweaver.jar

5、Spring JDBC部分核心库：

• spring-jdbc-4.3.9.RELEASE.jar
• spring-tx-4.3.9.RELEASE.jar

6、Spring ORM部分核心库：

• spring-orm-4.3.9.RELEASE.jar

7、若配置的是c3p0数据源还需要：

• c3p0-0.9.5.2.jar
• hibernate-c3p0-5.2.10.Final.jar
• mchange-commons-java-0.2.11.jar

8、Hibernate部分核心库：

• antlr-2.7.7.jar
• classmate-1.3.0.jar
• dom4j-1.6.1.jar
• hibernate-commons-annotations-5.0.1.Final.jar
• hibernate-core-5.2.10.Final.jar
• hibernate-jpa-2.1-api-1.0.0.Final.jar
• jandex-2.0.3.Final.jar
• javassist-3.20.0-GA.jar
• jboss-logging-3.3.0.Final.jar
• jboss-transaction-api_1.2_spec-1.0.1.Final.jar

9、Ehcache部分核心库：

• ehcache-2.10.3.jar
• hibernate-ehcache-5.2.10.Final.jar
• slf4j-api-1.7.7.jar

10、数据库对应的驱动包：mysql-connector-java-5.1.40-bin.jar

Spring整合Hibernate

1、使用Spring依赖注入和AOP简化Hibernate应用，由IOC 容器来管理 Hibernate 的 SessionFactory，让 Hibernate 使用上 Spring 的声明式事务

2、整合步骤

• 引用jar包
• 创建数据库和表
  

  DROP TABLE IF EXISTS t_customer ;
  
  CREATE TABLE t_customer (
      id  INT(5) PRIMARY KEY ,
      email  VARCHAR(60)  UNIQUE NOT NULL,
      password VARCHAR(32) NOT NULL ,
      nickname VARCHAR(150) ,
      gender VARCHAR(3) ,
      birthdate DATE ,
      married     CHAR(1)
  );

  
• 创建类创建类

  Customer类

  

  package ecut.hibernate.entity;
  
  import java.util.Date;
  
  public class Customer {
  
      private Integer id;
      private String email;
      private String password;
      private String nickname;
      private char gender;
      private Date birthdate;
      private boolean married;
  
      public Integer getId() {
          return id;
      }
  
      public void setId(Integer id) {
          this.id = id;
      }
  
      public String getEmail() {
          return email;
      }
  
      public void setEmail(String email) {
          this.email = email;
      }
  
      public String getPassword() {
          return password;
      }
  
      public void setPassword(String password) {
          this.password = password;
      }
  
      public String getNickname() {
          return nickname;
      }
  
      public void setNickname(String nickname) {
          this.nickname = nickname;
      }
  
      public char getGender() {
          return gender;
      }
  
      public void setGender(char gender) {
          this.gender = gender;
      }
  
      public Date getBirthdate() {
          return birthdate;
      }
  
      public void setBirthdate(Date birthdate) {
          this.birthdate = birthdate;
      }
  
      public boolean isMarried() {
          return married;
      }
  
      public void setMarried(boolean married) {
          this.married = married;
      }
  
  }

  

  CustomerController类

  package ecut.hibernate.controller;
  
  import java.util.List;
  
  import ecut.hibernate.entity.Customer;
  import ecut.hibernate.service.CustomerService;
  
  public class CustomerController {
  
      private CustomerService customerService ;
  
      public String regist( Customer c ){
          System.out.println(  "CustomerController # regist ." );
          customerService.save( c );
          return "success" ;
      }
  
      public List<Customer> allCustomer(){
          return customerService.findAll();
      }
  
      public CustomerService getCustomerService() {
          return customerService;
      }
  
      public void setCustomerService(CustomerService customerService) {
          this.customerService = customerService;
      }
  
  }

  CustomerService类

  package ecut.hibernate.service;
  
  import java.util.List;
  
  import ecut.hibernate.dao.CustomerDao;
  import ecut.hibernate.entity.Customer;
  
  public class CustomerService {
  
      private CustomerDao customerDao ;
  
      public boolean save( Customer c ) {
          System.out.println( "CustomerService # save ." );
          return customerDao.persist( c );
      }
  
      public List<Customer> findAll(){
          return customerDao.loadAll() ;
      }
  
      public CustomerDao getCustomerDao() {
          return customerDao;
      }
  
      public void setCustomerDao(CustomerDao customerDao) {
          this.customerDao = customerDao;
      }
  
  }

  Spring配置文件

  <?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:aop="http://www.springframework.org/schema/aop"
      xmlns:p="http://www.springframework.org/schema/p"
      xmlns:tx="http://www.springframework.org/schema/tx"
      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
          http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
  
      <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
          <property name="driverClassName" value="com.mysql.jdbc.Driver" />
          <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf8" />
          <property name="username" value="root" />
          <property name="password" value="123456" />
      </bean>
  
      <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" >
          <!-- 注入数据源，用来获得数据库连接 -->
          <property name="dataSource" ref="dataSource" />
          <!-- 注入 hibernate 的配置 ( 方言、二级缓存 、查询缓存) -->
          <property name="hibernateProperties">
              <props>
                  <!-- 指示数据库的基本信息 -->
                  <!--
                  <prop key="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</prop>
                  <prop key="hibernate.connection.url" >jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=UTF8</prop>
                  <prop key="hibernate.connection.username" >root</prop>
                  <prop key="hibernate.connection.password" >123456</prop>
                  -->
                  <!-- 启用二级缓存 -->
                  <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
                  <!-- 启用查询缓存 -->
                  <prop key="hibernate.cache.use_query_cache" >true</prop>
                  <!-- 指定数据方言 类-->
                  <prop key="hibernate.dialect" >org.hibernate.dialect.MySQLDialect</prop>
                  <!-- 指示是否显示sql -->
                  <prop key="hibernate.show_sql" >true</prop>
                  <!-- 指示是否对sql格式化输出 -->
                  <prop key="hibernate.format_sql" >true</prop>
              </props>
          </property>
  
          <!-- 引入映射文件 -->
          <!-- mappingResources 对应的是 String 数组，不支持 使用 通配符 ，下面的写法是错误的 -->
          <!-- <property name="mappingResources" value="classpath:ecut/hibernate/entity/*.hbm.xml" /> -->
          <!-- mappingLocations 对应的 是 Resource 数组 ，因此 支持 使用 通配符 -->
          <property name="mappingLocations" value="classpath:ecut/hibernate/entity/*.hbm.xml"></property>
  
      </bean>
  
      <!-- 配置平台事务管理器 ，由HibernateTransactionManager类来完成事务管理-->
      <bean id="platformTransactionManager"
               class="org.springframework.orm.hibernate5.HibernateTransactionManager">
          <property name="sessionFactory" ref="sessionFactory" />
      </bean>
  
      <!-- 提供对事务的配置 ( Advice ) -->
      <tx:advice id="transactionAdvice" transaction-manager="platformTransactionManager">
          <tx:attributes>
              <tx:method name="persist*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="false" />
              <tx:method name="save*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="false" />
              <tx:method name="update*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="false" />
              <tx:method name="delete*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="false" />
              <tx:method name="remove*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="false" />
  
              <tx:method name="load*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
              <tx:method name="get*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
              <tx:method name="find*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
              <tx:method name="query*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
          </tx:attributes>
      </tx:advice>
  
      <!-- aop实现事务控制：使用 aop:config 实现将 Advice 织入到 相应的 连接点中 -->
      <aop:config>
          <aop:pointcut  id="tx-pointcut" expression="execution(* ecut.hibernate.service.*.*(..))"/>
          <!-- 声明事务控制 切面 -->
          <aop:advisor pointcut-ref="tx-pointcut" advice-ref="transactionAdvice"/>
      </aop:config>
      <!-- hibernate所有操作都是通过sessionFactory实现的 -->
      <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
          <property name="sessionFactory" ref="sessionFactory" />
      </bean>
  
      <bean id="customerDao" class="ecut.hibernate.dao.CustomerDao" >
          <property name="hibernateTemplate" ref="hibernateTemplate" />
      </bean>
  
      <bean id="customerService" class="ecut.hibernate.service.CustomerService" >
          <property name="customerDao" ref="customerDao" />
      </bean>
  
      <bean id="customerController" class="ecut.hibernate.controller.CustomerController" >
          <property name="customerService" ref="customerService" />
      </bean>
  
  </beans>

  在spring配置文件中，配置平台事务管理器 ，由HibernateTransactionManager类来完成事务管理，并引用sessionFactory。在sessionFactory中注入 hibernate 的配置 ( 方言、二级缓存 、查询缓存)和数据源，以及引入映射文件，需要注意的是引入配置文件时mappingLocations 对应的 是 Resource 数组 ，因此 支持 使用 通配符，但是mappingResources 对应的是 String 数组，不支持使用通配符。最终通过AOP来实现事务的控制。controller中添加了CustomerService的对象，因此需要将CustomerService以ref的方式引入到controller中。service中添加了CustomerDao的对象，因此需要将CustomerDao以ref的方式引入到service中。dao中添加了jdbcTemplate的对象，因此需要将jdbcTemplate以ref的方式引入到dao中。而Template依赖与DataSource，以ref的方式为JdbcTemplate注入引用。DataSource的属性可以通过注入数据库的一些配置属性添加。

  Hibernate配置文件

  <?xml version="1.0" encoding="UTF-8"?>
  
  <!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
      "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  
  <hibernate-mapping>
  
      <!-- 指定 那个类 ( name 指定类名 ) 对应 那个表 ( table 指定表名 ) -->
      <class name="ecut.hibernate.entity.Customer" table="t_customer">
  
          <!-- 对于 与 数据库主键 对应的 对象标识符属性 来说，要单独使用 id 标签来映射 -->
          <id name="id" type="integer" column="id" >
              <generator class="increment" /> <!-- 由 hibernate 提供的 对象标识符 生成策略 -->
          </id>
  
          <!-- 指定 那个属性 ( name 指定属性名 )  对应 那个列 ( column 属性指定 列名 ) -->
          <property name="email" type="string" column="email" />
          <!-- 使用 type 属性指定 映射类型 ( 既不是 Java 类型，也不是 数据库类型，而是 中间类型 ( 媒婆 ) ) -->
          <property name="password" type="string" column="password" />
          <property name="nickname" type="string" column="nickname" />
          <!-- Java 中的 char 类型在 hibernate 中对应的映射类型是 character -->
          <property name="gender" type="character" column="gender" />
          <property name="birthdate" type="date"  column="birthdate" />
          <!-- Java 中的 boolean  类型在 hibernate 中对应的映射类型可以是 true_false 、yes_no  -->
          <property name="married" type="yes_no" column="married" />
  
      </class>
  
  </hibernate-mapping>

  CustomerDao类

  package ecut.hibernate.dao;
  
  import java.io.Serializable;
  import java.util.List;
  
  import ecut.hibernate.entity.Customer;
  import org.springframework.orm.hibernate5.HibernateTemplate;
  
  public class CustomerDao {
  
      private HibernateTemplate hibernateTemplate;
  
      public boolean persist( Customer c ) {
          try{
              //没有提交事务所以需要增加事务的配置
              Serializable id = hibernateTemplate.save( c );
              return id != null ;
          } catch ( Exception e) {
              e.printStackTrace();
              return false ;
          }
      }
  
      public boolean update( Customer c ) {
          try{
              hibernateTemplate.update( c );
              return true ;
          } catch ( Exception e) {
              return false ;
          }
      }
  
      public boolean delete( Customer c ) {
          try{
              hibernateTemplate.delete( c );
              return true ;
          } catch ( Exception e) {
              return false ;
          }
      }
  
      public Customer load( Integer id  ) {
          return hibernateTemplate.get( Customer.class , id ) ;
      }
      //@SuppressWarnings抑制编译器警告
      @SuppressWarnings("unchecked")
      public List<Customer> loadAll() {
          final String HQL = "FROM Customer";
          List<Customer> list = (List<Customer>)hibernateTemplate.find( HQL );
          return list ;
      }
  
      public HibernateTemplate getHibernateTemplate() {
          return hibernateTemplate;
      }
  
      public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
          this.hibernateTemplate = hibernateTemplate;
      }
  
  }

  测试类

  package ecut.hibernate;
  
  import java.util.Date;
  import java.util.List;
  
  import org.junit.AfterClass;
  import org.junit.BeforeClass;
  import org.junit.Test;
  import ecut.hibernate.controller.CustomerController;
  import ecut.hibernate.entity.Customer;
  import org.springframework.context.support.AbstractApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  public class TestCustomerController {
  
      private static AbstractApplicationContext container ;
  
      public @BeforeClass static void init(){
          String configLocations = "classpath:ecut/**/hibernate/beans.xml";
          container = new ClassPathXmlApplicationContext( configLocations );
      }
  
      public @Test void testRegist(){
  
          Customer c = new Customer();
  
          c.setEmail( "lao@ecut.edu.cn" );
          c.setPassword( "hello2017" );
  
          Date birthdate = new Date() ;
          c.setBirthdate( birthdate );
          c.setGender( '男' );
  
          c.setNickname( "老王" );
          c.setMarried( false );
  
          CustomerController cc = container.getBean( "customerController" , CustomerController.class );
  
          cc.regist( c );
  
      }
  
      public @Test void all(){
  
          CustomerController cc = container.getBean( "customerController" , CustomerController.class );
  
          List<Customer> list = cc.allCustomer();
  
          for( Customer c : list ){
              System.out.println( c.getEmail() + " : " + c.getNickname() );
          }
  
      }
  
      public @AfterClass static void destory(){
          container.close();
      }
  
  }

  通过整合，使数据库的操作得到了简化，Spring的IoC容器则提供了更好的管理方式，它不仅能以声明式的方式配置Session- Factory实例，也可充分利用IoC容器的作用，为SessionFactory注入数据源引用。

转载请于明显处标明出处：

https://www.cnblogs.com/AmyZheng/p/9281813.html