springboot注解之@Import @Conditional @ImportResource @ConfigurationProperties @EnableConfigurationProperties

1.包结构

 

 

2.主程序类

@SpringBootApplication(scanBasePackages={"com.atguigu"})
public class MainApplication {
    public static void main(String[] args) {
        //1.返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //2.获取容器内所有组件的名称
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }


        //获取指定组件类型的所有组件名称
        String[] beanNamesForType = run.getBeanNamesForType(User.class);
        //com.atguigu.boot.bean.User   --->通过@Import({User.class})在容器中自动创建的组件，默认组件名是全类名
        //user01   --->配置类中通过@Bean给容器注册组件，组件名默认是方法名
        //haha     --->从spring配置文件beans.xml导入添加到容器中的haha组件
        for (String bean : beanNamesForType) {
            System.out.println(bean);
        }

        boolean tomcatPet = run.containsBean("tomcatPet");
        System.out.println("容器中是否有tomcatPet组件？ " + tomcatPet);

        boolean user01 = run.containsBean("user01");
        System.out.println("容器中是否有user01组件？ " + user01);

        //spring配置文件beans.xml只有导入到了容器中，
        //这个配置文件中配置的bean才能添加到容器中
        //导入方式：一般在配置类上加上@ImportResource("classpath:beans.xml")，
        // 括号内指定xml的文件路径
        boolean haha = run.containsBean("haha");
        boolean hehe = run.containsBean("hehe");
        System.out.println(haha);
        System.out.println(hehe);

        Car car = run.getBean(Car.class);
        System.out.println(car);

    }
}

 

3.资源文件

　application.properties

#每一个key都是某个类的属性，而且都有默认值，可以修改
server.port=8888

#默认文件上传的最大文件大小是1MB，修改为10MB
#spring.servlet.multipart.max-file-size=10MB

mycar.brand=BYD
mycar.price=100000

 

　beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


<!--    spring使用<bean>标签给容器添加组件-->
    <bean id="haha" class="com.atguigu.boot.bean.User">
        <property name="name" value="张三"/>
        <property name="age" value="18"/>
    </bean>

    <bean id="hehe" class="com.atguigu.boot.bean.Pet">
        <property name="name" value="helloKitty"/>
    </bean>

</beans>

 

4.config包下配置类

package com.atguigu.boot.config;

import com.atguigu.boot.bean.Car;
import com.atguigu.boot.bean.Pet;
import com.atguigu.boot.bean.User;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.*;

/**
    1.配置类里面使用@Bean标注在方法上给容器注册组件，默认是单实例的
    2.配置类本身也是组件
    3.proxyBeanMethods：配置类是否作为代理bean来调用方法
        如果 proxyBeanMethods = true 则是Full模式（重量级模式）
            ---> 此模式下，配置类作为代理bean来调用方法，springboot都会去容器里面检查有没有这个组件，如果有，就使用容器中的组件，确保单实例，形成组件依赖
        如果 proxyBeanMethods = false 则是Lite模式（轻量级模式）
            ---> 此模式下，配置类是作为普通类调用方法，springboot不会去容器里面检查组件，不会形成组件依赖，项目启动运行快

    4.最佳实战
        配置类组件之间无依赖关系，用Lite模式加速容器启动过程，减少判断
        配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式

    5.@Import({User.class})
        给容器中自动创建出这个类型的组件，默认组件名是其全类名

    6.@Conditional 条件装配：满足Conditional指定的条件，组件才会被添加到容器中
    @ConditionalOnBean(name="user01")
    @ConditionalOnMissingBean(name = "user01")

    7.@ImportResource("classpath:beans.xml")   将spring配置文件导入到容器中

    8.配置绑定（属性）的两种方式
        第一种方式：目标bean上加上如下两个注解
            @Component  //将目标bean作为组件添加到容器中
            @ConfigurationProperties("mycar")  //配置属性：将配置文件中指定前缀的属性值映射到对象的属性
            注意：由于只有在容器中的组件，才能拥有SpringBoot提供的强大功能，所以这两个注解一般配合使用
        第二种方式
            在目标bean上加上@ConfigurationProperties("mycar")
            在配置类上加上@ConfigurationProperties(Car.class) //1.开启Car的属性绑定功能 2.将Car组件自动注册到容器中
            注：这种方法比较适合用于目标bean是第三方jar包里的类，因为没法使用第一种方法在它上面标注@Component

 */

