要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，编写一个与目标类具有相同接口的代理类，代理类的每
个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。 如果采用工厂模式和配置文件的方式进行管理，则不需要
修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换。
代理结构图：
系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：
交叉业务的编程问题即为面向方面的编程，简称AOP。AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方method1 method2 method
{ { {
------------------------------------------------------切面
.... .... ......
------------------------------------------------------切面} } }
法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：
------------------------------------------------------切面
func1 func2 func3
{ { {
.... .... ......
} } }
------------------------------------------------------切面
使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。
注意：
安全，事务，日志等功能要贯穿到好多个模块中，所以，它们就是交叉业务。重要原则：不要把供货商暴露给你的客户。
要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类。
JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代
理类，那么可以使用CGLIB库。
代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系
统功能代码：
例如：1、在调用目标方法之前
2、在调用目标方法之后
3、在调用目标方法前后
4、在处理目标方法异常的catch块中
分析JVM动态生成的类：class proxy{
void sayHello(){
……….
try{
target.sayHello();
}catch(Exception e){
………..
}
………….
}
}
创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。 编码列出动态类中的所有构造方
法和接收参数的类型。
编码列出动态类中的所有构造方法和接收参数的类型。
编码列出动态类中的所有方法和接收参数的类型。
<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
public class ProxyTest {
public static void main(String[] args) {
//编码列出动态类中的所有构造方法和接收参数的类型。
Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
System.out.println(clazzProxy.getName());
System.out.println("--------begin constructors list-------");
Constructor[] constructors = clazzProxy.getConstructors();
for (Constructor constructor : constructors) {
String name = constructor.getName();
StringBuilder sb = new StringBuilder(name);
sb.append("(");
Class[] clazzParams = constructor.getParameterTypes();
for(Class clazzParam : clazzParams) {
sb.append(clazzParam.getName()).append(",");
}
if (clazzParams !=null && clazzParams.length != 0) {
sb.deleteCharAt(sb.length()-1);
}
sb.append(")");
System.out.println(sb.toString());
}
//编码列出动态类中的所有方法和接收参数的类型。
System.out.println("--------begin method list-------");
Method [] methods = clazzProxy.getMethods();
for (Method method : methods) {
String name = method.getName();
StringBuilder sb =new StringBuilder(name);
sb.append("(");
Class[] clazzParams = method.getParameterTypes();
for (Class clazzParam : clazzParams) {
sb.append(clazzParam.getName()).append(",");
}
if(clazzParams !=null && clazzParams.length != 0) {
sb.deleteCharAt(sb.length()-1);
}
sb.append(")");
System.out.println(sb.toString());
}
}
} </span>
</span></span></span>com.sun.proxy.$Proxy0
--------begin constructors list-------
com.sun.proxy.$Proxy0(java.lang.reflect.InvocationHandler)
--------begin method list-------
add(java.lang.Object)
remove(java.lang.Object)
equals(java.lang.Object)
toString()
hashCode()
clear()
contains(java.lang.Object)
isEmpty()
size()
toArray()
toArray([Ljava.lang.Object;)
addAll(java.util.Collection)
iterator()
containsAll(java.util.Collection)
removeAll(java.util.Collection)
retainAll(java.util.Collection)
isProxyClass(java.lang.Class)
getInvocationHandler(java.lang.Object)
getProxyClass(java.lang.ClassLoader,[Ljava.lang.Class;)
newProxyInstance(java.lang.ClassLoader,[Ljava.lang.Class;,java.lang.reflect.InvocationHandler)
wait(long,int)
wait(long)
wait()
getClass()
notify()
notifyAll()
注意：
StringBuilder与StringBuffer的区别？
答：StringBuffer是线程安全的，StringBuilder是线程不安全的。StringBuilder在单线程的时候使用，StringBuffer则是在多线程
的时候使用。因此StringBuilder比StringBuffer效率高一些。
创建动态类的实例对象及调用其方法：步骤：
1、创建动态类的实例对象。通过反射获得构造方法。
2、编写一个最简单的InvocationHandler类。
3、调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去。
4、将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
public class ProxyTest1 {
public static void main(String[] args)throws Exception {
Class<?> clazzProxy =Proxy.getProxyClass(
Collection.class.getClassLoader(),
Collection.class);
Collection<?> proxy = (Collection<?>)clazzProxy.getConstructor(InvocationHandler.class).newInstance(
new InvocationHandler(){
@Override
public Object invoke(Object proxy,Method method,Object[] args)
throws Throwable{
return null;
}
});
System.out.println(proxy);
//结果：null
proxy.clear();
//执行没有返回值的方法，不会报告异常
proxy.size();
}
}
</span></span></span>用Proxy.newInstance方法可以直接一步就创建出代理对象。
<span style="font-size:14px;">import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
public class ProxyTest {
@SuppressWarnings("unchecked")
public static void main (String[] args) throws Exception {
@SuppressWarnings("rawtypes")
Collection proxy = (Collection) Proxy.newProxyInstance(
Collection.class.getClassLoader(),
new Class[]{Collection.class},
new InvocationHandler() {
ArrayList<String> target = new ArrayList<String>();
@Override
public Object invoke(Object proxy, Method method, Object[] args) {
long startTime = System.currentTimeMillis();
Object retVal = method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println(method.getName() + "运行时间" + (endTime - startTime) + "秒");
return retVal;
}
});
proxy.add("黑马程序员训练营");
proxy.add("Android");
proxy.add("黄兴");
}
}
</span>proxy.size()的时候，结果为0。
分析InvocationHandler对象的运行原理：
动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个InvocationHandler参数的构造方法。
构造方法接受一个InvocationHandler对象，接受的对象会通过构造函数赋值给某个成员变量。
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
public class classProxyTest {
@SuppressWarnings("unchecked")
public static void main(String[] args)throws Exception {
@SuppressWarnings("rawtypes")
Collection proxy = (Collection)Proxy.newProxyInstance(
Collection.class.getClassLoader(),
new Class[] {Collection.class },
new InvocationHandler() {
@Override
public Object invoke(Object proxy,Method method, Object[] args)throws Throwable{
return null;
}
});
System.out.println(proxy.getClass());// class com.sun.proxy.$Proxy0
System.out.println(proxy); // 结果：null
proxy.clear();// 执行没有返回值的方法，不会报告异常
proxy.size(); //执行有返回值的方法，会报告异常
}
} 打印动态类的示例对象实际上就是打印proxy的toString方法，也就是执行代理对象中的如下代码：
String toString(){
return handler.invoke(this,this.getClass().getMethod("toString"),null);
}
由于invoke方法返回的是null，打印出来的结果肯定是null。
2.proxy.size(); //执行有返回值的方法，会报告异常 ，为什么会出现NullPointerException异常？
执行proxy.size()方法，就是执行下面的代码：
int size(){
return handler.invoke(this,this.getClass().getMethod("size"),null);
}
由于invoke方法返回的是null，要将null转换为int类型，肯定会报告空指针异常。
3.为什么动态类的实例对象的getClass()方法返回了正确结果呢？
调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时，代理对象将调用请求转发给 InvocationHandler对象，对于其他方法，则不转发调用请求，比如getClass
方法，所以它会返回正确的结果。
总结分析动态代理类的设计原理与结构：
源对象的类必须自己定义时就实现接口，从该类的祖辈类上继承的接口是无效的。将创建代理的过程改为一种更优雅的方式，MyEclipse重构出一个getProxy方法绑定接收目标同时返回
代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式
提供？把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即 等于执行了外界提供的代码！为方法增加一个Advice参数。
工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符 串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类
名不是ProxyFactoryBean，则直接返回该类的 实例对象，否则，返回该类实例对象的getProxy方法返回的对象。
BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
#proxy=java.util.ArrayList
proxy=com.itheima.day03.ProxyFactoryBean
proxy.target=java.util.ArrayList
proxy.advice=com.itheima.day03.MyAdvice
ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？ 1.目标 2. 通知
592
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
