Spring的AOP

一、实现自己的AOP

在之前一篇随笔中已经详细讲解了java的动态代理机制，我们也知道了AOP的底层其实就是基于动态代理机制实现的，所以这里先自己实现一下AOP

public class DynamicProxy implements InvocationHandler
{    // 要代理的对象    private Object target;    // 将构造方法禁用掉，不让外部通过new来得到DynamicProxy对象    private DynamicProxy()
    {
    };    /**
     * 返回一个动态的代理对象
     * 
     * @param object
     * @return     */    public static Object newInstance(Object object)
    {
        DynamicProxy proxy = new DynamicProxy();
        proxy.target = object;        //    通过Proxy的newProxyInstance方法来得到一个代理对象
        Object result = Proxy.newProxyInstance(object.getClass()
                .getClassLoader(), object.getClass().getInterfaces(), proxy);        return result;
    }

    @Override    public Object invoke(Object proxy, Method method, Object[] args)            throws Throwable
    {//        //    只有方法名为add和delete时候才引入日志//        if(method.getName().equals("add") || method.getName().equals("delete"))//        {//            Logger.logInfo("动态代理类");//        }        
        // 根据LogAnnotation来判断，如果被标注了注解，则输出日志        if(method.isAnnotationPresent(LogAnnotation.class))
        {
            LogAnnotation log = method.getAnnotation(LogAnnotation.class);
            Logger.logInfo(log.value());
        }
        
        Object object = method.invoke(target, args);        return object;
    }
}

就如上篇随笔所说，动态代理类必须要实现InvocationHandler的这个接口，我们的这个类当然也要实现这个接口了。然后在里面定义了一个私有的Object属性，表示我们要代理的对象。这里我们将这个类的构造方法禁用掉，使其不能通过外部直接new出来一个对象，然后我们写一个newInstance的方法来给我们的代理对象赋初值，并且返回的就是我们的代理对象。我们看看在beans.xml中的配置文件

因为我们的DynamicProxy类的对象以及代理对象是通过static方法来进行注入的，因此我们如果要对其进行注入的话，需要通过 factory-method 这个属性来给我们的静态方法进行属性注入，通过 来讲参数传递进去，这样我们的userDAOProxy就是一个代理对象了。

二、通过Annotation来配置我们的AOP

我们要将AOP的schema引入，如果使用注解的话，还要开启AOP的自动代理

然后我们来看看我们的切面类：

@Component("logAspect")    //    将该切面类由Spring托管@Aspect    //    声明该类是一个Aspect,切面类public class LogAspect
{    /**
     * execution(* com.xiaoluo.dao.*.add*(..))
     * 第一个*表示任意返回值
     * 第二个*表示com.xiaoluo.dao下的所有类
     * 第三个*表示所有以add开头的方法
     * (..)表示方法接收的任何参数     */    /*
     * Before在方法执行前执行     */
    @Before("execution(* com.xiaoluo.dao.*.add*(..))||" +
            "execution(* com.xiaoluo.dao.*.delete*(..))||" +
            "execution(* com.xiaoluo.dao.*.update*(..))")    public void logStart(JoinPoint jp)
    {        //    得到该JoinPoint的类        System.out.println(jp.getTarget());        //    得到该JoinPoint的方法        System.out.println(jp.getSignature());        //    得到该JoinPoint的方法的名字        System.out.println(jp.getSignature().getName());
        Logger.logInfo("日志开始");
    }    
    /*
     * After在方法执行只会执行     */
    @After("execution(* com.xiaoluo.dao.*.add*(..))||" +
            "execution(* com.xiaoluo.dao.*.delete*(..))||" +
            "execution(* com.xiaoluo.dao.*.update*(..))")    public void logEnd()
    {
        Logger.logInfo("日志结束");
    }    
    /*
     * Around包含了这个方法的执行
     * 
     * Logger.logInfo("开始执行Around日志");
     * pjp.proceed();
     * Logger.logInfo("结束了Around日志");的执行顺序为：
     * 
     * 首先执行 Logger.logInfo("开始执行Around日志");，接着执行方法，因为在方法执行要执行
     * Before，所以先执行完Before再执行方法，接着执行  Logger.logInfo("结束了Around日志");
     * 最后执行After
     * 
     */
    @Around("execution(* com.xiaoluo.dao.*.add*(..))||" +
            "execution(* com.xiaoluo.dao.*.delete*(..))||" +
            "execution(* com.xiaoluo.dao.*.update*(..))")    public void logAround(ProceedingJoinPoint pjp) throws Throwable
    {
        Logger.logInfo("开始执行Around日志");
        pjp.proceed();
        Logger.logInfo("结束了Around日志");
    }
}

因为Spring的AOP使用的是第三方的jar包，所以我们这里还要引入三个AOP的jar文件：

aopalliance-1.0.jar
aspectjrt-1.7.3.jar
aspectjweaver-1.7.3.jar

这样我们的基于注解的AOP就配置好可以使用了。

三、基于XML的AOP配置

如果基于XML的AOP配置，我们的beans.xml配置如下

我们这里当然也要声明我们的切面类：

@Component("logAspect")    //    将该切面类由Spring托管public class LogAspect
{    public void logStart(JoinPoint jp)
    {        //    得到该JoinPoint的类        System.out.println(jp.getTarget());        //    得到该JoinPoint的方法        System.out.println(jp.getSignature());        //    得到该JoinPoint的方法的名字        System.out.println(jp.getSignature().getName());
        Logger.logInfo("日志开始");
    }    
    public void logEnd()
    {
        Logger.logInfo("日志结束");
    }    
    public void logAround(ProceedingJoinPoint pjp) throws Throwable
    {
        Logger.logInfo("开始执行Around日志");
        pjp.proceed();
        Logger.logInfo("结束了Around日志");
    }
}

本篇随笔主要记录了自己实现AOP的配置以及基于Annotation和XML的方式来配置我们的AOP