Spring on pipo's site

Spring 中的 Bind

Thu, 22 Jan 2026 14:44:35 +0800

Bind 是什么？

Spring Boot 的 Bind 机制主要负责将 外部配置（如 application.yml、application.properties、环境变量等）绑定到 Java 对象 中。

外部配置绑定优先级：

命令行参数（java -jar app.jar --db.port=9000)
操作系统环境变量（export DB_PORT=9000)
jar 包外部的配置文件（/config/application.yaml)
jar 包内部的配置文件（resources/application.yml)

三种绑定方式

@Value

@Component
public class MyService {
    
    @Value("${app.name:default-app}")  // 支持默认值
    private String appName;
    
    @Value("${app.feature.enabled:false}")
    private boolean featureEnabled;
    
    @Value("#{systemProperties['user.home']}")  // SpEL 表达式
    private String userHome;
}

限制：

不支持 JSR-303 校验
不支持复杂对象绑定
不支持松散绑定
无法在配置文件中提示 IDE 支持

@ConfigurationProperties

@ConfigurationProperties( prefix = "") 外部配置文件：

myapp:
  name: 'myapp'
  server:
    host: 1.1.1.1
    port: 80
  security:
    username: admin
    password: 123

配置方式

@Data
@Component 
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
	// 必须要提供 getter setter，可以使用 Lombook 简化
	private String name;
	
	private ServerConfig server;
	
	private ServerSecurity security;
	
	//嵌套配置 创建类， 必须是 public static
	@Data
	public static class ServerConfig {
		private String host;
		private Long port;
	}
	
	@Data 
	public static class ServerSecurity {
		private String username; 
		private String password;
	}
	
}

使用方式

@Configuration
public class AppConfig {
	@Autowired
	private MyAppProperties properties;
}

prefix 的使用： prefix 填入要被装载的属性的前缀，如果有多个嵌套则可以 myapp.server.XXX.XXX 来装载对应层级下的属性
松散绑定： Spring 可以自动将配置属性的名词与定义的类中的名称进行自动映射支持的类型名称：
- kebab-case (烤肉串式): 全小写，单词间用连字符分隔，如 my-variable-name
- snake_case (蛇形): 全小写，单词间用下划线分隔，如 my_variable_name
- UPPERCASE (全大写): 全部大写，通常用于常量，如 MY_CONSTANT

JSR-303 校验：在类上添加 @Validated 开启校验

@NotNull
@Min()
@Max()
@NotBlank
@Email
@Size(min = )

@Data
@Component
@ConfigurationProperties(prefix = "myapp")
@Validated // <--- 开启第一层校验
public class MyAppProperties {
    @Valid // <--- 关键！告诉 Spring 钻进去校验内部属性
    private ServerConfig server;
    // ...
}

Binder API

使用 Binder API 读取 Environment 中的配置

Bind bind = Binder.get(environment);

读取单个值

// 读取单个值
String host = bind.bind("myapp.server.host", String.class).orElse("1.1.1.1");

读取单个值要写入完整的路径，并且使用点号分割

读取复杂类型 (List/Map)

如果在 application.yaml 里写了一个 List：

my-app:
  whitelist:
    - 192.168.1.1
    - 10.0.0.1

需要使用 Bindable 包装器处理范型

