AOP之代理篇

现看静态代理：
[code]
package proxy.demo2;

public interface Subject {
public void request();
}

[/code]
[code]
package proxy.demo2;

public class RealSubject implements Subject{

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

}
[/code]
[code]
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()");
}
}

[/code]
看测试类
[code]
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();
}

}
[/code]
再看动态代理
[code]
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()");
}
}

[/code]

看测试类：
[code]
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();
}

}

[/code]