Spring学习4：代理

Posted 2021-09-03 Z|Star

什么是代理

代理，可以和房产中介进行类比。
通过中介，买房者无需直接联系房东，中介和房东通过共同的目的（租房）进行相连。

共同的目的就是 接口。

代理的好处

通过代理，能够在不改变原来的代码的情况下，实现了对原有功能的增强。

静态代理

通过一个小例子来理解一下静态代理。

1. 创建一个抽象角色（接口），实现增删改查。

//抽象角色：增删改查业务
public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

2. 创建一个真实对象来完成这些增删改查操作。

//真实对象，完成增删改查操作的人
public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }
    public void delete() {
        System.out.println("删除了一个用户");
    }
    public void update() {
        System.out.println("更新了一个用户");
    }
    public void query() {
        System.out.println("查询了一个用户");
    }
}

3. 新的需求，需要在原有的基础上，增加日志功能。创建一个代理：

//代理角色，在这里面增加日志的实现
public class UserServiceProxy implements UserService {
    private UserServiceImpl userService;
    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }
    public void add() {
        log("add");
        userService.add();
    }
    public void delete() {
        log("delete");
        userService.delete();
    }
    public void update() {
        log("update");
        userService.update();
    }
    public void query() {
        log("query");
        userService.query();
    }
    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

代码分析：原先的代码UserServiceImpl通过UserService接口实现事件处理。现在的代理UserServiceProxy同样调用UserService接口，将UserServiceImpl实例化，并覆写了接口的方法。

4. 测试访问类：

public class Client {
    public static void main(String[] args) {
        //真实业务
        UserServiceImpl userService = new UserServiceImpl();
        //代理类
        UserServiceProxy proxy = new UserServiceProxy();
        //使用代理类实现日志功能！
        proxy.setUserService(userService);
        proxy.add();
    }
}

5. 输出结果
   

动态代理

还是通过上面的例子来理解动态代理，保持第1，2步不变。

3. 编写一个通用的动态代理实现的类

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

public class ProxyInvocationHandler implements InvocationHandler {
   private Object target;
   public void setTarget(Object target) {
       this.target = target;
   }
   //生成代理类
   public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),
               target.getClass().getInterfaces(),this);
   }
   // proxy : 代理类
   // method : 代理类的调用处理程序的方法对象.
   public Object invoke(Object proxy, Method method, Object[] args) throws
           Throwable {
       log(method.getName());
       Object result = method.invoke(target, args);
       return result;
   }
   public void log(String methodName){
       System.out.println("执行了"+methodName+"方法");
   }
}

4. 测试

public class Test {
    public static void main(String[] args) {
        //真实对象
        UserServiceImpl userService = new UserServiceImpl();
        //代理对象的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService); //设置要代理的对象
        UserService proxy = (UserService)pih.getProxy(); //动态生成代理类！
        proxy.add();
    }
}

5. 输出结果
   

总结

1. 在静态代理中，我们在每个方法里都写了一个 log(“method”)。如果方法很多，使用起来就非常麻烦，而动态代理则通过反射（method.getName()）来获得method，使用起来更为灵活方便。
2. 静态代理有的动态代理都有，静态代理没有的，动态代理也有！
3. 一个动态代理 , 一般代理某一类业务。
4. 一个动态代理 , 一般代理某一类业务。
5. 动态代理理解起来比静态代理稍微复杂一些，底层原理这里暂不探究。