一、Spring Boot 入门

1、Spring Boot 简介

简化Spring应用开发的一个框架; 整个Spring技术栈的一个大整合; J2EE开发的一站式解决方案;

2、微服务

2014,martin fowler
微服务:架构风格(服务微化)
一个应用应该是一组小型服务;可以通过HTTP的方式进行互通;
单体应用:ALL IN ONE
微服务:每一个功能元素最终都是一个可独立替换和独立升级的软件单元;
详细参照微服务文档

3、环境准备

http://www.gulixueyuan.com/ 谷粒学院
环境约束
–jdk1.8:Spring Boot 推荐jdk1.7及以上;java version “1.8.0_112”
–maven3.x:maven 3.3以上版本;Apache Maven 3.3.9
–IntelliJIDEA2017:IntelliJ IDEA 2017.2.2 x64、STS
–SpringBoot 1.5.9.RELEASE:1.5.9;
统一环境;

1、MAVEN设置;

给maven 的settings.xml配置文件的profiles标签添加

  1. <profile>
  2. <id>jdk-1.8</id>
  3. <activation>
  4. <activeByDefault>true</activeByDefault>
  5. <jdk>1.8</jdk>
  6. </activation>
  7. <properties>
  8. <maven.compiler.source>1.8</maven.compiler.source>
  9. <maven.compiler.target>1.8</maven.compiler.target>
  10. <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
  11. </properties>
  12. </profile>

2、IDEA设置

整合maven进来;
Spring Boot - 图1
Spring Boot - 图2

4、Spring Boot HelloWorld

一个功能:
浏览器发送hello请求,服务器接受请求并处理,响应Hello World字符串;

1、创建一个maven工程;(jar)

2、导入spring boot相关的依赖

  1. <parent>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-parent</artifactId>
  4. <version>1.5.9.RELEASE</version>
  5. </parent>
  6. <dependencies>
  7. <dependency>
  8. <groupId>org.springframework.boot</groupId>
  9. <artifactId>spring-boot-starter-web</artifactId>
  10. </dependency>
  11. </dependencies>

3、编写一个主程序;启动Spring Boot应用

  1. /**
  2. * @SpringBootApplication 来标注一个主程序类,说明这是一个Spring Boot应用
  3. */
  4. @SpringBootApplication
  5. public class HelloWorldMainApplication {
  6. public static void main(String[] args) {
  7. // Spring应用启动起来
  8. SpringApplication.run(HelloWorldMainApplication.class,args);
  9. }
  10. }

4、编写相关的Controller、Service

  1. @Controller
  2. public class HelloController {
  3. @ResponseBody
  4. @RequestMapping("/hello")
  5. public String hello(){
  6. return "Hello World!";
  7. }
  8. }

5、运行主程序测试

6、简化部署

  1. <!-- 这个插件,可以将应用打包成一个可执行的jar包;-->
  2. <build>
  3. <plugins>
  4. <plugin>
  5. <groupId>org.springframework.boot</groupId>
  6. <artifactId>spring-boot-maven-plugin</artifactId>
  7. </plugin>
  8. </plugins>
  9. </build>

将这个应用打成jar包,直接使用java -jar的命令进行执行;

5、Hello World探究

1、POM文件

1、父项目

  1. <parent>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-parent</artifactId>
  4. <version>1.5.9.RELEASE</version>
  5. </parent>
  6. 他的父项目是
  7. <parent>
  8. <groupId>org.springframework.boot</groupId>
  9. <artifactId>spring-boot-dependencies</artifactId>
  10. <version>1.5.9.RELEASE</version>
  11. <relativePath>../../spring-boot-dependencies</relativePath>
  12. </parent>
  13. 他来真正管理Spring Boot应用里面的所有依赖版本;

Spring Boot的版本仲裁中心;
以后我们导入依赖默认是不需要写版本;(没有在dependencies里面管理的依赖自然需要声明版本号)

2、启动器

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>

spring-boot-starter-web:
spring-boot-starter:spring-boot场景启动器;帮我们导入了web模块正常运行所依赖的组件;
Spring Boot将所有的功能场景都抽取出来,做成一个个的starters(启动器),只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器

2、主程序类,主入口类

  1. /**
  2. * @SpringBootApplication 来标注一个主程序类,说明这是一个Spring Boot应用
  3. */
  4. @SpringBootApplication
  5. public class HelloWorldMainApplication {
  6. public static void main(String[] args) {
  7. // Spring应用启动起来
  8. SpringApplication.run(HelloWorldMainApplication.class,args);
  9. }
  10. }

