SPRINGBOOT02_概述入门案例父项目依赖管理特性@Configuration@Import@Conditional@ConfigurationProperties配置绑定

Posted 2022-08-30 所得皆惊喜

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SPRINGBOOT02_概述入门案例父项目依赖管理特性@Configuration@Import@Conditional@ConfigurationProperties配置绑定相关的知识，希望对你有一定的参考价值。

文章目录

①. SpringBoot - 概述
②. HelloWorld - 项目
③. 父项目依赖管理特性
④. 底层注解@Configuration
⑤. 底层注解@Import导入组件
⑥. 底层注解@Conditional条件装配
⑦. 原生配置文件引入 ImportResource
⑧. 底层注解@ConfigurationProperties配置绑定

①. SpringBoot - 概述

①. Spring Boot是一个便捷搭建基于spring工程的脚手架,是整合Spring技术栈的一站式框架
②. 作用

帮助开发人员快速搭建大型的spring项目
简化工程的配置,依赖管理
实现开发人员把时间都集中在业务开发上

③. 缺点:

人称版本帝,迭代快,需要时刻关注变化
封装太深,内部原理复杂,不容易精通

④.SrpingBoot官网文档
⑤. 查看版本新特性

②. HelloWorld - 项目

①. Maven配置文件新添内容:

<mirrors>
	<mirror>
		<id>nexus-aliyun</id>
		<mirrorOf>central</mirrorOf>
		<name>Nexus aliyun</name>
		<url>http://maven.aliyun.com/nexus/content/groups/public</url>
	</mirror>
</mirrors>

<profiles>
	<profile>
		<id>jdk-1.8</id>

		<activation>
			<activeByDefault>true</activeByDefault>
			<jdk>1.8</jdk>
		</activation>

		<properties>
			<maven.compiler.source>1.8</maven.compiler.source>
			<maven.compiler.target>1.8</maven.compiler.target>
			<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
		</properties>
	</profile>
</profiles>

②. 需求:浏览发送/hello请求,响应"Hello,Spring Boot 2”
如何快速搭建helloWorld项目官方文档
③. 引入依赖

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>

    <dependencies>
        <!--web场景-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <!--这个插件,可以将应用打包成一个可执行的jar包-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

④. 创建主程序

将主配置类(@SpringBootApplication标注的类)的所在包及下面所有子包里面的所有组件扫描到Spring容器
想要改变扫描路径
@SpringBootApplication(scanBasePackages=“com.lun”)
@ComponentScan指定扫描路径,这个不能和@SpringBootApplication一起使用

//@SpringBootApplication 等同于如下三个注解
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com")//可以扫描com及com下的所有包
public class MainApplication 
    public static void main(String[] args) 
        SpringApplication.run(MainApplication.class,args);

⑤. 编写业务
更多配置信息官方文档

@RestController
public class HelloController 
    @RequestMapping("/hello")
    public String handle01()
        return "Hello, Spring Boot 2!";

server:
  port: 8888

⑥. 运行&测试
运行MainApplication类
浏览器输入http://localhost:8888/hello,将会输出Hello,Spring Boot 2!
⑦. 运用springboot提供的插件进行打包处理,进行maven的打包
用cmd运行java -jar boot-01-helloworld-1.0-SNAPSHOT.jar,既可以运行helloworld工程项目

    <!--这个插件,可以将应用打包成一个可执行的jar包-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

③. 父项目依赖管理特性

①. 父项目做依赖管理

<!--依赖管理-->
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.3.4.RELEASE</version>
</parent>

<!--上面项目的父项目如下-->
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-dependencies</artifactId>
	<version>2.3.4.RELEASE</version>
</parent>
<!--它几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制-->

②. Spring Boot将所有的功能场景都抽取出来,做成一个个的starters(启动器),只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器

见到很多 spring-boot-starter-* :*代表某种场景
只要引入starter,这个场景的所有常规需要的依赖我们都自动引入
SpringBoot所有支持的场景
见到的 *-spring-boot-starter:第三方为我们提供的简化开发的场景启动器

	<!--所有场景启动器最底层的依赖-->
	<dependency>
	  <groupId>org.springframework.boot</groupId>
	  <artifactId>spring-boot-starter</artifactId>
	  <version>2.3.4.RELEASE</version>
	  <scope>compile</scope>
	</dependency>

③. 无需关注版本号,自动版本仲裁

引入依赖默认都可以不写版本
引入非版本仲裁的jar,要写版本号

④. 底层注解@Configuration

①. 关于Configuration详解

Full(proxyBeanMethods = true)(保证每个@Bean方法被调用多少次返回的组件都是单实例的)(默认)
Lite(proxyBeanMethods = false)(每个@Bean方法被调用多少次返回的组件都是新创建的)

/**
(1). 配置类里面使用@Bean标注在方法上给容器注册组件,默认也是单实例的
(2). 配置类本身也是组件
(3). proxyBeanMethods:代理bean的方法(说的是被调用的方法)
     Full(proxyBeanMethods = true)(保证每个@Bean方法被调用多少次返回的组件都是单实例的)(默认)
     Lite(proxyBeanMethods = false)(每个@Bean方法被调用多少次返回的组件都是新创建的)
     proxyBeanMethods = false,如果别人不用,设置为false,会变得快,减少了这个检查的过程
 */
@SuppressWarnings("all")
@Configuration(proxyBeanMethods = true) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig 

    //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值,就是组件在容器中的实例
    @Bean
    public User user01()
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    
    @Bean("tom")
    public Pet tomcatPet()
        return new Pet("tomcat");

