1. AOP基础概念
2. JDK的动态代理和CGLib
3. Spring的AOP
4. 增强类 Advice
5. 切点类 PointCut
6. 切面类 Advisor

AOP基础概念

1. 连接点 Joinpoint, 这个名词指的是程序执行的特定位置. Spring只支持方法的连接点, 也就是指某个方法调用前, 方法调用后, 方法抛出异常, 方法调用前+后这几个点.
2. 切点, Pointcut, 这个东西我终于理解了, 实际上就是连接点的容器, 里边可以只放一个连接点, 也可以放多个连接点. 你说这个容器有什么用, 其实是给后边的增强一起来结合成实际的AOP内容. 如果不使用切点封装一下连接点, 如果在多个连接点需要插入, 就需要一个一个连接点的插入过去. 有了切点, 就可以选好一批连接点包装到一个切点里, 然后一次性结合进去, 其实就是操作单个数据和操作集合的区别.
3. 增强, Advice, 话说这个词真的抽象, 学英语的时候这个词都是建议, 忠告的意思. 这里的意思就是额外干什么事情. 增强实际上要和方位搭配使用, 否则这段代码插入到哪里呢. 比如切点定位了一个方法. 然后使用在方法前的增强, 结果就是在执行这个方法前, 先执行增强中的代码.
4. 目标对象, Target, 这个指的是目标类, 注意是目标类, 由于Spring只支持方法的连接点, 所以你可以认为连接点就是目标方法, 而target 是目标类.
5. 织入, Weaving, 这个词语我当时就觉得实在是绝妙, 书作者也说用的棒. 这就是把你前边辛苦写的代码, 按照找准的切点给写到目标对象里去的过程. 一般有三种, 动态代理, 类装载的时候修改, 和编译时候修改. Spring采用动态代理, AspectJ支持后两者. 动态代理的特点是织入快, 运行慢, 后边两者是反过来的.
6. 引介, Introduction, 这个看上去就是来来来给你介绍一个新的东西. 如果说连接点至少是本来类里有的地方, 你给织入新玩意了, 这个引介就是给你加上原来没有的东西, 比如属性, 甚至实现接口. 你写的类本来没实现某个接口, 可以动态的让这个类实现接口, 确实刺激.
7. 代理, Proxy, 这个一想便知, 你实际用的类, 肯定就不是原来你自己写的类了, 至少也是原来的类的类型或者是一个子类, 保证可以正常运行.
8. 切面, Aspect, 切点加上增强和(或)引介, 就是一个切面, 也可以理解为实际能够发挥作用的对象, 单有切点, 单有增强和引介, 都没法发挥作用, 必须结合起来. 硬要类比的话, 好比心脏搭支架, 切点等于说:在哪个地方搭? 增强等于说:用进口的还是国产的. 想要手术成功(成功实施切面), 这两个都得先定下来, 才能正常进行. AOP的核心就是一句话: 实施切面.

JDK的动态代理和CGLib

public interface StandardService {
    public void service(int number);
}

import java.util.Random;

public class StandardServiceImpl implements StandardService {

    @Override
    public void service(int number) {
        System.out.println("给" + number + "号顾客服务");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            System.out.println("服务被中断");
        }
    }
}

import java.util.Random;

public class StandardServiceImpl implements StandardService {

    @Override
    public void service(int number) {

        long start =(System.currentTimeMillis());

        System.out.println("给" + number + "号顾客服务");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            System.out.println("服务被中断");
        }

        long end = System.currentTimeMillis();
        System.out.println("程序执行的时间是" + (end - start));
    }

    public static void main(String[] args) {

        StandardService service1 = new StandardServiceImpl();
        service1.service(10);
        service1.service(20);

    }
}

public class StandardServiceImplMonitorProxy implements StandardService {

    private StandardService RealService = new StandardServiceImpl();

    @Override
    public void service(int number) {

        long start =(System.currentTimeMillis());

        RealService.service(number);

        long end = System.currentTimeMillis();
        System.out.println("程序执行的时间是" + (end - start));
    }

    public static void main(String[] args) {

        StandardService service1 = new StandardServiceImpl();
        service1.service(10);
        service1.service(20);

        StandardService service2 = new StandardServiceImplMonitorProxy();
        service2.service(10);
        service2.service(20);
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class PerformanceHandler implements InvocationHandler {

    //把目标业务类弄进来
    private Object target;

    public PerformanceHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //跟直接编写代理类很类似, 只不过方法和参数会由反射传进来
        long start = System.currentTimeMillis();

        Object result = method.invoke(target, args);

        long end = System.currentTimeMillis();

        System.out.println("程序执行的时间是" + (end - start));

        return result;
    }
}

import java.lang.reflect.Proxy;

public class Main {