@SpringBootApplication: Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类,SpringBoot就应该运行这个类的main方法来启动SpringBoot应用;

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Inherited
  5. @SpringBootConfiguration
  6. @EnableAutoConfiguration
  7. @ComponentScan(excludeFilters = {
  8. @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
  9. @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
  10. public @interface SpringBootApplication {

@SpringBootConfiguration:Spring Boot的配置类;
标注在某个类上,表示这是一个Spring Boot的配置类;
@Configuration:配置类上来标注这个注解;
配置类 ——- 配置文件;配置类也是容器中的一个组件;_@_Component
@EnableAutoConfiguration:开启自动配置功能;
以前我们需要配置的东西,Spring Boot帮我们自动配置;@EnableAutoConfiguration告诉SpringBoot开启自动配置功能;这样自动配置才能生效;

  1. @AutoConfigurationPackage
  2. @Import(EnableAutoConfigurationImportSelector.class)
  3. public @interface EnableAutoConfiguration {
  1. @**AutoConfigurationPackage**:自动配置包<br /> @**Import**(AutoConfigurationPackages.Registrar.class):<br /> Spring的底层注解@Import,给容器中导入一个组件;导入的组件由AutoConfigurationPackages.Registrar.class;<br />将主配置类(@SpringBootApplication标注的类)的所在包及下面所有子包里面的所有组件扫描到Spring容器;<br /> @**Import**(EnableAutoConfigurationImportSelector.class);<br /> 给容器中导入组件?<br /> **EnableAutoConfigurationImportSelector**:导入哪些组件的选择器;<br /> 将所有需要导入的组件以全类名的方式返回;这些组件就会被添加到容器中;<br /> 会给容器中导入非常多的自动配置类(xxxAutoConfiguration);就是给容器中导入这个场景需要的所有组件,并配置好这些组件; ![](images/%E6%90%9C%E7%8B%97%E6%88%AA%E5%9B%BE20180129224104.png#)<br />有了自动配置类,免去了我们手动编写配置注入功能组件等的工作;<br /> SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,classLoader);<br />==Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值,将这些值作为自动配置类导入到容器中,自动配置类就生效,帮我们进行自动配置工作;==以前我们需要自己配置的东西,自动配置类都帮我们;<br />J2EE的整体整合解决方案和自动配置都在spring-boot-autoconfigure-1.5.9.RELEASE.jar;<br />Spring注解版(谷粒学院)

6、使用Spring Initializer快速创建Spring Boot项目

1、IDEA:使用 Spring Initializer快速创建项目

IDE都支持使用Spring的项目创建向导快速创建一个Spring Boot项目;
选择我们需要的模块;向导会联网创建Spring Boot项目;
默认生成的Spring Boot项目;

  • 主程序已经生成好了,我们只需要我们自己的逻辑
  • resources文件夹中目录结构
    • static:保存所有的静态资源; js css images;
    • templates:保存所有的模板页面;(Spring Boot默认jar包使用嵌入式的Tomcat,默认不支持JSP页面);可以使用模板引擎(freemarker、thymeleaf);
    • application.properties:Spring Boot应用的配置文件;可以修改一些默认设置;

      2、STS使用 Spring Starter Project快速创建项目


二、配置文件

1、配置文件

SpringBoot使用一个全局的配置文件,配置文件名是固定的;
•application.properties
•application.yml
配置文件的作用:修改SpringBoot自动配置的默认值;SpringBoot在底层都给我们自动配置好;
YAML(YAML Ain’t Markup Language)
YAML A Markup Language:是一个标记语言
YAML isn’t Markup Language:不是一个标记语言;
标记语言:
以前的配置文件;大多都使用的是 xxxx.xml文件;
YAML:以数据为中心,比json、xml等更适合做配置文件;
YAML:配置例子

  1. server:
  2. port: 8081
  1. XML
  1. <server>
  2. <port>8081</port>
  3. </server>

2、YAML语法:

1、基本语法

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

  1. server:
  2. port: 8081
  3. path: /hello

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

2、值的写法

字面量:普通的值(数字,字符串,布尔)

  1. k: v:字面直接来写;<br /> 字符串默认不用加上单引号或者双引号;<br /> "":双引号;不会转义字符串里面的特殊字符;特殊字符会作为本身想表示的意思<br /> name: "zhangsan \n lisi":输出;zhangsan 换行 lisi<br /> '':单引号;会转义特殊字符,特殊字符最终只是一个普通的字符串数据<br /> name: zhangsan \n lisi’:输出;zhangsan \n lisi

对象、Map(属性和值)(键值对):

  1. k: v:在下一行来写对象的属性和值的关系;注意缩进<br /> 对象还是k: v的方式
  1. friends:
  2. lastName: zhangsan
  3. age: 20

行内写法:

  1. friends: {lastName: zhangsan,age: 18}

数组(List、Set):

用- 值表示数组中的一个元素

  1. pets:
  2. - cat
  3. - dog
  4. - pig

行内写法

  1. pets: [cat,dog,pig]

3、配置文件值注入

配置文件

  1. person:
  2. lastName: hello
  3. age: 18
  4. boss: false
  5. birth: 2017/12/12
  6. maps: {k1: v1,k2: 12}
  7. lists:
  8. - lisi
  9. - zhaoliu
  10. dog:
  11. name: 小狗
  12. age: 12

javaBean:

  1. /**
  2. * 将配置文件中配置的每一个属性的值,映射到这个组件中
  3. * @ConfigurationProperties:告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定;
  4. * prefix = "person":配置文件中哪个下面的所有属性进行一一映射
  5. *
  6. * 只有这个组件是容器中的组件,才能容器提供的@ConfigurationProperties功能;
  7. *
  8. */
  9. @Component
  10. @ConfigurationProperties(prefix = "person")
  11. public class Person {
  12. private String lastName;
  13. private Integer age;
  14. private Boolean boss;
  15. private Date birth;
  16. private Map<String,Object> maps;
  17. private List<Object> lists;
  18. private Dog dog;

我们可以导入配置文件处理器,以后编写配置就有提示了

  1. <!--导入配置文件处理器,配置文件进行绑定就会有提示-->
  2. <dependency>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-configuration-processor</artifactId>
  5. <optional>true</optional>
  6. </dependency>

1、properties配置文件在idea中默认utf-8可能会乱码

调整
Spring Boot - 图3

2、@Value获取值和@ConfigurationProperties获取值比较

@ConfigurationProperties _@_Value
功能 批量注入配置文件中的属性 一个个指定
松散绑定(松散语法) 支持 不支持
SpEL 不支持 支持
JSR303数据校验 支持 不支持
复杂类型封装 支持 不支持

配置文件yml还是properties他们都能获取到值;
如果说,我们只是在某个业务逻辑中需要获取一下配置文件中的某项值,使用@Value;
如果说,我们专门编写了一个javaBean来和配置文件进行映射,我们就直接使用@ConfigurationProperties;

3、配置文件注入值数据校验

  1. @Component
  2. @ConfigurationProperties(prefix = "person")
  3. @Validated
  4. public class Person {
  5. /**
  6. * <bean class="Person">
  7. * <property name="lastName" value="字面量/${key}从环境变量、配置文件中获取值/#{SpEL}"></property>
  8. * <bean/>
  9. */
  10. //lastName必须是邮箱格式
  11. @Email
  12. //@Value("${person.last-name}")
  13. private String lastName;
  14. //@Value("#{11*2}")
  15. private Integer age;
  16. //@Value("true")
  17. private Boolean boss;
  18. private Date birth;
  19. private Map<String,Object> maps;
  20. private List<Object> lists;
  21. private Dog dog;

4、@PropertySource&@ImportResource&_@_Bean

@PropertySource:加载指定的配置文件;

  1. /**
  2. * 将配置文件中配置的每一个属性的值,映射到这个组件中
  3. * @ConfigurationProperties:告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定;
  4. * prefix = "person":配置文件中哪个下面的所有属性进行一一映射
  5. *
  6. * 只有这个组件是容器中的组件,才能容器提供的@ConfigurationProperties功能;
  7. * @ConfigurationProperties(prefix = "person")默认从全局配置文件中获取值;
  8. *
  9. */
  10. @PropertySource(value = {"classpath:person.properties"})
  11. @Component
  12. @ConfigurationProperties(prefix = "person")
  13. //@Validated
  14. public class Person {
  15. /**
  16. * <bean class="Person">
  17. * <property name="lastName" value="字面量/${key}从环境变量、配置文件中获取值/#{SpEL}"></property>
  18. * <bean/>
  19. */
  20. //lastName必须是邮箱格式
  21. // @Email
  22. //@Value("${person.last-name}")
  23. private String lastName;
  24. //@Value("#{11*2}")
  25. private Integer age;
  26. //@Value("true")
  27. private Boolean boss;

@ImportResource:导入Spring的配置文件,让配置文件里面的内容生效;
Spring Boot里面没有Spring的配置文件,我们自己编写的配置文件,也不能自动识别;
想让Spring的配置文件生效,加载进来;@ImportResource标注在一个配置类上

  1. @ImportResource(locations = {"classpath:beans.xml"})
  2. 导入Spring的配置文件让其生效

不来编写Spring的配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5. <bean id="helloService" class="com.atguigu.springboot.service.HelloService"></bean>
  6. </beans>

SpringBoot推荐给容器中添加组件的方式;推荐使用全注解的方式
1、配置类_@_Configuration ———>Spring配置文件
2、使用_@_Bean 给容器中添加组件

  1. /**
  2. * @Configuration:指明当前类是一个配置类;就是来替代之前的Spring配置文件
  3. *
  4. * 在配置文件中用<bean><bean/>标签添加组件
  5. *
  6. */
  7. @Configuration
  8. public class MyAppConfig {
  9. //将方法的返回值添加到容器中;容器中这个组件默认的id就是方法名
  10. @Bean
  11. public HelloService helloService02(){
  12. System.out.println("配置类@Bean给容器中添加组件了...");
  13. return new HelloService();
  14. }
  15. }

4、配置文件占位符

1、随机数

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

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

  1. person.last-name=张三${random.uuid}
  2. person.age=${random.int}
  3. person.birth=2017/12/15
  4. person.boss=false
  5. person.maps.k1=v1
  6. person.maps.k2=14
  7. person.lists=a,b,c
  8. person.dog.name=${person.hello:hello}_dog
  9. person.dog.age=15

5、Profile

1、多Profile文件

我们在主配置文件编写的时候,文件名可以是 application-{profile}.properties/yml
默认使用application.properties的配置;

2、yml支持多文档块方式

  1. server:
  2. port: 8081
  3. spring:
  4. profiles:
  5. active: prod
  6. ---
  7. server:
  8. port: 8083
  9. spring:
  10. profiles: dev
  11. ---
  12. server:
  13. port: 8084
  14. spring:
  15. profiles: prod #指定属于哪个环境

3、激活指定profile

  1. 1、在配置文件中指定 spring.profiles.active=dev<br /> 2、命令行:<br /> java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev;<br /> 可以直接在测试的时候,配置传入命令行参数<br /> 3、虚拟机参数;<br /> -Dspring.profiles.active=dev

6、配置文件加载位置

springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件
–file:./config/
–file:./
–classpath:/config/
–classpath:/
优先级由高到底,高优先级的配置会覆盖低优先级的配置;
SpringBoot会从这四个位置全部加载主配置文件;互补配置
我们还可以通过spring.config.location来改变默认的配置文件位置
项目打包好以后,我们可以使用命令行参数的形式,启动项目的时候来指定配置文件的新位置;指定配置文件和默认加载的这些配置文件共同起作用形成互补配置;
java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar —spring.config.location=G:/application.properties

7、外部配置加载顺序

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指定的默认属性
所有支持的配置加载来源;
参考官方文档

8、自动配置原理

配置文件到底能写什么?怎么写?自动配置原理;
配置文件能配置的属性参照

1、自动配置原理:

1)、SpringBoot启动的时候加载主配置类,开启了自动配置功能 @EnableAutoConfiguration
2)、@EnableAutoConfiguration 作用:

  • 利用EnableAutoConfigurationImportSelector给容器中导入一些组件?
  • 可以查看selectImports()方法的内容;
  • List configurations = getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置

    1. SpringFactoriesLoader.loadFactoryNames()
    2. 扫描所有jar包类路径下 META-INF/spring.factories
    3. 把扫描到的这些文件的内容包装成properties对象
    4. properties中获取到EnableAutoConfiguration.class类(类名)对应的值,然后把他们添加在容器中

    将 类路径下 META-INF/spring.factories 里面配置的所有EnableAutoConfiguration的值加入到了容器中;

    1. # Auto Configure
    2. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    3. org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
    4. org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
    5. org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
    6. org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
    7. org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
    8. org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
    9. org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
    10. org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
    11. org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
    12. org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
    13. org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
    14. org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
    15. org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
    16. org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
    17. org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
    18. org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
    19. org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
    20. org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
    21. org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
    22. org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
    23. org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
    24. org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
    25. org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
    26. org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
    27. org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
    28. org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
    29. org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
    30. org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
    31. org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
    32. org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
    33. org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
    34. org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
    35. org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
    36. org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
    37. org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
    38. org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
    39. org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
    40. org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
    41. org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
    42. org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
    43. org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
    44. org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
    45. org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
    46. org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
    47. org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
    48. org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
    49. org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
    50. org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
    51. org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
    52. org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
    53. org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
    54. org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
    55. org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
    56. org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
    57. org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
    58. org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
    59. org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
    60. org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
    61. org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
    62. org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
    63. org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
    64. org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,\
    65. org.springframework.boot.autoconfigure.mobile.DeviceDelegatingViewResolverAutoConfiguration,\
    66. org.springframework.boot.autoconfigure.mobile.SitePreferenceAutoConfiguration,\
    67. org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
    68. org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
    69. org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
    70. org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
    71. org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
    72. org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
    73. org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,\
    74. org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\
    75. org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,\
    76. org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
    77. org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
    78. org.springframework.boot.autoconfigure.social.SocialWebAutoConfiguration,\
    79. org.springframework.boot.autoconfigure.social.FacebookAutoConfiguration,\
    80. org.springframework.boot.autoconfigure.social.LinkedInAutoConfiguration,\
    81. org.springframework.boot.autoconfigure.social.TwitterAutoConfiguration,\
    82. org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
    83. org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
    84. org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
    85. org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
    86. org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
    87. org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,\
    88. org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
    89. org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration,\
    90. org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration,\
    91. org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
    92. org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
    93. org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
    94. org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration,\
    95. org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
    96. org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration,\
    97. org.springframework.boot.autoconfigure.websocket.WebSocketMessagingAutoConfiguration,\
    98. org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

    每一个这样的 xxxAutoConfiguration类都是容器中的一个组件,都加入到容器中;用他们来做自动配置;
    3)、每一个自动配置类进行自动配置功能;
    4)、以HttpEncodingAutoConfiguration(Http编码自动配置)为例解释自动配置原理;

    1. @Configuration //表示这是一个配置类,以前编写的配置文件一样,也可以给容器中添加组件
    2. @EnableConfigurationProperties(HttpEncodingProperties.class) //启动指定类的ConfigurationProperties功能;将配置文件中对应的值和HttpEncodingProperties绑定起来;并把HttpEncodingProperties加入到ioc容器中
    3. @ConditionalOnWebApplication //Spring底层@Conditional注解(Spring注解版),根据不同的条件,如果满足指定的条件,整个配置类里面的配置就会生效; 判断当前应用是否是web应用,如果是,当前配置类生效
    4. @ConditionalOnClass(CharacterEncodingFilter.class) //判断当前项目有没有这个类CharacterEncodingFilter;SpringMVC中进行乱码解决的过滤器;
    5. @ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true) //判断配置文件中是否存在某个配置 spring.http.encoding.enabled;如果不存在,判断也是成立的
    6. //即使我们配置文件中不配置pring.http.encoding.enabled=true,也是默认生效的;
    7. public class HttpEncodingAutoConfiguration {
    8. //他已经和SpringBoot的配置文件映射了
    9. private final HttpEncodingProperties properties;
    10. //只有一个有参构造器的情况下,参数的值就会从容器中拿
    11. public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
    12. this.properties = properties;
    13. }
    14. @Bean //给容器中添加一个组件,这个组件的某些值需要从properties中获取
    15. @ConditionalOnMissingBean(CharacterEncodingFilter.class) //判断容器没有这个组件?
    16. public CharacterEncodingFilter characterEncodingFilter() {
    17. CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
    18. filter.setEncoding(this.properties.getCharset().name());
    19. filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
    20. filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
    21. return filter;
    22. }

    根据当前不同的条件判断,决定这个配置类是否生效?
    一但这个配置类生效;这个配置类就会给容器中添加各种组件;这些组件的属性是从对应的properties类中获取的,这些类里面的每一个属性又是和配置文件绑定的;
    5)、所有在配置文件中能配置的属性都是在xxxxProperties类中封装者‘;配置文件能配置什么就可以参照某个功能对应的这个属性类

    1. @ConfigurationProperties(prefix = "spring.http.encoding") //从配置文件中获取指定的值和bean的属性进行绑定
    2. public class HttpEncodingProperties {
    3. public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    精髓:
    1)、SpringBoot启动会加载大量的自动配置类
    2)、我们看我们需要的功能有没有SpringBoot默认写好的自动配置类;
    3)、我们再来看这个自动配置类中到底配置了哪些组件;(只要我们要用的组件有,我们就不需要再来配置了)
    4)、给容器中自动配置类添加组件的时候,会从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值;
    xxxxAutoConfigurartion:自动配置类;
    给容器中添加组件
    xxxxProperties:封装配置文件中相关属性;

    2、细节

    1、@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环境
_@_ConditionalOnJndi JNDI存在指定项

自动配置类必须在一定的条件下才能生效;
我们怎么知道哪些自动配置类生效;
我们可以通过启用 debug=true属性;来让控制台打印自动配置报告,这样我们就可以很方便的知道哪些自动配置类生效;

  1. =========================
  2. AUTO-CONFIGURATION REPORT
  3. =========================
  4. Positive matches:(自动配置类启用的)
  5. -----------------
  6. DispatcherServletAutoConfiguration matched:
  7. - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
  8. - @ConditionalOnWebApplication (required) found StandardServletEnvironment (OnWebApplicationCondition)
  9. Negative matches:(没有启动,没有匹配成功的自动配置类)
  10. -----------------
  11. ActiveMQAutoConfiguration:
  12. Did not match:
  13. - @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)
  14. AopAutoConfiguration:
  15. Did not match:
  16. - @ConditionalOnClass did not find required classes 'org.aspectj.lang.annotation.Aspect', 'org.aspectj.lang.reflect.Advice' (OnClassCondition)

三、日志

1、日志框架

小张;开发一个大型系统;
1、System.out.println(“”);将关键数据打印在控制台;去掉?写在一个文件?
2、框架来记录系统的一些运行时信息;日志框架 ; zhanglogging.jar;
3、高大上的几个功能?异步模式?自动归档?xxxx? zhanglogging-good.jar?
4、将以前框架卸下来?换上新的框架,重新修改之前相关的API;zhanglogging-prefect.jar;
5、JDBC—-数据库驱动;
写了一个统一的接口层;日志门面(日志的一个抽象层);logging-abstract.jar;
给项目中导入具体的日志实现就行了;我们之前的日志框架都是实现的抽象层;
市面上的日志框架;
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) Log4j2 Logback

左边选一个门面(抽象层)、右边来选一个实现;
日志门面: SLF4J;
日志实现:Logback;
SpringBoot:底层是Spring框架,Spring框架默认是用JCL;‘
SpringBoot选用 SLF4j和logback;

2、SLF4j使用

1、如何在系统中使用SLF4j https://www.slf4j.org

以后开发的时候,日志记录方法的调用,不应该来直接调用日志的实现类,而是调用日志抽象层里面的方法;
给系统里面导入slf4j的jar和 logback的实现jar

  1. import org.slf4j.Logger;
  2. import org.slf4j.LoggerFactory;
  3. public class HelloWorld {
  4. public static void main(String[] args) {
  5. Logger logger = LoggerFactory.getLogger(HelloWorld.class);
  6. logger.info("Hello World");
  7. }
  8. }

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

2、遗留问题

a(slf4j+logback): Spring(commons-logging)、Hibernate(jboss-logging)、MyBatis、xxxx
统一日志记录,即使是别的框架和我一起统一使用slf4j进行输出?
Spring Boot - 图5
如何让系统中所有的日志都统一到slf4j;
1、将系统中其他日志框架先排除出去;
2、用中间包来替换原有的日志框架;
3、我们导入slf4j其他的实现

3、SpringBoot日志关系

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter</artifactId>
  4. </dependency>

SpringBoot使用它来做日志功能;

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-logging</artifactId>
  4. </dependency>

底层依赖关系
Spring Boot - 图6
总结:
1)、SpringBoot底层也是使用slf4j+logback的方式进行日志记录
2)、SpringBoot也把其他的日志都替换成了slf4j;
3)、中间替换包?

  1. @SuppressWarnings("rawtypes")
  2. public abstract class LogFactory {
  3. static String UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J = "http://www.slf4j.org/codes.html#unsupported_operation_in_jcl_over_slf4j";
  4. static LogFactory logFactory = new SLF4JLogFactory();

Spring Boot - 图7
4)、如果我们要引入其他框架?一定要把这个框架的默认日志依赖移除掉?
Spring框架用的是commons-logging;

  1. <dependency>
  2. <groupId>org.springframework</groupId>
  3. <artifactId>spring-core</artifactId>
  4. <exclusions>
  5. <exclusion>
  6. <groupId>commons-logging</groupId>
  7. <artifactId>commons-logging</artifactId>
  8. </exclusion>
  9. </exclusions>
  10. </dependency>

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

