框架技术Spring Boot ---- JavaConfig介绍、Spring创建项目、配置文件.yml

最新推荐文章于 2022-11-10 09:42:57 发布

码农C风

最新推荐文章于 2022-11-10 09:42:57 发布

阅读量1.2k

点赞数 1

分类专栏： JAVAweb 文章标签：后端 spring boot idea java-ee

本文链接：https://blog.csdn.net/a23452/article/details/123765708

版权

JAVAweb 专栏收录该内容

53 篇文章 3 订阅

订阅专栏

SpringBoot框架

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

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.16</version>
</dependency>

如果爆红，那么久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指定位置

   <import resource="classpath:school-context.xml"/>
    <import resource="classpath:student-context.xml"/>

那么使用配置类，也是支持导入其他的配置文件的，使用@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.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>   父项目管理依赖的版本
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.5</version>  下面都会使用该version
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>Cfeng</groupId>
    <artifactId>springboot-02</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  
    <properties>
        <java.version>16</java.version>  这里的版本是16
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>  插件，清理打包等
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </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

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>

    <groupId>Cshen</groupId>
    <artifactId>springboot-03</artifactId>
    <version>1.0-SNAPSHOT</version>


</project>

可以看到上面的项目的核心就是使用了父工程来管理版本，那么直接copy过来即可

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.5</version>
        <relativePath/> 
   </parent>

使用的plugin和java版本的配置还有相关的starter【web和test】等直接copy

    <properties>
        <java.version>16</java.version>
    </properties>
    <dependencies>
        <dependency>
            <!-- web项目的起步依赖 -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </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 确实方便了许多

今天就分享到这里，明天继续多环境配置🎉

码农C风

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
框架技术Spring Boot ---- JavaConfig介绍、Spring创建项目、配置文件.yml

SpringBoot框架内容管理SpringBootSSM --- 繁琐臃肿的配置文件JavaConfig@Configuration 类上方表明为配置类@Bean 声明对象DI 相当于配置文件的bean标签Bean的参数name自定义参数名@ImportResource value导入其他的配置文件容器value= {"","}指定多个文件导入@PropertySource 导入.properties文件@ComponentScan 扫描器注解SpringBoot --- 简化版SpringMV
复制链接

扫一扫