代理模式（静态、动态）

//抽象主题类：
public interface subject {
    //抽象主题类
    public void doMethod();

}

//具体的实现类：
public class realSubject implements subject {

    @Override
    public void doMethod() {
        // TODO Auto-generated method stub
        System.out.println("excute the subject method");
    }

}

//代理类
package com.designpatten.staticproxy;

public class realProxy implements subject {

    //实现对于subject类的代理
    subject sub;
    //构造函数
    public realProxy(subject sub){
        this.sub=sub;
    }
    
    @Override
    public void doMethod() {
        // TODO Auto-generated method stub
        //预处理
        preprocess();
        //执行主题的方法
        sub.doMethod();
        //后处理
        postprocess();
    }
    
    public void preprocess(){
        System.out.println("before excusion of the domethed");
    }
    
    public void postprocess(){
        System.out.println("after excusion of the domethed");
    }

}

//测试类：
import java.net.Proxy;

public class Test {
    
    public static void main(String[]args){
        
        //利用多态
        subject sub=new realSubject();
        subject proxy=new realProxy((realSubject)sub);
        proxy.doMethod();
        
    }
    
}

//运行结果：
/*
before excusion of the domethed
excute the subject method
after excusion of the domethed
*/

//首先是一个接口即是抽象主题类：

public interface subject {
    //抽象主题类
    public void doMethod(String str);

}

//之后是两个对于这个抽象的具体的实现，即是被代理类：
package com.designpatten.dynamicproxy;

public class realSubject1 implements subject {

    @Override
    public void doMethod(String str) {
        // TODO Auto-generated method stub
        System.out.println("excute the subject in method1:"+str);
    }

}

package com.designpatten.dynamicproxy;

public class realSubject2 implements subject{

    @Override
    public void doMethod(String str) {
        // TODO Auto-generated method stub
        System.out.println("excute the subject in method2:"+str);
    }
    

}

//之后是一个继承了InvocationHandler的类：

package com.designpatten.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class dynamicSubject implements InvocationHandler{

    //由于是动态代理 不知道传递进来的是什么类 这里用object
    private Object subject;
    public dynamicSubject(Object obj){
        this.subject=obj;
    }
    
    //object proxy  Method method Object[]obj
    //这里的arg0是在运行的时候 实际生成的$Proxy类的实例
    //这里对invoke方法进行重写 把新加进来的方法补充进去
    @Override
    public Object invoke(Object arg0, Method arg1, Object[] arg2)
            throws Throwable {
     //由于不知道方法是不是有返回值 默认返回null要是有返回值的话 也可以再添加

     //反正在方法的定义中 返回值是object
        preprocess();
       //反射 执行 method arg1 方法 这个方法 是实例类arg0的  方法的参数是arg2
       //注意这里传参数的技巧是很关键的
        //错了很多次了 执行的是subject类（传进来的被代理的类）的arg1（Method类)类方法  
        //第二个参数是arg2   通过反射来进行
        //注意这里的arg1是一个Method类的实例
        arg1.invoke(subject,arg2);
        
        postprocess();
        
        //把三个参数输出来下
        System.out.println("Object arg0:"+arg0.getClass()+"\nMethod arg1:"+arg1.getName()+"\nObject[] arg2:"+arg2[0].getClass());
        
        return null;
    }
    public void preprocess(){
        System.out.println("before excusion of the domethed");
    }
    
    public void postprocess(){
        System.out.println("after excusion of the domethed");
    }

}


//实际进行测试的类：
package com.designpatten.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;


public class Test {
     public static void main(String[]args){
         //生成两个被代理类的实例
         realSubject1 realsubject1=new realSubject1();
         realSubject2 realsubject2=new realSubject2();
         //生成两个InvocationHandler的实例 这里可以理解为 对真实主题类设置拦截器
         InvocationHandler handler1=new dynamicSubject(realsubject1);
         InvocationHandler handler2=new dynamicSubject(realsubject2);
         
         Class<?>classType1=handler1.getClass();
         Class<?>classType2=handler2.getClass();
        
         //生成两个代理类的实例
         //classLoader与每一个class是相互绑定的
         //dynamic subject 类只用实现一次就可以了可以把不同的handler放进去生成不同的代理类
         //被代理的类 除了执行本身各自的方法之外 都通过代理类进行了方法的扩展
         subject subjectproxy1=(subject)Proxy.newProxyInstance(classType1.getClassLoader(),
                                 realsubject1.getClass().getInterfaces(), handler1);

         subject subjectproxy2=(subject)Proxy.newProxyInstance(classType2.getClassLoader(),
                 realsubject2.getClass().getInterfaces(), handler2);
         
         subjectproxy1.doMethod("function1");
         subjectproxy1.doMethod("function2");
         
         subjectproxy2.doMethod("function1");
         subjectproxy2.doMethod("function2");
         
     }
}



//最后的输出的结果：
/*
before excusion of the domethed
excute the subject in method1:function1
after excusion of the domethed
Object arg0:class com.sun.proxy.$Proxy0
Method arg1:doMethod
Object[] arg2:class java.lang.String
before excusion of the domethed
excute the subject in method1:function2
after excusion of the domethed
Object arg0:class com.sun.proxy.$Proxy0
Method arg1:doMethod
Object[] arg2:class java.lang.String
before excusion of the domethed
excute the subject in method2:function1
after excusion of the domethed
Object arg0:class com.sun.proxy.$Proxy0
Method arg1:doMethod
Object[] arg2:class java.lang.String
before excusion of the domethed
excute the subject in method2:function2
after excusion of the domethed
Object arg0:class com.sun.proxy.$Proxy0
Method arg1:doMethod
Object[] arg2:class java.lang.String

*/