需求/图解说明

构建一个SpringBoot项目, 浏览器发送hello请求[http://localhost:8080/hello], 响应 Hello SpringBoot

完成步骤

1.确认开发环境是jdk 8或以上, maven在3.5+

2.创建maven项目

3.在pom.xml引入SpringBoot父工程和web项目场景启动器
父工程概念

<?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>com.zzw</groupId>
    <artifactId>quickStart</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!--导入springboot父工程-规定写法[在mybatis中讲过]-->
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.5.3</version>
    </parent>

    <!--导入web项目场景启动器: 会自动导入和web开发相关的所有依赖[库/jar]
    后面还会说明spring-boot-starter-web 到底引入哪些相关依赖-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

4.创建com.zzw.springboot.MainApp.java SpringBoot引用主程序

/**
 * @SpringBootApplication: 表示这是一个springboot引用/项目
 */
@SpringBootApplication
public class MainApp {
    public static void main(String[] args) {
        //启动springboot应用程序/项目
        SpringApplication.run(MainApp.class, args);
    }
}

5.创建com.zzw.springboot.controller.HelloController.java 控制器

@Controller
public class HelloController {

    //写一个方法, 返回hello,springboot
    @RequestMapping(value = "/hello")
    @ResponseBody
    public String hello() {
        return "hello~, springboot";
    }
}

6.运行MainApp.java, 完成测试, 浏览器访问 http://localhost:8080/hello

快速入门小结

1.SprintBoot比较传统的SSM开发, 简化整合步骤, 提高开发效率.
2.简化了Maven项目的pom.xml依赖导入, 可以说是一键导入

3.引入一个spring-boot-start-web, 到底发生了什么? 一图胜千言

4.内置Tomcat, 简化服务器的配置
5.当然SpringBoot还有很多优势, 后面逐步讲解.

Spring SpringMVC SpringBoot的关系

梳理关系

Spring SpringMVC SprintBoot的关系

1.它们大概的关系是: Spring Boot > Spring > Spring MVC
拓展: Spring MVC -> Servlet -> Java Web -> java基础

2.SpringMVC只是Spring处理WEB层请求的一个模块/组件, Spring MVC的基石是Servlet

3.Spring的核心是IOC和AOP, IOC提供了依赖注入的 容器, AOP解决了面向切面编程

4.Spring Boot是为了简化开发, 推出的 封神框架( 约定优于配置[COC], 简化了Spring项目的配置流程), SpringBoot包含很多组件/框架, Spring就是最核心的内容之一, 也包含Spring MVC

5.Spring家族, 有众多衍生框架和组件例如 boot, security, jpa等, 它们的基础都是Spring

如何理解 -约定优于配置

1.约定优于配置(Convention over Configuration/COC), 又称按约定编程, 是一种软件设计规范, 本质上是对系统, 类库或框架中一些东西假定一个大众合理的默认值[缺省值]
2.例如在模型中存在一个名为User的类, 那么对应到数据库会存在一个名为user的表, 只有在偏离这个约定时才需要做相关的配置 (例如你想将表名命名为t_user等非user时才需要写关于这个名字的配置)
3.简单来说就是假如你所期待的配置与约定的配置一致, 那么就可以不做任何配置, 约定不符合期待时, 才需要对约定进行替换配置

4.约定优于配置理念[解读: 为什么要搞一个约定优于配置]
约定其实就是一种规范, 遵循了规范, 那么就存在通用性, 存在通用性, 那么事情就会变得相对简单, 程序员之间的沟通成本会降低, 工作效率会提升, 合作也会变得更加简单.

依赖管理和自动配置

依赖管理

什么是依赖管理

1.spring-boot-starter-parent 还有父项目, 声明了开发中常用的版本号.

2.并且进行 自动版本仲裁, 即如果程序员没有指定某个依赖 jar 的版本, 则以父项目指定的版本为准.

修改自动仲裁/默认版本号

1.需求说明: 将SpringBoot mysql驱动修改成 5.1.49

2.查看spring-boot-dependencies.pom里面规定的当前依赖 的版本 的对应的 key, 这里是 mysql.version

3.修改quickstart/pom.xml, 重写配置, 当更新Maven时, 就依赖到新的mysql驱动. 一句话: 父项目不能动, 两种方案均是修改本项目的pom文件.

两种方案

方式1

<dependencies>
    <!--我们自己指定mysql/驱动版本, 即修改版本仲裁
    1.方式1: 显示地导入mysql依赖, 并明确地指定version
    2.方式2: 在自己的pom.xml文件, 在<properties> 中指定mysql的key
    形如:
    <properties>
        <mysql.version>5.1.49</mysql.version>
    </properties>
    3.为什么可以达到修改版本仲裁: 根据依赖就近优先原则.
    -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.49</version>
    </dependency>
</dependencies>

方式2 在自己的pom.xml文件, 在<properties> 节点中指定mysql的key

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!--这里我们可以指定mysql.version-->
    <mysql.version>5.1.49</mysql.version>
</properties>

<dependencies>
    <!--我们自己指定mysql/驱动版本, 即修改版本仲裁
    1.方式1: 显示地导入mysql依赖, 并明确地指定version
    2.方式2: 在自己的pom.xml文件, 在<properties> 中指定mysql的key
    形如:
    <properties>
        <mysql.version>5.1.49</mysql.version>
    </properties>
    3.为什么可以达到修改版本仲裁: 根据依赖就近优先原则.
    -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

starter场景启动器

starter场景启动器基本介绍

1.开发中我们引入相关场景的starter, 这个场景中所有的相关依赖都引入进来了, 比如我们做web开发引入了spring-boot-starter-web, 该starter将导入与web开发相关的所有包.

2.依赖树: 可以看到 spring-boot-starter-web, 帮我们导入了spring-web, spring-webmvc开发模块, 还导入了tomcat的场景启动器spring-boot-starter-tomcat, spring-boot-starter-json场景, 这些场景下面又引出了一大堆相关的包, 这些依赖项可以快速启动和运行一个项目, 提高开发效率.

3.所有场景启动器最基本的依赖就是spring-boot-starter, 前面的依赖树分析可以看到, 这个依赖也就是SpringBoot自动配置的核心依赖

官方提供的starter

地址: https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters

介绍:
1.在开发中我们经常会用到spring-boot-starter-xxx, 比如spring-boot-starter-web, 该场景是用作web开发, 也就是说xxx是某种开发场景.

2.我们只需要引入starter, 这个场景的所有常规需要的依赖我们都自动引入.

3.SpringBoot2支持的所有场景如下:

第三方starter

1.SpringBoot也支持第三方starter

2.第三方starter不会从spring-boot开始, 因为这是官方spring-boot保留的命名方式. 第三方启动程序通常以项目名称开头. 例如, 名为 thirdpartyproject 的第三方启动程序项目通常被命名为 thirdpartyproject-spring-boot-starter.

3.也就是说: xxx-spring-boot-starter是第三方为我们提供的简化开发的场景启动器.

自动配置

自动配置基本介绍

1.小伙伴还记得否, 前面学习SSM整合时, 需要配置Tomcat, 配置SpringMVC, 配置如何扫描包, 配置字符过滤器, 配置视图解析器, 文件上传等, 非常麻烦[如图]. 而在SpringBoot中, 存在自动配置机制, 提高开发效率.

2.简单回顾以前SSM整合的配置.

SpringBoot自动配置了哪些?

1.自动配置Tomcat

2.自动配置SpringMVC

3.自动配置Web常用功能: 比如字符过滤器. 提示: 通过获取ioc容器, 查看容器创建的组件来验证
修改D:\idea_project\zzw_springboot\quickstart\src\main\java\com\zzw\springboot\MainApp.java

/**
 * @SpringBootApplication: 表示这是一个springboot引用/项目
 */
@SpringBootApplication
public class MainApp {
    public static void main(String[] args) {
        //启动springboot应用程序/项目
        ApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        //如何查看容器中注入的组件
        //① 打断点
        //② 写代码
        String[] beanDefinitionNames = ioc.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println("beanDefinitionName=" + beanDefinitionName);
        }
    }
}

