备案控制台
开发者社区 开发与运维 文章 正文

【SpringBoot：详解Bean装配】

2024-05-06 11
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
RDS MySQL Serverless 高可用系列，价值2615元额度，1个月
简介： 【SpringBoot：详解Bean装配】

🏡Java码农探花：

🔥 推荐专栏：<springboot学习>

🛸学无止境，不骄不躁，知行合一

前言

IoC（（Inversion of Control,控制反转）容器是 Spring 的核心，可以说 Spring 是一种基于 IoC容器编程的框架。因为Spring Boot 是基于注解的开发 Spring IoC， 所以我们就从全注解的方式来讲诉Bean装配。

一、IoC容器的简介

Spring IoC 容器是一个管理 Bean 的容器，在 Spring 的定义中，它要求所有的 IoC 容器都需要实现接口 BeanFactory，它是一个顶级容器接口。 我们从源码讲诉。

BeanFactory接口源码


🏡Java码农探花：

 🔥 推荐专栏：<springboot学习>

🛸学无止境，不骄不躁，知行合一

前言
IoC（（Inversion of Control,控制反转）容器是 Spring 的核心，可以说 Spring 是一种基于 IoC容器编程的框架。因为Spring Boot 是基于注解的开发 Spring IoC， 所以我们就从全注解的方式来讲诉Bean装配。

一、IoC容器的简介
Spring IoC 容器是一个管理 Bean 的容器，在 Spring 的定义中，它要求所有的 IoC 容器都需要实现接口 BeanFactory，它是一个顶级容器接口。 我们从源码讲诉。

BeanFactory接口源码
package org.springframework.beans.factory;
 
import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;
 
public interface BeanFactory {
  // 前缀
    String FACTORY_BEAN_PREFIX = "&";
  
  // 多个getBean方法
    Object getBean(String name) throws BeansException;
 
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
 
    Object getBean(String name, Object... args) throws BeansException;
 
    <T> T getBean(Class<T> requiredType) throws BeansException;
 
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
 
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
 
    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
  
  // 是否包含Bean
    boolean containsBean(String name);
  
  //是否单例
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
  
  // 是否原型
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
  
  // 是否类型匹配
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
 
    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
  
  // 获取Bean的类型
    @Nullable
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
  
  // 获取Bean的别名
    @Nullable
    Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
 
    String[] getAliases(String name);
}

分析：

上诉源码中加入了中文注释，通过它们就可以理解这些方法的含义。
这里值得注意的是接口中的几个方法：
首先我们看到了多个getBean 方法，这也是IoC 容器最重要的方法之一， 它的意义是从IoC 容器中获取Bean而从多个getBean方法中可以看到有按类型(bytype)获取Bean 的，也有按名称(by name)获取 Bean 的，这就意味着在 Spring IoC 容器中，允许我们按类型或者名称获取 Bean。这对理解后面将讲到的Spring 的依赖注入（Dependency Injection, DI） 是十分重要的。
isSingleton 方法则判断 Bean 是否在 Spring IoC 中为单例。这里需要记住的是在 Spring IoC 容器中，默认的情况下， Bean 都是以单例存在的，也就是使用 getBean 方法返回的都是同一个对象。与isSingleton 方法相反的是 isPrototype 方法，如果它返回的是 true，那么当我们使用 getBean 方法获取Bean 的时候， Spring IoC 容器就会创建一个新的 Bean 返回给调用者。
由于BeanFactory 的功能还不够强大，因此 Spring 在 BeanFactory 的基础上， 还设计了一个更为高级的接口 ApplicationContext。 它是 BeanFactory 的子接口之一， 在 Spring 的体系中 BeanFactory 和ApplicationContext 是最为重要的接口设计，在现实中我们使用的大部分 Spring IoC 容器是ApplicationContext 接口的实现类。

在这里插入图片描述