List<String> ips = 
binder.bind( "my-app.whitelist", Bindable.listOf(String.class) // <--- 关键！告诉 Binder 这是一个 List<String> ).orElse(Collections.emptyList());

如果是更复杂的比如

routes:  
  - id: "order-service"  
    path: "/api/order"  
    url: "http://localhost:8081"  
  - id: "user-service"  
    path: "/api/user"  
    url: "http://localhost:8082"
    
private List<Map<Object, Object>> routes = new ArrayList<>();

1.方法一
@SuppressWarnings("unchecked")  
List<Map<Object, Object>> routes = (List<Map<Object, Object>>) (List<?>)  
        binder.bind("gateway.routes", Bindable.listOf(Map.class))  
                .orElse(List.of());
2.方法二                  
List<?> routes = binder.bind("gateway.routes", Bindable.listOf(Map.class))  
        .orElse(List.of());

3.方法三
public class RouteConfig {
    private String id;
    private String path;
    private String url;
}

List<RouteConfig> routes = binder.bind("gateway.routes", 
        Bindable.listOf(RouteConfig.class))
        .orElse(List.of());

读取整个配置类

//后面的 XXX.class 是在告诉 “我要读取的是什么类型的配置请转换成这种类型 "
MyAppProperties properties = bind.bind("myapp", MyAppProperties.class).get();

创建本地 bind 并绑定

创建本地 bind 并添加配置

Binder binder = Binder.get(environment);

//添加 配置
1. 方法一
	MapConfigurationPropertySource source1 = new MapConfigurationPropertySource(map1);
	MapConfigurationPropertySource source2 = new MapConfigurationPropertySource(map2);
	
	Binder localBind = new Binder(source1, source2);
2. 方法二
	List<ConfigurationPropertySource> sources = new ArrayList<>();
	sources.add(new MapConfigurationPropertySource(map1));
	sources.add(new MapConfigurationPropertySource(map2));
	sources.add(new MapConfigurationPropertySource(map3));

	Binder localBind = new Binder(sources);

生产中建议

private Binder createLocalBinder(Map<String, Object>... configMaps) {
    List<ConfigurationPropertySource> sources = new ArrayList<>();
    
    for (Map<String, Object> map : configMaps) {
        if (map != null && !map.isEmpty()) {
            sources.add(new MapConfigurationPropertySource(map));
        }
    }
    
    return new Binder(sources);
}
// 使用
Binder localBind = createLocalBinder(legacyMap, otherMap, thirdMap);

将 bind 中的值绑定类

//RouteDefinition.java
@Data  
public class RouteDefinition {  
    private String id;  
  
    private String path;  
  
    private String url;  
}

Map<String, Object> legacyMap = new HashMap<>();  
legacyMap.put("id", "legacy-service-999");  
legacyMap.put("path", "/api/old");  
legacyMap.put("url", "http://192.168.1.100");  

//Bind 无法直接绑定 Map 需要转换
MapConfigurationPropertySource legacyConfigurationMap = new MapConfigurationPropertySource(legacyMap);  
Binder localBind = new Binder(legacyConfigurationMap);  

									//为什么这里是 "" 空字符串？
RouteDefinition legacyRoute = localBind.bind("", RouteDefinition.class).orElse(new RouteDefinition());  
System.out.println(legacyRoute);

prefix + 要注入的字段名 = key 此时 key 与字段名完全相同，所以使用空字符串如果 legacyMap 中 put 时 key 是 legacy.route.id 那么在将 source 中的属性绑定到 RouteDefinition 时 prefix = “legacy.route”

三种绑定方式对比

特性	@Value	@ConfigurationProperties	Binder API
使用场景	1-2 个简单配置	结构化配置、多个相关配置	动态绑定、运行时绑定
JSR-303 校验	❌ 不支持	✅ 支持（@Validated）	✅ 支持
松散绑定	❌ 不支持	✅ 支持	✅ 支持
复杂对象	❌ 不支持	✅ 支持（嵌套对象）	✅ 支持
IDE 元数据支持	❌ 无提示	✅ 有提示（spring-configuration-metadata.json）	❌ 无提示
类型安全	⚠️ 编译时不检查	✅ 强类型检查	✅ 强类型检查
集合类型	⚠️ 需要手动解析	✅ 自动绑定 List/Set/Map	✅ 自动绑定（需要 Bindable）
默认值	✅ `${prop:default}`	✅ 字段初始化或 @DefaultValue	✅ `.withDefaultValue()`
灵活性	低	中	高

优先使用 @ConfigurationProperties - 类型安全、IDE 支持、可校验
简单配置用 @Value - 如端口、开关等单个属性
动态配置用 Binder API - 如从数据库、Nacos 读取配置后绑定

Reference

Spring循环依赖解决

Thu, 27 Nov 2025 09:05:35 +0800

什么是依赖循环？

我们知道在 Spring 中依赖注入时的行为是：

如果当前 Bean 依赖其他 Bean，那么递归注入子 Bean
如果来源于配置文件，则从 Environment 中读取

这就导致了如果 A→B→C→A 成环互相依赖，就会不断递归陷入死循环。就像是死锁一样，互相等待彼此。

类比死锁的解决方案

我们可以借鉴解决死锁的方法来解决依赖循环：

破坏互斥条件：允许所有资源被共享，但这不适用于某些不能共享的资源（如打印机）
破坏不剥夺条件：当进程请求新资源未得到满足时，必须释放所有已占有的资源
破坏请求与保持条件：采用预先静态分配，即进程在运行前一次性申请所有所需资源
破坏循环等待条件：采用顺序资源分配，规定进程必须按照资源的编号顺序来申请

Spring 的选择：

Spring 选择的是破坏循环等待条件（或者说打破了"资源必须完全就绪才能被使用"的互斥条件），允许循环中的 Bean 在未完全初始化结束前，先拿到一个"半成品"引用，从而结束递归等待。

Spring 在哪里、通过什么方法解决了它？

Spring 通过在 Instantiation 之后提前暴露工厂对象，在 Populate 之前，加入到三级缓存，允许其他对象通过 ObjectFactory 获取到 bean。

三级缓存机制

级别	缓存名称	存放内容	作用
一级缓存	singletonObjects	完全初始化好的 Bean	存放成熟的单例 Bean
二级缓存	earlySingletonObjects	半成品的 Bean（提前代理）	解决循环依赖中的 AOP 代理单例问题
三级缓存	singletonFactories	ObjectFactory	延迟决策是否需要代理

具体流程

A 实例化 → 暴露工厂到三级缓存
    ↓
A 填充属性，需要 B
    ↓
B 实例化 → 暴露工厂到三级缓存
    ↓
B 填充属性，需要 A → 从三级缓存获取 A 的工厂 → 创建代理/获取原始对象 → 放入二级缓存
    ↓
B 完成 → 放入一级缓存
    ↓
A 继续填充 B（从一级缓存获取）→ A 完成 → 放入一级缓存

![[../pics/BeanDependencyLoop.png]]

为什么要三级缓存而不是二级？

如果去掉二级缓存会发生什么：

当非 AOP代理的对象注入属性时 B从三级缓存中 getbean获取到A,打破循环，此时B已经已经成熟，放入一级缓存，回到A的属性注入流程，查找一级缓存，发现B存在，完成注入。整体流程没有问题，也就是说在没有AOP代理时是可以的。
当有AOP代理时 B从三级缓存中 getbean获取到proxy012_A，把自身放入一级缓存，A又依赖C，C从三级缓存中获取proxy013_A，回到A，此时B和C拿到的是不同的A的代理对象，违反了单例原则。当加入了二级缓存，获取到proxy_A后会把代理对象放到二级缓存，其他依赖需要时拿到的是同一个代理对象。

为什么不直接在三级缓存中存放代理对象？

Spring 的设计初衷是 AOP 代理应当在 Bean 生命周期最后一步（初始化后）完成。但在 循环依赖 这种极端情况下，为了打破死锁，Spring 此时不得不妥协，允许在 实例化后、填充属性前 提前进行 AOP。

为什么提前暴露“空壳代理”没问题？

因为 Java 是 值传递（传递的是对象引用的地址）。

代理对象（Proxy）内部持有原始对象（Target）的引用。
虽然注入给别人时，原始对象还是“空的”，但随着生命周期继续，原始对象会被填充完好。
当真正调用代理对象方法时，内部委托的原始对象已经是成熟的了。

为什么要三级缓存总结：

三级缓存（ObjectFactory）：它的作用是 “延迟决策”。它存的是一个生成代理的工厂逻辑，而不是具体的对象。只有当循环依赖发生时，才去运行这个逻辑（打破原则）；否则，永远不运行（坚持原则）。Spring选的的是破坏不剥夺条件，允许循环中的Bean先拿到不成熟的Bean，结束递归。
二级缓存（EarlySingletonObjects）：它的作用是 “保持单例”。一旦三级缓存的工厂被执行，生成的代理对象（Proxy）必须放入二级缓存。因为 createProxy 每次都会产生新对象，如果有多个 Bean 依赖它，必须从二级缓存拿同一个 Proxy，保证全局唯一。

为什么构造器注入无法解决依赖循环？

在 Bean 的生命周期中 Instantiation 中如果使用的是构造器注入，会在此步骤直接注入依赖，但暴露工厂对象是在 Instantiation 结束后进行的，此时缓存中没有对象，无法获取到未成熟的Bean 。解决方法：使用懒加载 @Lazy，返回一个空壳，当真正需要该对象时才加载注入属性。

总结

问题	答案
Spring 如何解决循环依赖	三级缓存 + 提前暴露半成品对象
为什么需要三级缓存	三级缓存用于"延迟决策"是否需要代理，二级缓存用于保持代理单例
构造器注入为什么不支持	构造器注入发生在暴露工厂之前
推荐的注入方式	构造器注入（避免循环依赖）+ 必要时使用 @Lazy

Reference

聊透Spring循环依赖 - 掘金

Spring Bean生命周期

Tue, 25 Nov 2025 20:22:35 +0800

Bean 的生命流程简述

Instantitaion
populate
Initialization
使用
结束销毁

Instantiation

什么是 Instatiation？他和 populate 有什么区别？

Spring 的 Bean 创建是控制反转（IoC）的核心体现。容器根据 BeanDefinition 中的元数据（如类名、作用域、构造参数、工厂方法、初始化/销毁方法等），通过 Java 反射机制来实例化 Bean 对象。这个阶段只是‘创建空壳对象’，尚未进行依赖注入。后续 Spring 会基于同样的 BeanDefinition 完成 属性填充（即依赖注入）和初始化，最终将一个完整可用的 Bean 交还给应用。通过这种方式，对象的创建和依赖管理不再由程序员手动控制（比如 new），而是交给了 Spring 容器，实现了控制反转。

三种创建对象的方法

Supplier
工厂方法
构造函数

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   //检查获取 BeanDefinition
   Class<?> beanClass = resolveBeanClass(mbd, beanName);

   //首先检查是否提供了 Supplier，如果有就直接返回创建对象
   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }

   
   //检查是否有工厂方法
   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }
   
   
   //执行后置处理器, 获取候选构造方法
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      return autowireConstructor(beanName, mbd, ctors, args);
   }

   
   return instantiateBean(beanName, mbd);
}

