学习笔记《模式——动态》

动态***

前言：接着上一篇《***模式——静态***》

动态***结构类图，如下
主要过程

***对象通过Proxy***，实现InvocationHandler接口，这个接口可以任何类的任何类对象的方法，然后再去找到真是对象，执行里面的方法。

InvocationHandler接口（事务处理器）中仅定义了一个方法public object invoke(Object obj,Method method,Object[] args)，在实际的使用中，第一个参数obj一般是指***类，method是被***的方法，args为该方法的参数数组，这个抽象方法在***类中动态实现。

Proxy：该类即为动态***类，通过newProxyInstance方法可以返回***类的一个实例，返回后的***类可以当做被***类使用（可使用被***类的在接口中声明的方法）

实现步骤
（1）创建一个实现接口InvocationHandler的类，它必须实现invoke方法，在invoke方法中添加具体的业务逻辑。
（2）创建被***的类和接口。
通过Proxy的静态方法newProxyInstance，动态创建一个***类。
（3）通过***调用方法。
常用的***场景
远程***：为不同地理的对象，提供局域网代表对象。
虚拟***：根据需要将资源消耗很大的对象进行延迟，真正需要的时候进行创建。
保护***：控制对一个对象访问的权限。
智能引用***：提供对目标对象额外的服务。
代码思维导图
代码

步骤1：
//接口
public interface ITestInterface {
    public void SendMessage(String msg);
}

步骤2：
//实现接口的被***类
public class CTest implements ITestInterface {
    @Override
    public void SendMessage(String msg) {
        for (int i=5; i>0; i--){
            System.out.println(msg+"怪物的出现还有"+i+"秒");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(msg+"怪物出现了！");
    }
}

步骤4：
//动态***类
public class CLocalPicShow {
    private Object target;

    public CLocalPicShow(Object target){
        super();
        this.target=target;
    }

    public Object getProxyInstance()   {

        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, final Method method, final Object[] args) throws Throwable {
                    System.out.println("准备载入图片"+args[0].toString());
                    Thread th = new Thread(new Runnable() {
                        @Override
                        public void run() {
                            //完成远程图片的调用过程
                            try {
                                method.invoke(target,args);
                            } catch (IllegalAccessException e) {
                                e.printStackTrace();
                            } catch (InvocationTargetException e) {
                                e.printStackTrace();
                            }
                        }
                    });// new thread end
                    th.start();
                    return null;
                }
            }
        );
    }
}

步骤5：
//客户端代码
public class ClientClass {
    public static void main(String[] args) {
//        IShowPic iShowPic = new CRemoPic();//被***对象
//        CLocalPicShow cLocalPicShow = new CLocalPicShow(iShowPic);//***对象
//        IShowPic isc = (IShowPic)cLocalPicShow.getProxyInstance();
//        isc.ShowPic("AAA");

        //为了直观地看到动态性，我们再创一个接口，都是可以***的
        ITestInterface iTestInterface = new CTest();//被***对象
        CLocalPicShow cLocalPicShow2 = new CLocalPicShow(iTestInterface);//***对象
        ITestInterface iTestInterface2 = (ITestInterface)cLocalPicShow2.getProxyInstance();
        iTestInterface2.SendMessage("卡卡");

    }
}

执行程序，输出结果：

练习中遇到的问题：

报错：Exception in thread “main” java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to DProxy.CTest

排除练习中的代码，发现
//CTest是被***类
//ITestInterface是接口，声明了SendMessage方法
//CLocalPicShow是***类

报错的代码

ITestInterface iTestInterface = new CTest();//被***对象
CLocalPicShow cLocalPicShow2 = new CLocalPicShow(iTestInterface);//***对象
CTest cTest= (CTest )cLocalPicShow2.getProxyInstance();
cTest.SendMessage("卡卡");

正确的代码

ITestInterface iTestInterface = new CTest();//被***对象
CLocalPicShow cLocalPicShow2 = new CLocalPicShow(iTestInterface);//***对象
ITestInterface iTestInterface2 = (ITestInterface)cLocalPicShow2.getProxyInstance();
iTestInterface2.SendMessage("卡卡");

分析：
根据ClassCastException翻译过来是类转换异常的原因，错误定位到getProxyInstance()方法转换类型这行，错误的代码CTest 是被***对象实现类。而ITestInterface是接口，声明业务的方法。

结论：
根据百度其他文章的记录，要使用动态***，用来生成***(CLocalPicShow)的委托对象(ITestInterface)必须是一个接口，而不是被***类(CTest);

补充参考资料：
关于***模式的博客：https://www.jianshu.com/p/9bcac608c714