Spring小结

作者: 唯黑 | 来源:发表于2018-02-01 14:43 被阅读0次

Spring生命周期以及Aop的执行时机总结
Spring小结
Spring小结
Spring小结
在传统Spring应用中使用spring-boot-actuat
某Java项目一期完成后的小结
180531-Spring中JavaConfig知识小结
Spring 事务
jpa初级用法
JAVA 异常控制

1、IOC 容器

1、概念

IOC为Inversion of control，控制反转，意思是现在需要对象，自己不创建，交给外部的容器创建
IOC容器= bean.xml配置 + ApplicationContext容器类

2、简单使用

引入jar

commons-logging-1.1.3.jar       【单独下载】
spring-beans-3.2.5.RELEASE.jar        【spring源码, bean节点管理】
spring-context-3.2.5.RELEASE.jar      【spring上下文类】
spring-core-3.2.5.RELEASE.jar         【IOC容器】
spring-expression-3.2.5.RELEASE.jar    【spring表达式】

新建applicationContext.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:p="http://www.springframework.org/schema/p"
  xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="
  http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd">

</beans>

配置

<bean id="userAction " class="xxxx.UserAction ">
</bean>

获取

// 容器对象(加载applicationContext.xml配置文件)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
// 获取对象
UserAction userAction = (UserAction) ac.getBean("userAction");
userAction.execute();

3、配置细节

细节1

id 不能以数字开头，不能含有特殊符号, 不能有空格、逗号等， id 不能重复
name 可以以数字开头，可以有特殊符合，如果name值重复，编译没有问题但运行报错
<bean id="user" name="user2,user3 user4" class="xxxx.User"></bean>
<bean name="user5" class="xxxx.User"></bean>
<bean id="user6" class="xxxx.User"></bean>
<bean id="user6" class="xxxx.User"></bean>

细节2

 <!-- 
      scope="singleton"   默认表示单例！
             prototype    多例
      init-method=""      在创建完对象之后执行初始化方法
      destroy-method=""   在调用容器类的destroy()方法时候，对单例的对象有效！
      lazy-init="true"    延迟初始化 / 这个属性的设置只对单例有影响，对多例没有任何影响！
                          单例的对象默认是在创建容器的时候就创建所有单例的对象，如果希望在第一次访问的时候创建单例的对象，就设置延迟初始化
      Bean生命周期：
         bean在xml中配置，
            singleton  单例
              1) 创建对象
                   如果有配置延迟初始化，
                      lazy-init=true  如果单例的对象有配置延迟初始化， 在创建容器之后，在第一次从容器获取对象的时候
                                   创建单例的对象！
                  如果没有配置或延迟初始化为默认值, 单例的对象会在创建容器的时候创建对象
              2) 执行初始化方法 , init-method配置的方法会执行
              3) 调用容器destroy() 方法时候，容器在销毁单例对象的实例的时候，会调用destroy-method对应的方法
                 此时bean对象会被销毁！
            
            prototype  多例
               1) 每次在从容器获取对象的时候，都会创建新的对象
               2) 每次创建完对象后，就执行初始化方法
               3) java回回收不用资源(jvm gc)     
   -->
  <bean id="user" 
      class="xxxx.User" 
      init-method="init" 
      destroy-method="destroy_" 
      lazy-init="false" 
      scope="prototype"></bean>

4、创建对象的几种方式

构造赋值

<!-- 创建user对象，且赋值 -->
<!-- 
  value 当直接给属性值的时候使用value赋值
  ref   当引用的是IOC容器中的对象的时候，使用ref    
 -->
<bean id="user" class="xxxx.User">
  <constructor-arg index="0" type="int" value="10000"></constructor-arg>
  <constructor-arg index="1" type="String" ref="str"></constructor-arg>
</bean>

set赋值

