AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

JavaEE Spring AOP使用

2018-04-12 996
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 1. AOP入门1). 创建项目并导入Jar包：spring-beans-5.0.5.RELEASE.jar、spring-context-5.0.5.

1. AOP入门

1). 创建项目并导入Jar包：spring-beans-5.0.5.RELEASE.jar、spring-context-5.0.5.RELEASE.jar、spring-core-5.0.5.RELEASE.jar、spring-expression-5.0.5.RELEASE.jar、spring-aop-5.0.5.RELEASE.jar、spring-aop-5.0.5.RELEASE.jar、spring-aspects-5.0.5.RELEASE.jar、commons-logging-1.2.jar、aopalliance-1.0.jar、aspectjweaver-1.8.13.jar.

img_fe63508b1cbe7c6be4537ced588519f0.png
图1.png

2). 引入aop命令空间

<?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%20%20%20%20%20%20%20%20http://www.springframework.org/schema/beans/spring-beans.xsd%20%20%20%20%20%20%20%20http://www.springframework.org/schema/context%20%20%20%20%20%20%20%20http://www.springframework.org/schema/context/spring-context-4.2.xsd%20%20%20%20%20%20%20%20http://www.springframework.org/schema/aop%20%20%20%20%20%20%20%20%20http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

</beans>
img_b228245d51de12c2216eb5409b17db8d.png
图2.png

3). 创建PersonService接口

public interface PersonService {
    public void save(String name);
    public void update(String name, int id);
    public String getPersonName(int id);
}

4). 创建实现了PersonService的接口PersonServiceImpl

public class PersonServiceImpl implements PersonService{

    @Override
    public void save(String name) {
        System.out.println("我是save方法");
    }

    @Override
    public void update(String name, int id) {
        System.out.println("我是update方法");
    }

    @Override
    public String getPersonName(int id) {
        System.out.println("我是getPersonName方法");
        return "mazaiting";
    }

}

5). 创建切面类——MyInterceptor
最典型的切入点表达式是根据方法的签名来匹配各种方法：

  • execution (* cn.itcast.service.impl.PersonServiceImpl.*(..))：匹配PersonServiceImpl类中声明的所有方法。第一个代表任意修饰符及任意返回值类型，第二个代表任意方法，..匹配任意数量任意类型的参数，若目标类与该切面在同一个包中，可以省略包名。
  • execution public * cn.itcast.service.impl.PersonServiceImpl.*(..)：匹配PersonServiceImpl类中的所有公有方法。
  • execution public double cn.itcast.service.impl.PersonServiceImpl.*(..)：匹配PersonServiceImpl类中返回值类型为double类型的所有公有方法。
  • execution public double cn.itcast.service.impl.PersonServiceImpl.*(double, ..)：匹配PersonServiceImpl类中第一个参数为double类型，后面不管有无参数的所有公有方法，并且该方法的返回值类型为double类型。
  • execution public double cn.itcast.service.impl.PersonServiceImpl.*(double, double)：匹配PersonServiceImpl类中参数类型为double，double类型的，并且返回值类型也为double类型的所有公有方法。
// 声明当前类为切面类
@Aspect
public class MyInterceptor {
    // 声明一个切入点，anyMethod为切入点名称
    @Pointcut("execution (* com.mazaiting.test.service.impl.PersonServiceImpl.*(..))")
    private void anyMethod(){
        
    }
    
    // 声明该方法是一个前置通知，在目标方法开始之前执行
    @Before("anyMethod()")
    public void doAccessCheck() {
        System.out.println("前置通知");
    }
}

注意：若是将一个类声明为一个切面，那么需要把该类放到IOC容器管理。
6). 在bean.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%20%20%20%20%20%20%20%20http://www.springframework.org/schema/beans/spring-beans.xsd%20%20%20%20%20%20%20%20http://www.springframework.org/schema/context%20%20%20%20%20%20%20%20http://www.springframework.org/schema/context/spring-context-4.2.xsd%20%20%20%20%20%20%20%20http://www.springframework.org/schema/aop%20%20%20%20%20%20%20%20%20http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
    
    <aop:aspectj-autoproxy />
    <bean id="myInterceptor" class="com.mazaiting.test.MyInterceptor"></bean>
    <bean id="personService" class="com.mazaiting.test.service.impl.PersonServiceImpl"></bean>