populate

populate 在做什么？

popluate 流程主要是将属性注入到上一步创建好的“空壳对象”，核心是对对象中有 [[@Autowired]] 和 @Resource 的字段 Setter 函数等注入属性，完成这一步后会进行 Initialization 进行 AOP 代理、回调 Aware 接口、回调初始化方法。

属性填充的核心流程

读取 BeanDefinition
Spring 查看这个 Bean 的 PropertyValues（属性值元数据）
解析依赖来源
- 如果依赖来源于其他 Bean，那么递归先去创建该 Bean（如果成环这里就可能诞生 [[依赖循环]]依赖循环的问题）
- 如果来源于配置文件，则从 Environment 中读取
通过反射赋值
- [[Spring/@AutoWired.md|@AutoWired ]]注入（构造器注入已经在 Instantiation 阶段完成）
- @Resource 注入

Initalization

Aware BeanPostProcessor invokeInitMethods() BeanPostFactory.postProcessAfterInitialization()

步骤	名称	作用	代码体现	具体效果
4	`BeanPostProcessor` 前置处理	在初始化方法执行前，允许你对 Bean 做预处理	`postProcessBeforeInitialization`	打印日志，告诉开发者“Bean 即将初始化”，可用于权限检查、日志埋点等。
5	是否实现 `InitializingBean`	Spring 提供的标准初始化回调接口	`afterPropertiesSet()`	在这里做数据校验（如用户名不能为空），确保 Bean 状态合法。
6	是否配置自定义 `init-method`	用户自定义的初始化方法	`myInitMethod()`	在这里做业务初始化（如加载缓存、连接数据库），非常灵活。
7	`BeanPostProcessor` 后置处理	在所有初始化完成后，对 Bean 进行最终处理或包装	`postProcessAfterInitialization`	关键效果：返回一个代理对象！这使得你可以无侵入地给 Bean 添加功能（如事务、日志、安全检查），这就是 AOP 的基础。

