「Java」《Spring框架实战：提升开发效率的实用技巧与经验总结》

一、引言

1.1 Spring框架简介

Spring框架是一个开源的Java应用程序开发框架，旨在简化企业级Java应用程序的开发。它提供了一套全面的解决方案，涵盖了从基本的IoC（控制反转）和DI（依赖注入）到各种企业级应用开发所需的模块和功能。Spring框架的主要特点和优势包括：

1. 轻量级：Spring框架采用轻量级设计理念，不依赖于任何其他框架或容器，只需要JDK就可以运行。

2. IoC（控制反转）和DI（依赖注入）：Spring框架通过IoC容器管理Java对象之间的依赖关系，实现了对象的松耦合和可复用性。

3. AOP（面向切面编程）支持：Spring框架提供了AOP的支持，可以将横切关注点（如日志、事务等）与业务逻辑代码分离，提高代码的模块化和可维护性。

4. 集成各种技术和框架：Spring框架可以与其他常用的Java技术和框架（如Hibernate、MyBatis、Spring MVC等）无缝集成，提供了更便捷的开发方式。

5. 统一的异常处理：Spring框架提供了全局的异常处理机制，可以统一处理应用程序中的异常，提高系统的健壮性。

6. 支持事务管理：Spring框架内置了强大的事务管理机制，可以方便地处理数据库事务，确保数据的一致性和完整性。

7. 安全性支持：Spring框架提供了对安全性的支持，包括认证、授权和加密等功能，保障应用程序的安全性。

// 统一的异常处理
@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ModelAndView handleException(Exception ex) {
        // 异常处理逻辑
        ModelAndView modelAndView = new ModelAndView("error");
        modelAndView.addObject("errorMessage", ex.getMessage());
        return modelAndView;
    }

    @ExceptionHandler(MyCustomException.class)
    public ModelAndView handleCustomException(MyCustomException ex) {
        // 自定义异常处理逻辑
        ModelAndView modelAndView = new ModelAndView("customError");
        modelAndView.addObject("errorCode", ex.getErrorCode());
        modelAndView.addObject("errorMessage", ex.getErrorMessage());
        return modelAndView;
    }
}

二、基础知识

2.1 Java与面向对象编程回顾

当涉及到Java和面向对象编程（OOP）的回顾时，我们可以回顾以下内容：

1. 类与对象：Java是一种面向对象的编程语言，它支持类和对象的概念。类是定义对象的模板，它描述了对象的属性（字段）和行为（方法）。对象是类的实例，具有特定的状态和行为。

2. 封装：封装是OOP的核心原则之一，它指的是将数据和相关的行为封装在一个单独的单元中（类），并对外部隐藏内部实现细节。通过使用访问修饰符（如private、public等），我们可以控制对类的成员的访问权限。

3. 继承：继承允许一个类派生出一个或多个子类，从而实现类之间的层次结构。子类从父类继承属性和方法，并可以添加自己的特定功能。这提供了代码重用和层次化设计的能力。

4. 多态：多态允许对象根据当前所处的上下文以不同的方式呈现。通过多态，可以以通用的方式处理不同类型的对象，以提高代码的灵活性和可扩展性。它包括方法重写和方法重载两种形式。

5. 抽象类和接口：抽象类是一个不能实例化的类，它为子类定义了通用属性和行为。接口是一种契约，规定了类应该实现的方法，但没有具体的实现。Java允许类实现多个接口，但只能继承一个抽象类。

6. 构造函数：构造函数是在创建对象时调用的特殊方法，用于初始化对象的状态。它与类名相同，没有返回类型，并且可以包含参数。通过构造函数，可以确保对象在创建时处于一致的状态。

7. 异常处理：异常处理是一种处理程序运行过程中可能发生的错误或异常情况的机制。Java提供了try-catch-finally块来捕获和处理异常。这样可以使程序更加健壮，防止因异常而导致程序崩溃。

这些是Java和面向对象编程的一些核心概念和特性。Java的面向对象编程范式提供了抽象、封装、继承、多态等强大的工具，使得代码更易于理解、扩展和维护。它已经成为广泛使用的编程范式，并且在许多应用程序和开发领域中都得到了广泛应用。