在图中可以看到， ApplicationContext 接口通过继承上级接口，进而继承 BeanFactory 接口， 但是在BeanFactory 的基础上，扩展了消息国际化接口（MessageSource）、环境可配置接口 （EnvironmentCapable）、应用事件发布接口（ApplicationEventPublish巳r） 和资源模式解析接口（ResourcePatternResolver），所以它的功能会更为强大。
在Spring Boot 当中我们主要是通过注解来装配Bean到 Spring IoC 容器中，为了贴近 SpringBoot 的需要， 这里不再介绍与 XML 相关的 IoC 容器，而主要介绍一个基于注解的 IoC 容器，它就是AnnotationConfigApplicationContext，从名称就可以看出它是一个基于注解的 IoC 容器。 之所以研究它， 是因为Spring Boot 装配和获取 Bean 的方法与它如出一辙。
例：创建一个User类，然后使用AnnotationConfigApplicationContext构建IoC容器

public class User {
  private Long id; 
  private String userName; 
/**setter and getter **/ 
}
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Con f工guration ;
import com.springboot.chapter3.po] o.User;
@Configuration 
public class AppConfig { 
  @Bean(name =”user” } 
  public User ini tUser () { 
    User user= new User (); 
    user. set Id (1L) ; 
    user.setUserName (”aa”); 
    return user;
  }
}
＠Configuration 代表这是一个 Java 配置文件， Spring 的容器会根据它来生成IoC 容器去装配Bean；@Bean 代表将 initUser 方法返回的 POJO 装配到 IoC 容器中，而其属性name 定义这个 Bean 的名称，如果没有配置它，则将方法名称“initUser”作为 Bean 的名称保存到Spring IoC 容器中。

import org.apache. log4j .Logger; 
import org. springframework.context.ApplicationContext; 
import org. springframework.context annotation.AnnotationConfigApplicat工onContext;
import com.springboot.chapter3.po] o .User;
public class IoCTest { 
  private static Logger log= Logger.getLogger(IoCTest.class); 
  publ工c static 飞roid main (String [] args) { 
    ApplicationContext ctx = new AnnotationConfigAppl丰cationContext(AppConfig. class);
    User user= ctx.getBean(User.class); 
  }
}
代码中将Java 配置文件 AppConfig 传递给 AnnotationConfigApplicationContext 的构造方法，这样它就能够读取配置了。然后将配置里面的Bean装配到IoC容器中，于是可以使用 getBean方法获取对应的POJO。

二、Bean装配
扫描装配
上诉讲诉的User对象装配就是使用@Bean装配。但是如果一个个的 Bean 使用注解＠Bean 注入 Spring loC 容器中，那将是一件很麻烦的事情。好在Spring 还允许我们进行扫描装配 Bean 到 loC 容器中，对于扫描装配而言使用的注解是＠Component和＠ComponentScan。＠Component 是标明l哪个类被扫描进入 Spring IoC 容器，而ComponentScan则是标明采用何种策略去扫描装配Bean。

@Component(”user") 
public class User { 
  @Value("1") 
  private Long id; 
  @Value("aa"} 
  private String userName; 
/**setter and getter **/ 
}
这里的注解＠Component表明这个类将被SpringIoC 容器扫描装配，其中配置的“user＂则是作为Bean 的名称，当然你也可以不配置这个字符串，那么IoC容器就会把类名第一个字母作为小写，其他不变作为Bean 名称放入到IoC 容器中；注解＠Value则是指定具体的值，使得Spring IoC给予对应的属性注入对应的值。为了让SpringIoC 容器装配这个类， 需要改造类AppConfig：

import org.springframework.context.annotat工on.ComponentScan;
import org.springframework.context.annotation Configuration; 
@Configuration 
@ComponentScan 
public class AppConfig {
}
这里加入了＠ComponentScan，意味着它会进行扫描，但是它只会扫描类AppConfig所在的当前包和其子包。也就是@ComponentScan默认扫描当前类所在包及其子包。 所以User类的位置要注意。

测试：

Applicat工onContext ctx = new AnnotationConfigApplicationContext{AppConfig.class) ;
User user= ctx.getBean(User.class); 
log. info(user.getid());
为了更加合理，＠ComponentScan还允许我们自定义扫描的包，我们看一下源码：

package org.springframework.context.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.core.annotation.AliasFor;
 
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
//在一个类中可重复定义
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
 
  // 定义扫描的包
    @AliasFor("basePackages")
    String[] value() default {};
  
  //定义扫描的包
    @AliasFor("value")
    String[] basePackages() default {};
  
  //定义扫描的类
    Class<?>[] basePackageClasses() default {};
  
  //Bean name生成器
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
  
  //作用域解析器
    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
  
  //作用域代理模式
    ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
  
  //资源匹配模式
    String resourcePattern() default "**/*.class";
  
  //是否启用默认的过滤器
    boolean useDefaultFilters() default true;
  
  //当满足过滤器的条件时扫描
    Filter[] includeFilters() default {};
  
  //当不满足过滤器的条件时扫描
    Filter[] excludeFilters() default {};
  
  //是否延迟初始化
    boolean lazyInit() default false;
  
  //定义过滤器
    @Retention(RetentionPolicy.RUNTIME)
    @Target({})
    public @interface Filter {
      //过滤器类型，可以按注解类型或者正则式等过滤
        FilterType type() default FilterType.ANNOTATION;
    
    //定义过滤的类
        @AliasFor("classes")
        Class<?>[] value() default {};
 
        @AliasFor("value")
        Class<?>[] classes() default {};
    
    //匹配方式
        String[] pattern() default {};
    }
}