4、日志使用;

1、默认配置

SpringBoot默认帮我们配置好了日志;

  1. //记录器
  2. Logger logger = LoggerFactory.getLogger(getClass());
  3. @Test
  4. public void contextLoads() {
  5. //System.out.println();
  6. //日志的级别;
  7. //由低到高 trace<debug<info<warn<error
  8. //可以调整输出的日志级别;日志就只会在这个级别以以后的高级别生效
  9. logger.trace("这是trace日志...");
  10. logger.debug("这是debug日志...");
  11. //SpringBoot默认给我们使用的是info级别的,没有指定级别的就用SpringBoot默认规定的级别;root级别
  12. logger.info("这是info日志...");
  13. logger.warn("这是warn日志...");
  14. logger.error("这是error日志...");
  15. }
  1. 日志输出格式:
  2. %d表示日期时间,
  3. %thread表示线程名,
  4. %-5level:级别从左显示5个字符宽度
  5. %logger{50} 表示logger名字最长50个字符,否则按照句点分割。
  6. %msg:日志消息,
  7. %n是换行符
  8. -->
  9. %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n

SpringBoot修改日志的默认配置

  1. logging.level.com.atguigu=trace
  2. #logging.path=
  3. # 不指定路径在当前项目下生成springboot.log日志
  4. # 可以指定完整的路径;
  5. #logging.file=G:/springboot.log
  6. # 在当前磁盘的根路径下创建spring文件夹和里面的log文件夹;使用 spring.log 作为默认文件
  7. logging.path=/spring/log
  8. # 在控制台输出的日志的格式
  9. logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n
  10. # 指定文件中日志输出的格式
  11. logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} ==== %msg%n
logging.file logging.path Example Description
(none) (none) 只在控制台输出
指定文件名 (none) my.log 输出日志到my.log文件
(none) 指定目录 /var/log 输出到指定目录的 spring.log 文件中

2、指定配置

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

Logging System Customization
Logback logback-spring.xml, logback-spring.groovy, logback.xml or logback.groovy
Log4j2 log4j2-spring.xml or log4j2.xml
JDK (Java Util Logging) logging.properties

logback.xml:直接就被日志框架识别了;
logback-spring.xml:日志框架就不直接加载日志的配置项,由SpringBoot解析日志配置,可以使用SpringBoot的高级Profile功能

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

如:

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

如果使用logback.xml作为日志配置文件,还要使用profile功能,会有以下错误
no applicable action for [springProfile]

5、切换日志框架

可以按照slf4j的日志适配图,进行相关的切换;
slf4j+log4j的方式;

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-web</artifactId>
  4. <exclusions>
  5. <exclusion>
  6. <artifactId>logback-classic</artifactId>
  7. <groupId>ch.qos.logback</groupId>
  8. </exclusion>
  9. <exclusion>
  10. <artifactId>log4j-over-slf4j</artifactId>
  11. <groupId>org.slf4j</groupId>
  12. </exclusion>
  13. </exclusions>
  14. </dependency>
  15. <dependency>
  16. <groupId>org.slf4j</groupId>
  17. <artifactId>slf4j-log4j12</artifactId>
  18. </dependency>

切换为log4j2

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-web</artifactId>
  4. <exclusions>
  5. <exclusion>
  6. <artifactId>spring-boot-starter-logging</artifactId>
  7. <groupId>org.springframework.boot</groupId>
  8. </exclusion>
  9. </exclusions>
  10. </dependency>
  11. <dependency>
  12. <groupId>org.springframework.boot</groupId>
  13. <artifactId>spring-boot-starter-log4j2</artifactId>
  14. </dependency>

四、Web开发

1、简介

使用SpringBoot;
1)、创建SpringBoot应用,选中我们需要的模块;
2)、SpringBoot已经默认将这些场景配置好了,只需要在配置文件中指定少量配置就可以运行起来
3)、自己编写业务代码;
自动配置原理?
这个场景SpringBoot帮我们配置了什么?能不能修改?能修改哪些配置?能不能扩展?xxx

  1. xxxxAutoConfiguration:帮我们给容器中自动配置组件;
  2. xxxxProperties:配置类来封装配置文件的内容;

