SpringBoot

Published on with 0 views and 0 comments

点击 springinit-> 到最后选择 Spring Web,spring2.1 以上的版本从 Web 选项变成了 Spring Web

pom 文件

<dependencies>
    <!-- web启动器 -->
    <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>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- 内置的tomcat -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

程序主入口

@SpringBootApplication
public class SpringbootdemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootdemoApplication.class, args);
    }

}
  • @SpringBootApplication:注解标注在某个类上,说明该类是 SpringBoot 的主配置类,SpringBoot 就应该运行这个类的 main 方法来启动项目
  • @SpringBootConfiguration:标注某个类是配置类
    • @Configuration:配置类上标注这个注解 --- 与配置文件功能相同
  • @EnableAutoConfiguration:开启自动配置功能 --- 以前需要配置的东西,现在都不需要配置
    • @AutoConfigurationPackage:自动配置包,== 将主配置类(@SpringBootApplication 标注的类)的所在包及下面所有子包里面的所有组件扫描到 Spring 容器中 ==

      • @Import({Registrar.class}):Spring 的底层注解,给容器中导入一个组件;导入的组件有 Registrar.class
         public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {    //meatdata表示元数据,包含扫描到的组件的信息
            AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
        }
        
    • @Import({AutoConfigurationImportSelector.class}):导入哪些组件的选择器 --- 将所有需要导入的组件以全类目的方式返回;这些组件就会被添加到容器中,会给容器中导入非常多的自动配置类(XXXAutoConfiguration);就是给这些容器中导入这个场景所需要的所有组件,并配置好这些组件,免去了手动编写配置注入功能组件的工作

      //部分源码
      protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
      List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
      Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
          return configurations;
      }
      
      protected Class<?> getSpringFactoriesLoaderFactoryClass() {
          return EnableAutoConfiguration.class;
      }
      

      ==spring 启动时从类路径下的 META-INF/spring.factories 中获得 EnableAutoConfiguration 指定的值,将这些值作为自动配置类导入到容器中,自动配置类就生效,帮我们进行配置工作 ==
      J2EE 的整体整合解决方案和自动配置都在:spring-boot-autoconfigure-2.2.1.RELEASE.jar 中

使用 Spring Initializer 创建一个 SpringBoot 项目

  • 主程序
  • resources 配置文件夹
    • static:保存所有的静态资源;js、CSS 这些
    • templates:保存所有的模板页面;(Spring Boot 默认 jar 包使用嵌入式的 Tomcat,不支持 JSP 页面);可以使用模板引擎(FreeMarker、thymeleaf)
    • application.properties:Spring Boot 的配置文件

注解

@RestController=@Controller+@ResponseBody:spring4.0 后引入的注解

Sping Boot 的配置

SpringBoot 使用一个全局的配置文件,配置文件名是固定的;

  • application.properties
  • application.yml

YAML(YAML Ain't Markup Language)

标记语言:

    以前的配置文件大多都是 XML 文件

    YAML:以数据为中心,比 JSON、XML 等更适合做配置文件

server:
  port: 8081

YAML 基本语法

k: v:表示一对键值对(值前面必须有一个空格),以 == 空格 == 的缩进来控制层级关系,只要是左对齐的一列数据都是同一个层级的

server:
  port: 8081
  path: /hello

属性和值也是大小写敏感的

值的写法

  • 字面量:普通的值(数字,字符串,布尔):k: v,字符串默认不加单引号或者双引号

    • 双引号:不会转义字符串中的特殊字符,特殊字符会作为本身想表达的意思,eg:name: 'zhangsan \n lisl',这里面的\n 会表示成换行
    • 单引号:会转义特殊字符,特殊字符最终只是一个普通的字符串数据,上面所说的那一句会原样输出
  • 对象、Map(属性和值)

    • k: v:还是键值对形式
    <!-- 常规写法 -->
    friends:
        lastName: zhangsan
        age: 20
    <!-- 行内写法 -->
    friends: {lastName: zhangsan,age: 18}
    
  • 数组(List、set):用'-'值表示数组中的一个元素

    <!-- 常规写法 -->
    pets:
        - cat
        - dog
        - pig
    <!-- 行内写法 -->
    pets: [cat,dog,pig]
    

配置文件属性注入

方式一

application.yml

person:
  lastName: zhangsan
  age: 20
  boss: false
  birth: 2019/11/25
  map: {k1: v1,k2: 12}
  list:
    - lisi
    - zhaoliu
  dog:
    name: 小狗
    age: 2

application.properties

跟 yml 文件类似,二者选择其一使用

person.age=20
#map的配置形式,每个键值对分开配置
person.map.k1=v1
person.map.k2=v2
#list的配置形式,每个元素用逗号隔开
person.list=a,b,c
#对象的配置形式,对象中的每个属性分开赋值
person.dog.name=dog
person.dog.age=10

导入配置文件处理器

<!-- 导入配置文件处理器,配置文件进行绑定就好有提示 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <version>2.2.1.RELEASE</version>
</dependency>

javaBean

/*
 * 将配置文件中配置的每一个属性的值,映射到这个组件中
 * @ConfigurationProperties:告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
 *      prefix = "person":配置文件中哪个下面的所有属性进行一一映射
 * 默认从全局配置文件中获取值
 * 只有这个组件是容器中的组件,才能使用容器提供的@ConfigurationProperties功能
 */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;

    private Map<String, Object> map;
    private List<Object> list;
    private Dog dog;
}

方式二

@Value:在 XML 中取值可以使用下面的三种方式去取值,用这个注解就与在 XML 中一样,可以获取配置文件中的值

/*
 * <bean class = "Person">
 *      <property name = "lastName" value = "字面量/${key}从环境变量、配置文件中取值、#{SpEL}"></property>
 * </bean>
 */
@Value("${person.last-name}")
private String lastName;
  • @ConfigurationProperties@Value
    功能批量注入配置文件中的属性一个一个指定
    松散绑定- 可以表示接下来的一个字母是大写,_ 表示小写不支持
    SpEL不支持支持
    JSR303 数据校验支持不支持
    复杂类型封装支持不支持

JSR303 校验:

@Validated  //类上加Validated注解

@Email      //属性上可以加上校验注解,这个是代表注入的值必须是email格式的

总结:如果说我们只是在某个业务逻辑中需要获取一下配置文件中的你某个值,使用 @value 注解,如果说我们专门编写了一个 JavaBean 来和配置文件进行映射,就使用 @ConfigurationProperties

@PropertySource & @ImportResource

@PropertySource

@PropertySource:读取指定配置文件,这个注解要跟 @ConfigurationProperties 一起使用

eg:@PropertySource("classpath:person.properties")

@ImportResource

导入 Spring 的配置文件,让配置文件里面的内容生效

Spring Boot 里面没有 Spring 的配置文件,自己编写的配置文件,也不能自动识别

想让 Spring 的配置文件生效,加载进来,就需要使用这个注解,标注在一个配置类上,可以是主程序

@ImportResource(locations = {"classpath:bean.xml"})

原先是使用 XML 配置文件的方式添加组件,SpringBoot 不推荐这种方式

SpringBoot 推荐给容器添加组件的方式:推荐使用注解的方式

@Configuration   //标明这是一个配置类
public class MyAppConfig {
    @Bean   //将方法的返回值添加到容器中,容器中的这个组件默认的id就是方法名
    public HelloService helloService() {
        return new HelloService();
    }
}

配置文件占位符

1.随机数

random.value,{random,int},${random.long}、random.int(10),{random.int[102,65536]

2.占位符获取之前配置的值,如果没有,可以指定默认值

${person.hello:hello}:冒号后面的为指定的默认值

person.age=20
person.last-name=吴若辉${random.uuid}
person.map.k1=v1
person.list=a,b,c
person.dog.name=${person.hello:hello} ${person.last-name}'s dog
person.dog.age=${random.int}

Profile:切换环境使用,测试环境用测试环境,生产环境用生成环境

1.多 Profile 文件

文件名可以是:application-{profile}.properties/yml

默认使用 application.properties

2.yml 支持多文档块的方式

---:是文档分块标志,上面的为一个文档,下面的为一个文档

server:
  port: 8082
spring:
  profiles:
    active: dev
---
server:
  port: 8083
spring:
  profiles: dev
---
server:
  port: 8084
spring:
  profiles: prod

3.激活指定 profile

(1)在配置文件中指定 spring.profiles.active=dev,就可以激活 application-dev.properties

(2)命令行:--spring.profiles.active=dev

(3)虚拟机参数:-Dpring.profiles.active=dev

配置文件的加载位置

Spring boot 启动会扫描以下位置的 application.properties 或者 application.yml 文件作为 SpringBoot 的默认配置文件

  • -file:./config/:当前目录下的 config 文件夹,该文件夹跟 src 文件夹是同级的关系
  • -file:./:当前目录下,跟 pom 文件是同一级
  • classpath:/config/:resources 下的 config 文件夹
  • classpath:/:resources 文件夹下

以上 == 优先级从高到低 ==,所有位置的文件都会被加载,高优先级配置内容会覆盖低优先级配置内容,我们也可以通过 spring.config.location 改变默认配置

项目打包好之后,我们可以使用命令行参数的形式,启动项目的时候来指定配置文件的新位置;指定配置文件和默认加载的这些配置文件形成互补配置

java -jar jar包名 --spring.config.location=配置文件完整路径

外部配置的加载顺序

SpringBoot 也可以从以下位置加载配置; 优先级从高到低;高优先级的配置覆盖低优先级的配置,所有的配置会形成互补配置

1.命令行参数

所有的配置都可以在命令行上进行指定

Java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc

多个配置用空格分开; --配置项 = 值

2.来自 java:comp/env 的 JNDI 属性

3.Java 系统属性(System.getProperties())

4.操作系统环境变量

5.RandomValuePropertySource 配置的 random.*属性值

== 由 jar 包外向 jar 包内进行寻找;==

== 优先加载带 profile==

6.jar 包外部的 application-{profile}.properties 或 application.yml(带 spring.profile)配置文件

7.jar 包内部的 application-{profile}.properties 或 application.yml(带 spring.profile)配置文件

== 再来加载不带 profile==

8.jar 包外部的 application.properties 或 application.yml(不带 spring.profile)配置文件

9.jar 包内部的 application.properties 或 application.yml(不带 spring.profile)配置文件

10.@Configuration 注解类上的@PropertySource

11.通过 SpringApplication.setDefaultProperties 指定的默认属性

所有支持的配置加载来源;

参考官方文档

自动配置原理

配置文件到底能写什么?怎么写?自动配置原理;

配置文件能配置的属性参照

自动配置原理

1.SpringBoot 启动的时候加载主配置类,开启自动配置功能 @EnableAutoConfiguration

2.@EnableAutoConfiguration 作用:

  • 利用 EnableAutoConfigurationImportSelector 给容器中导入一些组件
  • 可以查看 selectImports()方法的内容
  • List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);:获取候选的配置
    //扫描所有jar包类路径下的META-INF/spring.factories,把扫描到的文件包装成properties对象,从properties中获取到EnableAutoConfiguration.class(类名对应的值)的值,然后把他们添加到容器中
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
    

