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

详解Spring学习总结——Spring实现AOP的多种方式

2022-07-09 144
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 详解Spring学习总结——Spring实现AOP的多种方式

这篇文章主要介绍了详解Spring学习总结——Spring实现AOP的多种方式，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧

目录

一、基于XML配置的Spring AOP

二、使用注解配置AOP

三、AspectJ切点函数

四、AspectJ通知注解

五、零配置实现Spring IoC与AOP

AOP（Aspect Oriented Programming）面向切面编程，通过预编译方式和运行期动态代理实现程序功能的横向多模块统一控制的一种技术。AOP是OOP的补充，是spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP可以分为静态织入与动态织入，静态织入即在编译前将需织入内容写入目标模块中，这样成本非常高。动态织入则不需要改变目标模块。Spring框架实现了AOP，使用注解配置完成AOP比使用XML配置要更加方便与直观。

图片.png

一、基于XML配置的Spring AOP

在讲注解实现AOP功能前先用前面学习过的使用xml配置Spring AOP功能，这样是为了对比以便更好的理解。

1.1、新建一个Maven项目，添加引用，项目的pom.xml文件如下：

图片.png

<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>com.zhangguo</groupId>
 <artifactId>Spring052</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>jar</packaging>
 
 <name>Spring052</name>
 <url>http://maven.apache.org</url>
 
 <properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <spring.version>4.3.0.RELEASE</spring.version>
 </properties>
 <dependencies>
  <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <scope>test</scope>
   <version>4.10</version>
  </dependency>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId>
   <version>${spring.version}</version>
  </dependency>
  <dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.8.9</version>
  </dependency>
  <dependency>
   <groupId>cglib</groupId>
   <artifactId>cglib</artifactId>
   <version>3.2.4</version>
  </dependency>
 </dependencies>
</project>

1.2、创建要被代理的Math类，代码如下：

package com.zhangguo.Spring052.aop01;
 
/**
 * 被代理的目标类
 */
public class Math{
 //加
 public int add(int n1,int n2){
  int result=n1+n2;
  System.out.println(n1+"+"+n2+"="+result);
  return result;
 }
  
 //减
 public int sub(int n1,int n2){
  int result=n1-n2;
  System.out.println(n1+"-"+n2+"="+result);
  return result;
 }
  
 //乘
 public int mut(int n1,int n2){
  int result=n1*n2;
  System.out.println(n1+"X"+n2+"="+result);
  return result;
 }
  
 //除
 public int div(int n1,int n2){
  int result=n1/n2;
  System.out.println(n1+"/"+n2+"="+result);
  return result;
 }
}

1.3、编辑AOP中需要使用到的通知类Advices.Java代码如下：

package com.zhangguo.Spring052.aop01;
 
import org.aspectj.lang.JoinPoint;
 
/**
 * 通知类，横切逻辑
 *
 */
public class Advices {
  
 public void before(JoinPoint jp){
  System.out.println("----------前置通知----------");
  System.out.println(jp.getSignature().getName());
 }
  
 public void after(JoinPoint jp){
  System.out.println("----------最终通知----------");
 }
}

1.4、配置容器初始化时需要的XML文件，aop01.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:p="http://www.springframework.org/schema/p"
 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/aop
  http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
   
 <!-- 被代理对象 -->
 <bean id="math" class="com.zhangguo.Spring052.aop01.Math"></bean>
  
 <!-- 通知 -->
 <bean id="advices" class="com.zhangguo.Spring052.aop01.Advices"></bean>
  
 <!-- aop配置 -->
 <aop:config proxy-target-class="true">
  <!--切面 -->
  <aop:aspect ref="advices">
   <!-- 切点 -->
   <aop:pointcut expression="execution(* com.zhangguo.Spring052.aop01.Math.*(..))" id="pointcut1"/>
   <!--连接通知方法与切点 -->
   <aop:before method="before" pointcut-ref="pointcut1"/>
   <aop:after method="after" pointcut-ref="pointcut1"/>
  </aop:aspect>
 </aop:config>
 
</beans>

1.5、测试代码Test.java如下：

