AOP的简单介绍

1.AOP简介

AOP面向切面编程，采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、安全检查、缓存）

SpringAOP使用纯java实现，不需要专门的编译过程和类加载器，在运行期间以代理方式织入增强代码

2.AOP底层原理

AOP底层原理：代理机制

动态代理：

特点：字节码就是随用随创建，随用随加载

作用：不修改源码的基础上对方法进行增强

分类：

基于接口的动态代理

基于子类的动态代理

Spring的代理分为两个：JDK动态代理和CGLib动态代理

JDK是必须实现接口才能产生代理对象，而CGLib可以对任何类生成代理

代理的原理是对目标对象进行继承代理，如果目标对象被final修饰，就无法使用CGlib代理

总而言之：在使用Spring框架时，如果类实现了接口就直接用JDK代理，如果没有实现接口就用CGlib代理

3.AOP术语

Joinpoint（连接点）： 这个连接点其实就是指得我们所用的方法，spring只支持方法类型的连接点

Pointcut（切入点）：切点就是对连接点的位置进行确定，然后再切点上添加增强代码

Advice（增强）：增强就是AOP再给一些特殊的连接点一些特殊的功能（如添加事务，和添加日志等）

Introduction(引介)：引介是通过一种特殊的通知在不修改代码的前提下，动态的添加代理的目标对象

Target(目标对象)：代理的目标对象

Weaving（织入）：是指增强应用到目标对象来创建新的代理对象的过程

Proxy（代理）：就是在一个类被AOP植入增强后，就产生一个结果代理类

Aspect（切面）：切入点和通知的结合

4.AOP代理使用

先导入一个依赖：
专门管AOP代理的依赖
    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.9.6version>
    dependency>
创建通知类
    前置方法(before)：目标方法运行之前调用
    后置通知(after-returning)：在运行方法运行之后调用
    环绕通知(around):在目标方法之前和之后都调用
    异常拦截(after-throwing):如果出现异常，就会调用
    最终通知(after):在目标方法调用之后调用（无论是否出现异常都会调用）

AOP代理依旧有两种方式：

配置文件的方式和注解的方式【注解的方式也需要在配置文件中配置aop:aspectj-autoproxy/aop:aspectj-autoproxy标签】

配置文件的方式，
<aop:pointcut expression="execution(* com.qf.service.*ServiceImpl.*(..))" id="pc"/>
    <aop:aspect ref="myAdvice" >
        
        <aop:before method="before" pointcut-ref="pc" />
        
        <aop:after-returning method="afterReturning" pointcut-ref="pc" />
        
        <aop:around method="around" pointcut-ref="pc" />
        
        <aop:after-throwing method="afterException" pointcut-ref="pc"/>
        
        <aop:after method="after" pointcut-ref="pc"/>
    aop:aspect>
aop:config>

注解方式是直接在方法前或者类前加上注解已完成配置文件的功能
 但是注解方式必须执行applicationcontext.xml文件配置Aop代理
//通知类
@Aspect
//表示该类是一个通知类
public class MyAdvice {
    //自己设置一个切点，管理重复代码
    @Pointcut("execution(* com.qf.service.*ServiceImpl.*(..))")
    public void pc(){}
    //前置通知
    //指定该方法是前置通知,并制定切入点
    @Before("MyAdvice.pc()")
    public void before(){
        System.out.println("这是前置通知!!");
    }
    //后置通知
    @AfterReturning("execution(* com.qf.service.*ServiceImpl.*(..))")
    public void afterReturning(){
        System.out.println("这是后置通知(如果出现异常不会调用)!!");
    }
    //环绕通知
    @Around("execution(* com.qf.service.*ServiceImpl.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("这是环绕通知之前的部分!!");
        Object proceed = pjp.proceed();//调用目标方法
        System.out.println("这是环绕通知之后的部分!!");
        return proceed;
    }
    //异常通知
    @AfterThrowing("execution(* com.qf.service.*ServiceImpl.*(..))")
    public void afterException(){
        System.out.println("出事啦!出现异常了!!");
    }
    //后置通知
    @After("execution(* com.qf.service.*ServiceImpl.*(..))")
    public void after(){
        System.out.println("这是后置通知(出现异常也会调用)!!");
    }
}

​
注解方式：   

    <bean name="userService" class="com.qf.service.UserServiceImpl" >bean>
    
    <bean name="myAdvice" class="com.qf.annotation_aop.MyAdvice" >bean>
    
    <aop:aspectj-autoproxy>aop:aspectj-autoproxy>