Java基础加强总结(5)(代理)

代理

代理的概念与作用

为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等。

代理类与目标类具有相同接口的类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能代码。

采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类或者代理类，这样容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。

如下：X的代理类XProxy，与X具有相同的方法声明，代理类的方法可以执行X类的功能，同时加上系统辅助功能。以后使用X类时，直接使用它的代理类就好了。

class X {
static void sayHello(){
System.out.println("hello ! itcast !");
}
}
class XProxy{
static void sayHello(){
starttime();
X.sayHello();
endtime();
}
private static void endtime() {
}
private static void starttime() {
}
}

代理原理图：代理类和原类实现相同的接口，代理类具有原类相同的方法，此方法调用原类对应的方法外，附加额外的系统辅助代码功能，使用代理时，引用它的接口。



面向方面的编程---Aspect oriented program 简称AOP

系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下

安全 事务 日志

StudentService ----- |---------|--------|-----------

CourseService ------|---------|--------|-----------

MiscService ------|---------|--------|-----------

用具体的程序代码描述交叉业务：

mehtod1 method2 method3

{ { {

-----------------------------------------------切面

........

-----------------------------------------------切面

} } }

AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果一样。

-----------------------------------------------切面

mehtod1 method2 method3

{ { {

........

} } }

-----------------------------------------------切面

使用代理技术可以解决这种问题，代理是实现AOP功能的核心和关键技术。

动态代理技术

要为系统中得各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情，写成百上千个代理，工作量太大。

JVM可以在运行期动态生成出类的字节码，这种动态生出的类往往被用作代理类，即动态代理类。

JVM生成的动态类必须实现一个或者多个接口，所以，JVM生出的动态类只能用作具有相同接口的目标类的代理。

CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，可以使用CGLIB库。

代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：

1.在调用目标方法之前

2.在调用目标方法之后

3.在调用目标方法前后

4.在处理目标方法异常的catch块中

分析JVM动态生成的类

创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass()方法的各个参数。

编码列出动态类中得所有构造方法和参数签名。

编码列出动态类中得所有方法和参数签名。

创建动态类的实例对象。

用反射获得构造方法。

编写一个最简单的InvocationHandler类

调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传出去。

打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。

将创建动态类的实例对象的代理修改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。

总结思考：让JVM创建动态类，需要给它提供哪些信息?

三个方面

1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知。

2.产生的类字节码必须有一个关联的类加载器对象。

3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHander对象的invoke方法中加一点代码，就可以看到这些代码，就可以看到这些代码被调用运行了。

用Proxy.newInstance方法直接一步就创建出代理对象。

演示，用JVM动态生成java类，并打印出这个类的构造函数和方法等信息

package test;

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 clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
System.out.println("类名"+clazzProxy1.getName());
//这个类有什么样的构造方法
System.out.println("这个类的构造方法====");
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("这个类的方法====");
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());
}
}
}

运行结果：

$Proxy0

这个类的构造方法====

$Proxy0(java.lang.reflect.InvocationHandler)

这个类的方法====

add(java.lang.Object)

hashCode()

clear()

equals(java.lang.Object)

toString()

contains(java.lang.Object)

isEmpty()

addAll(java.util.Collection)

iterator()

size()

toArray([Ljava.lang.Object;)

toArray()

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)

wait()

wait(long,int)

wait(long)

getClass()

notify()

notifyAll()

用动态生成的类创建实例

package test;

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 clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
System.out.println("类名"+clazzProxy1.getName());
//这个类有什么样的构造方法
System.out.println("这个类的构造方法====");
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("这个类的方法====");
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());
}

System.out.println("开始创建动态类的实例对象！");

Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
class MyInvocationHander implements InvocationHandler{
@Override
public Object invoke(Object arg0, Method arg1, Object[] arg2)
throws Throwable {
// TODO Auto-generated method stub
return null;
}
}
Collection proxy1 = (Collection) constructor.newInstance(new MyInvocationHander());
System.out.println(proxy1);
proxy1.clear();
//不能调用有返回值的方法
proxy1.size();
}
}

