简单写一个AOP的例子,帮助理解SpringAOP里面的概念

抛开AOP的概念，自己实现AOP，帮助理解

1、定义一个简单的接口HelloService

package com.hy.diyAOP;

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

2、HelloService的实现类HelloServiceImpl

package com.hy.diyAOP;

import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

@Service
public class HelloServiceImpl implements HelloService {

    @Override
    public void sayHello(String name) {
        if(StringUtils.isEmpty(name)){
            throw new RuntimeException("parameter is null");
        }
        System.out.println("hello!"+name);
    }
}

3、定义一个拦截器接口

package com.hy.diyAOP;

import java.lang.reflect.InvocationTargetException;

public interface Interceptor {
    //事前方法
    public void before();

    //事后方法
    public void after();

    /**
     * 增强后的方法
     * @param invocation 会调参数，可以通过它的proceed方法，回调原方法
     * @return 原方法的返回值
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    public Object around(Invocation invocation) throws InvocationTargetException,IllegalAccessException;

    //没有发生异常时执行
    public void afterReturning();

    //发生异常时执行
    public void afterThrowing();

    //是否使用增强后的方法替代原方法
    boolean userAround();
}

4、编写拦截器接口的实现类

package com.hy.diyAOP;

import java.lang.reflect.InvocationTargetException;

public class MyInterceptor implements Interceptor {
    @Override
    public void before() {
        System.out.println("before...................");
    }

    @Override
    public void after() {
        System.out.println("after......................");
    }

    @Override
    public Object around(Invocation invocation) throws InvocationTargetException, IllegalAccessException {
        System.out.println("aroundBefore......................");
        Object obj = invocation.proceed();
        System.out.println("aroundAfter......................");
        return obj;
    }

    @Override
    public void afterReturning() {
        System.out.println("afterReturning.................");
    }

    @Override
    public void afterThrowing() {
        System.out.println("afterThrowing..................");
    }

    @Override
    public boolean userAround() {
        return true;
    }
}

5、拦截器接口中的Invocation类

package com.hy.diyAOP;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

@Data
public class Invocation {
    private Object target;
    private Method method;
    private Object[] params;

    public Invocation(Object target, Method method, Object[] params) {
        this.params = params;
        this.method = method;
        this.target = target;
    }

    public Object proceed() throws InvocationTargetException,IllegalAccessException {
        return method.invoke(target,params);
    }

6、定义一个ProxyBean实现InvocationHandler接口，invoke()方法就是被增强后的方法

package com.hy.diyAOP;

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

public class ProxyBean implements InvocationHandler {

    private Object target = null;

    private Interceptor interceptor = null;

    public static Object getProxyBean(Object target,Interceptor interceptor){
        ProxyBean proxyBean = new ProxyBean();
        proxyBean.target = target;
        proxyBean.interceptor = interceptor;

        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), proxyBean);
        return proxy;

    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //异常标识
        boolean exceptionFlag = false;
        Invocation invocation = new Invocation(target, method, args);
        Object retObj = null;
        try{
            if(this.interceptor.userAround()){
                retObj = this.interceptor.around(invocation);
            }else {
                this.interceptor.before();
                retObj = method.invoke(target,args);
                this.interceptor.after();
            }
        }catch (Exception e){
            exceptionFlag = true;
        }
        if(exceptionFlag) {
            this.interceptor.afterThrowing();
        }else{
            this.interceptor.afterReturning();
            return retObj;
        }
        return null;
    }
}

7、测试一下

    @Test
    public  void test() {
        HelloService helloService = new HelloServiceImpl();
        HelloService proxy = (HelloService) ProxyBean.getProxyBean(helloService,new MyInterceptor());
        proxy.sayHello("张三");
    }

总结一下，ProxyBean实现了接口InvocationHandler，重写了invoke方法。在getBean方法中，创建了一个代理对象，并且创建了一个ProxyBean实例保存目标对象（target）和拦截器（interceptor），为后面的调用做好了准备，这个代理对象挂在target实现的接口之下，所以你可以用target对象实现的接口对这个代理对象实现强制转换，并且将这个代理对象的逻辑挂在ProxyBean实例之下，这样就完成了目标对象（target）和代理对象（proxy）的绑定。通过调用getBean()方法获取到这个代理对象，当我们使用它调用方法时，就会进入到ProxyBean的invoke方法里了。