|
------- android培训、java培训、期待与您交流！ ----------
代理的概念和作用
l 生活中的代理
武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑，你觉得最终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但是，一点区别都没有吗？从代理商那里买真的一点好处都没有吗？
l 程序中的代理
要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？
编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。 （参看下页的原理图）
如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易
AOP
l 系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：
安全 事务 日志
StudentService ------|----------|------------|-------------
CourseService ------|----------|------------|-------------
MiscService ------|----------|------------|-------------
l 用具体的程序代码描述交叉业务：
method1 method2 method3
{ { {
------------------------------------------------------切面
.... .... ......
------------------------------------------------------切面
} } }
l 交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：
------------------------------------------------------切面
func1 func2 func3
{ { {
.... .... ......
} } }
------------------------------------------------------切面
l 使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。
动态代理技术
l 要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！
l JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
l JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
l CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
l 代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
1.在调用目标方法之前
2.在调用目标方法之后
3.在调用目标方法前后
4.在处理目标方法异常的catch块中（应用范围比较广）
分析JVM动态生成的类
l 创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
l 编码列出动态类中的所有构造方法和参数签名
l 编码列出动态类中的所有方法和参数签名
l 创建动态类的实例对象
用反射获得构造方法
编写一个最简单的InvocationHandler类
调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。
将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
l 总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
三个方面：
生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
产生的类字节码必须有个一个关联的类加载器对象；
生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
l 用Proxy.newInstance方法直接一步就创建出代理对象。
让动态生成的类成为目标类的代理
l 怎样将目标类传进去？
直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。
为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。
让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。
l 将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
l 将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？
把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！
为bind方法增加一个Advice参数。
猜想分析动态生成的类的内部代码：
|-动态生成的类实现了Collection接口(可以实现若干接口)，生成的类有Collection接口中的所有方法和一个如下接受 InvocationHandler参数的构造方法。
|-构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会怎么样呢？
|-实现Collection接口中的各个方法的代码又是怎么样的呢？
InvocationHandler接口中定义的invoke的方法接受
的三个参数又是什么意思？图解说明如下：
代码示例：
package day3;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
public class ProxyTest {
/**
* @param args
* @throws NoSuchMethodException
* @throws SecurityException
* @throws InvocationTargetException
* @throws IllegalAccessException
* @throws InstantiationException
* @throws IllegalArgumentException
*/
public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException,
InstantiationException, IllegalAccessException, InvocationTargetException {
// TODO Auto-generated method stub
//返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。
Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
System.out.println(clazzProxy1.getName());
//获取代理类的构造方法
Constructor[] constructors = clazzProxy1.getConstructors();
for(Constructor constructor : constructors)
{
String name = constructor.getName();
StringBuilder sBuilder = new StringBuilder(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);
}
//获取代理类的方法。
Method[] methods = clazzProxy1.getMethods();
for(Method method : methods)
{
String name = method.getName();
StringBuilder sBuilder = new StringBuilder(name);
sBuilder.append('(');
Class[] clazzParams = method.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);
}
class MyInvocationHandler implements InvocationHandler{
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
return null;
}
}
/*动态类第一种方式：
//返回代理的字节码。
Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHandler());此处需要些匿名内部类或者创建一个类。
*/
//clazzProxy1.newInstance();不能用这个生成动态代理，因为他没有无参的构造方法。newInstance()只能生成午餐的构造方法。
Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
//创建动态实体对象，需要传参new MyInvocationHandler(),可以用匿名内部类写
Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHandler());
System.out.println(proxy1);//打印结果为Null有可能没建立对象或者内部数据位空。分析，如果没建立对象那么他会报空指针异常。
//第二种创建动态代理方式：
Collection proxy3 = (Collection)Proxy.newProxyInstance(Collection.class.getClassLoader(),
new Class[]{Collection.class},//接口类型因为可能有多个，所以用Class[]数组.(不能使用可变参数因为Class不在最后面无法使用)
//创建InvocationHandler匿名内部类。
new InvocationHandler(){
//作为成员变量就每次调用只创建一个对象。
ArrayList target = new ArrayList();
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
long startTime = System.currentTimeMillis();
//ArrayList target = new ArrayList();局部变量就每次调用都会创建一个ArrayList集合。
Object reVal = method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println(method.getName()+":::startTime-endTime= "+(startTime-endTime));
return reVal;
}
});
proxy3.add("abc");
proxy3.add("123c");
proxy3.add("bbb");
System.out.println("size::"+proxy3.size());
}
}
-----------------------------------------------------------
56 实现类似spring的可配置的AOP框架
需求：
工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串
返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例
对象，否则，返回该类实例对象的getProxy方法返回的对象。
BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
#xxx=java.util.ArrayList
xxx=cn.itcast.ProxyFactoryBean
xxx.target=java.util. ArrayList
xxx.advice=cn.itcast.Myadvice
ProxyFactoryBean充当封装成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
目标 target
通知 advice
编写客户端应用：
编写实现Advice接口的类和配置文件中进行配置
调用BeanFactory获取对象
package cn.itcast.day3.aopframework;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import cn.itcast.day3.Advice;
public class BeanFactory {
Properties props = new Properties();
public BeanFactory(InputStream ips){
try {
props.load(ips);
} catch (IOException e) {
//商业行的项目85%以上都是处理各种意外。
e.printStackTrace();
}
}
//返回代理或者目标。
public Object getBean(String name){
String className = props.getProperty(name);//根据名字拿到类名。
Object bean = null;//bean放在这里是因为if也用到了bean。但是if它没在try代码里面
//对于java bean来说必须要有一个不带参数的构造方法。因为创建实例对象用的就是这个。
try {
Class clazz = Class.forName(className);
bean = clazz.newInstance();
} catch (Exception e) {
// TODO: handle exception
}
if(bean instanceof ProxyFactoryBean){
//用这个beanFactory创建实例对象。
Object proxy =null;
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.setAdvice(advice);
proxyFactoryBean.setTarget(target);
proxy = ((ProxyFactoryBean)bean).getProxy();
} catch (Exception e) {
// TODO: handle exception
}
return proxy;
}
return bean;
}
}
package cn.itcast.day3.aopframework;
import java.io.InputStream;
public class AopFrameworkTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建流读取配置文件
InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
//读取文件名为xxx的类。
Object bean = new BeanFactory(ips).getBean("xxx");
//查看字节码名称
System.out.println(bean.getClass().getName());
}
}
package cn.itcast.day3.aopframework;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import javax.lang.model.type.PrimitiveType;
import cn.itcast.day3.Advice;
//生成动态代理类
public class ProxyFactoryBean {
private Advice advice;
private Object target;
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;
}
public Object getProxy() {
// TODO Auto-generated method stub
Object proxy3 = Proxy.newProxyInstance(
//Collection.class.getClassLoader(), 返回传入类加载器
target.getClass().getClassLoader(),
//new Class[]{Collection.class},返回传入类接口
target.getClass().getInterfaces(),
new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//传入执行前的方法参数，该方法为MyAdvice类实现Advice接口覆盖的方法。
advice.beforeMethod(method);
Object reVal = method.invoke(target, args);
//传入执行后的方法参数，这里必须传入method不传会报错。具体原因还不知道。
advice.afterMethod(method);
return reVal;
}
});
return proxy3;
}
}
配置文件：
#xxx=java.util.ArrayList
xxx=cn.itcast.day3.aopframework.ProxyFactoryBean
xxx.advice=cn.itcast.day3.MyAdvice
xxx.target=java.util.ArrayList
< ------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------/p>
| 
转播