== 将类路径下的 META-INF/spring.factories 里面配置的所有 EnableAutoConfiguration 的值加入到了容器中 ==,每一个 XXXAutoConfiguration 类都是容器中的一个组件,都加入到容器中,用他们来做自动配置

每一个自动配置类进行自动配置功能

以 HttpEncodingAutoConfiguration(Http 编码自动配置)为例

@Configuration(   //表示这是个配置类,以前编写的配置文件一样,也可以给容器中添加组件
    proxyBeanMethods = false
)
@EnableConfigurationProperties({HttpProperties.class})   //启动指定类的configurationProperties功能,将配置文件中对应的值和HttpEncodingAutoConfiguration绑定起来;并把HttpEncodingProperties加入到IOC容器中
@ConditionalOnWebApplication(   //spring底层@Conditional注解,根据不同的条件,如果满足指定的条件,整个配置类里面的配置就好生效 ---> 判断是否web应用,是则生效
    type = Type.SERVLET
)
@ConditionalOnClass({CharacterEncodingFilter.class})   //判断当前当前项目有没有CharacterEncodingFilter这个类
@ConditionalOnProperty(   //判断配置文件中是否存在某个配置 --> spring.http.encoding.enabled;matchIfMissing表示如果不存在也认识生效
                        //即使配置文件中不配置spring.http.encoding.enabled=true,也是默认生效的
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    //已经和springboot的配置文件映射了
    private final Encoding properties;

    //只有一个
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }


    @Bean    //给容器中添加一个组件,这个组件的某些值需要从properties中获取
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }
}


根据当前不同条件判断,决定这个配置类是否生效,一旦这个配置类生效;这个配置类就会给容器中添加各种组件,这些组件的属性是从对应的 properties 类中获取的,这些类中的每一个属性又是和配置文件绑定的

所有在配置文件中能配置的属性都是在 xxxProperties 类中封装着,配置文件能配置什么就可以参照某个功能对应的这个属性类

@ConfigurationProperties(  //从配置文件中获取指定的值和bean属性进行绑定
    prefix = "spring.http"
)
public class HttpProperties {

}

精髓:

    1.SpringBoot 启动会加载大量的自动配置类

    2.我们需要的功能有没有 SpringBoot 默认写好的自动配置类

    3.我们再来看这个自动配置类到底配置了哪些组件(只要我们要用的组件有,我们就不需要配置了)

    4.给容器中自动配置类添加组件时,会从 properties 类中获取某些属性,我们就可以在配置文件中指定这些属性的值

xxxxAutoConfigurartion:自动配置类;

给容器中添加组件

xxxxProperties:封装配置文件中相关属性;

@Conditional 派生注解(Spring 注解版原生的@Conditional 作用)

作用:必须是@Conditional 指定的条件成立,才给容器中添加组件,配置配里面的所有内容才生效;

@Conditional 扩展注解作用(判断是否满足当前指定条件)
@ConditionalOnJava系统的 Java 版本是否符合要求
@ConditionalOnBean容器中存在指定 Bean;
@ConditionalOnMissingBean容器中不存在指定 Bean;
@ConditionalOnExpression满足 SpEL 表达式指定
@ConditionalOnClass系统中有指定的类
@ConditionalOnMissingClass系统中没有指定的类
@ConditionalOnSingleCandidate容器中只有一个指定的 Bean,或者这个 Bean 是首选 Bean
@ConditionalOnProperty系统中指定的属性是否有指定的值
@ConditionalOnResource类路径下是否存在指定资源文件
@ConditionalOnWebApplication当前是 Web 环境
@ConditionalOnNotWebApplication当前不是 Web 环境
@ConditionalOnJndiJNDI 存在指定项

自动配置类必须在一定的条件下才能生效;

我们怎么知道哪些自动配置类生效;

== 可以通过在配置文件中启用 debug=true 属性;来让控制台打印自动配置报告 ==,这样我们就可以很方便的知道哪些自动配置类生效;

=========================
AUTO-CONFIGURATION REPORT
=========================


Positive matches:(自动配置类启用的)
-----------------

   DispatcherServletAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
      - @ConditionalOnWebApplication (required) found StandardServletEnvironment (OnWebApplicationCondition)


Negative matches:(没有启动,没有匹配成功的自动配置类)
-----------------

   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)

   AopAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'org.aspectj.lang.annotation.Aspect', 'org.aspectj.lang.reflect.Advice' (OnClassCondition)

SpringBoot 日志

市面上的日志框架:JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j...

日志门面 (日志的抽象层)日志实现
JCL(Jakarta Commons Logging)
SLF4j(Simple  Logging Facade for Java)

jboss-logging | Log4j JUL(java.util.logging) Log4j2Logback |

左边选一个门面(抽象层)、右边来选一个实现;

日志门面: SLF4J;

日志实现:Logback;

SpringBoot:底层是 Spring 框架,Spring 框架默认是用 JCL;‘

    ==SpringBoot 选用 SLF4j 和 logback;==

SLF4j 的使用

如何在系统中使用 SLF4j

开发时,日志记录方法的调用,不应该调用日志类的实现类,而是调用日志抽象层的方法

给系统里面导入 slf4j 的 jar 和 logback 的实现 jar

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

每一个日志的实现框架都有自己的配置文件。使用 slf4j 以后,配置文件还是做成日志实现框架自己本身的配置文件;

遗留问题

a(slf4j+logback): Spring(commons-logging)、Hibernate(jboss-logging)、MyBatis、xxxx

统一日志记录,即使是别的框架和我一起统一使用 slf4j 进行输出?

如何让系统中所有的日志都统一到 slf4j;

==1、将系统中其他日志框架先排除出去;==

==2、用中间包来替换原有的日志框架;==

==3、我们导入 slf4j 其他的实现 ==

SpringBoot 的日志关系

SpringBoot 使用它来做日志功能;

	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-logging</artifactId>
		</dependency>

底层依赖关系

总结:

  1. 、SpringBoot 底层也是使用 slf4j+logback 的方式进行日志记录
  2. 、SpringBoot 也把其他的日志都替换成了 slf4j;
  3. 、中间替换包?
@SuppressWarnings("rawtypes")
public abstract class LogFactory {

    static String UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J = "http://www.slf4j.org/codes.html#unsupported_operation_in_jcl_over_slf4j";

    static LogFactory logFactory = new SLF4JLogFactory();

4. 、如果我们要引入其他框架?一定要把这个框架的默认日志依赖移除掉?
Spring 框架用的是 commons-logging;
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<exclusions>
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

==SpringBoot 能自动适配所有的日志,而且底层使用 slf4j+logback 的方式记录日志,引入其他框架的时候,只需要把这个框架依赖的日志框架排除掉即可;==

日志使用

Spring 默认帮我们配置好了日志

//记录器
Logger logger = LoggerFactory.getLogger(getClass());
@Test
void contextLoads() {
    //日志级别,由低到高trace < debug < info < warn < error
    //可以调整日志的输出级别,就只会输出在此级别以及高级别的日志
    logger.trace("trace");
    logger.debug("debug");
    //spring默认给我们使用的是info级别,没有指定级别的就用SpringBoot默认规定的级别:root级别
    logger.info("info");
    logger.warn("warn");
    logger.error("error");
    System.out.println(person);
}

SpringBoot 修改日志的默认配置

logging.level.com.wu.springbootdemo=trace

#logging.path=
#指定日志输出的文件名,可以指定完整路径,springboot2.2前的是logging.file
#logging.file.name=G:/spring.log
#在当前磁盘的根路径下创建spring文件夹和里面的log文件夹,使用spring.log作为默认文件,springboot2.2前是logging.path
#logging.file.path=/spring/log

#在控制台输出的日志的格式
logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n
#指定文件中日志输出的格式
logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} ==== %msg%n

日志输出格式

%d表示日期时间,
%thread表示线程名,
%-5level:级别从左显示5个字符宽度
%logger{50} 表示logger名字最长50个字符,否则按照句点分割。
%msg:日志消息,
%n是换行符

%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n

指定配置文件

给类路径下放上每个日志框架自己的配置文件即可;SpringBoot 就不使用他默认配置的了