2、SpringBoot对静态资源的映射规则;

  1. @ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
  2. public class ResourceProperties implements ResourceLoaderAware {
  3. //可以设置和静态资源有关的参数,缓存时间等
  1. WebMvcAuotConfiguration
  2. @Override
  3. public void addResourceHandlers(ResourceHandlerRegistry registry) {
  4. if (!this.resourceProperties.isAddMappings()) {
  5. logger.debug("Default resource handling disabled");
  6. return;
  7. }
  8. Integer cachePeriod = this.resourceProperties.getCachePeriod();
  9. if (!registry.hasMappingForPattern("/webjars/**")) {
  10. customizeResourceHandlerRegistration(
  11. registry.addResourceHandler("/webjars/**")
  12. .addResourceLocations(
  13. "classpath:/META-INF/resources/webjars/")
  14. .setCachePeriod(cachePeriod));
  15. }
  16. String staticPathPattern = this.mvcProperties.getStaticPathPattern();
  17. //静态资源文件夹映射
  18. if (!registry.hasMappingForPattern(staticPathPattern)) {
  19. customizeResourceHandlerRegistration(
  20. registry.addResourceHandler(staticPathPattern)
  21. .addResourceLocations(
  22. this.resourceProperties.getStaticLocations())
  23. .setCachePeriod(cachePeriod));
  24. }
  25. }
  26. //配置欢迎页映射
  27. @Bean
  28. public WelcomePageHandlerMapping welcomePageHandlerMapping(
  29. ResourceProperties resourceProperties) {
  30. return new WelcomePageHandlerMapping(resourceProperties.getWelcomePage(),
  31. this.mvcProperties.getStaticPathPattern());
  32. }
  33. //配置喜欢的图标
  34. @Configuration
  35. @ConditionalOnProperty(value = "spring.mvc.favicon.enabled", matchIfMissing = true)
  36. public static class FaviconConfiguration {
  37. private final ResourceProperties resourceProperties;
  38. public FaviconConfiguration(ResourceProperties resourceProperties) {
  39. this.resourceProperties = resourceProperties;
  40. }
  41. @Bean
  42. public SimpleUrlHandlerMapping faviconHandlerMapping() {
  43. SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
  44. mapping.setOrder(Ordered.HIGHEST_PRECEDENCE + 1);
  45. //所有 **/favicon.ico
  46. mapping.setUrlMap(Collections.singletonMap("**/favicon.ico",
  47. faviconRequestHandler()));
  48. return mapping;
  49. }
  50. @Bean
  51. public ResourceHttpRequestHandler faviconRequestHandler() {
  52. ResourceHttpRequestHandler requestHandler = new ResourceHttpRequestHandler();
  53. requestHandler
  54. .setLocations(this.resourceProperties.getFaviconLocations());
  55. return requestHandler;
  56. }
  57. }

1)、所有 /webjars/** ,都去 classpath:/META-INF/resources/webjars/ 找资源;
webjars:以jar包的方式引入静态资源;
http://www.webjars.org/
Spring Boot - 图8
localhost:8080/webjars/jquery/3.3.1/jquery.js

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

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

  1. "classpath:/META-INF/resources/",
  2. "classpath:/resources/",
  3. "classpath:/static/",
  4. "classpath:/public/"
  5. "/":当前项目的根路径

localhost:8080/abc === 去静态资源文件夹里面找abc
3)、欢迎页; 静态资源文件夹下的所有index.html页面;被”/“映射;
localhost:8080/ 找index页面
4)、所有的
/favicon.ico 都是在静态资源文件下找;

3、模板引擎

JSP、Velocity、Freemarker、Thymeleaf
Spring Boot - 图9
SpringBoot推荐的Thymeleaf;
语法更简单,功能更强大;

1、引入thymeleaf;

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-thymeleaf</artifactId>
  4. 2.1.6
  5. </dependency>
  6. 切换thymeleaf版本
  7. <properties>
  8. <thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
  9. <!-- 布局功能的支持程序 thymeleaf3主程序 layout2以上版本 -->
  10. <!-- thymeleaf2 layout1-->
  11. <thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>
  12. </properties>

2、Thymeleaf使用

  1. @ConfigurationProperties(prefix = "spring.thymeleaf")
  2. public class ThymeleafProperties {
  3. private static final Charset DEFAULT_ENCODING = Charset.forName("UTF-8");
  4. private static final MimeType DEFAULT_CONTENT_TYPE = MimeType.valueOf("text/html");
  5. public static final String DEFAULT_PREFIX = "classpath:/templates/";
  6. public static final String DEFAULT_SUFFIX = ".html";
  7. //

只要我们把HTML页面放在classpath:/templates/,thymeleaf就能自动渲染;
使用:
1、导入thymeleaf的名称空间

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

2、使用thymeleaf语法;

  1. <!DOCTYPE html>
  2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Title</title>
  6. </head>
  7. <body>
  8. <h1>成功!</h1>
  9. <!--th:text 将div里面的文本内容设置为 -->
  10. <div th:text="${hello}">这是显示欢迎信息</div>
  11. </body>
  12. </html>

3、语法规则

1)、th:text;改变当前元素里面的文本内容;
th:任意html属性;来替换原生属性的值
Spring Boot - 图10
2)、表达式?

  1. Simple expressions:(表达式语法)
  2. Variable Expressions: ${...}:获取变量值;OGNL
  3. 1)、获取对象的属性、调用方法
  4. 2)、使用内置的基本对象:
  5. #ctx : the context object.
  6. #vars: the context variables.
  7. #locale : the context locale.
  8. #request : (only in Web Contexts) the HttpServletRequest object.
  9. #response : (only in Web Contexts) the HttpServletResponse object.
  10. #session : (only in Web Contexts) the HttpSession object.
  11. #servletContext : (only in Web Contexts) the ServletContext object.
  12. ${session.foo}
  13. 3)、内置的一些工具对象:
  14. #execInfo : information about the template being processed.
  15. #messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{…} syntax.
  16. #uris : methods for escaping parts of URLs/URIs
  17. #conversions : methods for executing the configured conversion service (if any).
  18. #dates : methods for java.util.Date objects: formatting, component extraction, etc.
  19. #calendars : analogous to #dates , but for java.util.Calendar objects.
  20. #numbers : methods for formatting numeric objects.
  21. #strings : methods for String objects: contains, startsWith, prepending/appending, etc.
  22. #objects : methods for objects in general.
  23. #bools : methods for boolean evaluation.
  24. #arrays : methods for arrays.
  25. #lists : methods for lists.
  26. #sets : methods for sets.
  27. #maps : methods for maps.
  28. #aggregates : methods for creating aggregates on arrays or collections.
  29. #ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).
  30. Selection Variable Expressions: *{...}:选择表达式:和${}在功能上是一样;
  31. 补充:配合 th:object="${session.user}:
  32. <div th:object="${session.user}">
  33. <p>Name: <span th:text="*{firstName}">Sebastian</span>.</p>
  34. <p>Surname: <span th:text="*{lastName}">Pepper</span>.</p>
  35. <p>Nationality: <span th:text="*{nationality}">Saturn</span>.</p>
  36. </div>
  37. Message Expressions: #{...}:获取国际化内容
  38. Link URL Expressions: @{...}:定义URL;
  39. @{/order/process(execId=${execId},execType='FAST')}
  40. Fragment Expressions: ~{...}:片段引用表达式
  41. <div th:insert="~{commons :: main}">...</div>
  42. Literals(字面量)
  43. Text literals: 'one text' , 'Another one!' ,…
  44. Number literals: 0 , 34 , 3.0 , 12.3 ,…
  45. Boolean literals: true , false
  46. Null literal: null
  47. Literal tokens: one , sometext , main ,…
  48. Text operations:(文本操作)
  49. String concatenation: +
  50. Literal substitutions: |The name is ${name}|
  51. Arithmetic operations:(数学运算)
  52. Binary operators: + , - , * , / , %
  53. Minus sign (unary operator): -
  54. Boolean operations:(布尔运算)
  55. Binary operators: and , or
  56. Boolean negation (unary operator): ! , not
  57. Comparisons and equality:(比较运算)
  58. Comparators: > , < , >= , <= ( gt , lt , ge , le )
  59. Equality operators: == , != ( eq , ne )
  60. Conditional operators:条件运算(三元运算符)
  61. If-then: (if) ? (then)
  62. If-then-else: (if) ? (then) : (else)
  63. Default: (value) ?: (defaultvalue)
  64. Special tokens:
  65. No-Operation: _

4、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;
      1. @Bean
      2. @ConditionalOnProperty(prefix = "spring.mvc", name = "date-format")//在文件中配置日期格式化的规则
      3. public Formatter<Date> dateFormatter() {
      4. return new DateFormatter(this.mvcProperties.getDateFormat());//日期格式化组件
      5. }
      自己添加的格式化器转换器,我们只需要放在容器中即可
  • Support for HttpMessageConverters (see below).

    • HttpMessageConverter:SpringMVC用来转换Http请求和响应的;User—-Json;
    • HttpMessageConverters 是从容器中确定;获取所有的HttpMessageConverter;
      自己给容器中添加HttpMessageConverter,只需要将自己的组件注册容器中(@Bean,@Component)
  • Automatic registration of MessageCodesResolver (see below).定义错误代码生成规则
  • Automatic use of a ConfigurableWebBindingInitializer bean (see below).
    我们可以配置一个ConfigurableWebBindingInitializer来替换默认的;(添加到容器)

    1. 初始化WebDataBinder
    2. 请求数据=====JavaBean

    org.springframework.boot.autoconfigure.web:web的所有自动场景;
    If you want to keep Spring Boot MVC features, and you just want to add additional MVC configuration (interceptors, formatters, view controllers etc.) you can add your own @Configuration class of type WebMvcConfigurerAdapter, but without @EnableWebMvc. If you wish to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter or ExceptionHandlerExceptionResolver you can declare a WebMvcRegistrationsAdapter instance providing such components.
    If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc.

    2、扩展SpringMVC

    1. <mvc:view-controller path="/hello" view-name="success"/>
    2. <mvc:interceptors>
    3. <mvc:interceptor>
    4. <mvc:mapping path="/hello"/>
    5. <bean></bean>
    6. </mvc:interceptor>
    7. </mvc:interceptors>

    编写一个配置类(@Configuration),是WebMvcConfigurerAdapter类型;不能标注_@_EnableWebMvc ;
    既保留了所有的自动配置,也能用我们扩展的配置;

    1. //使用WebMvcConfigurerAdapter可以来扩展SpringMVC的功能
    2. @Configuration
    3. public class MyMvcConfig extends WebMvcConfigurerAdapter {
    4. @Override
    5. public void addViewControllers(ViewControllerRegistry registry) {
    6. // super.addViewControllers(registry);
    7. //浏览器发送 /atguigu 请求来到 success
    8. registry.addViewController("/atguigu").setViewName("success");
    9. }
    10. }

    原理:
    1)、WebMvcAutoConfiguration是SpringMVC的自动配置类
    2)、在做其他自动配置时会导入;@Import(EnableWebMvcConfiguration.class)

    1. @Configuration
    2. public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {
    3. private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
    4. //从容器中获取所有的WebMvcConfigurer
    5. @Autowired(required = false)
    6. public void setConfigurers(List<WebMvcConfigurer> configurers) {
    7. if (!CollectionUtils.isEmpty(configurers)) {
    8. this.configurers.addWebMvcConfigurers(configurers);
    9. //一个参考实现;将所有的WebMvcConfigurer相关配置都来一起调用;
    10. @Override
    11. // public void addViewControllers(ViewControllerRegistry registry) {
    12. // for (WebMvcConfigurer delegate : this.delegates) {
    13. // delegate.addViewControllers(registry);
    14. // }
    15. }
    16. }
    17. }

    3)、容器中所有的WebMvcConfigurer都会一起起作用;
    4)、我们的配置类也会被调用;
    效果:SpringMVC的自动配置和我们的扩展配置都会起作用;

    3、全面接管SpringMVC;

    SpringBoot对SpringMVC的自动配置不需要了,所有都是我们自己配置;所有的SpringMVC的自动配置都失效了
    我们需要在配置类中添加@EnableWebMvc即可;

    1. //使用WebMvcConfigurerAdapter可以来扩展SpringMVC的功能
    2. @EnableWebMvc
    3. @Configuration
    4. public class MyMvcConfig extends WebMvcConfigurerAdapter {
    5. @Override
    6. public void addViewControllers(ViewControllerRegistry registry) {
    7. // super.addViewControllers(registry);
    8. //浏览器发送 /atguigu 请求来到 success
    9. registry.addViewController("/atguigu").setViewName("success");
    10. }
    11. }

    原理:
    为什么@EnableWebMvc自动配置就失效了;
    1)@EnableWebMvc的核心

    1. @Import(DelegatingWebMvcConfiguration.class)
    2. public @interface EnableWebMvc {

    2)、

    1. @Configuration
    2. public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

    3)、

    1. @Configuration
    2. @ConditionalOnWebApplication
    3. @ConditionalOnClass({ Servlet.class, DispatcherServlet.class,
    4. WebMvcConfigurerAdapter.class })
    5. //容器中没有这个组件的时候,这个自动配置类才生效
    6. @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
    7. @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
    8. @AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
    9. ValidationAutoConfiguration.class })
    10. public class WebMvcAutoConfiguration {

    4)、@EnableWebMvc将WebMvcConfigurationSupport组件导入进来;
    5)、导入的WebMvcConfigurationSupport只是SpringMVC最基本的功能;

    5、如何修改SpringBoot的默认配置

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

    6、RestfulCRUD

    1)、默认访问首页

    1. //使用WebMvcConfigurerAdapter可以来扩展SpringMVC的功能
    2. //@EnableWebMvc 不要接管SpringMVC
    3. @Configuration
    4. public class MyMvcConfig extends WebMvcConfigurerAdapter {
    5. @Override
    6. public void addViewControllers(ViewControllerRegistry registry) {
    7. // super.addViewControllers(registry);
    8. //浏览器发送 /atguigu 请求来到 success
    9. registry.addViewController("/atguigu").setViewName("success");
    10. }
    11. //所有的WebMvcConfigurerAdapter组件都会一起起作用
    12. @Bean //将组件注册在容器
    13. public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
    14. WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
    15. @Override
    16. public void addViewControllers(ViewControllerRegistry registry) {
    17. registry.addViewController("/").setViewName("login");
    18. registry.addViewController("/index.html").setViewName("login");
    19. }
    20. };
    21. return adapter;
    22. }
    23. }

    2)、国际化

    1)、编写国际化配置文件;
    2)、使用ResourceBundleMessageSource管理国际化资源文件
    3)、在页面使用fmt:message取出国际化内容
    步骤:
    1)、编写国际化配置文件,抽取页面需要显示的国际化消息
    Spring Boot - 图11
    2)、SpringBoot自动配置好了管理国际化资源文件的组件;

    1. @ConfigurationProperties(prefix = "spring.messages")
    2. public class MessageSourceAutoConfiguration {
    3. /**
    4. * Comma-separated list of basenames (essentially a fully-qualified classpath
    5. * location), each following the ResourceBundle convention with relaxed support for
    6. * slash based locations. If it doesn't contain a package qualifier (such as
    7. * "org.mypackage"), it will be resolved from the classpath root.
    8. */
    9. private String basename = "messages";
    10. //我们的配置文件可以直接放在类路径下叫messages.properties;
    11. @Bean
    12. public MessageSource messageSource() {
    13. ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
    14. if (StringUtils.hasText(this.basename)) {
    15. //设置国际化资源文件的基础名(去掉语言国家代码的)
    16. messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(
    17. StringUtils.trimAllWhitespace(this.basename)));
    18. }
    19. if (this.encoding != null) {
    20. messageSource.setDefaultEncoding(this.encoding.name());
    21. }
    22. messageSource.setFallbackToSystemLocale(this.fallbackToSystemLocale);
    23. messageSource.setCacheSeconds(this.cacheSeconds);
    24. messageSource.setAlwaysUseMessageFormat(this.alwaysUseMessageFormat);
    25. return messageSource;
    26. }

    3)、去页面获取国际化的值;
    Spring Boot - 图12

    1. <!DOCTYPE html>
    2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    5. <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    6. <meta name="description" content="">
    7. <meta name="author" content="">
    8. <title>Signin Template for Bootstrap</title>
    9. <!-- Bootstrap core CSS -->
    10. <link href="asserts/css/bootstrap.min.css" th:href="@{/webjars/bootstrap/4.0.0/css/bootstrap.css}" rel="stylesheet">
    11. <!-- Custom styles for this template -->
    12. <link href="asserts/css/signin.css" th:href="@{/asserts/css/signin.css}" rel="stylesheet">
    13. </head>
    14. <body class="text-center">
    15. <form class="form-signin" action="dashboard.html">
    16. <img class="mb-4" th:src="@{/asserts/img/bootstrap-solid.svg}" src="asserts/img/bootstrap-solid.svg" alt="" width="72" height="72">
    17. <h1 class="h3 mb-3 font-weight-normal" th:text="#{login.tip}">Please sign in</h1>
    18. <label class="sr-only" th:text="#{login.username}">Username</label>
    19. <input type="text" class="form-control" placeholder="Username" th:placeholder="#{login.username}" required="" autofocus="">
    20. <label class="sr-only" th:text="#{login.password}">Password</label>
    21. <input type="password" class="form-control" placeholder="Password" th:placeholder="#{login.password}" required="">
    22. <div class="checkbox mb-3">
    23. <label>
    24. <input type="checkbox" value="remember-me"/> [[#{login.remember}]]
    25. </label>
    26. </div>
    27. <button class="btn btn-lg btn-primary btn-block" type="submit" th:text="#{login.btn}">Sign in</button>
    28. <p class="mt-5 mb-3 text-muted">© 2017-2018</p>
    29. <a class="btn btn-sm">中文</a>
    30. <a class="btn btn-sm">English</a>
    31. </form>
    32. </body>
    33. </html>

    效果:根据浏览器语言设置的信息切换了国际化;
    原理:
    国际化Locale(区域信息对象);LocaleResolver(获取区域信息对象);

    1. @Bean
    2. @ConditionalOnMissingBean
    3. @ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
    4. public LocaleResolver localeResolver() {
    5. if (this.mvcProperties
    6. .getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
    7. return new FixedLocaleResolver(this.mvcProperties.getLocale());
    8. }
    9. AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
    10. localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
    11. return localeResolver;
    12. }
    13. 默认的就是根据请求头带来的区域信息获取Locale进行国际化

    4)、点击链接切换国际化

    1. /**
    2. * 可以在连接上携带区域信息
    3. */
    4. public class MyLocaleResolver implements LocaleResolver {
    5. @Override
    6. public Locale resolveLocale(HttpServletRequest request) {
    7. String l = request.getParameter("l");
    8. Locale locale = Locale.getDefault();
    9. if(!StringUtils.isEmpty(l)){
    10. String[] split = l.split("_");
    11. locale = new Locale(split[0],split[1]);
    12. }
    13. return locale;
    14. }
    15. @Override
    16. public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {
    17. }
    18. }
    19. @Bean
    20. public LocaleResolver localeResolver(){
    21. return new MyLocaleResolver();
    22. }
    23. }

    3)、登陆

    开发期间模板引擎页面修改以后,要实时生效
    1)、禁用模板引擎的缓存

    1. # 禁用缓存
    2. spring.thymeleaf.cache=false

    2)、页面修改完成以后ctrl+f9:重新编译;
    登陆错误消息的显示

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

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

    拦截器

    1. /**
    2. * 登陆检查,
    3. */
    4. public class LoginHandlerInterceptor implements HandlerInterceptor {
    5. //目标方法执行之前
    6. @Override
    7. public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    8. Object user = request.getSession().getAttribute("loginUser");
    9. if(user == null){
    10. //未登陆,返回登陆页面
    11. request.setAttribute("msg","没有权限请先登陆");
    12. request.getRequestDispatcher("/index.html").forward(request,response);
    13. return false;
    14. }else{
    15. //已登陆,放行请求
    16. return true;
    17. }
    18. }
    19. @Override
    20. public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    21. }
    22. @Override
    23. public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    24. }
    25. }

    注册拦截器

    1. //所有的WebMvcConfigurerAdapter组件都会一起起作用
    2. @Bean //将组件注册在容器
    3. public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
    4. WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
    5. @Override
    6. public void addViewControllers(ViewControllerRegistry registry) {
    7. registry.addViewController("/").setViewName("login");
    8. registry.addViewController("/index.html").setViewName("login");
    9. registry.addViewController("/main.html").setViewName("dashboard");
    10. }
    11. //注册拦截器
    12. @Override
    13. public void addInterceptors(InterceptorRegistry registry) {
    14. //super.addInterceptors(registry);
    15. //静态资源; *.css , *.js
    16. //SpringBoot已经做好了静态资源映射
    17. registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/**")
    18. .excludePathPatterns("/index.html","/","/user/login");
    19. }
    20. };
    21. return adapter;
    22. }

    5)、CRUD-员工列表

    实验要求:
    1)、RestfulCRUD:CRUD满足Rest风格;
    URI: /资源名称/资源标识 HTTP请求方式区分对资源CRUD操作

普通CRUD(uri来区分操作) RestfulCRUD
查询 getEmp emp—-GET
添加 addEmp?xxx emp—-POST
修改 updateEmp?id=xxx&xxx=xx emp/{id}—-PUT
删除 deleteEmp?id=1 emp/{id}—-DELETE

2)、实验的请求架构;

实验功能 请求URI 请求方式
查询所有员工 emps GET
查询某个员工(来到修改页面) emp/1 GET
来到添加页面 emp GET
添加员工 emp POST
来到修改页面(查出员工进行信息回显) emp/1 GET
修改员工 emp PUT
删除员工 emp/1 DELETE

3)、员工列表:

thymeleaf公共页面元素抽取

  1. 1、抽取公共片段
  2. <div th:fragment="copy">
  3. &copy; 2011 The Good Thymes Virtual Grocery
  4. </div>
  5. 2、引入公共片段
  6. <div th:insert="~{footer :: copy}"></div>
  7. ~{templatename::selector}:模板名::选择器
  8. ~{templatename::fragmentname}:模板名::片段名
  9. 3、默认效果:
  10. insert的公共片段在div标签中
  11. 如果使用th:insert等属性进行引入,可以不用写~{}:
  12. 行内写法可以加上:[[~{}]];[(~{})];

三种引入公共片段的th属性:
th:insert:将公共片段整个插入到声明引入的元素中
th:replace:将声明引入的元素替换为公共片段
th:include:将被引入的片段的内容包含进这个标签中

  1. <footer th:fragment="copy">
  2. &copy; 2011 The Good Thymes Virtual Grocery
  3. </footer>
  4. 引入方式
  5. <div th:insert="footer :: copy"></div>
  6. <div th:replace="footer :: copy"></div>
  7. <div th:include="footer :: copy"></div>
  8. 效果
  9. <div>
  10. <footer>
  11. &copy; 2011 The Good Thymes Virtual Grocery
  12. </footer>
  13. </div>
  14. <footer>
  15. &copy; 2011 The Good Thymes Virtual Grocery
  16. </footer>
  17. <div>
  18. &copy; 2011 The Good Thymes Virtual Grocery
  19. </div>

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

  1. <nav class="col-md-2 d-none d-md-block bg-light sidebar" id="sidebar">
  2. <div class="sidebar-sticky">
  3. <ul class="nav flex-column">
  4. <li class="nav-item">
  5. <a class="nav-link active"
  6. th:class="${activeUri=='main.html'?'nav-link active':'nav-link'}"
  7. href="#" th:href="@{/main.html}">
  8. <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">
  9. <path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path>
  10. <polyline points="9 22 9 12 15 12 15 22"></polyline>
  11. </svg>
  12. Dashboard <span class="sr-only">(current)</span>
  13. </a>
  14. </li>
  15. <!--引入侧边栏;传入参数-->
  16. <div th:replace="commons/bar::#sidebar(activeUri='emps')"></div>

6)、CRUD-员工添加

添加页面

  1. <form>
  2. <div class="form-group">
  3. <label>LastName</label>
  4. <input type="text" class="form-control" placeholder="zhangsan">
  5. </div>
  6. <div class="form-group">
  7. <label>Email</label>
  8. <input type="email" class="form-control" placeholder="zhangsan@atguigu.com">
  9. </div>
  10. <div class="form-group">
  11. <label>Gender</label><br/>
  12. <div class="form-check form-check-inline">
  13. <input class="form-check-input" type="radio" name="gender" value="1">
  14. <label class="form-check-label"></label>
  15. </div>
  16. <div class="form-check form-check-inline">
  17. <input class="form-check-input" type="radio" name="gender" value="0">
  18. <label class="form-check-label"></label>
  19. </div>
  20. </div>
  21. <div class="form-group">
  22. <label>department</label>
  23. <select class="form-control">
  24. <option>1</option>
  25. <option>2</option>
  26. <option>3</option>
  27. <option>4</option>
  28. <option>5</option>
  29. </select>
  30. </div>
  31. <div class="form-group">
  32. <label>Birth</label>
  33. <input type="text" class="form-control" placeholder="zhangsan">
  34. </div>
  35. <button type="submit" class="btn btn-primary">添加</button>
  36. </form>

提交的数据格式不对:生日:日期;
2017-12-12;2017/12/12;2017.12.12;
日期的格式化;SpringMVC将页面提交的值需要转换为指定的类型;
2017-12-12—-Date; 类型转换,格式化;
默认日期是按照/的方式;

7)、CRUD-员工修改

修改添加二合一表单

  1. <!--需要区分是员工修改还是添加;-->
  2. <form th:action="@{/emp}" method="post">
  3. <!--发送put请求修改员工数据-->
  4. <!--
  5. 1、SpringMVC中配置HiddenHttpMethodFilter;(SpringBoot自动配置好的)
  6. 2、页面创建一个post表单
  7. 3、创建一个input项,name="_method";值就是我们指定的请求方式
  8. -->
  9. <input type="hidden" name="_method" value="put" th:if="${emp!=null}"/>
  10. <input type="hidden" name="id" th:if="${emp!=null}" th:value="${emp.id}">
  11. <div class="form-group">
  12. <label>LastName</label>
  13. <input name="lastName" type="text" class="form-control" placeholder="zhangsan" th:value="${emp!=null}?${emp.lastName}">
  14. </div>
  15. <div class="form-group">
  16. <label>Email</label>
  17. <input name="email" type="email" class="form-control" placeholder="zhangsan@atguigu.com" th:value="${emp!=null}?${emp.email}">
  18. </div>
  19. <div class="form-group">
  20. <label>Gender</label><br/>
  21. <div class="form-check form-check-inline">
  22. <input class="form-check-input" type="radio" name="gender" value="1" th:checked="${emp!=null}?${emp.gender==1}">
  23. <label class="form-check-label"></label>
  24. </div>
  25. <div class="form-check form-check-inline">
  26. <input class="form-check-input" type="radio" name="gender" value="0" th:checked="${emp!=null}?${emp.gender==0}">
  27. <label class="form-check-label"></label>
  28. </div>
  29. </div>
  30. <div class="form-group">
  31. <label>department</label>
  32. <!--提交的是部门的id-->
  33. <select class="form-control" name="department.id">
  34. <option th:selected="${emp!=null}?${dept.id == emp.department.id}" th:value="${dept.id}" th:each="dept:${depts}" th:text="${dept.departmentName}">1</option>
  35. </select>
  36. </div>
  37. <div class="form-group">
  38. <label>Birth</label>
  39. <input name="birth" type="text" class="form-control" placeholder="zhangsan" th:value="${emp!=null}?${#dates.format(emp.birth, 'yyyy-MM-dd HH:mm')}">
  40. </div>
  41. <button type="submit" class="btn btn-primary" th:text="${emp!=null}?'修改':'添加'">添加</button>
  42. </form>

8)、CRUD-员工删除

  1. <tr th:each="emp:${emps}">
  2. <td th:text="${emp.id}"></td>
  3. <td>[[${emp.lastName}]]</td>
  4. <td th:text="${emp.email}"></td>
  5. <td th:text="${emp.gender}==0?'女':'男'"></td>
  6. <td th:text="${emp.department.departmentName}"></td>
  7. <td th:text="${#dates.format(emp.birth, 'yyyy-MM-dd HH:mm')}"></td>
  8. <td>
  9. <a class="btn btn-sm btn-primary" th:href="@{/emp/}+${emp.id}">编辑</a>
  10. <button th:attr="del_uri=@{/emp/}+${emp.id}" class="btn btn-sm btn-danger deleteBtn">删除</button>
  11. </td>
  12. </tr>
  13. <script>
  14. $(".deleteBtn").click(function(){
  15. //删除当前员工的
  16. $("#deleteEmpForm").attr("action",$(this).attr("del_uri")).submit();
  17. return false;
  18. });
  19. </script>

7、错误处理机制

1)、SpringBoot默认的错误处理机制

默认效果:
1)、浏览器,返回一个默认的错误页面
Spring Boot - 图13
浏览器发送请求的请求头:
Spring Boot - 图14
2)、如果是其他客户端,默认响应一个json数据
Spring Boot - 图15
Spring Boot - 图16
原理:
可以参照ErrorMvcAutoConfiguration;错误处理的自动配置;

  1. 给容器中添加了以下组件
  1. 1DefaultErrorAttributes
  1. 帮我们在页面共享信息;
  2. @Override
  3. public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
  4. boolean includeStackTrace) {
  5. Map<String, Object> errorAttributes = new LinkedHashMap<String, Object>();
  6. errorAttributes.put("timestamp", new Date());
  7. addStatus(errorAttributes, requestAttributes);
  8. addErrorDetails(errorAttributes, requestAttributes, includeStackTrace);
  9. addPath(errorAttributes, requestAttributes);
  10. return errorAttributes;
  11. }
  1. 2BasicErrorController:处理默认/error请求
  1. @Controller
  2. @RequestMapping("${server.error.path:${error.path:/error}}")
  3. public class BasicErrorController extends AbstractErrorController {
  4. @RequestMapping(produces = "text/html")//产生html类型的数据;浏览器发送的请求来到这个方法处理
  5. public ModelAndView errorHtml(HttpServletRequest request,
  6. HttpServletResponse response) {
  7. HttpStatus status = getStatus(request);
  8. Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(
  9. request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
  10. response.setStatus(status.value());
  11. //去哪个页面作为错误页面;包含页面地址和页面内容
  12. ModelAndView modelAndView = resolveErrorView(request, response, status, model);
  13. return (modelAndView == null ? new ModelAndView("error", model) : modelAndView);
  14. }
  15. @RequestMapping
  16. @ResponseBody //产生json数据,其他客户端来到这个方法处理;
  17. public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
  18. Map<String, Object> body = getErrorAttributes(request,
  19. isIncludeStackTrace(request, MediaType.ALL));
  20. HttpStatus status = getStatus(request);
  21. return new ResponseEntity<Map<String, Object>>(body, status);
  22. }
  1. 3ErrorPageCustomizer
  1. @Value("${error.path:/error}")
  2. private String path = "/error"; 系统出现错误以后来到error请求进行处理;(web.xml注册的错误页面规则)
  1. 4DefaultErrorViewResolver
  1. @Override
  2. public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status,
  3. Map<String, Object> model) {
  4. ModelAndView modelAndView = resolve(String.valueOf(status), model);
  5. if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
  6. modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
  7. }
  8. return modelAndView;
  9. }
  10. private ModelAndView resolve(String viewName, Map<String, Object> model) {
  11. //默认SpringBoot可以去找到一个页面? error/404
  12. String errorViewName = "error/" + viewName;
  13. //模板引擎可以解析这个页面地址就用模板引擎解析
  14. TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
  15. .getProvider(errorViewName, this.applicationContext);
  16. if (provider != null) {
  17. //模板引擎可用的情况下返回到errorViewName指定的视图地址
  18. return new ModelAndView(errorViewName, model);
  19. }
  20. //模板引擎不可用,就在静态资源文件夹下找errorViewName对应的页面 error/404.html
  21. return resolveResource(errorViewName, model);
  22. }
  1. 步骤:<br /> 一但系统出现4xx或者5xx之类的错误;ErrorPageCustomizer就会生效(定制错误的响应规则);就会来到/error请求;就会被**BasicErrorController**处理;<br /> 1)响应页面;去哪个页面是由**DefaultErrorViewResolver**解析得到的;
  1. protected ModelAndView resolveErrorView(HttpServletRequest request,
  2. HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
  3. //所有的ErrorViewResolver得到ModelAndView
  4. for (ErrorViewResolver resolver : this.errorViewResolvers) {
  5. ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
  6. if (modelAndView != null) {
  7. return modelAndView;
  8. }
  9. }
  10. return null;
  11. }

2)、如果定制错误响应:

1)、如何定制错误的页面;

  1. **1)、有模板引擎的情况下;error/状态码;** 【将错误页面命名为 错误状态码.html 放在模板引擎文件夹里面的 error文件夹下】,发生此状态码的错误就会来到 对应的页面;<br /> 我们可以使用4xx5xx作为错误页面的文件名来匹配这种类型的所有错误,精确优先(优先寻找精确的状态码.html);<br /> 页面能获取的信息;<br /> timestamp:时间戳<br /> status:状态码<br /> error:错误提示<br /> exception:异常对象<br /> message:异常消息<br /> errorsJSR303数据校验的错误都在这里<br /> 2)、没有模板引擎(模板引擎找不到这个错误页面),静态资源文件夹下找;<br /> 3)、以上都没有错误页面,就是默认来到SpringBoot默认的错误提示页面;

2)、如何定制错误的json数据;

  1. 1)、自定义异常处理&返回定制json数据;
  1. @ControllerAdvice
  2. public class MyExceptionHandler {
  3. @ResponseBody
  4. @ExceptionHandler(UserNotExistException.class)
  5. public Map<String,Object> handleException(Exception e){
  6. Map<String,Object> map = new HashMap<>();
  7. map.put("code","user.notexist");
  8. map.put("message",e.getMessage());
  9. return map;
  10. }
  11. }
  12. //没有自适应效果...
  1. 2)、转发到/error进行自适应响应效果处理
  1. @ExceptionHandler(UserNotExistException.class)
  2. public String handleException(Exception e, HttpServletRequest request){
  3. Map<String,Object> map = new HashMap<>();
  4. //传入我们自己的错误状态码 4xx 5xx,否则就不会进入定制错误页面的解析流程
  5. /**
  6. * Integer statusCode = (Integer) request
  7. .getAttribute("javax.servlet.error.status_code");
  8. */
  9. request.setAttribute("javax.servlet.error.status_code",500);
  10. map.put("code","user.notexist");
  11. map.put("message",e.getMessage());
  12. //转发到/error
  13. return "forward:/error";
  14. }

