【Spring Bean】

曾经终败给现在 2023-09-26 19:41 79阅读 0赞

## 1、介绍 ##

当谈到Spring框架时，"bean"通常是指在Spring IoC容器中管理的对象，它是一个被实例化、组装和管理的Java对象。Spring框架通过IoC容器创建和管理这些bean，这意味着在应用程序运行时，容器负责实例化这些bean并将它们的依赖注入到容器中，从而使应用程序更加灵活和可配置。

在Spring中，可以使用注解或XML文件来定义bean，定义方式包括指定bean的类型、属性和依赖项。这些bean可以是任何类型的Java对象，包括简单的POJO类、数据访问对象、服务类等等。

通过使用Spring的IoC容器和bean定义，可以更轻松地实现应用程序的松耦合和依赖注入，从而使应用程序更易于维护和扩展。

## 2、哪些注解可以将一个类声明为 Bean? ##

在 Spring 框架中，可以使用以下注解来将一个类声明为 Bean：

### @Component： ###

@Component 是一个通用的 Spring 注解，用于标识一个类作为 Spring Bean。这意味着，当使用 @Component 注解标记一个类时，Spring 将会自动将这个类实例化并将其添加到应用程序上下文中，以供其他部分使用。

下面是一个使用 @Component 注解的例子：

@Component
    public class MyComponent {
        
        public void doSomething() {
        
            // ...
        }
    }

在这个例子中，MyComponent 类被标记为一个 Spring Bean，并被添加到应用程序上下文中。可以在其他部分中使用 @Autowired 或其他依赖注入注解来注入 MyComponent Bean，例如：

@Service
    public class MyService {
        
        @Autowired
        private MyComponent myComponent;
    
        public void doSomethingElse() {
        
            myComponent.doSomething();
        }
    }

这样，在 MyService 中，就可以使用 myComponent 成员变量来访问 MyComponent Bean 中的方法 doSomething()。

### @Controller： ###

用于声明一个控制层的Bean组件，通常用于处理Web请求和响应，它是基于MVC模式的。用于标识一个类为控制器，用于处理Web请求。在这个控制器类中，可以使用@RequestMapping注解来指定处理不同请求URL的方法。

下面是一个简单的示例，演示如何使用@Controller注解：

@Controller
    public class HomeController {
        
    
        @RequestMapping("/")
        public String home() {
        
            return "index";
        }
    
        @RequestMapping("/about")
        public String about() {
        
            return "about";
        }
    
    }

在这个示例中，HomeController类被标记为@Controller注解，表示它是一个控制器。它定义了两个处理请求的方法：home()和about()。

这两个方法都使用@RequestMapping注解来指定处理的URL。例如，home()方法处理根URL("/")的请求，并返回一个名为"index"的视图。about()方法处理URL"/about"的请求，并返回一个名为"about"的视图。

当一个请求到达服务器时，DispatcherServlet将根据请求的URL找到匹配的处理方法，并将处理结果返回给客户端。

需要注意的是，这个示例中的视图名称"index"和"about"都没有具体的定义。通常情况下，它们会对应于一个JSP或Thymeleaf模板文件，这些文件需要被放置在项目的资源文件夹下，如"/resources/templates"或"/src/main/resources/templates"。

### @RestController: ###

用于声明一个控制层的Bean组件，  
并且指定该组件返回的是JSON数据，  
通常用于编写RESTful风格的接口，它也是基于MVC模式的。  
（@Controller用于处理一般的Web请求和响应，  
而@RestController则会将返回值序列化成JSON格式，适用于Web API的编写。）

下面是一个简单的示例，演示如何使用@RestController注解：

@RestController
    public class UserController {
        
    
        @GetMapping("/users")
        public List<User> getUsers() {
        
            // 从数据库或其他数据源中获取用户列表
            List<User> users = userService.getUsers();
            return users;
        }
    
        @GetMapping("/users/{id}")
        public User getUserById(@PathVariable Long id) {
        
            // 根据ID从数据库或其他数据源中获取用户
            User user = userService.getUserById(id);
            return user;
        }
    
        @PostMapping("/users")
        public User createUser(@RequestBody User user) {
        
            // 创建用户并保存到数据库或其他数据源中
            User savedUser = userService.createUser(user);
            return savedUser;
        }
    
        @PutMapping("/users/{id}")
        public User updateUser(@PathVariable Long id, @RequestBody User user) {
        
            // 根据ID更新用户信息，并保存到数据库或其他数据源中
            User updatedUser = userService.updateUser(id, user);
            return updatedUser;
        }
    
        @DeleteMapping("/users/{id}")
        public void deleteUser(@PathVariable Long id) {
        
            // 根据ID从数据库或其他数据源中删除用户
            userService.deleteUser(id);
        }
    }