Logging SystemCustomization
Logbacklogback-spring.xml, logback-spring.groovy, logback.xml or logback.groovy
Log4j2log4j2-spring.xml or log4j2.xml
JDK (Java Util Logging)logging.properties

logback.xml:直接就被日志框架识别了;

logback-spring.xml:日志框架就不直接加载日志的配置项,由 SpringBoot 解析日志配置,可以使用 SpringBoot 的高级 Profile 功能(带 Spring 的才能使用高级功能)

<springProfile name="staging">
    <!-- configuration to be enabled when the "staging" profile is active -->
  	可以指定某段配置只在某个环境下生效
</springProfile>

例子:

<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
    <!--
    日志输出格式:
		%d表示日期时间,
		%thread表示线程名,
		%-5level:级别从左显示5个字符宽度
		%logger{50} 表示logger名字最长50个字符,否则按照句点分割。
		%msg:日志消息,
		%n是换行符
    -->
    <layout class="ch.qos.logback.classic.PatternLayout">
        <springProfile name="dev">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
        </springProfile>
        <springProfile name="!dev">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
        </springProfile>
    </layout>
</appender>

在主配置文件中要激活该功能
spring.profiles.active=dev

如果使用 logback.xml 作为日志配置文件,还要使用 profile 功能,会有以下错误

no applicable action for [springProfile]

切换到 log4j

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <exclusions>
       <!-- 排除两个依赖 -->
       <!-- 要用到log4j,所以要排除logback -->
       <exclusion>
           <artifactId>logback-classic</artifactId>
           <groupId>ch.qos.logback</groupId>
       </exclusion>
       <!-- 这个依赖是将log4j转成其他实现,要用log4j需要去除 -->
       <exclusion>
           <artifactId>log4j-over-slf4j</artifactId>
           <groupId>org.slf4j</groupId>
       </exclusion>
   </exclusions>
</dependency>
<dependency>
   <!-- 导入log4j依赖 -->
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-log4j12</artifactId>
</dependency>

切换到 log4j2

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <exclusions>
       <exclusion>
           <artifactId>spring-boot-starter-logging</artifactId>
           <groupId>org.springframework.boot</groupId>
       </exclusion>
   </exclusions>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

Web 开发

SpringBooot 对静态资源的映射规则

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties implements ResourceLoaderAware {
 //可以设置和静态资源有关的参数,缓存时间等
public void addResourceHandlers(ResourceHandlerRegistry registry) {
   if (!this.resourceProperties.isAddMappings()) {
       logger.debug("Default resource handling disabled");
   } else {
       Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
       CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
       if (!registry.hasMappingForPattern("/webjars/**")) {
           this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{"/webjars/**"}).addResourceLocations(new String[]{"classpath:/META-INF/resources/webjars/"}).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
               }

       String staticPathPattern = this.mvcProperties.getStaticPathPattern();
       if (!registry.hasMappingForPattern(staticPathPattern)) {
           this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{staticPathPattern}).addResourceLocations(WebMvcAutoConfiguration.getResourceLocations(this.resourceProperties.getStaticLocations())).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
       }
   }
}

//配置欢迎页映射
@Bean
public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext, FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
   WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(new TemplateAvailabilityProviders(applicationContext), applicationContext, this.getWelcomePage(), this.mvcProperties.getStaticPathPattern());        welcomePageHandlerMapping.setInterceptors(this.getInterceptors(mvcConversionService, mvcResourceUrlProvider));
   return welcomePageHandlerMapping;
}
  1. 、所有 /webjars/** ,都去 classpath:/META-INF/resources/webjars/ 找资源;

webjars:以 jar 包的方式引入静态资源;

http://www.webjars.org/

<!--引入jquery-webjar-->在访问的时候只需要写webjars下面资源的名称即可
<dependency>
	<groupId>org.webjars</groupId>
	<artifactId>jquery</artifactId>
	<version>3.3.1</version>
</dependency>

==2)、"/**" 访问当前项目的任何资源,都去(静态资源的文件夹)找映射 ==

"classpath:/META-INF/resources/",
"classpath:/resources/",
"classpath:/static/",
"classpath:/public/"
"/":当前项目的根路径

==3)、欢迎页; 静态资源文件夹下的所有 index.html 页面;被"/**"映射;==

localhost:8080/ 找 index 页面

更改静态文件夹位置

在主配置文件中配置,多个路径可以用逗号隔开,配置后 SpringBoot 默认的配置就不生效了

spring.resources.static-locations=classpath:/hello

模板引擎

JSP、freemaker、thymeleaf

SpringBoot 推荐 thymeleaf

1.引入 starter

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-thymeleaf</artifactId>
  	2.1.6
</dependency>
切换thymeleaf版本
<properties>
	<thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
	<!-- 布局功能的支持程序  thymeleaf3主程序  layout2以上版本 -->
	<!-- thymeleaf2   layout1-->
	<thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>
 </properties>

2.使用

@ConfigurationProperties(prefix = "spring.thymeleaf")
public class ThymeleafProperties {

	private static final Charset DEFAULT_ENCODING = Charset.forName("UTF-8");

	private static final MimeType DEFAULT_CONTENT_TYPE = MimeType.valueOf("text/html");
    //只要我们把HTML页面放在classpath:/templates/,thymeleaf就能自动渲染
	public static final String DEFAULT_PREFIX = "classpath:/templates/";
	public static final String DEFAULT_SUFFIX = ".html";

(1)导入 thymeleaf 的名称空间

<html lang="en" xmlns:th="http://www.thymeleaf.org">

(2)语法

<!--th:text 将div里面的文本内容设置为 -->
<div th:text="${hello}">这是显示欢迎信息</div>

(3)语法规则

  1. th:text;改变当前元素里面的文本内容;

th:任意 HTML 属性;来替换原生属性的值

  1. 表达式
Simple expressions:(表达式语法)
    Variable Expressions: ${...}:获取变量值;OGNL;
    		1)、获取对象的属性、调用方法
    		2)、使用内置的基本对象:
    			#ctx : the context object.
    			#vars: the context variables.
                #locale : the context locale.
                #request : (only in Web Contexts) the HttpServletRequest object.
                #response : (only in Web Contexts) the HttpServletResponse object.
                #session : (only in Web Contexts) the HttpSession object.
                #servletContext : (only in Web Contexts) the ServletContext object.

                ${session.foo}
            3)、内置的一些工具对象:
                #execInfo : information about the template being processed.
                #messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{…} syntax.
                #uris : methods for escaping parts of URLs/URIs
                #conversions : methods for executing the configured conversion service (if any).
                #dates : methods for java.util.Date objects: formatting, component extraction, etc.
                #calendars : analogous to #dates , but for java.util.Calendar objects.
                #numbers : methods for formatting numeric objects.
                #strings : methods for String objects: contains, startsWith, prepending/appending, etc.
                #objects : methods for objects in general.
                #bools : methods for boolean evaluation.
                #arrays : methods for arrays.
                #lists : methods for lists.
                #sets : methods for sets.
                #maps : methods for maps.
                #aggregates : methods for creating aggregates on arrays or collections.
                #ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).

    Selection Variable Expressions: *{...}:选择表达式:和${}在功能上是一样;
    	补充:配合 th:object="${session.user};*{firstName}表示取到前面user对象的firstName属性
            <div th:object="${session.user}">
                <p>Name: <span th:text="*{firstName}">Sebastian</span>.</p>
                <p>Surname: <span th:text="*{lastName}">Pepper</span>.</p>
                <p>Nationality: <span th:text="*{nationality}">Saturn</span>.</p>
            </div>

    Message Expressions: #{...}:获取国际化内容
    Link URL Expressions: @{...}:定义URL;
    		@{/order/process(execId=${execId},execType='FAST')}
    Fragment Expressions: ~{...}:片段引用表达式
    		<div th:insert="~{commons :: main}">...</div>

Literals(字面量)
      Text literals: 'one text' , 'Another one!' ,…
      Number literals: 0 , 34 , 3.0 , 12.3 ,…
      Boolean literals: true , false
      Null literal: null
      Literal tokens: one , sometext , main ,…
Text operations:(文本操作)
    String concatenation: +
    Literal substitutions: |The name is ${name}|
Arithmetic operations:(数学运算)
    Binary operators: + , - , * , / , %
    Minus sign (unary operator): -
Boolean operations:(布尔运算)
    Binary operators: and , or
    Boolean negation (unary operator): ! , not
Comparisons and equality:(比较运算)
    Comparators: > , < , >= , <= ( gt , lt , ge , le )
    Equality operators: == , != ( eq , ne )
Conditional operators:条件运算(三元运算符)
    If-then: (if) ? (then)
    If-then-else: (if) ? (then) : (else)
    Default: (value) ?: (defaultvalue)
Special tokens:
    No-Operation: _

用法测试

<div th:text="${hello}">hello</div>
<div th:utext="${hello}"></div>
<!-- [[${user}]]是高级写法,也可以在标签体中用th:text="${user}" -->
<h4 th:each="user : ${users}">[[${user}]]</h4>
<h4><span th:each="user:${users}">[[${user}]]</span> </h4>

SpringMVC 的自动配置

https://docs.spring.io/spring-boot/docs/1.5.10.RELEASE/reference/htmlsingle/#boot-features-developing-web-applications

1.Spring MVC auto-configuration

Spring Boot 自动配置好了 SpringMVC

以下是 SpringBoot 对 SpringMVC 的默认配置:==(WebMvcAutoConfiguration)==

  • Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.

    • 自动配置了 ViewResolver(视图解析器:根据方法的返回值得到视图对象(View),视图对象决定如何渲染(转发?重定向?))
    • ContentNegotiatingViewResolver:组合所有的视图解析器的;
    • == 如何定制:我们可以自己给容器中添加一个视图解析器;自动的将其组合进来;==
  • Support for serving static resources, including support for WebJars (see below).静态资源文件夹路径,webjars

  • Static index.html support. 静态首页访问

  • Custom Favicon support (see below). favicon.ico

  • 自动注册了 of Converter, GenericConverter, Formatter beans.

    • Converter:转换器; public String hello(User user):类型转换使用 Converter
    • Formatter 格式化器; 2017.12.17===Date;
    @Bean
      @ConditionalOnProperty(prefix = "spring.mvc", name = "date-format")//在文件中配置日期格式化的规则
      public Formatter<Date> dateFormatter() {
      	return new DateFormatter(this.mvcProperties.getDateFormat());//日期格式化组件
      }
    

2.扩展 SpringMVC

<mvc:view-controller path="/hello" view-name="success"/>
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/hello"/>
        <bean></bean>
    </mvc:interceptor>
</mvc:interceptors>

== 编写一个配置类(@Configuration),是 WebMvcConfigurerAdapter 类型;不能标注@EnableWebMvc==;

既保留了所有的自动配置,也能用我们扩展的配置;

@Configuration
public class MyMVCConfig implements WebMvcConfigurer {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/wu").setViewName("success");
    }
}

原理:

  1. 、WebMvcAutoConfiguration 是 SpringMVC 的自动配置类
  2. 、在做其他自动配置时会导入;@Import(EnableWebMvcConfiguration.class)
@Configuration
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {
    private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
    //从容器中获取所有的WebMvcConfigurer
    @Autowired(required = false)
    public void setConfigurers(List<WebMvcConfigurer> configurers) {
        if (!CollectionUtils.isEmpty(configurers)) {
            this.configurers.addWebMvcConfigurers(configurers);
            //一个参考实现;将所有的WebMvcConfigurer相关配置都来一起调用;
            @Override
             // public void addViewControllers(ViewControllerRegistry registry) {
              //    for (WebMvcConfigurer delegate : this.delegates) {
               //       delegate.addViewControllers(registry);
               //   }
              }
          }
	}
  1. 、容器中所有的 WebMvcConfigurer 都会一起起作用;
  2. 、我们的配置类也会被调用;

效果:SpringMVC 的自动配置和我们的扩展配置都会起作用;

3、全面接管 SpringMVC;

SpringBoot 对 SpringMVC 的自动配置不需要了,所有都是我们自己配置;所有的 SpringMVC 的自动配置都失效了

我们需要在配置类中添加@EnableWebMvc 即可;

@EnableWebMvc
@Configuration
public class MyMVCConfig implements WebMvcConfigurer {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/wu").setViewName("success");
    }
}

原理:

为什么@EnableWebMvc 自动配置就失效了;

  1. @EnableWebMvc 的核心
@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {

}

2)

@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

3)

@Configuration
@ConditionalOnWebApplication
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class,
		WebMvcConfigurerAdapter.class })
//容器中没有这个组件的时候,这个自动配置类才生效
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
		ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
  1. 、@EnableWebMvc 将 WebMvcConfigurationSupport 组件导入进来;
  2. 、导入的 WebMvcConfigurationSupport 只是 SpringMVC 最基本的功能;

从 3 中看出,只有容器中没有 WebMvcConfigurationSupport 这个组件时自动配置才会生效,而 1 中以及 import 进了这个组件,所以 SpringBoot 的自动配置失效了

如何修改 SpringBoot 的默认配置

模式:

  1. 、SpringBoot 在自动配置很多组件的时候,先看容器中有没有用户自己配置的(@Bean、@Component)如果有就用用户配置的,如果没有,才自动配置;如果有些组件可以有多个(ViewResolver)将用户配置的和自己默认的组合起来;
  2. 、在 SpringBoot 中会有非常多的 xxxConfigurer 帮助我们进行扩展配置
  3. 、在 SpringBoot 中会有很多的 xxxCustomizer 帮助我们进行定制配置

国际化

1.编写国际化配置文件

2.使用 ResourcesBundleMessageSource 管理国际化资源文件

3.在页面使用 fmt:message 取出国际化内容

步骤:

1.编写国际化配置文件,抽取页面需要显示的国际化消息

2.SpringBoot 自动配置好了管理国际化资源文件的组件

在主配置文件中配置国际化,/i18n/xxx.properties 写成 i18n.xxx

#国际化资源文件
spring.messages.basename=i18n.login
@Bean
public MessageSource messageSource(MessageSourceProperties properties) {
    /**
	 * Comma-separated list of basenames (essentially a fully-qualified classpath
	 * location), each following the ResourceBundle convention with relaxed support for
	 * slash based locations. If it doesn't contain a package qualifier (such as
	 * "org.mypackage"), it will be resolved from the classpath root.
	 */
	private String basename = "messages";
    //我们的配置文件可以直接放在类路径下叫messages.properties;

    ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
    if (StringUtils.hasText(properties.getBasename())) {
        //设置国际化资源文件的基础名(去掉语言国家代码的)
        messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(properties.getBasename())));
    }

    if (properties.getEncoding() != null) {
        messageSource.setDefaultEncoding(properties.getEncoding().name());
    }

    messageSource.setFallbackToSystemLocale(properties.isFallbackToSystemLocale());
    Duration cacheDuration = properties.getCacheDuration();
    if (cacheDuration != null) {
        messageSource.setCacheMillis(cacheDuration.toMillis());
    }

    messageSource.setAlwaysUseMessageFormat(properties.isAlwaysUseMessageFormat());
    messageSource.setUseCodeAsDefaultMessage(properties.isUseCodeAsDefaultMessage());
    return messageSource;
}

