代理模式及Spring AOP (二)

一.Spring AOP

    1.1 Spring AOP

        底层还是用的动态代理。如果目标对象所对应的类有接口，spring就用jdk生成代理对象；

                                               如果目标对象所对应的类没有接口，spring就用CGLIB生成代理对象。

        优点：动态代理，如果一个类被它代理，则接口或者类的所有方法都被强迫执行。而spring AOP可以按业务划分，有些方法需要事务则扩展功能，有些方法不需要则不进行扩展。

    1.2 相关概念名词

        ① 切面aspect：切面是一个类(功能类)，类里有若干方法，每个方法代表一个功能。把这些功能方法切到指定的位置，切到到业务方法的前后等

                                  对应:spring中<aop:aspect id="myAspect" ref="tm"></aop:aspect>

        ② 连接点joinpoint：用代理对象调用方法，这句话的位置就是连接点，用连接点启动横切。

        ③ 通知advice：切面类中的那些方法就是通知。

　　     前置通知<aop:before                在执行目标方法前面

            后置通知<aop:after-returning    在执行完目标方法后执行

            异常通知<aop:after-throwing    在目标方法抛异常执行,不会执行后置通知

            最终通知<aop:after                   前置,后置或异常通知,都执行完毕后会执行最终通知

            环绕通知<aop:around               特点:可以控制目标方法的执行

        ④ 切入点pointcut：把切面中的通知，切到哪个类中的哪些方法上，切入点是指切到哪些方法上，spring给提供一些规则表达式,用于指定切在哪些方法上。

                             对应：spring中<aop:pointcut id="myPointCut" expression="execution(* com.hdu.service..*.*(..))"/>

        ⑤ 目标对象targetObject：实际的业务类的对象

        ⑥ aop代理aopproxy：由spring框架帮程序员用jdk或cglib生成代理对象，这个生成的过程被spring封装了。spring的独有配置，用于指定生成代理对象。

                                  对应： spring中<aop:config></aop:config>

        ⑦ 织入weaving：也叫横切，把额外的功能用配置文件和注解的方式织入到业务中；取消配置文件和注解,就取消了织入,不影响原有业务流程

                         在spring中加入<aop:config节点,<aop:pointcut expression=""，从spring容器取出expression属性指定的对象都是代理对象。

                         在spring中没有加入<aop:config节点,从spring容器中取出的所有对象是真实对象。

    1.3 参考手册

        1.3.1 声明一个切面

　　　　

        1.3.2 声明一个切点

　　　　其中<aop:pointcut/>标签写在<aop:aspect></aop:aspect>标签内，为局部切点，只起作用在对应切面。

　　　　　　

　　　　其中<aop:pointcut/>标签写在<aop:aspect></aop:aspect>标签外，为全局切点，所有切面对其有效。

　　　　　　

　　关于切点的expression 表达式：

　　

　　　　参考手册中的示例：

　　　　　　① the execution of any public method:所有的public方法
　　　　　　　　execution(public * *(..))
　　　　　　② the execution of any method with a name beginning with "set": 所有以set开头的方法
　　　　　　　　execution(* set*(..))
　　　　　　③ the execution of any method defined by the AccountService interface: com.xyz.service.AccountService类或接口中任意方法,任意参数,任意返回值
　　　　　　　　execution(* com.xyz.service.AccountService.*(..))
　　　　　　④ the execution of any method defined in the service package: com.xyz.service包下任意类,任意方法,任意参数,任意返回值
　　　　　　　　execution(* com.xyz.service.*.*(..))
　　　　　　⑤ the execution of any method defined in the service package or a sub-package: com.xyz.service包下以及子包下任意类.任意的方法,任意参数,任意返回值
　　　　　　　　execution(* com.xyz.service..*.*(..)) 

　　关于切点的within表达式：

 　　　　① any join point (method execution only in Spring AOP) within the service package:  com.xyz.service的任意类

　　　　　　within(com.xyz.service.*)

　　　　 ② any join point (method execution only in Spring AOP) within the service package or a sub-package: com.xyz.service及其子包下的任意类

　　　　　　within(com.xyz.service..*)

　　　　 ③ any join point (method execution only in Spring AOP) where the proxy implements the AccountService interface: com.xyz.service的AccountService类

　　　　　　this(com.xyz.service.AccountService)

        1.3.3 声明通知

　　　　通常 前置通知、后置通知、异常通知、最终通知 与 环绕通知分开使用，否则执行顺序不符合预期逻辑。