</beans>

7). 创建测试类

public class TestAop {
    
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 创建对象
        PersonService service = (PersonService) context.getBean("personService");
        service.save("xxx");
    }
}

8). 执行结果


img_3164d86c9df78f26d94c0332b0126247.png
图3.png

2. AOP细节(前置通知、后置通知、异常通知、最终通知、环绕通知等)

1). 添加后置通知

// 声明当前类为切面类
@Aspect
public class MyInterceptor {
    // 声明一个切入点，anyMethod为切入点名称
    @Pointcut("execution (* com.mazaiting.test.service.impl.PersonServiceImpl.*(..))")
    private void anyMethod(){
        
    }
    
    // 声明该方法是一个前置通知，在目标方法开始之前执行
    @Before("anyMethod()")
    public void doAccessCheck() {
        System.out.println("前置通知");
    }
    
    // 声明一个后置通知
    @AfterReturning("anyMethod()")
    public void doAfterRunning() {
        System.out.println("后置通知");
    }
}

执行测试代码，打印结果：


img_566191c80f0738acb59ce9c013fbae19.png
图4.png

2). 添加最终通知

// 声明当前类为切面类
@Aspect
public class MyInterceptor {
    // 声明一个切入点，anyMethod为切入点名称
    @Pointcut("execution (* com.mazaiting.test.service.impl.PersonServiceImpl.*(..))")
    private void anyMethod(){
        
    }
    
    // 声明该方法是一个前置通知，在目标方法开始之前执行
    @Before("anyMethod()")
    public void doAccessCheck() {
        System.out.println("前置通知");
    }
    
    // 声明一个后置通知
    @AfterReturning("anyMethod()")
    public void doAfterRunning() {
        System.out.println("后置通知");
    }
    
    // 声明一个最终通知
    @After("anyMethod()")
    public void doAfter() {
        System.out.println("最终通知");
    }
}

执行测试代码，打印结果：


img_e76fa4255faac8f233f3c16e716023ea.png
图5.png

3). 添加异常通知
I. 修改PersonServiceImpl中的save代码实现

public class PersonServiceImpl implements PersonService{

    @Override
    public void save(String name) {
        throw new RuntimeException("异常");
//      System.out.println("我是save方法");
    }

    @Override
    public void update(String name, int id) {
        System.out.println("我是update方法");
    }

    @Override
    public String getPersonName(int id) {
        System.out.println("我是getPersonName方法");
        return "mazaiting";
    }

}

II. 修改MyInterceptor类中代码

// 声明当前类为切面类
@Aspect
public class MyInterceptor {
    // 声明一个切入点，anyMethod为切入点名称
    @Pointcut("execution (* com.mazaiting.test.service.impl.PersonServiceImpl.*(..))")
    private void anyMethod(){
        
    }
    
    // 声明该方法是一个前置通知，在目标方法开始之前执行
    @Before("anyMethod()")
    public void doAccessCheck() {
        System.out.println("前置通知");
    }
    
    // 声明一个后置通知
    @AfterReturning("anyMethod()")
    public void doAfterRunning() {
        System.out.println("后置通知");
    }
    
    // 声明一个最终通知
    @After("anyMethod()")
    public void doAfter() {
        System.out.println("最终通知");
    }
    
    // 声明一个异常通知
    @AfterThrowing("anyMethod()")
    public void doAfterThrowing() {
        System.out.println("异常通知");
    }
}

III. 执行测试代码，打印结果:


img_fbddd4ef8ad7125768a4a9fe001c734f.png
图6.png

4). 添加环绕通知
I. 将代码重置回第二步结束时样子
II. 修改MyInterceptor文件