beanDefinitionName=org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanDefinitionName=org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanDefinitionName=org.springframework.context.annotation.internalCommonAnnotationProcessor
beanDefinitionName=org.springframework.context.event.internalEventListenerProcessor
beanDefinitionName=org.springframework.context.event.internalEventListenerFactory
beanDefinitionName=mainApp
beanDefinitionName=org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory
beanDefinitionName=helloController 控制器
beanDefinitionName=org.springframework.boot.autoconfigure.AutoConfigurationPackages
beanDefinitionName=org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration
beanDefinitionName=propertySourcesPlaceholderConfigurer
beanDefinitionName=org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration$TomcatWebSocketConfiguration
beanDefinitionName=websocketServletWebServerCustomizer
beanDefinitionName=org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryConfiguration$EmbeddedTomcat
beanDefinitionName=tomcatServletWebServerFactory
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration
beanDefinitionName=servletWebServerFactoryCustomizer
beanDefinitionName=tomcatServletWebServerFactoryCustomizer
beanDefinitionName=org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor
beanDefinitionName=org.springframework.boot.context.internalConfigurationPropertiesBinderFactory
beanDefinitionName=org.springframework.boot.context.internalConfigurationPropertiesBinder
beanDefinitionName=org.springframework.boot.context.properties.BoundConfigurationProperties
beanDefinitionName=org.springframework.boot.context.properties.EnableConfigurationPropertiesRegistrar.methodValidationExcludeFilter
beanDefinitionName=server-org.springframework.boot.autoconfigure.web.ServerProperties
beanDefinitionName=webServerFactoryCustomizerBeanPostProcessor
beanDefinitionName=errorPageRegistrarBeanPostProcessor
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration$DispatcherServletConfiguration
beanDefinitionName=dispatcherServlet 前端控制器
beanDefinitionName=spring.mvc-org.springframework.boot.autoconfigure.web.servlet.WebMvcProperties
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration$DispatcherServletRegistrationConfiguration
beanDefinitionName=dispatcherServletRegistration
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration
beanDefinitionName=org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration
beanDefinitionName=taskExecutorBuilder
beanDefinitionName=applicationTaskExecutor
beanDefinitionName=spring.task.execution-org.springframework.boot.autoconfigure.task.TaskExecutionProperties
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration$WhitelabelErrorViewConfiguration
beanDefinitionName=error
beanDefinitionName=beanNameViewResolver 自定义视图解析器
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration$DefaultErrorViewResolverConfiguration
beanDefinitionName=conventionErrorViewResolver
beanDefinitionName=spring.resources-org.springframework.boot.autoconfigure.web.ResourceProperties
beanDefinitionName=spring.web-org.springframework.boot.autoconfigure.web.WebProperties
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration
beanDefinitionName=errorAttributes
beanDefinitionName=basicErrorController
beanDefinitionName=errorPageCustomizer
beanDefinitionName=preserveErrorControllerTargetClassPostProcessor
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration$EnableWebMvcConfiguration
beanDefinitionName=requestMappingHandlerAdapter
beanDefinitionName=requestMappingHandlerMapping
beanDefinitionName=welcomePageHandlerMapping
beanDefinitionName=localeResolver
beanDefinitionName=themeResolver
beanDefinitionName=flashMapManager
beanDefinitionName=mvcConversionService
beanDefinitionName=mvcValidator
beanDefinitionName=mvcContentNegotiationManager
beanDefinitionName=mvcPatternParser
beanDefinitionName=mvcUrlPathHelper
beanDefinitionName=mvcPathMatcher
beanDefinitionName=viewControllerHandlerMapping
beanDefinitionName=beanNameHandlerMapping
beanDefinitionName=routerFunctionMapping
beanDefinitionName=resourceHandlerMapping
beanDefinitionName=mvcResourceUrlProvider
beanDefinitionName=defaultServletHandlerMapping
beanDefinitionName=handlerFunctionAdapter
beanDefinitionName=mvcUriComponentsContributor
beanDefinitionName=httpRequestHandlerAdapter
beanDefinitionName=simpleControllerHandlerAdapter
beanDefinitionName=handlerExceptionResolver
beanDefinitionName=mvcViewResolver
beanDefinitionName=mvcHandlerMappingIntrospector
beanDefinitionName=viewNameTranslator
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration$WebMvcAutoConfigurationAdapter
beanDefinitionName=defaultViewResolver
beanDefinitionName=viewResolver
beanDefinitionName=requestContextFilter
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
beanDefinitionName=formContentFilter
beanDefinitionName=org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration
beanDefinitionName=mbeanExporter
beanDefinitionName=objectNamingStrategy
beanDefinitionName=mbeanServer
beanDefinitionName=org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration
beanDefinitionName=springApplicationAdminRegistrar
beanDefinitionName=org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$ClassProxyingConfiguration
beanDefinitionName=forceAutoProxyCreatorToUseClassProxying
beanDefinitionName=org.springframework.boot.autoconfigure.aop.AopAutoConfiguration
beanDefinitionName=org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration
beanDefinitionName=applicationAvailability
beanDefinitionName=org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$Jackson2ObjectMapperBuilderCustomizerConfiguration
beanDefinitionName=standardJacksonObjectMapperBuilderCustomizer
beanDefinitionName=spring.jackson-org.springframework.boot.autoconfigure.jackson.JacksonProperties
beanDefinitionName=org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperBuilderConfiguration
beanDefinitionName=jacksonObjectMapperBuilder
beanDefinitionName=org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$ParameterNamesModuleConfiguration
beanDefinitionName=parameterNamesModule
beanDefinitionName=org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration$JacksonObjectMapperConfiguration
beanDefinitionName=jacksonObjectMapper
beanDefinitionName=org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration
beanDefinitionName=jsonComponentModule
beanDefinitionName=org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration
beanDefinitionName=org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration
beanDefinitionName=lifecycleProcessor
beanDefinitionName=spring.lifecycle-org.springframework.boot.autoconfigure.context.LifecycleProperties
beanDefinitionName=org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration$StringHttpMessageConverterConfiguration
beanDefinitionName=stringHttpMessageConverter SpringMVC处理JSON
beanDefinitionName=org.springframework.boot.autoconfigure.http.JacksonHttpMessageConvertersConfiguration$MappingJackson2HttpMessageConverterConfiguration
beanDefinitionName=mappingJackson2HttpMessageConverter
beanDefinitionName=org.springframework.boot.autoconfigure.http.JacksonHttpMessageConvertersConfiguration
beanDefinitionName=org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration
beanDefinitionName=messageConverters
beanDefinitionName=org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration
beanDefinitionName=spring.info-org.springframework.boot.autoconfigure.info.ProjectInfoProperties
beanDefinitionName=org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration
beanDefinitionName=spring.sql.init-org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties
beanDefinitionName=org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer$DependsOnDatabaseInitializationPostProcessor
beanDefinitionName=org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration
beanDefinitionName=scheduledBeanLazyInitializationExcludeFilter
beanDefinitionName=taskSchedulerBuilder
beanDefinitionName=spring.task.scheduling-org.springframework.boot.autoconfigure.task.TaskSchedulingProperties
beanDefinitionName=org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration
beanDefinitionName=restTemplateBuilderConfigurer
beanDefinitionName=restTemplateBuilder
beanDefinitionName=org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration$TomcatWebServerFactoryCustomizerConfiguration
beanDefinitionName=tomcatWebServerFactoryCustomizer
beanDefinitionName=org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration
beanDefinitionName=characterEncodingFilter SpringMVC处理中文的过滤器
beanDefinitionName=localeCharsetMappingsCustomizer
beanDefinitionName=org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration
beanDefinitionName=multipartConfigElement
beanDefinitionName=multipartResolver SpringMVC处理文件上传
beanDefinitionName=spring.servlet.multipart-org.springframework.boot.autoconfigure.web.servlet.MultipartProperties
beanDefinitionName=org.springframework.aop.config.internalAutoProxyCreator

