Spring框架一般都是基于AspectJ
实现AOP操作
1、什么是AspectJ
AspectJ不是Spring框架的组成部分,是独立AOP框架,一般把AspectJ和Spring框架一起使用,进行AOP操作
2、基于AspectJ实现AOP操作
(1)基于xml配置文件方式实现
(2)基于注解方式实现(一般使用这个)
3、在项目工程里引入 AOP 相关依赖
目前总的依赖有以下
4、切入点表达式
(1)切入点表达式作用:知道对哪个类里面的哪个方法进行增强
(2)语法结构
execution([权限修饰符] [返回值类型] [简单类名/全类名(类全路径)] [方法名] ([参数列表]))
例1 对com.pencil.spring5.dao.BookDao类
里面的add方法
进行增强
execution (* void com.pencil.spring5.dao.BookDao.add(...))
//*表示任意的权限修饰符
例2 对com.pencil.spring5.dao.BookDao类
里面的所有方法
进行增强
execution(* com.pencil.spring5.dao.BookDao.*(...))
//返回值类型省略
例3 对com.pencil.spring5.dao包
里面的所有类
,类里面的所有方法
进行增强
execution(* com.pencil.dao.*.*(...))
//返回值类型省略
-------------------------------------------------------分割线----------------------------------------------------------------------------------------
AspectJ注解
1、创建类,在类里面定义方法
User类
package com.pencil.spring5.aopPac;
public class User {
public void add()
{
System.out.println("User:add....");
}
}
2、创建增强类(编写增强逻辑)
UserProxy类
package com.pencil.spring5.aopPac;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
//增强的类
@Component
@Aspect
public class UserProxy {
//前置通知
//@Before注解表示作为前置通知
@Before(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void before()
{
System.out.println("before....");
}
@After(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void after()
{
System.out.println("after...");
}
@AfterReturning(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void afterReturning()
{
System.out.println("afterReturning....");
}
@AfterThrowing(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void afterthrowing()
{
System.out.println("afterthrowing...");
}
@Around(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前...");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后...");
}
}
3、进行通知的配置
步骤如下
(1)在spring配置文件中,开启注解扫描
(2)使用注解创建User和UserProxy对象
(3)在增强类上面添加注解@Aspect,表示要生成代理对象
(4)在 spring 配置文件中开启生成代理对象
(1)在spring配置文件中,开启注解扫描
xml配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--开启注解扫描-->
<context:component-scan base-package="com.pencil.spring5.aopPac"></context:component-scan>
</beans>
(2)使用注解创建User和UserProxy对象
(3)在增强类上面添加注解@Aspect
,表示要生成代理对象
(4)在 spring 配置文件中开启生成代理对象
在配置文件中再加上这一段生成代理对象
4、配置不同类型的通知
(1)在增强类的里面,在作为通知方法上面添加通知类型注解,使用切入点表达式配置
package com.pencil.spring5.aopPac;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
//增强的类
@Component
@Aspect
public class UserProxy {
//前置通知
//@Before注解表示作为前置通知
@Before(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void before()
{
System.out.println("before....");
}
@After(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void after()
{
System.out.println("after...");
}
@AfterReturning(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void afterReturning()
{
System.out.println("afterReturning....");
}
@AfterThrowing(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void afterthrowing()
{
System.out.println("afterthrowing...");
}
@Around(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前...");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后...");
}
}
特别需要留意的是@Around
的编写
@Around(value="execution(* com.pencil.spring5.aopPac.User.add())")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前...");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后...");
}
测试代码
package com.pencil.spring5.test;
import com.pencil.spring5.aopPac.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testAOP {
@Test
public void test()
{
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
User user=context.getBean("user", User.class);
user.add();
}
}
运行结果