Spring AOP学习笔记(五)-代理模式与JDK动态代理模式

最新推荐文章于 2024-02-23 17:57:41 发布

markliwei1

最新推荐文章于 2024-02-23 17:57:41 发布

阅读量232

点赞数

分类专栏： Spring框架学习

本文链接：https://blog.csdn.net/makeliwei1/article/details/81456678

版权

Spring框架学习专栏收录该内容

14 篇文章 0 订阅

订阅专栏

一、代理模式

1.1、定义

为一个对象提供一个替身或者是占位符以达到控制这个对象的访问

1.2、模式中角色分析

角色	描述
Subject	是一个抽象接口，为ProxySubject和RealSubject提供了接口。ProxySubject和RealSubject实现同一个接口，那么ProxySubject就在RealSubject出现的地方取代它(实现同一个接口的两个类可以互为替代吗?只要我们实现类中不添加自己特有的方法，那么我们可以使用父类对象引用子类对象)
RealSubject	是真正做事的对象，它是被ProxySubject代理和控制访问的
ProxySubject	ProxySubject持有RealSubject对象的引用，也可能负责创建和销毁RealSubject。客户和RealSubject的交互都必须经过ProxySubject，因为ProxySubject和RealSubject都实现同一个接口，所以任何使用到RealSubject的地方都可以用ProxySubject实现

1.3、代码示意

public interface RedWine {
    public void sale();
}

public class RedWineFactory implements RedWine{
    public void sale(){
        System.out.println("由RedWineFactory直销");
    }
}


public class RedWineProxy implements RedWine{
    private RedWineFactory redWineFactory;

    public RedWineProxy(RedWineFactory redWineFactory){
        this.redWineFactory =redWineFactory;
    }
    @Override
    public void sale() {
        System.out.println("RedWineProxy 调用了RedWineFactory");
        redWineFactory.sale();
    }
}

public class Test {
    public static void main(String[] args){
        RedWine redWine = new RedWineProxy(new RedWineFactory());
        redWine.sale();
    }
}


输出结果
RedWineProxy 调用了RedWineFactory
由RedWineFactory直销

三、JDK动态代理模式

在JDK中有两个用于动态代理的类和接口，一个是Proxy这个类，另一个就是InvokeHandler接口。Proxy类主要是可以实现返回一个类的代理实例，二InvokeHandler主要是用来和代理实例相关联，当我们调用代理实例的方法时，我们的方法会自动根据参数名和方法名去调用相应的方法，同时我们还可以在方法调用前后中添加一个额外的操作，这样就达到了代理的方式。我们为什么说这是一个动态的呢，这是因为我们可以不用为每个类都写一个代理类，我们把代理的类的操作交给JVM去做，每个类只要调用Proxy.newProxyInstance(….)这个方法就可以返回一个代理类。同时我们将方法调用可以分割开来，对于我们具体需要的功能，只要把实现方式放到实现了InvocationHandler接口的invoke(….)方法中就可以了。

3.1、Proxy.newProxyInstance(..)

该方法是一个静态的方法我们可以通过类名Proxy来调用方法得到一个代理类

类(接口)	返回参数	方法名
Proxy	static Object	newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

参数	解释
loader	表示我们实际类的类加载器，可以通过RealSubject.getClass().getClassLoader()获得
interfaces	表示我们RealSubject实现的接口，我们可以通过RealSubject.getClass().getInterfaces()得到
h	与RealSubject相关联的一个实现InvocationHandler接口的类

3.2、InvocationHandler.invoke(..)

类(接口)	返回参数	方法名
InvocationHandler	Object	invoke(Object proxy, Method method, Object[] args)

参数解析

参数	解释
proxy	代理对象
method	当我们调用方法时，会自动获得RealSubject的具体的Method对象
Object[] args	我们需要调用方法的参数列表，这里采用数组的方式

3.3、实现一个动态代理

这里我们可以实现一个前置通知，让UserServiceImpl实现IUserService这个接口，当我们调用UserServiceImpl的方法时是调用代理类实例的方法。当我们调用代理类实例的方法时，内部调用流程是先调用我们invoke()方法，然后invoke方法中通过反射的方式去调用实际的UserServiceImpl方法。

public interface Subject {
    public void login(String username,String password);
}

public class RealSubject implements Subject {
    @Override
    public void login(String username, String password) {
        System.out.println("用户登录成功");
    }
}

第一步：实现InvokeHandler接口

package DesignPattern.ProxyPattern.Project2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class BeforeAdvice implements InvocationHandler{
    private Object object;
    public BeforeAdvice(Object object){
        this.object = object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args){
        try{
            System.out.println("前置通知");
            method.invoke(this.object,args);
        }catch(Throwable e){
            e.printStackTrace();
        }
        return null;
    }
}

第二步：去获取代理类实例，同样我们将这个方法设置成静态并放置在BeforeAdvice内

    public static Object newInstance(Object object){
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),
                object.getClass().getInterfaces(), new BeforeAdvice(object));
    }

测试

public class Test {
    public static void main(String[] args){
        RealSubject realSubject = new RealSubject();
        Subject subject = (Subject) BeforeAdvice.newInstance(realSubject);
        subject.login("mark","47q");
    }
}
/**输出:
 * 前置通知
 * 用户登录成功
 * /