　　　　若环绕通知叠加使用，按配置顺序先A后B，则执行时，先执行A在目标对象调用方法之前的内容，再执行B在目标对象调用方法之前的内容，调用目标对象的原有方法，执行A在目标对象调用方法之后的内容，执行B在目标对象调用方法之后的内容。

　　　　1.3.3.1 前置通知

　　　　　　

　　　　1.3.3.2 后置通知

　　　　　　   

　　　　1.3.3.3 异常通知

　　　　　　   

　　　　1.3.3.4最终通知

　　　　　　

　　　　1.3.3.5环绕通知

 　　　　　　

二.Spring AOP使用示例：使用xml配置文件的方式

    2.1 新增jar包，支持对AOP的处理

        

    2.2 接口及业务实现类

package com.hdu.dao;
 
public interface IUserDao {
    public int addrUser();
    public int updateUser();
}

package com.hdu.dao.impl;

import com.hdu.dao.IUserDao;

public class UserDaoImpl implements IUserDao {

    @Override
    public int addrUser() {
        System.out.println("UserDaoImpl.addUser()");
        return 1;
    }

    @Override
    public int updateUser() {
        System.out.println("UserDaoImpl.updateUser()");
        return 1;
    }
}

Class UserDaoImpl

package com.hdu.service;

public interface IUserService {
    public boolean addUser();
    public boolean updateUser();
    
}

Interface IUserService

package com.hdu.service.impl;

import com.hdu.dao.IUserDao;
import com.hdu.dao.impl.UserDaoImpl;
import com.hdu.service.IUserService;

public class UserServiceImpl implements IUserService {
    //应该用spring进行解耦，本次重点在于代理，故简化操作
    private IUserDao userDao = new UserDaoImpl();
    
    @Override
    public boolean addUser() {
        System.out.println("UserServiceImpl.addUser()");
        boolean flag = false;
        int rowAffect = userDao.addrUser();
        if(rowAffect==1) {
            flag = true;
        }
        return flag;
    }

    @Override
    public boolean updateUser() {
        System.out.println("UserServiceImpl.updateUser()");
        boolean flag = false;
        int rowAffect = userDao.updateUser();
        if(rowAffect==1) {
            flag = true;
        }
        return flag;
    }

}

Class UserServiceImpl

     2.3 切面类

        其中JoinPoint 可以获取目标对象，目标方法及目标方法的参数，环绕通知则使用ProceedingJoinPoint 获取。

package com.hdu.aspect;

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

/**
 * 切面
 * @author Administrator
 *
 */
public class TransactionManager {
    //前置通知方法
    public void begin(JoinPoint jp) {
        System.out.println("begin transaction");
        System.out.println("目标对象-->"+jp.getTarget());
        System.out.println("目标方法-->"+jp.getSignature().getName());
        System.out.println("目标方法参数-->"+jp.getArgs()[0]);
    }
    
    //后置通知方法
    public void commit(JoinPoint jp,Object flag) {
        System.out.println("commit transaction");
        System.out.println("目标对象-->"+jp.getTarget());
        System.out.println("目标方法-->"+jp.getSignature().getName());
        System.out.println("目标方法参数-->"+jp.getArgs()[0]);
        System.out.println("目标方法的返回值-->"+flag);
    }
    //异常通知方法
    public void rollback(JoinPoint jp,Exception ex) {
        System.out.println("rollback transaction");
        System.out.println("目标对象-->"+jp.getTarget());
        System.out.println("目标方法-->"+jp.getSignature().getName());
        System.out.println("目标方法参数-->"+jp.getArgs()[0]);
        System.out.println("目标方法抛异常-->"+ex.getMessage());
    }
    //最终通知
    public void finallyClose(JoinPoint jp) {
        System.out.println("finallyClose");
        System.out.println("目标对象-->"+jp.getTarget());
        System.out.println("目标方法-->"+jp.getSignature().getName());
        System.out.println("目标方法参数-->"+jp.getArgs()[0]);
    }
    //环绕通知  能控制目标方法的执行
    public Object around(ProceedingJoinPoint pjp)throws Throwable {
        Object retVal=null;
        try {
            System.out.println("around  begin transaction");
            System.out.println("目标对象-->"+pjp.getTarget());
            System.out.println("目标方法-->"+pjp.getSignature().getName());
            System.out.println("目标方法参数-->"+pjp.getArgs()[0]);
            //if() {
                //就是直接指定目标方法
                retVal = pjp.proceed();
            //}
            System.out.println("around  commit transaction");
        }catch(Exception e) {
            e.printStackTrace();
            System.out.println("around  rollback transaction");
        }finally {
            System.out.println("around  finallyClose");
        }
        
        return retVal;
    }
}

    2.4 配置文件

