10、代理模式

为什么要学习代理模式?
因为这就是SpringAOP的底层
面试必问: [SpringAOP 和 SpringMVC]
​

代理模式的分类:
①静态代理
②动态代理

10.1、静态代理

角色分析:
①抽象角色 : 一般会使用接口或者抽象类来解决
②真实角色 : 被代理的角色
③代理角色 : 代理真实角色 , 代理真实角色后, 我们一般会做一些附属操作
④客户 : 访问代理对象的人
​

代码步骤:
①接口

public interface Rent {
    public void rent();
}

②真实角色

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

③代理角色

//代理角色(中介)
public class Proxy {
    private Host host;//组合的方式

    public Proxy() {
    }

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

    //租房
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        fare();
    }

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

    //签租赁合同
    public void hetong() {
        System.out.println("中介跟你签合同");
    }

    //收中介费
    public void fare() {
        System.out.println("收中介费");
    }
}

④客户端访问代理角色

//租房的顾客
public class Client {
    public static void main(String[] args) {

        //代理, 帮房东租房子,但有一些附属操作
        Proxy proxy = new Proxy(new Host());

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

​

  静态代理的好处:<br />①可以与真实角色的操作更加纯粹! 不用去关注一些公共的业务<br />②公共业务交给了代理角色! **实现了业务的分工!**<br />③公共业务发生扩展时, 方便集中管理!<br />​

静态代理的缺点:
一个真实的角色就会产生一个代理角色; 代码量会翻倍_{开发效率变低}
​

10.2、加深理解

聊聊AOP
①接口

public interface UserService {
    public void add();

    public void delete();

    public void update();

    public void query();
}

②真实角色

//真实对象
public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("增");
    }

    @Override
    public void delete() {
        System.out.println("删");
    }

    @Override
    public void update() {
        System.out.println("改");
    }

    @Override
    public void query() {
        System.out.println("查");
    }
}

③代理角色

//代理角色(需要增加一个log功能)
public class UserServiceProxy implements UserService {
    private UserServiceImpl userService;

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

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

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

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

    @Override
    public void query() {
        log("query");
        userService.query();
    }

    //日志方法
    public void log(String msg) {
        System.out.println("使用了" + msg + "方法");
    }
}

④客户端访问代理角色

//找代理办事
public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();

        UserServiceProxy proxy = new UserServiceProxy();

        proxy.setUserService(userService);
        proxy.add();
    }
}

工作中更改原代码是大忌
​

10.3、动态代理

动态代理与静态代理角色一样
动态代理的代理类是动态生成的, 不是我们直接写的;
动态代理分为两大类 : 基于接口的动态代理, 基于类的动态代理
基于接口 — JDK动态代理**[我们在这里使用]**
基于类 : cglib
java字节码实现 : javasist
​

需要了解两个类 😗* Proxy**(代理) InvocationHandler(调节处理程序)
​

步骤:Spring-08-proxy\src\main\java\com\demo03
①代理的事件接口

//租房这个需要代理的事件
public interface Rent {
    public void rent();
}

②真实角色(需要代理的类), 有三个

//房东(真实对象)
public class Host implements Rent {
    public void rent() {
        System.out.println("房东身伤易逝要出租房子! ");
    }
}



public class Host1 implements Rent{
    @Override
    public void rent() {
        System.out.println("房东情伤难合要出租房子! ");
    }
}



public class Host2 implements Rent{
    @Override
    public void rent() {
        System.out.println("房东身伤易愈要出租房子! ");
    }
}

③InvocationHandler(用于用于自动生成代理类(Proxy))

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

//这个类用于自动生成代理类(Proxy)
//代理角色的发夹操作也在这里实现seeHouse
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Rent rent;

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

    //生成得到代理类
    public Object getProxy() {
        //三个参数:
        //①一个类加载器(一般是本类来处理)
        //②被代理的接口加载器
        //③InvocationHandler (因为本类继承了InvocationHandler所以传this就可以了)
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
    }

    //处理代理借口实例并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //附加操作
        seeHouse();

        //动态代理的本质就是使用反射机制实现![使用了set进入的host(真实角色)的Rent方法(要实现的进口方法)]
        Object re = method.invoke(rent, args);
        return re;
    }

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

}

④Client:

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        Host1 host1 = new Host1();
        Host2 host2 = new Host2();

        //代理角色 : 目前没有, 这里创建了可以动态生成代理角色类的ProxyInvocationHandler类
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        //传入需要代理的真实角色(host)需要继承代理事件的接口(Rent)
        pih.setRent(host1);

        //生成代理角色类(动态就体现在这里)
        Rent proxy = (Rent) pih.getProxy();

        //执行代理事件(代理接口)
        proxy.rent();
    }
}

​

InvocationHandler提取成工具类:(Spring-08-proxy\src\main\java\com\demo04)

package com.demo04;

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

//等会用这个类, 自动生成代理类(Proxy)
//代理角色的发夹操作也在这里实现seeHouse
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成得到代理类
    public Object getProxy() {
        //三个参数:
        //①一个类加载器(一般是本类来处理)
        //②被代理的接口加载器
        //③InvocationHandler (因为本类继承了InvocationHandler所以传this就可以了)
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    //处理代理接口的方法并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //附加操作
        log(method.getName());

        //动态代理的本质就是使用反射机制实现![使用了set进入的host(真实角色)的Rent方法(要实现的进口方法)]
        Object re = method.invoke(target, args);//此时method就代表了代理接口中的方法
        return re;
    }

    public void log(String mag) {
        System.out.println("使用了" + mag + "方法");
    }
}

Client测试:

package com.demo04;

import com.demo02.UserServiceImpl;
import com.demo02.UserService;

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();

        //代理角色 : 目前没有, 这里创建了可以动态生成代理角色类的ProxyInvocationHandler类
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        //传入需要代理的真实角色(host)需要继承代理事件的接口(Rent)
        pih.setTarget(userService);

        //生成代理角色类(动态就体现在这里, 注意变量类型是接口不是实现类)
        UserService proxy = (UserService) pih.getProxy();

        //执行代理事件(代理接口)
        proxy.delete();
    }
}

动态代理的好处:
①静态代理的所有好处
②一个动态代理类代理的是一个接口, 一般就是对应的一类业务
③一个动态代理类可以代理多个类