3)、将我们的定制数据携带出去;

出现错误以后,会来到/error请求,会被BasicErrorController处理,响应出去可以获取的数据是由getErrorAttributes得到的(是AbstractErrorController(ErrorController)规定的方法);
1、完全来编写一个ErrorController的实现类【或者是编写AbstractErrorController的子类】,放在容器中;
2、页面上能用的数据,或者是json返回能用的数据都是通过errorAttributes.getErrorAttributes得到;
容器中DefaultErrorAttributes.getErrorAttributes();默认进行数据处理的;
自定义ErrorAttributes

  1. //给容器中加入我们自己定义的ErrorAttributes
  2. @Component
  3. public class MyErrorAttributes extends DefaultErrorAttributes {
  4. @Override
  5. public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {
  6. Map<String, Object> map = super.getErrorAttributes(requestAttributes, includeStackTrace);
  7. map.put("company","atguigu");
  8. return map;
  9. }
  10. }

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

8、配置嵌入式Servlet容器

SpringBoot默认使用Tomcat作为嵌入式的Servlet容器;
Spring Boot - 图18
问题?

1)、如何定制和修改Servlet容器的相关配置;

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

  1. server.port=8081
  2. server.context-path=/crud
  3. server.tomcat.uri-encoding=UTF-8
  4. //通用的Servlet容器设置
  5. server.xxx
  6. //Tomcat的设置
  7. server.tomcat.xxx