<?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:tx="http://www.springframework.org/schema/tx"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.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
        http://www.springframework.org/schema/util 
        http://www.springframework.org/schema/util/spring-util.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
    <!-- 实例化业务模型对象 -->
    <bean id="userDao" class="com.hdu.dao.impl.UserDaoImpl"></bean>
    
    <bean id="userService" class="com.hdu.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    
    <!-- 实例化切面的对象 -->
    <bean id="tm" class="com.hdu.aspect.TransactionManager"></bean>
    
    <!-- spring 独有的配置,创建代理对象和确定如何横切切面 -->
    <!-- <aop:config>这个标签就告知spring要做代理对象了
            原则:如果实际对象有接口就jdk动态代理生成代理对象;如果实际对象没有接口就用cglib动态代理生成代理对象
             可以人为改动proxy-target-class="true",强制用cglib
    -->
    <aop:config proxy-target-class="false">
        <!-- <aop:aspect 这个节点标签,告知spring使用哪个切面
                可以写多个<aop:aspect节点,可以使用多个横切
        -->
        <aop:aspect id="myAspect" ref="tm">
            <!-- 告知spring 把切面 切在哪些类的哪些方法上,切点可以写多个-->
            <aop:pointcut id="myPointCut"
                          expression="execution(* com.hdu.service..*.*(..))"/>
            <!-- 前置通知 -->
            <aop:before
                pointcut-ref="myPointCut"
                method="begin"/>
            <!-- 后置通知 
                属性returning="flag" flag对应的通知方法中的参数
            -->
            <aop:after-returning
                pointcut-ref="myPointCut"
                method="commit"
                returning="flag"/>
            <!-- 异常通知 
                属性throwing="ex"  ex对应的异常通知的方法的参数
            -->
            <aop:after-throwing
                pointcut-ref="myPointCut"
                method="rollback"
                throwing="ex"/>
                
            <!-- 最终通知 -->
            <aop:after
                pointcut-ref="myPointCut"
                method="finallyClose"/>
            <!-- 环绕通知 -->
<!--              <aop:around -->
<!--                 pointcut-ref="myPointCut" -->
<!--                 method="around"/>         -->
        </aop:aspect> 
        
    </aop:config>    
    
</beans>

    2.5 测试

package com.hdu.test;

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

import com.hdu.dao.UserDao;
import com.hdu.entity.User;
import com.hdu.service.UserService;


public class TestSpringAOP {
    @Test
    public void testMethod1() {
        //初始化spring容器 
        ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_aop.xml");
        UserService userService=context.getBean("userService",UserService.class);
        System.out.println(userService.getClass());
        userService.addUser(new User());
        
        //userDao不会被代理
        UserDao userDao=context.getBean("userDao",UserDao.class);
        System.out.print("userDao不会被代理"+userDao.getClass());
    }
}

　　结果：

class com.sun.proxy.$Proxy6
begin transaction
目标对象-->com.hdu.service.impl.UserServiceImpl@769f71a9
目标方法-->addUser
目标方法参数-->com.hdu.entity.User@4b5d6a01
UserServiceImpl.addUser()
UserDaoImpl.addUser()
commit transaction
目标对象-->com.hdu.service.impl.UserServiceImpl@769f71a9
目标方法-->addUser
目标方法参数-->com.hdu.entity.User@4b5d6a01
目标方法的返回值-->true
finallyClose
目标对象-->com.hdu.service.impl.UserServiceImpl@769f71a9
目标方法-->addUser
目标方法参数-->com.hdu.entity.User@4b5d6a01
userDao不会被代理class com.hdu.dao.impl.UserDaoImpl

    2.6调用过程

　　　　我们获取对象，要么是对象地址，要么是代理：System.out.println(userService.getClass());

　　从打印结果 class com.sun.proxy.$Proxy6 可知，目前使用的是jdk动态代理。

　　　　其中UserService userService = (UserService) context.getBean("userService");执行时spring已经把UserService变成代理对象。

　　在执行userService.addUser();业务方法时就会被invoke方法拦截。就被切点表达式expression="execution(* com.hdu.service..*.*(..))"拦截。

　　切点表达式expression="execution(* com.hdu.service..*.*(..))"匹配上了实现类，就会执行切面中通知。

　　　　<aop:aspect id="myAspect" ref="tm">

　　　　　　<aop:before pointcut-ref="myPointCut" method="begin"/>

　　　　</aop:aspect>

　　就找到TransactionManager类，找到before方法，并调用。

　　也就是说只要程序满足切点表达式，就会调用切面的方法。最终我们就看到它不是真实的对象，而是一个代理对象。由代理去执行就会响应执行通知的方法。

