黑马程序员高薪_代理

         java_高新代理

代理的概念与作用:

生活中的代理:

-->武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑，你觉得最
-->终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但是，一点区别都没有吗？从代
-->理商那里买真的一点好处都没有吗？

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

 

 

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动态生成的类:

创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
编码列出动态类中的所有构造方法和参数签名
编码列出动态类中的所有方法和参数签名
创建动态类的实例对象
用反射获得构造方法
编写一个最简单的InvocationHandler类
调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。
将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?

三个方面：
1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
2.产生的类字节码必须有个一个关联的类加载器对象；
3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把
对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler
对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方
法中加一点代码，就可以看到这些代码被调用运行了。

用Proxy.newInstance方法直接一步就创建出代理对象。

代码示例:

private static Object getProxy(final Object target,final Advice advice) {
  Object proxy3 = Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    //new Class[]{Collection.class},
    target.getClass().getInterfaces(),
    new InvocationHandler(){
     
     
     public Object invoke(Object proxy, Method method, Object[] args)
     throws Throwable {     
      // TODO Auto-generated method stub
//      long beginTime = System.currentTimeMillis();
//      Object retVal = method.invoke(target, args);
//      long endTime = System.currentTimeMillis();
//      System.out.println("retVal run of " +(beginTime-endTime));
//      return retVal;
      
      
      advice.beforeMethod(method);
      
      Object retVal = method.invoke(target, args);
      
      advice.afterMethod(method);
      
      return retVal;
     }    
    }
    );
  return proxy3;

猜想分析动态生成的类的内部代码
 动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有
 方法和一个如下接受InvocationHandler参数的构造方法。
构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的
 代码会是怎样的呢？
实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接
 口中定义的invoke方法接受的三个参数又是什么意思？图解说明如下：

 

分析先前打印动态类的实例对象时，结果为什么会是null呢？调用有基本类型返回值的方法时为什么会
 出现NullPointerException异常？
分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？
调用调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时，代理对象将调用请求转
 发给InvocationHandler对象，对于其他方法，则不转发调用请求。

 

分析动态代理的工作原理图（见下页）
怎样将目标类传进去？
直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。
为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。
让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。
将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？
把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！
为bind方法增加一个Advice参数。

 

 

 

实现AOP功能的封装与配置:

工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数
字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则
直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。
BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
 #xxx=java.util.ArrayList
 xxx=cn.itcast.ProxyFactoryBean
 xxx.target=java.util.ArrayList
 xxx.advice=cn.itcast.MyAdvice

ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
目标
通知

编写客户端应用：
编写实现Advice接口的类和在配置文件中进行配置
调用BeanFactory获取对象

代码

 

************************配置文件****************************
#xxx=java.util.ArrayList
xxx=cn.itcast.day03.aopframework.ProxyFactoryBean
xxx.advice=cn.itcast.day03.MyAdvice
xxx.target=java.util.ArrayList
************************22222*****************************
package cn.itcast.day03.aopframework;

import java.io.InputStream;
import java.util.Collection;

public class AopFrameworkTest {

 /**
  * @param args
  */
 public static void main(String[] args) throws Exception {
  // TODO Auto-generated method stub
  
  //用相对路径getResourceAsStream来加载配置文件
  InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
  
  //将ips流输出到BeanFactory类的构造方法中.并往getBean函数内传递XXX的键.
  Object bean = new BeanFactory(ips).getBean("xxx");
  
  //打印返回的值的名字.
  System.out.println(bean.getClass().getName());
  ((Collection)bean).clear();
 }

}
********************333333333**********************************
package cn.itcast.day03.aopframework;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import cn.itcast.day03.Advice;


public class BeanFactory {
 
