黑马高新技术 代理篇

package my_finish_test;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;


/**
 * 首先：要知道为什么要用代理：
 * 需要在原来的方法的功能基础上再添加一些功能，而不用改变这个方法的签名，原来调用这个方法的类依然能正常工作。
 * （一）代理的概念：
 *   代理模式是常用的Java 设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息
 *   转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对
 *   象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。按照代理类的创建时期，代理类可分为两种。
 * 
 * （二）静态代理和动态代理的区别：
 * 静态代理类：由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
 * 动态代理类：在程序运行时，运用反射机制动态创建而成。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性。
 * （三）注意点：
 * 1、代理类的没个方法调用委托类的相同方法，并在调用时加上系统代码
 * 
 * 2、采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序在配置文件中配置那些是使用类那些事代理类，这样很容易切换
 * 
 * 3、动态代理：在程序运行时，运用反射机制动态创建而成。JVM可以在运行期间动态生成代理类的字节码，这种动态生成的类往往被用作代理类。
 *  在使用动态代理类时，我们必须实现InvocationHandler接口，Proxy：该类即为动态代理类
 * @使用Java动态代理机制的好处：
1、减少编程的工作量：假如需要实现多种代理处理逻辑，只要写多个代理处理器就可以了，无需每种方式都写一个代理类。
2、系统扩展性和维护性增强，程序修改起来也方便多了(一般只要改代理处理器类就行了)。
 * 
 * 4、代理的条件：代理类必须实现与委托类相同的接口。
 * 
 * 5、CGLIB库：（开源的）如果一个雷没有实现任何接口，有要被代理，那就可以用CGLIB库来动态生成它的一个子类，子类也可以用在该类的代理类。
 *。
 * @author Evan_Huang
 *
 */
public class ProxyTest_1{
public static void main(String[] args){



MyProxy pro = new MyProxy();
List alist = (List) pro.getProxy(new ArrayList());
alist.add("you");
alist.add("and");
alist.add("me");
System.out.println(alist.toString());

}


}
 class MyProxy  implements InvocationHandler {
 
Object obj = null;

public Object getProxy(Object obj){
this.obj = obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);

}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
long beginTime = System.currentTimeMillis();
Object temp = method.invoke(this.obj, args);
long endTime = System.currentTimeMillis();
System.out.println("时间为："+ (endTime - beginTime));
return temp;
} 
}


张老师的讲的代码，自己有实现了一遍
package my_finish_test;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;


public class IProxy {


 
public static void main(String[] args) {
final List list = new ArrayList();
final Advice advice = new Advice();
List relist = (List)proxyTo(list,advice);
relist.add("you");
relist.add("and");
relist.add("me");





}
public static Object proxyTo(final Object target,final Advice advice){
Object obj = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), 
new InvocationHandler(){


@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
long begin = advice.beginTime();
Object obj = method.invoke(target, args);
long end = advice.endTime();
System.out.println("The runing time is : "+(end - begin));

return obj;
}

});
return obj;

}
}
class Advice{
public long beginTime(){
return System.currentTimeMillis();
}
public long endTime(){
return System.currentTimeMillis();
}
}