三.Spring AOP使用示例：使用注解的方式

    3.1 切面类

　　参考手册：

　　　　

　　切点可以是局部的也可以是全局的。

package com.hdu.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 切面
 * @author Administrator
 *
 */
@Component("tm")
@Aspect
public class TransactionManager {
    //the pointcut expression
    @Pointcut("execution(* com.hdu.service..*.*(..))")
    private void myPointCut() {}// the pointcut signature
    
    //前置通知方法
    //@Before("myPointCut()")
    public void begin(JoinPoint jp) {
        System.out.println("begin transaction");
        System.out.println("目标对象-->"+jp.getTarget());
        System.out.println("目标方法-->"+jp.getSignature().getName());
        System.out.println("目标方法参数-->"+jp.getArgs()[0]);
    }
    
    //后置通知方法
    //@AfterReturning(pointcut="myPointCut()",returning="flag")
    public void commit(JoinPoint jp,Object flag) {
        System.out.println("commit transaction");
        System.out.println("目标对象-->"+jp.getTarget());
        System.out.println("目标方法-->"+jp.getSignature().getName());
        System.out.println("目标方法参数-->"+jp.getArgs()[0]);
        System.out.println("目标方法的返回值-->"+flag);
    }
    //异常通知方法
    //@AfterThrowing(pointcut="myPointCut()",throwing="ex")
    public void rollback(JoinPoint jp,Exception ex) {
        System.out.println("rollback transaction");
        System.out.println("目标对象-->"+jp.getTarget());
        System.out.println("目标方法-->"+jp.getSignature().getName());
        System.out.println("目标方法参数-->"+jp.getArgs()[0]);
        System.out.println("目标方法抛异常-->"+ex.getMessage());
    }
    //最终通知
    //@After("myPointCut()")
    public void finallyClose(JoinPoint jp) {
        System.out.println("finallyClose");
        System.out.println("目标对象-->"+jp.getTarget());
        System.out.println("目标方法-->"+jp.getSignature().getName());
        System.out.println("目标方法参数-->"+jp.getArgs()[0]);
    }

    //环绕通知  能控制目标方法的执行
    @Around("myPointCut()")
    public Object around(ProceedingJoinPoint pjp)throws Throwable {
        Object retVal=null;
        try {
            System.out.println("around  begin transaction");
            System.out.println("目标对象-->"+pjp.getTarget());
            System.out.println("目标方法-->"+pjp.getSignature().getName());
            System.out.println("目标方法参数-->"+pjp.getArgs()[0]);
            //if() {
                //就是直接指定目标方法
                retVal = pjp.proceed();
                
            //}
            System.out.println("around  commit transaction");
        }catch(Exception e) {
            e.printStackTrace();
            System.out.println("around  rollback transaction");
        }finally {
            System.out.println("around  finallyClose");
        }
        
        return retVal;
    }
}

    3.2 配置清单

<?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:tx="http://www.springframework.org/schema/tx"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.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
        http://www.springframework.org/schema/util 
        http://www.springframework.org/schema/util/spring-util.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
    <!-- 
        @Controller @Service @Repository @Component @Resource    @Autowired @Qualifier
     -->
    <!-- 实例化业务模型对象 -->
    <context:component-scan base-package="com.hdu.dao.impl"></context:component-scan>
    <context:component-scan base-package="com.hdu.service.impl"></context:component-scan>
    
    
    <!-- 实例化切面的对象 -->
    <context:component-scan base-package="com.hdu.aspect"></context:component-scan>
    
    <!-- spring 独有的配置,创建代理对象和确定如何横切切面
        @Aspect @Pointcut @Before @AfterReturning @AfterThrowing @After @Around
     -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

    3.3 测试

package com.hdu.test;

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

import com.hdu.entity.User;
import com.hdu.service.UserService;


public class TestSpringAOP {
    @Test
    public void testMethod1() {
        //初始化spring容器 
        ApplicationContext context= new ClassPathXmlApplicationContext("resources/spring_aop.xml");
        UserService userService=context.getBean("userService",UserService.class);
        System.out.println(userService.getClass());
        userService.addUser(new User());//连接点 启动横切
    }
    

}

     结果

class com.sun.proxy.$Proxy13
around  begin transaction
目标对象-->com.hdu.service.impl.UserServiceImpl@217ed35e
目标方法-->addUser
目标方法参数-->com.hdu.entity.User@f5958c9
UserServiceImpl.addUser()
UserDaoImpl.addUser()
around  commit transaction
around  finallyClose