4.自动配置: 默认扫描包结构.
官方文档: https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.structuring-your-code.using-the-default-package

如何修改默认配置

如何修改默认扫描包结构

1.需求: 要求能扫描 com.zzw 包下的 HiController.java, 应该如何处理?

2.创建: D:\idea_project\zzw_springboot\quickstart\src\main\java\com\zzw\HiController.java, 并测试, 这时是访问不到的

@Controller
public class HiController {
    //返回hi,world
    @RequestMapping("/hi")
    @ResponseBody
    public String hello() {
        return "hi, world";
    }
}

3.修改MainApp.java, 增加扫描的包, 并完成测试.

/**
 * @SpringBootApplication: 表示这是一个springboot引用/项目
 * @SpringBootApplication(scanBasePackages = "com.zzw")
 * 解读: scanBasePackages = "com.zzw" 指定SpringBoot要扫描的包和子包
 * 如果有多个包, 可以这样指定: 用数组 scanBasePackages = {"com.zzw","xxx.yyy.zzz"}
 */
@SpringBootApplication(scanBasePackages = "com.zzw")
public class MainApp {}

resources\application.properties配置大全

1.SpringBoot项目最重要也是最核心的配置文件就是application.properties, 所有的框架配置都可以在这个配置文件中说明.

2.地址: https://blog.csdn.net/pbrlovejava/article/details/82659702