    public static void main(String[] args) {

        //创建业务类
        StandardService service = new StandardServiceImpl();

        //创建方法处理器, 把目标对象传递给了方法处理器, 说明就是要对你这个业务对象里的方法动手了
        PerformanceHandler performanceHandler = new PerformanceHandler(service);

        //创建代理类, Proxy类需要知道你这个类的加载器, 类的接口有什么, 然后就是自己编写的方法处理器
        StandardService proxy = (StandardService) Proxy.newProxyInstance(service.getClass().getClassLoader(),
                service.getClass().getInterfaces(), performanceHandler);

        proxy.service(10);
        proxy.service(20);

    }
}

1. 只能代理接口, 从Proxy静态方法的参数里就能看出来, 要用到类加载器, 还有实现的接口, 以及处理器, 这说明后台肯定是用这几个玩意加载出来了一个代理类. 你如果在StandardServiceImpl自己扩展了其他方法, 用Proxy死活也没法代理.
2. 不能指定方法, 如果你给接口再添两个方法, 只想对其中一个方法进行测试, 你按照上边的代码使用代理类, 所以方法依然都会被事件处理器给代理了, 灵活程度不够.

Spring的AOP

1. 先看增强类, 增强类由于不附带切点信息, 只有方位, 因此和JDK代理很像, 只要你给上了增强, 所有方法全都给你代理了, 只不过更加精确的区分出了方法前后等方位.
2. 再看切点类, 切点类实际上就是更精确了, 你想匹配哪个类, 哪个方法都可以
3. 最后看切面类, 切面类就是切点(可以没有)和增强的组合了, 一个切面类设计好以后就可以发挥作用了.

增强类 Advice

1. 创建被代理的对象
2. 创建增强类(在之前是创建方法处理器)
3. 使用一个Proxy类似的类来生成代理对象
4. 使用代理对象

前置增强

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class GreetingBefore implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        int number = (int) args[0];
        System.out.println("欢迎" + number + "号顾客体验服务");
    }
}

public static void main(String[] args) {

    StandardService service1 = new StandardServiceImpl();

    MethodBeforeAdvice advice = new GreetingBefore();

    //创建一个ProxyFactory工厂
    ProxyFactory proxyFactory = new ProxyFactory();

    //很像建造者模式, 传入目标对象, 传入增强对象, 然后得到一个代理对象
    proxyFactory.setTarget(service1);

    proxyFactory.addAdvice(advice);

    StandardService service1proxy = (StandardService) proxyFactory.getProxy();

    //使用原版对象
    service1.service(10);
    //使用代理对象
    service1proxy.service(10);

}

<!--定义Advice的Bean-->
<bean class="test.aop.springadvice.GreetingBefore" id="greetingBefore"/>
<!--    定义目标类-->
<bean id="target" class="test.aop.jdkrawproxy.StandardServiceImpl"/>

<bean id="targetproxy" class="org.springframework.aop.framework.ProxyFactoryBean"
      p:proxyInterfaces="test.aop.jdkrawproxy.StandardService"
      p:interceptorNames="greetingBefore"
      p:target-ref="target"/>

后置增强

public class GreetingAfter implements AfterReturningAdvice {

    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        int number = (int) args[0];
        System.out.println("再见" + number + "号顾客, 欢迎您再来!");
    }
}

AfterReturningAdvice advice2 = new GreetingAfter();
proxyFactory.addAdvice(advice2);

环绕增强

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class SurrondAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        //MethodInvocation相对于包裹着要执行的方法的对象
        //可以从中获取参数
        Object[] args = invocation.getArguments();

        int number = (int) args[0];

        System.out.println("环绕之前的欢迎" + number + "号顾客");

        //执行实际的方法
        Object result = invocation.proceed();

        System.out.println("环绕之后的欢迎" + number + "号顾客");

        return result;
    }
}

MethodInterceptor surround = new SurrondAdvice();
proxyFactory.addAdvice(surround);

异常抛出增强

public class ExceptionAdvice implements ThrowsAdvice {

     public void afterThrowing(Method method, Object[] args, Object target, Throwable throwable) throws Throwable {
        System.out.println("抛出异常了.");
    }
}

切点类 PointCut

1. org.springframework.aop.support.StaticMethodMatcherPointcut是静态方法切点的基类, 默认匹配所有类
2. org.springframework.aop.support.DynamicMethodMatcherPointcut是动态方法切点的基类, 默认匹配所有类
3. org.springframework.aop.support.annotation.AnnotationMatchingPointcut是支持在Bean中使用注解切点的类
4. org.springframework.aop.support.ExpressionPointcut, 这是个接口, 是为了支持AspectJ表达式语法定义的接口
5. org.springframework.aop.support.ControlFlowPointcut, 这是一个控制切点, 是通过程序执行堆栈信息来查看是否执行了某个方法.
6. org.springframework.aop.support.ComposablePointcut, 这是将两个切点对象复合起来的类, 用于实现复杂的切点条件.

切面类 Advisor

StaticMethodMathcerPointcutAdvisor

public default void service2(int number) {
        System.out.println("向" + number + "号顾客提供默认服务");
    }

import org.springframework.aop.ClassFilter;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.StaticMethodMatcherPointcutAdvisor;
import test.aop.jdkrawproxy.StandardService;
import test.aop.jdkrawproxy.StandardServiceImpl;
import test.aop.springadvice.GreetingBefore;

import java.lang.reflect.Method;

public class ServiceOnlyAdvisor extends StaticMethodMatcherPointcutAdvisor {


    //类过滤, 必须是StandardService的实现类才可以
    @Override
    public ClassFilter getClassFilter() {
        return new ClassFilter() {
            @Override
            public boolean matches(Class<?> clazz) {
                return StandardService.class.isAssignableFrom(clazz);
            }
        };
    }

    //这个内部是利用了切点的方法, 判断方法名称是否等于service
    @Override
    public boolean matches(Method method, Class<?> targetClass) {
        return method.getName().equals("service");
    }

    public static void main(String[] args) {
        //目标对象
        StandardService service1 = new StandardServiceImpl();
        //切面
        StaticMethodMatcherPointcutAdvisor advisor = new ServiceOnlyAdvisor();
        //原来的前置增强
        MethodBeforeAdvice advice = new GreetingBefore();

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(service1);
        proxyFactory.setInterfaces(service1.getClass().getInterfaces());

        proxyFactory.addAdvice(advice);
        //添加advisor而不是advice
        proxyFactory.addAdvisor(advisor);

        StandardService service1proxy = (StandardService) proxyFactory.getProxy();

        service1proxy.service(10);

    }

}