分析：

首先可以通过配置项basePackages定义扫描的包名，在没有定义的情况下，它只会扫描当前包和其子包下的路径：还可以通过basePackageClasses 定义扫描的类；
其中还有 includeFilters 和 excludeFilters, includeFilters 是定义满足过滤器（Filter）条件的 Bean 才去扫描， excludeFilters 则是排除过滤器条件的 Bean，它们都需要通过一个注解＠Filter 去定义，它有一个type 类型，这里可以定义为注解或者正则式等类型。 classes定义注解类， pattern 定义正则式类
所以得出三个扫描路径表示：

@ComponentScan ("com.springboot.example.* ")
@ComponentScan(basePackages = {"com.springboot.example.pojo"})
@ComponentScan(basePackageClasses = {User.class} ) 
以及排除扫描包或类，让其不被装配：

//扫描example下所有包除了@Service装配的类
//这样，由于加入了 excludeFilters 的配置，使标注了＠Service 的类将不被 IoC 容器扫描注入，这样就可以把它类排除到 Spring IoC容器中了。
@ComponentScan(basePackages = {"com.dragon.restart"},excludeFilters = {@ComponentScan.Filter(classes = Service.class)})
探索启动类
事实上，之前在 Spring Boot 的注解＠SpringBootApplication 也注入了＠ComponentScan，这里不妨探索其源码：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
//自定义排除的扫描类
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
  //通过类型排除自动配置
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};
  //通过名称排除自动配置类
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};
  //定义扫描包
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};
  //定义被扫描的类
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};

显然，通过它就能够定义扫描哪些包。但是这里需要特别注意的是，它提供的exclude和excludeName两个方法是对于其内部的自动配置类才会生效的。为了能够排除其他类，还可以再加入＠ComponentScan以达到我们的目的。