2、编写一个EmbeddedServletContainerCustomizer:嵌入式的Servlet容器的定制器;来修改Servlet容器的配置

  1. @Bean //一定要将这个定制器加入到容器中
  2. public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
  3. return new EmbeddedServletContainerCustomizer() {
  4. //定制嵌入式的Servlet容器相关的规则
  5. @Override
  6. public void customize(ConfigurableEmbeddedServletContainer container) {
  7. container.setPort(8083);
  8. }
  9. };
  10. }

2)、注册Servlet三大组件【Servlet、Filter、Listener】

由于SpringBoot默认是以jar包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用,没有web.xml文件。
注册三大组件用以下方式
ServletRegistrationBean

  1. //注册三大组件
  2. @Bean
  3. public ServletRegistrationBean myServlet(){
  4. ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
  5. return registrationBean;
  6. }

FilterRegistrationBean

  1. @Bean
  2. public FilterRegistrationBean myFilter(){
  3. FilterRegistrationBean registrationBean = new FilterRegistrationBean();
  4. registrationBean.setFilter(new MyFilter());
  5. registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
  6. return registrationBean;
  7. }

ServletListenerRegistrationBean

  1. @Bean
  2. public ServletListenerRegistrationBean myListener(){
  3. ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
  4. return registrationBean;
  5. }

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

  1. @Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
  2. @ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
  3. public ServletRegistrationBean dispatcherServletRegistration(
  4. DispatcherServlet dispatcherServlet) {
  5. ServletRegistrationBean registration = new ServletRegistrationBean(
  6. dispatcherServlet, this.serverProperties.getServletMapping());
  7. //默认拦截: / 所有请求;包静态资源,但是不拦截jsp请求; /*会拦截jsp
  8. //可以通过server.servletPath来修改SpringMVC前端控制器默认拦截的请求路径
  9. registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
  10. registration.setLoadOnStartup(
  11. this.webMvcProperties.getServlet().getLoadOnStartup());
  12. if (this.multipartConfig != null) {
  13. registration.setMultipartConfig(this.multipartConfig);
  14. }
  15. return registration;
  16. }

2)、SpringBoot能不能支持其他的Servlet容器;

3)、替换为其他嵌入式Servlet容器

Spring Boot - 图19
默认支持:
Tomcat(默认使用)

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

Jetty

  1. <!-- 引入web模块 -->
  2. <dependency>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-starter-web</artifactId>
  5. <exclusions>
  6. <exclusion>
  7. <artifactId>spring-boot-starter-tomcat</artifactId>
  8. <groupId>org.springframework.boot</groupId>
  9. </exclusion>
  10. </exclusions>
  11. </dependency>
  12. <!--引入其他的Servlet容器-->
  13. <dependency>
  14. <artifactId>spring-boot-starter-jetty</artifactId>
  15. <groupId>org.springframework.boot</groupId>
  16. </dependency>

Undertow

  1. <!-- 引入web模块 -->
  2. <dependency>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-starter-web</artifactId>
  5. <exclusions>
  6. <exclusion>
  7. <artifactId>spring-boot-starter-tomcat</artifactId>
  8. <groupId>org.springframework.boot</groupId>
  9. </exclusion>
  10. </exclusions>
  11. </dependency>
  12. <!--引入其他的Servlet容器-->
  13. <dependency>
  14. <artifactId>spring-boot-starter-undertow</artifactId>
  15. <groupId>org.springframework.boot</groupId>
  16. </dependency>

4)、嵌入式Servlet容器自动配置原理;

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

  1. @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
  2. @Configuration
  3. @ConditionalOnWebApplication
  4. @Import(BeanPostProcessorsRegistrar.class)
  5. //导入BeanPostProcessorsRegistrar:Spring注解版;给容器中导入一些组件
  6. //导入了EmbeddedServletContainerCustomizerBeanPostProcessor:
  7. //后置处理器:bean初始化前后(创建完对象,还没赋值赋值)执行初始化工作
  8. public class EmbeddedServletContainerAutoConfiguration {
  9. @Configuration
  10. @ConditionalOnClass({ Servlet.class, Tomcat.class })//判断当前是否引入了Tomcat依赖;
  11. @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)//判断当前容器没有用户自己定义EmbeddedServletContainerFactory:嵌入式的Servlet容器工厂;作用:创建嵌入式的Servlet容器
  12. public static class EmbeddedTomcat {
  13. @Bean
  14. public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {
  15. return new TomcatEmbeddedServletContainerFactory();
  16. }
  17. }
  18. /**
  19. * Nested configuration if Jetty is being used.
  20. */
  21. @Configuration
  22. @ConditionalOnClass({ Servlet.class, Server.class, Loader.class,
  23. WebAppContext.class })
  24. @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
  25. public static class EmbeddedJetty {
  26. @Bean
  27. public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory() {
  28. return new JettyEmbeddedServletContainerFactory();
  29. }
  30. }
  31. /**
  32. * Nested configuration if Undertow is being used.
  33. */
  34. @Configuration
  35. @ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
  36. @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
  37. public static class EmbeddedUndertow {
  38. @Bean
  39. public UndertowEmbeddedServletContainerFactory undertowEmbeddedServletContainerFactory() {
  40. return new UndertowEmbeddedServletContainerFactory();
  41. }
  42. }

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

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

Spring Boot - 图20
2)、EmbeddedServletContainer:(嵌入式的Servlet容器)
Spring Boot - 图21
3)、以TomcatEmbeddedServletContainerFactory为例

  1. @Override
  2. public EmbeddedServletContainer getEmbeddedServletContainer(
  3. ServletContextInitializer... initializers) {
  4. //创建一个Tomcat
  5. Tomcat tomcat = new Tomcat();
  6. //配置Tomcat的基本环节
  7. File baseDir = (this.baseDirectory != null ? this.baseDirectory
  8. : createTempDir("tomcat"));
  9. tomcat.setBaseDir(baseDir.getAbsolutePath());
  10. Connector connector = new Connector(this.protocol);
  11. tomcat.getService().addConnector(connector);
  12. customizeConnector(connector);
  13. tomcat.setConnector(connector);
  14. tomcat.getHost().setAutoDeploy(false);
  15. configureEngine(tomcat.getEngine());
  16. for (Connector additionalConnector : this.additionalTomcatConnectors) {
  17. tomcat.getService().addConnector(additionalConnector);
  18. }
  19. prepareContext(tomcat.getHost(), initializers);
  20. //将配置好的Tomcat传入进去,返回一个EmbeddedServletContainer;并且启动Tomcat服务器
  21. return getTomcatEmbeddedServletContainer(tomcat);
  22. }

4)、我们对嵌入式容器的配置修改是怎么生效?

  1. ServerPropertiesEmbeddedServletContainerCustomizer

EmbeddedServletContainerCustomizer:定制器帮我们修改了Servlet容器的配置?
怎么修改的原理?
5)、容器中导入了EmbeddedServletContainerCustomizerBeanPostProcessor

  1. //初始化之前
  2. @Override
  3. public Object postProcessBeforeInitialization(Object bean, String beanName)
  4. throws BeansException {
  5. //如果当前初始化的是一个ConfigurableEmbeddedServletContainer类型的组件
  6. if (bean instanceof ConfigurableEmbeddedServletContainer) {
  7. //
  8. postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
  9. }
  10. return bean;
  11. }
  12. private void postProcessBeforeInitialization(
  13. ConfigurableEmbeddedServletContainer bean) {
  14. //获取所有的定制器,调用每一个定制器的customize方法来给Servlet容器进行属性赋值;
  15. for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
  16. customizer.customize(bean);
  17. }
  18. }
  19. private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {
  20. if (this.customizers == null) {
  21. // Look up does not include the parent context
  22. this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
  23. this.beanFactory
  24. //从容器中获取所有这葛类型的组件:EmbeddedServletContainerCustomizer
  25. //定制Servlet容器,给容器中可以添加一个EmbeddedServletContainerCustomizer类型的组件
  26. .getBeansOfType(EmbeddedServletContainerCustomizer.class,
  27. false, false)
  28. .values());
  29. Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
  30. this.customizers = Collections.unmodifiableList(this.customizers);
  31. }
  32. return this.customizers;
  33. }
  34. ServerProperties也是定制器

步骤:
1)、SpringBoot根据导入的依赖情况,给容器中添加相应的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】
2)、容器中某个组件要创建对象就会惊动后置处理器;EmbeddedServletContainerCustomizerBeanPostProcessor;
只要是嵌入式的Servlet容器工厂,后置处理器就工作;
3)、后置处理器,从容器中获取所有的EmbeddedServletContainerCustomizer,调用定制器的定制方法
###5)、嵌入式Servlet容器启动原理;
什么时候创建嵌入式的Servlet容器工厂?什么时候获取嵌入式的Servlet容器并启动Tomcat;
获取嵌入式的Servlet容器工厂:
1)、SpringBoot应用启动运行run方法
2)、refreshContext(context);SpringBoot刷新IOC容器【创建IOC容器对象,并初始化容器,创建容器中的每一个组件】;如果是web应用创建AnnotationConfigEmbeddedWebApplicationContext,否则:AnnotationConfigApplicationContext
3)、refresh(context);刷新刚才创建好的ioc容器;

  1. public void refresh() throws BeansException, IllegalStateException {
  2. synchronized (this.startupShutdownMonitor) {
  3. // Prepare this context for refreshing.
  4. prepareRefresh();
  5. // Tell the subclass to refresh the internal bean factory.
  6. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  7. // Prepare the bean factory for use in this context.
  8. prepareBeanFactory(beanFactory);
  9. try {
  10. // Allows post-processing of the bean factory in context subclasses.
  11. postProcessBeanFactory(beanFactory);
  12. // Invoke factory processors registered as beans in the context.
  13. invokeBeanFactoryPostProcessors(beanFactory);
  14. // Register bean processors that intercept bean creation.
  15. registerBeanPostProcessors(beanFactory);
  16. // Initialize message source for this context.
  17. initMessageSource();
  18. // Initialize event multicaster for this context.
  19. initApplicationEventMulticaster();
  20. // Initialize other special beans in specific context subclasses.
  21. onRefresh();
  22. // Check for listener beans and register them.
  23. registerListeners();
  24. // Instantiate all remaining (non-lazy-init) singletons.
  25. finishBeanFactoryInitialization(beanFactory);
  26. // Last step: publish corresponding event.
  27. finishRefresh();
  28. }
  29. catch (BeansException ex) {
  30. if (logger.isWarnEnabled()) {
  31. logger.warn("Exception encountered during context initialization - " +
  32. "cancelling refresh attempt: " + ex);
  33. }
  34. // Destroy already created singletons to avoid dangling resources.
  35. destroyBeans();
  36. // Reset 'active' flag.
  37. cancelRefresh(ex);
  38. // Propagate exception to caller.
  39. throw ex;
  40. }
  41. finally {
  42. // Reset common introspection caches in Spring's core, since we
  43. // might not ever need metadata for singleton beans anymore...
  44. resetCommonCaches();
  45. }
  46. }
  47. }

4)、 onRefresh(); web的ioc容器重写了onRefresh方法
5)、webioc容器会创建嵌入式的Servlet容器;createEmbeddedServletContainer();
6)、获取嵌入式的Servlet容器工厂:
EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
从ioc容器中获取EmbeddedServletContainerFactory 组件;TomcatEmbeddedServletContainerFactory创建对象,后置处理器一看是这个对象,就获取所有的定制器来先定制Servlet容器的相关配置;
7)、使用容器工厂获取嵌入式的Servlet容器:this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());
8)、嵌入式的Servlet容器创建对象并启动Servlet容器;
先启动嵌入式的Servlet容器,再将ioc容器中剩下没有创建出的对象获取出来;
IOC容器启动创建嵌入式的Servlet容器