<!--IOC容器， 给对象属性赋值 -->
<bean id="user" class="xxxx.User">
  <property name="id" value="1000"></property>
  <property name="name" value="Jacky"></property>
  <!-- list集合赋值 -->
  <property name="list">
      <list>
          <value>cn</value>
          <value>usa</value>
      </list>
  </property>
  <!-- map 集合赋值 -->
  <property name="map">
      <map>
          <entry key="cn" value="China"></entry>
          <entry key="usa" value="1234"></entry>
      </map>
  </property>
  <!-- Properties对象赋值 -->
  <property name="prop">
      <props>
          <prop key="cn">China</prop>
          <prop key="usa">America</prop>
      </props>
  </property>
</bean>

工厂创建对象

 <!-- 
    class 指定工厂的类型；  
    factory-method: 工厂类的静态方法
-->
 <bean id="user1" class="xxxx.UserFactory" factory-method="getStaticInstance"></bean>

   <!-- * 非静态方法创建对象 -->
  <!-- 先创建工厂实例 -->
 <bean id="factory" class="xxxx.UserFactory"></bean>
 <bean id="user" factory-bean="factory" factory-method="getInstance"></bean>

p名称空间

<bean id="str" class="java.lang.String">
 <constructor-arg value="Jacky"></constructor-arg>
</bean>
<bean id="user" class="xxxx.User" p:id="1000" p:name-ref="str"></bean>

自动装配

<?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:p="http://www.springframework.org/schema/p"
      xmlns:context="http://www.springframework.org/schema/context"
      xsi:schemaLocation="
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context.xsd" 
          default-autowire="byType">
      
      <!-- 配置： 需要创建的对象、对象依赖关系处理 -->
      
      <!-- 方式4：自动装配 (了解) -->
      <!-- 
          a. default-autowire="byType"  配置到全局
              当前所有的bean都采用”根据类型自动装配“
          b. 配置到bean节点
              autowire="byName"  根据名称自动装配， 会去容器找指定名称的对象，注入到set方法的参数中！
              autowire="byType"  根据类型自动装配, 要确保改类型对应的对象在IOC容器中唯一，否则报错！
              
          总结：
              简化配置，但是维护麻烦！
       -->
      <bean id="userDao" class="xxx.UserDao"></bean>
      <bean id="userService" class="xxx.UserService"></bean>
      <bean id="userAction" class="xxx.UserAction"></bean>

  </beans>

注解

<!-- 1. 开启注解扫描 -->
<context:component-scan base-package="xxxx"></context:component-scan>

  // 把userDao对象加入IOC容器
  //@Component("userdao")  // <bean id=userDao class="...">
  //@Repository("userdao")  // <bean id=userDao class="...">

  @Repository   // 默认名称是类名，且第一个字母小写
  public class UserDao implements IUserDao {
      // 模拟：保存对象
      public void save() {
          System.out.println("UserDao.save()");
      }
  }
//@Component("userService")  // 把当前类加入IOC容器
  //@Service("userService")  // 把当前类加入IOC容器
  @Service
  public class UserService implements IUserService {
      
      //@Resource(name = "userDao")   // 根据”userDao“去ioc容器找对象，找到后注入到当前方法参数
      
      @Resource       // 默认会根据private IUserDao userDao 这里的名称去容器找； 如果没有找到，再根据类型找，再没有找到就报错！
      private IUserDao userDao;

      public void save() {
          userDao.save();
      }
  }


  //@Component("userAction")  // 加入IOC容器
  //@Controller("userAction")  // 加入IOC容器
  @Scope("prototype")       // 指定加入ioc容器的对象为多例

  @Controller
  public class UserAction {
      
  //  @Resource(name = "userService")  // ioc容器找名称是userService的对象并注入
      
      @Resource
      private IUserService userService;
      
      public String execute(){
          userService.save();
          return "success";
      }
  }

2、Spring与Struts2整合

1、关键

把action的创建，交给spring的ioc容器

2、引入jar

struts2-spring-plugin-2.3.4.1.jar 【struts源码】
spring-web-3.2.5.RELEASE.jar 【spring源码】

3、配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <!-- struts2配置 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- Spring配置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/classes/bean*.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>


    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

3、Aop编程

1、概念