package com.zhangguo.Spring052.aop01;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Test {
 
 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("aop01.xml");
  Math math = ctx.getBean("math", Math.class);
  int n1 = 100, n2 = 5;
  math.add(n1, n2);
  math.sub(n1, n2);
  math.mut(n1, n2);
  math.div(n1, n2);
 }
 
}

运行结果：

图片.png

二、使用注解配置AOP

图片.png

2.1、在上一个示例中修改被代理的类Math,为了实现IOC扫描在Math类上注解了@Service并命名bean为math。相当于上一个示例中在xml配置文件中增加了一个bean， ，Math类的代码如下：

package com.zhangguo.Spring052.aop02;
 
import org.springframework.stereotype.Service;
 
/**
 * 被代理的目标类
 */
@Service("math")
public class Math{
 //加
 public int add(int n1,int n2){
  int result=n1+n2;
  System.out.println(n1+"+"+n2+"="+result);
  return result;
 }
  
 //减
 public int sub(int n1,int n2){
  int result=n1-n2;
  System.out.println(n1+"-"+n2+"="+result);
  return result;
 }
  
 //乘
 public int mut(int n1,int n2){
  int result=n1*n2;
  System.out.println(n1+"X"+n2+"="+result);
  return result;
 }
  
 //除
 public int div(int n1,int n2){
  int result=n1/n2;
  System.out.println(n1+"/"+n2+"="+result);
  return result;
 }
}

2.2、修改通知类Advices，代码中有3个注解，@Component表示该类的实例会被Spring IOC容器管理；@Aspect表示声明一个切面；@Before表示before为前置通知，通过参数execution声明一个切点，Advices.java代码如下所示：

package com.zhangguo.Spring052.aop02;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
 
/**
 * 通知类，横切逻辑
 *
 */
@Component
@Aspect
public class Advices {
 @Before("execution(* com.zhangguo.Spring052.aop02.Math.*(..))")
 public void before(JoinPoint jp){
  System.out.println("----------前置通知----------");
  System.out.println(jp.getSignature().getName());
 }
  
 @After("execution(* com.zhangguo.Spring052.aop02.Math.*(..))")
 public void after(JoinPoint jp){
  System.out.println("----------最终通知----------");
 }
}

上面的代码与下面的配置基本等同

<!-- 通知 -->
<bean id="advices" class="com.zhangguo.Spring052.aop01.Advices"></bean>
 
<!-- aop配置 -->
<aop:config proxy-target-class="true">
 <!--切面 -->
 <aop:aspect ref="advices">
  <!-- 切点 -->
  <aop:pointcut expression="execution(* com.zhangguo.Spring052.aop01.Math.*(..))" id="pointcut1"/>
  <!--连接通知方法与切点 -->
  <aop:before method="before" pointcut-ref="pointcut1"/>
  <aop:after method="after" pointcut-ref="pointcut1"/>
 </aop:aspect>
</aop:config>

2.3、新增配置文件aop02.xml，在配置IOC的基础上增加了aop:aspectj-autoproxy节点，Spring框架会自动为与AspectJ切面配置的Bean创建代理，proxy-target-class="true"属性表示被代理的目标对象是一个类，而非实现了接口的类，主要是为了选择不同的代理方式。

<?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:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:context="http://www.springframework.org/schema/context"
 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-4.3.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
  <context:component-scan base-package="com.zhangguo.Spring052.aop02">
  </context:component-scan>
  <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
</beans>

2.4、测试运行代码Test.java如下：

package com.zhangguo.Spring052.aop02;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Test {
 
 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("aop02.xml");
  Math math = ctx.getBean("math", Math.class);
  int n1 = 100, n2 = 5;
  math.add(n1, n2);
  math.sub(n1, n2);
  math.mut(n1, n2);
  math.div(n1, n2);
 }
 
}

运行结果：

图片.png

三、AspectJ切点函数

切点函数可以定位到准确的横切逻辑位置，在前面的示例中我们只使用过execution( com.zhangguo.Spring052.aop02.Math.(..))，execution就是一个切点函数，但该函数只什么方法一级，如果我们要织入的范围是类或某个注解则execution就不那么好用了，其实一共有9个切点函数，有不同的针对性。

@AspectJ使用AspectJ专门的切点表达式描述切面，Spring所支持的AspectJ表达式可分为四类:

方法切点函数：通过描述目标类方法信息定义连接点。

方法参数切点函数：通过描述目标类方法入参信息定义连接点。

目标类切点函数：通过描述目标类类型信息定义连接点。

代理类切点函数：通过描述代理类信息定义连接点。

常见的AspectJ表达式函数：

execution()：满足匹配模式字符串的所有目标类方法的连接点

@annotation()：任何标注了指定注解的目标方法链接点

args()：目标类方法运行时参数的类型指定连接点

@args()：目标类方法参数中是否有指定特定注解的连接点

within()：匹配指定的包的所有连接点

target()：匹配指定目标类的所有方法

@within()：匹配目标对象拥有指定注解的类的所有方法

@target()：匹配当前目标对象类型的执行方法，其中目标对象持有指定

的注解

this()：匹配当前AOP代理对象类型的所有执行方法

最常用的是：execution(<修饰符模式>?<返回类型模式><方法名模式>(<参数模式>)<异常模式>?)切点函数，可以满足多数需求。

为了展示各切点函数的功能现在新增一个类StrUtil，类如下：

package com.zhangguo.Spring052.aop03;
 
import org.springframework.stereotype.Component;
 
@Component("strUtil")
public class StrUtil {
 public void show(){
  System.out.println("Hello StrUtil!");
 }
}

测试代码如下：

package com.zhangguo.Spring052.aop03;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Test {
 
 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("aop03.xml");
  IMath math = ctx.getBean("math", Math.class);
  int n1 = 100, n2 = 5;
  math.add(n1, n2);
  math.sub(n1, n2);
  math.mut(n1, n2);
  math.div(n1, n2);
   
  StrUtil strUtil=ctx.getBean("strUtil",StrUtil.class);
  strUtil.show();
 }
 
}

3.1、切点函数execution，通知与切面的定义如下：

package com.zhangguo.Spring052.aop03;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
 
/**
 * 通知类，横切逻辑
 *
 */
@Component
@Aspect
public class Advices {
 @Before("execution(* com.zhangguo.Spring052.aop03.Math.*(..))")
 public void before(JoinPoint jp){
  System.out.println("----------前置通知----------");
  System.out.println(jp.getSignature().getName());
 }
  
 //execution切点函数
 //com.zhangguo.Spring052.aop03包下所有类的所有方法被切入
 @After("execution(* com.zhangguo.Spring052.aop03.*.*(..))")
 public void after(JoinPoint jp){
  System.out.println("----------最终通知----------");
 }
}

运行结果如下：

图片.png

execution(<修饰符模式>?<返回类型模式><方法名模式>(<参数模式>)<异常模式>?)

3.2、切点函数within

//within切点函数
//com.zhangguo.Spring052.aop03包下所有类的所有方法被切入
@After("within(com.zhangguo.Spring052.aop03.*)")
public void after(JoinPoint jp){
 System.out.println("----------最终通知----------");
}

图片.png

3.3、this切点函数

//this切点函数
//实现了IMath接口的代理对象的任意连接点
@After("this(com.zhangguo.Spring052.aop03.IMath)")
public void after(JoinPoint jp){
 System.out.println("----------最终通知----------");
}

图片.png

3.4、args切点函数

//args切点函数
//要求方法有两个int类型的参考才会被织入横切逻辑
@After("args(int,int)")
public void after(JoinPoint jp){
 System.out.println("----------最终通知----------");
}

图片.png

如果参数类型不是基本数据类型则需要包名。

3.5、@annotation切点函数

先自定义一个可以注解在方法上的注解