resources\application.properties修改配置

各种配置都有默认, 可以在 resources\application.properties 修改, application.properties 文件我们 可以手动创建

手动输入如果没有提示, 安装插件

#修改server的监听端口
server.port=8081
#修改单个文件上传的大小. 默认是1MB, 修改成10MB
#让我们解读一下这个配置是在哪里读取的!
#multipart.max-file-size 属性可以指定springboot上传文件的大小限制-体现约定优于配置
#默认配置最终都是映射到某个类, 比如multipart.max-file-size 会映射/关联到 MultipartProperties 类
#把光标放在该属性, 输入ctrl+b, 就可以定位这个属性是关联到哪个类(属性类)
spring.servlet.multipart.max-file-size=10MB

resources\application.properties常用配置

●常用配置一览

#端口号
server.port=10000
#应用的上下文路径(项目路径)
server.servlet.context-path=/allModel

#指定POJO扫描包来让mybatis自动扫描到自定义的POJO
mybatis.type-aliases-package=com.cxs.allmodel.model

#指定mapper.xml的路径
#(application上配置了@MapperScan(扫面mapper类的路径)和pom.xml中放行了mapper.xml后,
#配置mapper-locations没有意义。如果mapper类和mapper.xml不在同一个路径下时，mapper-locations就有用
了)
mybatis.mapper-locations=classpath:com/cxs/allmodel/mapper

#session失效时间(单位s)
spring.session.timeout=18000

#数据库连接配置
#mysql数据库url
mysql.one.jdbc-url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=Asia/shanghai&usessL=false
#mysql数据库用户名
mysql.one.username
#数据库密码
mysql.one.password=
#线程池允许的最大连接数
mysgl.one.maximum-pool-size=15

#日志打印:日志级别 trace<debug<info<warn<error<fatal默认级别为info，即默认打印info及其以上级别的日志
#logging.evel设置日志级别，后面跟生效的区域，比如root表示整个项目，也可以设置为某个包下，也可以具体到某个类名(日志级别的值不区分大小写)
logging.level.com.cxs.allmodel.=debug
logging.level.com.cxs.allmodel.mapper=debug
logging.level.org.springframework.web=info
logging.level.org.springframeworktransaction=info
logging.level.org.apache.lbatis=info
logging.level.org:mybatis=info
logging.level.com.github.pagehelper = info
logging.level.root=info
#日志输出路径
logging.file=/tmp/api/allmodel.log

#配置pagehelper分页插件
pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.supportMethodsArguments=true
pagehelper.params=count=countSql