! [[../pics/SpringBean.png]]

Destruction

当容器关闭时会调用

DisposableBean.destroy()
destory-method() 与初始化阶段的 InitializingBean.afterPropertiesSet() 和 init_method 对称

总结：Destruction 的核心要点

要点	说明
两个钩子	`DisposableBean.destroy()` + `destroy-method`
执行顺序	`@PreDestroy` → `destroy()` → `destroy-method`
触发条件	必须调用 `context.close()`
为什么重要	防止资源泄漏（数据库连接、线程池、文件句柄等）
最佳实践	用 `@PreDestroy` 注解方法，清晰且解耦

Reference

title: "聊透Spring bean的生命周期一步一图带你理解Spring bean的生命周期，清楚Spring的IOC、DI、A - 掘金"
image: "https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1960950d22104a639e09de10d2bff105~tplv-k3u1fbpfcp-zoom-in-crop-mark:1512:0:0:0.awebp?"
description: "一步一图带你理解Spring bean的生命周期，清楚Spring的IOC、DI、AOP是怎么完成的，并教你如何借助Bean的生命周期，拓展你的应用"
url: "https://juejin.cn/post/7155884227714613285"
favicon: ""
aspectRatio: "24.867724867724867"

title: "聊透Spring依赖注入依赖自动注入；依赖注入模型；[[@AutoWired]]和@Resource依赖注入的解析、超找、注入流 - 掘金"
image: "https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9f2a1a92368a44c8bfb343fc864a7a52~tplv-k3u1fbpfcp-zoom-in-crop-mark:1512:0:0:0.awebp?"
description: "依赖自动注入；依赖注入模型；@AutoWired和@Resource依赖注入的解析、超找、注入流程分析；@Qualifier实现名称查找的原理分析"
url: "https://juejin.cn/post/7143419261657022472"
favicon: ""
aspectRatio: "42.28310502283105"

