spring+aspectJ的实现

AspectJ：（Java社区里最完整最流行的AOP框架）

spring自身也有一套AOP框架，但相比较于AspectJ，更推荐AspectJ

在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。

AspectJ最强大的地方在于他的切入点表达式：

语法：execution(修饰符  返回值  包.类.方法名(参数) throws异常)

　　修饰符，一般省略

　　　　public 公共方法

               * 任意

　　返回值，不能省略

　　　　void 返回没有值

　　　　String 返回值字符串

　　　　* 任意

　　包

　　　　com.zby.service　　固定包

　　　　com.zby.oa.*.service oa包下面子包 （例如：com.zby.oa.flow.service）

　　　　com.zby.oa.. 　　oa包下面的所有子包（含自己）

　　　　com.zby.oa.*.service.. oa包下面任意子包，固定目录service，service目录任意包

　　类

　　　　UserServiceImpl 指定类

　　　　*Impl 以Impl结尾

　　　　User* 以User开头

　　　　* 任意

　　方法名，不能省略

　　　　addUser 固定方法

　　　　add* 以add开头

　　　　*Do 以Do结尾

　　　　* 任意

　　(参数)

　　　　() 无参

　　　　(int) 一个整型

　　　　(int ,int) 两个

　　　　(..) 参数任意

　　throws ,可省略，一般不写

AspectJ支持5种类型的通知注解：

before:前置通知(应用：各种校验)
　　　在方法执行前执行，如果通知抛出异常，阻止方法运行

afterReturning:后置通知(应用：常规数据处理)
           方法正常返回后执行，如果方法中抛出异常，通知无法执行，必须在方法执行后才执行，所以可以获得方法的返回值。

around:环绕通知(应用：十分强大，可以做任何事情)
           方法执行前后分别执行，可以阻止方法的执行，必须手动执行目标方法

afterThrowing:抛出异常通知(应用：包装异常信息)
           方法抛出异常后执行，如果方法没有抛出异常，无法执行

after:最终通知(应用：清理现场)
　　    方法执行完毕后执行，无论方法中是否出现异常

当然，最重要也最常用的还是环绕通知，因为环绕通知必须手动执行目标方法，所以，可以代替其他几个通知

项目结构图：

一：maven项目依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>demo</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>demo</name>
    <description>demo</description>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.10</version>
        </dependency>
    </dependencies>
</project>

二：声明切点

I.切面首先是一个IOC中的bean，即加入@Component注释

package com.debo.aspect.service;

import org.springframework.stereotype.Component;

@Component
public class AspectService {

    //添加
    public void add() {

    }

    //修改
    public void update() {

    }

    //删除
    public void delete() {

    }

}

三：声明切面

I.切面首先是一个IOC中的bean，即加入@Component注释
II.切面还需要加入@Aspect

package com.debo.aspect.service;

import java.lang.reflect.Method;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspectJ {

    // 多个方法需要使用这个切入点表达式，定义为一个公用的
    @Pointcut("execution(* com.debo.*.service.*.add*(..))")
    public void addCell() {
    }

    @Before("execution(* com.debo.*.service.*.update*(..))")
    public void updateCell() {
        System.out.println("更新的前置通知");
    }

    @After("execution(* com.debo.*.service.*.delete*(..))")
    public void deleteCell() {
        System.out.println("删除的最终通知");
    }

    @AfterReturning(value = "addCell()", returning = "ret")
    public void returnAdd(JoinPoint joinPoint, Object ret) {
        System.out.println("添加的后置通知 ： " + joinPoint.getSignature().getName());
    }

    @Around("addCell()")
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知执行方法前");
        // 手动执行目标方法
        Object obj = joinPoint.proceed();

        System.out.println("环绕通知执行方法后");
        return obj;
    }

    @AfterThrowing(value = "addCell()", throwing = "e")
    public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
        System.out.println("抛出异常通知 ： " + e.getMessage());
    }

}

四：xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"<span style="color:#ff0000;"> xmlns:aop="http://www.springframework.org/schema/aop"</span>
    <span style="color:#ff0000;">xmlns:context="http://www.springframework.org/schema/context"</span>
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <!-- 注解扫描 -->
    <context:component-scan base-package="com.debo.*.service" />

    <!-- 使AspectJ注解起作用：自动为匹配的类生成代理对象 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

五：测试

package com.debo.aspect.service;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {


    public static void main(String[] args) {
        // 1.创建Spring的IOC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "applicationContext.xml");

        // 2.从IOC容器中获取bean的实例
        AspectService aspectService = ctx.getBean(AspectService.class);

        aspectService.add();
        aspectService.update();
        aspectService.delete();
    }

}

原文链接：http://blog.csdn.net/qq_37936542/article/details/79555762