用Proxy.newInstance方法直接创建代理对象

final ArrayList target = new ArrayList();
Collection proxy3 = (Collection)Proxy.newProxyInstance(
Collection.class.getClassLoader(),
new Class[] {Collection.class},
new InvocationHandler(){
@Override
public Object invoke(Object arg0, Method method, Object[] arg2)
throws Throwable {

long beginTime = System.currentTimeMillis();
Object retVal = method.invoke(target, arg2);
long endTime = System.currentTimeMillis();
System.out.println(method.getName()+"运行了"+ (endTime - beginTime));
return retVal;
}

});
proxy3.add("zxx");
proxy3.add("lhm");
proxy3.add("bxd");
System.out.println(proxy3.size());

运行结果：

add运行了0

add运行了0

add运行了0

size运行了0

3

分析InvocationHandler对象的运行原理

Client程序调用objProxy.add("abc")方法时，涉及三要素：objProxy对象、add方法、"abc"参数。

Object invoke(Object arg0, Method method, Object[] arg2)

从Object继承的方法只有hashCode、equals、toString派发给InvocationHandler对象，其他的对象都不派发。

动态代理的工作原理图



让动态生成的类成为目标类的代理

怎样将目标类传进去？

1.直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。

2.为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。

3.让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。

将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。

将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的代码以参数形式提供呢？

1.要把执行代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码。

2.为bind方法增加一个Advice参数。

编写可生成代理和插入通告的通用方法，封装目标，和系统功能代码

package test;

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 {
final ArrayList target = new ArrayList();
final MyAdvice myAdvice = new MyAdvice();
Collection proxy3 = (Collection) getProxy(target,myAdvice);
proxy3.add("zxx");
proxy3.add("lhm");
proxy3.add("bxd");
System.out.println(proxy3.size());
}
private static Object getProxy(final Object target,final Advice advice) {
Object proxy3 = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler(){
@Override
public Object invoke(Object arg0, Method method, Object[] arg2)
throws Throwable {
advice.beforeMehtod(method);
Object retVal = method.invoke(target, arg2);
advice.afterMethod();
return retVal;
}
});
return proxy3;
}
}

实现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充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？

1.目标

2.通知

编写客户端应用：

1.编写实现Advice接口的类和在配置文件中进行配置。

2.调用BeanFactory获取对象。

bean工厂

package aopframweek;
import java.io.InputStream;
import java.util.Properties;
import test.Advice;
public class BeanFactory {
Properties props = new Properties();
public BeanFactory(InputStream ips){
try{
props.load(ips);
}catch(Exception e){
e.printStackTrace();
}
}
public Object getBean(String name){
String className = props.getProperty(name);
Class clazz = null;
Object bean = null;
try {
clazz = Class.forName(className);
bean = clazz.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
if(bean instanceof ProxyFactoryBean){
ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
Advice advice = null;
Object target = "";
try {
advice = (Advice) Class.forName(props.getProperty(name+".advice")).newInstance();
target = Class.forName(props.getProperty(name+".advice")).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
proxyFactoryBean.setAdvice(advice);
proxyFactoryBean.setTarget(target);
Object proxy = (proxyFactoryBean).getProxy();
return proxy;
}
return bean;
}
}

代理工厂bean

package aopframweek;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import test.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 proxy3 = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler(){
@Override
public Object invoke(Object arg0, Method method, Object[] arg2)
throws Throwable {
advice.beforeMehtod(method);
Object retVal = method.invoke(target, arg2);
advice.afterMethod();
return retVal;
}
});
return proxy3;
}
}

配置文件

#xxx=java.util.ArrayList
xxx=aopframweek.ProxyFactoryBean
xxx.advice=test.MyAdvice
xxx.target=java.util.ArrayList

测试类

package aopframweek;

import java.io.InputStream;

public class AopFramworkTest {
public static void main(String[] args) {
InputStream ips = AopFramworkTest.class.getResourceAsStream("config.properties");
Object bean = new BeanFactory(ips).getBean("xxx");
System.out.println(bean.getClass().getName());
}
}