 //建立Properties对象用于接收传进来的流.
 Properties props = new Properties();
 public BeanFactory(InputStream ips){
  try {
   //将AopFrameworkTest流中的数据传入到Properties中
   props.load(ips);
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
 //将XXX的键传入到getBean中
 public Object getBean(String name){
  
  //获取XXX中的值
  String className = props.getProperty(name);
  
  //在try外边建立引用
  Object bean = null;
  try {
   
   //用Class.forName获取XXX中的字节码文件并用newInstance创建实例对象
   Class clazz = Class.forName(className);
   bean = clazz.newInstance();
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } 
  
  //对XXX中的值进行判断.是否实例化ProxyFactoryBean,如果不是直接返回到AopFrameworkTest并打印
  if(bean instanceof ProxyFactoryBean){
   
   //try外部建立引用
   Object proxy = null;
   
   //已知XXX的值肯定是ProxyFactoryBean的实力对象了.直接强转过来.
   ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
   try {
    
    //获取名字创建实例对象
    Advice advice = (Advice)Class.forName(props.getProperty(name + ".advice")).newInstance();
    Object target = Class.forName(props.getProperty(name + ".target")).newInstance();
    
    //这是proxyFactoryBean中的advice和target,
    proxyFactoryBean.setAdvice(advice);
    proxyFactoryBean.setTarget(target);
    
    //使用代理.
    proxy = proxyFactoryBean.getProxy();
   } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   //返回代理
   return proxy;
  }
  return bean;
 }
}
****************************3333333333*****************************
package cn.itcast.day03.aopframework;

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

import cn.itcast.day03.Advice;

public class ProxyFactoryBean {

 //私有化
 private Advice advice;
 private Object target;
 public Object getProxy() {
  //使用Proxy代理类的静态方法newProxyInstance.并实现代理类的三个参数
  Object proxy3 = Proxy.newProxyInstance(
    
    //target的类加载器
    target.getClass().getClassLoader(),
    
    //new Class[]{Collection.class},
    //target的接口
    target.getClass().getInterfaces(),
    
    //InvocationHandler接口.实现内部类.
    new InvocationHandler(){
     
     //用内部类覆盖InvocationHandler中的方法proxy 代表对象,  method,代表对象的方法, args代表参数
     public Object invoke(Object proxy, Method method, Object[] args)
     throws Throwable {     
      // TODO Auto-generated method stub
//      long beginTime = System.currentTimeMillis();
//      Object retVal = method.invoke(target, args);
//      long endTime = System.currentTimeMillis();
//      System.out.println("retVal run of " +(beginTime-endTime));
//      return retVal;
       
      //获取程序开始时间
      advice.beforeMethod(method);
      
      Object retVal = method.invoke(target, args);
      
      //获取结束时间
      advice.afterMethod(method);
      
      return retVal;
     }    
    }
    );
  return proxy3;
 }
 //set和get方法
 public Advice getAdvice() {
  return advice;
 }
 public void setAdvice(Advice advice) {
  this.advice = advice;
 }
 public Object getTarget() {
  return target;
 }
 public void setTarget(Object target) {
  this.target = target;
 }

}
********************444444444***********************
package cn.itcast.day03;

import java.lang.reflect.Method;

public class MyAdvice implements Advice {
 long beginTime =0;
 public void afterMethod(Method method) {
  // TODO Auto-generated method stub
  System.out.println("传智播客毕业了");
  long endTime = System.currentTimeMillis();
  System.out.println("retVal run of " +(beginTime-endTime));
  
 }

 public void beforeMethod(Method method){
  // TODO Auto-generated method stub
  System.out.println("传智播客开学了");
  beginTime = System.currentTimeMillis();

 }

}
**********************5555555555******************************
package cn.itcast.day03;

import java.lang.reflect.Method;

public interface Advice {
 void afterMethod(Method method);
 void beforeMethod(Method method);
}

***********************************************************

总结:
AOP  面向方面的编程
涉及到代理

A接口有c方法，类B实现A接口，原本应该是执行B类中的c方法，可现在不这样做；
声明产生B类的代理类B',由它来冒充B类的“兄弟”并“实现”A接口，
对外界来说B'应该也有c方法，可当真正调用它的时候，
它会去执行与它关联InvocationHandler的invoke()方法，
在这个方法里面你可以做很多事情。这样，这个请求就被“代理”到其它地方去了
***********************************************************