1.@Configuration#

• 先准备两个bean：boot/bean/Pet.class和User.class

  1
  package com.atguigu.boot.bean;
  2
  
  3
  public class User {
  4
      private String name;
  5
      private Integer age;
  6
      private Pet pet;
  7
  
  8
      public User() {
  9
      }
  10
      public User(String name, Integer age) {
  11
          this.name = name;
  12
          this.age = age;
  13
      }
  14
  
  15
      public Pet getPet() {
  16
          return pet;
  17
      }
  18
      public void setPet(Pet pet) {
  19
          this.pet = pet;
  20
      }
  21
      public String getName() {
  22
          return name;
  23
      }
  24
  
  25
      public void setName(String name) {
  26
          this.name = name;
  27
      }
  28
      public Integer getAge() {
  29
          return age;
  30
      }
  31
      public void setAge(Integer age) {
  32
          this.age = age;
  33
      }
  34
  
  35
      @Override
  36
      public String toString() {
  37
          return "User{" +
  38
                  "name='" + name + '\'' +
  39
                  ", age=" + age +
  40
                  ", pet=" + pet +
  41
                  '}';
  42
      }
  43
  }

  展开收起

• 以前Spring容器中添加两组件方式：在resources下创建beans.xml

  1
  <?xml version="1.0" encoding="UTF-8"?>
  2
  <beans xmlns="http://www.springframework.org/schema/beans"
  3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5
  
  6
      <bean id="user01" class="com.atguigu.boot.bean.User">
  7
          <!--        默认值-->
  8
          <property name="name" value="zhangsan"/>
  9
          <property name="age" value="18"/>
  10
      </bean>
  11
      <bean id="cat" class="com.atguigu.boot.bean.Pet">
  12
          <property name="name" value="tomcat"/>
  13
      </bean>
  14
  </beans>

• 现在SpringBoot组件添加

  创建boot/config/MyConfig.class

  1
  package com.atguigu.boot.config;
  2
  
  3
  import com.atguigu.boot.bean.Pet;
  4
  import com.atguigu.boot.bean.User;
  5
  import org.springframework.context.annotation.Bean;
  6
  import org.springframework.context.annotation.Configuration;
  7
  
  8
  //告诉SpringBoot这是配置类（相当于以前的配置文件）
  9
  @Configuration
  10
  public class MyConfig {
  11
      //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
  12
      //外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
  13
      @Bean
  14
      public User user01(){
  15
          User zhangsan = new User("zhangsan",18);
  16
          //User组件依赖了Pet组件
  17
          zhangsan.setPet(tomcatPet());
  18
          return zhangsan;
  19
      }
  20
  
  21
      @Bean
  22
      public Pet tomcatPet(){
  23
          return new Pet("tomcat");
  24
      }
  25
  }

  展开收起

  • 给容器中添加组件。以方法名作为组件的id（也可以不用方法名：@Bean("tomcat")。返回类型就是组件类型。返回的值，就是组件在容器中的实例
  • @Configuration(proxyBeanMethods = false)：是否是代理对象（单实例），默认true【启用代理，就是先创建bean，每次用的时候直接拿】
  • Full模式(true)与Lite模式
  • • 配置类组件之间无依赖关系（别人不依赖你）用Lite模式加速容器启动过程，减少判断（容器中是否有这个bean）
    • 配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式

• 测试验证MainApplication.class

  1
  @SpringBootApplication
  2
  public class MainApplication {
  3
      public static void main(String[] args) {
  4
          //把主类加载进来(1.返回IOC容器)
  5
          ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
  6
          //2.查看容器里面的组件
  7
          String[] names = run.getBeanDefinitionNames();
  8
          for (String name : names) {
  9
              System.out.println(name);
  10
          }
  11
  
  12
          //3、从容器中获取组件
  13
          Pet tom01 = run.getBean("tomcat", Pet.class);
  14
          Pet tom02 = run.getBean("tomcat", Pet.class);
  15
          System.out.println("组件："+(tom01 == tom02));
  16
  
  17
          //4、com.atguigu.boot.config.MyConfig$$EnhancerBySpringCGLIB$$51f1e1ca@1654a892
  18
          MyConfig bean = run.getBean(MyConfig.class);
  19
          System.out.println(bean);
  20
  
  21
          //如果@Configuration(proxyBeanMethods = true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
  22
          //保持组件单实例
  23
          User user = bean.user01();
  24
          User user1 = bean.user01();
  25
          System.out.println(user == user1);
  26
  
  27
          User user01 = run.getBean("user01", User.class);
  28
          Pet tom = run.getBean("tomcat", Pet.class);
  29
          System.out.println("用户的宠物："+(user01.getPet() == tom));
  30
      }
  31
  }

  展开收起

2.@Bean、@Component、@Controller、@Service、@Repository#

@Bean：给容器中添加组件，以方法名作为组件的id，返回类型就是组件的类型，返回的值，就是组件在容器中的实例

@Component：组件，默认组件名就是类名，首字母小写

@Controller：控制层

@Service：服务层

@Repository：数据访问层

3.@ComponentScan、@Import#

MyConfig.class

1
@Import({User.class})
2
@Configuration
3
public class MyConfig {

@Import({User.class, DBHelper.class})

给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名

MainApplication.class

1
//5、获取组件
2
String[] beanNamesForType = run.getBeanNamesForType(User.class);
3
for (String s : beanNamesForType) {
4
    System.out.println(s);
5
}

输出：

com.atguigu.boot.bean.User

user01

@Import 高级用法： https://www.bilibili.com/video/BV1gW411W7wy?p=8

4.@Conditional#

条件装配：满足Conditional指定的条件，则进行组件注入

MyConfig.class

1
@Configuration
2
public class MyConfig {
3
    //容器中有tomcat组件时才给容器注入user01
4
    @ConditionalOnBean(name = "tomcat")
5
    @Bean
6
    public User user01(){
7
        User zhangsan = new User("zhangsan",18);
8
        //User组件依赖了Pet组件
9
        zhangsan.setPet(tomcatPet());
10
        return zhangsan;
11
    }
12
}

MainApplication.class

1
boolean tomcat = run.containsBean("tomcat");
2
System.out.println("有没有tomcat组件"+tomcat);
3
boolean user01 = run.containsBean("user01");
4
System.out.println("有没有user01组件"+user01);

输出：

有没有tomcat组件false

有没有user01组件false

也可以放到类上面：

1
@ConditionalOnMissingBean(name = "tomcat")
2
public class MyConfig {

表示只有当容器中有tomcat组件时这个类中的配置才生效