条件装配
例如在数据库连接池的配置中漏掉一些配置会造成数据源不能连接上。 在这样的情况下， IoC容器如果还进行数据源的装配， 则系统将会抛出异常，导致应用无法继续。这时倒是希望IoC容器不去装配数据源。
为了处理这样的场景， Spring 提供了＠Conditional注解帮助我们，而它需要配合另外一个接口Condition(org.springframework.context.annotation.Condition ）来完成对应的功能。
装配的Bean：

@Bean(name = "dataSource", destroyMethod = "close" ) 
@Conditional(DatabaseConditional.class)
public DataSource getDataSource ( 
@Value("${database.driverName}") String driver, 
@Value("${database.url}") String url, 
@Value("${database.username}") String username, 
@Value("{database.password}") String password 
){ 
  Properties props= new Properties(); 
  props.setProperty("driver", driver); 
  props setProperty("url", url); 
  props.setProperty("username", username); 
  props setProperty("password", password); 
  DataSource dataSource = null; 
  try { 
    dataSource = BasicDataSourceFactory.createDataSource(props) ; 
  ) catch (Exception e) { 
    e.printStackTrace();
  }
  return dataSource;
}

自定义DatabaseConditional类：

public class DatabaseConditional implements Condition { 
/**
* 数据库装配条件
* 
* ＠param context 条件上下文
* @param metadata 注释类型的元数据
* ＠return true 装配 Bean，否则不装配
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 
  //取出环境配置
  Environment env = context.getEnvironment(); 
  //判断属性文件是否存在对应的数据库配置
  return env.containsProperty(”database.driverName” ) 
    && env.containsProperty(”database.url”) 
    && env.containsProperty(” database.username”) 
    && env.containsProperty (”database.password");

matches 方法首先读取其上下文环境， 然后判定是否已经配置了对应的数据库信息。这样，当这些都己经配置好后则返回true。这个时候Spring会装配数据库连接池的Bean，否则是不装配的。

自定义Bean
现实的Java 的应用往往需要引入许多来自第三方的包， 并且很有可能希望把第三方包的类对象也放入到Spring IoC 容器中，这时＠Bean注解就可以发挥作用了。
例如，要引入一个DBCP数据源，我们先在pom.xml上加入项目所需要DBCP包和数据库MySQL驱动程序的依赖。
<dependency> 
  <groupid>org.apache.commons</groupid> 
  <artifactid>commons-dbcp2</artifactid> 
</dependency> 
<dependency> 
  <groupid>mysql</groupid> 
  <artifactid>mysql-connector-ava</artifactid>
</dependency>
这样 DBCP 和数据库驱动就被加入到了项目中，接着将使用它提供的机制来生成数据源：

@Bean(name = "dataSource") 
@Conditional(DatabaseConditional.class)
public DataSource getDataSource (){ 
  Properties props= new Properties(); 
  props.setProperty("driver", driver); 
  props setProperty("url", url); 
  props.setProperty("username", username); 
  props setProperty("password", password); 
  DataSource dataSource = null; 
  try { 
    dataSource = BasicDataSourceFactory.createDataSource(props) ; 
  ) catch (Exception e) { 
    e.printStackTrace();
  }
  return dataSource;
}

这里通过＠Bean 定义了其配置项 name 为“dataSource“，那么 Spring 就会把它返回的对象用名称“dataSource” 保存在 loC 容器中。当然， 你也可以不填写这个名称，那么它就会用你的方法名称作为Bean 名称保存到 IoC 容器中。通过这样，就可以将第三方包的类装配到SpringIoC容器中了。

总结
以上就是SpringBoot的Bean装配的详细讲解。

分析：

  • 上诉源码中加入了中文注释，通过它们就可以理解这些方法的含义。
  • 这里值得注意的是接口中的几个方法：
  • 首先我们看到了多个getBean 方法，这也是IoC 容器最重要的方法之一， 它的意义是从IoC 容器中获取Bean而从多个getBean方法中可以看到有按类型(bytype)获取Bean 的，也有按名称(by name)获取 Bean 的，这就意味着在 Spring IoC 容器中，允许我们按类型或者名称获取 Bean。这对理解后面将讲到的Spring 的依赖注入（Dependency Injection, DI） 是十分重要的。
  • isSingleton 方法则判断 Bean 是否在 Spring IoC 中为单例。这里需要记住的是在 Spring IoC 容器中，默认的情况下， Bean 都是以单例存在的，也就是使用 getBean 方法返回的都是同一个对象。与isSingleton 方法相反的是 isPrototype 方法，如果它返回的是 true，那么当我们使用 getBean 方法获取Bean 的时候， Spring IoC 容器就会创建一个新的 Bean 返回给调用者。

由于BeanFactory 的功能还不够强大，因此 Spring 在 BeanFactory 的基础上， 还设计了一个更为高级的接口 ApplicationContext。 它是 BeanFactory 的子接口之一， 在 Spring 的体系中 BeanFactory 和ApplicationContext 是最为重要的接口设计，在现实中我们使用的大部分 Spring IoC 容器是ApplicationContext 接口的实现类。

  • 在图中可以看到， ApplicationContext 接口通过继承上级接口，进而继承 BeanFactory 接口， 但是在BeanFactory 的基础上，扩展了消息国际化接口（MessageSource）、环境可配置接口 （EnvironmentCapable）、应用事件发布接口（ApplicationEventPublish巳r） 和资源模式解析接口（ResourcePatternResolver），所以它的功能会更为强大。
  • 在Spring Boot 当中我们主要是通过注解来装配Bean到 Spring IoC 容器中，为了贴近 SpringBoot 的需要， 这里不再介绍与 XML 相关的 IoC 容器，而主要介绍一个基于注解的 IoC 容器，它就是AnnotationConfigApplicationContext，从名称就可以看出它是一个基于注解的 IoC 容器。 之所以研究它， 是因为Spring Boot 装配和获取 Bean 的方法与它如出一辙。

例：创建一个User类，然后使用AnnotationConfigApplicationContext构建IoC容器

public class User {
  private Long id; 
  private String userName; 
/**setter and getter **/ 
}
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Con f工guration ;
import com.springboot.chapter3.po] o.User;
@Configuration 
public class AppConfig { 
  @Bean(name =”user” } 
  public User ini tUser () { 
    User user= new User (); 
    user. set Id (1L) ; 
    user.setUserName (”aa”); 
    return user;
  }
}

