一.简介
把方法执行的生命周期抽取出来try…catch…finally
把代理模式从抽象的逻辑转化成五个时间节点,把interceptorName传进来后,代理流程什么都不做,所有流程和方法交给拦截器做
二.案例
1.先创建拦截器,接口Interceptor
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public interface Interceptor {
/**
* 方法执行之前做检测,如果返回为false 那么方法终止
*/
Boolean before(Object target, Object proxy, Method method, Object[] args);
/*返回方法执行结果*/
Object around(Object target,Object proxy,Method method,Object[] args) throws InvocationTargetException, IllegalAccessException;
/**
* 方法执行之后,需要将方法执行之后的结果传入
*/
void afterReturning(Object target,Object proxy,Method method,Object[] args,Object result);
/**
* 方法发生异常之后,需要将异常的对象传进来
*/
void afterThrowing(Object target,Object proxy,Method method,Object[] args,Exception e);
void after(Object target,Object proxy,Method method,Object[] args);
}
2.创建实现类InterceptorImpl1
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Date;
//用InterceptorImpl1处理JDKProxyProcessor
public class InterceptorImpl1 implements Interceptor{
//方法执行前进行判断
@Override
public Boolean before(Object target, Object proxy, Method method, Object[] args) {
return true;
}
//方法执行中
@Override
public Object around(Object target, Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
Object result = method.invoke(target,args);
return result;
}
//记录日志
@Override
public void afterReturning(Object target, Object proxy, Method method, Object[] args, Object result) {
System.out.println(new Date() + "use args" +
Arrays.toString(args) + "use " + method.getName() + " get " + result + " as result");
}
@Override
public void afterThrowing(Object target, Object proxy, Method method, Object[] args, Exception e) {
}
@Override
public void after(Object target, Object proxy, Method method, Object[] args) {
}
}
3.创建代理工厂JDKProxyFactory
import java.lang.reflect.Proxy;
public class JDKProxyFactory {
//传入target 目标对象
//return 获得代理对象
public static Object bind(Object target){
//返回代理实例
//getClassLoader类加载器,getInterfaces所有的接口,获取这两个之后创建对象
//getInvocationHandler增强原始对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),new JDKProxyProcessor(target));
}
public static Object bind(Object target, String interceptorName){
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),new JDKProxyProcessor(target,interceptorName));
}
}
4.创建InvocationHandler的子实现类JDKProxyProcessor
import org.springframework.util.StringUtils;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Date;
//InvocationHandler的子实现
public class JDKProxyProcessor implements InvocationHandler {
private Object target;
public JDKProxyProcessor(Object target) {
this.target = target;
}
public JDKProxyProcessor() {
}
private String interceptorName;//接收Interceptor
public JDKProxyProcessor(Object target, String interceptorName) {
this.target = target;
this.interceptorName = interceptorName;
}
/*
* proxy:代理对象
* method:原始对象中的每一个方法 add方法
* args:原始对象被调用的时候的参数 参数a,b
* */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before");
Object result = null;
//把代理模式从抽象的逻辑转化成五个时间节点,把interceptorName传进来后,代理流程什么都不做,所有流程和方法交给拦截器做
if (StringUtils.hasText(interceptorName)){ //判断是否有这个接口名称,也就是是否有该拦截器
//根据名字创建
Interceptor interceptor = (Interceptor)Class.forName(interceptorName).newInstance();
//方法执行的生命周期
try {
if (interceptor.before(target,proxy,method,args)){
//抽取拦截器的5个时间节点,使用这些节点拦截invoke
result = interceptor.around(target,proxy,method,args);
interceptor.afterReturning(target,proxy,method,args,result); //返回之后
}else {
throw new RuntimeException("前置拦截返回为false ,方法终止");
}
}catch (Exception e){
interceptor.afterThrowing(target,proxy,method,args,e); //最终
}finally {
interceptor.after(target,proxy,method,args);
}
}else {//若没有拦截器则按之前的逻辑走
System.out.println("before");
result = method.invoke(target,args);
System.out.println(new Date() + "use args" +
Arrays.toString(args) + "use " + method.getName() + " get " + result + " as result");
}
return result;
}
}
5.创建UserMapperInterface
public interface UserMapperInterface {
void sayHello();
int add(int a,int b);
}
6.创建实现类
public class UserMapper implements UserMapperInterface {
@Override
public void sayHello(){
System.out.println("hello");
}
@Override
public int add(int a, int b) {
return a+b;
}
}
7.创建ProxyMain类
public class ProxyMain {
public static void main(String[] args) {
UserMapper userMapper=new UserMapper();
Interceptor interceptor = new InterceptorImpl1();
//把原始对象和拦截器名字传进去
UserMapperInterface proxyUserMapper1 = (UserMapperInterface) JDKProxyFactory.bind(userMapper,interceptor.getClass().getName());
UserMapperInterface proxyUserMapper2 = (UserMapperInterface) JDKProxyFactory.bind(proxyUserMapper1,interceptor.getClass().getName());
proxyUserMapper2.sayHello();
System.out.println(proxyUserMapper2.add(1,2));
}
}