Aop编程：关注点代码与业务代码分离(jdk/cglib代理)
关注点：重复执行的代码, 也叫关注点代码
切面：关注点代码形成的类，就叫做切面

2、步骤

引入jar

aopalliance.jar               【spring-framework-2.5.6\lib\aopalliance】
aspectjrt.jar                【spring-framework-2.5.6\lib\aspectj】
aspectjweaver.jar             【spring-framework-2.5.6\lib\aspectj】
spring-aop-3.2.5.RELEASE.jar     【Spring3.2源码】

引入aop名称空间和开启aop注解

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:context="http://www.springframework.org/schema/context"
  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/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd">

  <!-- 开启注解扫描 -->
  <context:component-scan base-package="xxxx"></context:component-scan>
  <!-- 开启aop注解 -->
  <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

使用Aop相关注解

  // 重复代码
  @Component("aop")
  @Aspect      // 指定一个类为切面类
  public class TransactionAop {
      
      // 定义一个切入点表达式变量  （后面使用这个切入点表达式的时候，直接引用方法名即可）
      @Pointcut("execution(* xxxx.UserDao.*(..))")
      public void pointcut_(){
      }

      //【前置通知】
      // 在执行业务方法，之前执行
      @Before("pointcut_()")
      public void beginTransaction() {
          System.out.println("[前置通知]  开启事务..");
      }
      
      //【后置通知】
      // 在执行业务方法，之后执行
      @After("pointcut_()")
      public void commit() {
          System.out.println("[后置通知] 提交事务..");
      }
      
      // 【返回后通知】   在执行目标方法结束后执行, 出现异常不会执行
      @AfterReturning("pointcut_()")
      public void afterReturing(){
          System.out.println("[返回后通知]");
      }
      
      // 【异常通知】   在执行目标方法的时候出现异常执行
      @AfterThrowing("pointcut_()")
      public void afterThrowing(){
          System.out.println("[异常通知]");
      }
      
      // 【环绕通知】 会环绕目标方法执行
      @Around("pointcut_()")
      public void arroud(ProceedingJoinPoint pjp) throws Throwable{
          System.out.println("[环绕前：]");
          pjp.proceed();                 // 执行目标方法
          System.out.println("[环绕后：]");
      }

  }

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:context="http://www.springframework.org/schema/context"
      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/context
          http://www.springframework.org/schema/context/spring-context.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop.xsd">
      
      <!-- dao实例加入容器 -->
      <bean id="userDao" class="xxxxx.UserDao"></bean>
      
      <!-- 实例化切面类 -->
      <bean id="aop" class="xxxx.TransactionAop"></bean>
      
      <!-- Aop相关配置 -->
      <aop:config>
          <!-- 切入点表达式定义 -->
          <aop:pointcut expression="execution(* xxxx.UserDao.*(..))" id="pt"/>
          
          <!-- 切面配置 -->
          <aop:aspect ref="aop">
          
              <!-- 【环绕通知】 -->
              <aop:around method="arroud" pointcut-ref="pt"/>
          
              <!-- 【前置通知】 在目标方法之前执行 -->
              <aop:before method="beginTransaction" pointcut-ref="pt" />
              
              <!-- 【后置通知】 -->
              <aop:after method="commit" pointcut-ref="pt"/>
              
              <!-- 【返回后通知】 -->
              <aop:after-returning method="afterReturing" pointcut-ref="pt"/>
              
              <!-- 异常通知 -->
              <aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
              
              
          </aop:aspect>
      </aop:config>
      
  </beans>

3、切入点表达式语法详解

切入点表达式：拦截指定的类，生成代理对象