＠Configuration 代表这是一个 Java 配置文件， Spring 的容器会根据它来生成IoC 容器去装配Bean；@Bean 代表将 initUser 方法返回的 POJO 装配到 IoC 容器中，而其属性name 定义这个 Bean 的名称，如果没有配置它，则将方法名称“initUser”作为 Bean 的名称保存到Spring IoC 容器中。

import org.apache. log4j .Logger; 
import org. springframework.context.ApplicationContext; 
import org. springframework.context annotation.AnnotationConfigApplicat工onContext;
import com.springboot.chapter3.po] o .User;
public class IoCTest { 
  private static Logger log= Logger.getLogger(IoCTest.class); 
  publ工c static 飞roid main (String [] args) { 
    ApplicationContext ctx = new AnnotationConfigAppl丰cationContext(AppConfig. class);
    User user= ctx.getBean(User.class); 
  }
}

代码中将Java 配置文件 AppConfig 传递给 AnnotationConfigApplicationContext 的构造方法，这样它就能够读取配置了。然后将配置里面的Bean装配到IoC容器中，于是可以使用 getBean方法获取对应的POJO。

二、Bean装配

扫描装配

上诉讲诉的User对象装配就是使用@Bean装配。但是如果一个个的 Bean 使用注解＠Bean 注入 Spring loC 容器中，那将是一件很麻烦的事情。好在Spring 还允许我们进行扫描装配 Bean 到 loC 容器中，对于扫描装配而言使用的注解是＠Component和＠ComponentScan。＠Component 是标明l哪个类被扫描进入 Spring IoC 容器，而ComponentScan则是标明采用何种策略去扫描装配Bean。

