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

Spring介绍以及IOC和AOP的实现

news 2025/7/19 6:40:48

Spring

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

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

优点

  • Spring是一个开源的免费框架（容器）

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

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

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

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

Spring的组成

  2. Core Container（核心容器）

    • 功能：IoC（控制反转）和 DI（依赖注入）实现，管理 Bean 的生命周期。

    • 核心类：ApplicationContext、BeanFactory

  3. AOP（面向切面编程）

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

    • 注解：@Aspect、@Transactional

  4. Data Access（数据访问）

    • 功能：简化 JDBC（JdbcTemplate）、集成 ORM（Hibernate/JPA）。

    • 事务管理：声明式事务（@Transactional）

  5. Web MVC

    • 功能：基于 Servlet 的 MVC 框架，支持 REST。

    • 核心类：DispatcherServlet、@Controller

  6. Context（上下文）

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

  7. WebFlux（响应式 Web）

    • 功能：非阻塞响应式编程（基于 Reactor），替代传统 Web MVC。

  8. 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.获取方法的信息

在通知方法中可以通过JoinPoint或ProceedingJoinPoint获取方法信息：

@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.dtcms.com/a/285854.html

相关文章：

  • 某邮生活旋转验证码逆向
  • Ansible + Shell 服务器巡检脚本
  • 如何使用Python将HTML格式的文本转换为Markdown格式？
  • UDP 协议下一发一收通信程序的实现与解析
  • Python - 数据分析三剑客之Pandas
  • docker--容器自启动
  • Vue导出Html为Word中包含图片在Microsoft Word显示异常问题
  • Python MP3 归一化器和长度分割器实用工具开发指南
  • 曼哈顿自注意力MaSA，基于曼哈顿距离的显式空间先验，以线性计算复杂度高效建模全局与局部空间关系，提升视觉任务的性能。
  • Java: 反射机制的 ParameterizedType(参数化类型）
  • WEB弹性设计
  • 使用 C++ 和 OpenCV 进行表面划痕检测
  • jQuery最新js文件下载教程
  • Django母婴商城项目实践（五）
  • Python 使用期物处理并发(使用concurrent.futures模块下载)
  • 黑马Node.js全套入门教程，nodejs新教程含es6模块化+npm+express+webpack+promise等_ts对象笔记
  • MISRA C-2012准则之指针类型转换
  • build.log中的is not a subdirectory of和ScanSourceDirectories函数的关系
  • 「Java案例」方法重装求不同类型数的立方
  • MySql：索引，结构
  • Leetcode 04 java
  • cocosCreator2.4 Android 输入法遮挡
  • JAVA中StringBuilder类，StringJoiner类构造函数方法简单介绍
  • C语言基础：数组练习题
  • Zabbix安装-Server
  • 【JS笔记】Java Script学习笔记
  • 【C语言进阶】题目练习(2)
  • react控制react Popover组件显示隐藏
  • Vue3 中使用 Element Plus 实现自定义按钮的 ElNotification 提示框
  • WAF 能防御哪些攻击？