spring中的AOP 以及各种通知 配置

理解了前面动态代理对象的原理之后，其实还是有很多不足之处，因为如果在项目中有20多个类，每个类有100多个方法都需要判断是不是要开事务，那么方法调用那里会相当麻烦。

spring中的AOP很好地解决了这个问题，通过 execution表达式 指定哪些包中的那些类 哪些方法 用到事务

execution（public * *（..））  所有的公共方法

execution（* set*（..））  以set开头的任意方法

execution（* com.xyz.service.AccountService.*（..）） com.xyz.service.AccountService类中的所有的方法

execution（* com.xyz.service.*.*（..））  com.xyz.service包中的所有的类的所有的方法

execution（* com.xyz.service..*.*（..）） com.xyz.service包及子包中所有的类的所有的方法

execution(* cn.itcast.spring.sh..*.*(String,?,Integer))  cn.itcast.spring.sh包及子包中所有的类的有三个参数

第一个参数为String,第二个参数为任意类型，

第三个参数为Integer类型的方法

springAOP的具体加载步骤：

1、当spring容器启动的时候，加载了spring的配置文件

2、为配置文件中所有的bean创建对象

3、spring容器会解析aop:config的配置

1、解析切入点表达式，用切入点表达式和纳入spring容器中的bean做匹配

如果匹配成功，则会为该bean创建代理对象，代理对象的方法=目标方法+通知

如果匹配不成功，不会创建代理对象

4、在客户端利用context.getBean获取对象时，如果该对象有代理对象则返回代理对象，如果代理对象，则返回目标对象

说明：如果目标类没有实现接口，则spring容器会采用cglib的方式产生代理对象，如果实现了接口，会采用jdk的方式

实例：

引入包

aspectjrt.jar

aspectjweaver.jar

Person.java

 package cn.itcast.sh.aop;

 import java.io.Serializable;

 /**
  * 对象的序列化的作用：让对象在网络上传输,以二进制的形式传输
  * @author Think
  * Serializable标示接口
  */
 public class Person implements Serializable{
     private Long pid;
     private String pname;

     public Person(){}

     public Person(String pname){
         this.pname = pname;
     }

     public Long getPid() {
         return pid;
     }
     public void setPid(Long pid) {
         this.pid = pid;
     }
     public String getPname() {
         return pname;
     }
     public void setPname(String pname) {
         this.pname = pname;
     }
     public String getPsex() {
         return psex;
     }
     public void setPsex(String psex) {
         this.psex = psex;
     }
     private String psex;
 }

PersonDao.java

 package cn.itcast.sh.aop;

 public interface PersonDao {
     public void savePerson(Person person);
 }

PersonDaoImpl.java

 package cn.itcast.sh.aop;

 import org.hibernate.Session;

 import cn.itcast.hibernate.sh.utils.HiberanteUtils;

 public class PersonDaoImpl extends HiberanteUtils implements PersonDao{

     @Override
     public void savePerson(Person person) {
         Session session=sessionFactory.getCurrentSession();
         session.save(person);
     }

 }

定义切面 MyTransaction.java

 package cn.itcast.sh.aop;

 import org.hibernate.Transaction;

 import cn.itcast.hibernate.sh.utils.HiberanteUtils;

 public class MyTransaction extends HiberanteUtils{

     private Transaction tran;
     public void beginTransaction()
     {
         tran=sessionFactory.getCurrentSession().beginTransaction();
     }
     public void commit()
     {
         tran.commit();
     }
 }

hibernate.cfg.xml

 <?xml version='1.0' encoding='utf-8'?>
 <!DOCTYPE hibernate-configuration PUBLIC
         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 <hibernate-configuration>
     <!--
         一个session-factory只能连接一个数据库
     -->
 <session-factory>
     <!--
         数据库的用户名
     -->
     <property name="connection.username">root</property>

     <property name="connection.driver_class">
         com.mysql.jdbc.Driver
     </property>

     <!--
         密码
     -->
     <property name="connection.password">friends</property>
     <!--
         url
     -->
     <property name="connection.url">
         jdbc:mysql://localhost:3306/hibernate_basic
     </property>
     <!--
         作用：根据持久化类和映射文件生成表
         validate
         create-drop
         create
         update
     -->
     <property name="hbm2ddl.auto">update</property>

     <property name="hibernate.dialect">
         org.hibernate.dialect.MySQLInnoDBDialect
     </property>
 <!--     用于配置当前线程用的 -->
     <property name="current_session_context_class">thread</property>
     <!--
         显示hibernate内部生成的sql语句
     -->
     <property name="show_sql">true</property>
     <property name="format_sql">true</property>
     <mapping resource="cn/itcast/sh/aop/Person.hbm.xml" />

 </session-factory>
 </hibernate-configuration>

重点applicationContext-aop.xml配置spring提供的切面

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
     <!--
         导入目标类，导入切面
      -->
      <bean id="personDao" class="cn.itcast.sh.aop.PersonDaoImpl"></bean>

      <bean id="myTransaction" class="cn.itcast.sh.aop.MyTransaction"></bean>

      <!--
          aop的配置
       -->
       <aop:config>
           <!--
                切入点表达式
            -->
           <aop:pointcut expression="execution(* cn.itcast.sh.aop.PersonDaoImpl.*(..))" id="perform"/>
           <aop:aspect ref="myTransaction">

               <aop:before method="beginTransaction" pointcut-ref="perform"/>
               <aop:after-returning method="commit" pointcut-ref="perform"/> 

 <!--               <aop:after method="finallyMethod" pointcut-ref="perform"/> -->
 <!--               <aop:after-throwing method="throwingMethod" pointcut-ref="perform" throwing="ex"/> -->
 <!--               <aop:around method="aroundMethod" pointcut-ref="perform"/> -->
           </aop:aspect>
       </aop:config>
 </beans>