#jackson时间格式化
spring.jackson.serialization.fail-on-empty-beans=false
#指定日期格式，比如yyyy-MM-dd HH:mm:ss，或者具体的格式化类的全限定名
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
#指定日期格式化时区，比如America/Los_Angeles或各GMT+10
spring.jackson.time-zone=GMT+8

#设置统一字符集
spring.http.encoding.charset=utf8

#redis连接配置
#redis所在主机ip地址
spring.redis.host=
#redis服务器密码
spring.redis.password=
#redis服务器端口号
spring.redis.port=
#redis数据库的索引编号(0到15)
spring.redis.database=14
##连接池的最大活动连接数量，使用负值无限制
#spring.redis.pool.max-active=8
#
##连接池的最大空闲连接数量，使用负值表示无限数量的空闲连接
#spring.redis.pool.max-idle=8
#
##连接池最大阻塞等待时间，使用负值表示没有限制
#spring.redis.pool.max-wait=-1ms
#
##最小空闲连接数量，使用正值才有效果
#spring.redis.pool.min-idle=0
#
## 是否启用SSL连接.
##spring.redis.ssl=false
#
##连接超时，毫秒为单位
#spring.redis.timeout= 18000ms
#
## 集群模式下，集群最大转发的数量
#spring.redis.cluster.max-redirects=
#
## 集群模式下，逗号分隔的键值对(主机:端口)形式的服务器列表
#spring.redis.cluster.nodes=
#
## 哨兵模式下，Redis主服务器地址
#spring.redis.sentinel.master=
#
## 哨兵模式下，逗号分隔的键值对(主机:端口)形式的服务器列表
#spring.redis.sentinel.nodes= 127.0.0.1:5050,127.0.0.1:5060

resources\application.properties自定义配置

●还可以在properties文件中自定义配置, 通过 @Value(“${}”) 获取对应属性值.

#自定义配置属性
my.webSite=https://www.baidu.com

@Controller
public class HiController {

    //需求: webSite 属性值从 application.properties 的k-v获取
    //当HiController作为一个bean被创建时, webSite属性值被赋值
    @Value("${my.webSite}")
    private String webSite;

    //返回hi,world
    @RequestMapping("/hi")
    @ResponseBody
    public String hello() {
        System.out.println("webSite = " + webSite);
        return "hi, world";
    }
}

SpringBoot在哪配置读取application.properties

1.打开 ConfigFileApplicationListener.java, 看一下源码

file:./config/*/ ⇒ 表示 项目根目录/config/a目录下

自动配置遵守按需加载原则

基本说明

1.自动配置遵守按需加载原则: 也就是说, 引入了哪个场景starter就会加载该场景关联的jar包, 没有引入的starter, 则不会加载其关联jar

2.SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

3.在SpringBoot的自动配置包, 一般是XxxAutoConfiguration.java, 对应XxxProperties.java, 如图
XxxAutoConfiguration.java 包含 XxxProperties.java

实例演示

1.以 application.properties, MultipartProperties 和 MultipartAutoConfiguration 来说明. SpringBoot在创建MultipartProperties bean时，会去读取application.properties文件， 将数据封装，这个Bean会被注入关联的MultipartAutoConfiguration Bean里面。

容器功能

Spring注入组件的注解

@Component，@Controller，@Service，@Repository

说明：这些在Spring中的传统注解仍然有效，通过这些注解可以给容器注入组件。

案例演示

1.创建D:\idea_project\zzw_springboot\quickstart\src\main\java\com\zzw\springboot\bean\A.java

@Repository
public class A {}

2.测试MainApp.java, 其它注解不再一一测试.

@SpringBootApplication(scanBasePackages = "com.zzw")
public class MainApp {
    public static void main(String[] args) {
        //启动springboot应用程序/项目
        ApplicationContext ioc = SpringApplication.run(MainApp.class, args);
        System.out.println("ok");

        //演示Spring中传统的注解依然可以使用 @controler @service @repository
        A aBean = ioc.getBean(A.class);
        System.out.println("aBean=" + aBean);
    }
}

@Configuration

应用实例

●@Configuration应用实例需求
说明: 演示在SpringBoot, 如何通过 @Configuration 创建配置类来注入组件.

传统方式

●回顾传统方式如何通过配置文件注入组件. 基于XML配置bean
1.创建D:\idea_project\zzw_springboot\quickstart\src\main\java\com\zzw\springboot\bean\Monster.java

@Getter
@Setter
@ToString
@NoArgsConstructor
@AllArgsContructor
public class Monster {
    private Integer id;
    private String name;
    private Integer age;
    private String skill;
}

2.创建D:\idea_project\zzw_springboot\quickstart\src\main\resources\beans.xml创建容器配置文件的方式在SpringBoot中依然好使

<!--配置了Monster bean-->
<bean class="com.zzw.springboot.bean.Monster" id="monster">
    <property name="id" value="100"/>
    <property name="name" value="孙悟空"/>
    <property name="age" value="20"/>
    <property name="skill" value="金箍棒"/>
</bean>

3.在springboot项目中，依然可以使用spring的配置bean/注入bean/获取bean方式

@SpringBootApplication(scanBasePackages = "com.zzw")
public class MainApp {
    public static void main(String[] args) {
        //=====演示在springboot项目，依然可以使用spring的配置bean/注入bean/获取bean方式 start===

        ApplicationContext ac =
                new ClassPathXmlApplicationContext("beans.xml");
        Monster monster = ac.getBean("monster" , Monster.class);
        System.out.println("monster=" + monster);

        //=====演示在springboot项目，依然可以使用spring的配置bean/注入bean/获取bean方式 end=====

    }
}

使用@Configuration

●使用SpringBoot的@Configuration添加组件
1.创建D:\idea_project\zzw_springboot\quickstart\src\main\java\com\zzw\springboot\config\BeanConfig.java

配置文件和配置类都差不多, 但是在springboot中开发尽量用配置类来完成Bean的注入.

/**
 * 解读
 * 1.@Configuration 表示这是一个配置类，等价于配置文件
 * 2.程序员可以通过@Bean 注解注入bean对象到容器
 * 3.当一个类被 @Configuration 标识, 该类-Bean 也会注入到容器
 */