// 声明当前类为切面类
@Aspect
public class MyInterceptor {
    // 声明一个切入点，anyMethod为切入点名称
    @Pointcut("execution (* com.mazaiting.test.service.impl.PersonServiceImpl.*(..))")
    private void anyMethod(){
        
    }
    
    // 声明该方法是一个前置通知，在目标方法开始之前执行
    @Before("anyMethod()")
    public void doAccessCheck() {
        System.out.println("前置通知");
    }
    
    // 声明一个后置通知
    @AfterReturning("anyMethod()")
    public void doAfterRunning() {
        System.out.println("后置通知");
    }
    
    // 声明一个最终通知
    @After("anyMethod()")
    public void doAfter() {
        System.out.println("最终通知");
    }
    
    // 声明一个异常通知
    @AfterThrowing("anyMethod()")
    public void doAfterThrowing() {
        System.out.println("异常通知");
    }
    
    // 环绕通知，环绕通知方法的写法是固定
    @Around("anyMethod()")
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("进入方法");
        Object result = pjp.proceed();
        System.out.println("退出方法");
        return result;
    }
}
注意：环绕通知内部一定要确保执行proceed()该方法，如果不执行该方法，业务bean中被拦截的方法就不会被执行。当执行该方法，如果后面还有切面的话，它的执行顺序应该是这样的：先执行后面的切面，如果后面没有切面了，再执行最终的目标对象的业务方法。若不执行该方法，则后面的切面，业务bean的方法都不会被执行。 其实我们仅使用环绕通知就可以实现前置通知、后置通知、异常通知、最终通知等的效果。

III. 执行测试代码，打印结果：


img_15ae399b80486da371a92b876df9fc07.png
图7.png

3. 前置通知获取参数

I. 修改MyInterceptor中的doAccessCheck方法


// 声明当前类为切面类
@Aspect
public class MyInterceptor {
    // 声明一个切入点，anyMethod为切入点名称
    @Pointcut("execution (* com.mazaiting.test.service.impl.PersonServiceImpl.*(..))")
    private void anyMethod(){
        
    }
    
    // 声明该方法是一个前置通知，在目标方法开始之前执行
    @Before("anyMethod() && args(name)")
    public void doAccessCheck(String name) {
        System.out.println("前置通知" + name);
    }
    
    // 声明一个后置通知
    @AfterReturning("anyMethod()")
    public void doAfterRunning() {
        System.out.println("后置通知");
    }
    
    // 声明一个最终通知
    @After("anyMethod()")
    public void doAfter() {
        System.out.println("最终通知");
    }
    
    // 声明一个异常通知
    @AfterThrowing("anyMethod()")
    public void doAfterThrowing() {
        System.out.println("异常通知");
    }
    
    // 环绕通知，环绕通知方法的写法是固定
    @Around("anyMethod()")
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("进入方法");
        Object result = pjp.proceed();
        System.out.println("退出方法");
        return result;
    }
}

II. 执行测试代码，打印结果：


img_3ad228e49145aab68f0ace9c81fff0a0.png
图8.png

4. 获取getPersonName()方法的返回参数

I. 修改MyInterceptor代码

// 声明当前类为切面类
@Aspect
public class MyInterceptor {
    // 声明一个切入点，anyMethod为切入点名称
    @Pointcut("execution (* com.mazaiting.test.service.impl.PersonServiceImpl.*(..))")
    private void anyMethod(){
        
    }
    
    // 声明该方法是一个前置通知，在目标方法开始之前执行
    @Before("anyMethod() && args(name)")
    public void doAccessCheck(String name) {
        System.out.println("前置通知" + name);
    }
    
    // 声明一个后置通知
    @AfterReturning(pointcut = "anyMethod()", returning = "result")
    public void doAfterRunning(String result) {
        System.out.println("后置通知" + result);
    }
    
    // 声明一个最终通知
    @After("anyMethod()")
    public void doAfter() {
        System.out.println("最终通知");
    }
    