在这个示例中，UserController类被标记为@RestController注解，表示它是一个RESTful控制器。

它定义了五个处理请求的方法，每个方法都使用不同的HTTP方法（GET、POST、PUT、DELETE）和不同的URL来处理请求。这些方法的返回值都是Java对象，Spring Boot将自动将它们转换为JSON或XML格式的响应。

例如，getUsers()方法处理URL “/users” 的GET请求，并返回一个包含用户列表的List对象。getUserById()方法处理URL “/users/\{id\}” 的GET请求，并返回一个指定ID的用户对象。createUser()方法处理URL “/users” 的POST请求，并从请求体中获取User对象，创建并保存用户到数据源中，并返回创建的User对象。updateUser()方法处理URL “/users/\{id\}” 的PUT请求，并从请求体中获取User对象，根据ID更新用户信息，并将更新后的User对象返回。deleteUser()方法处理URL “/users/\{id\}” 的DELETE请求，并根据ID从数据源中删除用户。

需要注意的是，这个示例中的User对象需要先定义，并且这些方法使用了一些Spring Boot的注解，例如@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、@PathVariable和@RequestBody，它们都可以用来简化代码，并提高开发效率。

### @Service： ###

用于声明一个服务层的Bean组件，通常用于注入到控制层中使用，它通常是基于业务逻辑的，实现某些特定的业务功能。

下面是一个简单的示例，演示了如何在Spring Boot中使用@Service注解：

@Service
    public class MyService {
        
        
        public void doSomething() {
        
            // 业务逻辑实现
        }
    }

在上面的示例中，创建了一个名为MyService的服务类，并使用@Service注解标记它。该类包含一个名为doSomething()的方法，用于实现服务的业务逻辑。

在应用程序中使用服务时，可以通过依赖注入（dependency injection）的方式来获取它的实例。下面是一个演示如何使用@Autowired注解将服务注入到另一个类中的示例：

@Service
    public class MyService {
        
        
        public void doSomething() {
        
            // 业务逻辑实现
        }
    }
    
    @Controller
    public class MyController {
        
        
        @Autowired
        private MyService myService;
        
        @RequestMapping("/doSomething")
        public void handleRequest() {
        
            myService.doSomething();
        }
    }

在上面的示例中，创建了一个名为MyController的控制器类，并使用@Autowired注解将MyService注入到它的myService字段中。还创建了一个名为handleRequest()的方法，用于处理请求并调用myService的doSomething()方法。

总之，使用@Service注解是在Spring Boot应用程序中创建服务层的一种方便的方式。它允许我们将业务逻辑封装在服务类中，并通过依赖注入的方式在应用程序的其他部分中使用它们。

### @Repository： ###

用于声明一个数据访问层的Bean组件，通常用于注入到服务层中使用，它是基于数据访问的，实现对数据库等数据存储的操作。这个注解通常与 @Autowired 或者 @Resource 注解一起使用，以便在应用程序中使用数据访问对象（DAO）。

下面是一个使用 @Repository 注解的示例：

首先，定义一个 DAO 接口：

public interface UserRepository {
        
        User findById(Long id);
        List<User> findAll();
        void save(User user);
        void delete(User user);
    }

然后，创建一个实现该接口的类，并使用 @Repository 注解标识该类：

@Repository
    public class UserRepositoryImpl implements UserRepository {
        
    
        private final JdbcTemplate jdbcTemplate;
    
        @Autowired
        public UserRepositoryImpl(JdbcTemplate jdbcTemplate) {
        
            this.jdbcTemplate = jdbcTemplate;
        }
    
        @Override
        public User findById(Long id) {
        
            // 实现查找用户的方法
            return null;
        }
    
        @Override
        public List<User> findAll() {
        
            // 实现查找所有用户的方法
            return null;
        }
    
        @Override
        public void save(User user) {
        
            // 实现保存用户的方法
        }
    
        @Override
        public void delete(User user) {
        
            // 实现删除用户的方法
        }
    }

在上面的示例中，我们使用了 Spring 的 JdbcTemplate 来执行数据库操作。通过构造函数注入 JdbcTemplate，可以使该类成为 Spring 容器中的 bean，从而可以在应用程序中使用该类。

现在，我们可以在其他类中使用 UserRepository：