@Configuration
public class BeanConfig {

    /**
     * 解读
     * 1.@Bean: 给容器添加组件, 就是一个Monster bean
     * 2.monster01(): 默认 你的方法名monster01 作为bean的名字/id
     * 3.Monster: 注入类型, 注入bean的类型时Monster
     * 4.new Monster(200, "牛魔王" , 500 , "芭蕉扇"); 注入到容器中具体的bean信息
     * 5.@Bean(name = "monster_nmw"): 在配置/注入 bean 指定名字/id monster_nmw
     * 6.默认是单例注入
     * 7.通过 @Scope("prototype") 可以每次返回新的对象, 指定bean对多例
     */
    //@Bean(name = "monster_aliasName")
    @Bean
    public Monster monster01() {
        return new Monster(200, "牛魔王" , 500 , "芭蕉扇");
    }
}

2.修改MainApp.java, 从配置文件/容器获取bean, 并完成测试
hashCode含义

@SpringBootApplication(scanBasePackages = "com.zzw")
public class MainApp {
    public static void main(String[] args) {
        //启动springboot应用程序/项目
        ApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        //=====演示在springboot项目中，@Configuration的使用 start===

        Monster monster01 = ioc.getBean("monster01" , Monster.class);
        Monster monster02 = ioc.getBean("monster01" , Monster.class);
        System.out.println("monster01=" + monster01 + " " + monster01.hashCode());
        System.out.println("monster02=" + monster02 + " " + monster02.hashCode());

        //=====演示在springboot项目中，@Configuration的使用 end=====

    }
}

3.也可以通过Debug来查看 ioc 容器是否存在 monster01 的 Bean实例

ioc->beanFactory->beanDefinitionMap->monster01

注意事项和细节

1.配置类本身也是组件, 因此也可以获取. 修改MainApp.java
配置类是CGLIB代理对象. 动态代理jdk的Proxy和Spring的CGlib

@SpringBootApplication(scanBasePackages = "com.zzw")
public class MainApp {
    public static void main(String[] args) {
        //启动springboot应用程序/项目
        ApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        //=====演示 配置类-bean也会注入到容器 start===

        BeanConfig beanConfig = ioc.getBean("beanConfig", BeanConfig.class);
        System.out.println("beanConfig=" + beanConfig + " " + beanConfig.hashCode());

        //=====演示 配置类-bean也会注入到容器 end=====

    }
}

2.SpringBoot2新增特性: proxyBeanMethods 指定 Full模式 和 Lite模式
1)修改D:\idea_project\zzw_springboot\quickstart\src\main\java\com\zzw\springboot\config\BeanConfig.java

/**
 * 第二部分解读
 * 1.proxyBeanMethods: 代理bean的方法
 * 2.Full(proxyBeanMethods = true): (默认)保证每个@Bean方法被调用多少次返回的组件都是单例的, 是代理方法
 * 3.Lite(proxyBeanMethods = false): 保证每个@Bean方法被调用多少次返回的组件都是新创建的, 是非代理方法
 * 4.特别说明: proxyBeanMethods 是在 调用@Bean方法 才生效. 因此, 需要先获取BeanConfig 组件, 再调用方法
 * 而不是直接通过 SpringBoot 主程序得到的容器来获取bean, 注意观察直接通过ioc.getBean() 获取Bean, proxyBeanMethods 值并没有生效
 * 5.如何选择: 组件依赖必须使用默认 Full模式, 如果不需要组件依赖则使用 Lite模式.
 * 6.Lite模式: 也称为轻量级模式, 因为不检测依赖关系, 所以运行速度快
 */
@Configuration(proxyBeanMethods = false)
public class BeanConfig {}

2)修改MainApp.java