@Import({User.class})
@Configuration(proxyBeanMethods = false)  //告诉Springbooot这是一个配置类
//@ConditionalOnBean(name="user01")  //条件装配：当满足容器中有user01组件这个条件，该配置类中带有@Bean的组件方法才能添加组件到容器中
//@ConditionalOnMissingBean(name = "user01") //条件装配：当容器中没有user01组件时，该配置类中带有@Bean的组件方法才能添加组件到容器中
@ImportResource("classpath:beans.xml")
@EnableConfigurationProperties(Car.class)
public class Myconfig {

    /**
     * 外部无论对配置类中的组件注册方法调用多少次，获取的都是之前注册在容器中的单实例对象
     * @return
     */
    //执行此语句会判断容器中是否有tomcatPet组件，由于程序代码顺序执行，所以容器里面此时没有tomcatPet组件
    //因此user01组件的条件不满足，容器不会添加user01组件
//    @ConditionalOnBean(name="tomcatPet")  //条件装配：只有当容器中有tomcatPet组件时，user01组件才能添加到容器中
    @Bean   //给容器中添加组件，默认以方法名作为组件id(组件名)。返回类型就是组件类型，返回值就是组件在容器中的实例
    public User user01() {
        User user = new User("zhangsan", 20);
        //如果@Configuration(proxyBeanMethods = true)，
        // 此时容器中的user01组件依赖容器中的tomcatPet组件
        user.setPet(cat());
        return user;
    }


    @Bean("tomcatPet") //此时组件名就是tomcatPet,而不是方法名了
    public Pet cat() {
        return new Pet("HelloKitty");
    }
}

 

5.bean包下实体类

　User

public class User {
    private String name;
    private Integer age;

    private Pet pet;

    public User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Pet getPet() {
        return pet;
    }

    public void setPet(Pet pet) {
        this.pet = pet;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", pet=" + pet +
                '}';
    }
}

 

　Pet

public class Pet {
    private String name;

    public Pet() {
    }

    public Pet(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                '}';
    }
}

 

　Car

/**
 * 只有在容器中的组件，才能拥有SpringBoot提供的强大功能，
 * 所以在使用@ConfigurationProperties("mycar")配置属性的前提是此bean为组件
 */

//@Component  //将此bean作为组件添加到容器中
@ConfigurationProperties("mycar")
//配置属性：将配置文件application.properties中指定前缀mycar的属性值映射到对象中相应的属性
public class Car {
    private String brand;//品牌
    private Double price;//价格

    public Car() {
    }

    public Car(String brand, Double price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

 

6.controller包下控制类

/**
 *
 * 默认包
 * springboot会将主程序所在包及其所有子包下的组件扫描进IOC容器
 *
 * 如果组件不在主程序所在包或者其子包下，比如WorldController组件，则必须将此组件所在全包名com.atguigu，
 * 声明在主程序类的@SpringBootApplication注解后面，
 * @SpringBootApplication(scanBasePackages={"com.atguigu"})，如果多个以字符串数组的形式
 * 这样此组件才能被扫描进IOC容器
 */


//@ResponseBody 方法直接返回字符串给浏览器
//@Controller
//  @RestController  =  @ResponseBody + @Controller
@RestController
public class HelloController {
    @Autowired  //自动注入组件
    Car car;

    @RequestMapping("/car")
    public Car car() {
        return car;
    }

    @RequestMapping("/hello")
    public String handle01() {
        return "hello,Spring boot 2!" + " 你好";
    }
}