框架技术Spring Boot ---- JavaConfig介绍、Spring创建项目、配置文件.yml
SpringBoot框架
内容管理
- SpringBoot
-
- SSM --- 繁琐臃肿的配置文件
- JavaConfig
-
- @Configuration 类上方表明为配置类
- @Bean 声明对象DI 相当于配置文件的bean标签
-
- Bean的参数name自定义参数名
- @ImportResource value导入其他的配置文件容器
-
- value= {"","}指定多个文件导入
- @PropertySource 导入.properties文件
- @ComponentScan 扫描器注解
- SpringBoot --- 简化版SpringMVC+ Spring
- Spring Boot使用
-
- 使用SpringBoot提供的初始化器
-
- 使用国内镜像https://start.springboot.io
- 使用maven向导创建
- Boot的web示例
- Spring Boot注解
-
- @SpringBootApplication 可以当作配置类使用
-
- @EnableAutoConfiguration
- @ComponentScan
- @SpringBootConfiguration
- Spring Boot配置文件
SpringBoot框架基础介绍
前面一段时间一直在分享前端的知识，确实还是扩展了思维，自从前端工程化之后，使用vue框架，之前的JQuery确实显得没有那么…，前端主要就是模块化，工程化，和后端追求的一样： 那就是代码的复用性
开发项目，最开始就使用最原始的纯servlet，当时所i有的前端代码全部使用response的println方法打印，这样Servlet就十分臃肿，并且前端代码不容易检查错误； 后面使用JSP来简化了 操作，前端页面可以用JSP编写了，可是页面中还是使用了很多的<% ，可读性不好，前后端交互还是不方便【前端不会JSP】，所以可以使用ajax来发送请求，不使用jsp，但是还是不方便；还是会依赖； 使用Vue + SpringBoot分别前后端分离构建项目
SpringBoot
SSM — 繁琐臃肿的配置文件
为什么使用SpringBoot，SSM的弊端？----- 这里很好理解，SSM的一个重要的步骤就是配置文件的编写，非常不方便，
比如博主放在项目的resource-> conf下面的Spring配置文件applicationContext.xml 【配置的信息包括数据源druid对象，sqlSessionFactory对象，可以创建数据库的实例对象，需要的就是mybatis的配置文件和数据源， 配置mapper文件的扫描器，组件扫描器（加注解的类都创建一个实例），然后引入aop的aspectJ，同时配置事务管理对象，配置事务，tx声明自定义的切入点】
还有MVC的配置文件dispatcherServletConfig.xml （配置视图解析器对象， 使用@ResponseBody的注解驱动annotation-driven（mvc命名空间），静态资源配置问题default-servlet-handler； 还有使用其他的组件比如文件上传等的bean对象 ）
mybatis的配置文件mybatis.xml； 数据源配置移动到了Spring中，没有什么了； 在settings中配置开启自动驼峰转换【就是数据中的下划线命名变为驼峰】mapUnderscoreToCameCard； 配置别名，typeAlias中将package指定后，在mapper文件中可以不指定全名， 配置一个pageHelper分页的插件plugin； 还有mapper文件的位置指定，package指定即可mappers标签
Mybatis每一张表的操作文件mapper； mapper的namespace指定包，每一个sql标签比如insert，update，delete等的id对应一个方法即可
还有Maven项目的包管理文件pom.xml， 需要使用dependency标签指定导入的包，可以在properties中使用自定义标签指定版本号，使用${标签}；同时为了能够运行项目时能够解析java包下面的mapper文件，需要配置资源插件，src/main/java和src/main/resources都需要配置
作为web项目，还要配置web.xml， 其中需要配置中央处理器servlet【要创建其实例对象】，如果要获取到Spring容器，那么就使用监听器，通过context-param来指定监听文件的位置； 还需要配置全局的过滤器，字符过滤器
上面所提到的还是基础配置，使用的各种依赖也可能需要在spring中配置；一个项目的业务逻辑还没有开始弄，可能基础配置文件编写就把人弄麻了
JavaConfig
SpringBoot和之前的Spring和SpringMVC不同，springBoot中使用大量的注解，所以在正式介绍Boot之前，先介绍一下JavaConfig； java中本身就有很多的注解，之前的自动引用类型的自动注入DI，就依赖的是java本身的注解@Resoource；【高版本需要导入javax.annotation-api】
javaConfig是Spring提供的使用java类配置容器，就是一个java类就代表一个容器，不再是纯文件的形式； 配置Spring IOC容器的纯java的方法； 在这个java类中可以创建java对象，并且注入spring容器
好处就是： 1. 可以使用OOP的方式，一个配置类可以继承配置类，可以重写方法 2. 避免繁琐的xml配置
将java类当作容器使用，依赖两个注解@Configuration 和@Bean
这里直接在IDEA中创建一个空项目，然后新建一个module；我采用的web-app的模板；使用maven工具； 这里的pom导入的核心的依赖就是spring-context
org.springframework
spring-context
5.3.16
如果爆红，那么久reimport一下； 【可以在settings—> edit --> template中编辑文件模板；这样在一定程度上可以减少SSM的弊端】； 博主设置的快捷键就是ALT + L 新建（因为ins不方便）； ALT + G是生成代码；其余的F2/shift + F6重命名还是相同的
一个JVM进程（理论上一个运行的java程序必定有自己的一个JVM进程）；多个容器就可以有多个对象了，他们在各自的容器中仍然是唯一的单例的。Spring中对象默认单例
这里可以简单回顾一下之前的Spring的配置文件的DI； DI两种： 一种是set注入； 就是通过property属性来指定，ref指代的是对象属性；【必须含有空参的构造方法】；另外一种就是构造注入；通过constructor标签； 同时bean标签的id为自定义名称；class指定类型
<bean class="Cfeng.entity.Student" id="student">
<property name="age" value="20"/>
<property name="name" value="Cfeng"/>
<property name="sex" value="man"/>
</bean>
--------------然后使用test查看容器中的对象---------------
public void testSpring() {
String config = "conf/springContext.xml"; //这里是classPath;是类路径，要加上conf； 就是移动到target中后的路径
ApplicationContext container = new ClassPathXmlApplicationContext(config);
//打印容器中的对象
Arrays.stream(container.getBeanDefinitionNames()).forEach(name -> System.out.println(name + " :" + container.getBean(name)));
}
student :Student{name='Cfeng', age=20, sex='man'}
接下来就是使用javaConfig来代替配置文件的方式了 ； ---- SpringBoot的变革
博主在Cfeng包下面建立 config/SpringConfig — 使用这个类来代表spring的配置文件
@Configuration 类上方表明为配置类
这个注解放在一个普通的java类上面，就表示这个类当作配置文件来使用
@Bean 声明对象DI 相当于配置文件的bean标签
声明对象，并且将对象注入到Spirng容器中； 之前的Spring的配置文件使用的Bean标签； 在config类的方法上面加上该标签之后，就会将该方法返回的对象自动放入Spring的容器中；【和之前的MVC的ResponseBody类似，加上后返回值自动放入请求体】
【这两个标签的配和SpringMVC的注解@Controller和@RequestMapping的配合相同；但是@Controller和@Service和@Component等都是为了创建对象】
package Cfeng.config;
import Cfeng.entity.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @Configuration 注解表示当前类是作为配置文件使用，配置容器
* 位置： 类的上方
* 这个类就相当于之前的springContext.xml
*/
@Configuration
public class SpringConfig {
/**
* 创建方法，方法的返回值就是对象；在方法的上面加上注解@Bean
* 方法的返回值就会被自动注入到容器中
*/
@Bean
public Student createStudent() {
Student student = new Student();
student.setAge(25);
student.setName("Cshen");
student.setSex("woman");
return student;
}
}
这里就成功创建了一个配置类，这个类【spring容器中就创建了一个Student类型的对象】； 那么这个spring容器ApplicationContext就不是之前的配置文件的ClassPathXmlApplicationContext类型； 而是注解的AnnotationConfigApplicationContext类型的spring容器
Ctrl + p可以查看方法的参数，比如ClassPath…的参数就是配置文件； 而Annotation… 的参数就是： String basePackages； 就是配置包； 或者通过反射机制的参数componentclasses ； 也就是当作spring配置文件的类 比如这里就是 SpringConfig.class
@Test
public void testJavaConfig() {
//这里的形式和上面的是相同的，上面的参数就是配置文件，这里的参数就是配置类.class --- 也是数据流
ApplicationContext container = new AnnotationConfigApplicationContext(SpringConfig.class);
//打印容器中的对象
Arrays.stream(container.getBeanDefinitionNames()).forEach(name -> System.out.println(name + " : " + container.getBean(name)));
}
--------------测试的结果--------------
org.springframework.context.annotation.internalConfigurationAnnotationProcessor : org.springframework.context.annotation.ConfigurationClassPostProcessor@bcec361
org.springframework.context.annotation.internalAutowiredAnnotationProcessor : org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor@26794848
org.springframework.context.event.internalEventListenerProcessor : org.springframework.context.event.EventListenerMethodProcessor@302552ec
org.springframework.context.event.internalEventListenerFactory : org.springframework.context.event.DefaultEventListenerFactory@3d285d7e
springConfig : Cfeng.config.SpringConfig$$EnhancerBySpringCGLIB$$c730d0a@40005471
createStudent : Student{name='Cshen', age=25, sex='woman'}
前面的4个对象就是系统配置的对象，后面的SpringConfig就是创建的容器类的对象 — 相当于一个子Spring容器对象； 而CreateStudent 【方法名】 就是创建的对象的id； 所以自定义的id就是方法名；Bean的默认对象的名称是方法名，而不是方法内部对象名
Bean的参数name自定义参数名
上面的默认的名称就是方法名，这还是有一些不便之处，所以这里可以通过name属性自定义id【value参数也可以】
@Bean(name = "myStudent")
public Student createStudent() {
Student student = new Student();
student.setAge(25);
student.setName("Cshen");
student.setSex("woman");
return student;
}
myStudent : Student{name='Cshen', age=25, sex='woman'}
@ImportResource value导入其他的配置文件容器
之前在Spirng部分就讲过; 开发中为了效率，一般是每一个模块都有一个配置文件，最后使用一个总配置文件来导入其他的子配置文件；使用import标签，resources指定位置
那么使用配置类，也是支持导入其他的配置文件的，使用@ImportResources注解即可
//这里创建一个实体类Car，这个car声明在配置文件容器springContext容器中
<bean id="myCar" class="Cfeng.entity.Car">
<property name="name" value="BOMM"/>
<property name="type" value="7系"/>
</bean>
//在SpringConfig中进行指定
@ImportResource(value = "classpath:conf/springContext.xml")
public class SpringConfig {
ImportResources 注解在类的上方, 指定要导入的对象所在的配置文件容器；使用classpath: 表明为类路径
可以查看输出的测试结果
springConfig : Cfeng.config.SpringConfig$$EnhancerBySpringCGLIB$$e3c2a911@8458f04
myStudent : Student{name='Cshen', age=25, sex='woman'}
myCar : Car{name='BOMM', type='7系'}
可以看到这个config就相当于之前的主配置文件，通过ImportResource就可以指定classpath的配置文件的； 将配置文件中的对象放入到springConfig容器中
value= {"","}指定多个文件导入
之前就是在一个文件中可以通过多个import标签导入多个xml文件，同理，这里也是可以导入多个文件的，并且只用在一个ImportResources注解的value属性中指定即可
@PropertySource 导入.properties文件
之前在Spring配置文件中，配置数据源的时候，就会将数据库连接的数据放在db.properties中，在spring中，通过
<context:property-placeholder location="classpath:conf/db.properties"/>
property-placeholder就可以导入属性配置文件； 然后在配置数据源时，可以通过$(…)拿到数据； 那么对于配置类，要引入properties类型的文件，需要使用@PropertySource标签，这里和上面的ImportResource标签类似，都是引入配置文件
使用属性配置文件可以是实现外部化配置，在程序之外提供数据
//这里在resources下面创建一个data.properties，存放一个学生的数据
##### just for a test #########
stu.name = CLei
stu.age = 22
stu.sex = woman
@ComponentScan 扫描器注解
之前使用配置文件的方式的时候，使用注解DI的时候，声明的注解想要被放入对象，必须在spring容器中声明组件扫描器；
<context:component-scan base-package="Jning.service"/>
比如这里就是扫描业务包，将下面的所有带有@Component或者@Service的类都创建一个单例对象； 那么现在使用纯配置类的方式，就需要使用@ComponentScan注解来扫描其他的注解；
value属性就是指定的base-package；
package Cfeng.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
import org.springframework.context.annotation.PropertySource;
/**
* 这里通过注解的方式DI，那么就使用ComponentScan注解来进行注解的扫描
*/
@Configuration
@ImportResource(value = "classpath:conf/springContext.xml")
@PropertySource("classpath:data.properties")
@ComponentScan(basePackages = "Cfeng.entity")
public class SpringConfig {
}
这里的配置类中就没有使用Bean注解，相当于之前的配置文件没有Bean标签，使用了扫描器
这里的这个SpringConfig就相当于是之前的Spring的主配置文件，其中的3个注解分别是组件扫描器，加载子配置文件和声明为配置类； 所以扫描器扫描的时候就可以将加载进来的properties文件的value赋值到对象中中
@Component("myStudent")
public class Student {
@Value("${stu.name}")
private String name;
@Value(value = "${stu.age}")
private Integer age;
@Value("${stu.sex}")
private String sex;
这里的写法和之前的是一模一样的； 那么这样再进行测试
myStudent : Student{name='CLei', age=22, sex='woman'}
所以使用JavaConfig确实简化了配置文件的编写； emmm… SpringBoot就是运用到，接下来就正式康康SpirngBoot
SpringBoot — 简化版SpringMVC+ Spring
Spring团队为了解决配置文件臃肿的问题，就推出了SpringBoot，它可以使用其他的框架已经配置好的配置文件，所以集成了很多东西，不需要用户再敲配置文件【这又好又不好的，不好的是…】，SpringBoot就相当于一个已经配置好了相关对象和库的Spring + SpringMVC
所以说，SpringBoot只是帮助简化了一些操作，但是核心的操作没有变化，比如AOP、 IOC、 DI等，其还是一个容器【之前SpringMVC的容器是Spring的子容器，现在综合成为一个】SpringBoot的核心就是IOC容器
Spring Boot特点：
- Create stand-alone Spring application 创建spring应用
- Embed Tomcat， Jetty or Undertow directly ( no need to deploy WAR files)内嵌了Tomcat、Jetty等服务器【也就是不需要再单独安装Tomcat了】
- Provide opinionated ‘starter’ dependencies to simplify your build configuration 提供了starter起步，简化应用的配置； 【比如使用Mybatis框架、需要在Spring项目中配置sqlSessionFactory、dao代理对象】，而在spring boot中，只要加入mybits-spring-boot-starter依赖项，就可以代替之前的操作，不需要配置
- automatically configure Spring and 3rd party libraries whenever possible 尽可能配置Spring和地方法的库 ----- 自动配置Spring和第三方库的对象，所以使用starter就减少了配置
- provide production-ready features such as metrics，health checks、externalized configuration 提供了一些生产就绪的特点： 比如测量【统计】、健康检查【项目是否正常】、外部化配置【properties】
- Absolutely no code generation and no requirement for XML configuration 无代码生成，不用使用xml进行配置
SpirngBoot的主要特点就是starter、自动配置automatically configure 、内嵌Tomcat
Spring Boot使用
使用SpringBoot提供的初始化器
使用Spring官方提供的初始化器，也就是向导，具体的使用步骤【IDEA中】
new module -> spring initializr【这里不选择maven，选择maven上面那项】 -> 填写信息【type、Group等】 -> 选择依赖
之前的依赖项都需要用户自己去mvn repository中拷贝坐标，在Spring Boot中直接在这个界面选择相关依赖项即可…
这里比如我随便选择一个依赖项Spring-web； 然后就创建了一个项目，可以康康项目的目录结构和之前的使用maven构建SSM项目的目录的异同
Spring initializr创建的项目的结构，.mvn包下面的就是maven相关的文件，wrapper等，mvn功能增强； src下面就是项目的源代码；.gitignore和git工具有关，前端工程化目录结构也有，HElP就帮助文档；mvnw和mvnw.cmd都是增强mvc； pom是项目的包管理配置文件；
真正有关的就是src目录和pom.xml； src下面的resource中static是存放静态资源的【前后端不分离】，templates是存放模板文件的，application.properties是存放的SpringBoot重要的配置项
博主之前分享过vue，vue+ springBoot实现前后端分离创建项目，后端的主要作用就是传递数据，对前端返回数据进行业务处理
实现前后端分离后，有了下面几点改变：
1.服务器一分为二，前后端分别部署，静态资源放在前端服务器，业务代码放在后的服务器
2.前端服务器需要接收Http请求（一般使用node.js）
3.前端服务器需要进行视图解析（可以使用vue.js、angular.js）
4.前端服务器需要处理路由（也就是页面之间的跳转逻辑）
5.后端服务器只需要返回数据
上面几点都提到过，比如路由的router，并且项目上线后通过ngnix来解决跨域问题
这里创建项目主要依赖的网址就是https://start.spring.io
- pom.xml 可以看到pom.xml的父项目parent标签，主要依赖parent来管理依赖，比如spring的版本
<modelVersion>4.0.0modelVersion>
<parent>
<groupId>org.springframework.bootgroupId> 父项目管理依赖的版本
<artifactId>spring-boot-starter-parentartifactId>
<version>2.6.5version> 下面都会使用该version
<relativePath/>
parent>
<groupId>CfenggroupId>
<artifactId>springboot-02artifactId>
<version>0.0.1-SNAPSHOTversion>
<properties>
<java.version>16java.version> 这里的版本是16
properties>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
<build>
<plugins>
<plugin> 插件，清理打包等
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
plugin>
plugins>
build>
打开旁边的maven可以看到加入了jackson、tomcat、spring-web:happy:spring-aop、context、core等等；这里就体现除了起步依赖的强大了，不需要再挨个配置pom了，starter完美解决
使用国内镜像https://start.springboot.io
上面的第二步使用的地址是https://start.spring.io，这是一个国外的地址，可能出现访问的问题；所以替代方式就是使用国内的镜像；其他的步骤相同
需要注意的是，这种方式是需要联网的【没有网络那就不谈】，可以直接访问网址，在浏览器中选择项目的模板结构，可以生成压缩包，导入到IDEA中是相同的效果
使用maven向导创建
这里就建立一个普通的maven项目，不使用模板；创建完成后就src和pom
创建了一个普通的maven项目，可以对比和上面的spring initializr创建的区别，这里就首先修改pom
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0modelVersion>
<groupId>CshengroupId>
<artifactId>springboot-03artifactId>
<version>1.0-SNAPSHOTversion>
project>
可以看到上面的项目的核心就是使用了父工程来管理版本，那么直接copy过来即可
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.6.5version>
<relativePath/>
parent>
使用的plugin和java版本的配置 还有相关的starter【web和test】等直接copy
<properties>
<java.version>16java.version>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
plugin>
plugins>
build>
- 和上面的项目对比，还有的变化就是resources中的结构，现在下面是什么都没有，所以需要手动创建3个目录文件 static templates application.properties 创建即可
这样就通过普通的maven方式创建了项目，不用联网【这个web项目没有webapp文件夹–> WEB-INF下面的lib和web.xml】Spring Boot内置了
Boot的web示例
这里就还是使用上面创建的maven项目，然后创建一个Controller类，处理请求，输出字符串
package Cfeng.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* 这里简单创建一个controller对象来实践web
*/
@Controller
public class SimpleTest {
@RequestMapping("/hello")
@ResponseBody
public String sayHello() {
return "Hello，Welcome, study Spring Boot with Cfeng";
}
}
这里为了运行Spring Boot项目，就按照生成的模板创建一个SpringBootApplication类
package Cfeng;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class BootApplication {
public static void main(String[] args) {
//运行SpringBoot程序
SpringApplication.run(BootApplication.class,args);
}
}
这样就只要运行main，就可以运行boot项目【因为SpringBoot内置了Tomcat服务器，不需要再web下面main目录下建立webapp/WEB-INF/lib和web.xml； 因为之前的Tomcat是分离的，必须要按照Tomcat要求进行配置；这里就不需要【 真的简化了很多】
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.6.5)
2022-03-26 21:42:55.948 INFO 8792 --- [ main] Cfeng.BootApplication : Starting BootApplication using Java 16
Tomcat started on port(s): 8080 (http) with context path '' //运行再8080上，根路径为空
所以我们就可以通过https://localhost:8080/hello访问到上面的处理器方法
打开浏览器就可以显示： Hello，Welcome, study Spring Boot with Cfeng ---- 这和之前的SSMweb项目相比确实简化了很多； 不需要配置中央调度器，SpringBoot将需要的相关配置都弄好了， 只用写业务逻辑
Spring Boot注解
@SpringBootApplication 可以当作配置类使用
上面的web示例就可以看到不管是普通的quick项目，还是web项目，使用Spring Boot构建，都需要通过一个Application类的main方法来启动【启动web会自动开启Tomcat】 这里可以使用CTRL + 鼠标左键 看一下源码
@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 {
这个注解是一个复合的注解@SpringBootConfiguration @EnableAutoConfiguration @ComponentScan三者统一组成
@EnableAutoConfiguration
启用自动配置，也就是将java对象配置好，注入到Spring的容器中，比如将mybatis，jackson等对象放入容器
@ComponentScan
组件扫描器，找到注解，比如上面实例的controller的对象，就是扫描器找到的；默认扫描该注解所在类所在的包和其子包； 所以这个Application起始类必须放在主包下面；博主就放在Cfeng下面；其他的类都在子包中，Cfeng/controller
@SpringBootConfiguration
这个注解从后缀可以看出，和Configuration有关系；打开源码查看
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
可以看到就是@Configuration和@Indexed的符合注解； 所以就相当于之前的JavaConfig，注解就相当于一个Spring容器
所以就可以再Applicatoin主类中声明对象，这些对象都可以注入到Spring容器中； 所以在其中也可以写@Bean
package Cfeng;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import java.util.Date;
@SpringBootApplication
public class BootApplication {
public static void main(String[] args) {
//运行SpringBoot程序
SpringApplication.run(BootApplication.class,args);
}
@Bean("student")
public Date createDate() {
return new Date();
}
}
在test中康康这个容器
@Test
public void testContext() {
ApplicationContext container = new AnnotationConfigApplicationContext(BootApplication.class);
Arrays.stream(container.getBeanDefinitionNames()).forEach(name -> System.out.println(name + " 值为 ： " + container.getBean(name)));
}
}
运行之后意料之中的爆满： 因为SpirngBoot自动配置了很多的依赖对象
org.springframework.context.annotation.internalConfigurationAnnotationProcessor 值为 ： org.springframework.context.annotation.ConfigurationClassPostProcessor@12db3386
org.springframework.context.annotation.internalAutowiredAnnotationProcessor 值为 ： org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor@4078695f
org.springframework.context.annotation.internalCommonAnnotationProcessor 值为 ： org.springframework.context.annotation.CommonAnnotationBeanPostProcessor@79a1728c
org.springframework.context.event.internalEventListenerProcessor 值为 ： org.springframework.context.event.EventListenerMethodProcessor@a7f0ab6
org.springframework.context.event.internalEventListenerFactory 值为 ： org.springframework.context.event.DefaultEventListenerFactory@41f35f7c
bootApplication 值为 ： Cfeng.BootApplication$$EnhancerBySpringCGLIB$$748c4d71@42c2f48c
simpleTest 值为 ： Cfeng.controller.SimpleTest@3005db4a
student 值为 ： Sat Mar 26 22:12:46 CST 2022
org.springframework.boot.autoconfigure.AutoConfigurationPackages 值为 ： org.springframework.boot.autoconfigure.AutoConfigurationPackages$BasePackages@425d5d46
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration@198ef2ce
propertySourcesPlaceholderConfigurer 值为 ： org.springframework.context.support.PropertySourcesPlaceholderConfigurer@4cbd03e7
org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration@52fc5eb1
taskExecutorBuilder 值为 ： org.springframework.boot.task.TaskExecutorBuilder@7a639ec5
22:12:47.340 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'applicationTaskExecutor'
22:12:47.341 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Autowiring by type from bean name 'applicationTaskExecutor' via factory method to bean named 'taskExecutorBuilder'
22:12:47.354 [main] DEBUG org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor - Initializing ExecutorService 'applicationTaskExecutor'
applicationTaskExecutor 值为 ： org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor@392a04e7
org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor 值为 ： org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor@7f02251
org.springframework.boot.context.internalConfigurationPropertiesBinderFactory 值为 ： org.springframework.boot.context.properties.ConfigurationPropertiesBinder$Factory@dffa30b
org.springframework.boot.context.internalConfigurationPropertiesBinder 值为 ： org.springframework.boot.context.properties.ConfigurationPropertiesBinder@4d8126f
org.springframework.boot.context.properties.BoundConfigurationProperties 值为 ： org.springframework.boot.context.properties.BoundConfigurationProperties@6d3c232f
org.springframework.boot.context.properties.EnableConfigurationPropertiesRegistrar.methodValidationExcludeFilter 值为 ： org.springframework.boot.validation.beanvalidation.MethodValidationExcludeFilter$$Lambda$524/0x0000000800dc5f80@6b587673
spring.task.execution-org.springframework.boot.autoconfigure.task.TaskExecutionProperties 值为 ： org.springframework.boot.autoconfigure.task.TaskExecutionProperties@1bcf67e8
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$ClassProxyingConfiguration 值为 ： org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$ClassProxyingConfiguration@5f404594
forceAutoProxyCreatorToUseClassProxying 值为 ： org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$ClassProxyingConfiguration$$Lambda$485/0x0000000800da5420@53692008
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.aop.AopAutoConfiguration@7b2a3ff8
org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration@1bbae752
applicationAvailability 值为 ： org.springframework.boot.availability.ApplicationAvailabilityBean@71a9b4c7
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$Jackson2ObjectMapperBuilderCustomizerConfiguration 值为 ： org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$Jackson2ObjectMapperBuilderCustomizerConfiguration@460b6d54
standardJacksonObjectMapperBuilderCustomizer 值为 ： org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$Jackson2ObjectMapperBuilderCustomizerConfiguration$StandardJackson2ObjectMapperBuilderCustomizer@5cf87cfd
spring.jackson-org.springframework.boot.autoconfigure.jackson.JacksonProperties 值为 ： org.springframework.boot.autoconfigure.jackson.JacksonProperties@76075d65
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperBuilderConfiguration 值为 ： org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperBuilderConfiguration@3a4ba480
jacksonObjectMapperBuilder 值为 ： org.springframework.http.converter.json.Jackson2ObjectMapperBuilder@4455f57d
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$ParameterNamesModuleConfiguration 值为 ： org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$ParameterNamesModuleConfiguration@29fc1a2b
parameterNamesModule 值为 ： com.fasterxml.jackson.module.paramnames.ParameterNamesModule@5553d0f5
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperConfiguration 值为 ： org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperConfiguration@4d0b0fd4
jacksonObjectMapper 值为 ： com.fasterxml.jackson.databind.ObjectMapper@7a24eb3
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration@6c37bd27
jsonComponentModule 值为 ： org.springframework.boot.jackson.JsonComponentModule@25d3cfc8
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration@30331109
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration@2571066a
lifecycleProcessor 值为 ： org.springframework.context.support.DefaultLifecycleProcessor@74fe5966
spring.lifecycle-org.springframework.boot.autoconfigure.context.LifecycleProperties 值为 ： org.springframework.boot.autoconfigure.context.LifecycleProperties@4fe875be
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration$StringHttpMessageConverterConfiguration 值为 ： org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration$StringHttpMessageConverterConfiguration@677b8e13
stringHttpMessageConverter 值为 ： org.springframework.http.converter.StringHttpMessageConverter@1a5b8489
org.springframework.boot.autoconfigure.http.JacksonHttpMessageConvertersConfiguration$MappingJackson2HttpMessageConverterConfiguration 值为 ： org.springframework.boot.autoconfigure.http.JacksonHttpMessageConvertersConfiguration$MappingJackson2HttpMessageConverterConfiguration@4a9486c0
mappingJackson2HttpMessageConverter 值为 ： org.springframework.http.converter.json.MappingJackson2HttpMessageConverter@6f8f8a80
org.springframework.boot.autoconfigure.http.JacksonHttpMessageConvertersConfiguration 值为 ： org.springframework.boot.autoconfigure.http.JacksonHttpMessageConvertersConfiguration@4c27d39d
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration@40ee0a22
messageConverters 值为 ： org.springframework.boot.autoconfigure.http.HttpMessageConverters@7bde1f3a
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration@15923407
spring.info-org.springframework.boot.autoconfigure.info.ProjectInfoProperties 值为 ： org.springframework.boot.autoconfigure.info.ProjectInfoProperties@67dba613
org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration@57540fd0
spring.sql.init-org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties 值为 ： org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties@5cf8edcf
org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer$DependsOnDatabaseInitializationPostProcessor 值为 ： org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer$DependsOnDatabaseInitializationPostProcessor@58cec85b
org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration@629f066f
scheduledBeanLazyInitializationExcludeFilter 值为 ： org.springframework.boot.autoconfigure.task.ScheduledBeanLazyInitializationExcludeFilter@1542af63
taskSchedulerBuilder 值为 ： org.springframework.boot.task.TaskSchedulerBuilder@ecfbe91
spring.task.scheduling-org.springframework.boot.autoconfigure.task.TaskSchedulingProperties 值为 ： org.springframework.boot.autoconfigure.task.TaskSchedulingProperties@20ed3303
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration 值为 ： org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration@3adbe50f
22:12:47.359 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'restTemplateBuilderConfigurer'
restTemplateBuilderConfigurer 值为 ： org.springframework.boot.autoconfigure.web.client.RestTemplateBuilderConfigurer@3eed0f5
22:12:47.361 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'restTemplateBuilder'
22:12:47.362 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Autowiring by type from bean name 'restTemplateBuilder' via factory method to bean named 'restTemplateBuilderConfigurer'
restTemplateBuilder 值为 ： org.springframework.boot.web.client.RestTemplateBuilder@319854f0
org.springframework.aop.config.internalAutoProxyCreator 值为 ： proxyTargetClass=true; optimize=false; opaque=false; exposeProxy=false; frozen=false
这里我将它放出来，可以看到我们自定义的student对象确实成功创建，还有和之前的配置相同，创建了类名相同的spring容器对象
bootApplication 值为 ： Cfeng.BootApplication$$EnhancerBySpringCGLIB$$748c4d71@42c2f48c
simpleTest 值为 ： Cfeng.controller.SimpleTest@3005db4a
student 值为 ： Sat Mar 26 22:12:46 CST 2022
这三个简单的就是： Spring容器对象，控制层的处理器对象【相当于之前的Servlet实例】、放入的student对象
分析上面的其他对象，就可以看到很多常见的依赖包的对象 比如aop web等
综上所述，Boot的起始类的注解@SpringBootConfiguration由
@SpringBootConfiguration @EnableAutoConfiguration @ComponentScan
共同组成，第一个是将该类当作Spring的容器，第二个是自动配置，第三个是自动扫描器； 所以Spring的核心功能的完成就依靠这个注解； 所以起始类就是一个自动配置的带有扫描器的一个配置类【JavaConfig】
Spring Boot配置文件
Spring Boot的配置文件就是指之前放在Resource下面Application.properties文件，配置文件主要两种格式；一种就是.properties，另外一种就是.yml；现在趋于.yml
//properties格式
key=value
//yml格式
key: value
配置文件主要用于配置Spring Boot程序，必须以application开始
配置文件可以设置application的很多参数，比如运行的默认端口号，还有根路径等
#######Spring Boot配置文件#######
##设置端口号####
server:
port: 8081
servlet:
context-path: /mySpringBoot #上下文路径
yml是一种哦yaml格式的配置文件，主要采用了空格、换行的方式，可以看出层级，能够直观被计算机是被的数据序列化格式，比xml简洁许多，从2.4开始，如果两种类型的文件同时存在，默认采用yml格式，之前是properties
配置之后，访问之前的页面localhost:8081/mySpringBoot/hello 确实方便了许多
今天就分享到这里，明天继续多环境配置