springboot

SpringBoot-WD版本

Properties或者yml配置文件中的值和组件之间属性的关联。

  1. 需要全部的名称，直接是在属性上面@Value("${hello.controller.content}").

        //@Value("${demo.druid.driver}")
    String driver;

  2. @ConfigurationProperties 放在类上,其实就是把这个类变成了弄属性的类了。

    @ConfigurationProperties(prefix = "demo.druid")
    • 如果需要在yml中写配置的时候有提示，需要加入这个依赖。
            <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

    • 属性中其他数据类型的在yml中的赋值问题。

      Properties中的写法：
#list的两种写法
my.file.list1=data1,data2,data3
my.file.list2[0]=data1
my.file.list2[1]=data2
my.file.list2[2]=data3

#map的两种写法
my.file.map1.key1=value1
my.file.map1.key2=value2
my.file.map1.key3=value3

my.file.map2[key1]=value1
my.file.map2[key2]=value2
my.file.map2[key3]=value3

#javabean → 和map是一样的
my.file.file-detail.param1=songge
my.file.file-detail.param2=18
#my.file.file-detail[param1]=songge
#my.file.file-detail[param2]=18


组件在中的属性问题。
@Data
@Component
@ConfigurationProperties(prefix = "my.file")
public class FileProperties {
    String basePath; //d:/spring/file/
    String jpgPath;//d:/spring/file/jpg/
    String pngPath;//d:/spring/file/png/
    String xmlPath;//d:/spring/file/xml/

    Integer maxFile;
    boolean saved;

    List list1;
    List list2;

    Map map1;
    Map map2;
    FileDetail fileDetail;
}

    • 配置中的引用问题

      my:
  file:
    base-path: e:/springx/file/
    jpg-path: ${my.file.base-path}jpg/
    png-path: ${my.file.base-path}png/
    xml-path: ${my.file.base-path}xml/

  3. @ConfigurationProperties(prefix="demo1.druid")直接标注在配置类上。使属性和properties中的属性值是直接关联的。在需要用的地方，直接是@EnableConfigurationProperties(FileProperties.class)。就可以把这个类引进来。

    配置类：
@Data
@ConfigurationProperties(prefix = "demo1.druid")
public class FileProperties {
    String basePath; //d:/spring/file/
    String jpgPath;//d:/spring/file/jpg/
    String pngPath;//d:/spring/file/png/
    String xmlPath;//d:/spring/file/xml/
    String driver;
    String url;
    String username;
    String password;
    Integer maxFile;
    boolean saved;
    List list1;
    List list2;
    Map map1;
    Map map2;
    FileDetail fileDetail;
}


加载的配置类：
@Data
@Configuration
@EnableConfigurationProperties(FileProperties.class)
public class DruidConfig {
    FileProperties fileProperties;
    public DruidConfig(FileProperties fileProperties) {
        this.fileProperties = fileProperties;
    }
    //@Value("${demo.druid.driver}")

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(fileProperties.driver);
        dataSource.setUrl(fileProperties.url);
        dataSource.setUsername(fileProperties.username);
        dataSource.setPassword(fileProperties.password);
        return dataSource;
    }
}

多个配置文件协调

  • 如下在yml中,也可以写在不同的配置文件中，不同的配置文件中的名字，application-beta.yml。

    激活：spring.profiles.active

    spring:
  profiles:
    active: alpha,context
---
#spring.profiles作为key指定配置文件的名字
spring:
  profiles: alpha
server:
  port: 8081

---
spring:
  profiles: beta
server:
  port: 8082
---
spring:
  profiles: dev
server:
  port: 8083

---
spring:
  profiles: context
server:
  servlet:
    context-path: /demo2

  • 引入额外的properties文件：@PropertySource（value="classpath:db.properties"）

  • 引入额外的spring配置文件：@ImportResource(value="classpath:beans.xml")

springboot的配置问题

主要是约定大于配置：

@ConditionalOn 当满足条件时其他注解生效

@ConditionalOnMissing 当缺少条件时，其他注解生效

//@EnableWebMvc  //意味着全面接管SpringMVC的配置，也就是说配置文件是无效的
@Configuration   //做的是补充，他是和配置文件是结合的。

SpringBoot的注解拓展

  1. @SpringBootApplication
    作用：默认扫描启动类所在的包下的所有层级的子包。
    可以拆分为三个，并且制定扫描的包：
    @SpringBootConfiguration

    @EnableAutoConfiguration

@ComponentScan(basePackages = "com.msb")

