Spring代理模式

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

Spring学习记录
02. Spring代理模式

---

提示：以下是本篇文章正文内容，下面案例可供参考

静态代理

1.创建一个抽象角色，如用户业务，抽象为增删改查：

public interface UserService {
    void add();
    void delete();
    void update();
    void select();
}

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 select() {
        System.out.println("查");
    }
}

3.若出现新的需求：在原有基础上增加日志功能
 则创建一个代理类来处理日志

public class UserServiceProxy implements UserService {
    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    public void log(String msg){
        System.out.println("执行了" + msg + "方法");
    }

    public void add() {
        log("add");
        userService.add();
    }

    public void delete() {
        log("delete");
        userService.delete();
    }

    public void update() {
        log("update");
        userService.update();
    }

    public void select() {
        log("select");
        userService.select();
    }
}

4.测试访问类：

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

动态代理

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！
可以编写一个通用的动态代理实现的类！所有的代理对象设置为Object即可！

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+"方法");
    }
}

测试方法：

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

动态代理的好处
静态代理有的它都有，静态代理没有的，它也有！

可以使得我们的真实角色更加纯粹，不再去关注一些公共的事情；
公共的业务由代理来完成，实现了业务的分工；
公共业务发生扩展时变得更加集中和方便；
一个动态代理，一般代理某一类业务；
一个动态代理可以代理多个类，代理的是接口！

---

总结