@Service
    public class UserService {
        
    
        private final UserRepository userRepository;
    
        @Autowired
        public UserService(UserRepository userRepository) {
        
            this.userRepository = userRepository;
        }
    
        public User findById(Long id) {
        
            return userRepository.findById(id);
        }
    
        public List<User> findAll() {
        
            return userRepository.findAll();
        }
    
        public void save(User user) {
        
            userRepository.save(user);
        }
    
        public void delete(User user) {
        
            userRepository.delete(user);
        }
    }

在上面的示例中，我们使用了 @Autowired 注解来注入 UserRepository。由于 UserRepository 带有 @Repository 注解，因此 Spring 容器会自动将该类创建为 bean，并将其注入到 UserService 中。

### @Configuration： ###

用于将类声明为配置类, 配置类通常包含用于创建和配置Spring应用程序上下文的bean的方法。

下面是一个使用@Configuration注解的示例：

@Configuration
    public class AppConfig {
        
        @Bean
        public UserService userService() {
        
            return new UserServiceImpl();
        }
    }

在这个示例中，@Configuration注解标识了一个名为AppConfig的Java类，该类包含一个名为userService的方法，该方法创建并返回一个新的UserServiceImpl对象。通过将此方法标记为@Bean，Spring将使用该方法返回的对象作为应用程序上下文中的bean。

另外，@Configuration注解还可以用来定义其他的bean，例如数据源、事务管理器等等。您可以使用@Autowired注解将这些bean注入到其他组件中，例如控制器、服务等等。

### @Bean ###

用来创建和配置对象，通常在配置类中使用。下面是一个使用 @Bean 的示例：

@Configuration
    public class MyConfig {
        
    
        @Bean
        public MyService myService() {
        
            return new MyServiceImpl();
        }
    }

上述代码中，@Configuration 声明了一个配置类，@Bean 声明了一个方法 myService()，该方法返回一个 MyService 类型的实例。这个实例将被 Spring 容器管理。

在使用 @Bean 注解时，有一些常用的属性可以使用，例如：

name：指定 bean 的名称，如果不指定，则使用方法名作为 bean 的名称；
    initMethod：指定 bean 初始化时调用的方法；
    destroyMethod：指定 bean 销毁时调用的方法。

下面是一个带有这些属性的示例：

@Configuration
    public class MyConfig {
        
    
        @Bean(name = "myService", initMethod = "init", destroyMethod = "cleanup")
        public MyService myService() {
        
            return new MyServiceImpl();
        }
    }

上述代码中，@Bean 的 name 属性指定了 bean 的名称为 myService，initMethod 和 destroyMethod 属性分别指定了 bean 初始化和销毁时调用的方法为 init 和 cleanup。

在其他的类中使用这个 bean，只需要使用 @Autowired 注解即可。例如：

@Service
    public class MyServiceImpl implements MyService {
        
    
        @Autowired
        private MyService myService;
    
        // ...
    }

上述代码中，MyServiceImpl 类中使用了 @Autowired 注解注入了 MyService 类型的实例 myService，Spring 会自动将 MyService bean 注入到 myService 变量中。

#### 和@Component区别 ####

@Component 和 @Bean 都是用于声明 Spring Framework 中的 bean 的注解，但是它们有以下不同：

@Component 是一个泛化的概念，可以用来表示任何组件，
    而 @Bean 注解通常用于在配置类中声明一个 bean。
    
    @Component 是在类级别上使用的注解，而 @Bean 是在方法级别上使用的注解。
    
    @Component 可以自动扫描和装配到 Spring 容器中，而 @Bean 需要手动配置。
    
    @Component 的作用域是 singleton，而 @Bean 可以通过配置作用域来改变它的范围。
    
    @Bean 方法可以具有参数，这些参数可以通过 Spring 容器中的其他 bean 注入，
    而 @Component 中的依赖关系必须通过其他方式注入，例如使用 @Autowired 或 @Resource。

因此，如果你需要在配置类中声明一个 bean，使用 @Bean 注解；如果你需要在应用程序中使用自动扫描和装配的组件，则使用 @Component 注解。

### @Import ###

用于导入其他的配置类，可以将多个配置类组合在一起，实现复杂应用的配置。下面是一个简单的例子，演示了如何在Spring Boot应用中使用@Import注解。

假设有两个配置类：FooConfig和BarConfig。FooConfig负责配置Foo相关的Bean，BarConfig负责配置Bar相关的Bean。现在我们想要在一个应用中同时使用这两个配置类，可以使用@Import注解来实现。

