使用cglib实现aop切面编程
我最近在写一个简易的java web框架，其中包括ioc，mvc，aop，dao等基本功能，这几天把aop这块弄得差不多了，所以在这里总结一下。
项目详细信息：coin-framework
spring中核心的概念就是ioc和aop。aop面向切面编程听起来很厉害，所以今天我们用cglib动态代理来实现一个简单的aop。
首先我们模仿一下spring的aop中基于注解的切面编程。
@Aspect 标识切面类
package com.me.coin.framework.aop.annotation;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/**
* 标识切面类
* @author dwl
*
*/
@Documented
@Retention(RUNTIME)
@Target(TYPE)
public @interface Aspect {
//切入点
String pointCut();
//过滤
String filter() default "";
}
@Before 前置通知
package com.me.coin.framework.aop.annotation;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/**
* 前置通知
*
* @author dwl
*
*/
@Documented
@Retention(RUNTIME)
@Target(METHOD)
public @interface Before {
}
@After 后置通知
package com.me.coin.framework.aop.annotation;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/**
* 后置通知
*
* @author dwl
*
*/
@Documented
@Retention(RUNTIME)
@Target(METHOD)
public @interface After {
}
@Throwing 异常通知
package com.me.coin.framework.aop.annotation;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/**
* 异常通知
*
* @author dwl
*
*/
@Documented
@Retention(RUNTIME)
@Target(METHOD)
public @interface Throwing {
}
切面方法封装
package com.me.coin.framework.aop;
import java.lang.reflect.Method;
import com.me.coin.framework.aop.annotation.After;
import com.me.coin.framework.aop.annotation.Before;
import com.me.coin.framework.aop.annotation.Throwing;
import net.sf.cglib.proxy.MethodProxy;
/**
* aop代理
*
* @author dwl
*
*/
public class AopProxy {
//切面类
private Object proxy;
private Method beforeMethod;
private Method afterMethod;
private Method throwingMethod;
public AopProxy(Object proxy) {
this.proxy = proxy;
setValue(proxy.getClass());
}
/**
* 执行动作链
* @param chain
* @param target
* @param method
* @param methodProxy
* @param params
* @return
*/
public Object proceed(ProxyChain chain, Object target, Method method, MethodProxy methodProxy, Object[] params) {
Object result = null;
before(method,params);
try {
AopProxy proxy = chain.next();
if(null != proxy)
result = proxy.proceed(chain,target,method,methodProxy,params);
else
result = methodProxy.invokeSuper(target, params);
after(method,params);
} catch (Throwable e) {
throwing(method,params,e);
} finally {
chain.removeLocal();
}
return result;
}
public void before(Method method, Object[] args){
if(null == beforeMethod)
return;
try {
beforeMethod.setAccessible(true);
beforeMethod.invoke(proxy, new Object[]{method,args});
} catch (Exception e) {
e.printStackTrace();
}
}
public void after(Method method, Object[] args){
if(null == afterMethod)
return;
try {
afterMethod.setAccessible(true);
afterMethod.invoke(proxy, new Object[]{method,args});
} catch (Exception e) {
e.printStackTrace();
}
}
public void throwing( Method method, Object[] args,Throwable e) {
if(null == throwingMethod)
return;
try {
throwingMethod.setAccessible(true);
throwingMethod.invoke(proxy, new Object[]{method,args});
} catch (Exception e1) {
e.printStackTrace();
}
}
public Object getProxy() {
return proxy;
}
public void setProxy(Object proxy) {
this.proxy = proxy;
}
public Method getBeforeMethod() {
return beforeMethod;
}
public void setBeforeMethod(Method beforeMethod) {
this.beforeMethod = beforeMethod;
}
public Method getAfterMethod() {
return afterMethod;
}
public void setAfterMethod(Method afterMethod) {
this.afterMethod = afterMethod;
}
public Method getThrowingMethod() {
return throwingMethod;
}
public void setThrowingMethod(Method throwingMethod) {
this.throwingMethod = throwingMethod;
}
private void setValue(Class clazz){
Method[] methods = clazz.getDeclaredMethods();
for(Method method:methods){
if(method.isAnnotationPresent(Before.class)){
this.beforeMethod = method;
}else if(method.isAnnotationPresent(After.class)){
this.afterMethod = method;
}else if(method.isAnnotationPresent(Throwing.class)){
this.throwingMethod = method;
}
}
}
}
一个类或方法可能被多个切面横切，所以这里要维护一个代理链。
package com.me.coin.framework.aop;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import net.sf.cglib.proxy.MethodProxy;
/**
* 代理链
*
* @author dwl
*
*/
public class ProxyChain {
private List proxies = new ArrayList<>();
//保证线程安全
private ThreadLocal currentIndex = new ThreadLocal(){
protected Integer initialValue() {
return 0;
};
};
/**
* 获取下一个节点
* @return
*/
public AopProxy next(){
if(currentIndex.get() >= proxies.size())
return null;
AopProxy proxy = proxies.get(currentIndex.get());
currentIndex.set(currentIndex.get()+1);
return proxy;
}
/**
* 执行代理链
* @return
*/
public Object handler(Object target, Method method, MethodProxy methodProxy, Object[] args){
return next().proceed(this, target, method, methodProxy, args);
}
public List getProxies() {
return proxies;
}
public void setProxies(List proxies) {
this.proxies = proxies;
}
public void removeLocal(){
this.currentIndex.remove();
}
}
生成代理对象
package com.me.coin.framework.aop;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
* aop
*
* 根据代理链生成代理后的对象
*
* @author dwl
*
*/
public class ProxyManager {
/**
* @param clazz
*
* 被横切的类
* @param chain
*
* 代理链
* @return
*
* 生成一个代理实例
*/
@SuppressWarnings("unchecked")
public static T getProxy(Class clazz,ProxyChain chain){
return (T) Enhancer.create(clazz, new MethodInterceptor(){
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
return chain.handler(obj, method, proxy, args);
}
});
}
}
在ioc初始化的时候生成被代理类和代理链的关系，再生成被代理后的对象放入ioc中。
package com.me.coin.framework.aop;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.me.coin.framework.aop.annotation.Aspect;
import com.me.coin.framework.ioc.CoinIocCache;
import com.me.coin.framework.util.ClassHelper;
/**
* 切面上下文
*
* @author dwl
*
*/
public class AopCache {
private static Map, ProxyChain> cache = new HashMap<>();
/**
* 生成代理链
* @param clazz
* @param ioc
*/
public static void add(Class clazz,CoinIocCache ioc){
Aspect aspect = clazz.getAnnotation(Aspect.class);
List> list = ClassHelper.findClassBypackageName(aspect.pointCut().split(","));
AopProxy proxy = new AopProxy(ioc.getCoinBean(clazz).getBean());
for(Class cls:list){
if(cache.containsKey(cls)){
cache.get(cls).getProxies().add(proxy);
}else{
ProxyChain chain = new ProxyChain();
chain.getProxies().add(proxy);
cache.put(cls, chain);
}
}
}
public static Set> getProxyClass(){
return cache.keySet();
}
public static ProxyChain getChain(Class clazz){
return cache.get(clazz);
}
}
ioc初始化的一些代码
public class CoinIocImpl implements CoinIoc{
private static Logger logger = LoggerFactory.getLogger(CoinIoc.class);
private static CoinIocCache cache = new CoinIocCache();
//初始化ioc容器 controller service 以及一些组件都需要交给ioc
static {
logger.info("CoinIoc - 初始化开始...");
List> classes = ClassHelper.findClassBypackageName(PropertyUtils.getPropertyArray((Constants.IOC_PACKAGE)));
classes.forEach(clazz->{
if(clazz.isAnnotationPresent(Act.class)){
cache.addActionBean(clazz);;
logger.info("CoinIoc - 加载controller类：{}",clazz.getName());
}
if(clazz.isAnnotationPresent(Service.class)){
cache.addServiceBean(clazz);
logger.info("CoinIoc - 加载service类：{}",clazz.getName());
}
if(clazz.isAnnotationPresent(IocBean.class)){
cache.addIocBean(clazz);
//切面
if(clazz.isAnnotationPresent(Aspect.class))
AopCache.add(clazz,cache);
logger.info("CoinIoc - 加载组件bean类：{}",clazz.getName());
}
});
//aop
AopCache.getProxyClass().forEach(clz->{
cache.addAopBean(clz);
});
}
@SuppressWarnings("unchecked")
public T getBean(Class clazz) {
if(!cache.hasCoinBean(clazz))
throw new BeanNotFoundException("CoinIoc - 无法获取该实例对象-" + clazz.getName());
CoinBean coinBean = cache.getCoinBean(clazz);
if(!coinBean.isInject())
return injectBean(clazz);
return (T) coinBean.getBean();
}
} ioc 存放所有bean的容器
package com.me.coin.framework.ioc;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.me.coin.framework.aop.AopCache;
import com.me.coin.framework.aop.ProxyChain;
import com.me.coin.framework.aop.ProxyManager;
import com.me.coin.framework.dao.impl.CoinDao;
import com.me.coin.framework.ioc.annotation.IocBean;
import com.me.coin.framework.tx.TransactionProxy;
import com.me.coin.framework.tx.annotation.Service;
import com.me.coin.framework.util.Strings;
/**
* 存放所有bean的容器
* @author dwl
*
*/
public class CoinIocCache {
//存放所有的bean
private Map, CoinBean> cache = new HashMap, CoinBean>();
public CoinIocCache() {
CoinBean dao = new CoinBean("coinDao", new CoinDao());
dao.setInject(true);
cache.put(CoinDao.class,dao);
}
/**
* controller类
* @param clazz
*/
public void addActionBean(Class clazz){
try {
String name = Strings.lowerFirst(clazz.getSimpleName());
cache.put(clazz, new CoinBean(name, clazz.newInstance()));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* service类通过动态代理生成
* @param clazz
*/
public void addServiceBean(Class clazz){
Object bean = TransactionProxy.getProxy(clazz);
Service service = clazz.getAnnotation(Service.class);
String name = service.value();
if(Strings.isEmpty(name))
name = Strings.lowerFirst(clazz.getSimpleName());
cache.put(clazz, new CoinBean(name, bean));
}
/**
* 普通bean类
* @param clazz
*/
public void addIocBean(Class clazz){
try {
IocBean iocBean = clazz.getAnnotation(IocBean.class);
String name = iocBean.value();
if(Strings.isEmpty(name))
name = Strings.lowerFirst(clazz.getSimpleName());
cache.put(clazz, new CoinBean(name, clazz.newInstance()));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* aop切面后的bean
* @param clazz
*/
public void addAopBean(Class clazz){
String name = "";
if(clazz.isAnnotationPresent(IocBean.class))
name = clazz.getAnnotation(IocBean.class).value();
if(clazz.isAnnotationPresent(Service.class))
name = clazz.getAnnotation(Service.class).value();
ProxyChain chain = AopCache.getChain(clazz);
Object bean = ProxyManager.getProxy(clazz, chain);
if(Strings.isEmpty(name))
name = Strings.lowerFirst(clazz.getSimpleName());
cache.put(clazz, new CoinBean(name, bean));
}
} 使用方法跟spring有点像
package com.dwl.controller;
import java.lang.reflect.Method;
import com.me.coin.framework.aop.annotation.After;
import com.me.coin.framework.aop.annotation.Aspect;
import com.me.coin.framework.aop.annotation.Before;
import com.me.coin.framework.aop.annotation.Throwing;
import com.me.coin.framework.ioc.annotation.IocBean;
@IocBean//交给ioc
@Aspect(pointCut="com.dwl.controller")//切面 pointCut：切入点
public class AspectT {
@Before
void start(Method method,Object[] args){
System.out.println("前置通知");
System.out.println(method.getName());
}
@After
void end(Method method,Object[] args){
System.out.println("后置通知");
}
@Throwing
void error(Method method,Object[] args){
System.out.println("异常通知");
}
}
由于aop与ioc有交叉的地方，有一些代码可能没贴上来，感兴趣的同学请戳这里：coin-framework