p`js
ackage com.zhangguo.Spring052.aop03;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnno {
}

//@annotation切点函数
//要求方法必须被注解com.zhangguo.Spring052.aop03.MyAnno才会被织入横切逻辑
@After("@annotation(com.zhangguo.Spring052.aop03.MyAnno)")
public void after(JoinPoint jp){
System.out.println("----------最终通知----------");
}

package com.zhangguo.Spring052.aop03;

import org.springframework.stereotype.Component;

@Component("strUtil")
public class StrUtil {
@MyAnno
public void show(){
System.out.println("Hello StrUtil!");
}
}




运行结果：

![图片.png](https://ucc.alicdn.com/pic/developer-ecology/0dc6df915d214674b0f7eaf081f8bfcc.png)


其它带@的切点函数都是针对注解的

**四、AspectJ通知注解**

AspectJ通知注解共有6个，常用5个，引介少用一些。

先解决定义切点复用的问题，如下代码所示，切点函数的内容完全一样：

package com.zhangguo.Spring052.aop04;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**

  • 通知类，横切逻辑

*
*/
@Component
@Aspect
public class Advices {
@Before("execution( com.zhangguo.Spring052.aop04.Math.(..))")
public void before(JoinPoint jp){
System.out.println("----------前置通知----------");
System.out.println(jp.getSignature().getName());
}

@After("execution( com.zhangguo.Spring052.aop04.Math.(..))")
public void after(JoinPoint jp){
System.out.println("----------最终通知----------");
}
}




可以先定义一个切点然后复用，如下所示：

package com.zhangguo.Spring052.aop04;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**

  • 通知类，横切逻辑

*/
@Component
@Aspect
public class Advices {
//切点
@Pointcut("execution( com.zhangguo.Spring052.aop04.Math.(..))")
public void pointcut(){
}

@Before("pointcut()")
public void before(JoinPoint jp){
System.out.println("----------前置通知----------");
System.out.println(jp.getSignature().getName());
}

@After("pointcut()")
public void after(JoinPoint jp){
System.out.println("----------最终通知----------");
}
}




修改Advices.java文件，增加各种通知类型如下：

package com.zhangguo.Spring052.aop04;

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;

/**

  • 通知类，横切逻辑

*/
@Component
@Aspect
public class Advices {
//切点
@Pointcut("execution( com.zhangguo.Spring052.aop04.Math.a(..))")
public void pointcut(){
}

//前置通知
@Before("pointcut()")
public void before(JoinPoint jp){
System.out.println(jp.getSignature().getName());
System.out.println("----------前置通知----------");
}

//最终通知
@After("pointcut()")
public void after(JoinPoint jp){
System.out.println("----------最终通知----------");
}

//环绕通知
@Around("execution( com.zhangguo.Spring052.aop04.Math.s(..))")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println(pjp.getSignature().getName());
System.out.println("----------环绕前置----------");
Object result=pjp.proceed();
System.out.println("----------环绕后置----------");
return result;
}

//返回结果通知
@AfterReturning(pointcut="execution( com.zhangguo.Spring052.aop04.Math.m(..))",returning="result")
public void afterReturning(JoinPoint jp,Object result){
System.out.println(jp.getSignature().getName());
System.out.println("结果是："+result);
System.out.println("----------返回结果----------");
}

//异常后通知
@AfterThrowing(pointcut="execution( com.zhangguo.Spring052.aop04.Math.d(..))",throwing="exp")
public void afterThrowing(JoinPoint jp,Exception exp){
System.out.println(jp.getSignature().getName());
System.out.println("异常消息："+exp.getMessage());
System.out.println("----------异常通知----------");
}
}




运行结果：

![图片.png](https://ucc.alicdn.com/pic/developer-ecology/32fa9ec8acfa459eb611bac5883b4539.png)


**五、零配置实现Spring IoC与AOP**

为了实现零配置在原有示例的基础上我们新增一个类User，如下所示：

package com.zhangguo.Spring052.aop05;

public class User {
public void show(){
System.out.println("一个用户对象");
}
}




该类并未注解，容器不会自动管理。因为没有xml配置文件，则使用一个作为配置信息，ApplicationCfg.java文件如下：

package com.zhangguo.Spring052.aop05;

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

@Configuration //用于表示当前类为容器的配置类，类似<beans/>
@ComponentScan(basePackages="com.zhangguo.Spring052.aop05") //扫描的范围，相当于xml配置的结点<context:component-scan/>
@EnableAspectJAutoProxy(proxyTargetClass=true) //自动代理，相当于<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
public class ApplicationCfg {
//在配置中声明一个bean，相当于
@Bean
public User getUser(){
return new User();
}
}



该类的每一部分内容基本都与xml 配置有一对一的关系，请看注释，这样做要比写xml方便，但不便发布后修改。测试代码如下：

package com.zhangguo.Spring052.aop05;

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

public class Test {

public static void main(String[] args) {
// 通过类初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(ApplicationCfg.class);
Math math = ctx.getBean("math", Math.class);
int n1 = 100, n2 = 0;
math.add(n1, n2);
math.sub(n1, n2);
math.mut(n1, n2);
try {
math.div(n1, n2);
} catch (Exception e) {
}

User user=ctx.getBean("getUser",User.class);
user.show();
}

}




 advices.java 同上，没有任何变化，运行结果如下：

![图片.png](https://ucc.alicdn.com/pic/developer-ecology/8306bd83563f4e07ae187ec02ad3a823.png)
文章标签：
Java
容器
Spring
Maven
数据格式
XML
关键词：
Spring AOP
Spring学习
aop学习
学习aop
Spring学习aop
java全栈开发
目录
相关文章
计算机程序设计Y2013070224
|
2月前
|
搜索推荐 JavaScript Java
基于springboot的儿童家长教育能力提升学习系统
本系统聚焦儿童家长教育能力提升，针对家庭教育中理念混乱、时间不足、个性化服务缺失等问题，构建科学、系统、个性化的在线学习平台。融合Spring Boot、Vue等先进技术，整合优质教育资源，提供高效便捷的学习路径，助力家长掌握科学育儿方法，促进儿童全面健康发展，推动家庭和谐与社会进步。
计算机程序设计Y2013070224
168 5
HELLO程序员
|
3月前
|
XML 安全 Java
使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
面向方面编程（AOP）通过分离横切关注点，如日志、安全和事务，提升代码模块化与可维护性。Spring 提供了对 AOP 的强大支持，核心注解 `@Aspect` 和 `@Pointcut` 使得定义切面与切入点变得简洁直观。`@Aspect` 标记切面类，集中处理通用逻辑；`@Pointcut` 则通过表达式定义通知的应用位置，提高代码可读性与复用性。二者结合，使开发者能清晰划分业务逻辑与辅助功能，简化维护并提升系统灵活性。Spring AOP 借助代理机制实现运行时织入，与 Spring 容器无缝集成，支持依赖注入与声明式配置，是构建清晰、高内聚应用的理想选择。
HELLO程序员
429 0
一枚后端工程狮
|
2月前
|
XML Java 数据格式
《深入理解Spring》：AOP面向切面编程深度解析
Spring AOP通过代理模式实现面向切面编程，将日志、事务等横切关注点与业务逻辑分离。支持注解、XML和编程式配置，提供五种通知类型及丰富切点表达式，助力构建高内聚、低耦合的可维护系统。
一枚后端工程狮
462 7
游客wkqymr43luqiu
|
7月前
|
监控 安全 Java
Spring AOP实现原理
本内容主要介绍了Spring AOP的核心概念、实现机制及代理生成流程。涵盖切面（Aspect）、连接点（Join Point）、通知（Advice）、切点（Pointcut）等关键概念，解析了JDK动态代理与CGLIB代理的原理及对比，并深入探讨了通知执行链路和责任链模式的应用。同时，详细分析了AspectJ注解驱动的AOP解析过程，包括切面识别、切点表达式匹配及通知适配为Advice的机制，帮助理解Spring AOP的工作原理与实现细节。
游客wkqymr43luqiu
1109 13
Quan_Chen
|
9月前
|
监控 Java 应用服务中间件
微服务——SpringBoot使用归纳——为什么学习Spring Boot
本文主要探讨为什么学习Spring Boot。从Spring官方定位来看，Spring Boot旨在快速启动和运行项目，简化配置与编码。其优点包括：1) 良好的基因，继承了Spring框架的优点；2) 简化编码，通过starter依赖减少手动配置；3) 简化配置，采用Java Config方式替代繁琐的XML配置；4) 简化部署，内嵌Tomcat支持一键式启动；5) 简化监控，提供运行期性能参数获取功能。此外，从未来发展趋势看，微服务架构逐渐成为主流，而Spring Boot作为官方推荐技术，与Spring Cloud配合使用，将成为未来发展的重要方向。
Quan_Chen
349 0
微服务——SpringBoot使用归纳——为什么学习Spring Boot
aliyun4145988376
|
4月前
|
人工智能 监控 安全
如何快速上手【Spring AOP】？核心应用实战（上篇）
哈喽大家好吖~欢迎来到Spring AOP系列教程的上篇 - 应用篇。在本篇，我们将专注于Spring AOP的实际应用，通过具体的代码示例和场景分析，帮助大家掌握AOP的使用方法和技巧。而在后续的下篇中，我们将深入探讨Spring AOP的实现原理和底层机制。 AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架中的核心特性之一，它能够帮助我们解决横切关注点（如日志记录、性能统计、安全控制、事务管理等）的问题，提高代码的模块化程度和复用性。
aliyun4145988376
553 1
aliyun4145988376
|
4月前
|
设计模式 Java 开发者
如何快速上手【Spring AOP】？从动态代理到源码剖析（下篇）
Spring AOP的实现本质上依赖于代理模式这一经典设计模式。代理模式通过引入代理对象作为目标对象的中间层，实现了对目标对象访问的控制与增强，其核心价值在于解耦核心业务逻辑与横切关注点。在框架设计中，这种模式广泛用于实现功能扩展（如远程调用、延迟加载）、行为拦截（如权限校验、异常处理）等场景，为系统提供了更高的灵活性和可维护性。
aliyun4145988376
270 0
啦啦啦191
|
6月前
|
安全 Java 数据库
Spring Boot 框架深入学习示例教程详解
本教程深入讲解Spring Boot框架，先介绍其基础概念与优势，如自动配置、独立运行等。通过搭建项目、配置数据库等步骤展示技术方案，并结合RESTful API开发实例帮助学习。内容涵盖环境搭建、核心组件应用（Spring MVC、Spring Data JPA、Spring Security）及示例项目——在线书店系统，助你掌握Spring Boot开发全流程。代码资源可从[链接](https://pan.quark.cn/s/14fcf913bae6)获取。
啦啦啦191
956 2
蓝易云
|
8月前
|
Java Spring
Spring框架的学习与应用
总的来说，Spring框架是Java开发中的一把强大的工具。通过理解其核心概念，通过实践来学习和掌握，你可以充分利用Spring框架的强大功能，提高你的开发效率和代码质量。
蓝易云
195 20

热门文章

最新文章

  • 1
    《深入理解Spring》：AOP面向切面编程深度解析
  • 2
    AOP 切面编程
  • 3
    Java高级期末复习：Java EE框架整合开发入门到实战——Spring+Spring MVC+MyBatis微课版
  • 4
    Spring 构造注入和设置注入
  • 5
    spring-web源码解析之AbstractMappingContentNegotiationStrategy
  • 6
    Springboot+vue的旅游信息推荐系统设计与实现（有报告）。Javaee项目，springboot vue前后端分离项目。
  • 7
    实战！Spring Boot Security+JWT前后端分离架构登录认证！
  • 8
    Spring boot随机端口你都不会，怎么动态扩容？
  • 9
    java开发实战(2)：springboot多模块工程引入日志配置和swagger3
  • 10
    Spring 5 中文解析测试篇-集成测试之概要和注解
  • 1
    Spring AOP实现原理
    1109
  • 2
    面向切面编程（AOP）介绍--这是我见过最易理解的文章
    431
  • 3
    微服务——SpringBoot使用归纳——Spring Boot中的切面AOP处理——Spring Boot 中的 AOP 处理
    1084
  • 4
    微服务——SpringBoot使用归纳——Spring Boot中的切面AOP处理——什么是AOP
    522
  • 5
    鸿蒙开发：实现AOP代码插桩能力
    220
  • 6
    Spring AOP—通知类型 和 切入点表达式 万字详解（通俗易懂）
    715
  • 7
    Spring AOP—深入动态代理 万字详解（通俗易懂）
    446
  • 8
    NEON AOP 表面定向反射率数据是一种高光谱 VSWIR（可见光到短波红外）数据产品，包含 426 个波段
    183
  • 9
    Spring Boot中的AOP实现
    528
  • 10
    Spring Boot 3 集成Spring AOP实现系统日志记录
    792

    • 相关课程

    更多
  • 全面讲解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仓库
    • 下一篇
    全面了解阿里云OSS使用方法