黑马程序员--第三阶段--Java基础加强--第27天

-------------------- android培训、java培训、期待与您交流！--------------------
代理的概念与作用

生活中的代理

武汉人从武汉的代理商手中买联想电脑，除也电脑外，一般代理商会送一些音响、电脑包、鼠标等产品，而直接跑到北京传智播客旁边来找联想总部买电脑，还不一定有礼品送，而且路费很贵，走代理比较实惠。

程序中的代理

类似生活中的代理，貌似包装类，代理类把目标类包装后除了拥有目标类原来的功能外，还多了一些其他功能，方便用户使用。

要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能 ，例如，异常处理、日志、计算方法的运行时间、事务管理、等待。

编写一个与目标类具有相同接口的代理类（也就是有相同方法的类），代理类的每个调用与目标类的相同方法，并在调用方法时加上系统功能的代码。（参看下面的原理图）

代理架构图




如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是使用代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。

AOP

系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：



安全、事务、日记等功能要贯穿到好多个模块中，所以，它们就是交叉业务。

用具体的程序代码描述交叉业务：



交叉业务的编程问题即为面向方面的编程（Aspect oriented program,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：



使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。

动态代理技术

要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻类的事情！写成百上千个代理类，是不是太累！
JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：

1。在调用目标方法之前
2。在调用目标方法之后
3。在调用目标方法前后
4。在处理目标方法异常的catch块中

提示：StringBuffer与StringBuilder的区别：他们的使用基本一样，在多线程上使用StringBuffer比较好，在单线程上使用StringBuilder效率比较高一些。

分析JVM动态生成的类

创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数，代码如下：

package cn.itcast.day3;

import java.lang.reflect.*;

import java.util.Collection;

public class ProxyTest {

　　public static void main(String[] args) {

　　　　Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);

　　　　System.out.println(clazzProxy1.getName());//实现了Collection接口的动态类的名称为：$Proxy0

　　　　System.out.println("-------------------动态类中的所有构造方法和参数签名 -------------------");

　　　　Constructor[] constructors = clazzProxy1.getConstructors();

　　　　for(Constructor constructor : constructors)

　　　　{

　　　　　　String name = constructor.getName();

　　　　　　StringBuilder sBuilder = new StringBuilder(name);

　　　　　　Class[] clazzTypes = constructor.getParameterTypes();

　　　　　　sBuilder.append('(');

　　　　　　for(Class clazzType : clazzTypes)

　　　　　　{

　　　　　　　　String paramType = null;

　　　　　　　　if(clazzType == clazzTypes[clazzTypes.length - 1])

　　　　　　　　 　　paramType = clazzType.getName();

　　　　　　　　else

　　　　　　　　　　paramType = clazzType.getName() + ",";

　　　　　　　　sBuilder.append(paramType);

　　　　　　}

　　　　　　sBuilder.append(')');

　　　　　　String strConsctructor = sBuilder.toString();

　　　　　　System.out.println(strConsctructor);

　　}

　　System.out.println("-------------------动态类中的所有方法和参数签名-------------------");

　　Method[] methods = clazzProxy1.getMethods();

　　for(Method method : methods)

　　{

　　　　String name = method.getName();

　　　　StringBuilder sBuilder = new StringBuilder(name);

　　　　Class[] clazzTypes = method.getParameterTypes();

　　　　sBuilder.append('(');

　　　　for(Class clazzType : clazzTypes)

　　　　{

　　　　　　String paramType = null;

　　　　　　if(clazzType == clazzTypes[clazzTypes.length - 1])

　　　　　　　　paramType = clazzType.getName();

　　　　　　else

　　　　　　　　paramType = clazzType.getName() + ",";

　　　　　　sBuilder.append(paramType);

　　　　}

　　　　　sBuilder.append(')');

　　　　　String strMethod = sBuilder.toString();

　　　　　System.out.println(strMethod);

　　　}

　　

　　 System.out.println("-------------------创建类的动态实例对象-------------------");

　　　 Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);

　　　　Collection proxy1 = (Collection) constructor.newInstance(new InvocationHandler() {

　　　　　　@Override

　　　　　　public Object invoke(Object proxy,
Method method, Object[] args) throws Throwable

　　　　　　{

　　　　　　　　return null;

　　　　　　}});

　　　　proxy1.clear();//可以正常调用没有返回值的方法

　　　　//proxy1.size();//调用有返回值的方法应付出现异常。

　　}

}

总结思考

让JVM创建动态类及其实例对象，需要给它提供哪些信息？

三个方法：

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

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

