笔记——Spring AOP

最新推荐文章于 2024-11-09 20:45:09 发布

Winter_Tong

最新推荐文章于 2024-11-09 20:45:09 发布

阅读量264

点赞数

文章标签： spring aop

本文链接：https://blog.csdn.net/qq_43524048/article/details/113109215

版权

Spring AOP

概念
实现方式
术语
代码实现

概念

AOP是一种思想，而Spring AOP是对这种思想的具体实现，他只是将jdk动态代理和cglib代理整合到一块
简单来说：将程序中重复的代码抽取出来，在程序执行的时候，利用动态代理技术，在不修改源码的基础上，对现有的功能进行增强。

实现方式

JDK动态代理+cglib代理

术语

Joinpoint（连接点）
目标对象中有可能被增强的方法（final修饰的方法可以被jdk动态代理）
Pointcut（切入点）
目标对象中已经被增强的方法
Advice（通知/增强）
增强的代码，一般分为：前置通知before、后置通知after-returning、最终通知after、异常通知after-throwing、环绕通知around
Target（目标）
被代理的对象（切入点/连接点所在的类）
Weaving（织入）
将通知应用到切入点的过程（会产生一个代理对象）
Proxy（代理）
将通知植入到目标对象后形成的代理对象
Aspect（切面）
切入点+通知

代码实现

准备

目标对象（接口和实现类）

package com.spring.test04;

public interface IStudentService {
	void saveStudent();
	void updateStudent();
	void deleteStudent();
}

package com.spring.test04;

public class StudentServiceImpl implements IStudentService{
    public void saveStudent() {
        System.out.println("新增学生");
    }

    public void updateStudent() {
        System.out.println("更新学生");
    }

    public void deleteStudent() {
        System.out.println("删除学生");
    }
}

切面类

package com.spring.test04.aspect;

import org.aspectj.lang.ProceedingJoinPoint;

public class StudentAspect {
    public void beforeAspect(){
        System.out.println("前置通知");
    }

    public void afterReturningAspect() {
        System.out.println("后置通知");
    }

    public void afterAspect(){
        System.out.println("最终通知");
    }

    public void afterThrowingAspect() {
        System.out.println("异常通知");
    }

    public void aroundAspect(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知---前");
        Object[] args = joinPoint.getArgs();
        joinPoint.proceed(args);
        System.out.println("环绕通知---后");
    }
}

基于xml

创建配置文件spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
						 http://www.springframework.org/schema/beans/spring-beans.xsd
						 http://www.springframework.org/schema/aop
						 http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 目标对象 -->
    <bean id="stu" class="com.spring.test04.StudentServiceImpl"/>
    <!-- 切面 -->
    <bean id="stuAspect" class="com.spring.test04.aspect.StudentAspect"/>
    
    <aop:config>
    	<!-- 切入点  expression切入点表达式 -->
        <aop:pointcut id="pt1" expression="execution(* com.spring.test04..*.*(..))"/>
        <!-- 配置切面 -->
        <aop:aspect id="aspect" ref="stuAspect">
            <aop:before method="beforeAspect" pointcut-ref="pt1"/>
            <aop:after-returning method="afterReturningAspect" pointcut-ref="pt1"/>
            <aop:after method="afterAspect" pointcut-ref="pt1"/>
            <aop:after-throwing method="afterThrowingAspect" pointcut-ref="pt1"/>
            <aop:around method="aroundAspect" pointcut-ref="pt1"/>
        </aop:aspect>
    </aop:config>
</beans>

测试

    public void test03() {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        IStudentService
                stu = (IStudentService) app.getBean("stu");
        stu.saveStudent();

        System.out.println("-----------------");
        stu.deleteStudent();
    }

基于注解

接口不变，目标类（实现类对象）加注解@Service

切面类

package com.spring.test04.annotation;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class StudentAspectAnno {

	//声明执行切入点，方便后续的使用，减少代码量
    @Pointcut("execution(* com.spring.test04..*.*(..))")
    public void pointCut() {}

    @Before("execution(* com.spring.test04..*.*(..))")
    public void beforeAspect(){
        System.out.println("前置通知");
    }

    @AfterReturning("pointCut()")
    public void afterReturningAspect() {
        System.out.println("后置通知");
    }

    @After("pointCut()")
    public void afterAspect(){
        System.out.println("最终通知");
    }

    @AfterThrowing("pointCut()")
    public void afterThrowingAspect() {
        System.out.println("异常通知");
    }

    @Around("pointCut()")
    public void aroundAspect(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知---前");
        Object[] args = joinPoint.getArgs();
        joinPoint.proceed(args);
        System.out.println("环绕通知---后");
    }
}

增加配置类

package com.spring.test04.annotation;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.spring.test04")
@EnableAspectJAutoProxy
public class AspectConfig {
}

如果配置类中没有加注解@EnableAspectJAutoProxy，则需要在配置文件中加上<aop:aspectj-autoproxy />

测试

public void test04() {
	AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(AspectConfig.class);
	IStudentService stu = (IStudentService) app.getBean("studentServiceImpl");
    stu.saveStudent();
}