表达式

 execution(
  modifiers-pattern?                  拦截的方法的访问修饰符
  ret-type-pattern                   方法返回类型，必须指定
  declaring-type-pattern?             拦截的方法所在的类
  name-pattern(param-pattern)       拦截的方法（以及方法的参数列表）
  throws-pattern?)                  方法声明的异常

  <!-- 切入点表达式定义 -->
  
  <!-- 1. 拦截指定的方法(通用)  -->
  <!--<aop:pointcut expression="execution(* xxxx.UserDao.save(..))" id="pt"/>-->
  
  <!-- 2. 拦截指定的类下所有的方法 -->
  <!--<aop:pointcut expression="execution(* xxxx.UserDao.*(..))" id="pt"/>-->
  
  <!-- 3. 拦截指定包下所有的类的所有方法 -->
  <!--<aop:pointcut expression="execution(* xxxx.*.*(..))" id="pt"/>-->
  
  <!-- 3. 拦截指定包，以及其子包下所有类的所有方法 -->
  <!--<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>-->
  
  <!-- 5. 拦截所有的public方法 -->
  <!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->
  
  <!-- 6. 拦截所有的包含save方法 -->
  <!--<aop:pointcut expression="execution(* *save*(..))" id="pt"/>-->
  
  <!-- 7. 拦截UserDao.save()方法与OrderDao.save() -->
  <!--<aop:pointcut expression="execution(* cn..UserDao.save(..)) || execution(* cn..OrderDao.save(..))" id="pt"/>-->
  <!--<aop:pointcut expression="execution(* cn..UserDao.save(..)) or execution(* cn..OrderDao.save(..))" id="pt"/>-->
  
  <!-- 8. 不拦截UserDao.save()方法 -->
  <!--<aop:pointcut expression="!execution(* cn..UserDao.save(..))" id="pt"/>-->
  <!--<aop:pointcut expression=" not execution(* cn..UserDao.save(..))" id="pt"/>-->
  
  <!-- 9. 拦截UserDao.save()同时拦截OrderDao.save() -->
  <!-- 注意： 这种很少用，一般都是或者的关系即: || 、 or  -->
  <!--<aop:pointcut expression="execution(* cn..UserDao.save(..)) and execution(* cn..OrderDao.save(..))" id="pt"/>-->
  <aop:pointcut expression="execution(* cn..UserDao.save(..)) &amp;&amp; execution(* cn..OrderDao.save(..))" id="pt"/>

4、Spring对jdbc模块的支持

1、配置

db.properties

driverClass=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql:///hib_demo
user=root
password=root
initialPoolSize=3
maxPoolSize=6
acquireIncrement=2

applicationContext

<?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:context="http://www.springframework.org/schema/context"
      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/context
          http://www.springframework.org/schema/context/spring-context.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop.xsd">
      
      <!-- 加载Proerties配置文件 -->
      <context:property-placeholder location="classpath:xxxx/db.properties"/>
      
      <!-- 1.  实例化连接池  -->
      <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
          <property name="driverClass" value="${driverClass}"></property>
          <property name="jdbcUrl" value="${jdbcUrl}"></property>
          <property name="user" value="${user}"></property>
          <property name="password" value="${password}"></property>
          <property name="initialPoolSize" value="${initialPoolSize}"></property>
          <property name="maxPoolSize" value="${maxPoolSize}"></property>
          <property name="acquireIncrement" value="${acquireIncrement}"></property>
      </bean>
      
      <!--  2. 创建JdbcTemplate对象 -->
      <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
          <property name="dataSource" ref="dataSource"></property>
      </bean>
      
      <!-- 实例化dao -->
      <bean id="deptDao" class="xxxx.DeptDao">
          <property name="jdbcTemplate" ref="jdbcTemplate"></property>
      </bean>
      
  </beans>

JdbcTemplate Api

public class DeptDao implements IDeptDao {
      