3.如何取国际化信息

${} 类似,取国际化信息使用 #{}

<label class="sr-only" th:text="#{login.password}">Password</label>
<input type="password" class="form-control" placeholder="Password" th:placeholder="#{login.password}" required="">
<button class="btn btn-lg btn-primary btn-block" type="submit" th:text="#{login.btn}">Sign in</button>

效果:根据浏览器语言设置信息切换国际化

原理:国际化 Locale(区域信息对象);LocaleResolver(获取区域信息对象)

默认是根据请求头带来的区域信息获取 Locale 进行国际化

@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(
    prefix = "spring.mvc",
    name = {"locale"}
)
public LocaleResolver localeResolver() {
    if (this.mvcProperties.getLocaleResolver() == org.springframework.boot.autoconfigure.web.servlet.WebMvcProperties.LocaleResolver.FIXED) {
        return new FixedLocaleResolver(this.mvcProperties.getLocale());
    } else {
        AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
        localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
        return localeResolver;
    }
}

4.点击链接切换国际化

<!-- /指的是访问页面的路径,如果访问路径是/index.html的话,@{/index.html(l='zh_CN')},(l='zh_CN')是thymeleaf模板的功能,表示的是url后缀带着?l=zh_CN -->
<a class="btn btn-sm" th:href="@{/(l='zh_CN')}">中文</a>
<a class="btn btn-sm" th:href="@{/(l='en_US')}">English</a>
/*
*   可以在链接上携带区域信息
*/
//自己编写的组件类
public class MyLocaleResolver implements LocaleResolver {
    @Override
    public Locale resolveLocale(HttpServletRequest request) {
        String l = request.getParameter("l");
        Locale locale = Locale.getDefault();
        if (!StringUtils.isEmpty(l)) {
            String[] split = l.split("_");
            locale = new Locale(split[0],split[1]);
        }
        return locale;
    }

    @Override
    public void setLocale(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Locale locale) {

    }
}

//在配置类中注入组件
@Configuration
public class MyMVCConfig implements WebMvcConfigurer {
    @Bean
    public LocaleResolver localeResolver() {
        return new MyLocaleResolver();
    }
}

5.登录

开发期间模板引擎页面修改以后,要实时生效

  1. 、禁用模板引擎的缓存
# 禁用缓存
spring.thymeleaf.cache=false
  1. 、页面修改完成以后 ctrl+f9:重新编译;

登陆错误消息的显示

<p style="color: red" th:text="${msg}" th:if="${not #strings.isEmpty(msg)}"></p>

4)、拦截器进行登陆检查

拦截器


/**
 * 登陆检查,
 */
public class LoginHandlerInterceptor implements HandlerInterceptor {
    //目标方法执行之前
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Object user = request.getSession().getAttribute("loginUser");
        if(user == null){
            //未登陆,返回登陆页面
            request.setAttribute("msg","没有权限请先登陆");
            request.getRequestDispatcher("/index.html").forward(request,response);
            return false;
        }else{
            //已登陆,放行请求
            return true;
        }

    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

注册拦截器

  //所有的WebMvcConfigurerAdapter组件都会一起起作用
    @Bean //将组件注册在容器
    public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
        WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
            @Override
            public void addViewControllers(ViewControllerRegistry registry) {
                registry.addViewController("/").setViewName("login");
                registry.addViewController("/index.html").setViewName("login");
                registry.addViewController("/main.html").setViewName("dashboard");
            }

