代理模式学习

代理模式

什么是代理模式

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。其实就是我们生活中的中介

为什么要使用代理模式

在不修改源代码的情况下又想要增加功能，就可以使用代理模式。

静态代理

案例

例如我现在要出租房子，如果我直接自己出租，需要到租房平台注册，拍照房子，介绍房子，带客户看房，等，实在是太麻烦，因此我们可以交给中介来做，我们只需要出租房屋即可，客户来租房时直接找中介，出租完成后我们只需要收钱就好

实现
中介和房东都要出租房屋，因此要实现同一个租房接口

public interface Rent {
    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() {
        System.out.println("出租前准备.....");
        // 由真实对象完成
        host.rent();
        System.out.println("中介出租.....");
    }
}

测试，客户端来买房

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

实际开发中的例子

public interface UserService {
    void add();
    void del();
}

实现类，具体业务中，一般这个实现类写好的，我们可以使用代理类去进行功能的扩展，而不应该去修改原有代码，例如添加日志信息

public class UserServiceImpl implements  UserService{
    @Override
    public void add() {
        System.out.println("添加一个用户...");
    }

    @Override
    public void del() {
        System.out.println("删除一个用户...");
    }
}

代理类

public class UserProxy implements  UserService{


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

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

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

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

    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserProxy userProxy = new UserProxy();
        userProxy.setUserService(userService);
        userProxy.add();
    }

小结

优点：
可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务就交给了代理角色，实现了业务的分工
公共业务发生扩展的时候，方便集中管理
缺点
一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率变低

动态代理

在动态代理中我们不再需要再手动的创建代理类，我们只需要编写一个动态处理器就可以了。真正的代理对象是在运行期间利用java的反射机制为我们动态创建的。

public class ProxyInvocationHandler implements InvocationHandler {
    // 需要代理的类
    private Object target;
       public void setTarget(Object target) {
        this.target = target;
    }
    // 生产代理对象的方法
    public Object getProxy(Object target){
        this.target = target;
        /**
         * ClassLoader loader:指定当前目标对象使用的类加载器,获取加载器的方法是固定的
         * Class<?>[] interfaces:指定目标对象实现的接口的类型，要代理的接口是哪一个接口
         * InvocationHandler:指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法
         */
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                this.target.getClass().getInterfaces(),this);
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("准备工作....");
        Object result = method.invoke(target, args);
        System.out.println("后续工作....");
        return result;
    }
}

  public static void main(String[] args) {
        //静态代理
//        UserServiceImpl userService = new UserServiceImpl();
//        UserProxy userProxy = new UserProxy();
//        userProxy.setUserService(userService);
//        userProxy.add();
//        ProxyInvocationHandler handler = new ProxyInvocationHandler();
//        Rent proxy = (Rent) handler.getProxy(new Actural());
//        proxy.rent();
        //动态代理
        UserServiceImpl serService = new UserServiceImpl();
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        proxyInvocationHandler.setTarget(serService);
        UserService proxy = (UserService) proxyInvocationHandler.getProxy(serService);
        proxy.add();

    }

小结

虽然相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度。但是那就是它始终无法摆脱仅支持interface代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫Proxy。Java的继承机制注定了这些动态代理类们无法实现对class的动态代理。