自己实现AOP，AOP实现的步骤分解

一、需求：

　　自己实现AOP：1.0版本：在某个方法上加"@InOutLog"注解，那么执行到该方法时，方法的前面、后面会输出日志信息。

　　【自己实现AOP 2.0版本（实现Spring的有前置通知、后置通知、返回通知等各种通知的AOP）：https://www.cnblogs.com/laipimei/p/11163377.html】

二、思路整理：

　　1.涉及的角色：

　　　　①被代理类；

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

　　　　③代理类；

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

　　　　⑤注解类（注解在方法上）；

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

　　2.实现步骤：

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

　　　　（2）创建一个“动态代理类”，并把“被代理类的实例”传给该代理类；在该动态代理类的invoke()方法中，实现日志的输出，也是在该invoke()方法中调用、执行真正的代理类要执行的那个方法。

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

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

三、代码实现：

被代理类的接口：

package MyIOCAndMyAop.bean;

public interface Subject {

    void test();

}

被代理类：

 1 package MyIOCAndMyAop.bean;

 2

 3 import MyIOCAndMyAop.Annotations.InOutLog;

 4 import MyIOCAndMyAop.Annotations.MyAutowired;

 5 import MyIOCAndMyAop.Annotations.MyComponent;

 6

 7 /**

 8  * 被代理类

 9  */

10 @MyComponent

11 public class Person implements Subject{

12

13     @MyAutowired

14     private Student student;

15

16     @InOutLog

17     public void test(){

18         System.out.println(this + ".test() : " + student);

19     }

20 }

InOutLog注解类：

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 InOutLog {

}

动态代理类：

public class MyInvocationHandler2 implements InvocationHandler{

    private Object object;//被代理类

    private Object invoke;

    public void setObject(Object object) {

        this.object = object;

    }

    /**

     *  在BeanFactory中，方法上有@InOutLog注解，则生成动态代理方法

     */

    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //这里做判断，看是否需要做下面的输出

        Boolean bool = false;

        //！！！注意，要用被代理类的对象去判断其method方法上是否有@InOutLog注解，而不是用入参method对象（该method对象是被代理类的接口的）

        //怎么处理入参的类型：见MyAOP2.这里没有做入参处理，可能会报方法找不到异常，注意！！！

        Method declaredMethod = object.getClass().getDeclaredMethod(method.getName());

        if(null != declaredMethod.getAnnotation(InOutLog.class)) {

            System.out.println("我是日志输出~~~start~~~");

            bool = true;

        }

        invoke = method.invoke(object, args);

        //这里做判断，同上

        if(bool) {

            System.out.println("我是日志输出~~~end~~~");

            System.out.println("------------------------------------------------------------------------------");

        }

        return invoke;

    }

}

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

public class MyProxy2 {

    /**

     * 动态的创建一个代理类的对象

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

     *     class A implements Subject{

     *         private Handler  handler;

     *         public void test() {

     *             //获得到当前方法名

     *             handler.invoke();

     *         }

     *     }

     */

    public static Object getProxyInstance(Object obj) {

        MyInvocationHandler2 handler = new MyInvocationHandler2();

        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 MyAOP2 {

    public static void main(String[] args) {

        /**

         * 使用步骤：

         * ① 給指定类的某个方法加@InOutLog注解；

         * ② 通过BeanFactory或的该类的实例；

         * ③ 执行bean.method()；

         * 效果：method()方法的前后有了log的输出。

         */

        String completeClassName = "MyIOCAndMyAop.bean.Person";

        Object bean = MyIOC.getBean(completeClassName);

        Subject person = (Subject)bean;

        person.test();

    }

    static {

        init();

    }

    public static void init() {

        updateBeanFromBeanFactory();

    }

    /**

     * 扫描BeanFactory，找出方法上有@InOutLog注解的bean，为其创建代理类对象，并替代原bean。

     */

    public static void updateBeanFromBeanFactory() {

        for(Map.Entry<String, Object> entry : MyIOC.getBeanFactory().entrySet()) {

            for(Method method : entry.getValue().getClass().getDeclaredMethods()) {

                if(null != method.getAnnotation(InOutLog.class)) {

                    MyProxy2.updateBean(entry.getKey(), entry.getValue());

                }

            }

        }

    }

}

巴特西

自己实现AOP，AOP实现的步骤分解

最新文章

热门文章