仿照Spring自己实现有各种通知的AOP，AOP实现的步骤分解

一、需求：

　　自己实现AOP 2.0：实现Spring AOP，有环绕通知、前置通知、后置通知、返回通知、异常通知等。
　　　　已实现：①通过动态代理+通知的注解类，实现了前置通知、后置通知等各种通知；②切点（在需要通知的方法上加注解）；③切面（同②）；
　　　　未实现：①通知的格式没写成可配置的； ②切点、切面没抽取成一个更方便配置的切面类；③其他。

　　【自己实现AOP 1.0版本（简易版）：https://www.cnblogs.com/laipimei/p/11137250.html】

二、思路整理：

　　1.涉及的角色：

　　　　①被代理类；

　　　　②被代理类要实现的接口；

　　　　③代理类；

　　　　④动态创建“代理类的对象”的类；

　　　　⑤注解类：

　　　　　　a. 切面注解类，注解在类上：
　　　　　　　　@Aspect
　　　　　　b. 各种通知注解，注解在方法上：
　　　　　　　　@Before
　　　　　　　　@AfterReturning
　　　　　　　　@After
　　　　　　　　@AfterThrowing
　　　　　　　　@Around

　　　　⑥IOC容器：BeanFactory（自己实现IOC容器：https://www.cnblogs.com/laipimei/p/11205510.html）。

　　2.实现步骤：

　　　　（1）被代理类、被代理类的接口、通知的注解类的创建；

　　　　（2）创建一个“动态代理类”，并把“被代理类的实例”传给该代理类；在该动态代理类的invoke()方法中，实现前置通知、后置通知等各种通知，也是在该invoke()方法中调用、执行真正的代理类要执行的那个方法。

　　　　（3）创建一个可以动态创建“代理类的实例”的类，通过该类的getProxyInstance(Object obj)方法可以得到一个动态代理类的实例。
　　　　（4）给方法加通知注解，该方法的实例须已交由IOC容器管理的；
　　　　（5）遍历BeanFactory，找出方法上有@通知注解的bean，为这些bean生成代理类对象（步骤：MyProxy3.getProxyInstance(Object obj)）

　　　　（6）用代理类的实例去替代BeanFactory中的被代理类的实例

三、代码实现：

被代理类的接口：

 public interface SuperMan {
     int add(int a, int b);
     int divide(int a, int b);
 }

被代理类：

 package MyIOCAndMyAop.bean;

 import MyIOCAndMyAop.Annotations.After;
 import MyIOCAndMyAop.Annotations.AfterReturning;
 import MyIOCAndMyAop.Annotations.AfterThrowing;
 import MyIOCAndMyAop.Annotations.Around;
 import MyIOCAndMyAop.Annotations.Aspect;
 import MyIOCAndMyAop.Annotations.Before;
 import MyIOCAndMyAop.Annotations.MyComponent;

 @Aspect//切面注解类，加了该注解就表示被注解的类的实例需要做动态代理。
 @MyComponent//自定义注解类，有该注解就表示被注解类交由自定义IOC容器管理了。
 public class Student implements SuperMan {

     @After
     @AfterReturning
     @Before
     @AfterThrowing
     @Override
     public int add(int a, int b) {
         System.out.println("--> a + b = " + (a + b));
         return a + b;
     }

     @Around
     @Override
     public int divide(int a, int b) {
         return a/b;
     }
 }

注解类：

 package MyIOCAndMyAop.Annotations;

 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

 /**
  * 扫描BeanFactory，找出方法上有@Aspect注解的bean，为其创建代理类对象，并替代原bean。
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Aspect {

 }

 package MyIOCAndMyAop.Annotations;

 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

 /**
  * 前置通知  */
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface After {

 }

 package MyIOCAndMyAop.Annotations;

 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

 /**
  * 返回通知（方法正常执行完，才执行的通知）
  */
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface AfterReturning {

 }

package MyIOCAndMyAop.Annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 后置通知
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Before {

}

package MyIOCAndMyAop.Annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 异常通知
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AfterThrowing {

}

package MyIOCAndMyAop.Annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 环绕通知：around==>并不常用，但功能最强大。
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Around {

}