@SpringBootApplication
//等同于如下三个注解
//@SpringBootConfiguration
//@EnableAutoConfiguration
//@ComponentScan("com")//可以扫描com及com下的所有包
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);
        
        //3.从容器中获取组件
        Pet tomcat1 = run.getBean("tom", Pet.class);
        Pet tomcat2 = run.getBean("tom", Pet.class);
        System.out.println(tomcat1==tomcat2);
        //4、com.xiaozhi.config.MyConfig@2def7a7a
        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        /**
         * 如果@Configuration(proxyBeanMethods = true)代理对象调用方法
         * SpringBoot总会检查这个组件是否在容器中有。
         * 保持组件单实例
         * */
        User user = bean.user01();
        User user1 = bean.user01();
        System.out.println(user == user1);

        User user01 = run.getBean("user01", User.class);
        Pet tom = run.getBean("tom", Pet.class);
        System.out.println("用户的宠物："+(user01.getPet() == tom));

②. 最佳实战

配置类组件之间无依赖关系用Lite模式加速容器启动过程,减少判断
配置类组件之间有依赖关系,方法会被调用得到之前单实例组件,用Full模式(默认)

⑤. 底层注解@Import导入组件

①. @Import(User.class, DBHelper.class)给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
②. 代码展示如下

	@Import(User.class, DBHelper.class)
	@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
	public class MyConfig

	//1、返回我们IOC容器
	ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
	//...
	//5、获取组件
	String[] beanNamesForType = run.getBeanNamesForType(User.class);
	for (String s : beanNamesForType) 
 		//com.xiaozhi.bean.User
	    //user01
	    System.out.println(s);
	
	DBHelper bean1 = run.getBean(DBHelper.class);
	//ch.qos.logback.core.db.DBHelper@188cbcde
	System.out.println(bean1);

⑥. 底层注解@Conditional条件装配

①. 条件装配:满足Conditional指定的条件,则进行组件注入
②. 用@ConditionalOnMissingBean举例说明

@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
//有tom名字的Bean时,MyConfig类的Bean才能生效
@ConditionalOnBean(name="tom")
public class MyConfig 

    //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值,就是组件在容器中的实例
    @Bean
    //当容器中有tom组件的时候,才给注册user01
    //@ConditionalOnBean(name="tom")
    public User user01()
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    
    //@Bean("tom")
    @Bean("tom2")
    public Pet tomcatPet()
        return new Pet("tomcat");

@SpringBootApplication
//等同于如下三个注解
//@SpringBootConfiguration
//@EnableAutoConfiguration
//@ComponentScan("com")//可以扫描com及com下的所有包
public class MainApplication 
    public static void main(String[] args) 
        //1.返回我们的IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        boolean tomFlag = run.containsBean("tom");
        System.out.println("容器中是否有tom组件"+tomFlag);//false
        boolean user01Flag = run.containsBean("user01");
        System.out.println("容器中是否有user01组件"+user01Flag);//true
        boolean tom2 = run.containsBean("tom2");
        System.out.println("容器中tom2组件："+tom2);//true

⑦. 原生配置文件引入 ImportResource

①. 比如,公司使用bean.xml文件生成配置bean,然而你为了省事,想继续复用bean.xml,这个时候可以使用@ImportResource

<?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-2.5.xsd">
    <bean id="hehe" class="com.xiaozhi.bean.User">
        <property name="name" value="TANGZHI"></property>
        <property name="age" value="24"></property>
    </bean>
    <bean id="haha" class="com.xiaozhi.bean.Pet">
        <property name="name" value="dog"></property>
    </bean>
</beans>

@ImportResource("classpath:bean.xml")//比如,公司使用bean.xml文件生成配置bean,然而你为了省事,想继续复用bean.xml,@ImportResource粉墨登场。
public class MyConfig

    //引入了importResource
    boolean hehe = run.containsBean("hehe");
    System.out.println("容器中是否有hehe组件"+hehe);//true
    boolean haha = run.containsBean("haha");
    System.out.println("容器中是否有haha组件"+haha);//true

⑧. 底层注解@ConfigurationProperties配置绑定

①. 方式一:@ConfigurationProperties + @Component

@Data
@NoArgsConstructor
@AllArgsConstructor
/**
 * 注意: 只有在容器中的组件,才会拥有SpringBoot提供的强大功能
 */
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car 
    private String branch;
    private String price;

# application.yaml
server:
  port: 8888
mycar:
  branch: "雅阁"
  price: "20w"

@RestController
public class myController 
    @Autowired
    Car car;
    @GetMapping("/car")
    public Car getMyCar()
        return car;

②. 方式二:@EnableConfigurationProperties + @ConfigurationProperties

/**
 * EnableConfigurationProperties做了两件事情
 * (1). 开启Car配置绑定功能
 * (2). 把这个Car这个组件自动注册到容器中
 */
@EnableConfigurationProperties(Car.class)
public class MyConfig

@Data
@NoArgsConstructor
@AllArgsConstructor
/**
 * 注意: 只有在容器中的组件,才会拥有SpringBoot提供的强大功能
 */
//@Component
@ConfigurationProperties(prefix = "mycar")
public class Car 
    private String branch;
    private String price;

③. 问题:如果出现如下提示,项目也可以运行
解决方案：如果要去掉上述的提示,则可以在 pom.xml 文件中添加如下依赖：

    <dependency>
        <groupId> org.springframework.boot </groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <!--不传递依赖-->
        <optional&g以上是关于SPRINGBOOT02_概述入门案例父项目依赖管理特性@Configuration@Import@Conditional@ConfigurationProperties配置绑定的主要内容，如果未能解决你的问题，请参考以下文章 
 SpringBoot入门案例后的4个问题
 springboot入门案例
 springBoot
 springboot基础篇（快速入门 + 完整项目案例）
 阶段3 1.Mybatis_02.Mybatis入门案例_3 mybatis注解开发和编写dao实现类的方式
 搭建一个入门springboot工程