@SpringBootApplication
public class Springboot04Application {
    public static void main(String[] args) {
        //返回一个spring容器
        ConfigurableApplicationContext context = SpringApplication.run(Springboot04Application.class, args);
        // 查看所有组件的名
        String[] names = context.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}
  1. @Configuration

如果你在一个类上写好了@component那么这个类自动注入到容器中，并且是以空构造器的方式注入里面。
但是还有一种就是通过配置类的方式。@Configuration 就是注明这个类就是配置类。

但是他标注的配置类，对于容器中注入bean的方式是有区别的。

/**
 * @Author: Ma HaiYang
 * @Description: MircoMessage:Mark_7001
 * MyConfig配置类本身也是一个spring容器中的bean
 * proxyBeanMethods=true 属性,给MyConfig对象产生一个代理对象
 * 通过代理对象控制反复调用MyConfig里面的方法返回的是容器中的一个单实例
 * 如果proxyBeanMethods=false 那么我们拿到的MyConfig对象就不是一个代理对象
 * 那么这个时候反复调用MyConfig中的方法返回的就是多实例
 *
 * proxyBeanMethods=false 称之为Lite模式  特点启动快
 * proxyBeanMethods=true  称之为Full模式  特点依赖spring容器控制bean单例
 *
 */
@Configuration(proxyBeanMethods = true)
public class MyConfig {
    /*<bean id = "user1" class ="com.msb.pojo.User">... ...</bean>*/
    @Bean // 向容器中添加一个Bean,以方法名作为Bean的id,返回值类型作为组件的类型
    public User user1(){
        return new User("zhangsan", 10);
    }
    /*<bean id = "user2" class ="com.msb.pojo.User">... ...</bean>*/
    @Bean("user2") // 向容器中添加一个Bean,手动指定Bean的name属性,返回值类型作为组件的类型
    public User getUser(){
        return new User("lisi", 11);
    }
}


测试部分：
@SpringBootApplication(scanBasePackages = "com.msb")
public class Springboot04Application {
    public static void main(String[] args) {
        //返回一个spring容器
        ConfigurableApplicationContext context = SpringApplication.run(Springboot04Application.class, args);
      
        System.out.println(context.getBean("user1"));
        System.out.println(context.getBean("user2"));
        User usera = context.getBean(MyConfig.class).getUser();
        User userb = context.getBean(MyConfig.class).getUser();
        System.out.println(usera==userb);
    }
}

总结：proxyBeanMethods=true的话，那么下面的获取部分，usera和userb是同一个实例。
    proxyBeanMethods=false的话，那usera和userb的获取的不是同一个实例。

  1. @Import

    感觉这个注解是有点多余啊,其实就是把类放入到容器里面啊。明明@component就可以把类放入到容器里，还需要这个干吗呢

    /*
* @Import({User.class}) 在容器中自动创建Bean的注解
* 通过传入字节码,默认调用bean的无参构造器,向容器中存放一个Bean
* 默认组件的名字就是类的全路径名
* @Import只要放到可以被扫描到的类之上就可以,不必非得是配置类或者Controller
* */
@Import({User.class})
@Configuration(proxyBeanMethods = true)
public class MyConfig {
}

  2. @Conditional 条件装配

    @Bean("user2")
    @ConditionalOnProperty(name = "aaa.b", havingValue = "y")
    public User getUser() {
        return new User(2, "lisi");
    }
//上面的这个的意思是，必须在yml汇总有aaa.b=y这么个配置，才会注入user2到容器里面。
//下面这个的意思是，容器里必须有一个bean他的名字是user2才会把person注入到容器里面。
    @Bean
    @ConditionalOnBean(name = "user2")
    public Person person() {
        return new Person(25, 175);
    }

  1. @ImportResource

    可以把原生的配置文件中的bean，接入到我们的容器里面。

    bean.xml文件中的bean，弄到config文件里。

    @Configuration
@ImportResource("classpath:beans.xml")
public class MyConfig {
}

    1. @ConfigurationProperties 把配置文件中的值，弄到bean里面来。

      • 方式一

        /*prefix前缀,为配置文件中对应的前缀
* 通过前缀找到对应的配置信息后,在根据属性名去注入匹配的数据*/
@ConfigurationProperties( prefix = "user")
@Component
public class User {
    private String uname;
    private int age;
}

      • 方式二

        @ConfigurationProperties( prefix = "user")
public class User {
    private String uname;
    private int age;
}

在类上注入值，但是在配置类上把这个bean注入
@Configuration
/*开启了User的属性自动配置功能并把User自动注册到容器中
* 这个时候,我们的User上就不用加@Component注解了
* 适用于Bean来自于第三方JAR场景
* */
@EnableConfigurationProperties(User.class)
public class MyConfig {
}
posted @ 2022-04-06 22:42  孙立人bc  阅读(57)  评论(0)    收藏  举报