public static void main(String[] args) {

　　Collection proxy3 = (Collection)Proxy.newProxyInstance(

　　Collection.class.getClassLoader(),

　　new Class[] {Collection.class},

　　new InvocationHandler() {

　　ArrayList target = new ArrayList();//用作绑定的目标

　　public Object invoke(Object proxy, Method method,Object[] args)　throws Throwable {

　　　　　　long startTime = System.currentTimeMillis();

　　　　　　Object retVal = method.invoke(target, args);

　　　　　　long endTime = System.currentTimeMillis();

　　　　　　System.out.println(method.getName() + "方法的运行时间为：" + (endTime - startTime));

　　　　　　return retVal;

　　}

　　});

　　proxy3.add("zhangsan");

　　proxy3.add("lisi");

　　proxy3.add("wangwu");

　　System.out.println(proxy3.size());

}

猜想分析动态生成的类的内部代码

动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个仅有的接收InvocationHandler参数的构造方法。
构造方法接受一个InvocationHandler对象是要干什么用呢？该方构造方法内部的代码会是怎样的呢？

答：接受一个参数，肯定是要保存起来的，以便使用。所以代码应该为：

InvocationHandler handler;

public $Proxy0(InvocationHandler handler)

{

　　this.handler = handler;

}

实现的Collection接口中的各个方法的代码又是怎样的呢？

猜想如下：

//生成的Collection接口中的方法的运行原理

int size()

{

　　return handler.invoke(this,this.getClass().getMethod("size"),null);

}

void clear()

{

　　handler.invoke(this,this.getClass().getMethod("clear"),null);

}

InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？ Cilen程序调用proxy3.add("zhangsan")方法时，涉及三要素：proxy3代理类对象，add方法,"zhangsan"参数，图解说明如下：


分析，

1、为什么先前打印动态类的实例对象时，结果为什么是null，因为打印对象即调用了toString方法，而调用这个方法又会调用InvocationHandler的invoke方法，而这个方法的简单实现的时候是默认返回null的。

2、为什么先前调用有返回基本类型值的方法时会出现NullPointerException异常？因为调用该方法时会调用InvocationHandler的invoke方法，而这个方法的简单实现的时候是默认返回null的。而null是无法转的为要求的基本类型的。

3、为什么的实例对象的getClass（）方法返回了正确结果呢？因为从Object继承的方法中，只有hashCode、equals、toString这三个方法会将请求转发给InvocationHandler对象，其他方法则不会。（即原来是怎么做的还是怎么做）

让动态生成的类成为目标类的代理

动态代理的工作原理图



怎样将目标类传进去？

1、直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入 日志代码，但没有实际意义。

2、为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。

3、让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的 引用变量。

将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。

将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？

把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等执行了外界提供的代码！
为bind方法增加一个Advice参数。

代码如下：

ProxyTest.java

import java.lang.reflect.*;

import java.util.*;

public class ProxyTest {

public static void main(String[] args)
throws Exception {

　　Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);

　　final ArrayList target = new ArrayList();

　　MyAdvice advice = new MyAdvice();

　　Collection proxy3 = (Collection)getProxy(target,advice);

　　proxy3.add("zhangsan");

　　proxy3.add("lisi");

　　proxy3.add("wangwu");

　　System.out.println(proxy3.size());

}

private static Object getProxy(final Object target,final Advice advice) {

　　Object proxy3 = Proxy.newProxyInstance(

　　　　target.getClass().getClassLoader(),

　　　　//new Class[] {Collection.class},

　　　　target.getClass().getInterfaces(),//此方法返回target实现的所有接口的的Class的数组

　　　　new InvocationHandler() {

　　　　　　public Object invoke(Object proxy,
Method method,Object[] args) throws Throwable {

　　　　　　　　 advice.afterMethod(method);//执行外面对象的方法

　　　　　　　　Object retVal = method.invoke(target, args);

　　　　　　 　　advice.beforeMethod(method); //执行外面对象的方法

　　　　　　　　return retVal;

　　　　　　　}});

　　　　　　return proxy3;

　　}

}

Advice.java

import java.lang.reflect.Method;

public interface Advice {

　　void beforeMethod(Method method);

　　void afterMethod(Method method);

}

MyAdvice.java （我们想让代理类增加一些什么功能就编写一个实现Advice接口的类）

import java.lang.reflect.Method;

public class MyAdvice implements Advice {

　　long startTime;

　　@Override

　　public void afterMethod(Method method) {

　　　　startTime = System.currentTimeMillis();

　　　　System.out.println("来黑马学习了！");

　　}

　　@Override

　　public void beforeMethod(Method method) {

　　　　long endTime = System.currentTimeMillis();

　　　　System.out.println("从黑马毕业上班了！");

　　　　System.out.println(method.getName() + "方法的运行时间为：" + (endTime - startTime));

　　}

}

实现AOP功能封装与配置

工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。

BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：

#xxx=java.util.ArrayList