测试类

 package cn.itcast.sh.aop;

 import org.junit.Test;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class test {
     @Test
     public void testAop()
     {
         Person p=new Person();
         p.setPname("new comer");
         p.setPsex("boy");

         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-aop.xml");
         PersonDao dao=(PersonDao) context.getBean("personDao");
         dao.savePerson(p);
     }

 }

示例二： 返回值通过 applicationContext.xml中在通知后面添加参数来配置返回值

例如后置通知中 配置 returinn属性

通知：

1、前置通知

1、在目标方法执行之前执行

2、无论目标方法是否抛出异常，都执行，因为在执行前置通知的时候，目标方法还没有执行，还没有遇到异常

2、后置通知

1、在目标方法执行之后执行

2、当目标方法遇到异常，后置通知将不再执行

3、后置通知可以接受目标方法的返回值，但是必须注意：aop:after-returning标签

后置通知的参数的名称和配置文件中returning="var"的值是一致的

3、最终通知：

1、在目标方法执行之后执行

2、无论目标方法是否抛出异常，都执行，因为相当于finally

4、异常通知

1、接受目标方法抛出的异常信息

2、步骤

在异常通知方法中有一个参数Throwable  ex

在配置文件中

<aop:after-throwing method="throwingMethod" pointcut-ref="perform" throwing="ex"/>

5、环绕通知             用于判断条件是否让目标方法执行

1、如果不在环绕通知中调用ProceedingJoinPoint的proceed，目标方法不会执行

2、环绕通知可以控制目标方法的执行

PersonDaoImpl.java

 package cn.itcast.spring.aop.sh;

 import java.lang.reflect.Method;

 import org.junit.Test;

 import cn.itcast.spring.aop.annotation.sh.HibernateUtils;
 import cn.itcast.spring.aop.annotation.sh.Person;

 public class PersonDaoImpl extends HibernateUtils{
     public String savePerson(Person person) {
         // TODO Auto-generated method stub
         //int a = 1/0;
         //sessionFactory.getCurrentSession().save(person);
         System.out.println("aaaa");
         return "aaaa";
     }
 }

用到的类和方法和上面相同，只不过改切面的文件(MyTransaction.java)和 applicationContext-aop.xml文件

 package cn.itcast.spring.aop.sh;

 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.hibernate.Transaction;

 import cn.itcast.spring.aop.annotation.sh.HibernateUtils;

 public class MyTransaction extends HibernateUtils{
     private Transaction transaction;
     /**
      * 通过该参数可以获取目标方法的一些信息
      *在每个通知中都可以加入 JoinPoint joinpoint参数
      * @param joinpoint
      */
     public void beginTransaction(JoinPoint joinpoint){
         System.out.println("bbb");
         this.transaction = sessionFactory.getCurrentSession().beginTransaction();
     }
     　　　　　　　　　　　　　　　　　　　　　　　　//var是目标方法的返回值,以上的savePerson函数返回值 aaaa
     public void commit(Object var){         //保持与 application-aop.xml 中的aop:after-returning元素中 returning中的属性值一致
         System.out.println(var);
         this.transaction.commit();
     }

     public void finallyMethod(){
         System.out.println("finally method");
     }

     /**
      * 异常通知
      * @param ex
      */
     public void throwingMethod(Throwable ex){    //保持与 application-aop.xml 中的aop:after-returning元素中 throwing中的属性值一致
         System.out.println(ex.getMessage());
     }
     　　//JoinPoint是 ProceedingJoinPoint的父类 
 public void aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable{ 
        System.out.println(joinPoint.getSignature().getName()); 
        joinPoint.proceed();//调用目标方法 
        System.out.println("aaaasfdasfd"); 
     } 
  }

applicationContext-aop.xm

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
     <!--
         导入目标类，导入切面
      -->
      <bean id="personDao" class="cn.itcast.spring.aop.sh.PersonDaoImpl"></bean>

      <bean id="myTransaction" class="cn.itcast.spring.aop.sh.MyTransaction"></bean>

      <!--
          aop的配置
       -->
       <aop:config>
           <!--
                切入点表达式
            -->
           <aop:pointcut expression="execution(* cn.itcast.spring.aop.sh.PersonDaoImpl.*(..))" id="perform"/>
           <aop:aspect ref="myTransaction">
           <!--
         前置通知 <aop:before method="beginTransaction" pointcut-ref="perform"/>
        后置通知 <aop:after-returning method="commit" pointcut-ref="perform" returning="var"/>
            --><!--最终通知   异常通知   环绕通知 用于判断是否执行目标对象的-->
               <aop:after method="finallyMethod" pointcut-ref="perform"/>
               <aop:after-throwing method="throwingMethod" pointcut-ref="perform" throwing="ex"/>
               <aop:around method="aroundMethod" pointcut-ref="perform"/>
           </aop:aspect>
       </aop:config>
 </beans>

测试

 package cn.itcast.spring.aop.sh;

 import org.junit.Test;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import cn.itcast.spring.aop.annotation.sh.Person;
 import cn.itcast.spring.aop.annotation.sh.PersonDaoImpl;

 public class PersonTest {
     @Test
     public void test(){
         ApplicationContext context = new ClassPathXmlApplicationContext("cn/itcast/spring/aop/sh/applicationContext.xml");
         PersonDaoImpl personDao = (PersonDaoImpl)context.getBean("personDao");
         Person person = new Person();
         person.setPname("aaas");
         personDao.savePerson(person);
     }
 }