@SpringBootApplication(scanBasePackages = "com.zzw")
public class MainApp {
    public static void main(String[] args) {
        //启动springboot应用程序/项目
        ApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        //=====演示 @Configuration(proxyBeanMethods = xxx) start===

        //1.先得到BeanConfig组件
        BeanConfig beanConfig = ioc.getBean("beanConfig", BeanConfig.class);
        Monster monster_01 = beanConfig.monster01();
        Monster monster_02 = beanConfig.monster01();
        System.out.println("monster_01--" + monster_01 + " " + monster_01.hashCode());
        System.out.println("monster_02--" + monster_02 + " " + monster_02.hashCode());

        //特别说明: proxyBeanMethods 是在 调用@Bean方法 才生效. 因此, 需要先获取BeanConfig 组件, 再调用方法
        //1. 而不是直接通过 SpringBoot 主程序得到的容器来获取bean, 注意观察直接通过ioc.getBean() 获取Bean, proxyBeanMethods 值并没有生效
        Monster monster01 = ioc.getBean("monster01", Monster.class);
        Monster monster02 = ioc.getBean("monster01", Monster.class);
        System.out.println("monster01--" + monster01 + " " + monster01.hashCode());
        System.out.println("monster02--" + monster02 + " " + monster02.hashCode());

        //=====演示 @Configuration(proxyBeanMethods = xxx) end===

    }
}

3.配置类可以有多个, 就和Spring可以有多个ioc配置文件一个道理
1)创建D:\idea_project\zzw_springboot\quickstart\src\main\java\com\zzw\springboot\config\BeanConfig2.java

@Configuration
public class BeanConfig2 {
    @Bean
    public Monster monster02() {
        return new Monster(300, "太上老君" , 1000 , "炼丹炉");
    }
}

2)完成测试MainApp.java

@SpringBootApplication(scanBasePackages = "com.zzw")
public class MainApp {
    public static void main(String[] args) {
        //启动springboot应用程序/项目
        ApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        //=====测试可以有多个配置类 start===
        //两个配置类注入的Bean都生效
        Monster monster02 = ioc.getBean("monster02", Monster.class);
        Monster monster01 = ioc.getBean("monster01", Monster.class);
        System.out.println("monster02--" + monster02);
        System.out.println("monster01--" + monster01);

        //=====测试可以有多个配置类 end===
    }
}

@Import

应用实例

说明: 演示在SpringBoot, 如何通过 @Import 来注入组件
1.创建D:\idea_project\zzw_springboot\quickstart\src\main\java\com\zzw\springboot\bean\Cat.java 和 D:\idea_project\zzw_springboot\quickstart\src\main\java\com\zzw\springboot\bean\Dog.java

public class Dog {}

public class Cat {}

2.修改BeanConfig.java, 通过@Import注入组件

/**
 * 解读
 * 1.@Import 源码 可以看到, 我们可以指定 class的数组, 可以注入指定类型的Bean
 * public @interface Import {
 *     Class<?>[] value();
 * }
 * 2.通过@Import 方式注入了组件, 默认组件 名字/id 就是对应类型的全类名
 */
@Import(value = {Dog.class, Cat.class})
@Configuration
public class BeanConfig {}

3.修改MainApp.java, 完成测试

@SpringBootApplication(scanBasePackages = "com.zzw")
public class MainApp {
    public static void main(String[] args) {
        //启动springboot应用程序/项目
        ApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        //=====测试@Import 使用 start===

        Dog dogBean = ioc.getBean(Dog.class);
        Cat catBean = ioc.getBean(Cat.class);
        System.out.println("dogBean---" + dogBean);
        System.out.println("catBean---" + catBean);

        //=====测试@Import 使用 end===
    }
}

@Conditional

@Conditional介绍

1.条件装配: 满足Conditional指定的条件, 则进行组件注入

2.@Conditional 是一个根注解, 下面有很多扩展注解

应用实例

1.要求: 演示在SpringBoot, 如何通过 @ConditionalOnBean 来注入组件
2.只有在容器中有 name=monster_nmw 组件时, 才注入 dog01.

@Import(value = {Dog.class, Cat.class})
@Configuration
public class BeanConfig {
    @Bean
    //@Bean(name = "monster_nmw")
    public Monster monster01() {
        return new Monster(200, "牛魔王", 500, "芭蕉扇");
    }

    @Bean
    public Dog dog01() {
        return new Dog();
    }
}

3.先测试下, 当前是否能注入 dog01

@SpringBootApplication(scanBasePackages = "com.zzw")
public class MainApp {
    public static void main(String[] args) {
        //启动springboot应用程序/项目
        ApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        //=====测试@ConditionalOnBean 使用 start===

        Dog dog01 = ioc.getBean("dog01", Dog.class);
        System.out.println("dog01---" + dog01);

        //=====测试@ConditionalOnBean 使用 end===
    }
}

4.修改BeanConfig.java, 加入@ConditionalBean条件约束, 并完成测试

@Import(value = {Dog.class, Cat.class})
@Configuration
public class BeanConfig {
    @Bean
    //@Bean(name = "monster_nmw")
    public Monster monster01() {
        return new Monster(200, "牛魔王", 500, "芭蕉扇");
    }

