谷粒商城实战踩坑笔记-Service循环依赖

启动项目失败，原因是出现了循环依赖。

The dependencies of some of the beans in the application context form a cycle:

   attrController (field private com.atguigu.gulimall.product.service.AttrService com.atguigu.gulimall.product.controller.AttrController.attrService)
      ↓
   attrService (field com.atguigu.gulimall.product.service.CategoryService com.atguigu.gulimall.product.service.impl.AttrServiceImpl.categoryService)
      ↓
   categoryService (field com.atguigu.gulimall.product.service.CategoryBrandRelationService com.atguigu.gulimall.product.service.impl.CategoryServiceImpl.categoryBrandRelationService)
┌─────┐
|  categoryBrandRelationService (field com.atguigu.gulimall.product.service.BrandService com.atguigu.gulimall.product.service.impl.CategoryBrandRelationServiceImpl.brandService)
↑     ↓
|  brandService (field com.atguigu.gulimall.product.service.CategoryBrandRelationService com.atguigu.gulimall.product.service.impl.BrandServiceImpl.categoryBrandRelationService)
└─────┘

一共测试了两种解决方案，都是有效的。

1. 使用 @Lazy 注解

解决思路：通过使用 @Lazy 注解，可以让Spring容器延迟初始化bean，直到真正使用时才创建实例。

示例代码:

public class BrandServiceImpl extends ServiceImpl<BrandDao, BrandEntity> implements BrandService {
    @Autowired
    @Lazy
    private CategoryBrandRelationService categoryBrandRelationService;
    
    // ....
}

2. 使用 @PostConstruct 注解

解决思路：

• 这种方式不是@Lazy简单。
• ServiceA不要自动注入ServiceB，而是提供一个public的setServiceB方法。
• ServiceB自动注入ServiceA，且提供一个PostConstruct方法，在方法中调用ServiceA的set方法，把自身对象传递给ServiceB

示例代码:

@Service
public class ServiceA {
    private ServiceB serviceB;
    
    public void setServiceB(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}


@Service
public class ServiceB {
	@Autowired
    private ServiceA serviceA;

    @PostConstruct
    public void setServiceB() {
        this.serviceA.setServiceB(this);
    }
}

3，补充循环依赖相关知识

循环依赖是在软件开发中常见的问题之一，特别是在使用依赖注入（DI）框架时，如Spring框架。

循环依赖指的是两个或多个类互相依赖对方的情况，这可能导致对象无法正确初始化。

循环依赖的原因

1. 设计问题：

   • 过度耦合：当两个类之间存在过多的耦合时，它们可能会形成循环依赖。例如，两个类都试图通过构造函数注入对方的实例。
   • 职责不清：如果两个类之间的职责划分不明确，可能会导致它们之间存在不必要的依赖关系。

2. 依赖注入问题：

   • 构造函数注入：当两个类都试图通过构造函数注入对方时，如果没有适当处理，会导致循环依赖。
   • 静态初始化：如果两个类在静态初始化块中互相引用，也可能产生循环依赖。

3. 配置问题：

   • 配置错误：在配置文件或配置类中错误地设置了依赖关系，可能会无意中引入循环依赖。
   • 懒加载未正确配置：如果没有正确使用懒加载特性（如Spring框架中的@Lazy注解），可能会导致循环依赖。

举例说明

假设我们有两个类 ClassA 和 ClassB，它们互相依赖对方：

@Service
public class ClassA {
    private final ClassB b;

    public ClassA(ClassB b) {
        this.b = b;
    }

    public void doSomething() {
        System.out.println("ClassA doing something...");
    }
}

@Service
public class ClassB {
    private final ClassA a;

    public ClassB(ClassA a) {
        this.a = a;
    }

    public void doSomething() {
        System.out.println("ClassB doing something...");
    }
}

在这种情况下，当Spring容器尝试创建 ClassA 实例时，它需要 ClassB 的实例。而 ClassB 的实例又需要 ClassA 的实例。这形成了一个循环依赖，导致Spring容器无法创建这两个类的实例。

4，@Lazy 的工作原理

@Lazy 注解告诉Spring容器延迟初始化一个bean，直到该bean第一次被请求时才创建其实例。

1. 元数据解析：

   • 当Spring容器启动时，它会扫描所有的配置类和bean定义，解析元数据。
   • 如果一个bean定义上有 @Lazy 注解，那么Spring会识别出这是一个需要懒加载的bean。

2. 代理机制：

   • Spring使用代理机制来实现懒加载。对于需要懒加载的bean，Spring不会立即创建其实例，而是创建一个代理对象（Proxy）。
   • 这个代理对象实现了目标bean的所有接口，并且可以拦截对目标bean的访问。

3. 代理对象的行为：

   • 当第一次尝试访问一个懒加载的bean时，Spring会通过代理对象检测到这个访问请求。
   • 代理对象会检查是否已经创建了目标bean的实例。
   • 如果尚未创建实例，代理对象会触发bean的初始化过程，创建实例并将其实例化结果缓存起来。
   • 如果已经创建了实例，则直接返回已缓存的实例。

4. 初始化时机：

   • 懒加载的bean会在第一次被请求时初始化，而不是在Spring容器启动时初始化。
   • 初始化过程包括注入依赖、调用初始化方法（如 @PostConstruct 标记的方法）等。