自己实现简易版AOP,含AOP实现的步骤分解

2019-08-16 09:48:11来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

自己实现简易版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());
                }
            }
        }
    }
}

 


原文链接:https://www.cnblogs.com/laipimei/p/11137250.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Redis的HelloWorld

下一篇:Java:synchronized关键字引出的多种锁