【Spring学习笔记】10、代理模式

10、代理模式

为什么要学习代理模式？
因为这就是Spring AOP的底层！【SpringAOP 和 SpringMVC】
AOP（Aspect Oriented Programming）：面向切面编程

• 代理模式的分类：
  1、静态代理
  2、动态代理
  

10.1、静态代理

角色分析

• 抽象角色：一般使用接口或者抽象类解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，一般会做一些附属的操作
• 客户：访问代理对象的人

代码步骤

1、接口

   //抽象角色：租房
   public interface Rent {
   	public void rent();
   }

2、真实角色

   //真实角色: 房东，房东要出租房子
   public class Host implements Rent{
       public void rent() {
       	System.out.println("房屋出租");
       }
   }

3、代理角色

   public class Proxy implements Rent {
   	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("收中介费");
       }
   }

4、客户端访问代理角色

   //租客
   public class Client {
   public static void main(String[] args) {
           //房东要租房
           Host host = new Host();
       
           //代理帮房东租房，代理还会有一些附属操作
           Proxy proxy = new Proxy(host);
         
       	   //租房直接找中介
           proxy.rent();
       }
   }

代理模式的好处：

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

缺点：

• 一个真实角色就会产生一个代理角色，代码量翻倍，开发效率会降低。

10.2、加深理解

1、接口

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

2、真实角色

public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("add");
    }

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

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

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

3、代理角色

如果想增加一个日志的功能，不要在原来的代码上进行改动，要新增一个代理类

public class UserServiceProxy implements UserService{

    UserServiceImpl service = new UserServiceImpl();

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


    public UserServiceProxy(UserServiceImpl service) {
        this.service = service;
    }

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

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

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

    public void query() {
        log("query");
        service.query();
    }

}

4、客户端访问代理角色

public class Client {
    public static void main(String[] args) {
        UserServiceImpl service = new UserServiceImpl();
//        service.add();
        UserServiceProxy proxy = new UserServiceProxy(service);
        proxy.add();
    }
}

聊聊AOP（Aspect Oriented Programming）面向切面编程

10.3、动态代理

• 动态代理和静态代理角色一样（抽象角色，真实角色，代理角色）。
• 动态代理的代理类是动态生成的，不是我们直接写好的。
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
  • 基于接口：JDK的动态代理
  • 基于类：cglib
  • java字节码：JAVAssist

需要了解两个类

• Proxy：代理

  Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。

• InvocationHandler：调用处理程序

  InvocationHandler 是代理实例的调用处理程序 实现的接口。
  每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。

动态代理的好处

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

---------------------------------------------------------------------------------------------------同静态代理

• 一个动态代理类代理的是一个接口，一般就是对应的一类业务！
• 一个动态代理类可以代理多个类，只要是实现了同一接口即可！

实现动态代理

1、UserService接口

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

2、ProxyInvocationHandler.class

//用这个类自动生成代理类,代理调用处理
/*
InvocationHandler 是代理实例的调用处理程序 实现的接口。
每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，
将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。
 */
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object target;

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

    //生成得到代理类
    //Proxy:提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    //处理代理实例并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object invoke = method.invoke(target,args);
        return invoke;
    }

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

}

3、Client.class

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色,不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //设置要代理的对象
        pih.setTarget(userService);
        //动态生成代理类,getProxy返回的必须是接口
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();
        proxy.delete();
        proxy.update();
        proxy.query();
       /**
         * [debug]执行add方法
         * add
         * [debug]执行delete方法
         * delete
         * [debug]执行update方法
         * update
         * [debug]执行query方法
         * query
         */
    }
}

本文章内容整理自b站up主：遇见狂神说，欢迎关注，一键三连！