            //注册拦截器
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                //super.addInterceptors(registry);
                //静态资源;  *.css , *.js
                //SpringBoot已经做好了静态资源映射
                registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/**")
                        .excludePathPatterns("/index.html","/","/user/login");
            }
        };
        return adapter;
    }

5)、CRUD-员工列表

实验要求:

  1. 、RestfulCRUD:CRUD 满足 Rest 风格;

URI: /资源名称/资源标识 HTTP 请求方式区分对资源 CRUD 操作

普通 CRUD(uri 来区分操作)RestfulCRUD
查询getEmpemp---GET
添加addEmp?xxxemp---POST
修改updateEmp?id=xxx&xxx=xxemp/{id}---PUT
删除deleteEmp?id=1emp/{id}---DELETE
  1. 、实验的请求架构;
实验功能请求 URI请求方式
查询所有员工empsGET
查询某个员工(来到修改页面)emp/1GET
来到添加页面empGET
添加员工empPOST
来到修改页面(查出员工进行信息回显)emp/1GET
修改员工empPUT
删除员工emp/1DELETE

thymeleaf 公共页面元素抽取

1. 抽取公共片段
<div th:fragment="copy">
© 2011 The Good Thymes Virtual Grocery
</div>

2. 引入公共片段
<div th:insert="~{footer :: copy}"></div>
~{templatename::selector}:模板名::选择器
~{templatename::fragmentname}:模板名::片段名

3. 默认效果:
insert的公共片段在div标签中
如果使用th:insert等属性进行引入,可以不用写~{}:
行内写法可以加上:[[~{}]];[(~{})];

三种引入公共片段的th属性:

**th:insert**:将公共片段整个插入到声明引入的元素中

**th:replace**:将声明引入的元素替换为公共片段

**th:include**:将被引入的片段的内容包含进这个标签中

引入片段的时候传入参数:

```html

<nav class="col-md-2 d-none d-md-block bg-light sidebar" id="sidebar">
    <div class="sidebar-sticky">
        <ul class="nav flex-column">
            <li class="nav-item">
                <a class="nav-link active"
                   th:class="${activeUri=='main.html'?'nav-link active':'nav-link'}"
                   href="#" th:href="@{/main.html}">
                    <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-home">
                        <path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path>
                        <polyline points="9 22 9 12 15 12 15 22"></polyline>
                    </svg>
                    Dashboard <span class="sr-only">(current)</span>
                </a>
            </li>

<!--引入侧边栏;传入参数-->
<div th:replace="commons/bar::#sidebar(activeUri='emps')"></div>

6)、CRUD-员工添加

添加页面

<form>
    <div class="form-group">
        <label>LastName</label>
        <input type="text" class="form-control" placeholder="zhangsan">
    </div>
    <div class="form-group">
        <label>Email</label>
        <input type="email" class="form-control" placeholder="zhangsan@atguigu.com">
    </div>
    <div class="form-group">
        <label>Gender</label><br/>
        <div class="form-check form-check-inline">
            <input class="form-check-input" type="radio" name="gender"  value="1">
            <label class="form-check-label">男</label>
        </div>
        <div class="form-check form-check-inline">
            <input class="form-check-input" type="radio" name="gender"  value="0">
            <label class="form-check-label">女</label>
        </div>
    </div>
    <div class="form-group">
        <label>department</label>
        <select class="form-control">
            <option>1</option>
            <option>2</option>
            <option>3</option>
            <option>4</option>
            <option>5</option>
        </select>
    </div>
    <div class="form-group">
        <label>Birth</label>
        <input type="text" class="form-control" placeholder="zhangsan">
    </div>
    <button type="submit" class="btn btn-primary">添加</button>
</form>

提交的数据格式不对:生日:日期;

2017-12-12;2017/12/12;2017.12.12;

日期的格式化;SpringMVC 将页面提交的值需要转换为指定的类型;

2017-12-12---Date; 类型转换,格式化;

默认日期是按照/的方式;

区分表单是 post 还是 put 提交

<!--发送put请求修改员工数据-->
<!--
1. SpringMVC中配置HiddenHttpMethodFilter;(SpringBoot自动配置好的)
2. 页面创建一个post表单
3. 创建一个input项,name="_method";值就是我们指定的请求方式
-->
<input type="hidden" name="_method" value="put" th:if="${emp!=null}"/>

SpringBoot 的错误处理

SpringBoot 默认的错误处理机制

默认效果:

(1)浏览器,返回一个默认的错误页面

(2)如果是其他客户端,会返回一个 JSON 数据

原理:可以参照 ErrorMVCAutoConfiguration,错误处理的自动配置

给容器中添加了以下组件

1.DefaultErrorAttributes

帮我们在页面共享信息;
@Override
public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
		boolean includeStackTrace) {
	Map<String, Object> errorAttributes = new LinkedHashMap<String, Object>();
	errorAttributes.put("timestamp", new Date());
	addStatus(errorAttributes, requestAttributes);
	addErrorDetails(errorAttributes, requestAttributes, includeStackTrace);
	addPath(errorAttributes, requestAttributes);
	return errorAttributes;
}

2.BasicErrorController:处理默认/error 请求

@Controller
@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {

    @RequestMapping(produces = "text/html")//产生html类型的数据;浏览器发送的请求来到这个方法处理
	public ModelAndView errorHtml(HttpServletRequest request,
			HttpServletResponse response) {
		HttpStatus status = getStatus(request);
		Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(
				request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
		response.setStatus(status.value());

        //去哪个页面作为错误页面;包含页面地址和页面内容
		ModelAndView modelAndView = resolveErrorView(request, response, status, model);
		return (modelAndView == null ? new ModelAndView("error", model) : modelAndView);
	}

	@RequestMapping
	@ResponseBody    //产生json数据,其他客户端来到这个方法处理;
	public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
		Map<String, Object> body = getErrorAttributes(request,
				isIncludeStackTrace(request, MediaType.ALL));
		HttpStatus status = getStatus(request);
		return new ResponseEntity<Map<String, Object>>(body, status);
	}

3.ErrorPageCustomizer

@Value("${error.path:/error}")
private String path = "/error";  系统出现错误以后来到error请求进行处理;(web.xml注册的错误页面规则)

4.DefaultErrorViewResolver

@Override
public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status,
		Map<String, Object> model) {
	ModelAndView modelAndView = resolve(String.valueOf(status), model);
	if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
		modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
	}
	return modelAndView;
}

private ModelAndView resolve(String viewName, Map<String, Object> model) {
    //默认SpringBoot可以去找到一个页面?  error/404
	String errorViewName = "error/" + viewName;

    //模板引擎可以解析这个页面地址就用模板引擎解析
	TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
			.getProvider(errorViewName, this.applicationContext);
	if (provider != null) {
        //模板引擎可用的情况下返回到errorViewName指定的视图地址
		return new ModelAndView(errorViewName, model);
	}
    //模板引擎不可用,就在静态资源文件夹下找errorViewName对应的页面   error/404.html
	return resolveResource(errorViewName, model);
}

步骤:一旦系统出现 4xx 或者 5xx 之类的错误,ErrorPageCustomizer 就会生效(定制错误的响应规则),就会来到/error 请求,就会被 BasicErrorController 处理

(1)响应页面:去哪个页面是由 DefaultErrorViewResolver 解析得到的

protected ModelAndView resolveErrorView(HttpServletRequest request,
      HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
    //所有的ErrorViewResolver得到ModelAndView
   for (ErrorViewResolver resolver : this.errorViewResolvers) {
      ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
      if (modelAndView != null) {
         return modelAndView;
      }
   }
   return null;
}

(2)如何定制响应错误

如何定制错误响应

(1)如何定制错误页面

a.有模板引擎的情况下,error/状态码,将错误页面命名为错误状态码.html 放在模板引擎文件夹里面的 error 文件夹下,发生此状态码的错误就会来到对应的错误页面

可以使用 4xx 和 5xx 作为错误页面的文件名来匹配这种类型的所有错误,精确优先(优先寻找精确的状态码.html)

页面能获取的信息;

timestamp:时间戳

status:状态码

error:错误提示

exception:异常对象

message:异常消息

errors:JSR303 数据校验的错误都在这里

b.没有模板引擎(模板引擎找不到这个错误页面),静态资源文件夹下找;

c.以上都没有错误页面,就是默认来到 SpringBoot 默认的错误提示页面;

(2)如何定制错误的 JSON 数据

  1. 、自定义异常处理&返回定制 JSON 数据;
@ControllerAdvice
public class MyExceptionHandler {

    @ResponseBody
    @ExceptionHandler(UserNotExistException.class)
    public Map<String,Object> handleException(Exception e){
        Map<String,Object> map = new HashMap<>();
        map.put("code","user.notexist");
        map.put("message",e.getMessage());
        return map;
    }
}
//没有自适应效果...
  1. 、转发到/error 进行自适应响应效果处理
 @ExceptionHandler(UserNotExistException.class)
    public String handleException(Exception e, HttpServletRequest request){
        Map<String,Object> map = new HashMap<>();
        //传入我们自己的错误状态码  4xx 5xx,否则就不会进入定制错误页面的解析流程
        /**
         * Integer statusCode = (Integer) request
         .getAttribute("javax.servlet.error.status_code");
         */
        request.setAttribute("javax.servlet.error.status_code",500);
        map.put("code","user.notexist");
        map.put("message",e.getMessage());
        //转发到/error
        return "forward:/error";
    }
  1. 、将我们的定制数据携带出去;

出现错误以后,会来到/error 请求,会被 BasicErrorController 处理,响应出去可以获取的数据是由 getErrorAttributes 得到的(是 AbstractErrorController(ErrorController)规定的方法);

1. 完全来编写一个 ErrorController 的实现类【或者是编写 AbstractErrorController 的子类】,放在容器中;
2. 页面上能用的数据,或者是 JSON 返回能用的数据都是通过 errorAttributes.getErrorAttributes 得到;
容器中 DefaultErrorAttributes.getErrorAttributes();默认进行数据处理的;

自定义 ErrorAttributes

//给容器中加入我们自己定义的ErrorAttributes
@Component
public class MyErrorAttributes extends DefaultErrorAttributes {

    @Override
    public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {
        Map<String, Object> map = super.getErrorAttributes(requestAttributes, includeStackTrace);
        map.put("company","atguigu");
        return map;
    }
}

最终的效果:响应是自适应的,可以通过定制 ErrorAttributes 改变需要返回的内容,