    @Bean(name = "monster_nmw")
    public Cat cat01() {
        return new Cat();
    }

    @Bean
    /**
     * 解读
     * 1.@ConditionalOnBean(name = "monster_nmw") 表示
     * 2.当容器中有一个Bean, 名字是monster_nmw(类型不做约束), 就注入dog01这个Dog bean
     * 3.如果没有 名字是 monster_nmw 的Bean, 就不注入dog01这个Dog bean.
     * 4.还有很多其它的条件约束注解, 小伙伴可以自己测试
     *
     * 5.@ConditionalOnMissingBean(name = "monster_nmw") 表示在容器中
     * , 没有 名字/id 为 monster_nmw 的Bean, 才注入dog01这个Bean
     *
     * 6.@Conditional根注解及其扩展注解, 也可以修饰类
     * @ConditionalOnBean(name = "monster_nmw")
     * public class BeanConfig {}
     * 表示对该配置类的所有要注入的组件, 都进行条件约束.
     */
    @ConditionalOnBean(name = "monster_nmw")
    //@ConditionalOnMissingBean(name = "monster_nmw")
    public Dog dog01() {
        return new Dog();
    }
}

@ImportResource

作用: 原生配置文件引入, 也就是可以直接导入Spring 传统的beans.xml, 可以认为是SpringBoot 对 Spring 容器文件的兼容.

应用实例

1.需求: 将 beans.xml 导入到 BeanConfig.java 配置类, 并测试是否可以获得 beans.xml 注入/配置 的组件

2.修改BeanConfig.java 或者 创建新的BeanConfig3.java(建议创建新的配置类)来测试, 使用 @ImportResource 导入beans.xml，beans02.xml（复制beans.xml的配置，改改数据）

@Configuration
//导入beans.xml, 就可以获取到beans.xml 中配置的bean
@ImportResource(locations = {"classpath:beans.xml", "classpath:beans02.xml"})
public class BeanConfig3 {
}

3.修改MainApp.java

@SpringBootApplication(scanBasePackages = "com.zzw")
public class MainApp {
    public static void main(String[] args) {
        //启动springboot应用程序/项目
        ApplicationContext ioc = SpringApplication.run(MainApp.class, args);

        //=====演示@ImportResource 使用 start===

        Monster monster = ioc.getBean("monster", Monster.class);
        System.out.println("monster---" + monster);
        System.out.println("monster bean 是否存在-" + ioc.containsBean("monster"));
        
        Monster monster03 = ioc.getBean("monster03", Monster.class);
        System.out.println("monster03---" + monster03);
        System.out.println("monster03 bean 是否存在-" + ioc.containsBean("monster03"));

        //=====演示@ImportResource 使用 end===
    }
}

配置绑定

一句话：使用Java读取到SpringBoot 核心配置文件 application.properties 的内容，并且把它封装到JavaBean中.

应用实例

1.需求: 将application.properties指定的 k-v 和 JavaBean 绑定

2.application.properties增加配置

#1.设置Furn的属性k-v
#2.前面的furn01 是用于指定/区分不同的绑定对象, 这样可以在绑定Furn bean属性值时
#, 通过furn01 前缀进行区分
#3.furn01.id 中的id 就是你要绑定的 Furn bean的属性名
furn01.id=100
furn01.name=phone
furn01.price=6000

3.创建D:\idea_project\zzw_springboot\quickstart\src\main\java\com\zzw\springboot\bean\Furn.java

@Setter
@Getter
@Component
@ConfigurationProperties(prefix = "furn01")
public class Furn {
    private Integer id;
    private String name;
    private BigDecimal price;
}

4.修改HiController, 完成自动装配

@Controller
public class HiController {
    //装配到HiController
    @Resource
    private Furn furn;

    @RequestMapping("/furn")
    @ResponseBody
    public Furn furn() {
        return furn;
    }
}

5.启动SpringBoot 主程序, 完成测试

5.配置绑定还有第2种方式, 这里也演示一下, 效果一样.
注意: 注销 @Component 需要在 BeanConfig.java(说明: 也可以是其它配置类) 配置 @EnableConfigurationProperties(Furn.class), 否则会提示错误

/**
 * @EnableConfigurationProperties({Furn.class})解读
 * 1.开启Furn配置绑定功能
 * 2.把Furn组件自动 注册/注入 到容器中
 */
@EnableConfigurationProperties({Furn.class})
public class BeanConfig {}

注意事项和细节

1.如果 application.properties 有中文, 需要转成 unicode 编码写入, 否则会出现乱码. 在线Unicode转中文
以前学SpringMVC创建国际化文件的时候遇到过

furn01.id=100
furn01.name=\u5bb6\u5c45
furn01.price=6000

2.使用 @ConfigurationProperties(prefix=“furn01”) 会提示以下信息, 但是不会影响使用

3.解决 @ConfigurationProperties(prefix=“furn01”) 提示信息, 在 pom.xml 增加依赖, 即可

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>