AOP及AspectJ 实现AOP

AOP
概念
AOP（Aspect Oriented Programming），通常称为面向切面编程。它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。
代理
静态代理：
静态代理是指，在程序运行前，由程序员创建或特定工具自动生成源代码并对其编译生成.class文件。静态代理的实现只需要三步：首先，定义业务接口；其次，实现业务接口；然后，定义代理类并实现业务接口；最后便可通过客户端进行调用
缺点：
　　①、代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
②、如果接口增加一个方法，比如 UserService 增加修改 updateUser(）方法，则除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
动态代理：
动态代理是指，程序在整个运行过程中根本就不存在目标类的代理类，目标对象的代理 对象只是由代理生成工具（不是真实定义的类）在程序运行时由 JVM 根据反射等机制动态生成的。代理对象与目标对象的代理关系在程序运行时才确立。
动态代理分为：JDK动态代理和cglib动态代理
JDK动态代理
1、动态代理是实现InvocationHandler接口，通过构造器进行目标类和切面类的赋值，重写invoke方法，三个参数依次是目标类的加载器、目标类所有实现的接口、拦截器
2、JDK动态代理使用步骤
创建被代理的接口和类；
实现InvocationHandler接口，对目标接口中声明的所有方法进行统一处理；
调用Proxy的静态方法，创建代理类并生成相应的代理对象；
使用代理。
DK动态代理和cglib动态代理区别：
一、原理区别：
java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换
JDK 动态代理，要求是必须要实现接口。与之对应的另外一种动态代理实现模式 Cglib，则不需要。
如何强制使用CGLIB实现AOP？
（1）添加CGLIB库，SPRING_HOME/cglib/*.jar
（2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class=“true”/>
JDK动态代理和CGLIB字节码生成的区别？
（1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类
（2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法
因为是继承，所以该类或方法最好不要声明成final
Cglib动态代理（需要导入两个jar包，asm-5.2.jar,cglib-3.2.5.jar。版本自行选择）
Cglib动态代理，实现MethodInterceptor接口
对比
静态代理是指在程序运行前就已经定义好了目标类的代理类。代理类与目标类的代理关系在程序运行之前就确立了。
动态代理是指，程序在整个运行过程中根本就不存在目标类的代理类，目标对象的代理 对象只是由代理生成工具（不是真实定义的类）在程序运行时由 JVM 根据反射等机制动态生成的。代理对象与目标对象的代理关系在程序运行时才确立。
AOP 关键术语
1.target：目标类，需要被代理的类。例如：UserService
2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
3.PointCut 切入点：已经被增强的连接点。例如：addUser()。即调用的方法
4.advice 通知/增强，增强代码。例如：after、before
5. Weaving(织入)：是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
6.proxy 代理类：通知+切入点
7. Aspect(切面): 是切入点pointcut和通知advice的结合，不是一个类，是一个抽象概念
AOP 的通知类型
Spring按照通知Advice在目标类方法的连接点位置，可以分为5类
1、前置通知 org.springframework.aop.MethodBeforeAdvice
在目标方法执行前实施增强，比如上面例子的 before()方法
2、后置通知 org.springframework.aop.AfterReturningAdvice
在目标方法执行后实施增强，比如上面例子的 after()方法
3、环绕通知 org.aopalliance.intercept.MethodInterceptor
在目标方法执行前后实施增强
4、异常抛出通知 org.springframework.aop.ThrowsAdvice
在方法抛出异常后实施增强
5、引介通知 org.springframework.aop.IntroductionInterceptor
在目标类中添加一些新的方法和属性
使用 Spring AOP
springAOP 的具体加载步骤：
　　1、当 spring 容器启动的时候，加载了 spring 的配置文件
　　2、为配置文件中的所有 bean 创建对象
　　3、spring 容器会解析 aop:config 的配置
　　　1、解析切入点表达式，用切入点表达式和纳入 spring 容器中的 bean 做匹配。
如果匹配成功，则会为该 bean 创建代理对象，代理对象的方法=目标方法+通知。
如果匹配不成功，不会创建代理对象
　　4、在客户端利用 context.getBean() 获取对象时，如果该对象有代理对象，则返回代理对象；如果没有，则返回目标对象
说明：如果目标类没有实现接口，则 spring 容器会采用 cglib 的方式产生代理对象，如果实现了接口，则会采用 jdk 的方式
xml配置：

<bean id="usersService" class="com_zh.service.impl.UsersServiceImpl"/>
    <bean id="transtraion" class="com_zh.dao.MyTransaction"/>
    <aop:config>
        <aop:pointcut id="myPointCut" expression="execution(* com_zh.service.impl.*.*(..))"/>
        <aop:aspect ref="transtraion">
            <aop:before method="before" pointcut-ref="myPointCut"/>
            <aop:after method="after" pointcut-ref="myPointCut"/>
        </aop:aspect>
    </aop:config>

AspectJ 实现AOP
概念
AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，也可以说 AspectJ 是一个基于 Java 语言的 AOP 框架。通常我们在使用 Spring AOP 的时候，都会导入 AspectJ 的相关 jar 包。
切入点表达式

<aop:pointcut expression="execution(* com.ys.aop.*.*(..))" id="myPointCut"/>

execution：执行
第一个星：匹配任意的方法返回值
com.ys.aop.*表示aop包以及其子包
下一个星：所有方法
(…)：任意参数
如果切入点表达式有多个不同目录，可以通过 || 来表示或的关系。

<aop:pointcut expression="execution(* com.ys.*Service1.*(..)) ||
                          execution(* com.ys.*Service2.*(..))" id="myPointCut"/>

AOP 切入点表达式支持多种形式的定义规则：
1、execution:匹配方法的执行（常用）
execution(public .(…))
2.within:匹配包或子包中的方法(了解)
within(com.ys.aop…*)
3.this:匹配实现接口的代理对象中的方法(了解)
this(com.ys.aop.user.UserDAO)
4.target:匹配实现接口的目标对象中的方法(了解)
target(com.ys.aop.user.UserDAO)
5.args:匹配参数格式符合标准的方法(了解)
args(int,int)
6.bean(id) 对指定的bean所有的方法(了解)
bean(‘userServiceId’)
Aspect 通知类型
before:前置通知(应用：各种校验)
在方法执行前执行，如果通知抛出异常，阻止方法运行
afterReturning:后置通知(应用：常规数据处理)
方法正常返回后执行，如果方法中抛出异常，通知无法执行
必须在方法执行后才执行，所以可以获得方法的返回值。
around:环绕通知(应用：十分强大，可以做任何事情)
方法执行前后分别执行，可以阻止方法的执行
必须手动执行目标方法
afterThrowing:抛出异常通知(应用：包装异常信息)
方法抛出异常后执行，如果方法没有抛出异常，无法执行
after:最终通知(应用：清理现场)
方法执行完毕后执行，无论方法中是否出现异常
这里最重要的是around,环绕通知，它可以代替上面的任意通知。
AOP具体实例

①、创建接口

package com_zh.service;

import org.springframework.stereotype.Service;

@Service
public interface UsersService {
    int saveUsers();
    void deleteUsers();
}

②、创建实现类

package com_zh.service.impl;

import com_zh.dao.UsersDao;
import com_zh.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

public class UsersServiceImpl implements UsersService {


    @Override
    public int saveUsers() {

//        int i=10/0;测试异常打开
        System.out.println("添加成功");
        return 0;
    }

    @Override
    public void deleteUsers() {
        System.out.println("删除成功");
    }
}

③、创建切面类（包含各种通知）

package com_zh.dao;

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

public class MyAspect {
    public void myBefore(JoinPoint jp){
        System.out.println("前置通知："+jp.getSignature().getName());
    }

    public void myAfterReturning(JoinPoint jp,Object ret){
        System.out.println("后置通知 ： "+ jp.getSignature().getName() +" , -->"+ ret);
    }

    public void myAfterThrowing(JoinPoint jp,Throwable e){
        System.out.println("异常通知："+jp.getSignature().getName()+"---"+e.getMessage());
    }

    public Object myRound(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("前之通知");
        Object obj=pjp.proceed();
        System.out.println("后置通知");
        return obj;
    }

    public void myAfter(){
        System.out.println("最终通知");
    }
}

④、创建spring配置文件applicationContext.xml

 <bean id="usersServiceImpl" class="com_zh.service.impl.UsersServiceImpl"/>
    <bean id="myAspect" class="com_zh.dao.MyAspect"/>
    <aop:config>
        <aop:pointcut id="myPointCut" expression="execution(* com_zh.service.*.*(..))"/>
       <aop:aspect ref="myAspect">
           <aop:before method="myBefore" pointcut-ref="myPointCut"/>
           <aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret"/>
           <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
          <aop:around method="myRound" pointcut-ref="myPointCut"/>
           <aop:after method="myAfter" pointcut-ref="myPointCut"/>
       </aop:aspect>
    </aop:config>

⑤、测试

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext2.xml");
        UsersService us=(UsersService) ac.getBean("usersServiceImpl");
        us.saveUsers();
        us.deleteUsers();