如何配置 servlet 容器

SpringBoot 默认使用的 Tomcat 作为嵌入式的 Servlet 容器

(1)如何定制和修改 servlet 容器的相关配置

1. 修改和server有关的配置(ServerProperties【也是EmbeddedServletContainerCustomizer】);

```properties
server.port=8081
server.context-path=/crud

server.tomcat.uri-encoding=UTF-8

//通用的Servlet容器设置
server.xxx
//Tomcat的设置
server.tomcat.xxx
  1. 编写一个 EmbeddedServletContainerCustomizer:嵌入式的 Servlet 容器的定制器;来修改 Servlet 容器的配置
//SpringBoot1.xxx
@Bean  //一定要将这个定制器加入到容器中
public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
    return new EmbeddedServletContainerCustomizer() {
        //定制嵌入式的Servlet容器相关的规则
        @Override
        public void customize(ConfigurableEmbeddedServletContainer container) {
            container.setPort(8083);
        }
    };
}
//SpringBoot2.xxx
@Bean
public WebServerFactoryCustomizer webServerFactoryCustomizer() {
    return new WebServerFactoryCustomizer<ConfigurableWebServerFactory>() {
        @Override
        public void customize(ConfigurableWebServerFactory factory) {
            factory.setPort(8081);
        }
    };
}

(2)注册三大组件,Servlet、Filter、Listener

由于 SpringBoot 默认是以 jar 包的方式启动嵌入式的 Servlet 容器来启动 SpringBoot 的 Web 应用,没有 web.xml 文件。

注册三大组件用以下方式(在配置类中编写)

ServletRegistrationBean

@Bean
public ServletRegistrationBean myServlet() {
    ServletRegistrationBean<Servlet> servletRegistrationBean = new ServletRegistrationBean<>(new MyServlet(),"/myServlet");   //参数1为自己编写的servlet。参数2是该servlet的映射路径
    return servletRegistrationBean;
}

FilterRegistrationBean

@Bean
public FilterRegistrationBean myFilter(){
    FilterRegistrationBean registrationBean = new FilterRegistrationBean();
    registrationBean.setFilter(new MyFilter());   //添加自己编写的拦截器
    registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));   //拦截路径的数组
    return registrationBean;
}

ServletListenerRegistrationBean

@Bean
public ServletListenerRegistrationBean myListener(){
    ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
    return registrationBean;
}

SpringBoot 帮我们自动 SpringMVC 的时候,自动的注册 SpringMVC 的前端控制器;DIspatcherServlet;

DispatcherServletAutoConfiguration 中:

@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public ServletRegistrationBean dispatcherServletRegistration(
      DispatcherServlet dispatcherServlet) {
   ServletRegistrationBean registration = new ServletRegistrationBean(
         dispatcherServlet, this.serverProperties.getServletMapping());
    //默认拦截: /  所有请求;包静态资源,但是不拦截jsp请求;   /*会拦截jsp
    //可以通过server.servletPath来修改SpringMVC前端控制器默认拦截的请求路径

   registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
   registration.setLoadOnStartup(
         this.webMvcProperties.getServlet().getLoadOnStartup());
   if (this.multipartConfig != null) {
      registration.setMultipartConfig(this.multipartConfig);
   }
   return registration;
}

SpringBoot 能不能支持其他 servlet 容器

替换为其他嵌入式 Servlet 容器

默认支持:

Tomcat(默认使用)

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   引入web模块默认就是使用嵌入式的Tomcat作为Servlet容器;
</dependency>

Jetty

<!-- 引入web模块 -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <exclusions>
      <exclusion>
         <artifactId>spring-boot-starter-tomcat</artifactId>
         <groupId>org.springframework.boot</groupId>
      </exclusion>
   </exclusions>
</dependency>

<!--引入其他的Servlet容器-->
<dependency>
   <artifactId>spring-boot-starter-jetty</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

Undertow

<!-- 引入web模块 -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <exclusions>
      <exclusion>
         <artifactId>spring-boot-starter-tomcat</artifactId>
         <groupId>org.springframework.boot</groupId>
      </exclusion>
   </exclusions>
</dependency>

<!--引入其他的Servlet容器-->
<dependency>
   <artifactId>spring-boot-starter-undertow</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

嵌入式 Servlet 容器自动配置原理

EmbeddedServletContainerAutoConfiguration:嵌入式的 Servlet 容器自动配置

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
//导入BeanPostProcessorsRegistrar:Spring注解版;给容器中导入一些组件
//导入了EmbeddedServletContainerCustomizerBeanPostProcessor:
//后置处理器:bean初始化前后(创建完对象,还没赋值赋值)执行初始化工作
public class EmbeddedServletContainerAutoConfiguration {

    @Configuration
	@ConditionalOnClass({ Servlet.class, Tomcat.class })//判断当前是否引入了Tomcat依赖;
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)//判断当前容器没有用户自己定义EmbeddedServletContainerFactory:嵌入式的Servlet容器工厂;作用:创建嵌入式的Servlet容器
	public static class EmbeddedTomcat {

		@Bean
		public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {
			return new TomcatEmbeddedServletContainerFactory();
		}

	}

    /**
	 * Nested configuration if Jetty is being used.
	 */
	@Configuration
	@ConditionalOnClass({ Servlet.class, Server.class, Loader.class,
			WebAppContext.class })
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedJetty {

		@Bean
		public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory() {
			return new JettyEmbeddedServletContainerFactory();
		}

	}

	/**
	 * Nested configuration if Undertow is being used.
	 */
	@Configuration
	@ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedUndertow {

		@Bean
		public UndertowEmbeddedServletContainerFactory undertowEmbeddedServletContainerFactory() {
			return new UndertowEmbeddedServletContainerFactory();
		}

	}
  1. 、EmbeddedServletContainerFactory(嵌入式 Servlet 容器工厂)

有三个:xxxEmbeddedServletContainerFactory

public interface EmbeddedServletContainerFactory {
   //获取嵌入式的Servlet容器
   EmbeddedServletContainer getEmbeddedServletContainer(
         ServletContextInitializer... initializers);
}
  1. 、EmbeddedServletContainer:(嵌入式的 Servlet 容器)

有三个:xxxEmbeddedServletContainer

  1. 、以 TomcatEmbeddedServletContainerFactory 为例
@Override
public EmbeddedServletContainer getEmbeddedServletContainer(
      ServletContextInitializer... initializers) {
    //创建一个Tomcat
   Tomcat tomcat = new Tomcat();

    //配置Tomcat的基本环境
   File baseDir = (this.baseDirectory != null ? this.baseDirectory
         : createTempDir("tomcat"));
   tomcat.setBaseDir(baseDir.getAbsolutePath());
   Connector connector = new Connector(this.protocol);
   tomcat.getService().addConnector(connector);
   customizeConnector(connector);
   tomcat.setConnector(connector);
   tomcat.getHost().setAutoDeploy(false);
   configureEngine(tomcat.getEngine());
   for (Connector additionalConnector : this.additionalTomcatConnectors) {
      tomcat.getService().addConnector(additionalConnector);
   }
   prepareContext(tomcat.getHost(), initializers);

    //将配置好的Tomcat传入进去,返回一个EmbeddedServletContainer;并且启动Tomcat服务器
   return getTomcatEmbeddedServletContainer(tomcat);
}
  1. 、我们对嵌入式容器的配置修改是怎么生效?
ServerProperties、EmbeddedServletContainerCustomizer  //配置文件,定制器

EmbeddedServletContainerCustomizer:定制器帮我们修改了 Servlet 容器的配置?

怎么修改的原理?

  1. 、容器中导入了 EmbeddedServletContainerCustomizerBeanPostProcessor:后置处理器
//初始化之前
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
      throws BeansException {
    //如果当前初始化的是一个ConfigurableEmbeddedServletContainer类型的组件
   if (bean instanceof ConfigurableEmbeddedServletContainer) {
       //
      postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
   }
   return bean;
}

private void postProcessBeforeInitialization(
			ConfigurableEmbeddedServletContainer bean) {
    //获取所有的定制器,调用每一个定制器的customize方法来给Servlet容器进行属性赋值;
    for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
        customizer.customize(bean);
    }
}

private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {
    if (this.customizers == null) {
        // Look up does not include the parent context
        this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
            this.beanFactory
            //从容器中获取所有这葛类型的组件:EmbeddedServletContainerCustomizer
            //定制Servlet容器,给容器中可以添加一个EmbeddedServletContainerCustomizer类型的组件
            .getBeansOfType(EmbeddedServletContainerCustomizer.class,
                            false, false)
            .values());
        Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
        this.customizers = Collections.unmodifiableList(this.customizers);
    }
    return this.customizers;
}

ServerProperties也是定制器

步骤:

  1. 、SpringBoot 根据导入的依赖情况,给容器中添加相应的 EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】
  2. 、容器中某个组件要创建对象就会惊动后置处理器;EmbeddedServletContainerCustomizerBeanPostProcessor;

只要是嵌入式的 Servlet 容器工厂,后置处理器就工作;

  1. 、后置处理器,从容器中获取所有的 EmbeddedServletContainerCustomizer,调用定制器的定制方法

5)、嵌入式 Servlet 容器启动原理;

什么时候创建嵌入式的 Servlet 容器工厂?什么时候获取嵌入式的 Servlet 容器并启动 Tomcat;

获取嵌入式的 Servlet 容器工厂:

  1. 、SpringBoot 应用启动运行 run 方法
  2. 、refreshContext(context);SpringBoot 刷新 IoC 容器【创建 IoC 容器对象,并初始化容器,创建容器中的每一个组件】;如果是 Web 应用创建 AnnotationConfigEmbeddedWebApplicationContext,否则:AnnotationConfigApplicationContext
  3. 、refresh(context);刷新刚才创建好的 IoC 容器;
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         initMessageSource();

         // Initialize event multicaster for this context.
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         onRefresh();

         // Check for listener beans and register them.
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}
  1. 、 onRefresh(); Web 的 IoC 容器重写了 onRefresh 方法
  2. 、webioc 容器会创建嵌入式的 Servlet 容器;createEmbeddedServletContainer();

6)、获取嵌入式的 Servlet 容器工厂:

EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();

从 IoC 容器中获取 EmbeddedServletContainerFactory 组件;

TomcatEmbeddedServletContainerFactory 创建对象,后置处理器一看是这个对象,就获取所有的定制器来先定制 Servlet 容器的相关配置;

  1. 使用容器工厂获取嵌入式的 Servlet 容器:this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());
  2. 、嵌入式的 Servlet 容器创建对象并启动 Servlet 容器;

先启动嵌入式的 Servlet 容器,再将 IoC 容器中剩下没有创建出的对象获取出来;

==IOC 容器启动创建嵌入式的 Servlet 容器 ==

使用外置的 servlet 容器

嵌入式 Servlet 容器:应用打成可执行的 jar

优点:简单、便携;

缺点:默认不支持 JSP、优化定制比较复杂(使用定制器【ServerProperties、自定义 EmbeddedServletContainerCustomizer】,自己编写嵌入式 Servlet 容器的创建工厂【EmbeddedServletContainerFactory】);

外置的 Servlet 容器:外面安装 Tomcat---应用 war 包的方式打包;

步骤

  1. 、必须创建一个 war 项目;(利用 idea 创建好目录结构)
  2. 、将嵌入式的 Tomcat 指定为 provided;
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-tomcat</artifactId>
   <scope>provided</scope>
</dependency>
  1. 、必须编写一个 SpringBootServletInitializer 的子类,并调用 configure 方法
public class ServletInitializer extends SpringBootServletInitializer {

   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
       //传入SpringBoot应用的主程序
      return application.sources(SpringBoot04WebJspApplication.class);
   }

}
  1. 、启动服务器就可以使用;

原理

jar 包:执行 SpringBoot 主类的 main 方法,启动 IoC 容器,创建嵌入式的 Servlet 容器;

war 包:启动服务器,服务器启动 SpringBoot 应用【SpringBootServletInitializer】,启动 IoC 容器;

servlet3.0(Spring 注解版):

8.2.4 Shared libraries / runtimes pluggability:

规则:

1. 、服务器启动(Web 应用启动)会创建当前 Web 应用里面每一个 jar 包里面 ServletContainerInitializer 实例:
2. 、ServletContainerInitializer 的实现放在 jar 包的 META-INF/services 文件夹下,有一个名为 javax.servlet.ServletContainerInitializer 的文件,内容就是 ServletContainerInitializer 的实现类的全类名
3. 、还可以使用@HandlesTypes,在应用启动的时候加载我们感兴趣的类;

流程:

  1. 、启动 Tomcat
  2. 、org\springframework\spring-web\4.3.14.RELEASE\spring-web-4.3.14.RELEASE.jar!\META-INF\services\javax.servlet.ServletContainerInitializer:

Spring 的 Web 模块里面有这个文件:org.springframework.web.SpringServletContainerInitializer

  1. 、SpringServletContainerInitializer 将@HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到 onStartup 方法的 Set<Class<?>>;为这些 WebApplicationInitializer 类型的类创建实例;
  2. 、每一个 WebApplicationInitializer 都调用自己的 onStartup;

  1. 、相当于我们的 SpringBootServletInitializer 的类会被创建对象,并执行 onStartup 方法
  2. 、SpringBootServletInitializer 实例执行 onStartup 的时候会 createRootApplicationContext;创建容器
protected WebApplicationContext createRootApplicationContext(
      ServletContext servletContext) {
    //1、创建SpringApplicationBuilder
   SpringApplicationBuilder builder = createSpringApplicationBuilder();
   StandardServletEnvironment environment = new StandardServletEnvironment();
   environment.initPropertySources(servletContext, null);
   builder.environment(environment);
   builder.main(getClass());
   ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
   if (parent != null) {
      this.logger.info("Root context already created (using as parent).");
      servletContext.setAttribute(
            WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
      builder.initializers(new ParentContextApplicationContextInitializer(parent));
   }
   builder.initializers(
         new ServletContextApplicationContextInitializer(servletContext));
   builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);

    //调用configure方法,子类重写了这个方法,将SpringBoot的主程序类传入了进来
   builder = configure(builder);

    //使用builder创建一个Spring应用
   SpringApplication application = builder.build();
   if (application.getSources().isEmpty() && AnnotationUtils
         .findAnnotation(getClass(), Configuration.class) != null) {
      application.getSources().add(getClass());
   }
   Assert.state(!application.getSources().isEmpty(),
         "No SpringApplication sources have been defined. Either override the "
               + "configure method or add an @Configuration annotation");
   // Ensure error pages are registered
   if (this.registerErrorPageFilter) {
      application.getSources().add(ErrorPageFilterConfiguration.class);
   }
    //启动Spring应用
   return run(application);
}
  1. 、Spring 的应用就启动并且创建 IoC 容器
public ConfigurableApplicationContext run(String... args) {
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   ConfigurableApplicationContext context = null;
   FailureAnalyzers analyzers = null;
   configureHeadlessProperty();
   SpringApplicationRunListeners listeners = getRunListeners(args);
   listeners.starting();
   try {
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(
            args);
      ConfigurableEnvironment environment = prepareEnvironment(listeners,
            applicationArguments);
      Banner printedBanner = printBanner(environment);
      context = createApplicationContext();
      analyzers = new FailureAnalyzers(context);
      prepareContext(context, environment, listeners, applicationArguments,
            printedBanner);

       //刷新IOC容器
      refreshContext(context);
      afterRefresh(context, applicationArguments);
      listeners.finished(context, null);
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass)
               .logStarted(getApplicationLog(), stopWatch);
      }
      return context;
   }
   catch (Throwable ex) {
      handleRunFailure(context, listeners, analyzers, ex);
      throw new IllegalStateException(ex);
   }
}

== 启动 Servlet 容器,再启动 SpringBoot 应用 ==

SpringBoot 与数据访问

JDBC

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
spring:
  datasource:
    password: 458974
    username: root
    url: jdbc:mysql://localhost:3306/crm?serverTimezone=UTC
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    initialization-mode: always
    #   数据源其他配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
    filters: stat,wall,stf4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

错误

java.sql.SQLException: The server time zone value '�й���׼ʱ��' is unrecognized or represents more than one time zone. You must configure either the server or JDBC driver (via the serverTimezone configuration property) to use a more specifc time zone value if you want to utilize time zone support.

在url中加上serverTimezone=UTC

效果:

默认是用 org.apache.tomcat.jdbc.pool.DataSource 作为数据源;
数据源的相关配置都在 DataSourceProperties 里面;

自动配置原理:

org.springframework.boot.autoconfigure.jdbc:

  1. 参考 DataSourceConfiguration,根据配置创建数据源,默认使用 Tomcat 连接池;可以使用 spring.datasource.type 指定自定义的数据源类型;
  2. SpringBoot 默认可以支持;
org.apache.tomcat.jdbc.pool.DataSource、HikariDataSource、BasicDataSource、
  1. 自定义数据源类型
/**
 * Generic DataSource configuration.
 */
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(name = "spring.datasource.type")
static class Generic {

   @Bean
   public DataSource dataSource(DataSourceProperties properties) {
       //使用DataSourceBuilder创建数据源,利用反射创建响应type的数据源,并且绑定相关属性
      return properties.initializeDataSourceBuilder().build();
   }

}
  1. DataSourceInitializer:ApplicationListener
作用:
1. 、runSchemaScripts();运行建表语句;
2. 、runDataScripts();运行插入数据的 SQL 语句;

默认只需要将文件命名为:

schema-*.sql、data-*.sql
默认规则:schema.sql,schema-all.sql;
可以使用
	schema:
      - classpath:department.sql
      指定位置
  1. 操作数据库:自动配置了 JdbcTemplate 操作数据库

2、整合 Druid 数据源

导入druid数据源
@Configuration
public class DruidConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid() {
        return new DruidDataSource();
    }

    //配置Druid的监控
    //1.配置一个管理后台的servlet
    @Bean
    public ServletRegistrationBean statViewServlet() {
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
        Map<String,String> initParams = new HashMap<>();
        initParams.put("loginUsername","admin");
        initParams.put("loginPassword","458974");
        initParams.put("allow","");      //不填写值的话就是默认所有
        initParams.put("deny","");
        bean.setInitParameters(initParams);
        return bean;
    }

    //2.配合一个web监控的filter
    public FilterRegistrationBean webStatFilter() {
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());
        Map<String,String> initParams = new HashMap<>();
        initParams.put("exclusions","*.js,*.css,/druid/*");
        bean.setInitParameters(initParams);
        bean.setUrlPatterns(Arrays.asList("/*"));
        return bean;
    }
}

3、整合 MyBatis

<!-- 这不是spring官方提供的,由mybatis自己做的适配包 -->
<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>1.3.1</version>
</dependency>

4)、注解版

//指定这是一个操作数据库的mapper
@Mapper
public interface SysUserMapper {
    @Select("select * from sys_user where user_id = #{id} ")
    public SysUser getUserById(Long id);
}

@Options(useGeneratedKeys = true,keyProperty = "id")  //回传自增主键,keyProperty是对象中的属性
    @Insert("insert into department(departmentName) values(#{departmentName})")
    public int insertDept(Department department);

假定我们要使数据库字段 user_name 和实体的 userName 属性匹配,那么需要自定义配置规则,如下

@org.springframework.context.annotation.Configuration
public class MyBatisConfig {

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return new ConfigurationCustomizer() {
            @Override
            public void customize(Configuration configuration) {
                configuration.setMapUnderscoreToCamelCase(true);  //开启驼峰命名规则
            }
        };
    }
}

又或者可以在配置文件中配置开启驼峰映射

mybatis:
  configuration:
    map-underscore-to-camel-case: true

一个注解扫描所有包,不需要每个注解加@Mapper

使用MapperScan批量扫描所有的Mapper接口;
@MapperScan(value = "com.atguigu.springboot.mapper")
@SpringBootApplication
public class SpringBoot06DataMybatisApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringBoot06DataMybatisApplication.class, args);
	}
}

5)、配置文件版

mybatis:
  config-location: classpath:mybatis/mybatis-config.xml 指定全局配置文件的位置
  mapper-locations: classpath:mybatis/mapper/*.xml  指定sql映射文件的位置

上面配合的驼峰映射 configuration: 无法与 config-location: 一起使用,换在 XML 中配置

<configuration>
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
</configuration>

更多使用参照

http://www.mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/

4、整合 SpringData JPA

1)、SpringData 简介

2)、整合 SpringData JPA

JPA:ORM(Object Relational Mapping);

  1. 、编写一个实体类(bean)和数据表进行映射,并且配置好映射关系;
//使用JPA注解配置映射关系
@Entity   //告诉JPA这是一个实体类(和数据表映射的类)
@JsonIgnoreProperties(value = {"hibernateLazyInitializer", "handler"})   //设置当有属性为null值时任可转为json,不写的话存在null值会报错,错误信息如下
@Table(name = "sys_user")   //@Table来指定和哪个数据表对应;如果省略默认表名就是user;
public class SysUser implements Serializable {
    @Id //这是一个主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
    private long user_id;
    @Column(name = "user_code",length = 50) //这是和数据表对应的一个列
    private String user_code;
    @Column  //省略默认列名就是属性名
    private String user_name;
    @Column
    private String user_password;
    @Column
    private Character user_state;

    省略getter/setter
}
com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class org.hibernate.proxy.pojo.bytebuddy.ByteBuddyInterceptor and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) (through reference chain: com.wu.srpingbootdata.pojo.SysUser$HibernateProxy$cGGP5atS["hibernateLazyInitializer"])

  1. 、编写一个 Dao 接口来操作实体类对应的数据表(Repository)
//继承JpaRepository来完成对数据库的操作
//泛型1是要操作的对象,2是主键的ID
public interface UserRepository extends JpaRepository<User,Integer> {
}
  1. 、基本的配置 JpaProperties
spring:
 jpa:
    hibernate:
#     更新或者创建数据表结构
      ddl-auto: update
#    控制台显示SQL
    show-sql: true
@RequestMapping("/hei")
@ResponseBody
public SysUser hei() {
    SysUser sysUser = userRepository.getOne(3l);
    return sysUser;
}

七、启动配置原理

几个重要的事件回调机制

配置在 META-INF/spring.factories

ApplicationContextInitializer

SpringApplicationRunListener

只需要放在 IoC 容器中

ApplicationRunner

CommandLineRunner

启动流程:

1、创建 SpringApplication 对象

initialize(sources);
private void initialize(Object[] sources) {
    //保存主配置类
    if (sources != null && sources.length > 0) {
        this.sources.addAll(Arrays.asList(sources));
    }
    //判断当前是否一个web应用
    this.webEnvironment = deduceWebEnvironment();
    //从类路径下找到META-INF/spring.factories配置的所有ApplicationContextInitializer;然后保存起来
    setInitializers((Collection) getSpringFactoriesInstances(
        ApplicationContextInitializer.class));
    //从类路径下找到ETA-INF/spring.factories配置的所有ApplicationListener
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    //从多个配置类中找到有main方法的主配置类
    this.mainApplicationClass = deduceMainApplicationClass();
}

2、运行 run 方法

public ConfigurableApplicationContext run(String... args) {
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   ConfigurableApplicationContext context = null;
   FailureAnalyzers analyzers = null;
   configureHeadlessProperty();

   //获取SpringApplicationRunListeners;从类路径下META-INF/spring.factories
   SpringApplicationRunListeners listeners = getRunListeners(args);
    //回调所有的获取SpringApplicationRunListener.starting()方法
   listeners.starting();
   try {
       //封装命令行参数
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(
            args);
      //准备环境
      ConfigurableEnvironment environment = prepareEnvironment(listeners,
            applicationArguments);
       		//创建环境完成后回调SpringApplicationRunListener.environmentPrepared();表示环境准备完成

      Banner printedBanner = printBanner(environment);

       //创建ApplicationContext;决定创建web的ioc还是普通的ioc
      context = createApplicationContext();

      analyzers = new FailureAnalyzers(context);
       //准备上下文环境;将environment保存到ioc中;而且applyInitializers();
       //applyInitializers():回调之前保存的所有的ApplicationContextInitializer的initialize方法
       //回调所有的SpringApplicationRunListener的contextPrepared();
       //
      prepareContext(context, environment, listeners, applicationArguments,
            printedBanner);
       //prepareContext运行完成以后回调所有的SpringApplicationRunListener的contextLoaded();

       //s刷新容器;ioc容器初始化(如果是web应用还会创建嵌入式的Tomcat);Spring注解版
       //扫描,创建,加载所有组件的地方;(配置类,组件,自动配置)
      refreshContext(context);
       //从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
       //ApplicationRunner先回调,CommandLineRunner再回调
      afterRefresh(context, applicationArguments);
       //所有的SpringApplicationRunListener回调finished方法
      listeners.finished(context, null);
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass)
               .logStarted(getApplicationLog(), stopWatch);
      }
       //整个SpringBoot应用启动完成以后返回启动的ioc容器;
      return context;
   }
   catch (Throwable ex) {
      handleRunFailure(context, listeners, analyzers, ex);
      throw new IllegalStateException(ex);
   }
}

3、事件监听机制

配置在 META-INF/spring.factories

ApplicationContextInitializer

public class HelloApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializer...initialize..."+applicationContext);
    }
}

SpringApplicationRunListener

public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {

    //必须有的构造器
    public HelloSpringApplicationRunListener(SpringApplication application, String[] args){

    }

    @Override
    public void starting() {
        System.out.println("SpringApplicationRunListener...starting...");
    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        Object o = environment.getSystemProperties().get("os.name");
        System.out.println("SpringApplicationRunListener...environmentPrepared.."+o);
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("SpringApplicationRunListener...contextPrepared...");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("SpringApplicationRunListener...contextLoaded...");
    }

    @Override
    public void finished(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("SpringApplicationRunListener...finished...");
    }
}

配置(META-INF/spring.factories)

org.springframework.context.ApplicationContextInitializer=\
com.atguigu.springboot.listener.HelloApplicationContextInitializer

org.springframework.boot.SpringApplicationRunListener=\
com.atguigu.springboot.listener.HelloSpringApplicationRunListener

只需要放在 IoC 容器中

ApplicationRunner

@Component
public class HelloApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("ApplicationRunner...run....");
    }
}

CommandLineRunner

@Component
public class HelloCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
    }
}

八、自定义 starter

starter:

1. 这个场景需要使用到的依赖是什么?
2. 如何编写自动配置
@Configuration  //指定这个类是一个配置类
@ConditionalOnXXX  //在指定条件成立的情况下自动配置类生效
@AutoConfigureAfter  //指定自动配置类的顺序
@Bean  //给容器中添加组件

@ConfigurationPropertie结合相关xxxProperties类来绑定相关的配置
@EnableConfigurationProperties //让xxxProperties生效加入到容器中

自动配置类要能加载
将需要启动就加载的自动配置类,配置在META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
3. 模式:

启动器只用来做依赖导入;

专门来写一个自动配置模块;

启动器依赖自动配置;别人只需要引入启动器(starter)

mybatis-spring-boot-starter;自定义启动器名-spring-boot-starter

步骤:

  1. 、启动器模块
<?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.atguigu.starter</groupId>
    <artifactId>atguigu-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--启动器-->
    <dependencies>

        <!--引入自动配置模块-->
        <dependency>
            <groupId>com.atguigu.starter</groupId>
            <artifactId>atguigu-spring-boot-starter-autoconfigurer</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>
  1. 、自动配置模块
<?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.atguigu.starter</groupId>
   <artifactId>atguigu-spring-boot-starter-autoconfigurer</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>atguigu-spring-boot-starter-autoconfigurer</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.10.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>

      <!--引入spring-boot-starter;所有starter的基本配置-->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>

   </dependencies>



</project>

package com.atguigu.starter;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "atguigu.hello")
public class HelloProperties {

    private String prefix;
    private String suffix;

    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }
}

package com.atguigu.starter;

public class HelloService {

    HelloProperties helloProperties;

    public HelloProperties getHelloProperties() {
        return helloProperties;
    }

    public void setHelloProperties(HelloProperties helloProperties) {
        this.helloProperties = helloProperties;
    }

    public String sayHellAtguigu(String name){
        return helloProperties.getPrefix()+"-" +name + helloProperties.getSuffix();
    }
}

package com.atguigu.starter;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnWebApplication //web应用才生效
@EnableConfigurationProperties(HelloProperties.class)
public class HelloServiceAutoConfiguration {

    @Autowired
    HelloProperties helloProperties;
    @Bean
    public HelloService helloService(){
        HelloService service = new HelloService();
        service.setHelloProperties(helloProperties);
        return service;
    }
}

更多 SpringBoot 整合示例

https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples