什么是Spring的AOP功能

1、什么是AOP?

AOP(Aspect-Oriented Programming:面向切面编程)：是指将那些与业务无关，却被多个业务模块所共同调用逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，提升系统的可维护性。

2、AOP的实现有哪两种方式？

AOP实现的关键在于代理模式，主要有两种实现方式，分别是AspectJ AOP和Spring AOP。

3、Spring AOP 和 AspectJ AOP 有什么区别？

AspectJ AOP使用的是静态代理方式，也称为编译时增强，AOP框架会在编译阶段生成AOP代理类，并将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的AOP对象。

Spring AOP使用的是动态代理方式，也就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候Spring AOP会使用 Cglib 生成一个被代理对象的子类来作为代理。

另外，Spring AOP 也已经集成了AspectJ 。

AspectJ 相比于 Spring AOP 功能更加强大，性能更好，但是 Spring AOP 相对来说使用更简单。

4、Spring AOP里面的几个名词的概念

（1）连接点（Join point）：指程序运行过程中所执行的方法。在Spring AOP中，一个连接点总代表一个方法的执行。 

（2）切面（Aspect）：被抽取出来的公共模块，可以用来横切多个对象。Aspect切面可以看成 Pointcut切点 和 Advice通知 的结合，一个切面可以由多个切点和通知组成。在Spring AOP中，切面可以在类上使用 @AspectJ 注解来实现。

（3）切点（Pointcut）：切点用于定义 要对哪些Join point进行拦截。

切点分为execution方式和annotation方式。execution方式可以用路径表达式指定对哪些方法拦截，比如指定拦截add*、search*。annotation方式可以指定被哪些注解修饰的代码进行拦截。

（4）通知（Advice）：指要在连接点（Join Point）上执行的动作，即增强的逻辑，比如权限校验和、日志记录等。通知有各种类型，包括Around、Before、After、After returning、After throwing。

（5）目标对象（Target）：包含连接点的对象，也称作被通知（Advice）的对象。 由于Spring AOP是通过动态代理实现的，所以这个对象永远是一个代理对象。

（6）织入（Weaving）：通过动态代理，在目标对象（Target）的方法（即连接点Join point）中执行增强逻辑（Advice）的过程。

整个流程串联起来就是，通过切点(Pointcut)的表达式或者注解的定义，找到相应的连接点(Joinpoint)即目标对象中(Target)的某个方法，将相应的通知(Advice)织入(Weaving)到这些连接点(Joinpoint)处。

切点和通知组成了切面，连接点其实就是连接的切点和通知。

5、Spring通知（Advice）有哪些类型？

（1）前置通知（Before Advice）：在连接点（Join point）之前执行的通知。

（2）后置通知（After Advice）：当连接点退出的时候执行的通知（不论是正常返回还是异常退出）。 

（3）环绕通知（Around Advice）：包围一个连接点的通知，这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也可以选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

（4）返回后通知（AfterReturning Advice）：在连接点正常完成后执行的通知（如果连接点抛出异常，则不执行）

（5）抛出异常后通知（AfterThrowing advice）：在方法抛出异常退出时执行的通知

所有通知的执行顺序如下：

同一个Aspect，不同advice的执行顺序：

（1）没有异常情况下的执行顺序：

     around before advice
→ before advice 
→ target method 执行
→ around after advice
→ after advice
→ afterReturning

（2）有异常情况下的执行顺序：

     around before advice
→ before advice
→ target method 执行
→ around after advice
→ after advice
→ afterThrowing
→ java.lang.RuntimeException: 异常发生

接口实现方案
1）首先编写我们的业务接口（StudentInfoService.java）：

public interface StudentInfoService{
    void findInfo(String studentName);
}
及其实现类（StudentInfoServiceImpl.java）：

public class StudentInfoServiceImpl implements StudentInfoService{
    public void findInfo(String name){
        System.out.println("你目前输入的名字是:"+name);
    }
}
2）现在我们需要一个日志功能，在findInfo行为之前执行并记录其行为，那么我们就首先要拦截该行为。在实际执行的过程中用一个代理类来替我们完成。Java中为我们提供了实现动态代理类的方案：

1'处理拦截目的的类（MyHandler.java）

import org.apache.log4j.Logger;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Method;
public class MyHandler implements InvocationHandler{
    private Object proxyObj;
    private static Logger log=Logger.getLogger(MyHandler.class);
    public Object bind(Object obj){
        this.proxyObj=obj;
 return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
}
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
    Object result=null;
    try{
        //请在这里插入代码，在方法前调用
        ("调用log日志方法"+method.getName());
        result=method.invoke(proxyObj,args); //原方法
        //请在这里插入代码，方法后调用
    }catch(Exception e){
        e.printStackTrace();
    }
    return result;
    }
}

2'我们实现一个工厂，为了方便我们使用该拦截类(AOPFactory.java)：

