public interface Subject //定义一个接口Subject
{
public void request(); //抽象方法 request
}

public class RealSubject implements Subject //定义一个类实现接口Subject
{
public void request()   //覆盖接口中的抽象方法 request
{
  System.out.println("I'm the Real Subject!");
}
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//定义一个类 DynamicProxy 实现接口 InvocationHandler
public class DynamicProxy implements InvocationHandler
{
private Object sub; //定义一个Object类型变量sub

public DynamicProxy()
{
  
}
//定义构造函数参数为Object对象
public DynamicProxy(Object sub)
{
  this.sub = sub;
}
//覆盖接口中的方法
@Override
public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable
{
  System.out.println("附加的方法1");
  method.invoke(sub, args); //调用method中的方法参数为 sub args
  System.out.println("附加的方法2");
  return null;
}
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Client
{
public static void main(String[] args)
{ //创建RealSubject的对象 rs
  RealSubject rs = new RealSubject();
  //接口指向实现它的类对象 ds 参数为 rs
  InvocationHandler ds = new DynamicProxy(rs);
  //？？？？
  Class<?> cls = rs.getClass();
  //？？？？
  Subject sub = (Subject)Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), ds);
  sub.request();
}
}
这是Spring AOP 中的一个动态代理的例子
前边的我都看懂了，但是后边主函数中的我标记出 //？？？？的实在不明白什么意思
Class<?> cls = rs.getClass();  
Subject sub = (Subject)Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), ds);

Class<?> cls = rs.getClass();    获取一个类的运行时类，你打印一下cls  实际上就是rs那个类。但是通过这个方法，可以执行rs里边的方法，修改参数等操作，这个就是反射的一部分了

Subject sub = (Subject)Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), ds);

这个呢，Proxy是java.lang.reflect下的一个类，跟InvocationHandle接口一起用于创建动态代理类。
这句话的意思是  直接创建一个动态代理对象，该代理对象的实现类实现了Interface指定的系列接口，执行代理对象的每个方法时都会被替换执行InvocationHandle对象的invoke方法。

栗培文 发表于 2012-5-14 18:12
Class cls = rs.getClass();  为泛型，动态创建类型为rs的对象cls

貌似不是吧~~~~~~~~~~~~

Class<?> cls = rs.getClass();  <?>为泛型，动态创建类型为rs的对象cls