IoC控制反转与DI依赖注入

Tue, 25 Nov 2025 11:25:35 +0800

什么是 IoC (Inversion of Control) 和 DI (Dependency Injection)？

IoC 控制反转

IoC 控制反转，指的是创建和控制注入 Spring Bean 的操作权反转交给框架去自动完成。

DI 依赖注入

DI 依赖注入，是 IoC 思想在 Spring 的实现，框架自动地将程序所需的依赖注入到 Bean 中。

在 Spring Boot 中的关系

IoC 是设计思想，DI 是实现方式。Spring 容器通过 IoC 容器管理 Bean，并通过 DI 完成依赖注入。

Spring Boot 中如何实现依赖注入？

依赖注入方式有：

注解 @Autowired 直接字段进行注入
Setter() 方法注入
构造函数注入

我们通常会使用 构造函数 和 字段注入。

	字段注入	Setter()注入	构造函数注入
final 不可变对象	❌ 不可注入	❌ 不可注入	✅ 可以
通用性	只适用于 IoC 容器	只适用于 IoC 容器	非 IoC 也适用

解释@Autowired 注解的作用，以及它在 Spring Boot 中的自动装配模式有哪些？

@Autowired 自动装配

什么是 Bean 的作用域 (Scope)？

Spring Boot 支持多种 Bean 作用域：

作用域	描述
singleton	单例模式（默认）
prototype	原型模式，每次请求创建新实例
request	每次 HTTP 请求创建一个实例（Web）
session	同一个 HTTP Session 共享实例
application	ServletContext 生命周期

@Qualifier 和 @Primary 注解

@Qualifier：显式指定 Bean 名称，用于解决多个同类型 Bean 的冲突
@Primary：标记优先使用的 Bean

ApplicationContext 与 BeanFactory

特性	BeanFactory	ApplicationContext
类型	基础接口	BeanFactory 的子接口，更高级
功能	基础的 IoC 容器功能	提供更多企业级特性（事件发布、国际化、资源加载等）
初始化时机	懒加载（getBean 时才初始化）	饿加载（容器启动时预加载所有单例 Bean）
适用场景	资源受限的环境或需要延迟加载	大多数企业应用（推荐使用）

配置文件依赖注入

可以在 application.properties 或 application.yml 中配置属性，然后通过：

@Value("${property.name}") 注入单个属性
@ConfigurationProperties 批量注入属性

