黑马程序员：jdk1.5新特性5（代理）

 

类加载器
1 java 虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：
 BootStrap,ExtClassLoader,AppClassLoader
2 类加载器也是java类，第一个类加载器BootStrap不是java类，它是java虚拟机中的一段二进制代码，与java虚拟机一同加载。
3 java虚拟机中的所有类装载器 采用具有父子关系的树形结构进行组织，在实例化每个类加载器对象时需要为其制定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。

类加载器的委托机制
 当java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？
  1 首先当前线程的类加载器去加载线程中的第一个类。
  2 如果类A中引用了类B，java虚拟机将使用加载了类A的装载器去加载类B。
  3 还可以调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类
 每个类加载器加载类时 ，又先委托给其上级类加载器
  1 当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛出ClassNotFoundException
  2 对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。

代理的概念与作用：
 1 程序中的代理：
  为已存在多个具有相同接口的，目标类的各个方法增加一些系统功能，例如：异常处理，日志，计算方法的运行时间，事物管理等等 如何做？
  1 编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能代码
 2 如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是 使用目标类还是使用代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，想去掉也很容易。

AOP（面向方面的编程）
安全，事务，日志等功能要贯穿到好多个模块中，所有，他们就是交叉业务。
系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下：
                  安全     事务    日志        
StudentService  ----|--------|-------|-----
CourseService   ----|--------|-------|-----
MiscService     ----|--------|-------|-----
 用具体的程序代码描述交叉业务：
  method1     method2     method3
  {             {           {
 ----------------------------------切面
 ....         ....       ....
  ---------------------------------切面
   }           }             }
交叉业务的编程问题极为面向方面的编程（Aspect oriented program 简称AOP），AOP的目标就是要使交叉业务模块化，可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面的代码运行效果是一样的，如下
--------------------------切面
 func1   func2   func3
  {        {       {
  ...     ...     ...
  }        }        }
-------------------------切面
使用代理技术正好可以解决这个问题 ，代理是实现AOP功能的核心的关键技术。

动态代理技术

JVM可以在运行期动态的生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类
JVM生成的动态类必须实现一个或多个接口,所以,JVM生成的动态类只能用作具有相同接口的目标类的代理
CGLIB库可以动态生成一个类的子类，一个类的子类也可以作为该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库
代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置驾驶系统功能代码。
 <1 在调用目标方法之前
 <2 在调用目标方法之后
 <3 在调用目标方法前后
 <4 在处理目标方法异常的catch块中

JVM动态生成类
 Proxy 类能够动态生成类,编写一个动态类，获得它的构造方法和 其他方法
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;

public class ProxyTest {
 public static void main(String[] args){
 Class clazzProxy=Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);
 
 System.out.println("---------bengin constructors list--------");
 Constructor[] constructors=clazzProxy.getConstructors(); 
    for(Constructor constructor:constructors){
     String name=constructor.getName();
     StringBuilder sBuilder=new StringBuilder();
     sBuilder.append(name);
     sBuilder.append("(");
        Class[] clazzParams=constructor.getParameterTypes();
        for(Class clazzParam:clazzParams){
         sBuilder.append(clazzParam.getName()).append(",");
         if(clazzParams!=null && clazzParams.length!=0){
          sBuilder.deleteCharAt(sBuilder.length()-1);   } } 
     sBuilder.append(")");
     System.out.println(sBuilder);
    }
 System.out.println("---------bengin methods list--------");
 Method[] methods=clazzProxy.getMethods();
   
    for(Method method:methods){
     String name1=method.getName();
     StringBuilder sBuilder1=new StringBuilder();
     sBuilder1.append(name1);
     sBuilder1.append("(");
        Class[] clazzParams=method.getParameterTypes();
        for(Class clazzParam:clazzParams){
         sBuilder1.append(clazzParam.getName()).append(",");
         if(clazzParams!=null && clazzParams.length!=0){
          sBuilder1.deleteCharAt(sBuilder1.length()-1);   }    } 
     sBuilder1.append(")");
     System.out.println(sBuilder1);
    } }    }

分析动态生成的类的内部代码
 1 动态生成的类实现了Collection接口（可实现若干个接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法
 2 构造方法接受一个InvocationHandler对象，接受对象要做什么呢？（接受了对象就是要记住这个对象在以后使用！）
 3 InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？
  Client程序调用objProxy.add("abc")方法时，涉及到三要素：objProxy对象，add方法，"abc"参数
  它们分别对应InvocationHandler 接口唯一方法的三个参数invoke(Object proxy, Method method,Object[] args) {return null；} objProxy调用一个方法后，程序会直接调用InvocationHandler 实例的invoke方法，并传递三要素。invoke方法的返回值就是objProxy调用方法所要的结果。

让动态生成的类称为目标类的代理
 1 分析动态代理的工作原理图

 2 怎样将目标类传进去？
  <1 直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没实际意义
  <2 为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了
  <3 让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量
 3 将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接受目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API
 4 将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎么样把要执行的系统功能代码以参数形式提供？
  <1 把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接受者只要调用这个对象的方法，即等于执行了外界提供的代码
  <2 为bind方法增加一个Advice参数。
 调用：final ArrayList target=new ArrayList();
       Collection proxy3 = (Collection)getProxy(target,new MyAdvice());
   proxy3.add("qwe");
   proxy3.add("sdf");
   proxy3.add("cvb");
   System.out.println(proxy3.size());

代理：
private static Object getProxy(final Object target,final Advice advice) {
 Object proxy3=Proxy.newProxyInstance(
  target.getClass().getClassLoader(),
  //Collection.class.getClassLoader(),
  target.getClass().getInterfaces(),
  //new Class[] {Collection.class},
  new InvocationHandler(){
public Object invoke(Object proxy, Method method,Object[] args) throws Throwable {

    /*long beginTime=System.currentTimeMillis();
    Object retval=method.invoke(target, args);
    long endTime=System.currentTimeMillis();
    System.out.println(method.getName()+"running time is"+(endTime-beginTime));
        return retval;*/
       
    advice.beforeMethod(method);
     Object retval=method.invoke(target, args);
    advice.afterMethod(method);
       
 return retval;
         }  }
 );
 return proxy3;

实现AOP功能的封装与配置

 1 工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换，器getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean,则返回该类的实例对象，否则 返回该类实例对象的getProxy方法返回的对象
 2 BeanFactory的构造方法接受代表配置文件的输入流对象，配置文件格式如下：
#xxxjava.util.ArrayList
xxx=cn.itcast.ProxyFactoryBean
xxx.target=java.util.ArrayList
xxx.advice=cn.itcast.MyAdvice
3 ProxyFactoryBean 充当封装生成动态代理的工厂，需要为工厂提供的配置信息：
  目标  target
  通知  advice
4 编写客户端应用：
编写实现Advice接口的类和在配置文件中进行配置
调用BeanFactory获取对象
代码：workspace2/javaenhance/cn/itcast/day3/aopframexwork