    // 声明一个异常通知
    @AfterThrowing("anyMethod()")
    public void doAfterThrowing() {
        System.out.println("异常通知");
    }
    
    // 环绕通知，环绕通知方法的写法是固定
    @Around("anyMethod()")
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("进入方法");
        Object result = pjp.proceed();
        System.out.println("退出方法");
        return result;
    }
}

II. 修改测试代码

public class TestAop {
    
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 创建对象
        PersonService service = (PersonService) context.getBean("personService");
//      service.save("xxx");
        service.getPersonName(2);
    }
}

III. 执行测试代码，打印结果：


img_b19ca20ec898ca03254b2b413a31985c.png
图9.png

5. 获取异常

I. 修改PersonServiceImpl代码

public class PersonServiceImpl implements PersonService{

    @Override
    public void save(String name) {
        throw new RuntimeException("异常");
//      System.out.println("我是save方法");
    }

    @Override
    public void update(String name, int id) {
        System.out.println("我是update方法");
    }

    @Override
    public String getPersonName(int id) {
        System.out.println("我是getPersonName方法");
        return "mazaiting";
    }

}

II. 修改异常通知代码

// 声明当前类为切面类
@Aspect
public class MyInterceptor {
    // 声明一个切入点，anyMethod为切入点名称
    @Pointcut("execution (* com.mazaiting.test.service.impl.PersonServiceImpl.*(..))")
    private void anyMethod(){
        
    }
    
    // 声明该方法是一个前置通知，在目标方法开始之前执行
    @Before("anyMethod() && args(name)")
    public void doAccessCheck(String name) {
        System.out.println("前置通知" + name);
    }
    
    // 声明一个后置通知
    @AfterReturning(pointcut = "anyMethod()", returning = "result")
    public void doAfterRunning(String result) {
        System.out.println("后置通知" + result);
    }
    
    // 声明一个最终通知
    @After("anyMethod()")
    public void doAfter() {
        System.out.println("最终通知");
    }
    
    // 声明一个异常通知
    @AfterThrowing(pointcut = "anyMethod()", throwing = "e")
    public void doAfterThrowing(Exception e) {
        System.out.println("异常通知" + e);
    }
    
    // 环绕通知，环绕通知方法的写法是固定
    @Around("anyMethod()")
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("进入方法");
        Object result = pjp.proceed();
        System.out.println("退出方法");
        return result;
    }
}

III. 修改测试代码

public class TestAop {
    
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 创建对象
        PersonService service = (PersonService) context.getBean("personService");
        service.save("xxx");
//      service.getPersonName(2);
    }
}

IV. 执行测试代码，打印结果：


img_eb95813f5dc6ea33e4160d671569316e.png
图10.png

6. 配置文件实现AOP

1). 创建Person接口

public interface Person {
    void save();
}

2). 创建实现Person接口的PersonImpl类

public class PersonImpl implements Person {

    @Override
    public void save() {
        System.out.println("我是save方法");
    }

}

3). 创建MyInterceptor类


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

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

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

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

    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("进入方法");
        Object result = pjp.proceed();
        System.out.println("退出方法");
        return result;
    }
}

4). 修改bean.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%20%20%20%20%20%20%20%20http://www.springframework.org/schema/beans/spring-beans.xsd%20%20%20%20%20%20%20%20http://www.springframework.org/schema/context%20%20%20%20%20%20%20%20http://www.springframework.org/schema/context/spring-context-4.2.xsd%20%20%20%20%20%20%20%20http://www.springframework.org/schema/aop%20%20%20%20%20%20%20%20%20http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
    
    <aop:aspectj-autoproxy />
    <bean id="myInterceptor1" class="com.mazaiting.test1.MyInterceptor"></bean>
    <bean id="person" class="com.mazaiting.test1.service.impl.PersonImpl"></bean>
    <aop:config>
        <aop:aspect id="asp" ref="myInterceptor1">
            <aop:pointcut expression="execution(* com.mazaiting.test1.service.impl.PersonImpl.*(..))" id="mycut"/>
            <aop:before pointcut-ref="mycut" method="doAccessCheck"/>
            <aop:after pointcut-ref="mycut" method="doAfter"/>
            <aop:after-returning pointcut-ref="mycut" method="doAfterReturning"/>
            <aop:after-throwing pointcut-ref="mycut" method="doAfterThrowing"/>
            <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>
        </aop:aspect>
    </aop:config>
