设计模式-静态代理和动态代理

代理模式概述

为什么要学代理模式？因为这就是springAOP的底层 

代理模式分为：静态代理和动态代理

静态代理

角色分析

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

代码实现

房东接口

//房东
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(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        host.rent();
    }

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

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

顾客租房

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

        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{
    @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("查询了个用户");
    }
}

我们现在想不改变原有代码，在方法里面加入一些新的操作，实现aop，就需要代理对象了

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

动态代理 

静态代理虽然有上面很多好处，但是代码量会增加。那我们要怎么做到代码量不增加呢，这时候就要用到反射

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们写的
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理

需要了解两个类：Proxy代理 和 InvocationHandler调用处理程序

有三种方式使用动态代理

• 基于接口-JDK动态代理（我们用这种）
• 基于类-cglib
• java字节码实现-javasist

代码实现

房东接口

//房东
public interface Rent {

    public void rent();
}

实现类

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

实现生成动态代理类

public class ProxyInvocationHandler implements InvocationHandler {

    private Rent rent;

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

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

    //处理代理实例 返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理本质 就是使用反射实现
        seeHouse();
        Object result = method.invoke(rent, args);
        fare();
        return null;
    }

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

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

客户调用

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

        //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象
        pih.setRent(host);

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

动态代理的好处

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