Java深入（高新技术）（八）：代理技术AOP
深切怀念传智播客张孝祥老师，特将其代表作——Java并发库视频研读两遍，受益颇丰，记以后阅
l 生活中的代理
Ø 武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑，你觉得最终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但是，一点区别都没有吗？从代理商那里买真的一点好处都没有吗？
l 程序中的代理
Ø 要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？
Ø 编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。 （参看下页的原理图）【包装一下】
Ø 如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。
我和你要找的对象给你实现完全相同的目标就行了嘛，我在我的代码里面就能轻易完成我想要的功能【通过管理更好的效率、增加功能等】。
AOP
l 系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：
安全 事务 日志
StudentService ------|----------|------------|-------------
CourseService ------|----------|------------|-------------
MiscService ------|----------|------------|-------------
安全，事务，日志等功能要贯穿到好多个模块中，所以，它们就是交叉业务。
重要原则：不要把供货商暴露给你的客户
l 用具体的程序代码描述交叉业务：
method1 method2 method3
{ { {
------------------------------------------------------切面
.... .... ......
------------------------------------------------------切面
} } }
l 交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：
------------------------------------------------------切面
func1 func2 func3
{ { {
.... .... ......
} } }
------------------------------------------------------切面
l 使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。
以上的抽象说明什么？你的很多模块中只要有许多重复的代码，你就能提取出一个模块来专门进行管理，有共同的就一定要抽象提取出来，这跟以前的SqlHelper思想不是一样吗？
动态代理技术
l 要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！
l JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
l JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
l CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
l 【接口】【子类】都能知道目标类的方法声明
l 代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码【这才是代理类的价值】：
Ø 1.在调用目标方法之前
Ø 2.在调用目标方法之后
Ø 3.在调用目标方法前后
Ø 4.在处理目标方法异常的catch块中
Classproxy{
void sayHello(){
……….
try{
target.sayHello();
}catch(Exception e){
………..
}
………….
}
}
分析JVM动态生成的类
1. Class clazz =Proxy.getProxyClass(ProxyTest.class.getClassLoader(),Collection.class);
System.out.println(clazz.getName());
2. Method[] methods =clazz.getMethods();
for(Method m:methods)
{
System.out.println(m.getName());
}
System.out.println("---------------------");
3. Constructor[] contructors =clazz.getConstructors();
for(Constructor c:contructors)
{
System.out.print(c.getName());
StringBuilder sBuilder = new StringBuilder();
sBuilder.append('(');
Class[] paramTypes =c.getParameterTypes();
for(Class paramType:paramTypes)
{
sBuilder.append(paramType.getName());
sBuilder.append(',');
}
if(paramTypes.length>1)
sBuilder.deleteCharAt(sbf.length()-1);
sBuilder.append(')');
System.out.println(sBuilder.toString());
}
l 创建动态类的实例对象
Ø 用反射获得构造方法
Ø 编写一个最简单的InvocationHandler类
Ø 调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
Ø 打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。
Ø 将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
用下面的代码可以吗？
clazz.newInstance() ;//没有不带参数的构造方法
clazz.getConstructor().newInstance();
4.1
Constructor constructor =clazz.getConstructor(InvocationHandler.class);
4.2
private class MyInvocationHandler(){
public Object invoke(Object proxy,Method method, Object[] args)
throws Throwable {
return null;
}
4.3
System.out.println(obj);//注意，结果为null，其实obj不是null，是其toString方法搞的鬼！
System.out.println(obj.getClass().getName());
obj.clear();//这里为什么要选择一个没有返回值的方法呢？
//proxy.add(“xyz”);//调用有基本类型返回值的方法会抛出异常
//System.out.println(proxy.size());//
4.4
Collection proxy=(Collection)constructor.newInstance(new InvocationHandler(){
@Override
//这里的三个参数正好就是proxy.add(obj)中的三部分 。
public Object invoke(Object proxy,Method method, Object[] args)
throws Throwable {
return null;
}
});
l 总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
Ø 三个方面：
• 生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
• 产生的类字节码必须有个一个关联的类加载器对象；
• 生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
l 用Proxy.newInstance方法直接一步就创建出代理对象。
把
放入内部类的成员中才会返回3
l 动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。
l 构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？你参数传进来的目的肯定是让我调用你的方法。
l 实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？图解说明如下：
同一用一个入口对你的一众方法进行管理。
$Proxy0implements Collection
{
InvocationHandler handler;
public $Proxy0(InvocationHandler handler)
{
this.handler = handler;
}
//生成的Collection接口中的方法的运行原理
int size()
{
returnhandler.invoke(this,this.getClass().getMethod("size"),null);
}
void clear(){
handler.invoke(this,this.getClass().getMethod("clear"),null);
}
boolean add(Object obj){
handler.invoke(this,this.getClass().getMethod("add"),obj);
}
}
在调用目标方法的前后你就可以为所欲为了。
l 分析先前打印动态类的实例对象时，结果为什么会是null呢？调用有基本类型返回值的方法时为什么会出现NullPointerException异常？【size需要返回int，但是你返回null，那不就是null异常了吗？】
l 分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？
Ø 调用调用代理对象的从Object类继承的hashCode,equals, 或toString这几个方法时，代理对象将调用请求转发给InvocationHandler对象，对于其他方法，则不转发调用请求。
动态代理的工作原理图
l 怎样将目标类传进去？
Ø 直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。
Ø 为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。
Ø 让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。
l 将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
l 将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？
Ø 把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！
Ø 为bind方法增加一个Advice参数。
final Collection target = newArrayList();
//目标作为参数，系统功能封装成类【接口】
Collection proxy =getProxy(target,new Advice(){
public void afterMethod() {
System.out.println("来传智学习啦");
}
public void beforeMethod() {
// TODO Auto-generated methodstub
System.out.println("从传智毕业习啦");
}
});
proxy.add("aa");
proxy.add("bb");
System.out.println(proxy.size());
//proxy.clear();
System.out.println(proxy.toString());
System.out.println(((ArrayList)target).get(0));
}
private static Collection getProxy(finalCollection target ,final Advice advice)
throws NoSuchMethodException,InstantiationException,
IllegalAccessException,InvocationTargetException {
Class clazz1 =Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
class MyInvocationHander implementsInvocationHandler {
public Object invoke(Objectproxy, Method method, Object[] args)
throws Throwable {
advice.beforeMethod();
Object retVal =method.invoke(target, args);
advice.afterMethod();
return retVal;
}
}
//Collection proxy =(Collection)clazz.newInstance();
Constructor constructor =clazz1.getConstructor(InvocationHandler.class);
Collection proxy =(Collection)constructor.newInstance(new MyInvocationHander());
return proxy;
}
}
类似spring的AOP
Object obj= BeanFactory.getBean("xxx")
-------------------
config.properties
//xxx=java.util.ArrayList
xxx=cn.itcast.ProxyFactoryBean
xxx.target=java.util.ArrayList
xxx.advice=cn.itcast.MyAdvice
----------------------------------------------
packagecn.itcast.javaehance3.day2;
importjava.io.IOException;
importjava.io.InputStream;
importjava.util.Properties;
publicclass BeanFactory {
/**
*@param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
InputStream ips =BeanFactory.class.getResourceAsStream("config.properties");
BeanFactory beanFactory = newBeanFactory(ips);
Object obj =beanFactory.getBean("xxx");
System.out.println(obj.getClass().getName());
System.out.println(obj.toString());
}
private InputStream ips = null;
private Properties props = newProperties();
public BeanFactory(InputStream ips){
this.ips = ips;
try {
props.load(ips);
} catch (IOException e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
}
Object getBean(String beanName){
Object obj = null;
try {
String className =props.getProperty(beanName);
Class clazz =Class.forName(className);
obj = clazz.newInstance();
if(obj instanceofProxyFactoryBean){
ProxyFactoryBeanfactoryBean = (ProxyFactoryBean)obj;
String adviceName =props.getProperty(beanName + ".advice");
String targetName =props.getProperty(beanName + ".target");
factoryBean.setAdvice((Advice)Class.forName(adviceName).newInstance());
factoryBean.setTarget(Class.forName(targetName).newInstance());
obj =factoryBean.getProxy();
}
} catch (Exception e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
return obj;
}
}
-----------------------------------
packagecn.itcast.javaehance3.day2;
importjava.lang.reflect.Constructor;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.InvocationTargetException;
importjava.lang.reflect.Method;
importjava.lang.reflect.Proxy;
importjava.util.Collection;
publicclass ProxyFactoryBean {
Advice advice = null;
Object target = null;
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(){
Class clazz1 =Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
class MyInvocationHander implementsInvocationHandler {
public Object invoke(Objectproxy, Method method, Object[] args)
throws Throwable {
advice.beforeMethod();
Object retVal =method.invoke(target, args);
advice.afterMethod();
return retVal;
}
}
Object proxy = null;
//Collection proxy =(Collection)clazz.newInstance();
try {
Constructor constructor =clazz1.getConstructor(InvocationHandler.class);
proxy =constructor.newInstance(new MyInvocationHander());
} catch (Exception e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
return proxy;
}
}
-----------------------------------
public class MyAdvice implements Advice
{
public void afterMethod() {
System.out.println("从传智毕业习啦");
}
public void beforeMethod() {
// TODO Auto-generated methodstub
System.out.println("来传智学习啦");
}
}