@Component(”user") 
public class User { 
  @Value("1") 
  private Long id; 
  @Value("aa"} 
  private String userName; 
/**setter and getter **/ 
}

这里的注解＠Component表明这个类将被SpringIoC 容器扫描装配，其中配置的“user＂则是作为Bean 的名称，当然你也可以不配置这个字符串，那么IoC容器就会把类名第一个字母作为小写，其他不变作为Bean 名称放入到IoC 容器中；注解＠Value则是指定具体的值，使得Spring IoC给予对应的属性注入对应的值。为了让SpringIoC 容器装配这个类， 需要改造类AppConfig：

import org.springframework.context.annotat工on.ComponentScan;
import org.springframework.context.annotation Configuration; 
@Configuration 
@ComponentScan 
public class AppConfig {
}

这里加入了＠ComponentScan，意味着它会进行扫描，但是它只会扫描类AppConfig所在的当前包和其子包。也就是@ComponentScan默认扫描当前类所在包及其子包。 所以User类的位置要注意。

测试：

Applicat工onContext ctx = new AnnotationConfigApplicationContext{AppConfig.class) ;
User user= ctx.getBean(User.class); 
log. info(user.getid());

为了更加合理，＠ComponentScan还允许我们自定义扫描的包，我们看一下源码：

package org.springframework.context.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.core.annotation.AliasFor;
 
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
//在一个类中可重复定义
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
 
  // 定义扫描的包
    @AliasFor("basePackages")
    String[] value() default {};
  
  //定义扫描的包
    @AliasFor("value")
    String[] basePackages() default {};
  
  //定义扫描的类
    Class<?>[] basePackageClasses() default {};
  
  //Bean name生成器
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
  
  //作用域解析器
    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
  
  //作用域代理模式
    ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
  
  //资源匹配模式
    String resourcePattern() default "**/*.class";
  
  //是否启用默认的过滤器
    boolean useDefaultFilters() default true;
  
  //当满足过滤器的条件时扫描
    Filter[] includeFilters() default {};
  
  //当不满足过滤器的条件时扫描
    Filter[] excludeFilters() default {};
  
  //是否延迟初始化
    boolean lazyInit() default false;
  
  //定义过滤器
    @Retention(RetentionPolicy.RUNTIME)
    @Target({})
    public @interface Filter {
      //过滤器类型，可以按注解类型或者正则式等过滤
        FilterType type() default FilterType.ANNOTATION;
    
    //定义过滤的类
        @AliasFor("classes")
        Class<?>[] value() default {};
 
        @AliasFor("value")
        Class<?>[] classes() default {};
    
    //匹配方式
        String[] pattern() default {};
    }
}

分析：

  • 首先可以通过配置项basePackages定义扫描的包名，在没有定义的情况下，它只会扫描当前包和其子包下的路径：还可以通过basePackageClasses 定义扫描的类；
  • 其中还有 includeFilters 和 excludeFilters, includeFilters 是定义满足过滤器（Filter）条件的 Bean 才去扫描， excludeFilters 则是排除过滤器条件的 Bean，它们都需要通过一个注解＠Filter 去定义，它有一个type 类型，这里可以定义为注解或者正则式等类型。 classes定义注解类， pattern 定义正则式类

所以得出三个扫描路径表示：

@ComponentScan ("com.springboot.example.* ")
@ComponentScan(basePackages = {"com.springboot.example.pojo"})
@ComponentScan(basePackageClasses = {User.class} )

以及排除扫描包或类，让其不被装配：

//扫描example下所有包除了@Service装配的类
//这样，由于加入了 excludeFilters 的配置，使标注了＠Service 的类将不被 IoC 容器扫描注入，这样就可以把它类排除到 Spring IoC容器中了。
@ComponentScan(basePackages = {"com.dragon.restart"},excludeFilters = {@ComponentScan.Filter(classes = Service.class)})
探索启动类

事实上，之前在 Spring Boot 的注解＠SpringBootApplication 也注入了＠ComponentScan，这里不妨探索其源码：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
//自定义排除的扫描类
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
  //通过类型排除自动配置
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};
  //通过名称排除自动配置类
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};
  //定义扫描包
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};
  //定义被扫描的类
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};

显然，通过它就能够定义扫描哪些包。但是这里需要特别注意的是，它提供的exclude和excludeName两个方法是对于其内部的自动配置类才会生效的。为了能够排除其他类，还可以再加入＠ComponentScan以达到我们的目的。