</beans>

5). 创建测试代码

public class TestPerson {
    
    @Test
    public void test() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 创建对象
        Person person = (Person) context.getBean("person");
        person.save();
    }
}

6). 执行测试代码，打印结果:


img_26a3d645e766f44a8a4b8fd6d0d2c255.png
图11.png

7). 修改PersonImpl代码

public class PersonImpl implements Person {

    @Override
    public void save() {
//      System.out.println("我是save方法");
        throw new RuntimeException("yichang");
    }

}

8). 执行测试代码，打印结果：


img_e23d06f9a4f07f9fc82a571c7e7735e2.png
图12.png

代码下载

文章标签：
Spring
测试技术
Java
数据格式
XML
关键词：
Spring AOP
Spring JavaEE
aop javaee
javaee Spring aop
javaee aop
凌浩雨
目录
相关文章
HELLO程序员
|
3月前
|
XML 安全 Java
使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
面向方面编程（AOP）通过分离横切关注点，如日志、安全和事务，提升代码模块化与可维护性。Spring 提供了对 AOP 的强大支持，核心注解 `@Aspect` 和 `@Pointcut` 使得定义切面与切入点变得简洁直观。`@Aspect` 标记切面类，集中处理通用逻辑；`@Pointcut` 则通过表达式定义通知的应用位置，提高代码可读性与复用性。二者结合，使开发者能清晰划分业务逻辑与辅助功能，简化维护并提升系统灵活性。Spring AOP 借助代理机制实现运行时织入，与 Spring 容器无缝集成，支持依赖注入与声明式配置，是构建清晰、高内聚应用的理想选择。
HELLO程序员
493 0
一枚后端工程狮
|
2月前
|
XML Java 数据格式
《深入理解Spring》：AOP面向切面编程深度解析
Spring AOP通过代理模式实现面向切面编程，将日志、事务等横切关注点与业务逻辑分离。支持注解、XML和编程式配置，提供五种通知类型及丰富切点表达式，助力构建高内聚、低耦合的可维护系统。
一枚后端工程狮
538 7
游客wkqymr43luqiu
|
7月前
|
监控 安全 Java
Spring AOP实现原理
本内容主要介绍了Spring AOP的核心概念、实现机制及代理生成流程。涵盖切面（Aspect）、连接点（Join Point）、通知（Advice）、切点（Pointcut）等关键概念，解析了JDK动态代理与CGLIB代理的原理及对比，并深入探讨了通知执行链路和责任链模式的应用。同时，详细分析了AspectJ注解驱动的AOP解析过程，包括切面识别、切点表达式匹配及通知适配为Advice的机制，帮助理解Spring AOP的工作原理与实现细节。
游客wkqymr43luqiu
1211 13
aliyun4145988376
|
4月前
|
人工智能 监控 安全
如何快速上手【Spring AOP】？核心应用实战（上篇）
哈喽大家好吖~欢迎来到Spring AOP系列教程的上篇 - 应用篇。在本篇，我们将专注于Spring AOP的实际应用，通过具体的代码示例和场景分析，帮助大家掌握AOP的使用方法和技巧。而在后续的下篇中，我们将深入探讨Spring AOP的实现原理和底层机制。 AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架中的核心特性之一，它能够帮助我们解决横切关注点（如日志记录、性能统计、安全控制、事务管理等）的问题，提高代码的模块化程度和复用性。
aliyun4145988376
608 1
aliyun4145988376
|
4月前
|
设计模式 Java 开发者
如何快速上手【Spring AOP】？从动态代理到源码剖析（下篇）
Spring AOP的实现本质上依赖于代理模式这一经典设计模式。代理模式通过引入代理对象作为目标对象的中间层，实现了对目标对象访问的控制与增强，其核心价值在于解耦核心业务逻辑与横切关注点。在框架设计中，这种模式广泛用于实现功能扩展（如远程调用、延迟加载）、行为拦截（如权限校验、异常处理）等场景，为系统提供了更高的灵活性和可维护性。
aliyun4145988376
328 0
Cyan_RA9
|
10月前
|
XML Java 测试技术
Spring AOP—通知类型 和 切入点表达式 万字详解（通俗易懂）
Spring 第五节 AOP——切入点表达式 万字详解！
Cyan_RA9
812 25
Cyan_RA9
|
10月前
|
XML 安全 Java
Spring AOP—深入动态代理 万字详解（通俗易懂）
Spring 第四节 AOP——动态代理 万字详解！
Cyan_RA9
472 24
Quan_Chen
|
9月前
|
Java API 微服务
微服务——SpringBoot使用归纳——Spring Boot中的切面AOP处理——Spring Boot 中的 AOP 处理
本文详细讲解了Spring Boot中的AOP（面向切面编程）处理方法。首先介绍如何引入AOP依赖，通过添加`spring-boot-starter-aop`实现。接着阐述了如何定义和实现AOP切面，包括常用注解如`@Aspect`、`@Pointcut`、`@Before`、`@After`、`@AfterReturning`和`@AfterThrowing`的使用场景与示例代码。通过这些注解，可以分别在方法执行前、后、返回时或抛出异常时插入自定义逻辑，从而实现功能增强或日志记录等操作。最后总结了AOP在实际项目中的重要作用，并提供了课程源码下载链接供进一步学习。
Quan_Chen
1206 0
Quan_Chen
|
9月前
|
Java 开发者 微服务
微服务——SpringBoot使用归纳——Spring Boot中的切面AOP处理——什么是AOP
本文介绍了Spring Boot中的切面AOP处理。AOP（Aspect Oriented Programming）即面向切面编程，其核心思想是分离关注点。通过AOP，程序可以将与业务逻辑无关的代码（如日志记录、事务管理等）从主要逻辑中抽离，交由专门的“仆人”处理，从而让开发者专注于核心任务。这种机制实现了模块间的灵活组合，使程序结构更加可配置、可扩展。文中以生活化比喻生动阐释了AOP的工作原理及其优势。
Quan_Chen
538 0