      // 接收容器注入的JdbcTemplate对象
      private JdbcTemplate jdbcTemplate;
      public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
          this.jdbcTemplate = jdbcTemplate;
      }
      

      // 1. 原始jdbc代码
      public void save(Dept dept) {
          jdbcTemplate.update("insert into t_dept(deptName) values(?)", dept.getName());
      }


      @Override
      public void delete(Serializable id) {
          jdbcTemplate.update("delete from t_dept where id=?", id);
      }
      
      @Override
      public void update(Dept dept) {
          jdbcTemplate.update("update t_dept set deptName=? where id=?", dept.getName(),dept.getId());
      }


      @Override
      public Dept findById(Serializable id) {
          // queryForList 把每一行都封装为map对象，再添加到list中
  //      List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from t_dept");
          
          // 传入类型参数，表示查询的列的类型；  这里只能查询一列
  //      List<String> list = jdbcTemplate.queryForList("select deptName from t_dept", String.class);

           List<Dept> list = jdbcTemplate.query("select * from t_dept where id=?",  new MyRowMapper(), id);
          
          return (list!=null&&list.size()>0)?list.get(0):null;
      }


      @Override
      public List<Dept> getAll() {
          List<Dept> list = jdbcTemplate.query("select * from t_dept", new MyRowMapper());
          return list;
      }
      
      
      
      // 封装Springjdbc查询的结果集
      class MyRowMapper implements RowMapper<Dept>{
          
          // 如何解析一行
          @Override
          public Dept mapRow(ResultSet rs, int rowNum) throws SQLException {
              Dept dept = new Dept();
              dept.setId(rs.getInt("id"));
              dept.setName(rs.getString("deptName"));
              return dept;
          }
          
      }
      
  }

5、Spring声明式事务管理

1、Jdbc（DataSourceTransactionManager）

引入jar
Spring 核心
Spring Aop 切面编程
Spring-jdbc / Spring-tx / 驱动包、连接池

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:p="http://www.springframework.org/schema/p"
      xmlns:context="http://www.springframework.org/schema/context"
      xmlns:aop="http://www.springframework.org/schema/aop" 
      xmlns:tx="http://www.springframework.org/schema/tx"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd">

      <!-- 1. 数据源配置 -->
      <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
          <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
          <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
          <property name="user" value="root"></property>
          <property name="password" value="root"></property>
          <property name="initialPoolSize" value="3"></property>
          <property name="maxPoolSize" value="6"></property>
      </bean>

      <!-- 2. JdbcTemplate配置 ,  注入数据源-->
      <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
          <property name="dataSource" ref="dataSource"></property>
      </bean>

      <!-- 3. dao实例，注入jdbcTemplate -->
      <bean id="deptDao" class="xxxx.DeptDao">
          <property name="jdbcTemplate" ref="jdbcTemplate"></property>
      </bean>
      
      <!-- 4. Service实例，注入dao实例 -->
      <bean id="deptService" class="xxxx.DeptService">
          <property name="deptDao" ref="deptDao"></property>
      </bean>

      <!-- 5. Spring声明式事务管理配置 -->
      
      <!-- 5.1 配置事务管理器类 -->
      <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
          <property name="dataSource" ref="dataSource"></property>
      </bean>
      
      <!-- 5.2 事务通知配置, 拦截到指定的方法后如何管理事务 -->
      <!-- find*  find开头的方法，是只读的事务 -->
      <!--   *    上面所有的方法都不满足时候，采用的事务控制规则 -->
      <tx:advice id="txAdvice" transaction-manager="txManager">
          <tx:attributes>
              <tx:method name="find*" read-only="true"/>
              <tx:method name="get*" read-only="true"/>
              <tx:method name="*" read-only="false"/>
          </tx:attributes>
      </tx:advice>
      
      <!-- 5.3 事务Aop配置 = 切入点表达式  + 应用上面的事务通知 -->
      <aop:config>
          <aop:pointcut expression="execution(* cn..*Service.*(..))" id="pt"/>
          <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
      </aop:config>

  </beans>

