当前位置: 首页 > news >正文

Spring介绍以及IOC和AOP的实现

Spring

spring是由interface21框架为基础经过重新设计,并不断丰富其内涵在2004年3月24日发布了1.0版本。

spring的创作理念就在于使现有的技术更加容易使用

优点
  • Spring是一个开源的免费框架(容器)

  • Spring是一个轻量级非入侵式的框架

  • Spring的核心技术控制反转(IOC)和面向切面编程(AOP)

  • 支持事务的处理,支持框架的整合。

总结:Spring是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架

Spring的组成

  1. Core Container(核心容器)

    • 功能:IoC(控制反转)和 DI(依赖注入)实现,管理 Bean 的生命周期。

    • 核心类ApplicationContextBeanFactory

  2. AOP(面向切面编程)

    • 功能:通过动态代理实现日志、事务等横切逻辑。

    • 注解@Aspect@Transactional

  3. Data Access(数据访问)

    • 功能:简化 JDBC(JdbcTemplate)、集成 ORM(Hibernate/JPA)。

    • 事务管理:声明式事务(@Transactional

  4. Web MVC

    • 功能:基于 Servlet 的 MVC 框架,支持 REST。

    • 核心类DispatcherServlet@Controller

  5. Context(上下文)

    • 功能:扩展 ApplicationContext,提供国际化、事件机制等。

  6. WebFlux(响应式 Web)

    • 功能:非阻塞响应式编程(基于 Reactor),替代传统 Web MVC。

  7. Testing(测试)

    • 功能:集成 JUnit,支持 Mock 测试(@SpringBootTest)。

IOC和AOP

Spring Ioc:控制反转的意思,它指的是一种思想,早些时候我们需要通过new关键字来创造对象,这就存在了一个弊端,当用户需要其它功能的时候,就会出现问题,我们就需要实时的根据需求进行修改,当我们通过IOC容器来帮我们进行实例化对象的时候,就大大的降低了对象之间的耦合度。依赖注入DI就是实现这个技术的一种方式。

AOP(面向切面编程) 的核心思想是:将与业务无关的通用功能(如日志、事务、权限)从业务代码中剥离,以切面(Aspect)的形式统一管理,避免代码重复和耦合。Spring AOP 的代理实现分为 JDK 动态代理CGLIB 代理,具体选择取决于目标对象是否实现接口。

当我们使用Spring AOP的时候:

1.先添加依赖:

<!-- Maven 依赖 -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2.定义切面类

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
​
@Aspect
@Component
public class LogAspect {
​// 定义切入点:拦截 service 包下所有方法@Pointcut("execution(* com.example.service.*.*(..))")public void serviceMethods() {}
​// 前置通知:方法执行前调用@Before("serviceMethods()")public void beforeAdvice() {System.out.println("【前置通知】准备执行方法...");}
​// 后置通知:方法正常返回后调用@AfterReturning(pointcut = "serviceMethods()", returning = "result")public void afterReturningAdvice(Object result) {System.out.println("【后置通知】方法执行成功,返回值:" + result);}
​// 异常通知:方法抛出异常时调用@AfterThrowing(pointcut = "serviceMethods()", throwing = "ex")public void afterThrowingAdvice(Exception ex) {System.out.println("【异常通知】方法执行异常:" + ex.getMessage());}
​// 环绕通知:控制方法整个执行流程@Around("serviceMethods()")public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {System.out.println("【环绕通知】方法开始执行...");Object result = pjp.proceed(); // 执行目标方法System.out.println("【环绕通知】方法执行结束");return result;}
}

3.切入点表达式

Spring AOP使用AspectJ切入点表达式语言定义切入点:

  • execution([修饰符] 返回类型 [类名].方法名(参数) [异常])

    • * 代表任意

    • .. 代表任意参数或包路径

    • 示例:

      • execution(public * *(..)) - 所有public方法

      • execution(* set*(..)) - 所有以set开头的方法

      • execution(* com.xyz.service.*.*(..)) - service包下所有类的所有方法

      • execution(* com.xyz.service..*.*(..)) - service包及其子包下所有类的所有方法

4.通知执行顺序

  1. 环绕通知的前半部分(@Around)

  2. 前置通知(@Before)

  3. 目标方法执行

  4. 后置通知(@AfterReturning)或异常通知(@AfterThrowing)

  5. 最终通知(@After)

  6. 环绕通知的后半部分(@Around)

可以通过@Order注解指定切面执行顺序:

@Aspect
@Component
@Order(1)  // 数字越小优先级越高
public class LoggingAspect {// ...
}

Spring AOP的高级特性

1.获取方法的信息

在通知方法中可以通过JoinPointProceedingJoinPoint获取方法信息:

@Before("serviceLayer()")
public void logBefore(JoinPoint joinPoint) {// 获取方法签名MethodSignature signature = (MethodSignature) joinPoint.getSignature();Method method = signature.getMethod();// 获取方法参数名和值String[] paramNames = signature.getParameterNames();Object[] paramValues = joinPoint.getArgs();// 获取目标类Object target = joinPoint.getTarget();Class<?> targetClass = target.getClass();
}

2.处理通知中的异常

在环绕通知当中可以捕获并处理异常

@Around("serviceLayer()")
public Object handleException(ProceedingJoinPoint joinPoint) {try {return joinPoint.proceed();} catch (BusinessException ex) {// 处理业务异常return fallbackResult();} catch (Throwable ex) {// 处理其他异常throw new RuntimeException("系统异常", ex);}
}

Spring AOP 的代理实现分为 JDK 动态代理CGLIB 代理,具体选择取决于目标对象是否实现接口。

JDK动态代理

需要目标至少实现一个接口,实现原理:JDK动态代理通过反射在运行时动态生成实现指定接口的代理类,将方法调用转发到InvocationHandler处理,在调用真实方法前后可插入自定义逻辑。

我们进行示例:

1.定义业务接口和实现

public interface OrderService {void createOrder(String orderId);void cancelOrder(String orderId);
}
public class OrderServiceImpl implements OrderService {@Overridepublic void createOrder(String orderId) {System.out.println("创建订单: " + orderId);}@Overridepublic void cancelOrder(String orderId) {System.out.println("取消订单: " + orderId);}
}

2.实现InvocationHandler

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
​
public class OrderServiceHandler implements InvocationHandler {private final Object target;  // 目标对象public OrderServiceHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 前置处理System.out.println("[日志] 开始执行 " + method.getName() + " 方法");System.out.println("[参数] " + (args != null ? Arrays.toString(args) : "无"));// 调用目标方法Object result = method.invoke(target, args);// 后置处理System.out.println("[日志] " + method.getName() + " 方法执行完成");return result;}
}

3.创建并使用

import java.lang.reflect.Proxy;
​
public class JdkProxyDemo {public static void main(String[] args) {// 1. 创建目标对象OrderService target = new OrderServiceImpl();// 2. 创建调用处理器OrderServiceHandler handler = new OrderServiceHandler(target);// 3. 创建代理对象OrderService proxy = (OrderService) Proxy.newProxyInstance(OrderService.class.getClassLoader(),  // 类加载器new Class[]{OrderService.class},     // 代理接口数组handler                             // 调用处理器);// 4. 使用代理对象proxy.createOrder("ORD123456");System.out.println("----------------");proxy.cancelOrder("ORD123456");}
}

执行结果

[日志] 开始执行 createOrder 方法
[参数] [ORD123456]
创建订单: ORD123456
[日志] createOrder 方法执行完成
----------------
[日志] 开始执行 cancelOrder 方法
[参数] [ORD123456]
取消订单: ORD123456
[日志] cancelOrder 方法执行完成

CGLIB动态代理

CGLIB动态代理通过继承目标类生成子类,重写方法实现代理,无需接口即可拦截方法调用(无法代理final类/方法)。

示例:

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
​
public class CglibDemo {// 目标类(无需接口)static class UserService {public void saveUser(String name) {System.out.println("保存用户: " + name);}}
​public static void main(String[] args) {// 1. 创建 EnhancerEnhancer enhancer = new Enhancer();enhancer.setSuperclass(UserService.class); // 设置父类(目标类)// 2. 设置回调(拦截逻辑)enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {System.out.println("[CGLIB] 方法调用前: " + method.getName());Object result = proxy.invokeSuper(obj, args); // 调用父类方法System.out.println("[CGLIB] 方法调用后");return result;});
​// 3. 生成代理对象UserService proxy = (UserService) enhancer.create();// 4. 调用代理方法proxy.saveUser("张三");}
}

Spring AOP 是高层抽象,底层默认通过 JDK动态代理(基于接口)或 CGLIB(基于子类)实现动态代理

http://www.lryc.cn/news/591927.html

相关文章:

  • 行为型设计模式:解释器模式
  • 2026python实战——如何利用海外代理ip爬取海外数据
  • ​​Docker 速通教程
  • 【Docker#2】容器历史发展 | 虚拟化实现方式
  • Delphi EDI 需求分析与对接指南
  • Docker 与 GPU 训练
  • 【Docker】在Linux环境下使用Dockerfile打包镜像(图文示例)
  • 深入浅出MyBatis缓存:如何让数据库交互飞起来
  • 无标记点动捕:如何突破传统娱乐边界,打造沉浸式交互体验
  • vscode的终端运行目录修改为当前文件的路径下
  • C#通过HslCommunication连接西门子PLC1200,并防止数据跳动的通用方法
  • 异世界历险之数据结构世界(排序(插入,希尔,堆排))
  • CentOS7下的ElasticSearch部署
  • 2025年6月电子学会全国青少年软件编程等级考试(Python一级)真题及答案
  • TL1A靶点:自免炎症领域的“潜力之星”
  • chainlink VRF中文教程(含mock),解决error: Arithmetic Underflow in createSubscription
  • Elasticsearch 和 solr 的区别
  • Prometheus错误率监控与告警实战:如何自定义规则精准预警服务器异常
  • 大数据时代下的时序数据库选型指南:基于工业场景的IoTDB技术优势与适用性研究
  • LiteCloud超轻量级网盘项目基于Spring Boot
  • 如何解决pip安装报错ModuleNotFoundError: No module named ‘django’问题
  • 第2章通用的高并发架构设计——2.5 高并发读场景总结:CQRS
  • JavaScript中的Window对象
  • 个人笔记(初级Linux运维设计脚本编写任务)
  • 微信小程序151~160
  • stl-string模拟
  • Solr7升级Solr8全攻略:从Core重命名到IK分词兼容,零业务中断实战指南
  • Java零基础快速入门
  • 闲庭信步使用图像验证平台加速FPGA的开发:第二十一课——高斯下采样后图像还原的FPGA实现
  • 缓存雪崩、缓存穿透,缓存击穿