代理模式

代理模式

静态代理

角色分析

• 抽象角色：一般会使用接口或者抽象类类解决

  //出租房屋
  public interface Rent {
      public void rent();
  }
  

• 真实角色：被代理的角色

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

• 代理角色：代理真实角色，代理真实角色后会进行一些操作。

  public class Proxy implements Rent{
      private Host host;
      public Proxy() {
      }
      public Proxy(Host host) {
          this.host = host;
      }
      public void rent() {
          host.rent();
      }
      public void seeHouse(){
          System.out.println("看房");
      }
  }
  

• Client角色：按照常理应该找真实角色，但在代理模式中应找Client角色

  public class Client {
      public static void main(String[] args) {
          Host host = new Host();
          Proxy proxy = new Proxy(host);
          proxy.rent();
          proxy.seeHouse();
      }
  }
  

好处：

• 使真实角色的操作更加纯粹
• 公共任务交给了代理角色，实现了任务的分工
• 公共任务发生扩展的时候，方便集中管理

坏处

• 一个真实角色就会产生一个代理角色；代码量翻倍

结合service层进行分析

我们的service接口以及具体实现分别对应了抽象角色和代理角色

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

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("查找");
    }
}

突发需求：在每一个方法的开始都要打印日志

我们不可能去修改具体的方法实现，这时我们可以引入一个代理类，让他来代理userServiceImpl的职责

public class UserServicePoxy implements UserService{
    private UserService userService;
	//这里使用set注入
    public void setUserService(UserService 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 select() {
        log("select");
        userService.select();
    }
    //日志方法
    public void log(String msg){
        System.out.println("使用了" + msg +"方法");
    }

动态代理

• 动态代理和静态代理角色一致
• 动态代理的代理类是动态生成的，不是上面静态代理自己手写的
• 动态代理分为两大类：基于接口的动态代理；基于类的动态代理
  • 基于接口-JDK动态代理
  • 基于类：cglib
  • java字节码实现

Proxy代理 InvocationHandler调用处理程序

举例

抽象角色和真实角色不变，区别的是我们不手动实现Proxy类这个代理角色了。

现在来编写动态代理类

//使用此类生成动态代理类  实现接口重写invoke方法
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Rent rent;
	//set注入
    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成得到代理类对象
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

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

由代码可以看出JDK动态代理更像是代理具体的接口，这也是他与cglib实现的区别。JDK动态代理代理的是接口

下面给出客户端类

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        //代理角色-->无
        //通过调用程序处理角色来处理我们要调用的接口对象
        ProxyInvocationHandler handler = new ProxyInvocationHandler();
        handler.setRent(host);

        Rent proxy = (Rent)handler.getProxy();
        proxy.rent();
    }
}