49_张孝祥_Java基础加强_分析代理类的作用与原理及AOP概念
l 生活中的代理
Ø 武汉人从武汉的总代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑，你觉得最终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但是，一点区别都没有吗？从代理商那里买真的一点好处都没有吗？
l 程序中的代理
Ø 要为已存在的多个具有相同功能接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等。
代码示例：
class X{
voidsayHello(){
syso:hello,itcast
}
}
Xproxy{
voidsayHello(){
starttime;
x.sayhello();
endtime;
}
}
l 编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。（参看下面原理图）
动态代理技术
l 要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！
l JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
l JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
l CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
l 代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
Ø 1.在调用目标方法之前
Ø 2.在调用目标方法之后
Ø 3.在调用目标方法前后
Ø 在处理目标方法异常的catch块中
50_张孝祥_Java基础加强_创建动态类及查看其方法列表信息
动态代理类获取构造方法和所有方法的代码演示：
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
public class PrroxyTest {
public static void main(String[] args) {
Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);
System.out.println(clazzProxy1.getName());
System.out.println("----------beginconstructors list----------");
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.toString());
}
System.out.println("----------beginmethods list----------");
/*$Proxy0()
$Proxy0(InvocationHandler,int)*/
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.toString());
}
}
}
51_张孝祥_Java基础加强_创建动态类的实例对象及调用其方法
代码示例：
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
public class ProxyTest2 {
public static void main(String[] args)throws Exception {
Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);
Constructor con = clazzProxy1.getConstructor(InvocationHandler.class);
class myInvocationHander1implements InvocationHandler{
@Override
public Object invoke(Object proxy, Method method, Object[]args)
throws Throwable {
return"ok";
}
}
Collection proxy1 = (Collection)con.newInstance(newmyInvocationHander1());
System.out.println(proxy1);//
//proxy1.clear();
proxy1.size();//有返回值，会抛java.lang.ClassCastException异常
}
}
53_张孝祥_Java基础加强_分析InvocationHandler对象的运行原理
54_张孝祥_Java基础加强_总结分析动态代理类的设计原理与结构
l 分析动态代理类的工作原理图
原理图解析：
首先，将InvocationHandler的对象handler传给代理$Proxy1的构造方法；
然后此代理的其他方法需找handler的invoke方法。（这个invoke方法内部可以加入日志功能，通过method还可以调用目标target对应的方法，）
l 怎样将目标类传进去？
Ø 直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，大师没有实际意义。
Ø 为InvocationHandler实现类注入目标类的实例对象，不恩能够采用匿名内部类的实现方式了。
Ø 让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。
l 将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接受目标的同时返回代理类对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
l 将系统功能代码模块化，即将切面代码也改为通用参数形式提供，怎样把执行的系统功能代码以参数的形式提供？
Ø 把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！
Ø 为bind方法增加一个Advice对象。
55_张孝祥_Java基础加强_编写可生成代理和插入通告的通用方法
l 定义契约接口
importjava.lang.reflect.Method;
public interface Advice {
voidbeforeMethod(Method method);
void afterMethod(Method method);
}
l 具体化契约接口
import java.lang.reflect.Method;
public class myAdvice implements Advice{
longbeginTime = 0;
@Override
public void beforeMethod(Method method) {
System.out.println("到传智播客来学习来了！");
beginTime = System.currentTimeMillis();
}
@Override
public void afterMethod(Method method) {
System.out.println("从传智播客毕业上班了！");
long endTime = System.currentTimeMillis();
System.out.println(method.getName() +"method running time is:" + (endTime-beginTime));
System.out.println();
}
}
l 将实例化的契约接口方法添加到代理中
importjava.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class ProxyTest5 {
public static void main(String[] args) {
//Class clazzProxy1 =Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
finalArrayList target =newArrayList();
Collection proxy3 = (Collection)getProxy(target,new myAdvice());
proxy3.add("a");
proxy3.add("b");
proxy3.add("c");
Iterator it = proxy3.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
public 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() {
@Override
public Object invoke(Objectproxy, Method method, Object[] args)
throws Throwable {
advice.beforeMethod(method);
Object reVal = method.invoke(target,args);
advice.afterMethod(method);
return reVal;
}
});
return proxy3;
}
}
56_张孝祥_Java基础加强_实现类似spring的可配置的AOP框架
实现AOP功能的封装与配置
l 工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类的实例对象的getProxy方法返回的对象。
l BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
#xxx = java.util.ArayList
xxx = cn.itcast.ProxyFactoryBean
xxx.target = java.util.ArrayList
xxx.Advice = cn.itcast.MyAdvice
l ProxyFactoryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
Ø 目标
Ø 通知
l 编写客户端运用
Ø 编写实现Advice接口的类黑配置文件中进行配置
Ø 调用BeanFactory获取对象
l Aop编程代码举例
Ø 配置文件
Config.properties
xxx = java.util.ArrayList
#xxx =day29Proxy1AOPFramework.ProxyFactoryBean
xxx.advice = day29Proxy1.myAdvice
xxx.target = java.util.ArrayList
Ø ProxyFactoryBean类
package day29Proxy1AOPFramework;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import day29Proxy1.Advice;
public class ProxyFactoryBean{
private Adviceadvice;
private Objecttarget;
public Advice getAdvice() {
returnadvice;
}
public void setAdvice(Advice advice) {
this.advice = advice;
}
public Object getTarget() {
returntarget;
}
public void setTarget(Object target) {
this.target = target;
}
public Object getProxy(){
Object proxy3= Proxy.newProxyInstance(
target.getClass().getClassLoader()
,/*newClass[]{Collection.class}*/
target.getClass().getInterfaces()
,new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[]args)
throws Throwable {
advice.beforeMethod(method);
Object reVal = method.invoke(target,args);
advice.afterMethod(method);
return reVal;
}
});
return proxy3;
}
}
Ø BeanFactory类
package day29Proxy1AOPFramework;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import day29Proxy1.Advice;
public class BeanFactory {
Properties props = new Properties();
public BeanFactory(InputStream ips){
try {
props.load(ips);
} catch (IOException e) {
e.printStackTrace();
}
}
public Object getBean(String name){
String className = props.getProperty(name);
Object bean = null;
try {
Class clazz = Class.forName(className);
bean = clazz.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
if(beaninstanceof ProxyFactoryBean){
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.getProxy();
} catch (Exception e) {
// TODO Auto-generatedcatch block
e.printStackTrace();
}
return proxy;
}
return bean;
}
}
Ø AopFrameworkTest测试类
package day29Proxy1AOPFramework;
import java.io.InputStream;
import java.util.Collection;
public class AopFrameworkTest {
public static void main(String[] args) {
InputStream ips = AopFrameworkTest.class.getResourceAsStream("Config.properties");
Object bean = new BeanFactory(ips).getBean("xxx");
System.out.println(bean.getClass().getName());
((Collection)bean).clear();
}
}