注解方式

  <?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:p="http://www.springframework.org/schema/p"
      xmlns:context="http://www.springframework.org/schema/context"
      xmlns:aop="http://www.springframework.org/schema/aop" 
      xmlns:tx="http://www.springframework.org/schema/tx"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd">

      <!-- 1. 数据源配置 -->
      <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
          <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
          <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
          <property name="user" value="root"></property>
          <property name="password" value="root"></property>
          <property name="initialPoolSize" value="3"></property>
          <property name="maxPoolSize" value="6"></property>
      </bean>

      <!-- 2. JdbcTemplate配置 ,  注入数据源-->
      <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
          <property name="dataSource" ref="dataSource"></property>
      </bean>
      
      <!-- 事务管理器类 -->
      <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
          <property name="dataSource" ref="dataSource"></property>
      </bean>
      
      <!-- 开启注解扫描 -->
      <context:component-scan base-package="xxxx"></context:component-scan>
      <!-- spring声明式事务管理，注解开启 -->
      <tx:annotation-driven transaction-manager="txManager"/>

      

  </beans>     


@Repository    // 当期类加入ioc容器
public class DeptDao implements IDeptDao {

  // 注入JdbcTemplate对象
  @Resource
  private JdbcTemplate jdbcTemplate;

  public void save() {
      jdbcTemplate.update("insert into t_dept(deptName)values('test..')");
  }
}

@Service
public class LogService {

    @Resource
    private JdbcTemplate jdbcTemplate;

    // 事务控制
        //@Transactional，写到方法上， 表示当前方法应用事务控制
                          写到类上，  表示当前类的所有方法都会应用事务
                          写到父类上， 当执行父类的这个方法时候才应用事务
    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void insertLog() {
        jdbcTemplate.update("insert into t_log values('在插入部门....')");
    }

}

@Service
public class DeptService implements IDeptService {

  @Resource
  private IDeptDao deptDao;
  
  @Resource
  private LogService logService;
  
  // 当前方法应用事务
  @Transactional(
          readOnly=false,      // 读写的事务，当修改数据时候用；如果查询就设置为true
          isolation=Isolation.DEFAULT,  // 事务隔离级别
          timeout=-1,         // 事务执行的超时时间, -1 表示不超时
          //noRollbackFor=ArithmeticException.class,   // 遇到指定的异常不回滚
          propagation=Propagation.REQUIRED      // 事务传播行为
         //REQUIRES_NEW  当前执行方法必须在事务环境下运行，且当前执行方法始终开启一个新的事务
         //REQUIRED   当前执行方法必须在事务环境下运行,
                      如果调用当前方式时候已经有一个事务环境，当前执行方法会加入当前事务环境，就不开启新的事务,
                      如果调用当前方法时候没有事务环境，就开启一个新的事务!
         //SUPPORTS       支持事务环境！ 如果当前方法没有事务，也可以运行！
        //Never           当前方法不能再事务环境下运行！
  )
  public void save() {
      // 插入日志
      logService.insertLog();
      
      int i = 1/0;
      
      // 插入部门
      deptDao.save();
  }
}

2、 Hibernate(HibenateTransactionManager)

引入jar
hibernate jar
spring – core
spring – aop
spring – orm 对orm支持
spring-jdbc-3.2.5.RELEASE.jar
spring-orm-3.2.5.RELEASE.jar
spring-tx-3.2.5.RELEASE.jar