首先，在主配置类中使用@Import注解导入这两个配置类：

@Configuration
    @Import({
        FooConfig.class, BarConfig.class})
    public class AppConfig {
        
        // ...
    }

这里使用了花括号来将多个配置类包裹在一起，注意这里的逗号是用来分隔不同的配置类的。现在，FooConfig和BarConfig中定义的所有Bean都可以在AppConfig中使用了。

例如，我们可以在AppConfig中注入FooConfig和BarConfig中定义的Bean：

@Configuration
    @Import({
        FooConfig.class, BarConfig.class})
    public class AppConfig {
        
        @Autowired
        private FooService fooService;
        
        @Autowired
        private BarService barService;
        
        // ...
    }

这里假设FooService和BarService是在FooConfig和BarConfig中定义的Bean。现在我们可以在AppConfig中注入这两个Bean并使用它们了。

@Import注解还有一些其他的用法，例如可以导入其他的Java类或者通过条件来动态选择要导入的配置类等。更多详细信息可以参考Spring官方文档。

## 3、哪些注解可以注入Bean ##

在Spring框架中，常用的注入Bean的注解有以下几种：

### @Autowired： ###

通过类型自动装配方式将一个Bean注入到另一个Bean中。  
在注入时，Spring会根据变量的类型在容器中查找对应的Bean，并将其注入到变量中。  
如果找到多个相同类型的Bean，还可以通过指定名称或者使用@Qualifier注解来指定具体的Bean。

### @Resource： ###

通过名称自动装配方式将一个Bean注入到另一个Bean中。  
与@Autowired不同的是，@Resource会根据名称查找对应的Bean，而不是根据类型查找。

#### 与@Autowired区别 ####

@Autowired 和 @Resource 都是 Java 中用来注入依赖的注解，但它们有以下区别：

**来源不同：**@Autowired 是 Spring 框架提供的注解，而 @Resource 是 JavaEE 标准提供的注解，不过 Spring 也支持 @Resource 注解。

**自动装配方式不同：**@Autowired 根据类型进行自动装配，如果容器中有多个相同类型的 Bean，那么需要通过 @Qualifier 或者其他方式指定具体的 Bean；而 @Resource 是根据名称进行自动装配，可以通过 name 属性指定具体的 Bean 名称。

**依赖范围不同：**@Autowired 可以用在字段、方法、构造函数上，也可以作用于集合类型，如 List、Set、Map 等；而 @Resource 只能用在字段上，且不支持集合类型。

**required 属性默认值不同：**@Autowired 的 required 属性默认值为 true，如果容器中找不到匹配的 Bean，会抛出 NoSuchBeanDefinitionException 异常；而 @Resource 的 required 属性默认值为 true，但不会抛出异常，而是会将字段设置为 null。

总的来说，@Autowired 更为灵活，可以用于更多的场景，而 @Resource 则更为简单，只适用于基本的注入场景。

### @Inject： ###

与@Autowired功能相同，都是通过类型自动装配方式将一个Bean注入到另一个Bean中。  
不同的是，@Inject是Java标准的注解，而@Autowired是Spring框架特有的注解。

### @Value： ###

用来注入简单类型的属性值，如字符串、数字、布尔值等。  
可以通过@Value注解指定属性值，也可以在配置文件中使用占位符$\{\}来动态指定属性值。

以上是常用的注入Bean的注解，根据实际情况选择不同的注解来注入Bean可以提高代码的可读性和灵活性。

## 4、Bean 的作用域 ##

在 Java 中，Bean 的作用域指的是 Bean 实例在容器中存在的时间范围。常用的 Bean 作用域包括：

Singleton：在整个应用程序中只存在一个实例。该作用域是默认作用域，通常用于状态无关的 Bean。
    
    Prototype：每次请求时都会创建一个新的实例。适合那些状态随请求变化的 Bean。
    
    Request：在每个 HTTP 请求中创建一个新的实例。适合那些与 HTTP 请求相关的 Bean。
    
    Session：在每个 HTTP 会话中创建一个新的实例。适合那些与用户会话相关的 Bean。
    
    Global Session：在一个全局 HTTP 会话中创建一个新的实例。通常用于 Portlet 环境。

其中，Singleton 和 Prototype 是最常用的 Bean 作用域。Singleton 用于那些在应用程序生命周期内只需要一个实例的 Bean，而 Prototype 则用于那些需要在每次调用时都创建新实例的 Bean。

### 单例 Bean 的线程安全问题 ###

