spring入门知识总结4 AOP技术

AOP技术
1.引出问题
建立spring _04_aop项目，在该项目下有一个UserDao接口，代码 如下：
package com.asm.dao;
public interface UserDao {
        void save();
        void update();
}
该接口的实现类UseDaoImp，代码如下：
package com.asm.dao.impl;
import com.asm.dao.UserDao;
public class UserDaoImp implements UserDao {
        private String username;
        public UserDaoImp() {
        }
        public UserDaoImp(String username) {
                this.username = username;
        }
        public String getUsername() {
                return username;
        }
        @Override
        public void save() {
                System.out.println("save method is called：" + username);
        }
        @Override
        public void update() {
                System.out.println("update method is called" + username);
        }
}
需求如下：如果实现类的username!=null,才可以调用save与update方法，为null则不能调用。当然要解决此问题，可以在save 与update方法内部进行判断，但是如果在方法内部进行判断，代码则失去了灵活性，如果以后的需求改变，比如变成username.equals时，则 又要在update/save方法中重新进行一次判断。如果save/update这样的方法很多，这样就会很麻烦。其实要解决此问题，可以通过动态 代理技术实现。这里的需求其实就是根据要求来拦截一些业务方法，这种编程问题称之为横切性关注点。
代理的目标对象必须实现了一个接口---横切关注点
2.动态代理实现[JDK]
建立代理工厂ProxyFactory，代码如下：
package com.asm.dao.impl.factory;
public class ProxyFactory implements InvocationHandler {
        private Object target;
        public Object createUserDaoImp(Object target) {
                this.target = target;
return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                UserDaoImp udi = (UserDaoImp) target;
                Object result = null;
                if (udi.getUsername() != null) {
                        result = method.invoke(target, args);
                }
                return result;
        }
}
简析动态代理：此类根据传递的target对象来生成此目标对象的代理对象，需要强调的是动态代理技术所要代理的对象必须实现一个接口。 newProxyInstance参数说明：第一个参数是目标对象的类装载器，第二个参数是目标对象的接口，第三个参数是回调对象，生成的代理对象要执行 方法时就是依靠这个回调对象的invoke方法来进行目标对象的方法回调。关于动态代理的其它细节不在此讨论。
建立junit测试代码，内容如下：
public class AopProxyTest {
        @Test        //用户 名为空，不执行方法
        public void testProxy(){
                ProxyFactory pf=new ProxyFactory();
                UserDao ud=(UserDao) pf.createUserDaoImp(new UserDaoImp());
                ud.save();
        }
        @Test        //用户名为不为空，才执行save方法
        public void testProxy2(){
                ProxyFactory pf=new ProxyFactory();
        UserDao ud=(UserDao) pf.createUserDaoImp(new UserDaoImp("张某"));
                ud.save();
        }
}
3.cglib实现代理
JDK的Proxy实现代理要求被代理的目标对象必须实现一个接口，而如果目标对象没有实现接口则不能使用Proxy来代理。其实也可以借助cglib来实现代理。操作步骤如下
步骤一、建立UserDaoImp2类，它与UserDaoImp的唯一区别就是没有实现任何接口。
步骤二、导入cglib.jar包，创建cglib代理工厂，代码如下：
package com.asm.dao.impl.factory;
public class CglibFactory implements MethodInterceptor {
        private Object target;
        public Object createUserDaoImp2(Object target) {
                this.target = target;
                Enhancer enhancer = new Enhancer();
                enhancer.setSuperclass(this.target.getClass());
// cglib创建的代理对象，其实就是继承了要代理的目标类，然后对目标类中所有非final方法进行覆盖，但在覆盖方法时会添加一些拦截代码。
                enhancer.setCallback(this); //注册回调器
                return enhancer.create();
        }
        @Override
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
                        throws Throwable {
                UserDaoImp2 udi = (UserDaoImp2) target;
                Object result = null;
                if (udi.getUsername() != null) {
                        // 前置通知
                        try {
                                result = methodProxy.invoke(target, args);
                                // 后置通知
                        } catch (Exception e) {
                                e.printStackTrace();
                                // 例外通知
                        } finally {
                                // 最终通知
                        }
                }
                return result;
        }
}
说明：注意注释的通知，通知就是拦截到方法后执行的一些代码，比如前置通知，就是说在回调目标方法时执行的一些操作。
步骤三、建立测试代码（省略，和五.2的测试代码相似）
4.aop理论知识
横切性关注点：对哪些方法拦截，拦截后怎么处理，这些关注就称之为横切性关注点
切面（aspect）：类是对物体特征的抽象，而切面是指对横切性关注点的抽象。
连接点（joinpoint）:被拦截到的点，因为spring只支持方法类型的连接点，所以在spring中连接点指的就是被拦截到的方法。实际上连接点还可以是字段或构造器。
切入点（pointcut）：对连接点进行拦截的定义。
通知（advice）：所谓通知就是指拦截到连接点之后的要执行的代码。通知分为前置、后置、异常、最终。环绕通知五类。
目标对象：代理的目标对象。
织入（weave）：将切面应用到目标对象并导致代理对象创建的过程
引入（introduction）：在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段。
5.基于spring的AOP实现
步骤一、导入spring开发 的基本包（包括切面及注解包）
步骤二、编写切面类TheInterceptor，代码如下：
package com.asm.dao.impl.factory;
@Aspect
public class TheInterceptor {
        @Pointcut("execution (* com.asm.dao.impl.UserDaoImp.*(..))")       
        // 声明一个切入点(第一个*后要留一个空格 )
        private void anyMethod() {
        }

