代理
代理的概念与作用
·生活中的代理
武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑，你觉得最终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但是，一点区别都没有吗？从代理商那里买真的一点好处都没有吗？
·程序中的代理
要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？
编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。
如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。
AOP
系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：
安全 事务 日志
StudentService ------|----------|------------|-------------
CourseService ------|----------|------------|-------------
MiscService ------|----------|------------|-------------
用具体的程序代码描述交叉业务：
method1 method2 method3
{ { {
------------------------------------------------------切面
.... .... ......
------------------------------------------------------切面
} } }
交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：
------------------------------------------------------切面
func1 func2 func3
{ { {
.... .... ......
} } }
------------------------------------------------------切面
使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。
注意：
安全，事务，日志等功能要贯穿到好多个模块中，所以，它们就是交叉业务。
重要原则：不要把供货商暴露给你的客户。
动态代理技术
·要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！
·JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
·JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
·CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
·代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
1.在调用目标方法之前
2.在调用目标方法之后
3.在调用目标方法前后
4.在处理目标方法异常的catch块中
创建动态类及查看其方法列表信息
创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
编码列出动态类中的所有构造方法和参数签名。
编码列出动态类中的所有方法和参数签名。
示例：
ProxyTest.java
package com.itheima.day3;
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 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);
}
System. out.println("--------begin methods list-------" );
Method[] methods = clazzProxy.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);
}
}
}
结果：
$Proxy0
--------begin constructors list-------
$Proxy0(java.lang.reflect.InvocationHandler)
--------begin methods list-------
hashCode()
add(java.lang.Object)
clear()
equals(java.lang.Object)
toString()
contains(java.lang.Object)
isEmpty()
addAll(java.util.Collection)
iterator()
size()
toArray()
toArray([Ljava.lang.Object;)
remove(java.lang.Object)
containsAll(java.util.Collection)
removeAll(java.util.Collection)
retainAll(java.util.Collection)
isProxyClass(java.lang.Class)
getProxyClass(java.lang.ClassLoader,[Ljava.lang.Class;)
getInvocationHandler(java.lang.Object)
newProxyInstance(java.lang.ClassLoader,[Ljava.lang.Class;,java.lang.reflect.InvocationHandler)
getClass()
wait(long,int)
wait()
wait(long)
notify()
notifyAll()
注意：
StringBuilder与StringBuffer的区别？
答：StringBuffer是线程安全的，StringBuilder是线程不安全的。
StringBuilder在单线程的时候使用，StringBuffer则是在多线程的时候使用。
因此StringBuilder比StringBuffer效率高一些。
创建动态类的实例对象及调用其方法
创建动态类的实例对象。
用反射获得构造方法。
编写一个最简单的InvocationHandler类。
调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去。
将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
总结思考：
让jvm创建动态类及其实例对象，需要给它提供哪些信息?
答：三个方面：
①生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
②产生的类字节码必须有个一个关联的类加载器对象；
③生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
示例：
ProxyTest.java
package com.itheima.day3;
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 ProxyTest {
public static void main(String[] args) throws Exception {
Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class );
System. out.println("--------begin create instance object-------");
Constructor constructor = clazzProxy.getConstructor(InvocationHandler.class) ;
Collection proxy = (Collection)constructor.newInstance(new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
return null ;
}
});
System. out.println(proxy);
//结果：null
proxy.clear();
//执行没有返回值的方法，不会报告异常
proxy.size();
//执行有返回值的方法，会报告异常
}
}
完成InvocationHandler对象的内部功能
用Proxy.newInstance方法可以直接一步就创建出代理对象。
一个简单的例子：
示例：
package com.itheima.day3;
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 {
public static void main(String[] args) throws Exception {
Collection proxy = (Collection)Proxy.newProxyInstance(
Collection.class.getClassLoader(),
newClass[]{Collection.class},
newInvocationHandler() {
ArrayListtarget=newArrayList();
publicObject invoke(Object proxy, Method method, Object[] args)
throwsThrowable {
longbeginTime = System.currentTimeMillis();
Object retVal = method.invoke(target,args);
longendTime = System.currentTimeMillis();
System.out.println(method.getName() +" running out of "+ (endTime - beginTime));
returnretVal;
}
}
);
proxy.add("zxx");
proxy.add("lhm");
proxy.add("bxd");
System.out.println(proxy.size());
//结果：3
}
}
注意：
如果作为target的ArrayList对象放置在invoke方法内部定义，那么每次调用代理的某个方法，都会调用invoke方法，这样作为target的ArrayList对象每次都会被创建，这样就导致最后调用proxy.size()的时候，结果为0。
分析InvocationHandler对象的运行原理
动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。
构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？
答：接受的对象会通过构造函数赋值给某个成员变量。
示例：
ProxyTest.java
package com.itheima.day3;
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 ProxyTest {
public static void main(String[] args) throws Exception {
Class clazzProxy = Proxy.getProxyClass(Collection. class.getClassLoader(), Collection.class );
System. out .println("--------begin create instance object-------");
Constructor constructor = clazzProxy.getConstructor(InvocationHandler. class) ;
Collection proxy = ( Collection)constructor.newInstance( new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
return null ;
}
});
System. out .println(proxy);
//结果：null
proxy.clear();
//执行没有返回值的方法，不会报告异常
proxy.size();
//执行有返回值的方法，会报告异常
System.out.println(proxy.getClass());
//class $Proxy0
}
}
①分析上面打印动态类的实例对象时，结果为什么会是null呢？
答：打印动态类的示例对象实际上就是打印proxy的toString方法，也就是执行代理对象中的如下代码：
String toString(){
return handler.invoke(this,this.getClass().getMethod("toString"),null);
}
由于invoke方法返回的是null，打印出来的结果肯定是null。
②调用有基本类型返回值的方法时为什么会出现NullPointerException异常？
答：执行proxy.size()方法，就是执行下面的代码：
int size(){
return handler.invoke(this,this.getClass().getMethod("size"),null);
}
由于invoke方法返回的是null，要将null转换为int类型，肯定会报告空指针异常。
③分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？
答：调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时，代理对象将调用请求转发给InvocationHandler对象，对于其他方法，则不转发调用请求，比如getClass方法，所以它会返回正确的结果。
注意：
源对象的类必须自己定义时就实现接口，从该类的祖辈类上继承的接口是无效的。
将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？
把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！为方法增加一个Advice参数。
示例：
Advice.java
package com.itheima.day3;
import java.lang.reflect.Method;
publicinterfaceAdvice {
voidbeforeAdvice(Method method);
voidafterAdvice(Method method);
}
MyAdvice.java
package com.itheima.day3;
import java.lang.reflect.Method;
publicclassMyAdviceimplementsAdvice {
privatelongbeginTime= 0;
publicvoidafterAdvice(Method method) {
longendTime = System.currentTimeMillis();
System.out.println(method.getName() +" running out of "+ (endTime -beginTime));
}
publicvoidbeforeAdvice(Method method) {
beginTime= System.currentTimeMillis();
}
}
ProxyTest.java
package com.itheima.day3;
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 {
public static void main(String[] args) throws Exception {
finalArrayList target =newArrayList ();
Collection collection = (Collection) getProxy(target,newMyAdvice());
collection.add("zxx");
//结果：add running out of 0
}
publicstaticObject getProxy(finalArrayList target,finalAdvice advice) {
Object proxy = Proxy. newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
newInvocationHandler() {
publicObject invoke(Object proxy, Method method, Object[] args)
throwsThrowable {
advice.beforeAdvice(method);
Object retVal = method.invoke(target ,args);
advice.afterAdvice(method);
returnretVal;
}
}
);
returnproxy;
}
}
实现类似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
ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
目标
通知
编写客户端应用：
编写实现Advice接口的类和在配置文件中进行配置
调用BeanFactory获取对象
示例：
ProxyFactoryBean.java
package com.itheima.day3.aopframework;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.itheima.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(){
Object proxy = Proxy. newProxyInstance(
target .getClass().getClassLoader(),
target .getClass().getInterfaces(),
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
advice .beforeAdvice(method);
Object retVal = method.invoke( target ,args);
advice .afterAdvice(method);
return retVal;
}
}
);
return proxy;
};
}
BeanFactory.java
package com.itheima.day3.aopframework;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import com.itheima.day3.Advice;
publicclassBeanFactory {
Propertiesprops=newProperties();
publicBeanFactory(InputStream ips){
try{
props.load(ips);
}catch(IOException e) {
e.printStackTrace();
}
}
publicObject 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(beaninstanceofProxyFactoryBean){
ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
Object proxy =null;
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) {
e.printStackTrace();
}
returnproxy;
}
returnbean;
}
}
AopFrameworkTest.java
package com.itheima.day3.aopframework;
import java.io.InputStream;
publicclassAopFrameworkTest {
publicstaticvoidmain(String[] args)throwsException{
InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
Object bean =newBeanFactory(ips).getBean("xxx");
System.out.println(bean.getClass().getName());
}
}
config.properties
xxx= java.util.ArrayList
//结果：java.util.ArrayList
config.properties
xxx=com.itheima.day3.aopframework.ProxyFactoryBean
xxx.advice= com.itheima.day3.MyAdvice
xxx.target= java.util.ArrayList
//结果：$Proxy0
扫一扫
657
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