在多线程环境下，单例 Bean 的共享实例可能会引发线程安全问题。以下是两个可能出现的问题：

竞态条件：当多个线程同时访问单例 Bean 的实例变量时，可能会发生数据竞争问题，导致结果不确定或不一致。
    
    非线程安全的操作：在单例 Bean 中使用非线程安全的对象或方法时，可能会导致线程安全问题，例如使用非线程安全的 HashMap类。

为了解决这些问题，可以采取以下措施：

同步方法或代码块：可以使用 synchronized 关键字来保证多线程访问单例 Bean 时的同步性。
    
    使用线程安全的对象或方法：可以使用线程安全的对象或方法，例如使用线程安全的 ConcurrentHashMap类。
    
    使用线程池：在高并发环境下，可以使用线程池来控制并发数量，从而减少对单例 Bean 的压力。

## 5、Bean的生命周期 ##

Spring Bean（Spring框架中的Java对象）的生命周期可以大致分为以下几个阶段：

实例化：当Spring容器启动时，它会读取配置文件并创建Bean定义，然后实例化Bean。在这个阶段，Spring会使用构造函数或工厂方法来创建Bean的实例。
    
    属性赋值：在Bean实例化后，Spring容器会将配置文件中定义的属性值注入到Bean中。这些属性可以是简单的值、引用其他Bean的引用，或者是集合类型。
    
    初始化：在Bean实例化和属性赋值完成后，Spring容器会调用Bean的初始化方法（如果定义了）。可以在这个阶段执行一些初始化的操作。
    
    使用：在初始化完成后，Bean可以被应用程序使用。在这个阶段，Bean会处理业务逻辑并执行相应的操作。
    
    销毁：当应用程序关闭时，Spring容器会调用Bean的销毁方法（如果定义了）。可以在这个阶段执行一些清理工作，比如释放资源等。

需要注意的是，Bean的生命周期受到Spring容器的控制，可以通过实现特定的接口或定义特定的方法来控制Bean的初始化和销毁过程。

### Bean 的生命周期引起的循环依赖、内存泄漏 ###

**循环依赖**是指两个或多个Bean之间相互依赖，形成了一个环形依赖关系。如果存在循环依赖，Spring会采用“提前暴露”和“后置处理器”的机制来解决。提前暴露是指Spring容器在创建Bean的过程中，会先创建一个空的Bean实例，然后再去填充它的属性。这样，在处理循环依赖时，就可以使用这个空的Bean实例来解决依赖关系。后置处理器则是在Bean初始化之后，对Bean进行一些额外的处理，例如增强、代理等。通过后置处理器，可以在Bean创建之后再进行一些处理，以解决循环依赖问题。

**内存泄漏**问题可能发生在Bean的销毁阶段。如果Bean中存在一些长生命周期的对象（如线程、数据库连接等），而这些对象没有被正确地关闭或释放，就可能导致内存泄漏。为了避免内存泄漏问题，可以通过在Bean中实现DisposableBean接口或在配置文件中使用destroy-method属性来指定Bean的销毁方法。在销毁方法中，可以手动关闭或释放长生命周期的对象，以确保它们不会导致内存泄漏。另外，Spring还提供了一个ApplicationContextAware接口，可以通过该接口获取到Spring容器的上下文对象，在销毁方法中可以使用该上下文对象进行一些操作。

### 销毁 Bean的方法 ###

Spring框架中有两种方式来销毁bean，一种是通过实现DisposableBean接口，另一种是通过定义自定义的销毁方法。

#### 实现DisposableBean接口： ####

DisposableBean接口是Spring框架提供的一个接口，它只有一个方法destroy()，在bean销毁的时候会自动调用这个方法。如果我们想在销毁bean的时候进行一些清理工作，可以让bean实现DisposableBean接口，并在destroy()方法中实现需要的清理逻辑。例如：

public class MyBean implements DisposableBean {
        
    
        @Override
        public void destroy() throws Exception {
        
            // 在这里实现需要的清理逻辑
        }
    }

#### 自定义销毁方法： ####

除了实现DisposableBean接口，我们还可以在bean的定义文件中通过配置自定义的销毁方法来销毁bean。需要在bean标签中设置destroy-method属性，并指定需要调用的方法名。例如：

在这个例子中，当bean销毁时，Spring会自动调用MyBean类中的cleanup()方法。

总的来说，Spring框架提供了多种销毁bean的方式，使得我们可以根据具体的需求来选择最合适的方式来实现清理工作，从而提高应用程序的健壮性和稳定性。