动态代理笔记

动态代理：反射的一个应用
反射，体现其动态性。
// 体现反射语言的动态性
public static Object getInstance(String className) throws Exception {
Class clazz = Class.forName(className);
return clazz.newInstance();
}
@Test
public void test(){
String className = "java.util.Date";
Object obj = getInstance(className);
System.out.println(obj);
}

【TestProxy.java】
//动态代理
interface Subject{
void action();
}


//被代理类
class RealSubject implements Subject{

@Override
public void action() {
System.out.println("被代理类的对象开始执行");
       }
}

//过程2：创建一个InvocationHandler接口的实现类，并重写其invoke()方法
//invoke()的作用：见下面invoke()上的注释
class MyInvocationHandler implements InvocationHandler{
Object s;//实际初始化时，赋值的是被代理类的对象

public Object getInstance(Object s){
this.s = s;
//过程1：动态的创建一个代理类的对象（根据需要被代理的类的信息，动态的创建一个代理类的对象）
return Proxy.newProxyInstance(s.getClass().getClassLoader(),s.getClass().getInterfaces(),this);
}

//当通过代理类的对象发起对被重写的抽象方法的调用时，会转换为对如下方法的调用
//此invoke方法的返回值即为被代理对象实现的抽象方法的返回值
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object returnVal = method.invoke(s, args);
return returnVal;
    }
}


public class TestProxy {
public static void main(String[] args) {
MyInvocationHandler handler = new MyInvocationHandler();
Subject s = new RealSubject();

Object obj = handler.getInstance(s);//此时的obj就是代理类的对象
Subject sub = (Subject)obj;
sub.action();//通过代理类的对象调用实现的抽象方法

//另例
ClothFactory cf = new AdidasFactory();
Object o = handler.getInstance(cf);
ClothFactory proxy = (ClothFactory)o;//此时的proxy就是代理类的对象
proxy.produceCloth();
    }
}


【TestAOP.java】
interface Human {
void info();
void fly();
}


class SuperMan implements Human {

@Override
public void info() {
System.out.println("我是超人！！我怕谁");
}

@Override
public void fly() {
System.out.println("I believe I can fly...");
      } 
}


class HumanUtil {

public void method1() {
System.out.println("通用的方法一");
}


public void method2() {
System.out.println("通用的方法二");
      }
}


class MyInvocationHandler1 implements InvocationHandler {
Object obj;// 使用被代理类的对象进行初始化


public void set(Object obj) {
this.obj = obj;
}
//当通过代理类的对象发起对被重写的抽象方法的调用时，会转换为对如下方法的调用
//此invoke方法的返回值即为被代理对象实现的抽象方法的返回值
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
HumanUtil util = new HumanUtil();
util.method1();
Object returnVal = method.invoke(obj, args);
util.method2();

return returnVal;
     }
}


class MyProxy {
// 返回与obj实现相同接口的代理类的对象
public static Object getProxyInstance(Object obj) {
MyInvocationHandler1 handler = new MyInvocationHandler1();
handler.set(obj);

return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
.getClass().getInterfaces(), handler);
}
}


public class TestAOP {
public static void main(String[] args) {
SuperMan man = new SuperMan();//创建被代理类的对象

Object obj = MyProxy.getProxyInstance(man);
Human human = (Human)obj;//human:代理类的对象
human.info();

human.fly();

//另例
ClothFactory cf = new AdidasFactory();
Object obj1 = MyProxy.getProxyInstance(cf);
ClothFactory factory = (ClothFactory)obj1;
factory.produceCloth();

      }
}