9、使用外置的Servlet容器

嵌入式Servlet容器:应用打成可执行的jar
优点:简单、便携;
缺点:默认不支持JSP、优化定制比较复杂(使用定制器【ServerProperties、自定义EmbeddedServletContainerCustomizer】,自己编写嵌入式Servlet容器的创建工厂【EmbeddedServletContainerFactory】);
外置的Servlet容器:外面安装Tomcat—-应用war包的方式打包;

步骤

1)、必须创建一个war项目;(利用idea创建好目录结构)
2)、将嵌入式的Tomcat指定为provided;

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-tomcat</artifactId>
  4. <scope>provided</scope>
  5. </dependency>

3)、必须编写一个SpringBootServletInitializer的子类,并调用configure方法

  1. public class ServletInitializer extends SpringBootServletInitializer {
  2. @Override
  3. protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
  4. //传入SpringBoot应用的主程序
  5. return application.sources(SpringBoot04WebJspApplication.class);
  6. }
  7. }

4)、启动服务器就可以使用;

原理

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
3)、SpringServletContainerInitializer将@HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到onStartup方法的Set>;为这些WebApplicationInitializer类型的类创建实例;
4)、每一个WebApplicationInitializer都调用自己的onStartup;
Spring Boot - 图22
5)、相当于我们的SpringBootServletInitializer的类会被创建对象,并执行onStartup方法
6)、SpringBootServletInitializer实例执行onStartup的时候会createRootApplicationContext;创建容器

  1. protected WebApplicationContext createRootApplicationContext(
  2. ServletContext servletContext) {
  3. //1、创建SpringApplicationBuilder
  4. SpringApplicationBuilder builder = createSpringApplicationBuilder();
  5. StandardServletEnvironment environment = new StandardServletEnvironment();
  6. environment.initPropertySources(servletContext, null);
  7. builder.environment(environment);
  8. builder.main(getClass());
  9. ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
  10. if (parent != null) {
  11. this.logger.info("Root context already created (using as parent).");
  12. servletContext.setAttribute(
  13. WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
  14. builder.initializers(new ParentContextApplicationContextInitializer(parent));
  15. }
  16. builder.initializers(
  17. new ServletContextApplicationContextInitializer(servletContext));
  18. builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);
  19. //调用configure方法,子类重写了这个方法,将SpringBoot的主程序类传入了进来
  20. builder = configure(builder);
  21. //使用builder创建一个Spring应用
  22. SpringApplication application = builder.build();
  23. if (application.getSources().isEmpty() && AnnotationUtils
  24. .findAnnotation(getClass(), Configuration.class) != null) {
  25. application.getSources().add(getClass());
  26. }
  27. Assert.state(!application.getSources().isEmpty(),
  28. "No SpringApplication sources have been defined. Either override the "
  29. + "configure method or add an @Configuration annotation");
  30. // Ensure error pages are registered
  31. if (this.registerErrorPageFilter) {
  32. application.getSources().add(ErrorPageFilterConfiguration.class);
  33. }
  34. //启动Spring应用
  35. return run(application);
  36. }

7)、Spring的应用就启动并且创建IOC容器

  1. public ConfigurableApplicationContext run(String... args) {
  2. StopWatch stopWatch = new StopWatch();
  3. stopWatch.start();
  4. ConfigurableApplicationContext context = null;
  5. FailureAnalyzers analyzers = null;
  6. configureHeadlessProperty();
  7. SpringApplicationRunListeners listeners = getRunListeners(args);
  8. listeners.starting();
  9. try {
  10. ApplicationArguments applicationArguments = new DefaultApplicationArguments(
  11. args);
  12. ConfigurableEnvironment environment = prepareEnvironment(listeners,
  13. applicationArguments);
  14. Banner printedBanner = printBanner(environment);
  15. context = createApplicationContext();
  16. analyzers = new FailureAnalyzers(context);
  17. prepareContext(context, environment, listeners, applicationArguments,
  18. printedBanner);
  19. //刷新IOC容器
  20. refreshContext(context);
  21. afterRefresh(context, applicationArguments);
  22. listeners.finished(context, null);
  23. stopWatch.stop();
  24. if (this.logStartupInfo) {
  25. new StartupInfoLogger(this.mainApplicationClass)
  26. .logStarted(getApplicationLog(), stopWatch);
  27. }
  28. return context;
  29. }
  30. catch (Throwable ex) {
  31. handleRunFailure(context, listeners, analyzers, ex);
  32. throw new IllegalStateException(ex);
  33. }
  34. }

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

五、Docker

1、简介

Docker是一个开源的应用容器引擎;是一个轻量级容器技术;
Docker支持将软件编译成一个镜像;然后在镜像中各种软件做好配置,将镜像发布出去,其他使用者可以直接使用这个镜像;
运行中的这个镜像称为容器,容器启动是非常快速的。
Spring Boot - 图23
Spring Boot - 图24

2、核心概念

docker主机(Host):安装了Docker程序的机器(Docker直接安装在操作系统之上);
docker客户端(Client):连接docker主机进行操作;
docker仓库(Registry):用来保存各种打包好的软件镜像;
docker镜像(Images):软件打包好的镜像;放在docker仓库中;
docker容器(Container):镜像启动后的实例称为一个容器;容器是独立运行的一个或一组应用
Spring Boot - 图25
使用Docker的步骤:
1)、安装Docker
2)、去Docker仓库找到这个软件对应的镜像;
3)、使用Docker运行这个镜像,这个镜像就会生成一个Docker容器;
4)、对容器的启动停止就是对软件的启动停止;

3、安装Docker

1)、安装linux虚拟机

  1. 1)、VMWareVirtualBox(安装);<br /> 2)、导入虚拟机文件centos7-atguigu.ova;<br /> 3)、双击启动linux虚拟机;使用 root/ 123456登陆<br /> 4)、使用客户端连接linux服务器进行命令操作;<br /> 5)、设置虚拟机网络;<br /> 桥接网络=选好网卡==接入网线;<br /> 6)、设置好网络以后使用命令重启虚拟机的网络
  1. service network restart
  1. 7)、查看linuxip地址
  1. ip addr
  1. 8)、使用客户端连接linux

2)、在linux虚拟机上安装docker

步骤:

  1. 1、检查内核版本,必须是3.10及以上
  2. uname -r
  3. 2、安装docker
  4. yum install docker
  5. 3、输入y确认安装
  6. 4、启动docker
  7. [root@localhost ~]# systemctl start docker
  8. [root@localhost ~]# docker -v
  9. Docker version 1.12.6, build 3e8e77d/1.12.6
  10. 5、开机启动docker
  11. [root@localhost ~]# systemctl enable docker
  12. Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
  13. 6、停止docker
  14. systemctl stop docker

4、Docker常用命令&操作

1)、镜像操作

操作 命令 说明
检索 docker search 关键字 eg:docker search redis 我们经常去docker hub上检索镜像的详细信息,如镜像的TAG。
拉取 docker pull 镜像名:tag :tag是可选的,tag表示标签,多为软件的版本,默认是latest
列表 docker images 查看所有本地镜像
删除 docker rmi image-id 删除指定的本地镜像

https://hub.docker.com/

2)、容器操作

软件镜像(QQ安装程序)——运行镜像——产生一个容器(正在运行的软件,运行的QQ);
步骤:

  1. 1、搜索镜像
  2. [root@localhost ~]# docker search tomcat
  3. 2、拉取镜像
  4. [root@localhost ~]# docker pull tomcat
  5. 3、根据镜像启动容器
  6. docker run --name mytomcat -d tomcat:latest
  7. 4docker ps
  8. 查看运行中的容器
  9. 5 停止运行中的容器
  10. docker stop 容器的id
  11. 6、查看所有的容器
  12. docker ps -a
  13. 7、启动容器
  14. docker start 容器id
  15. 8、删除一个容器
  16. docker rm 容器id
  17. 9、启动一个做了端口映射的tomcat
  18. [root@localhost ~]# docker run -d -p 8888:8080 tomcat
  19. -d:后台运行
  20. -p: 将主机的端口映射到容器的一个端口 主机端口:容器内部的端口
  21. 10、为了演示简单关闭了linux的防火墙
  22. service firewalld status ;查看防火墙状态
  23. service firewalld stop:关闭防火墙
  24. 11、查看容器的日志
  25. docker logs container-name/container-id
  26. 更多命令参看
  27. https://docs.docker.com/engine/reference/commandline/docker/
  28. 可以参考每一个镜像的文档

3)、安装MySQL示例

  1. docker pull mysql

错误的启动

  1. [root@localhost ~]# docker run --name mysql01 -d mysql
  2. 42f09819908bb72dd99ae19e792e0a5d03c48638421fa64cce5f8ba0f40f5846
  3. mysql退出了
  4. [root@localhost ~]# docker ps -a
  5. CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
  6. 42f09819908b mysql "docker-entrypoint.sh" 34 seconds ago Exited (1) 33 seconds ago mysql01
  7. 538bde63e500 tomcat "catalina.sh run" About an hour ago Exited (143) About an hour ago compassionate_
  8. goldstine
  9. c4f1ac60b3fc tomcat "catalina.sh run" About an hour ago Exited (143) About an hour ago lonely_fermi
  10. 81ec743a5271 tomcat "catalina.sh run" About an hour ago Exited (143) About an hour ago sick_ramanujan
  11. //错误日志
  12. [root@localhost ~]# docker logs 42f09819908b
  13. error: database is uninitialized and password option is not specified
  14. You need to specify one of MYSQL_ROOT_PASSWORD, MYSQL_ALLOW_EMPTY_PASSWORD and MYSQL_RANDOM_ROOT_PASSWORD;这个三个参数必须指定一个

正确的启动

  1. [root@localhost ~]# docker run --name mysql01 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
  2. b874c56bec49fb43024b3805ab51e9097da779f2f572c22c695305dedd684c5f
  3. [root@localhost ~]# docker ps
  4. CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
  5. b874c56bec49 mysql "docker-entrypoint.sh" 4 seconds ago Up 3 seconds 3306/tcp mysql01

做了端口映射

  1. [root@localhost ~]# docker run -p 3306:3306 --name mysql02 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
  2. ad10e4bc5c6a0f61cbad43898de71d366117d120e39db651844c0e73863b9434
  3. [root@localhost ~]# docker ps
  4. CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
  5. ad10e4bc5c6a mysql "docker-entrypoint.sh" 4 seconds ago Up 2 seconds 0.0.0.0:3306->3306/tcp mysql02

几个其他的高级操作

  1. docker run --name mysql03 -v /conf/mysql:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
  2. 把主机的/conf/mysql文件夹挂载到 mysqldocker容器的/etc/mysql/conf.d文件夹里面
  3. mysql的配置文件就只需要把mysql配置文件放在自定义的文件夹下(/conf/mysql
  4. docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
  5. 指定mysql的一些配置参数

六、SpringBoot与数据访问

1、JDBC

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-jdbc</artifactId>
  4. </dependency>
  5. <dependency>
  6. <groupId>mysql</groupId>
  7. <artifactId>mysql-connector-java</artifactId>
  8. <scope>runtime</scope>
  9. </dependency>
  1. spring:
  2. datasource:
  3. username: root
  4. password: 123456
  5. url: jdbc:mysql://192.168.15.22:3306/jdbc
  6. driver-class-name: com.mysql.jdbc.Driver

效果:
默认是用org.apache.tomcat.jdbc.pool.DataSource作为数据源;
数据源的相关配置都在DataSourceProperties里面;
自动配置原理:
org.springframework.boot.autoconfigure.jdbc:
1、参考DataSourceConfiguration,根据配置创建数据源,默认使用Tomcat连接池;可以使用spring.datasource.type指定自定义的数据源类型;
2、SpringBoot默认可以支持;

  1. org.apache.tomcat.jdbc.pool.DataSourceHikariDataSourceBasicDataSource

3、自定义数据源类型

  1. /**
  2. * Generic DataSource configuration.
  3. */
  4. @ConditionalOnMissingBean(DataSource.class)
  5. @ConditionalOnProperty(name = "spring.datasource.type")
  6. static class Generic {
  7. @Bean
  8. public DataSource dataSource(DataSourceProperties properties) {
  9. //使用DataSourceBuilder创建数据源,利用反射创建响应type的数据源,并且绑定相关属性
  10. return properties.initializeDataSourceBuilder().build();
  11. }
  12. }

4、DataSourceInitializer:ApplicationListener
作用:
1)、runSchemaScripts();运行建表语句;
2)、runDataScripts();运行插入数据的sql语句;
默认只需要将文件命名为:

  1. schema-*.sqldata-*.sql
  2. 默认规则:schema.sqlschema-all.sql
  3. 可以使用
  4. schema:
  5. - classpath:department.sql
  6. 指定位置

5、操作数据库:自动配置了JdbcTemplate操作数据库

