通过cglib实现AOP 拦截器

package com.apsoft.test.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.CallbackFilter;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import net.sf.cglib.proxy.NoOp;

public class CgLibTest
...{
    public static void main(String argv[])
    ...{
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(TargetClass.class);

        CallbackFilter callbackFilter = new TargetCallbackFilter();
        enhancer.setCallbackFilter(callbackFilter);

        AuthorizationService authorizationService = new AuthorizationServiceImpl();

        Callback saveCallback = new AuthorizationInterceptor(
                authorizationService);
        Callback loadCallback = NoOp.INSTANCE;

        Callback[] callbacks =
        ...{ saveCallback, loadCallback };

        enhancer.setCallbacks(callbacks);

        // enhancer.setCallback(NoOp.INSTANCE);
        Object obj = enhancer.create();
        Logger.debug("开始执行save方法...");
        TargetClass target = (TargetClass) obj;
        target.save();
    }
}

/** *//**
 * 认证拦截器，定义实现了方法拦截器，实现在调用目标方法前先认证。
 * 
 * @author Administrator
 * 
 */
class AuthorizationInterceptor implements MethodInterceptor
...{
    private AuthorizationService[] authorizers = null;

    /** *//**
     * 通过构造函数，注入认证服务处理器
     * 
     * @param authorizers
     */
    public AuthorizationInterceptor(AuthorizationService... authorizers)
    ...{
        this.authorizers = authorizers;
    }

    /** *//**
     * 拦截器处理方法
     */
    public Object intercept(Object object, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable
    ...{
        Logger.debug("拦截器捕获方法调用 method =" + method.getName());
        if (null == authorizers)
        ...{
            return null;
        }
        boolean retFlag = true;
        for (AuthorizationService authorizer : authorizers)
        ...{
            retFlag &= authorizer.authorize(method);
        }
        // 根据认证是否通过，执行不同的操作。
        if (retFlag)
        ...{
            return methodProxy.invokeSuper(object, args);
        }
        else
        ...{
            return null;
        }
    }
}

/** *//**
 * 目标调用回调过滤器
 * 
 * @author Administrator
 * 
 */
class TargetCallbackFilter implements CallbackFilter
...{
    /** *//**
     * 定义方法执行回调函数索引
     * 
     * @method 被调用的方法
     * @return 函数回调索引
     */
    public int accept(Method method)
    ...{
        Logger.debug("执行过滤方法： method = " + method.getName());
        if (method.getName().equals("save"))
        ...{
            return 0;
        }
        return 1;
    }
}

/** *//**
 * 认证服务接口
 * 
 * @author Administrator
 * 
 */
interface AuthorizationService
...{
    public boolean authorize(Method method);
}

/** *//**
 * 认证服务实现类
 * 
 * @author Administrator
 * 
 */
class AuthorizationServiceImpl implements AuthorizationService
...{
    public boolean authorize(Method method)
    ...{
        Logger.debug("执行鉴权操作。");
        return true;
    }
}

/** *//**
 * 被调用的目标类
 * 
 * @author Administrator
 * 
 */
class TargetClass
...{
    public void save()
    ...{
        Logger.debug("调用save方法");
    }

    public void load()
    ...{
        Logger.debug("调用load方法");
    }
}

/** *//**
 * 日志工具类
 * 
 * @author Administrator
 * 
 */
class Logger
...{
    public static void debug(String message)
    ...{
        System.out.println(message);
    }
}