1.拦截器是调用方法的改进.当称某个实例是拦截器是,这是就其行为上而言的;
2.从代码的角度来看,拦截器就是一个类,这个类也包含方法,只是这个方法是个特殊方 法,它会在目标方法调用之前“自动”执行
3.拦截器方法大都是通过代理的方式来调用的
4.jdk动态代理只能对实现了接口的实例来生成代理,因此必须提供一个接口:
(1)Dog.java接口
//代理接口
public interface Dog {
public void info();
public void run();
}
(2)DogImpl.java实现类
import com.Dog;
//DOc的实现类:
public class DogImpl implements Dog {
public void info() {
System.out.println("我是一直猎狗");
}
public void run() {
System.out.println("我奔跑迅速");
}
}
(3)DogIntercepter.java拦载器类
//拦截器类
public class DogIntercepter {
public void method1(){
System.out.println("模拟通用方法一");
}
public void method2(){
System.out.println("模拟通用方法二");
}
}
(4)ProxyHandler.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//关键是下面的ProxyHandler类,该类实现InvocationHandler接口,<该接口可以动态调用目标对象的方法>
public class ProxyHandler implements InvocationHandler {
private Object target;
DogIntercepter di = new DogIntercepter();
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
Object result = null;
if(method.getName().equals("info")){
di.method1();
result = method.invoke(target, args);
di.method2();
}else{
result = method.invoke(target, args);
}
return result;
}
public void setTarget(Object o){
this.target = o;
}
}
(5)TestDog.java测试类
import intercepterhandle.ProxyHandler;
import java.lang.reflect.Proxy;
import com.Dog;
import com.impl.DogImpl;
//测试类
public class TestDog {
/**
* @param args
*/
public static void main(String[] args) {
Dog targetObject = new DogImpl();//目标对象
Dog dog = null;
ProxyHandler handler = new ProxyHandler();
handler.setTarget(targetObject);
//第一个参数是用来创建动态代理的ClassLoader对象,只要该对象能访问Dog接口即可
//第二个参数是接口数组,正是代理该接口的数组
//第三个参数是代理包含的处理实例
Object proxy = Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(), handler);
if(proxy instanceof Dog){
dog = (Dog)proxy;//代理对象实际上也实现了接口Dog
}
dog.info();
dog.run();
}
}