依赖反转原则 (DIP)

依赖反转原则（DIP）是 SOLID 原则之一，主张：

高层模块不应依赖低层模块，两者都应依赖抽象
抽象不应依赖细节，细节应依赖抽象

DI 是 DIP 在 Spring 中的具体实现。

Autowired自动装配

Sat, 22 Nov 2025 13:34:35 +0800

@Autowired 的自动装配模式

@Autowired 默认是 按类型 (byType) 自动注入的。

按类型注入

按类型注入指的是：当 Spring 发现当前字段有 @Autowired 的标注之后，会去查看其字段类型，然后去寻找已注册的实现了当前字段类型的 Bean 然后初始化注入。

@Autowired
private UserService userService;
// 当前字段类型为 UserService

// UserService.java
public interface UserService { ... }

// UserServiceImpl.java
@Service
public class UserServiceImpl implements UserService { ... }

在上面例子中，已注册的实现 UserService 的 Bean 是 UserServiceImpl，Spring 会把这个 Bean 实例化注入到 userService 中。

当有多个同类型 Bean 时会怎样，如何解决？

在上面的例子中如果我们同时实现了多个 UserService 的话会怎样？

@Autowired
private UserService userService;

// UserService.java
public interface UserService { ... }

// UserServiceImpl.java
@Service
public class UserServiceImpl implements UserService { ... }

// UserServiceImpl2.java
@Service
public class UserServiceImpl2 implements UserService { ... }

这种情况会抛出 NoUniqueBeanDefinitionException 错误。

解决方案：@Qualifier 显式指定

可以使用 @Qualifier 注解指定具体的 Bean 名称，从而在多个同类型 Bean 中精确选择一个进行注入。

@Qualifier("userServiceImpl") // 注意：默认 bean 名称为类名首字母小写
@Autowired
private UserService userService;

@Service 注解默认生成的 Bean 名称是类名的首字母小写（如 UserServiceImpl → userServiceImpl）

解决方案：@Primary 标记首选

@Service
@Primary
public class UserServiceImpl implements UserService { ... }

标记了 @Primary 的 Bean 会在多个候选 Bean 中被优先选择。

@Autowired 的注入位置

1. 字段注入

@Autowired
private UserService userService;

简洁直接
不支持 final 字段
不利于单元测试

2. Setter 注入

private UserService userService;

@Autowired
public void setUserService(UserService userService) {
    this.userService = userService;
}

可选依赖
不支持 final 字段

3. 构造器注入（推荐）

private final UserService userService;

@Autowired
public UserController(UserService userService) {
    this.userService = userService;
}

从 Spring 4.3 开始，如果类只有一个构造器，@Autowired 可以省略。

优点：

支持 final 字段，保证不可变性
依赖关系清晰，便于理解
便于单元测试（可以直接 new 对象）
配合 Lombok 的 @RequiredArgsConstructor 更简洁

Spring Aop

Sun, 03 Aug 2025 00:00:00 +0000

1.AOP(Aspect-Oriented Programming) 面向切面编程

![](/pics/redis/Pasted image 20251020085030.png)

解耦代码 eg: 有多段类似业务代码,执行时需要进行log输出和判断

@Service
public class UserService {

	public void addUser(String name, int age) {

	System.out.println("add user: " + name + ", age: " + age);

	}

	public void deleteUser(int id) throws Exception {

	System.out.println("delete user: " + id);

	}
}

传统方法:

@Service
public class UserService {

	public void addUser(String name, int age) {
	System.out.println("[log] method addUser")
	System.out.println("add user: " + name + ", age: " + age);

	}

	public void deleteUser(int id) throws Exception {
	logBefore();
	System.out.println("delete user: " + id);
	logAfter();

	}
}

每段业务需要编写对应log输出或者是调用对应的日志输出方法,对业务代码侵入性强,出现了代码冗余.

AOP:

//UserService
@Service
public class UserService {

	public void addUser(String name, int age) {

	System.out.println("add user: " + name + ", age: " + age);

	}

	public void deleteUser(int id) throws Exception {

	System.out.println("delete user: " + id);

	}
}


