面向切面编程AOP-CSDN博客

背景：

AOP（Aspect-Oriented Programming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。简单地说，AOP就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。

实现原理：

AOP 代理其实是由 AOP 框架动态生成的一个对象，该对象可作为目标对象使用。AOP 代理包含了目标对象的全部方法，但 AOP 代理中的方法与目标对象的方法存在差异：AOP 方法在特定切入点添加了增强处理，并回调了目标对象的方法。纵观 AOP 编程，其中需要程序员参与的只有 3 个部分：定义普通业务组件。定义切入点，一个切入点可能横切多个业务组件。定义增强处理，增强处理就是在 AOP 框架为普通业务组件织入的处理动作。
以上三部分重点就是定义切入点和增强处理，不难发现Spring AOP的实现原理就是：AOP 框架负责动态地生成 AOP 代理类，这个代理类的方法则由 Advice 和回调目标对象的方法所组成。

从历史到现代

写死代码

我们每研究一个技术，总是会从最简单，最常用的例子开始，下面看看这个例子：
接口：

package com.service;

public interface Greeting {
    void sayHello(String name);
}

实现类：

package com.serviceImp;

import com.service.Greeting;

public class GreetingImpl implements Greeting {

    @Override
    public void sayHello(String name) {
        before();
        after();
    }
    private void before(){
        System.out.print("Before");;
    }
    private void after(){
        System.out.println("After");
    }
}

before() 与 after() 方法写死在 sayHello() 方法体中了，这样的代码的味道非常不好。如果哪位仁兄大量写了这样的代码，肯定要被你的架构师骂个够呛。

比如：我们要统计每个方法的执行时间，以对性能作出评估，那是不是要在每个方法的一头一尾都做点手脚呢？

再比如：我们要写一个 JDBC 程序，那是不是也要在方法的开头去连接数据库，方法的末尾去关闭数据库连接呢？

这样的代码只会把程序员累死，把架构师气死！

一定要想办法对上面的代码进行重构，首先给出三个解决方案：

静态代理：

在上面的基础上添加代理类：

package com.serviceImp;

import com.service.Greeting;

public class GreetingProxy implements Greeting {

    private GreetingImpl greetingImpl;

    public GreetingProxy(GreetingImpl greetingImpl){
        this.greetingImpl=greetingImpl;
    }
    @Override
    public void sayHello(String name) {
        before();
        greetingImpl.sayHello(name);
        after();

    }
    private void before(){
        System.out.println("Before");
    }
    private void after(){
        System.out.println("After");
    }

}

客户端调用：

import com.service.Greeting;
import com.serviceImp.GreetingImpl;
import com.serviceImp.GreetingProxy;


public class Client {

    public static void main(String[] args) {
        Greeting greetingProxy=new GreetingProxy(new GreetingImpl());
        greetingProxy.sayHello("jack");
    }

}

问题：
但是如果这样没增加一个类就增加一个代理类，岂不是有n个类等着我们去添加呢？可不可以用一个代理类呢？于是我们想到了jdk动态代理

jdk动态代理：

package com.jdkProxy;

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

public class JDKDynamicProxy implements InvocationHandler{

    private Object target;

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

    @SuppressWarnings("unchecked")
    public <T>T getProxy(){
        return(T)Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        before();
        Object result=method.invoke(target, args);
        after();
        return result;
    }
    private void before(){
        System.out.println("Before");
    }
    private void after(){
        System.out.println("After");
    }

}

客户端：

import com.jdkProxy.JDKDynamicProxy;
import com.service.Greeting;
import com.serviceImp.GreetingImpl;
import com.serviceImp.GreetingProxy;


public class Client {

    public static void main(String[] args) {
        Greeting greetingProxy=new JDKDynamicProxy(new GreetingImpl()).getClass();
        greetingProxy.sayHello("jack");
    }

}

问题：jdk代理只能代理有接口的，因此可以说，如果要用jdk动态代理的，我们所有的类都必须有接口，但是在实际中并不是这样的，因此我们引用了另一种方式：CGLib动态代理

CGLib动态代理

package com.CGLibProxy;

import java.lang.reflect.Method;


import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGLibDynamicProxy implements MethodInterceptor{

    private static CGLibDynamicProxy instance=new CGLibDynamicProxy();
    private CGLibDynamicProxy(){

    }
    public static CGLibDynamicProxy getInstance(){
        return instance;
    }
    @SuppressWarnings("unchecked")
    public <T>T getProxy(Class<T> cls){
        return (T) Enhancer.create(cls,this);
    }
    @Override
    public Object intercept(Object target, Method method, Object[] arg2,
            MethodProxy proxy) throws Throwable {
        before();
        Object result=proxy.invokeSuper(target, arg2);
        after();
        return result;
    }
    private void before(){
        System.out.println("Before");
    }
    private void after(){
        System.out.println("After");
    }

}

客户端调用：

import com.CGLibProxy.CGLibDynamicProxy;
import com.jdkProxy.JDKDynamicProxy;
import com.service.Greeting;
import com.serviceImp.GreetingImpl;
import com.serviceImp.GreetingProxy;


public class Client {

    public static void main(String[] args) {
        Greeting greetingProxy=CGLibDynamicProxy.getInstance().getProxy(GreetingImpl.class);
        greetingProxy.sayHello("jack");
    }

}