// 多态
abstract class Animal {
    public abstract void makeSound();
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.makeSound();  // 调用Dog的makeSound()方法
        animal2.makeSound();  // 调用Cat的makeSound()方法
    }
}

2.2 IoC（控制反转）与DI（依赖注入）

IoC（控制反转）和DI（依赖注入）是面向对象编程中的两个重要概念，它们经常一起使用。下面对它们进行解释：

1. 控制反转（IoC）：IoC是一种设计原则，它将对象的创建、组装和管理的责任从应用程序代码中转移到容器或框架。传统上，对象之间的依赖关系由开发人员定义和管理。而IoC通过反转这种过程，将对象的控制权交给了容器。容器负责实例化对象、解析对象之间的依赖关系，并在适当的时候将这些对象提供给应用程序使用。这样，应用程序只需关注业务逻辑而不需要关心对象的创建和管理。

2. 依赖注入（DI）：DI是IoC的一种具体实现方式。它是指通过构造函数、属性或方法参数将依赖关系注入到类中。使用DI，我们可以将一个对象所依赖的其他对象直接注入到它其中，而不是由该对象自己创建或查找依赖的对象。通过这种方式，我们可以避免类与其所依赖的具体实现类之间的耦合，提高代码的可测试性、可扩展性和可维护性。

下面是一个简单的示例来说明IoC和DI的概念：

假设有一个UserService类需要依赖一个UserRepository接口来进行用户数据的持久化操作。使用传统的方式，UserService需要自己实例化UserRepository对象：

public class UserService {
    private UserRepository userRepository;

    public UserService() {
        this.userRepository = new UserRepository(); // 创建依赖的对象
    }

    // ...
}

而使用IoC和DI的方式，我们通过构造函数注入UserRepository对象：

public class UserService {
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository; // 注入依赖的对象
    }

    // ...
}

在上述代码中，通过将UserRepository对象作为构造函数的参数进行注入，UserService类不再负责创建UserRepository对象，而是将依赖的控制权交给外部，即容器或框架。这样，我们可以轻松地替换UserRepository的具体实现，而不需要修改UserService的代码。

通过控制反转和依赖注入，我们实现了代码之间的解耦和灵活性。依赖关系由外部组件决定，提高了代码的可测试性和可维护性，并支持更好的模块化设计。常见的IoC和DI容器有Spring Framework、Google Guice等。

2.2.1 控制反转的好处

控制反转（IoC）带来了许多好处，下面列举了其中的一些：

1. 解耦：使用IoC可以将应用程序的各个组件解耦。传统上，对象之间直接创建和管理依赖关系，导致它们之间紧密耦合，难以复用和测试。而通过IoC，依赖关系由容器管理，对象只需要声明自己的依赖并接受注入。这样可以减少组件之间的直接依赖，提高代码的可维护性、可扩展性和可测试性。

2. 可测试性：IoC使得单元测试更加容易。在进行单元测试时，我们可以通过注入模拟对象来替代实际的依赖对象。这样可以更方便地对对象进行测试，并且可以更好地隔离测试环境，确保测试的准确性和稳定性。

3. 可维护性：IoC使代码的维护更加方便。当需要修改或替换依赖的具体实现时，我们只需修改配置或替换依赖的对象即可，不需要修改大量的代码。这样可以减少因为变更而引入的风险，并且可以更快速地适应需求的改变。

4. 可扩展性：通过IoC，我们可以更轻松地引入新的组件并集成到应用程序中。新的组件只需声明它所需要的依赖，并将其注入。这样可以更好地支持模块化设计和松散耦合的架构，使应用程序更加灵活和可扩展。

5. 生态系统和可重用性：IoC容器通常具有丰富的生态系统，提供了许多可重用的组件和功能，如事务管理、安全性、日志记录等。使用IoC容器可以更轻松地集成这些功能，并且可以从容器中获得这些组件，避免重复的开发工作。