//LogAspect
@Aspect  
@Component  
public class LogAspect {  
    @Pointcut(("within(@org.springframework.stereotype.Service *)"))  
    // @Around(execution(* com.example.service.*.*(..)))  
    public void logPoint() {}
	@Around("logPoint()")  
	public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {  
	    long start = System.currentTimeMillis();  
	    Object[] args = joinPoint.getArgs();  
	    System.out.println("[log] 方法Args:" + Arrays.toString(args));  
	    Object proceed = joinPoint.proceed();  
	    long end = System.currentTimeMillis();  
	    System.out.println("[log] 耗时：" + (end - start) + "ms");  
	    return proceed;  
	}
}

AOP仅需要编写好对应的切面代码,即可监听控制所需要的代码

2. AOP核心概念

概念	解释
Aspect(切面)	切断业务逻辑后进入的模块
Pointcut(切入点)	监听代码切断代码的表达式
JoinPoint(连接点)	被暂停方法处的上下文信息
Advice(通知)	在JoinPoint所执行的操作
Weaving(织入)	将Aspect应用到代码的过程

1. PointCut

@Pointcut(表达式)

@Pointcut(("within(@org.springframework.stereotype.Service *)")) 拦截所有@Service的Bean
@Pointcut("@annotation(com.example.springBean.RequireAdmin)") 拦截springBean下RequireAdmin方法

eg:

@Pointcut(("within(@org.springframework.stereotype.Service *)"))
public void logPoint() {}

@Pointcut("execution(* com.example.springBean.UserService.*(..))")
public void ExceptionAspectLogPoint() {}

@Pointcut("@annotation(com.example.springBean.RequireAdmin)")
public void SecurityAspect() {}

创建切入点后进行重命名,可以简化后续Advice的使用

2. JoinPoint

JoinPoint JoinPoint不能用在@Around, @Around需要使用 ProceedingJoinPoint

	@Before("logPoint()") 
	public void lMethod(JoinPoint joinPoint) {
		// 获取方法名 String 
		methodName = joinPoint.getSignature().getName(); 
		// 获取参数 
		Object[] args = joinPoint.getArgs();
	}

方法	说明	返回类型
`getSignature()`	获取被调用方法的签名（包含方法名、返回类型等）	`Signature`
`getArgs()`	获取方法调用时的参数数组	`Object[]`
`getTarget()`	获取目标对象（被代理的对象）	`Object`
`getThis()`	获取代理对象	`Object`
`getKind()`	获取连接点的类型（如方法执行、异常处理等）	`String`

ProceedingJoinPoint

@Around("logPoint")
public Object Method(ProceedingJoinPoint joinPoint) throws Throwable {
	boolean hasPermission = checkPermission();

    if (hasPermission) {
        // 有权限，执行目标方法
        return joinPoint.proceed();
    } else {
        // 无权限，不执行目标方法，返回默认值或抛出异常
        System.out.println("[Around] No permission, method skipped.");
        return null; // 或者 throw new AccessDeniedException();
    }
}

新增的关键方法

方法名	返回类型	说明
`proceed()`	`Object`	执行目标方法，并返回方法的返回值
`proceed(Object[] args)`	`Object`	执行目标方法，并可以修改传入的参数

3.Advice

Advice 类型	执行时机
@Before	方法执行前
@After	方法执行后
@AfterReturning	方法正常返回后
@AfterThrowing	方法抛出异常后
@Around	方法执行前后

@Before @After 适用于简单的前后置逻辑
@AfterReturning @AfterThrowing 处理返回值和异常
@Around 完全控制,如是否执行修改返回值传递参数

方法执行时若匹配到PointCut的表达式,将JointPoint处的方法上下文信息存储,进入Aspect,执行Advice.

3.示例

package com.example.springBean;  
  
import java.util.Arrays;  
  
import org.aspectj.lang.JoinPoint;  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.AfterThrowing;  
import org.aspectj.lang.annotation.Around;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.annotation.Pointcut;  
import org.springframework.stereotype.Component;  
  
@Aspect  
@Component  
public class LogAspect {  
    @Pointcut(("within(@org.springframework.stereotype.Service *)"))  
    public void logPoint() {}  
  
