AOP之代理篇

现看静态代理：

package proxy.demo2;

public interface Subject {
    public void request();
}

package proxy.demo2;

public class RealSubject implements Subject{

	public void request() {
		// TODO Auto-generated method stub
		System.out.println("invoke request is RealSubject.request");
	}
    
}

package proxy.demo2;

/**
 * @author spark
 * 代理接口：Subject ；
 * 真实的被代理对象:RealSubject（实现那subject接口）；
 * 代理对象：ProxySubjet;
 * 这里的有几点需要注意的
 * 1：RealSubject是存在的。也就是说ProxySubject
 * 事先是知道代理的对象是谁（这里指的是RealSubject）；
 * 故是一种静态代理；而所谓的Dynamic Proxy是事先不知道被代理的对象的存在，
 * 也就是知道被代理的对象是实现了某个接口的；也就是说真正被代理的对象是动态
 * 产生的。
 * 2：所谓的代理对象只不过是被代理对象的加强版对象
 * 说白那就是RealSubject对象有的功能（说到“功能”两字，大家的脑袋应该立马联想到接口（interface）），
 * ProxySubject都具有；故当RealSubject实现那Subject，那么ProxySubject也要实现Subject接口；
 * 并且在ProxySubject实现的request（）方法中其实是调用那RealSubject的request（）方法；
 * 当然ProxySubject的request()方法也可是RealSubject的request（）方法的加强版；可以在
 * RealSubject.request()方法之前或之后做一些事情
 * 3:由1，2二点可以看出
 * “如果要按照上述的方法使用代理模式，那么真实角色（被代理对象）必须是事先已经存在的，
 * 并将其作为代理对象的内部属性。但是实际使用时，一个真实角色（被代理对象）必须对应一个代理角色（代理对象），
 * 如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？
 * 这个问题引出了Java了一个很有趣的机制--动态代理。”
 * ----------------上面引用于“http://aladdin.iteye.com/blog/40998”
 * 呵呵，希望大家尊重原创，我也是看了aladdin的文章才有所启发的，谢谢aladdin的精彩文章；
 * 只是aladdin有些话太高深，我翻译成大白话，方便以后自己学习；
 * 希望aladdin不要介意
 */
public class ProxySubject implements Subject {
    private RealSubject realsubject;
    public ProxySubject(RealSubject realsubject){
    	this.realsubject=realsubject;
    }
	public void request() {
		// TODO Auto-generated method stub
         this.beforRequest();
         realsubject.request();//这句话才是“代理”二字的真实含义，实际上调用的RealSubject类对象的request（）；
         this.afterRequest();
	}
	//在RealSubject.request()调用之前做一些事情
    private void beforRequest(){
    	System.out.println("befor RealSubject.request()");
    }
    //在RealSubject.request()调用之后做一些事情
    private void afterRequest(){
    	System.out.println("after RealSubject.request()");
    }
}

看测试类

package proxy.demo2;

public class 测试静态代理 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
           Subject proxy=new ProxySubject(new RealSubject());
           //Subject proxy=new ProxySubject(new RealSubject());这行代码
           //也体现那proxy是静态代理，因为它知道该实例化那个代理对象；
           proxy.request();
	}

}

再看动态代理

package proxy.demo2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy implements InvocationHandler {
    private Subject subject;
    public DynamicProxy(Subject subject){
    	this.subject=subject;
    }
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		this.beforRequest();
		method.invoke(subject, args);
		this.afterRequest();
		return null;
	}
//	在RealSubject.request()调用之前做一些事情
    private void beforRequest(){
    	System.out.println("befor RealSubject.request()");
    }
    //在RealSubject.request()调用之后做一些事情
    private void afterRequest(){
    	System.out.println("after RealSubject.request()");
    }
}

看测试类：

package proxy.demo2;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

import proxy.Secretary;
public class 测试动态代理 {

	/**
	 * @param args
	 *  Subject is Interface
	 *	get Subject instance;
	 *  Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
     *        new Class[] { Foo.class }, handler);
	 */
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
       RealSubject real=new RealSubject();
       InvocationHandler handler=new DynamicProxy(real);
       Subject proxy= (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[]{Subject.class}, handler);
       proxy.request();
	}

}

明明是 decorator 模式, 不过 decorator 和 proxy 本身就差不多.

恩,了解,动态代理是利用jdk提供的proxy来实现的.

恩,学习了.标准的使用java.lang.reflect.InvocationHandler的动态代理解决方案
正在尝试写一个小型的aop应用框架,大家多多交流关注
http://www.iteye.com/topic/221172

Spring的AOP基本上就是动态代理加观察者了.


其他Interceptor,比如Hibernate的Interceptor只是基于观察者的,灵活性不好.
而Spring的AOP,动态代理可以对所有接口在运行时生成代理,Advice做为方法Interceptor.