总之，控制反转带来了很多好处，包括解耦、可测试性、可维护性、可扩展性和生态系统的优势。它改变了传统的对象依赖关系管理方式，使代码更加灵活、可读性更强，并且为应用程序提供了更好的设计和架构。

2.2.2 依赖注入的几种方式

依赖注入（DI）有多种方式可以实现，下面列举了几种常见的方式：

1. 构造函数注入（Constructor Injection）：通过类的构造函数将依赖项注入到类中。这是最常见和推荐的一种方式。在类的构造函数中声明参数来接受所需的依赖项，并将其保存在类的私有字段或属性中。在创建类的实例时，传递依赖项的实例作为构造函数的参数，容器负责解析依赖关系并自动进行注入。

public class UserService {
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // ...
}

2. 属性注入（Property Injection）：通过类的公共属性将依赖项注入到类中。在类中声明公共属性，并使用依赖项的实例直接赋值给属性。容器会自动解析依赖关系并注入属性。

public class UserService {
    @Inject
    public UserRepository userRepository;

    // ...
}

3. 方法注入（Method Injection）：通过类的方法将依赖项注入到类中。在类中定义一个公共方法，并在方法参数中接受依赖项的实例。容器会在调用该方法时解析依赖关系并注入实例。

public class UserService {
    private UserRepository userRepository;

    @Inject
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // ...
}

4. 接口注入（Interface Injection）：通过类实现接口的方式将依赖项注入到类中。定义一个接口，该接口包含设置依赖项的方法。让类实现该接口，并实现接口方法来接受依赖项的实例。容器会解析依赖关系并调用相应的接口方法进行注入。

public interface UserRepositoryAware {
    void setUserRepository(UserRepository userRepository);
}

public class UserService implements UserRepositoryAware {
    private UserRepository userRepository;

    @Override
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // ...
}

这些只是依赖注入的一些常见方式，实际上还可以根据不同的编程语言、框架和容器使用其他方式来实现依赖注入。无论采用哪种方式，依赖注入的核心思想都是将对象的依赖关系从类内部移动到外部容器或框架来管理，以提高代码的可维护性、可测试性和可扩展性。

2.3 AOP（面向切面编程）

面向切面编程（Aspect-Oriented Programming，AOP）是一种编程范式，用于将横切关注点从核心业务逻辑中分离出来。它通过定义切面（Aspect）来实现这一目标，切面可以横跨多个对象，并在预定的切点（Join Point）处插入通用的处理逻辑。

AOP 的核心思想是将与业务逻辑无关的功能抽取出来，形成可重用的模块，这些模块被称为切面。常见的切面功能包括日志记录、性能统计、事务管理等。

在 AOP 中，主要有以下几个概念：

1. 切面（Aspect）：切面是一个模块化单元，它封装了与横切关注点相关的代码。切面定义了在何处（切点）以及如何（通知）注入额外的行为。

2. 连接点（Join Point）：连接点是程序执行过程中的特定点，比如方法调用、异常抛出等。切面会在连接点处插入通知。

3. 切点（Pointcut）：切点是指一组连接点的集合，它定义了在哪些连接点上插入通知。切点可以使用表达式指定连接点的选择条件，例如特定类的特定方法。

4. 通知（Advice）：通知是切面在特定连接点处执行的代码。常见的通知类型包括前置通知（Before）、后置通知（After）、异常通知（After-Throwing）、返回通知（After-Returning）和环绕通知（Around）。

5. 织入（Weaving）：织入是将切面应用到目标对象上，从而创建新的代理对象的过程。通过织入，切面中的通知被插入到目标对象的连接点处。

AOP 的优势包括：

1. 横切关注点的集中管理：AOP 将横切关注点从核心业务逻辑中抽离出来，使得代码更加模块化和可维护。通过切面，可以集中管理日志记录、事务处理等通用功能，避免了代码的重复。

2. 降低代码复杂性：AOP 可以将一些非核心业务逻辑从主业务逻辑中分离出来，使得主业务逻辑更加清晰简洁，提高代码的可读性和可理解性。

3. 提高代码的可重用性：AOP 的切面是可重用的模块，可以在不同的应用或模块中共享使用，避免了代码的冗余编写。

4. 易于维护和扩展：AOP 的切面可以独立于核心业务逻辑进行维护和升级。当需要修改或新增横切关注点时，只需修改或添加相应的切面，而不需要修改核心业务逻辑。

需要注意的是，在使用 AOP 时，我们应该遵循一些设计原则，如单一职责原则、松耦合原则等，以确保切面的正确使用和代码的可维护性。此外，选择合适的 AOP 框架也是很重要的，常见的 Java AOP 框架包括 AspectJ、Spring AOP 等。

2.3.1 AOP举例

// 日志记录切面
@Aspect
@Component
public class LoggingAspect {
    
    // 前置通知，在方法执行前记录日志
    @Before("execution(* com.example.*.*(..))")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("方法调用前记录日志：" + joinPoint.getSignature().getName());
    }
    
    // 后置通知，在方法执行后记录日志
    @After("execution(* com.example.*.*(..))")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("方法调用后记录日志：" + joinPoint.getSignature().getName());
    }
    
    // 异常通知，在方法抛出异常时记录日志
    @AfterThrowing(pointcut = "execution(* com.example.*.*(..))", throwing = "error")
    public void afterThrowingAdvice(JoinPoint joinPoint, Throwable error) {
        System.out.println("方法抛出异常时记录日志：" + joinPoint.getSignature().getName());
        System.out.println("异常信息：" + error.getMessage());
    }
}

2.3.2 AOP和注解搭配实现日志记录

要结合AOP和注解实现日志记录，可以按照以下步骤进行操作：

1. 创建一个切面类，用于定义日志记录的通知方法。在该类上使用@Aspect注解标识为切面类，并添加@Component注解以使其成为Spring的bean。

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
  
  @Before("@annotation(Loggable)")
    public void logMethodEntry(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Entering method: " + methodName);
        // 在方法执行前进行日志记录的逻辑
    }

    @After("@annotation(Loggable)")
    public void logMethodExit(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Exiting method: " + methodName);
        // 在方法执行后进行日志记录的逻辑
    }
}

2. 创建一个自定义注解@Loggable，用于标注需要进行日志记录的方法。

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

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

3. 在目标方法上添加@Loggable注解，以指示该方法需要进行日志记录。

@Service
public class MyService {
    
    @Loggable
    public void doSomething() {
        // 方法逻辑
    }
}

4. 运行应用程序时，AOP会在目标方法执行前后触发切面中的通知方法，从而实现日志记录的功能。

通过以上步骤，使用AOP和注解搭配实现了日志记录。当带有@Loggable注解的方法被调用时，AOP切面会在方法执行前后记录相应的日志。请根据您的具体情况进行适当调整和扩展。

2.4 Spring配置与Bean的生命周期

在Spring框架中，配置和Bean的生命周期有以下几个重要的概念和阶段：

1. Spring配置：

   • XML配置：通过编写XML文件来定义Bean和配置它们之间的依赖关系。
   • 注解配置：使用注解（如@Component、@Configuration等）来标识和配置Bean。
   • Java配置：使用Java代码来定义和配置Bean，通常使用@Configuration和@Bean注解。

2. Bean的生命周期阶段：

   • 实例化：Spring容器根据配置信息，在需要时创建Bean实例。
   • 属性设置：将属性值或引用注入到Bean实例中，可以通过构造函数注入、Setter方法注入等方式。
   • 初始化：在Bean初始化之前或之后执行特定的初始化方法，例如实现InitializingBean接口的afterPropertiesSet()方法，或在Bean上使用@PostConstruct注解。
   • 使用：Bean实例可以被应用程序使用。
   • 销毁：当Bean不再需要时，可以执行特定的销毁方法进行资源释放，例如实现DisposableBean接口的destroy()方法，或在Bean上使用@PreDestroy注解。

3. 配置方式与生命周期方法的关联：

   • XML配置：可以使用元素的init-method和destroy-method属性来指定初始化方法和销毁方法。
   • 注解配置：可以通过在Bean类的初始化方法上使用@PostConstruct注解和在销毁方法上使用@PreDestroy注解，来定义初始化和销毁的方法。
   • Java配置：在@Configuration类中，可以使用@Bean注解来定义Bean，并在方法上使用@PostConstruct和@PreDestroy注解来指定初始化方法和销毁方法。

通过合理配置初始化方法和销毁方法，可以在Bean的生命周期中执行额外的逻辑，例如初始化资源、建立数据库连接等，以及在Bean不再需要时进行清理和释放资源。这样可以确保应用程序正确管理和维护Bean的状态和资源。

请注意，在使用Spring的IoC容器时，容器负责管理Bean的生命周期，因此在应用程序中不需要显式地调用初始化方法和销毁方法。容器会根据配置和注解自动触发相应的生命周期方法。

2.5 Spring的核心模块概述（如Spring MVC、Spring Data等）

Spring框架是一个非常广泛的生态系统，包含多个核心模块，每个模块都有不同的功能和用途。以下是一些Spring的核心模块的概述：

1. Spring Core：Spring核心模块提供了IoC（Inversion of Control）容器和依赖注入功能，是整个Spring框架的基础。它负责管理应用程序中的对象、处理对象之间的依赖关系，并提供了诸如Bean管理、AOP（Aspect-Oriented
   Programming）、事件处理等功能。

2. Spring MVC：Spring MVC（Model-View-Controller）模块是一个用于开发Web应用程序的框架。它基于MVC设计模式，通过DispatcherServlet来分发请求并处理响应。Spring
   MVC提供了灵活的URL映射、视图解析、数据绑定、验证、国际化等功能，使得开发Web应用程序更加简单和高效。

3. Spring Data：Spring Data模块是一组为数据访问提供简化开发的工具和特性的模块。它提供了对各种数据存储技术的支持，包括关系型数据库（如MySQL、PostgreSQL）、NoSQL数据库（如MongoDB、Redis）以及其他数据存储技术（如Elasticsearch、Apache
   Cassandra）。Spring
   Data通过使用注解或基于接口的方式，提供了通用的CRUD操作、查询方法、事务管理等功能，减少了开发者与底层数据存储技术的直接交互。

4. Spring Security：Spring Security模块是一个用于身份验证和授权的框架。它提供了一套完整的安全解决方案，包括用户认证、访问控制、密码加密、单点登录（SSO）等功能。Spring
   Security可以轻松地集成到Spring应用程序中，保护应用程序的安全性。

5. Spring Boot：Spring Boot是一个用于简化Spring应用程序开发的框架。它使得构建独立、自包含的、生产级别的Spring应用程序变得更加容易。Spring
   Boot提供了自动配置、内嵌服务器、健康检查、度量指标等功能，大大减少了开发者的配置工作，并提高了应用程序的开发效率和部署便利性。

除了上述核心模块外，Spring还有其他重要的模块，如Spring Batch（用于批处理作业）、Spring Integration（用于基于消息的集成）、Spring Cloud（用于分布式系统开发）等。每个模块都有其特定的功能和用途，可以根据项目需求选择合适的模块来加速开发和提高效率。

三、Spring的核心功能

3.1 Spring的IoC容器

Spring的核心功能之一就是IoC（Inversion of Control）容器。IoC容器是Spring框架的核心部分，负责创建、管理和装配应用程序中的对象（Bean）。

IoC容器的主要作用是将对象的创建和依赖关系的管理从应用程序代码中解耦，使得开发者可以专注于业务逻辑的实现，而不必关心对象的创建和组装过程。具体来说，IoC容器提供了以下核心功能：

1. 对象的创建和生命周期管理：IoC容器负责根据配置信息创建对象的实例，包括实例化对象、设置对象属性值或引用，以及执行初始化和销毁方法。开发者只需要在配置文件或类上使用注解指定依赖关系和初始化方法，而无需显式地调用new操作符或手动管理对象的生命周期。

2. 依赖注入（Dependency Injection）：IoC容器负责将对象之间的依赖关系注入到相应的对象中。开发者只需要在对象的属性、构造函数或Setter方法上使用注解或配置文件中的配置，声明该对象所依赖的其他对象，而无需手动获取依赖对象或编写大量的代码进行依赖关系的管理。

3. 配置的灵活性：IoC容器提供了多种配置方式，包括XML配置、注解配置和Java配置。开发者可以根据项目的需要选择合适的配置方式，以达到最佳的灵活性和便利性。不同的配置方式之间可以相互切换，而不必改变应用程序的代码。

4. AOP（Aspect-Oriented Programming）支持：IoC容器与AOP紧密集成，提供了切面编程的支持。开发者可以通过在配置文件或注解中定义切点（Pointcut）和通知（Advice），来实现诸如日志记录、事务管理、安全控制等与业务逻辑无关的横切关注点。

总之，IoC容器是Spring框架的核心，通过它可以实现对象的创建、生命周期管理和依赖注入，减少了开发者的工作量，提高了代码的可维护性和可测试性。开发者只需要关注业务逻辑的实现，而不必过多关心对象的创建和组装过程，使得应用程序更加简洁、模块化和可扩展。

3.2 Bean管理与装配

在Spring框架中，Bean的管理和装配是通过IoC容器来实现的。IoC（Inversion of Control，控制反转）是一种设计原则，它将对象的创建、组装和依赖关系的管理从应用程序代码中解耦出来，交给容器来完成。

Bean的管理和装配可以通过三种方式实现：

1. XML配置：使用XML配置文件进行Bean的管理和装配是Spring最传统的方式之一。在XML配置文件中，可以使用元素定义Bean的各种属性和依赖关系，然后通过IoC容器读取和解析配置文件，创建和组装Bean。

示例：

<bean id="myBean" class="com.example.MyBean"/>


<bean id="myBean" class="com.example.MyBean">
    <property name="name" value="John"/>
    <property name="dependency" ref="otherBean"/>
bean>

以上是使用XML配置方式定义一个简单的Bean，并定义其属性和依赖关系的示例。

: 这行代码定义了一个名为 “myBean” 的Bean，其类为 “com.example.MyBean”。这表示将会创建一个类型为 MyBean 的对象，并由IoC容器进行管理。

: 这行代码定义了一个名为 “name” 的属性，并给它设置了值 “John”。这表示在创建 MyBean 对象后，会调用其相应的setter方法，将值 “John” 注入到 “name” 属性中。

: 这行代码定义了一个名为 “dependency” 的属性，并指定其依赖关系。“ref” 属性值 “otherBean” 表示要注入另一个名为 “otherBean” 的Bean对象。这样，在创建 MyBean 对象后，会通过调用其相应的setter方法，将名为 “otherBean” 的Bean对象注入到 “dependency” 属性中。

综合起来，以上配置代码的含义是，创建一个名为 “myBean” 的 MyBean 对象，并将属性 “name” 的值设置为 “John”，将属性 “dependency” 的值设置为另一个名为 “otherBean” 的Bean对象。这样就完成了对 “myBean” Bean的定义和装配。

2. 注解配置：使用注解进行Bean的管理和装配是更简洁和方便的方式。可以在Bean类上使用各种注解（如@Component、@Service、@Repository等）标识其为一个Bean，并由IoC容器进行扫描和管理。同时，可以使用@Autowired注解进行依赖注入。

示例：

// 声明一个Bean
@Component
public class MyBean {
    // 自动注入依赖
    @Autowired
    private OtherBean dependency;
}

3. Java配置：使用Java配置类是Spring 3及以上版本引入的一种方式。通过编写Java配置类，可以使用@Configuration注解标识，并在方法上使用@Bean注解定义Bean及其依赖关系。然后通过IoC容器加载和解析配置类，创建和组装Bean。

示例：

@Configuration
public class AppConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
    
    @Bean
    public OtherBean otherBean() {
        return new OtherBean();
    }
}

无论使用哪种方式，最终目的都是将Bean的创建、组装和依赖关系的管理交给IoC容器来完成。开发者只需通过配置文件、注解或者Java配置类指定Bean的属性和依赖关系，IoC容器将负责实例化Bean，并自动处理依赖注入，使得应用程序的开发更加简便和灵活。