Spring-代理模式

目录​​​​​​​

前言

代理模式

代理模式的定义

代理模式的分类：

静态代理

代码实现

加深理解：给原有业务添加操作日志记录

AOP工作机制

动态代理

动态代理的好

---

前言

为什么要学习代理模式？因为这就是SpringAOP的底层！为了更好的进行后面的学习，所以这里重点学习一下【SpringAOP和SpringMVC】

代理模式

代理模式的定义

代理模式：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

代理模式实例：房东需要出租房子，但是房东不想自己的发布消息也不想带你看房，所以房东找了一个中介帮她做这些事，她自己只需要签合同就可以了，我们租房子的时候也是先联系中介，确认房子没问题后，才由中介联系房东签合同完成租房

代理模式是代理的一类事情，在Java中表现为某一接口：interface

代理模式的分类：

• 静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。
• 动态代理：在程序运行时，运用反射机制动态创建而成。

静态代理

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决（出租）
• 真实角色：被代理的角色（房东）
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作（中介）
• 客户：访问代理对象的人！（租客）

代码实现

接口（出租）

public interface Rent {
    void rent();
}

真是角色（房东）

public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("我是房东，我需要出租房子");
    }
}

代理角色（中介）

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    //当前代理对象也可以出租房子
    public void rent() {
        seeHouse();
        host.rent();
        sign();
        fee();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带着看房子！");
    }

    //签合同
    public void sign(){
        System.out.println("和中介签署租赁合同！");
    }

    //收费用
    public void fee() {
        System.out.println("中介收取费用！");
    }
}

租客找中介租房

public class Client {
    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
//        host.rent();

        //代理，中介帮房东出租房子，并且代理角色一般会有一些附属操作！
        Proxy proxy = new Proxy(host);

        //不用面对房东，直接找中介租房即可！
        proxy.rent();
    }
}

只需要面对中介就可以完成租房，由中介去联系房东

静态代理的优点：

• 可以使真实角色（房东）的操作更加纯粹！不用去关注一些公共业务（看房）
• 公共业务（看房）就交给代理角色！实现了业务的分工！
• 公共业务（看房）发生扩展的时候，方便集中管理！

缺点：

• 一个真实角色（房东）就会产生一个代理角色（中介），代码量会翻倍，开发效率会变低~

加深理解：给原有业务添加操作日志记录

具体业务

//具体业务
public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

真实角色，直接操作具体的业务

//真实角色
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("查询了一个用户！");
    }
}

代理角色，通过调用真实角色实现添加日志操作

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("[Debug] 使用了一个"+msg+"方法");
    }
}

客户端访问代理角色

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();

        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);

        proxy.delete();
    }
}

在修改原有代码的情况下增加了日志操作

AOP工作机制

动态代理

动态代理的特点：

• 动态代理和静态代理角色一样
• 动态代理的代理类（中介）是动态生成的，不是我们直接写好的！
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
  • 基于接口 ：JDK动态代理【我们在这里使用】
  • 基于类：cglib
  • java字节码实现：javassist

需要了解两个类：

• Proxy：代理（动态生成代理类：中介）
• InvocationHandler：调用处理程序（中介需要它告诉房东可以租房了）

动态代理工作结构：

代码步骤：

接口（事件）

public interface Rent {
    public void rent();
}

真实角色（房东）

public class Host implements Rent{
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

ProxyInvocationHandler类

//我们会用这个类，自动生成代理类！
public class ProxyInvocationHandler {

    private Object rent;

    public void setRent(Object rent) {
        this.rent = rent;
    }

    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("我是invoke方法");
                return method.invoke(rent, args);
            }
        });
    }

}

这里对上面内容进行解释说明：

指定需要代理的事情（租房）

    private Object rent;

    public void setRent(Object rent) {
        this.rent = rent;
    }

 生成代理对象（中介）

 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces, InvocationHandler h)参数说明：

• ClassLoader loader：指定哪个类加载器负责加载代理类

• Class<?>[] interfaces：动态代理类需要实现的接口

• InvocationHandler h：重写invoke(Object proxy, Method method, Object[] args)方法调用处理程序

invoke(Object proxy, Method method, Object[] args)参数说明：

• Object proxy：获取当前的代理对象（中介）
• Method method：调用的方法（租房）
• Object[] args：调用方法的参数

method.invoke(rent, args)方法及参数说明：

• method：代理对象（中介实际调用的方法）
• invoke(rent, args)方法为反射方法，调用rent（房东）对象的method方法，调用方法的参数是args

    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{Rent.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("我是中介");
                return method.invoke(rent, args);
            }
        });
    }

测试

public static void main(String[] args) {
        //房东
        Rent host = new Host();
        //找中介公司
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //告诉中介公司需要出租业务
        pih.setRent(host);
        //中介公司介绍中介
        Rent proxy = (Rent) pih.getProxy();
        //中介可以进行出租业务
        proxy.rent();
    }

通过中介完成出租

动态代理的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务！
• 公共业务就交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理！
• 一个动态代理类代理的是一个接口，一般就是对应的一类业务！
• 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！