动态代理类：

 class MyInvocationHandler3 implements InvocationHandler {
     private Object object;// 被代理类
     private Object invoke;

     public void setObject(Object object) {
         this.object = object;
     }

     /**
      * 动态代理：实现了环绕通知、前置通知、后置通知等通知。
      */
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         // 入参的类型的处理，返回被代理对象真正要执行的那个方法：
         Method declaredMethod = handleArgs(method);

         // 环绕通知：
         Boolean bool = false;
         if (null != declaredMethod.getAnnotation(MyIOCAndMyAop.Annotations.Around.class)) {
             bool = true;
         }
         aroundInform(declaredMethod, bool, method, args);

         // 前置通知、后置通知、返回通知、异常通知等：
         try {
             if (null != declaredMethod.getAnnotation(MyIOCAndMyAop.Annotations.Before.class)) {
                 System.out.println(declaredMethod.getName() + " begings with : " + declaredMethod.getParameters());
             }

             //通过放射，真正执行被代理对象的方法：
             invoke = method.invoke(object, args);

             if (null != declaredMethod.getAnnotation(MyIOCAndMyAop.Annotations.AfterReturning.class)) {
                 System.out.println(declaredMethod.getName() + "  ends with : " + invoke);
             }
         } catch (Exception e) {
             if (null != declaredMethod.getAnnotation(MyIOCAndMyAop.Annotations.AfterThrowing.class)) {
                 System.out.println(declaredMethod.getName() + " occurs exception : " + e);
             }
         } finally {
             if (null != declaredMethod.getAnnotation(MyIOCAndMyAop.Annotations.After.class)) {
                 System.out.println(declaredMethod.getName() + " ends.");
             }
         }
         return invoke;
     }

     /**
      * 入参的类型的处理，这个方法很重要。
      *        * @return 被代理对象真正要执行的那个方法
      * @param method 被代理对象的接口中声明的被代理方法
      * @throws NoSuchMethodException
      * @throws SecurityException
      */
     public Method handleArgs(Method method) throws NoSuchMethodException, SecurityException {
         Class<?>[] parameterTypes = method.getParameterTypes();
         switch (parameterTypes.length) {
         case 1:
             System.out.println("parameterTypes.length = 1 : " + parameterTypes[0]);
             return object.getClass().getDeclaredMethod(method.getName(), parameterTypes[0]);
         case 2:
             System.out.println("parameterTypes.length = 2 : " + parameterTypes[0] + " ; " + parameterTypes[1]);
             return object.getClass().getDeclaredMethod(method.getName(), parameterTypes[0], parameterTypes[1]);
         case 3:
             System.out.println("parameterTypes.length = 3 : " + parameterTypes[0] + " ; " + parameterTypes[1] + " ; "
                     + parameterTypes[2]);
             return object.getClass().getDeclaredMethod(method.getName(), parameterTypes[0], parameterTypes[1],
                     parameterTypes[2]);
         default:
             System.out.println("parameterTypes.length = 0 : " + parameterTypes.length);
             return object.getClass().getDeclaredMethod(method.getName());
         }
     }

     /**
      * 环绕通知
      *
      * @param declaredMethod 被代理对象的被代理方法
      * @param bool
      * @param method         被代理对象的接口中声明的被代理方法
      * @param args           被代理方法的声明的入参
      */
     private void aroundInform(Method declaredMethod, Boolean bool, Method method, Object[] args) {
         if (bool) {
             try {
                 System.out.println(declaredMethod.getName() + " begings with : " + declaredMethod.getParameters());
                 invoke = method.invoke(object, args);
                 System.out.println(declaredMethod.getName() + "  ends with : " + invoke);
             } catch (Exception e) {
                 System.out.println(declaredMethod.getName() + " occurs exception : " + e);
             } finally {
                 System.out.println(declaredMethod.getName() + " ends.");
             }
         }
     }
 }

动态创建“代理类的对象”的类：

class MyProxy3 {

    /**
     * 动态的创建一个代理类的对象.
     *
     * MyProxy动态创建的“代理类的对象”：
     *     class A implements Subject{
     *         private    Handler handler;
     *         public void test() {
     *             //获得到当前方法名:
     *              handler.invoke();
     *         }
     *     }
     */
    public static Object getProxyInstance(Object obj) {
        MyInvocationHandler3 handler = new MyInvocationHandler3();
        handler.setObject(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }

    /**
     * 对于有@InOutLog注解的，用代理类的bean来替代BeanFactory中的被代理类的bean。
     * 这一步很重要，因为当执行到bean.method()，执行的就一定是bean对应的method()方法，
     * 如果此时没有用代理类对象去替换，那么执行的就是没有InOutLog的原来的那个方法。
     */
    public static void updateBean(String completeClassName, Object object) {
        MyIOC.updateBeanFromBeanFactory(completeClassName, getProxyInstance(object));// (全类名，代理类的bean)
    }
}

①扫描BeanFactory，找出方法上有@InOutLog注解的bean，为其创建代理类对象，并替代原bean。②使用测试：

public class MyAOP3 {
    public static void main(String[] args) {
        String completeClassName1 = "MyIOCAndMyAop.bean.Student";
        Object bean = MyIOC.getBean(completeClassName1);
        SuperMan superMan = (SuperMan) bean;
        superMan.add(2, 3);
        superMan.divide(10, 5);
    }

    static {
        init();
    }

    public static void init() {
        updateBeanFromBeanFactory();
    }

    /**
     * 扫描BeanFactory，找出方法上有@Aspect注解的bean，为其创建代理类对象，并替代原bean。
     */
    public static void updateBeanFromBeanFactory() {
        for (Map.Entry<String, Object> entry : MyIOC.getBeanFactory().entrySet()) {
            if (null != entry.getValue().getClass().getDeclaredAnnotation(Aspect.class)) {
                MyProxy3.updateBean(entry.getKey(), entry.getValue());
            }
        }
    }
}