Spring创建SessionFactory几种方式

 <?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:p="http://www.springframework.org/schema/p"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context.xsd
      http://www.springframework.org/schema/aop
      http://www.springframework.org/schema/aop/spring-aop.xsd
      http://www.springframework.org/schema/tx
      http://www.springframework.org/schema/tx/spring-tx.xsd">
      
 <!-- 连接池, 通过spring管理 -->
 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
     <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
     <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
     <property name="user" value="root"></property>
     <property name="password" value="root"></property>
     <property name="initialPoolSize" value="3"></property>
     <property name="maxPoolSize" value="6"></property>
 </bean>
      
 <!-- Spring 与   Hibenate整合  (Spring创建SessionFactory) -->     

 <!-- 方式1： 直接加载hibernate.cfg.xml的方式，创建sessionFactory对象
 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
     <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
 </bean>
  -->
  
  <!-- 方式2： 连接池交给spring管理，其他配置还是写到hibernate.cfg.xml中 
  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
     <property name="dataSource" ref="dataSource"></property>
     <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
  </bean>
  -->
  
  <!-- 方式3：(推荐) 所有的配置都在spring中完成-->
  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
     <!-- a. 注入连接池 -->
     <property name="dataSource" ref="dataSource"></property>
     
     <!-- b. hibernate常用配置： 方言、自动建表、显示sql -->
     <property name="hibernateProperties">
         <props>
             <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
             <prop key="hibernate.show_sql">true</prop>
             <prop key="hibernate.hbm2ddl.auto">update</prop>
         </props>
     </property>
     
     <!-- c. 加载所有的映射(根据路径加载) 
     <property name="mappingLocations">
         <list>
             <value>classpath:xxx/entity/*.hbm.xml</value>
         </list>
     </property>
     -->
     <!-- c. 根据目录加载所有的映射 -->
     <property name="mappingDirectoryLocations">
         <list>
             <value>classpath:xxx/entity</value>
         </list>
     </property>
  </bean>


 <!-- 创建dao实例 -->
 <bean id="deptDao" class="xxx.DeptDao">
     <property name="sessionFactory" ref="sessionFactory"></property>
 </bean>
 
 <!-- 创建service实例 -->
 <bean id="deptService" class="xxxx.service.DeptService">
     <property name="deptDao" ref="deptDao"></property>
 </bean>
 
 
 <!-- 
     Spring声明式事务管理配置
  -->
  <!-- a. 事务管理器 -->
  <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
     <property name="sessionFactory" ref="sessionFactory"></property>
  </bean>
  
  <!-- b. 事务通知 -->
  <tx:advice id="txAdvice" transaction-manager="txManager">
     <tx:attributes>
         <tx:method name="*" read-only="false"/>
     </tx:attributes>
  </tx:advice>
  
  <!-- c. Aop配置  = 切入点表达式  + 应用通知规则 -->
  <aop:config>
     <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn..*Service.*(..))"/>
  </aop:config>
 
 
 </beans>

Spring对dao操作的支持
1、直接在dao中使用sessionFactory对象操作数据库
2、使用Spring提供的 HibernateTemplate 工具类操作数据库，优点：对session的常用操作进行封装！比较方便!
3、(推荐)HibernateDaoSupport工具类，Dao类直接继承HibernateDaoSupport工具类即可，HibernateDaoSupport对hibernateTemlate类进行了封装

Spring生命周期以及Aop的执行时机总结
Spring生命周期总结小结: Spring的Bean对象创建完整流程图如下(从getBean开始) obtai...
Spring小结
1、IOC 容器 1、概念 IOC为Inversion of control，控制反转，意思是现在需要对象，自己不...
Spring小结
一.环境搭建创建Maven项目一般pom.xml会出错,本地若无相应版本的jar包,则无法下载或下载速度非常慢...
Spring小结
在传统Spring应用中使用spring-boot-actuat
在之前发布的《Spring Boot Actuator监控端点小结》一文中，我们介绍了Spring Boot Ac...
某Java项目一期完成后的小结
项目小结技术栈： Spring Boot、Java Agent、 Byte Buddy、自定义ClassLoad...
180531-Spring中JavaConfig知识小结
原文链接：Spring中JavaConfig知识小结/ Sring中JavaConfig使用姿势去掉xml的配置...
Spring 事务
一些 Spring 事务的核心配置与代码片段核心配置目标对象测试小结：spring 的事务管理是通过动态代...
jpa初级用法
前言:公司新的项目使用的jpa，之前没有过，所以在此小结一下一、Spring data JPA简介 Spring...
JAVA 异常控制
文章 Spring RestFul API统一异常处理SpringBoot RESTful 应用中的异常处理小结S...

Spring小结

1、IOC 容器

2、Spring与Struts2整合

3、Aop编程

4、Spring对jdbc模块的支持

5、Spring声明式事务管理

相关文章

Spring生命周期以及Aop的执行时机总结

Spring小结

Spring小结

Spring小结

在传统Spring应用中使用spring-boot-actuat

某Java项目一期完成后的小结

180531-Spring中JavaConfig知识小结

Spring 事务

jpa初级用法

JAVA 异常控制

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读