xxx=cn.itcast.ProxyFactoryBean

xxx.target=java.util.ArrayList

xxx.advice=cn.ticast.MyAdvice

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

目标

通知

编写客户端应用：

编写实现Advice接口的类和在配置文件中进行配置

调用BeanFactory获取对象

实例代码如下：用的MyAdvice为上面例子中的代码

1、首先创建一个配置文件，

用xxx作为Key关联一个Value（要创建的类名）

用xxx.advice作为Key关联一个Value（代理类需要的参数：advice类）

用xxx.target作为Key关联一个Value（代理类需要的参数：目标类）

代码如下：

config.properties

xxx=java.util.ArrayList

#xxx=cn.itcast.day3.aopframework.ProxyFactoryBean

xxx.advice=cn.itcast.day3.MyAdvice

xxx.target=java.util.ArrayList

注：

配置文件中的符号 # 为注释符
当需要创建普通的Bean类时，则配置xxx=java.util.ArrayList(这个类可以为任意的普通的类）
如果要创建代理类，则配置xxx=cn.itcast.day3.aopframework.ProxyFactoryBean，这个类为生产代理类的工厂（类）
而xxx.advice可以为任意实现了Advice接口的类，这个类作为代理类的功能扩展。
xxx.target可以为任何类，这个类作为代理类的目标。

2、创建BeanFactory.java 用于产生普通类或代理类

package cn.itcast.day3.aopframework;

import java.io.*;

import java.util.*;

import cn.itcast.day3.Advice;

public class BeanFactory {

　　Properties props = new Properties();

　　public BeanFactory(InputStream in){ //参数为带有配置文件的输入流

　　　　try {props.load(in);}catch (IOException e){} //加载配置文件到Properties类中以方便使用

　　}

　　public Object getBean(String name) throws Exception { //获取Bean对象的方法

　　　　String className = props.getProperty(name); //通过参数name作为Key获取Properties中的Value作为类名

　　　　Class clazz = Class.forName(className); //通过类名获取Class对象

　　　　Object bean = clazz.newInstance(); //通过Class对象创建该类的实例

　　　　if(bean instanceof ProxyFactoryBean)

　　　　//如果通过传递进来的name创建的对象是一个ProxyFactoryBean，则证明需要返回一个代理类，否则直接返回这个对象。

　　　　{

　　　　　　ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;

　　　　　　Advice advice = (Advice) Class.forName(props.getProperty(name + ".advice")).newInstance();//创建功能扩展类的实例

　　　　　　Object target = Class.forName(props.getProperty(name + ".target")).newInstance();//创建目标类的实例

　　　　　　proxyFactoryBean.setAdvice(advice);

　　　　　　proxyFactoryBean.setTarget(target);//把目标类传给代理类工厂，以便生产代理类

　　　　　　return proxyFactoryBean.getProxy();//返回从代理工厂取得的代理类

　　　　}

　　　　return bean; //返回普通的类

　　}

}

3、创建ProxyFactoryBean.java，用于产生代理类

package cn.itcast.day3.aopframework;

import java.lang.reflect.*;

import cn.itcast.day3.Advice;

public class ProxyFactoryBean {

　private Object target;

　　private Advice advice;

　　public Object getProxy() {

　　　　Object proxy = Proxy.newProxyInstance(

　　　　　　target.getClass().getClassLoader(),

　　　　　　target.getClass().getInterfaces(),//此方法返回target实现的所有接口的的Class的数组

　　　　　　new InvocationHandler() {

　　　　　　　　public Object invoke(Object proxy,
Method method,Object[] args) throws Throwable {

　　　　　　　　 advice.afterMethod(method);

　　　　　　　　Object retVal = method.invoke(target, args);

　　　　　　　　 advice.beforeMethod(method);

　　　　　　　　return retVal;

　　　　　}

　　　　});

　　return proxy;

}

public Object getTarget() {

　　return target;

}

public void setTarget(Object target) {

　　this.target = target;

}

public Advice getAdvice() {

　　return advice;

}

public void setAdvice(Advice advice) {

　　this.advice = advice;

}

}

注：上面3个文件组合就是就是Spring框架

4、创建AopFrameworkTest.java，用于测试上面的AOP框架

package cn.itcast.day3.aopframework;

import java.io.*;

public class AopFrameworkTest {

　　public static void main(String[] args)
throws Exception {

　　　　InputStream in = AopFrameworkTest.class.getResourceAsStream("config.properties");//通过给定文件名创建一个输入流

　　　　Object bean = new BeanFactory(in).getBean("xxx");

　　　　System.out.println(bean.getClass().getName());

　　}

}

-------------------- android培训、java培训、期待与您交流！--------------------

详情请查看：http://edu.csdn.net/heima/