手动实现一个AOP

maven依赖：

		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.1</version>
        </dependency>

目标类：

public class UserService {

    public Object insert() {
        System.out.println("=====================插入成功=====================");
        //int i = 1/0;
        return "null";
    }
}

生成代理类：

public class ProxyFactory {
    //目标对象
    private Object target;

    //通知集合,把通知放到集合中
    private List<BaseAdvice> advices;
    public ProxyFactory() {
        advices = new ArrayList<BaseAdvice>();
        advices.add(new ThrowAdvice());
        advices.add(new AfterAdvice());
        advices.add(new AfterReturningAdvice());
        advices.add(new BeforeAdvice());
    }
	//创建代理对象
    public UserService getProxy(final Object target) {
        this.target = target;
        UserService userService = (UserService) Enhancer.create(target.getClass(), new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //通过调用链的方式，调用通知！
                Chain chain = new Chain(advices, method, args, target);
                chain.chainProceed();
                return null;
            }
        });
        return userService;
    }
}

执行链：Chain

public class Chain {
    //存放通知的集合
    private List<BaseAdvice> adviceList;

    private Method method; //目标方法
    private Object[] args; // 目标方法参数
    private Object target; // 目标对象
    public Chain(List<BaseAdvice> advices,Method method,Object[] args,Object target) {
        this.adviceList = advices;
        this.method = method;
        this.args = args;
        this.target = target;
    }
    //记录list下标
    public int index = -1;
    //遍历list,执行通知方法
    public Object chainProceed() throws Throwable {
        if (index == adviceList.size() - 1) {
            //执行我们的目标方法
            //所有通知都依次调用完成，才会进入到这个if
            //通过反射调用目标方法
            return method.invoke(target,args);
        }
        return adviceList.get(++index).execute(this);//调用通知方法
    }
}

通知：

public class BeforeAdvice extends BaseAdvice{
    @Override
    public Object execute(Chain chain) throws Throwable {
        //前置通知执行方法
        System.out.println("前置通知~");
        //如果chain链中还有通知，就继续调用
        chain.chainProceed();
        return null;
    }
}
public class AfterReturningAdvice extends BaseAdvice {
    @Override
    public Object execute(Chain chain) throws Throwable {

        Object o = chain.chainProceed();
        //如果上面执行没有报异常，执行后置通知
        System.out.println("后置通知~");
        return null;
    }
}
public class AfterAdvice extends BaseAdvice{
    @Override
    public Object execute(Chain chain) throws Throwable {
        try {
            return chain.chainProceed();
        }finally {
            System.out.println("最终通知~");
        }
    }
}
public class ThrowAdvice extends BaseAdvice{
    @Override
    public Object execute(Chain chain) throws Throwable {
        try {
            return chain.chainProceed();
        } catch (Throwable ex) {
            System.out.println("异常通知~");
            throw ex;
        }
    }
}

测试：

public class Main {
    public static void main(String[] args) throws Throwable {

        UserService proxyUserService = new ProxyFactory().getProxy(new UserService());
        proxyUserService.insert();
    }
}