代理的概念与作用
代理就是当想要访问程序中的某一个目标类的时候，还想对其绑定一些额外的功能，这时可以通过生成一个代理类，然后通过调用该类实现与目标类的映射。我们可以把这个代理类想象成为目标类的一个镜像，虚拟机可以识别它，然后在代理类内部的方法上其实还是在操作目标类对象的方法。代理架构图
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块中
分析JVM动态生成的类
JVM创建动态类及其实例对象，需要给它提供三种信息：1.生成的类中有哪些方法，通过让其实现目标类接口的方式进行告知
2.产生的类字节码必须有目标类的类加载器对象
3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的.
通过Proxy.newProxyInstance()方法一步创建代理对象，然后由eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，这样就得到了一个通用的产生代理对象的模版方法了。
public static Object getProxy(final Object target,final Advice advice) {
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler(){
@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
advice.beforeMethod(method);//调用系统功能
Object retValue = method.invoke(target, args);//调用目标类的方法
advice.afterMethod(method);
return retValue;
}
}
);
return proxy;
}public interface Advice {
void beforeMethod(Method method);
void afterMethod(Method method);
}public class MyAdvice implements Advice {
long beginTime;
@Override
public void afterMethod(Method method) {
// TODO Auto-generated method stub
long endTime = System.currentTimeMillis();
System.out.println(method.getName() + "运行了" + (endTime - beginTime)+ "毫秒");
}
@Override
public void beforeMethod(Method method) {
// TODO Auto-generated method stub
beginTime = System.currentTimeMillis();
}
}猜想分析动态生成的类的内部代码
动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。$Proxy0 implements Collection
{
InvocationHandler handler;
public $Proxy0(InvocationHandler handler)
{
this.handler = handler;
}
//生成的Collection接口中的方法的运行原理
int size()
{
return handler.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);
}
}
注意：调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时，代理对象将调用请求转发给InvocationHandler对象，对于其他方法，则不转发调用请求。
动态代理的工作原理图
图中的log()就是系统功能模块化。
实现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充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
1.目标(target)
2.通知 (advice)
1.目标(target)
2.通知 (advice)
public class BeanFactory {
/**
* @param args
*/
private InputStream ips = null;
private Properties props = new Properties();
public BeanFactory(InputStream ips){
this.ips = ips;
try {
props.load(ips);//加载配置文件
} catch (IOException e) {
// TODO Auto-generated catch block
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 instanceof ProxyFactoryBean){
ProxyFactoryBean factoryBean = (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 catch block
e.printStackTrace();
}
return obj;
}
}public class 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() {
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler(){
@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
advice.beforeMethod(method);
Object retValue = method.invoke(target, args);
advice.afterMethod(method);
return retValue;
}
}
);
return proxy;
}
}
public class AopFrameworkTest {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
Object bean = new BeanFactory(ips).getBean("xxx");
System.out.println(bean.getClass().getName());
((Collection)bean).clear();
}
}
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
