spring aop原理 InvocationHandler Proxy

2023年4月27日 270次阅读 来源: AOP

spring aop是基于spring IOC容器来管理以及使用了JDK自身的动态代理来实现，程序运行时在被切面前后动态进行的一些逻辑处理。

 

package com.daosheng.component;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * JDK动态代理的实现
 * 实现InvocationHandler接口，重写invoke方法
 * @author fanghb
 *
 */
public class LogIntercepter implements InvocationHandler{
    /**
     * 声明目标对象也就是被代理对象
     */
    private Object target;
    
    /**
     * 获得代理对象，
     * 这个代理对象是由传入的接口类型动态构造出来的一个代理类实例类型，
     * 这个代理类是JVM在内存中动态构造的动态类
     * 
     * tar.getClass().getClassLoader()    代理类加载器需和目标对象类加载器一致
     * tar.getClass().getInterfaces()     代理对象需实现目标对象所实现的接口
     * this                               调用此方法对象本身
     * @param tar                         被代理对象
     * @return
     */
    public Object getProxy(Object tar) {
        this.target = tar;
        Object proxy = Proxy.newProxyInstance(tar.getClass().getClassLoader(),
                tar.getClass().getInterfaces(), this);
        return proxy;
    }
    
    /**
     * 此方法在被代理对象的方法被调用之前触发，
     * 可以对被代理类方法调用的前后进行一些逻辑处理
     * 
     * @param proxy       代理对象
     * @param method      当前被调用的方法
     * @param args        当前被调用的方法参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = null;
        before(method);//被代理类方法调用前的逻辑处理
        try {
            result = method.invoke(target, args);//调用被代理类方法
        } catch (Exception e) {
            e.printStackTrace();
        }
        after(method);//被代理类方法调用后的逻辑处理
        return result;
    }
    
    /**
     * 被代理类方法调用前后的逻辑处理
     * 
     * @param m        当前被调用的方法
     */
    public void before(Method method) {//预处理
        System.out.println("织入预处理逻辑到" + method.getName() + "方法");
    }    
    public void after(Method method) {//后处理
        System.out.println("织入后处理逻辑到" + method.getName() + "方法");
    }

}

 测试：

 

 

package com.daosheng.service;  
  
import com.daosheng.component.LogIntercepter;  
import com.daosheng.pojo.User;  
import com.daosheng.service.impl.UserServiceImpl;  

//测试  
public class LogIntercepterTest {    
    public static void main(String[] args) {   
        LogIntercepter log = new LogIntercepter();  
        UserService proxy = (UserService) log.getProxy(new UserServiceImpl());  
        User user = new User();  
        proxy.saveUser(user);  
        System.out.println();  
        proxy.deleteUser(user);  
    }  
}

 输出：

 

织入预处理逻辑到saveUser方法  
user saved ...  
织入后处理逻辑到saveUser方法  
  
织入预处理逻辑到deleteUser方法  
user deleted ...  
织入后处理逻辑到deleteUser方法

 

    原文作者：AOP
    原文地址: https://blog.csdn.net/iteye_19683/article/details/82547749
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