1. 首先定义拦截器类
拦截器类就是一个普通的类,它有两个方法,一个方法用来定义被拦截对象执行方法前做什么,另一个方法定义被拦截对象执行方法后做什么。
/*
* 拦截器类
*/
public class Interceptor {
public void doBefore(){
System.out.println("do before");
}
public void doAfter(){
System.out.println("do after");
}
}
2. 定义一个目标类
目标类即被拦截处理的对象类。
写道
/**
* 定义目标类接口
* @author JyeChou
*
*/
public interface TargetInterface {
public void doSomething();
}
* 定义目标类接口
* @author JyeChou
*
*/
public interface TargetInterface {
public void doSomething();
}
/**
* 目标类
* @author JyeChou
*
*/
public class TargetImplements TargetInterface {
@Override
public void doSomething() {
System.out.println("Do something!");
}
}
* 目标类
* @author JyeChou
*
*/
public class TargetImplements TargetInterface {
@Override
public void doSomething() {
System.out.println("Do something!");
}
}
3. 定义一个处理器类
处理器类定义什么时候,对目标类的什么方法进行拦截处理。
/**
* 处理类
* @author JyeChou
*
*/
public class MyHandler implements InvocationHandler {
private Object object;
private Interceptor interceptor = new Interceptor();
public void setObject(Object object){
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
interceptor.doBefore();
result = method.invoke(object, args);
interceptor.doAfter();
return result;
}
}
4. 定义一个代理工厂类
通过反射机制对目标对象进行动态代理。
/**
* 代理类
* @author JyeChou
*
*/
public class MyProxy {
//代理是为了获得最终的代理对象,所以返回Object
public Object getProxy(Object object){
MyHandler myHandler = new MyHandler();
myHandler.setObject(object);
return Proxy.newProxyInstance(Target.class.getClassLoader(), object.getClass().getInterfaces(), myHandler);
}
}
5. 使用代理工厂类实现对象代理
/**
* 代理消费类
* @author JyeChou
*
*/
public class Client {
public static void main(String[] args) {
//目标对象
TargetInterface target = new Target();
MyProxy myProxy = new MyProxy();//代理工厂
//生成目标对象的代理
TargetInterface proxy = (TargetInterface) myProxy.getProxy(target);
//执行的是代理对象的方法
proxy.doSomething();
}
}