    @Pointcut("execution(* com.example.springBean.UserService.*(..))")  
    public void ExceptionAspectLogPoint() {}  
  
    @Pointcut("@annotation(com.example.springBean.RequireAdmin)")  
    public void SecurityAspect() {}  
  
    @Around("logPoint()")  
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {  
        long start = System.currentTimeMillis();  
        Object[] args = joinPoint.getArgs();  
        System.out.println("[log] 方法Args:" + Arrays.toString(args));  
        Object proceed = joinPoint.proceed();  
        long end = System.currentTimeMillis();  
        System.out.println("[log] 耗时：" + (end - start) + "ms");  
        return proceed;  
  
    }  
  
    @AfterThrowing(pointcut = "ExceptionAspectLogPoint()", throwing = "ex")  
    public void logException(JoinPoint JoinPoint, Exception ex) {  
        String methodName = JoinPoint.getSignature().getName();  
        System.out.println("[ExceptionLog] Method:" + methodName + " 异常信息 ：" + ex.getMessage());  
    }  
  
    @Around("SecurityAspect()")  
    public Object checkSecurity(ProceedingJoinPoint joinPoint) throws Throwable {  
        String methodName = joinPoint.getSignature().getName();  
        if (UserService.currentUser.equals("admin")) {  
            System.out.println("[SecurityLog] 当前用户有权限执行方法：" + methodName);  
            return joinPoint.proceed();  
        } else {  
            System.out.println("[SecurityLog] 当前用户无权限执行方法：" + methodName);  
            throw new SecurityException("当前用户无权限执行方法：" + methodName);  
        }  
    }  
  
  
  
}

package com.example.springBean;  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
  
@Service  
public class UserService {  
  
    public static String currentUser = "admin";  
  
    @RequireAdmin  
    public void addUser(String name, int age) {  
        System.out.println("add user: " + name + ", age: " + age);  
    }  
  
    public void deleteUser(int id) throws Exception {  
        if (id <= 0) {  
            throw new Exception("Invalid user ID");  
        }  
        System.out.println("delete user: " + id);  
    }  
}

package com.example.springBean;  
  
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)  
public @interface RequireAdmin {  
    String value() default "admin";  
}

Spring on pipo's site

Spring 中的 Bind

Bind 是什么？

三种绑定方式

@Value

@ConfigurationProperties

Binder API

读取单个值

读取复杂类型 (List/Map)

读取整个配置类

创建本地 bind 并绑定

三种绑定方式对比

Reference

Spring循环依赖解决

什么是依赖循环？

类比死锁的解决方案

Spring 在哪里、通过什么方法解决了它？

三级缓存机制

具体流程

为什么要三级缓存而不是二级？

为什么不直接在三级缓存中存放代理对象？

为什么提前暴露“空壳代理”没问题？

为什么构造器注入无法解决依赖循环？

总结

Reference

Spring Bean生命周期

Bean 的生命流程简述

Instantiation

什么是 Instatiation？ 他和 populate 有什么区别？

三种创建对象的方法

populate

populate 在做什么？

属性填充的核心流程

Initalization

Destruction

总结：Destruction 的核心要点

Reference

IoC控制反转与DI依赖注入

什么是 IoC (Inversion of Control) 和 DI (Dependency Injection)？

IoC 控制反转

DI 依赖注入

在 Spring Boot 中的关系

Spring Boot 中如何实现依赖注入？

解释@Autowired 注解的作用，以及它在 Spring Boot 中的自动装配模式有哪些？

什么是 Bean 的作用域 (Scope)？

@Qualifier 和 @Primary 注解

ApplicationContext 与 BeanFactory

配置文件依赖注入

依赖反转原则 (DIP)

Autowired自动装配

@Autowired 的自动装配模式

按类型注入

当有多个同类型 Bean 时会怎样，如何解决？

解决方案：@Qualifier 显式指定

解决方案：@Primary 标记首选

@Autowired 的注入位置

1. 字段注入

2. Setter 注入

3. 构造器注入（推荐）

Spring Aop

1.AOP(Aspect-Oriented Programming) 面向切面编程

2. AOP核心概念

1. PointCut

2. JoinPoint

3.Advice

3.示例

什么是 Instatiation？他和 populate 有什么区别？