2、整合Druid数据源

  1. 导入druid数据源
  2. @Configuration
  3. public class DruidConfig {
  4. @ConfigurationProperties(prefix = "spring.datasource")
  5. @Bean
  6. public DataSource druid(){
  7. return new DruidDataSource();
  8. }
  9. //配置Druid的监控
  10. //1、配置一个管理后台的Servlet
  11. @Bean
  12. public ServletRegistrationBean statViewServlet(){
  13. ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
  14. Map<String,String> initParams = new HashMap<>();
  15. initParams.put("loginUsername","admin");
  16. initParams.put("loginPassword","123456");
  17. initParams.put("allow","");//默认就是允许所有访问
  18. initParams.put("deny","192.168.15.21");
  19. bean.setInitParameters(initParams);
  20. return bean;
  21. }
  22. //2、配置一个web监控的filter
  23. @Bean
  24. public FilterRegistrationBean webStatFilter(){
  25. FilterRegistrationBean bean = new FilterRegistrationBean();
  26. bean.setFilter(new WebStatFilter());
  27. Map<String,String> initParams = new HashMap<>();
  28. initParams.put("exclusions","*.js,*.css,/druid/*");
  29. bean.setInitParameters(initParams);
  30. bean.setUrlPatterns(Arrays.asList("/*"));
  31. return bean;
  32. }
  33. }

3、整合MyBatis

  1. <dependency>
  2. <groupId>org.mybatis.spring.boot</groupId>
  3. <artifactId>mybatis-spring-boot-starter</artifactId>
  4. <version>1.3.1</version>
  5. </dependency>

Spring Boot - 图26
步骤:
1)、配置数据源相关属性(见上一节Druid)
2)、给数据库建表
3)、创建JavaBean

4)、注解版

  1. //指定这是一个操作数据库的mapper
  2. @Mapper
  3. public interface DepartmentMapper {
  4. @Select("select * from department where id=#{id}")
  5. public Department getDeptById(Integer id);
  6. @Delete("delete from department where id=#{id}")
  7. public int deleteDeptById(Integer id);
  8. @Options(useGeneratedKeys = true,keyProperty = "id")
  9. @Insert("insert into department(departmentName) values(#{departmentName})")
  10. public int insertDept(Department department);
  11. @Update("update department set departmentName=#{departmentName} where id=#{id}")
  12. public int updateDept(Department department);
  13. }

问题:
自定义MyBatis的配置规则;给容器中添加一个ConfigurationCustomizer;

  1. @org.springframework.context.annotation.Configuration
  2. public class MyBatisConfig {
  3. @Bean
  4. public ConfigurationCustomizer configurationCustomizer(){
  5. return new ConfigurationCustomizer(){
  6. @Override
  7. public void customize(Configuration configuration) {
  8. configuration.setMapUnderscoreToCamelCase(true);
  9. }
  10. };
  11. }
  12. }
  1. 使用MapperScan批量扫描所有的Mapper接口;
  2. @MapperScan(value = "com.atguigu.springboot.mapper")
  3. @SpringBootApplication
  4. public class SpringBoot06DataMybatisApplication {
  5. public static void main(String[] args) {
  6. SpringApplication.run(SpringBoot06DataMybatisApplication.class, args);
  7. }
  8. }

5)、配置文件版

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

更多使用参照
http://www.mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/

4、整合SpringData JPA

1)、SpringData简介

Spring Boot - 图27

2)、整合SpringData JPA

JPA:ORM(Object Relational Mapping);
1)、编写一个实体类(bean)和数据表进行映射,并且配置好映射关系;

  1. //使用JPA注解配置映射关系
  2. @Entity //告诉JPA这是一个实体类(和数据表映射的类)
  3. @Table(name = "tbl_user") //@Table来指定和哪个数据表对应;如果省略默认表名就是user;
  4. public class User {
  5. @Id //这是一个主键
  6. @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
  7. private Integer id;
  8. @Column(name = "last_name",length = 50) //这是和数据表对应的一个列
  9. private String lastName;
  10. @Column //省略默认列名就是属性名
  11. private String email;

2)、编写一个Dao接口来操作实体类对应的数据表(Repository)

  1. //继承JpaRepository来完成对数据库的操作
  2. public interface UserRepository extends JpaRepository<User,Integer> {
  3. }

3)、基本的配置JpaProperties

  1. spring:
  2. jpa:
  3. hibernate:
  4. # 更新或者创建数据表结构
  5. ddl-auto: update
  6. # 控制台显示SQL
  7. show-sql: true

七、启动配置原理

几个重要的事件回调机制
配置在META-INF/spring.factories
ApplicationContextInitializer
SpringApplicationRunListener
只需要放在ioc容器中
ApplicationRunner
CommandLineRunner
启动流程:

1、创建SpringApplication对象

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

Spring Boot - 图28
Spring Boot - 图29

2、运行run方法

  1. public ConfigurableApplicationContext run(String... args) {
  2. StopWatch stopWatch = new StopWatch();
  3. stopWatch.start();
  4. ConfigurableApplicationContext context = null;
  5. FailureAnalyzers analyzers = null;
  6. configureHeadlessProperty();
  7. //获取SpringApplicationRunListeners;从类路径下META-INF/spring.factories
  8. SpringApplicationRunListeners listeners = getRunListeners(args);
  9. //回调所有的获取SpringApplicationRunListener.starting()方法
  10. listeners.starting();
  11. try {
  12. //封装命令行参数
  13. ApplicationArguments applicationArguments = new DefaultApplicationArguments(
  14. args);
  15. //准备环境
  16. ConfigurableEnvironment environment = prepareEnvironment(listeners,
  17. applicationArguments);
  18. //创建环境完成后回调SpringApplicationRunListener.environmentPrepared();表示环境准备完成
  19. Banner printedBanner = printBanner(environment);
  20. //创建ApplicationContext;决定创建web的ioc还是普通的ioc
  21. context = createApplicationContext();
  22. analyzers = new FailureAnalyzers(context);
  23. //准备上下文环境;将environment保存到ioc中;而且applyInitializers();
  24. //applyInitializers():回调之前保存的所有的ApplicationContextInitializer的initialize方法
  25. //回调所有的SpringApplicationRunListener的contextPrepared();
  26. //
  27. prepareContext(context, environment, listeners, applicationArguments,
  28. printedBanner);
  29. //prepareContext运行完成以后回调所有的SpringApplicationRunListener的contextLoaded();
  30. //s刷新容器;ioc容器初始化(如果是web应用还会创建嵌入式的Tomcat);Spring注解版
  31. //扫描,创建,加载所有组件的地方;(配置类,组件,自动配置)
  32. refreshContext(context);
  33. //从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
  34. //ApplicationRunner先回调,CommandLineRunner再回调
  35. afterRefresh(context, applicationArguments);
  36. //所有的SpringApplicationRunListener回调finished方法
  37. listeners.finished(context, null);
  38. stopWatch.stop();
  39. if (this.logStartupInfo) {
  40. new StartupInfoLogger(this.mainApplicationClass)
  41. .logStarted(getApplicationLog(), stopWatch);
  42. }
  43. //整个SpringBoot应用启动完成以后返回启动的ioc容器;
  44. return context;
  45. }
  46. catch (Throwable ex) {
  47. handleRunFailure(context, listeners, analyzers, ex);
  48. throw new IllegalStateException(ex);
  49. }
  50. }

3、事件监听机制

配置在META-INF/spring.factories
ApplicationContextInitializer

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

SpringApplicationRunListener

  1. public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {
  2. //必须有的构造器
  3. public HelloSpringApplicationRunListener(SpringApplication application, String[] args){
  4. }
  5. @Override
  6. public void starting() {
  7. System.out.println("SpringApplicationRunListener...starting...");
  8. }
  9. @Override
  10. public void environmentPrepared(ConfigurableEnvironment environment) {
  11. Object o = environment.getSystemProperties().get("os.name");
  12. System.out.println("SpringApplicationRunListener...environmentPrepared.."+o);
  13. }
  14. @Override
  15. public void contextPrepared(ConfigurableApplicationContext context) {
  16. System.out.println("SpringApplicationRunListener...contextPrepared...");
  17. }
  18. @Override
  19. public void contextLoaded(ConfigurableApplicationContext context) {
  20. System.out.println("SpringApplicationRunListener...contextLoaded...");
  21. }
  22. @Override
  23. public void finished(ConfigurableApplicationContext context, Throwable exception) {
  24. System.out.println("SpringApplicationRunListener...finished...");
  25. }
  26. }

配置(META-INF/spring.factories)

  1. org.springframework.context.ApplicationContextInitializer=\
  2. com.atguigu.springboot.listener.HelloApplicationContextInitializer
  3. org.springframework.boot.SpringApplicationRunListener=\
  4. com.atguigu.springboot.listener.HelloSpringApplicationRunListener

只需要放在ioc容器中
ApplicationRunner

  1. @Component
  2. public class HelloApplicationRunner implements ApplicationRunner {
  3. @Override
  4. public void run(ApplicationArguments args) throws Exception {
  5. System.out.println("ApplicationRunner...run....");
  6. }
  7. }

CommandLineRunner

  1. @Component
  2. public class HelloCommandLineRunner implements CommandLineRunner {
  3. @Override
  4. public void run(String... args) throws Exception {
  5. System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
  6. }
  7. }

八、自定义starter

starter:
1、这个场景需要使用到的依赖是什么?
2、如何编写自动配置

  1. @Configuration //指定这个类是一个配置类
  2. @ConditionalOnXXX //在指定条件成立的情况下自动配置类生效
  3. @AutoConfigureAfter //指定自动配置类的顺序
  4. @Bean //给容器中添加组件
  5. @ConfigurationPropertie结合相关xxxProperties类来绑定相关的配置
  6. @EnableConfigurationProperties //让xxxProperties生效加入到容器中
  7. 自动配置类要能加载
  8. 将需要启动就加载的自动配置类,配置在META-INF/spring.factories
  9. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  10. org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
  11. org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
  1. 3、模式:<br />启动器只用来做依赖导入;<br />专门来写一个自动配置模块;<br />启动器依赖自动配置;别人只需要引入启动器(starter)<br />mybatis-spring-boot-starter;自定义启动器名-spring-boot-starter<br />步骤:<br />1)、启动器模块
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5. <modelVersion>4.0.0</modelVersion>
  6. <groupId>com.atguigu.starter</groupId>
  7. <artifactId>atguigu-spring-boot-starter</artifactId>
  8. <version>1.0-SNAPSHOT</version>
  9. <!--启动器-->
  10. <dependencies>
  11. <!--引入自动配置模块-->
  12. <dependency>
  13. <groupId>com.atguigu.starter</groupId>
  14. <artifactId>atguigu-spring-boot-starter-autoconfigurer</artifactId>
  15. <version>0.0.1-SNAPSHOT</version>
  16. </dependency>
  17. </dependencies>
  18. </project>

2)、自动配置模块

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4. <modelVersion>4.0.0</modelVersion>
  5. <groupId>com.atguigu.starter</groupId>
  6. <artifactId>atguigu-spring-boot-starter-autoconfigurer</artifactId>
  7. <version>0.0.1-SNAPSHOT</version>
  8. <packaging>jar</packaging>
  9. <name>atguigu-spring-boot-starter-autoconfigurer</name>
  10. <description>Demo project for Spring Boot</description>
  11. <parent>
  12. <groupId>org.springframework.boot</groupId>
  13. <artifactId>spring-boot-starter-parent</artifactId>
  14. <version>1.5.10.RELEASE</version>
  15. <relativePath/> <!-- lookup parent from repository -->
  16. </parent>
  17. <properties>
  18. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  19. <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  20. <java.version>1.8</java.version>
  21. </properties>
  22. <dependencies>
  23. <!--引入spring-boot-starter;所有starter的基本配置-->
  24. <dependency>
  25. <groupId>org.springframework.boot</groupId>
  26. <artifactId>spring-boot-starter</artifactId>
  27. </dependency>
  28. </dependencies>
  29. </project>
  1. package com.atguigu.starter;
  2. import org.springframework.boot.context.properties.ConfigurationProperties;
  3. @ConfigurationProperties(prefix = "atguigu.hello")
  4. public class HelloProperties {
  5. private String prefix;
  6. private String suffix;
  7. public String getPrefix() {
  8. return prefix;
  9. }
  10. public void setPrefix(String prefix) {
  11. this.prefix = prefix;
  12. }
  13. public String getSuffix() {
  14. return suffix;
  15. }
  16. public void setSuffix(String suffix) {
  17. this.suffix = suffix;
  18. }
  19. }
  1. package com.atguigu.starter;
  2. public class HelloService {
  3. HelloProperties helloProperties;
  4. public HelloProperties getHelloProperties() {
  5. return helloProperties;
  6. }
  7. public void setHelloProperties(HelloProperties helloProperties) {
  8. this.helloProperties = helloProperties;
  9. }
  10. public String sayHellAtguigu(String name){
  11. return helloProperties.getPrefix()+"-" +name + helloProperties.getSuffix();
  12. }
  13. }
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