热门文章

最新文章

  • 1
    spring boot应用优化，6s内启动，内存减半
  • 2
    SpringBoot+Docker+Git+Jenkins实现简易的持续集成和持续部署
  • 3
    Aliyun Java Initializr 和 Spring 官方的到底有什么区别？
  • 4
    Spring的事务管理对何种异常进行回滚
  • 5
    Spring Web MVC框架（三） 异步处理
  • 6
    Spring IOC的一些高级特性
  • 7
    【Spring Boot 源码学习】JedisConnectionConfiguration 详解
  • 8
    springboot RabbitMQ 连接超时配置
  • 9
    SpringBoot 使用cas5.3 认证中心返回多属性配置
  • 10
    Spring源码学习之：ClassLoader学习（4）
  • 1
    《深入理解Spring》：AOP面向切面编程深度解析
    538
  • 2
    AOP 切面编程
    483
  • 3
    使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
    493
  • 4
    Spring AOP切面编程颠覆传统！3大核心注解+5种通知类型，让业务代码纯净如初
    528
  • 5
    AOP切面编程快速入门
    453
  • 6
    如何快速上手【Spring AOP】？从动态代理到源码剖析（下篇）
    328
  • 7
    如何快速上手【Spring AOP】？核心应用实战（上篇）
    608
  • 8
    如何用go语言实现类似AOP的功能
    186
  • 9
    Spring AOP实现原理
    1211
  • 10
    面向切面编程（AOP）介绍--这是我见过最易理解的文章
    457

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第一阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库
    • 下一篇
    基于Python+Vue开发的口腔牙科预约管理系统