结构型设计模式-代理模式

结构型模式主要总结了一些类或者对象组合在一起的经典结构,用于解决特定场景的问题。

代理模式:

在不改变原始类或者被代理类代码的情况下,通过引入代理类来给原始类附加功能。

1、如果被代理类实现了一套接口,那么代理类也同样实现这一套接口,然后内部在实现这套接口的时候,委托给被代理类,还可以附加一些其他的处理;

2、如果被代理类没有定义接口,并且原始类代码并不是我们开发维护的(比如来自一个第三库的类库),并没有办法修改原始类,那么这时候就采用继承的方式来扩展外部类。

综上,很明显代理模式就是类上加了一层壳子,还是蛮好理解的。

代理类中,需要将原始类中的所有方法都重新实现一遍;同时,如果要添加代理的类有很多,那么就需要针对每个类都创建一个代理类。显然,这真的很麻烦,类立刻翻倍了。

针对上述的问题,就可以使用动态代理来解决。不管出现多么糟糕的情况,都有人知道怎么解决,真的很棒棒。

动态代理就说不事先为每个原始类编写代理类,而是在运行的时候,动态的创建原始类对应的代理类,然后在系统中用代理类替换调原始类。来看看如何实现吧。

首先需要明确的就是动态代理依赖反射。上代码吧。

public interface IUserController {

    void say();
    void run();
}
public class UserController implements IUserController{
    @Override
    public void say() {
        System.out.println("say 吧");
    }

    @Override
    public void run() {
        System.out.println("run 啊 瘪犊子");
    }
}
public class DemoProxy {


    public static void main(String[] args) {
        DemoProxy proxy = new DemoProxy();
        IUserController userController = (IUserController) proxy.createProxy(new UserController());
        userController.say();
        userController.run();
    }
    /**
     * 创建代理类对象
     * @param proxyObject
     * @return
     */
    public Object createProxy(Object proxyObject){
        Class[] interfaces = proxyObject.getClass().getInterfaces();
        DynamicProxyHandler proxyHandler = new DynamicProxyHandler(proxyObject);
        return Proxy.newProxyInstance(proxyObject.getClass().getClassLoader(),interfaces,proxyHandler);
    }
private class DynamicProxyHandler implements InvocationHandler{
        private Object mProxyObject;

        public DynamicProxyHandler(Object mProxyObject) {
            this.mProxyObject = mProxyObject;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object result  = method.invoke(mProxyObject,args);
            return result;
        }
    }
}

完事运行就可以得到

结构型设计模式-代理模式_第1张图片

 

你可能感兴趣的:(Java,设计模式,代理模式)