条件装配

  • 例如在数据库连接池的配置中漏掉一些配置会造成数据源不能连接上。 在这样的情况下， IoC容器如果还进行数据源的装配， 则系统将会抛出异常，导致应用无法继续。这时倒是希望IoC容器不去装配数据源。
  • 为了处理这样的场景， Spring 提供了＠Conditional注解帮助我们，而它需要配合另外一个接口Condition(org.springframework.context.annotation.Condition ）来完成对应的功能。

装配的Bean：

@Bean(name = "dataSource", destroyMethod = "close" ) 
@Conditional(DatabaseConditional.class)
public DataSource getDataSource ( 
@Value("${database.driverName}") String driver, 
@Value("${database.url}") String url, 
@Value("${database.username}") String username, 
@Value("{database.password}") String password 
){ 
  Properties props= new Properties(); 
  props.setProperty("driver", driver); 
  props setProperty("url", url); 
  props.setProperty("username", username); 
  props setProperty("password", password); 
  DataSource dataSource = null; 
  try { 
    dataSource = BasicDataSourceFactory.createDataSource(props) ; 
  ) catch (Exception e) { 
    e.printStackTrace();
  }
  return dataSource;
}

自定义DatabaseConditional类：

public class DatabaseConditional implements Condition { 
/**
* 数据库装配条件
* 
* ＠param context 条件上下文
* @param metadata 注释类型的元数据
* ＠return true 装配 Bean，否则不装配
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 
  //取出环境配置
  Environment env = context.getEnvironment(); 
  //判断属性文件是否存在对应的数据库配置
  return env.containsProperty(”database.driverName” ) 
    && env.containsProperty(”database.url”) 
    && env.containsProperty(” database.username”) 
    && env.containsProperty (”database.password");

matches 方法首先读取其上下文环境， 然后判定是否已经配置了对应的数据库信息。这样，当这些都己经配置好后则返回true。这个时候Spring会装配数据库连接池的Bean，否则是不装配的。

自定义Bean

  • 现实的Java 的应用往往需要引入许多来自第三方的包， 并且很有可能希望把第三方包的类对象也放入到Spring IoC 容器中，这时＠Bean注解就可以发挥作用了。
  • 例如，要引入一个DBCP数据源，我们先在pom.xml上加入项目所需要DBCP包和数据库MySQL驱动程序的依赖。
<dependency> 
  <groupid>org.apache.commons</groupid> 
  <artifactid>commons-dbcp2</artifactid> 
</dependency> 
<dependency> 
  <groupid>mysql</groupid> 
  <artifactid>mysql-connector-ava</artifactid>
</dependency>

这样 DBCP 和数据库驱动就被加入到了项目中，接着将使用它提供的机制来生成数据源：

@Bean(name = "dataSource") 
@Conditional(DatabaseConditional.class)
public DataSource getDataSource (){ 
  Properties props= new Properties(); 
  props.setProperty("driver", driver); 
  props setProperty("url", url); 
  props.setProperty("username", username); 
  props setProperty("password", password); 
  DataSource dataSource = null; 
  try { 
    dataSource = BasicDataSourceFactory.createDataSource(props) ; 
  ) catch (Exception e) { 
    e.printStackTrace();
  }
  return dataSource;
}

这里通过＠Bean 定义了其配置项 name 为“dataSource“，那么 Spring 就会把它返回的对象用名称“dataSource” 保存在 loC 容器中。当然， 你也可以不填写这个名称，那么它就会用你的方法名称作为Bean 名称保存到 IoC 容器中。通过这样，就可以将第三方包的类装配到SpringIoC容器中了。

总结

以上就是SpringBoot的Bean装配的详细讲解。


文章标签：
云数据库 RDS MySQL 版
Java
容器
Spring
数据库
XML
关键词：
Spring Boot装配
Spring Boot bean装配
Spring Boot bean
相关实践学习
基于CentOS快速搭建LAMP环境
本教程介绍如何搭建LAMP环境，其中LAMP分别代表Linux、Apache、MySQL和PHP。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
码农烧烤
目录
相关文章
hhzz
|
4天前
|
XML Java 开发者
Spring Boot中的bean注入方式和原理
Spring Boot中的bean注入方式和原理
hhzz
134 0
蒾酒
|
4天前
|
存储 NoSQL Java
Spring Boot统计一个Bean中方法的调用次数
Spring Boot统计一个Bean中方法的调用次数
蒾酒
44 1
请回答1024
|
4天前
|
Java
SpringBoot之@Conditional衍生条件装配详解
SpringBoot之@Conditional衍生条件装配详解
请回答1024
7 0
xiaohua616
|
4天前
|
Java Spring 容器
SpringBoot 使用Quartz执行定时任务对象时无法注入Bean问题
SpringBoot 使用Quartz执行定时任务对象时无法注入Bean问题
xiaohua616
19 1
Naylor
|
4天前
|
Java Spring 容器
SpringBoot中bean的生命周期
Spring Boot的Bean生命周期涉及实例化、属性注入、初始化和销毁。在实例化后，Spring通过构造函数或Setter注入属性，然后调用初始化方法（@PostConstruct、InitializingBean接口）。Bean在应用中使用后，当容器关闭时，会调用销毁方法（@PreDestroy、DisposableBean接口）。依赖注入、配置管理、组件扩展和切面编程是其常见应用场景。示例代码展示了如何通过实现BeanNameAware、BeanFactoryAware等接口以及使用@PostConstruct注解来控制Bean的初始化。
Naylor
46 2
SpringBoot中bean的生命周期
不会就选C.
|
4天前
|
XML Java 数据格式
【springboot原理篇】Bean的加载方式，面试必看
【springboot原理篇】Bean的加载方式，面试必看
不会就选C.
57 0
浩泽学编程
|
4天前
|
Java 容器 Spring
SpringBoot：Bean生命周期自定义初始化和销毁
SpringBoot：Bean生命周期自定义初始化和销毁
浩泽学编程
53 1
浩泽学编程
|
4天前
|
Java 开发者 容器
SpringBoot：详解Bean生命周期和作用域
SpringBoot：详解Bean生命周期和作用域
浩泽学编程
115 0
山河亦问安
|
4天前
|
XML Java API
Springboot的自动装配解读
Spring Framework本身有一个IOC容器，该容器会统一管理其中的Bean对象，Bean对象可以理解为组件，要理解组件装配，首先要理解组件的概念。
山河亦问安
16 1
Naylor
|
4天前
|
存储 Java 开发工具
SpringBoot中Bean的条件装配
本文总结了在SpringBoot中常用的bean装配方法： * profile * conditional * ConditionalOn
Naylor
44 1

热门文章

最新文章

  • 1
    Java语言开发的AI智慧导诊系统源码springboot+redis 3D互联网智导诊系统源码
  • 2
    [AIGC] 在Spring Boot中指定请求体格式
  • 3
    Spring Boot整合canal实现数据一致性解决方案解析-部署+实战
  • 4
    基于SpringBoot+Vue+uniapp微信小程序的微信课堂助手小程序的详细设计和实现
  • 5
    SpringBoot之三层架构的详细解析
  • 6
    SpringBoot自动装配原理之@Import注解解析
  • 7
    【Spring Boot系列】通过OpenAPI规范构建微服务服务接口
  • 8
    基于SpringBoot+Vue+uniapp微信小程序的电子商城购物平台的详细设计和实现
  • 9
    B/S基层卫生健康云HIS医院管理系统源码 SaaS模式 、Springboot框架
  • 10
    【SpringBoot系列】微服务监测（常用指标及自定义指标）
  • 1
    SpringBoot启动后出现Please sign in页面
    58
  • 2
    Spring Boot的定时任务与异步任务
    57
  • 3
    SpringBoot整合Mybatis连接Oracle数据库
    81
  • 4
    通用Shell脚本执行Spring Boot项目Jar包
    37
  • 5
    【SpringBoot系列】SpringBoot集成Fast Mybatis
    181
  • 6
    Spring Boot集成Redis启动失败【Caused by: java.lang.ClassNotFoundException: org.apache.commons.pool2.impl.G】
    93
  • 7
    【二十二】springboot整合拦截器实战并对比过滤器
    38
  • 8
    【二十一】springboot整合过滤器实战
    18
  • 9
    【二十】springboot整合ElasticSearch实战（万字篇）
    242
  • 10
    【十八】springboot实现自定义全局异常处理
    38

    • 相关课程

    更多
  • 微服务+全栈在线教育实战项目演练（SpringCloud Alibaba+SpringBoot）
  • SpringBoot实战教程
  • SpringBoot快速掌握 - 核心技术
  • SpringBoot快速掌握 - 高级应用
  • Springboot项目云开发快速迁移
  • 5天实战Spring Boot 2.5

    • 相关电子书

    更多
  • 使用Spring.Initializr定制工程脚手架
  • 陈曦：使用Spring.Initializr定制工程脚手架
  • Spring框架入门

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考