        @Before("anyMethod()")// 前置通知
        public void before() {
                System.out.println("前置通知");
        }       
        @AfterReturning("anyMethod()")//后置通知
        public void afterReturning(){
                System.out.println("后置通知");
        }       
}
简析：Aspect注解声明此类为一个切面类，Pointcut注解用来声明一个切入点，括号中的参数是切入点的表达式，这里的表达式的意思是对 UserDaoImp类的所有方法进行拦截。关于切入点表达式后面会有详细的说明。anyMethod是为切入点起一个名字，后面的“通知”都要依赖这个 名字。
步骤三、beans.xml 配置文件 的内容如下：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. <beans xmlns="http://www.springframework.org/schema/beans"
   
3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
4.         xmlns:context="http://www.springframework.org/schema/context"
   
5.         xmlns:aop="http://www.springframework.org/schema/aop"
   
6.         xsi:schemaLocation="http://www.springframework.org/schema/beans            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   
7.            http://www.springframework.org/schema/context           http://www.springframework.org/schema/context/spring-context-2.5.xsd
   
8.            http://www.springframework.org/schema/aop           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
   
9.         <aop:aspectj-autoproxy /><!-- 开启切面编程功能 -->
   
10.         <bean id="userDaoImp" class="com.asm.dao.impl.UserDaoImp" />       
    
11. <bean id="theInterceptor"
    
12.                 class="com.asm.dao.impl.factory.TheInterceptor" />
    
13. </beans>

复制代码

说明：要想切面类起作用，首先要把切面类纳入spring容器管理。
步骤四、编写junit测试单元
        @Test
public void base() {
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");               
        // UserDaoImp udii=(UserDaoImp) ctx.getBean("userDaoImp");
        UserDao ud = (UserDao) ctx.getBean("userDaoImp");
        System.out.println(ud.getClass().getName());
        ud.save();
}
说明：由于开启了切面编程功能，所以当我们获取一个被切面类监控管理的bean对象—UserDaoImp时，它实际上获取的是此对象的一个代理对象，而 在spring中对代理对象的处理有如下原则：（1）如果要代理的对象实现了接口，则会按照Proxy的方式来产生代理对象，这即是说产生的代理对象只能 是接口类型，比如起用上面注掉的代码就会报错，而且通过下面的打印语句我们也可以看出产生的是一个代理对象。（2）要代理的对象未实现接口，则按 cglib方式来产生代理对象。  另还要注意：要想spring的切面技术起作用，被管理的bean对象只能是通过spring容器获取的对象。比如这 里如果直接new出UseDaoImp对象，则new出的对象是不能被spring的切面类监控管理。
补充：测试被代理对象未实现接口时，spring切面技术的应用。
步骤一、修改切面类TheInterceptor切入点为如下内容：
@Pointcut("execution (* com.asm.dao.impl.*.*(..))")       
说明：拦截impl包下的所有类所有方法
步骤二、在beans.xml中增加如下内容：
<bean id="userDaoImp2" class="com.asm.dao.impl.UserDaoImp2" />
步骤三、junit测试代码如下：
public void base2() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        UserDaoImp2 udi2 = (UserDaoImp2) ctx.getBean("userDaoImp2");
        System.out.println(udi2.getClass().getName());
        System.out.println(udi2.getClass().getSuperclass().getName());
        udi2.save();
}
说明：UseDaoImp2未实现任何接口，因此在spring中利用切面技术来管理此类使用的动态代理技术实质是cglib的动态代理方式，所以产生的代理对象实质是被代理对象的一个子类，通过上面的控制台打印语句可以看出。
小结 ： （1）声明aspect的切面类要纳入spring容器管理才能起作用。（2）被管理的bean实例要通过容器的getBeans方法获取。 （3）依据被管理的bean是否实现接口，spring采取两种方式来产生代理对象。（4）在xml文件中启用<aop:aspectj- autoproxy/>
6.通知应用实例（基于注解）
在前一节，我们应用了前置通知和后置通知，除了这两个通知外，下面接着演示其它通知的应用。
（1）最终通知
在切面类TheInterceptor中增加如下代码即可：略去测试。
@After("anyMethod()")// 最终通知
        public void after() {
        System.out.println("最终通知");
}
（2）异常通知
为了演示此实例，我们在UseDaoImp中增加如下代码以抛出异常：
int i=1/0;在然后在切面类TheInterceptor中增加如下代码：
@AfterThrowing("anyMethod()")        // 例外通知
public void AfterThrowing() {
        System.out.println("例外通知");
}
当获取代理对象并调用save方法时会抛出异常，例外通知便会得以执行。
（3）环绕通知
@Around("anyMethod()") //环绕通知
public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("进入环绕");
        //if(){        // 进行一些判断，再执行环绕
        Object result = pjp.proceed();
        //}
        System.out.println("退出环绕");
        return result;
}
注意的是方法的参数及抛出异常类型的固定写法（方法名可以是任意得），另在该方法中必须执行pjp.proceed()才能让环绕通知中的两处打印代码得 以执行。即是说要想环绕通知的拦截处理代码起作用必须调用pjp.proceed方法。 补充：环绕通知通常可以用来测试方法的执行时间 ，在pjp.proceed前获取一个时间，在pjp.proceed方法后再获取一个时间。最后两个时间相减即可得方法执行时间。
（4）传递参数给通知
首先在UseDao接口中增加如下代码：
String add(String name);
然后再在UserDaoImp中实现此方法，代码如下：
public String add(String name) {
        System.out.println("add method is called [ " + name+" ]");
        return "添加成功";
}
需求：获取调用add方法传递的参数。操作步骤如下：在切面类增加如下代码：
@Before("anyMethod() && args(name)")// 前置通知,只针对UseDaoImp的add方法
public void beforeAdd(String name) {
        System.out.println("前置通知:" + name);
}
说明：在前置通知的方法中有一个参数，然后再把此参数作为拦截条件（即是说拦截带有一个String类型参数的方法）。args的名字和beforeAdd方法参数名字相同。
测试代码：

