---

单个拦截器(setCallback)、多个拦截器(setCallbacks)、过滤器(setCallbackFilter)、简单例子

---

 

单个拦截器(setCallback)

拦截器实现MethodInterceptor重写interceptor方法，实现代理目标类的目标方法的拦截。

en.setCallback(new MethodInterceptor() {
            
            @Override
            public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
                return arg3.invokeSuper(arg0, arg2);
            }
        });

---

 也可设置多个拦截器(setCallbacks)

设置多个拦截器，可通过过滤器(CallbackFilter)返回的多个拦截器的数组下标值(int)，确定使用哪个拦截器。

TestTranscation tProxy = new TestTranscation();

en.setCallbacks(new Callback[]{tProxy,new MethodInterceptor() {
    
    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
        System.out.println("没有事务的拦截器");
        return arg3.invokeSuper(arg0, arg2);
    }
}});

tProxy是另一个单个拦截器

/* 事务拦截器类 */
class TestTranscation implements MethodInterceptor{
    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
        System.out.println("加上事务的拦截器");
        return arg3.invokeSuper(arg0, arg2);
    }
}

之后可以通过过滤器(setCallbackFilter)筛选拦截器。

过滤器(setCallbackFilter)

这里通过判断方法的注解来筛选拦截器：

/**
 * 设置过滤器，过滤器实现CallbackFilter接口重写accept方法
 * 通过accept方法返回的int下标，用于指定调用哪个拦截器进行拦截处理。
 */
en.setCallbackFilter(new CallbackFilter() {
    
    /* 通过判断拦截的方法上是否有事务注解，从而选择是否需要事务 */
    @Override
    public int accept(Method arg0) {
        TestTransaction annotation = arg0.getAnnotation(TestTransaction.class);
        if(annotation == null){
            return 1;//不是事务拦截器
        }
        return 0;//使用事务拦截器
    }
});

完整例子

代理目标

class GTL{
    public void ydy(){
        System.out.println("没有事务注解的方法被执行");
    }
    @TestTransaction(name = "transactionAnno")
    public void dcq(){
        System.out.println("加上事务注解的方法被执行");
    }
}

事务注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface TestTransaction {
    String name();
}

cglib代理

public class TestCglibDemo {
    public static void main(String[] args) {
        final GTL gtl = new GTL();
        Enhancer en = new Enhancer();
        en.setSuperclass(gtl.getClass());
        /**
         * 设置拦截器，拦截器实现MethodInterceptor重写interceptor方法
         * 实现对代理目标类的方法拦截
         * 
         * 也可以设置多个拦截器     en.setCallbacks(new Callback[]{MethodInterceptor1 ...});
         * 通过过滤器返回的int下标选择调用哪个拦截器对代理目标方法进行处理。
         * 
         */

        // 多个拦截器
        TestTranscation tProxy = new TestTranscation();
        en.setCallbacks(new Callback[]{tProxy,new MethodInterceptor() {
            
            @Override
            public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
                System.out.println("没有事务的    拦截器");
                return arg3.invokeSuper(arg0, arg2);
            }
        }});
        /**
         * 设置过滤器，过滤器实现CallbackFilter接口重写accept方法
         * 通过accept方法返回的int下标，用于指定调用哪个拦截器进行拦截处理。
         */
        en.setCallbackFilter(new CallbackFilter() {
            
            /* 通过判断拦截的方法上是否有事务注解，从而选择是否需要事务 */
            @Override
            public int accept(Method arg0) {
                TestTransaction annotation = arg0.getAnnotation(TestTransaction.class);
                if(annotation == null){
                    return 1;//不是事务拦截器
                }
                return 0;//使用事务拦截器
            }
        });
        
        GTL proxy = (GTL)en.create();
        proxy.ydy();
        proxy.dcq();
    }
}

class GTL{
    public void ydy(){
        System.out.println("没有事务注解的方法被执行");
    }
    @TestTransaction(name = "transactionAnno")
    public void dcq(){
        System.out.println("加上事务注解的方法被执行");
    }
}

运行结果

没有事务的拦截器
没有事务注解的方法被执行
加上事务的拦截器
加上事务注解的方法被执行