public class AOPFactory{
    private static Object getClassInstance(String clzName){
        Object obj=null;
        try{
            Class cls=Class.forName(clzName);
            obj=(Object)cls.newInstance();
        }catch(ClassNotFoundException cnfe){
            System.out.println("ClassNotFoundException:"+cnfe.getMessage());
        }catch(Exception e){
            e.printStackTrace();
        }
        return obj;
    }
    public static Object getAOPProxyedObject(String clzName){
        Object proxy=null;
        MyHandler handler=new MyHandler();
        Object obj=getClassInstance(clzName);
        if(obj!=null) {
            proxy=handler.bind(obj);
        }else{
            System.out.println("Can't get the proxyobj");
            //throw
        }
        return proxy;
    }
}

3)基本的拦截与其工厂我们都实现了，现在测试（ClientTest.java）：

public class ClientTest{
    public static void main(String[] args){
    StudentInfoService studentInfo= (StudentInfoService)AOPFactory.getAOPProxyedObject("StudentInfoServiceImpl");
    studentInfo.findInfo("阿飞");
    }
}
 

输出结果（看你的log4j设置）：

调用log日志方法findInfo

你目前输入的名字是:阿飞

这样我们需要的效果就出来了，业务处理自己在进行，但是我们实现了日志功能，而业务处理(StudentInfoService)根本不知道存在该行为的。但是Java中提供的动态代理类的实现是针对实现了某些接口的类，如果没有实现接口的话，不能创建代理类，看以上部分：

return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
看到了没有？obj.getClass().getInterfaces()要求实现了某些接口。以下提供哪些没有实现接口的实现方案：

子类实现方案
首先，请上网下CGLib的包。设置好classpath路径，CGLib与java标准库提供的实现方案不同，cglib主要是基于实现类（如StudentInfoServiceImpl.java)扩展一个子类来实现。与Dynamic Proxy中的Proxy和InvocationHandler相对应，net.sf.cglib.proxy.Enhancer和MethodInterceptor在CGLib中负责完成代理对象创建和方法截获处理,产生的是目标类的子类而不是通过接口来实现方法拦截的，Enhancer主要是用于构造动态代理子类来实现拦截，MethodInterceptor（扩展了Callback接口）主要用于实现around advice（AOP中的概念）：

1）我们的业务处理（StudentInfoServiceImpl.java）：

public class StudentInfoServiceImpl{
    public void findInfo(String name){
    System.out.println("你目前输入的名字是:"+name);
    }
}
2）实行一个工具来处理日志功能（AOPInstrumenter.java）：

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
import org.apache.log4j.Logger;
public class AOPInstrumenter implements MethodInterceptor{
    private Logger log=Logger.getLogger(AOPInstrumenter.class);
    private Enhancer enhancer=new Enhancer();
    public Object getInstrumentedClass(Class clz){
        enhancer.setSuperclass(clz);
        enhancer.setCallback(this);
        return enhancer.create();
}
    public Object intercept(Object o,Method method,Object[] args,MethodProxy proxy) throws Throwable{
    ("调用日志方法"+method.getName());
    Object result=proxy.invokeSuper(o,args);
    return result;
    }
}

3）我们来测试一下（AOPTest.java）：

public class AOPTest{
    public static void main(String[] args){
        AOPInstrumenter instrumenter=new AOPInstrumenter();
        StudentInfoServiceImpl studentInfo=(StudentInfoServiceImpl)instrumenter.getInstrumentedClass(StudentInfoServiceImpl.class);
        studentInfo.findInfo("阿飞");
    }
}
输出结果与以上相同。

CGLib中为实现以上目的，主要提供的类

1)Enhancer：setCallback(Callback) ,setSuperclass(Class) ,create()返回动态子类Object

2)MethodInterceptor必须实现的接口：intercept(Object,Method,Object[],MethodProxy)返回的是原方法调用的结果。和Proxy原理一样。

AOP基本概念
1）aspect（切面）：实现了cross-cutting功能，是针对切面的模块。最常见的是logging模块，这样，程序按功能被分为好几层，如果按传统的继承的话，商业模型继承日志模块的话根本没有什么意义，而通过创建一个logging切面就可以使用AOP来实现相同的功能了。

2）jointpoint（连接点）：连接点是切面插入应用程序的地方，该点能被方法调用，而且也会被抛出意外。连接点是应用程序提供给切面插入的地方，可以添加新的方法。比如以上我们的切点可以认为是findInfo(String)方法。

3）advice（处理逻辑）：advice是我们切面功能的实现，它通知程序新的行为。如在logging里，logging advice包括logging的实现代码，比如像写r日志到一个文件中。advice在jointpoint处插入到应用程序中。以上我们在MyHandler.java中实现了advice的功能

4）pointcut（切点）：pointcut可以控制你把哪些advice应用于jointpoint上去，通常你使用pointcuts通过正则表达式来把明显的名字和模式进行匹配应用。决定了那个jointpoint会获得通知。

5）introduction：允许添加新的方法和属性到类中。

6）target（目标类）：是指那些将使用advice的类，一般是指独立的那些商务模型。比如以上的StudentInfoServiceImpl.

7)proxy（代理类）：使用了proxy的模式。是指应用了advice的对象，看起来和target对象很相似。

8）weaving(插入）：是指应用aspects到一个target对象创建proxy对象的过程：complie time，classload time，runtime