1. public void advieeTest() {
   
2.         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
   
3.         UserDao ud=(UserDao) ctx.getBean("userDaoImp");
   
4.         ud.add("xxx");
   
5. }

复制代码

（5）获取方法的返回值
我们知道add方法有一个返回值，我们对此方法进行拦截并获取返回值，在切面类中增加如下代码：
@AfterReturning(pointcut = "anyMethod()", returning = "result")
// 后置通知,监听返回结果，针对UserDaoImp的getUsername()方法
public void afterReturningRes(String result) {
        System.out.println("后置通知,返回结果:" + result);
}
说明：afterReturningRes方法的参数就是要返回的参数类型，returning标记的就是的结果，它的取值与该方法参数名相同。  测试代码同（4）。
（6）获取抛出的异常
切面类的增加如下代码：
@AfterThrowing(pointcut="anyMethod",throwing="e")
public void catchException(Exception e){
        System.out.println("获取抛出的异常："+e);  
}
throwing的取值和方法的参数名相同，测试代码省略。
7. 通知应用实例（基于XML）
步骤一、复制TheInterceptorX类为TheInterceptorXML，并去掉所有注解。
步骤二、建立beansXML.xml配置文件，内容如下：

1. <aop:aspectj-autoproxy /><!-- 开启切面编程功能 -->
   
2. <bean id="userDaoImp" class="com.asm.dao.impl.UserDaoImp" />
   
3. <bean id="aspectBean"
   
4.         class="com.asm.dao.impl.factory.TheInterceptorXML" />
   
5. <aop:config>
   
6. <aop:aspect id="asp" ref="aspectBean">     --声明一个切面类
   
7.                 <aop:pointcut id="thecut"                 --声明一个切入点
   
8.                 expression="execution(* com.asm.dao.impl.UserDaoImp.*(..))" />
   
9.                 <aop:after-returning pointcut-ref="thecut" method="afterReturningRes" returning="result" />
   
10.                 <aop:around pointcut-ref="thecut" method="around"/>
    
11.                 <aop:after-throwing pointcut-ref="thecut" method="catchException" throwing="e"/>                                               
    
12.                 <aop:after pointcut-ref="thecut" method="after" />
    
13.                 <aop:before pointcut-ref="thecut" method="before" />
    
14.         </aop:aspect>
    
15. </aop:config>
    
16. 测试代码如下：
    
17. public void advieeTest() {
    
18.                 ApplicationContext ctx = new ClassPathXmlApplicationContext("beansXML.xml");
    
19.                 UserDao ud=(UserDao) ctx.getBean("userDaoImp");
    
20.                 ud.add("xxx");               
    
21. }

复制代码

未解决问题：不能成功传参给前置通知。
8.解析 切入点表达式
1.格式 ：execution(返回值 空格 方法选择 )。两部分组成，中间一定要有空格。
返回值：可以是*，说明拦截任何方法。Java.lang.String(全名)，拦截返回值为String类型的方法。 常用的实例如下：
方法选择：包名[类名].*（）。设定要拦截的方法签名。


9.总结
面向切面的常见应用（如权限 拦 截）、spring的aop依赖两种方式实现代理（依被代理的对象是否实现接口而定）、通知概念、基于注解与基于XML两种方式来配置切面、基本步骤（依 要拦截的方法来设定切入点，依据业务需求实现拦截通知代码，切面纳入spring容器管理，要被监控的类只能是通过Spring容器获取）、切入点的格 式。