SpringBoot 的基本使用

  • 创建一个maven工程
  • 探究Hello World
  • 主程序类、主入口类
  • 使用Spring Initializer快速创建SpringBoot项目
    • 默认生成的SpringBoot项目
  • 配置文件的编写
    • YAML 语法
    • 值的写法
    • 配置文件值注入
    • @PropertySource和@ImportResource
    • 配置文件占位符
    • Profile
    • 配置文件加载位置
    • 外部配置加载顺序
  • web开发
    • 自动配置原理
    • 日志框架
    • SpringBoot 对前端的支持
      • SpringBoot对静态资源的映射规则
      • SpringBoot模板引擎
    • SpringMVC自动配置
    • 国际化开发编码
    • 禁用 thymeleaf 缓存
    • 拦截器进行登录检查
    • RestfulCRUD操作
  • 嵌入式 Servlet 容器
    • 注册三大组件
    • 使用其他Servlet容器
    • 嵌入式Servlet容器自动配置原理
    • 使用外置的Servlet容器
  • Docker
  • SpringBoot与数据访问
    • 原生 JDBC 的使用
    • 整合 Druid 数据源
    • 整合 mybatis
    • 整合SpringBoot 的 JPA
  • SpringBoot启动原理以及监听
    • SpringBoot 的 Application启动原理
    • SpringBoot事件监听
    • 自定义场景启动器

创建一个maven工程

  • 创建 maven 工程
  • 导入相关依赖jar包
    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.1.RELEASE
    

    
    
        
            org.springframework.boot
            spring-boot-starter-web
        
    
  • 编写一个主程序,启动Spring Boot应用
//该类必须与Controller包同层
@SpringBootApplication
public class HelloWordMainApplication {
    public static void main(String[] args) {
        //启动Spring
        SpringApplication.run(HelloWordMainApplication.class,args);
    }
}
  • 编写相关的 Controller 和 Service
@Controller
public class HelloController {
    @ResponseBody
    @RequestMapping("/hello")
    public String hello(){
        return "Hello World";
    }
}
  • 简化部署工作

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    


    
    cd Dessktop
    java -jar spring-boot-01-helloword-1.0-SNAPSHOT.jar
    

探究Hello World

  • POM文件(都可以点进去看)
    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.1.RELEASE
        
    
    
    
    
    org.springframework.boot
    spring-boot-dependencies
    2.2.1.RELEASE
    ../../spring-boot-dependencies
    
  • 依赖导入
    • spring-boot-starter:Spring Boot 场景启动器,帮我们导入了web模块正常启动所依赖的组件
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        
    

主程序类、主入口类

  • @SpringBootApplication:Spring Boot 应用标注在某个类上说明这个类是SpringBoot的主配置类,SpringBoot 就应该运行这个类的main方法来启动 SpringBoot 应用
  • @SpringBootConfiguration:修饰@SpringBootApplication,是Spring Boot 的配置类,可以标记在某个类上,表示是一个 Spring Boot 配置类
    • @Configuration:修饰@SpringBootConfiguratio,是Spring 配置类注解,该注解也是用 @Component 修饰的,表明是一个组件
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
  • @EnableAutoConfiguration:开启自动配置功能,以前需要配置的东西Spring已经帮我们自动配置
//EnableAutoConfiguration中的修饰两个注解
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
  • @AutoConfigurationPackage:自动配置包
    • @Import({Registrar.class}):spring的底层注解,给容器中导入组件
      • Registrar.class:将主配置类(@SpringBootApplication)所在包及所有子包所有组件扫描到Spring容器中,所以主配置类要放在与包同级
  • @Import({AutoConfigurationImportSelector.class})
    • AutoConfigurationImportSelector导入哪些组件的选择器,该类中会将需要导入的组件以全类名的方式封装在数组中返回,这些组件会被类加载器在spring.factories中将其添加到容器中,有了这些自动配置类,免去了手动编写注入功能组件等的工作。
    //选择器
    protected List getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }
  • SpringBoot在启动时会从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值,将这些值作为自动配置类导入到容器中,自动配置类就生效了,帮我们自动进行配置工作
  • C:\Users\DELL.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.2.1.RELEASE\spring-boot-autoconfigure-2.2.1.RELEASE.jar!\META-INF\spring.factories

使用Spring Initializer快速创建SpringBoot项目

IDEA支持Spring项目的创建向导快速创建一个SpringBoot项目,选择所需要的模块,向导会联网创建SpringBoot项目

默认生成的SpringBoot项目

  • 主程序已经写好了,我们只需要导入自己的逻辑
  • resources文件夹目录结构
    • static:保存所有的静态资源,像js、css、images
    • templates:保存所有的模块页面(SpringBoot默认jar包使用嵌入式Tomcat,默认不支持JSP页面),但是可以使用模板引擎(freemarke、thymeleaf)
    • application.properties:SpringBoot应用的配置文件,可以修改一些默认配置,像端口号
  • 配置文件
    • 配置文件名称是固定的(已是默认值,也可手动更改)
      • application.properties
      • application.yml
  • YAML:标记语言(A Markup Language)
    • 以数据为中心进行配置,比xml、json等更适合做配置文件
#application.properties文件配置端口号
server.port=8081

#application.yml文件配置端口号
server:
  port: 8081

配置文件的编写

YAML 语法

  • 基本语法
    • k:(空格)v :表示一对键值对(必须有空格)
    • 空格的缩进来控制层级关系,只要左对齐的一列数据,就都是同一层级的,同时属性和值也是大小写敏感的。
server:
  port: 8081
  path: /hello

值的写法:

  • 字面量:普通的值(数字,字符串,布尔)
    • k:v :字面量直接写入
    • “” : 双引号不会转义字符串里面的特殊字符,特殊字符会作为本身表示的意思
      • name: “zhangshan \n lisi”
      • 输出:zhangsan \n lisi
    • ‘’ : 单引号会转义特殊字符,特殊字符最终只是一个普通的字符串数据
      • name: “zhangshan \n lisi”
      • 输出:zhangsan 换行 lisi
  • 对象、Map(属性和值)(键值对):k: v : 在下一行来写对象的属性和值的关系,注意缩进
    • 分行写法:注意缩进
    • 行内写法:大括号,里面键值对间有空格
#分行写法
friends:
    lastName:zhangsan
    age:20
#行内写法
friends: {lastName: zhangsan,age: 20}
  • 数组:用 - 值表示数组中的元素
    • 分行写法:注意缩进
    • 行内写法:中括号,里面对象间有空格
#分行写法
pets:
 - cat
 - dog
 - pig
#行内写法
pets: [cat,dog,pig]

配置文件值注入

配置文件:全局变量

person:
  name: zhangsan
  age: 20

pom.xml

  • 导入配置文件处理器,以后编写配置文件就会有提示了
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-configuration-processorartifactId>
            <version>2.1.7.RELEASEversion>
            <optional>trueoptional>
        dependency>

JavaBean

  • 将配置文件配置的每一个属性的值,映射到这个组件中
  • @ConfigurationProperties(prefix = “person”):告诉springboot将本类中的所有属性和配置文件中相关的配置进行绑定
  • prefix = “person”:这个是指配置文件中哪个下面的所有属性进行一一映射
  • 同时只有是容器中的组件才能使用 @ConfigurationProperties(prefix = “person”),所有要加入注释 @Component
  • @Value():标注一个属性,注入属性值
/**
 * @author Ming
 * @date 2019/11/14 - 22:48
 * 将配置文件配置的每一个属性的值,映射到这个组件中
 * @ConfigurationProperties(prefix = "person"):告诉springboot将本类中的所有属性和配置文件中相关的配置进行绑定
 * prefix = "person":这个是指配置文件中哪个下面的所有属性进行一一映射
 * 同时只有是容器中的组件才能使用 @ConfigurationProperties(prefix = "person"),所有要加入注释 @Component
 */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;
    //...getter和setter方法...
    }


//也可以    
@Component
public class Person {
    @Email
    @Value("${person.name}")
    private String name;
    @Value("#{11*5}")
    private Integer age;
    private Map<String,Object> map;
    }
    
@Configurationproperties @Value
功能 批量注入配置文件属性 只能注入一个属性值
松散绑定(eg:last-name) 支持 不支持
SpEL 不支持 支持
JSR303数据校验 支持 不支持
复杂类型封装 支持 不支持

@PropertySource和@ImportResource

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

//person上的注解
@PropertySource(value = "classpath:person.properties")

//person.properties文件上的内容
person.name=李四person.properties
person.map.hhh='123'
person.map.k2=321

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

//标注在主配置类上,让配置文件生效
@ImportResource(location={"classpath:beans.xml"})

SpringBoot推荐给容器中添加组件的方式:不推荐使用xml文件,而使用配置类(注解方式)

  • 配置类==Spring配置文件
  • 使用@Bean向容器中添加组件,id就是标注注解的类名称,返回啥就向容器中添加啥
/**
 * @author Ming
 * @date 2019/11/24 - 23:18
 * @Configration:指明当前类是一个配置类,就是用来代替之前的Spring配置文件
 * 在配置类中的@Bean就相当于,且 id 等于类的名称,返回啥就向容器添加啥
 */
@Configuration
public class MyApplicationConfig {

    @Bean
    public HelloService helloService(){
        System.out.println("配置类给Spring添加组件了......");
        return new HelloService();
    }
}

配置文件占位符

随机数:{random.int}、{random.uuid}、{random.int[1024,65536]}…
占位符获取之前配置的值,如果没有可以用冒号(:)指定默认值以防止报错

person.name=李四${random.uuid}
person.map.hhh='123'
person.map.k2=${person.name}

Profile

1、多Profile文件

  • 我们在主配置文件编写的时候,文件名可以是 application-{profile}.properties/yml,默认使用application.properties的配置
  • yml支持多文档块方式
    • 可以用—分开文档块,然后用active来激活
server:
    port: 8081
spring:
    profile:
        active:dev
---
server:
    port: 8081
spring:
    profiles:dev
---
server:
    port: 8084
spring:
    profiles: prod
  • 激活指定Pofile
    • 在配置文件的指定
    • 命令行激活:在配置里的Program arguments行中:–spring.profiles.active=dev
    • cmd命令行:java -jar jar包名称 --spring.profiles.active=dev
    • 虚拟机参数写法:在 VM options中配置:-Dspring.profiles.active=dev

spring.profiles.active=dev

-Dspring.profiles.active=dev

配置文件加载位置

可识别位置(有优先级):高优先级会覆盖低优先级

  • file:./config/
  • file:./
  • classpath:/config/
  • classpath:/

可以通过spring.config.location来改变默认的配置文件位置


外部配置加载顺序

  • 命令行参数
java -jar spring-boot-01-helloword-1.0-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc
  • 1.来自java:comp/env的NDI属性
  • 2.java系统属性(System.getProperties())
  • 3.操作系统环境变量
  • RandomValuePropertySource配置的random.*属性值

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

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

再来加载不带profile

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

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

  • 8.@Configuration注解类上的@PropertySource

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


web开发

自动配置原理

SpringBoot提供配置文件的属性配置相关文档

自动配置原理

  • SpringBoot启动时加载自动配置类,开启了自动配置功能@EnableConfiguration
//扫描jar包类路径下META-INF/spring.factories,将扫描到的这些文件的内容整合成properties对象
//再从properties中获取到EnableConfiguration.class类(类名)对应的值
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }
    
//被调用的SpringFactoriesLoader加载器    
public final class SpringFactoriesLoader {
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
    private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);
    private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap();

    private SpringFactoriesLoader() {
    }    
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.rest.RestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketRequesterAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketServerAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketStrategiesAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.security.rsocket.RSocketSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.saml2.Saml2RelyingPartyAutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.reactive.ReactiveOAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.reactive.ReactiveOAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration,\
org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration

每一个 xxxxAutoConfiguration 类都是容器中的一个组件,都加入到容器中,用他们来做自动配置

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

    //只有一个有参构造器的情况下,参数的值会从容器中拿
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }

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

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

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

使用精髓:

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

  • 首先看我们所需要的功能有没有SpringBoot默认写好的自动配置类

  • 有的话可以看这个自动配置类到底配置了哪些的组件(有的话就可以不用配了)

  • 给容器中自动配置类添加组件的时候,会从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值
    自动配置类需要一定条件才能生效
    xxxxAutoConfiguration:自动配置类,给容器中添加组件
    xxxxProperties:封装配置文件中相关的属性值

  • 可以通过debug=true 属性来查看自动配置类是否生效


日志框架

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

日志门面(日志抽象层) 日志实现
JCL、SLF4j、jboss-logging Log4j、JUL、Log4j2、Logback

SpringBoot底层是Spring框架,Spring框架使用的是JCL。然而SpringBoot使用的是SLF4J和logback


日志配置

    Logger logger = LoggerFactory.getLogger(getClass());
    @Test
    void contextLoads() {
        //日志级别 由低到高trace
        //可以调整输出级别就可以在这个级别和更高级别输出
        //Spring默认级别是info级别
        logger.trace("trace日志");
        logger.debug("debug日志");
        logger.info("info日志");
        logger.warn("warm日志");
        logger.error("error日志");
    }

可以调节日志级别

#logging.level.+包名=级别名称
logging.level.com.springboot=trace
#在当前项目下生成springboot.log日志,不指定路径默认在根目录下
logging.file.name=D:/SpringBoot.log
#在项目当前磁盘根目录下创建也就是D盘
logging.path=/spring/log
#在控制台输出的格式,默认为时间+日志级别+线程Id+类名+信息
#logging.pattern.console=
#指定文件中日志输出格式
#logging.pattern.file=

SpringBoot对前端的支持


SpringBoot对静态资源的映射规则

        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
            } else {
                Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
                CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
                if (!registry.hasMappingForPattern("/webjars/**")) {
                    this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{"/webjars/**"}).addResourceLocations(new String[]{"classpath:/META-INF/resources/webjars/"}).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
                }

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

            }
        }
        
        //配置欢迎页映射
        @Bean
        public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext, FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
            WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(new TemplateAvailabilityProviders(applicationContext), applicationContext, this.getWelcomePage(), this.mvcProperties.getStaticPathPattern());
            welcomePageHandlerMapping.setInterceptors(this.getInterceptors(mvcConversionService, mvcResourceUrlProvider));
            return welcomePageHandlerMapping;
        }
  • 所有的 /webjars/** 都去classpath:/META-INF/resource/webjars/找资源
    • webjars:以jar包的形式引入静态资源,引入需要在xml文件中引入
    • http://localhost:8080/webjars/jquery/3.4.1/jquery.js

https://www.webjars.org/

        <dependency>
            <groupId>org.webjarsgroupId>
            <artifactId>jqueryartifactId>
            <version>3.4.1version>
        dependency>
  • /**,访问当前项目的任何资源
"classpath:/META-INF/resources/"
"classpath:/resources/"
"classpath:/static/"
"classpath:/public/"
  • 欢迎页:静态资源文件夹下的所有index.html。被“/**”映射
    local
    • 放在resources/public文件下
    • css等放在resources/static下
    • 图标放在resources/resources下
    • 也可在application.properties中配置spring.resources
spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/,classpath:/


SpringBoot模板引擎

  • SpringBoot推荐是使用Thymeleaf模板引擎:语法简单,功能强大
    
    <properties>
        <java.version>1.8java.version>
        
        <thymeleaf-layout-dialect.version>2.2.1thymeleaf-layout-dialect.version>
    properties>
    
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-thymeleafartifactId>
    dependency>

  • Thymeleaf 使用和用法
@ConfigurationProperties(
    prefix = "spring.thymeleaf"
)
public class ThymeleafProperties {
    private static final Charset DEFAULT_ENCODING;
    public static final String DEFAULT_PREFIX = "classpath:/templates/";
    public static final String DEFAULT_SUFFIX = ".html";
    private boolean checkTemplate = true;
    private boolean checkTemplateLocation = true;
    
    //前缀和后缀
    private String prefix = "classpath:/templates/";
    private String suffix = ".html";
    
    
    private String mode = "HTML";
    private Charset encoding;
    private boolean cache;
    private Integer templateResolverOrder;
    private String[] viewNames;
    private String[] excludedViewNames;
    private boolean enableSpringElCompiler;
    private boolean renderHiddenMarkersBeforeCheckboxes;
    private boolean enabled;
    private final ThymeleafProperties.Servlet servlet;
    private final ThymeleafProperties.Reactive reactive;
    
    
    @RequestMapping("/success")
    public String success(){
        //解析完访问classpath:/templates/success.html
        //不能加ResponseBody,否则封装为字符串了
        return "success";
    }
  • 1、导入 Thymeleaf 的命名空间
<html lang="en" xmlns:th="http://www.thymeleaf.org">
  • 2、使用 Thymeleaf 语法

<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>

<div th:text="${hello}">如果没有后端,则显示这些内容div>
body>
html>
  • 3、语法规则
    • th:text:改变元素里面的文本内容
    • th:可以用其替换掉容易元素原先的值
  • 4、表达式语法
Simple expressions: (表达式语法)
    Variable Expressions:${...} 获取变量值,OGNL表达式
        1.获取属性值、调用方法
        2.使用内置的基本对象
        3.内置的工具对象
    Selection Variable Expressions: *{...} :和 ${} 功能一样
        1、补充:配合 th:object 使用
        

Name: Sebastian.

Surname: Pepper.

Nationality: Saturn.

Message Expressions: #{...} :获取国际化内容 Link URL Expressions: @{...} :定义 url 链接 view view view Fragment Expressions: ~{...} :片段引用表达式 Literals (字面量) Text literals: 'one text' , 'Another one!' ,… Number literals: 0 , 34 , 3.0 , 12.3 ,… Boolean literals: true , false Null literal: null Literal tokens: one , sometext , main ,… Text operations:(文本操作) String concatenation: + Literal substitutions: |The name is ${name}| Arithmetic operations: (数学运算) Binary operators: + , - , * , / , % Minus sign (unary operator): - Boolean operations: (布尔运算) Binary operators: and , or Boolean negation (unary operator): ! , not Comparisons and equality: (比较运算) Comparators: > , < , >= , <= ( gt , lt , ge , le ) Equality operators: == , != ( eq , ne ) Conditional operators: (条件运算:比如三元运算符) If-then: (if) ? (then) If-then-else: (if) ? (then) : (else) Default: (value) ?: (defaultvalue) Special tokens: (特殊运算符) No-Operation:_

SpringMVC自动配置

Spring Boot为Spring MVC提供了自动配置,可与大多数应用程序完美配合。

自动配置在Spring的默认值之上添加了以下功能:

  • 包含ContentNegotiatingViewResolver和BeanNameViewResolver。
    • 配置 ViewResolver(视图解析器,根据方法的返回值得到视图对象),视图对象决定如何渲染(转发?重定向?)
    • ContentNegotiatingViewResolver :组合所有的视图解析器
    • 如何定制和添加一个视图解析器,自动的将其组合进来
  • 支持提供静态资源,包括对WebJars的支持。
  • 自动注册了 Converter,GenericConverter,Formatter豆类
    • Converter:转换器,类型转换使用Converter
    • Formatter:格式化器,如日期的转换
  • 支持HttpMessageConverters
    • 支持HttpMessageConverters:消息转换器,用于转换Http请求和响应的,如User对象转换为Json
    • HttpMessageConverters 是从容器中确定的,从容器中获取所有的HTTP转换器,所以可以自己给容器添加,将自己的组件注册在容器中。
  • 自动注册MessageCodesResolver
    • MessageCodesResolver:定义错误代码生成规则
  • 静态index.html支持:静态首页的访问
  • 定制Favicon支持
  • 自动使用ConfigurableWebBindingInitializer
    • ConfigurableWebBindingInitializer:我们也可以配置一个来替换原有的

如果您想保留Spring Boot MVC功能,而只想添加其他MVC配置(拦截器,格式化程序,视图控制器等),则可以添加自己@Configuration的type类 WebMvcConfigurerAdapter,但不添加 @EnableWebMvc。如果您希望提供的自定义实例RequestMappingHandlerMapping,RequestMappingHandlerAdapter或者 ExceptionHandlerExceptionResolver可以声明一个WebMvcRegistrationsAdapter 提供此类组件的实例。

如果您想完全控制Spring MVC,可以使用添加自己的@Configuration 注释@EnableWebMvc。

如何修改SpringBoot的默认配置

  • SpringBoot 在自动配置很多组件的时候,先看用户是否有自己配置的组件(@Bean、@Component),如果有就用用户自己配置的,如果没有就自动配置。如果有些组件可以有多个(视图解析器)的时候,SpringBoot将用户自己配置的和自身的组合起来
    • 扩展SpringMVC(添加配置类方法)
      • 编写一个配置类,该配置类(@Configuration),是WebMvcConfigurerAdapter类型,不能用 @EnableWebMvc 标注,添加了会使其他的MVC配置类失效
      • 原理:
        • WebMvcAutoConfiguration 是 SpringMVC 的自动配置类
        • 在做其他配置时会导入@ImportWebMvcConfiguration.class
//即保留了原有的自动配置,也能用我们的扩展
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {
    //即保留了原有的自动配置,也能用我们的扩展
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
//        super.addViewControllers(registry);
        //浏览器发送 /hello 请求时来到 success.html
        registry.addViewController("hello").setViewName("success");
    }

    @Bean
    public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
        WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter(){
            @Override
            public void addViewControllers(ViewControllerRegistry registry) {
                //super.addViewControllers(registry);
                registry.addViewController("/").setViewName("index");
                registry.addViewController("/index.html").setViewName("index");
            }
        };
        return adapter;
    };

}

国际化开发编码

  • 可编写一个配置类来代替原有的国际解析器
    • 1、添加一个配置类来继承 LocaleResolver 接口
    • 2、将该类添加到 MVC 的配置类中
public class MyLocaleResolver implements LocaleResolver {
    @Override
    public Locale resolveLocale(HttpServletRequest httpServletRequest) {
        Locale locale = Locale.getDefault();
        String l = httpServletRequest.getParameter("l");
        if(StringUtils.isEmpty(l)){
            String[] spilt =  l.split("_");
            locale = new Locale(spilt[0],spilt[1]);
        }
        return locale;
    }

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

    }
}
=================================================
    @Bean
    public LocaleResolver localeResolver(){
        return new MyLocaleResolver();
    }


禁用thymeleaf缓存

  • 1、在配置文件中配置相关信息
  • 2、ctrl+F9
# 禁用模板引擎缓存
spring.thymeleaf.cache=false

拦截器进行登录检查

  • 1、编写一个拦截器
  • 2、将拦截器注册到MVC中
/**
 * @author Ming
 * @date 2020/1/12 - 15:52
 *
 * 登录的拦截检查,要实现HandlerInterceptor 接口
 */
public class MyHandlerInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Object obj = request.getSession().getAttribute("loginUser");
        if(obj==null){
            //未登录,拦截,返回登录页面
            request.setAttribute("msg","没有权限,请先登录!");
            request.getRequestDispatcher("/index.html").forward(request,response);
            return false;
        }else{

            return true;
        }
    }

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

    }

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

    }
}

=======================

    //MyMvcConfig类,重写方法
    @Bean
    public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
        WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter(){
            @Override
            public void addViewControllers(ViewControllerRegistry registry) {
                //super.addViewControllers(registry);
                registry.addViewController("/").setViewName("login");
                registry.addViewController("/index.html").setViewName("login");
                registry.addViewController("/main.html").setViewName("main");
            }

            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                //注册拦截器,拦截所有请求,排除登录页面的请求,静态资源不需要排除
                registry.addInterceptor(new MyHandlerInterceptor()).addPathPatterns("/**").excludePathPatterns("/index.html","/","/user/login");
            }
        };

        return adapter;
    };

RestfulCRUD操作

  • 1、RestfulCRUD和普通的CRUD区别
普通CRUD RestfulCRUD
查询 getEmp emp—GET
添加 addEmp?xxx emp—POST
修改 updateEmp?id=xxx&xxx=xx emp/{id}—PUT
删除 deleteEmp?id=xx emp/{ID}—DELETE
  • 2、SpringBoot 错误处理机制
    • 默认是一个页面,如果不是则返回 JSON 数据
    • 默认给容器中添加了以下组件
      • 1、DefaultErrorAttributes
      • 2、BasicErrorAttributes:处理默认 /error 请求
      • 3、ErrorPageCustomizer:定制错误的响应规则
      • 4、DefaultErrorViewResolver:去哪个页面
    @RequestMapping(
        produces = {"text/html"}
    )//产生 Html 数据,浏览器来到这个处理
    public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
        HttpStatus status = this.getStatus(request);
        Map<String, Object> model = Collections.unmodifiableMap(this.getErrorAttributes(request, this.isIncludeStackTrace(request, MediaType.TEXT_HTML)));
        response.setStatus(status.value());
        //去到哪个页面作为错误页面,包含页面地址和页面内容
        ModelAndView modelAndView = this.resolveErrorView(request, response, status, model);
        return modelAndView != null ? modelAndView : new ModelAndView("error", model);
    }

    @RequestMapping//产生 Json 数据,其他客户端用这个处理
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        HttpStatus status = this.getStatus(request);
        if (status == HttpStatus.NO_CONTENT) {
            return new ResponseEntity(status);
        } else {
            Map<String, Object> body = this.getErrorAttributes(request, this.isIncludeStackTrace(request, MediaType.ALL));
            return new ResponseEntity(body, status);
        }
    }
    //DefaultErrorViewResolver:去哪个页面
    public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map model) {
        ModelAndView modelAndView = this.resolve(String.valueOf(status.value()), model);
        if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
            modelAndView = this.resolve((String)SERIES_VIEWS.get(status.series()), model);
        }

        return modelAndView;
    }

    private ModelAndView resolve(String viewName, Map model) {
        //默认SpringBoot可以去到哪一个页面?error/404
        String errorViewName = "error/" + viewName;
        
        //模板引擎可以解析这个页面地址就用模板引擎解析
        TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName, this.applicationContext);
        
        //模板引擎可用和不可用调用不同的方法
        return provider != null ? new ModelAndView(errorViewName, model) : this.resolveResource(errorViewName, model);
    }
  • 一旦出现 4xx 或者 5xx 之类的错误,ErrorPageCustomizer会生效(定制错误的响应规则),就会来到 error 请求,就会被 BasicErrorAttributes 处理
//响应页面
protected ModelAndView resolveErrorView(HttpServletRequest request, HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
        Iterator var5 = this.errorViewResolvers.iterator();

        ModelAndView modelAndView;
        do {
            if (!var5.hasNext()) {
                return null;
            }

            ErrorViewResolver resolver = (ErrorViewResolver)var5.next();
            modelAndView = resolver.resolveErrorView(request, status, model);
        } while(modelAndView == null);

        return modelAndView;
    } 
  • 2、如何定制错误的页面
    • 1、有模板引擎的情况下,在 templates 下建立一个子文件夹 error,在里面放置一个名字为 404.html(相应的状态码400、500…) 的页面即可。
    • 2、如果没有匹配到可以在error文件夹下,可以放置一个4xx.html 和 5xx.html 去到没有被匹配到的(优先精确寻找状态码页面)
    • 3、能取出的错误共享信息:时间戳(timestamp)、状态码(status)、错误提示(error)、异常对象(exception)、异常消息(message)、JSR303数据校验(errors)
  • 3、如何定制错误的 Json 数据
  • 需要将我们定制的数据携带出去
    • 出现错误以后,会来到 /error 请求,会被BasicErrorController处理,相应出去可以获取的数据是由getErrorAttributes得到的(是AbstractError(ErrorController)规定的方法)
      • 1、完全来编写一个ErrorController的实现类(或者编写AbstractErrorController的子类),放在容器中
      • 2、页面上能用的数据,或者是json返回能用的数据都是通过errorAttributes.getAttributes()方法得到的
@ControllerAdvice
public class MyExceptionHandler {

    /**
     * 可达到自适应效果的错误请求处理
     * @param e 错误
     * @param request 原生的request
     * @return 返回页面,模板引擎解析
     */
    @ExceptionHandler(UserException.class)
    public String handleException(Exception e, HttpServletRequest request){
        Map<String ,Object> map = new HashMap<>(8);
        map.put("data","放置的错误消息数据");
        map.put("message",e.getMessage());
        //设置状态码,然后转发
        map.put("javax.servlet.error.status_code",500);
        request.setAttribute("ext",map);
        //转发到 /error
        return "forward:/error";
    }
}

============================================================

@ControllerAdvice
public class MyExceptionHandler {

    /**
     * 可达到自适应效果的错误请求处理
     * @param e 错误
     * @param request 原生的request
     * @return 返回页面,模板引擎解析
     */
    @ExceptionHandler(UserException.class)
    public String handleException(Exception e, HttpServletRequest request){
        Map<String ,Object> map = new HashMap<>(8);
        map.put("data","放置的错误消息数据");
        map.put("message",e.getMessage());
        //设置状态码,然后转发
        map.put("javax.servlet.error.status_code",500);
        request.setAttribute("ext",map);
        //转发到 /error
        return "forward:/error";
    }
}

嵌入式 Servlet 容器

注册三大组件

  • 1、修改和定制一个Servlet容器的相关配置
    • (1)、修改和server有关的配置(ServerProperties)
    • (2)、编写一个EmbeddedServletContainerCustomizer:嵌入式的Servlet容器的定制器
    @Bean
    public WebServerFactoryCustomizer webServerFactoryCustomizer(){
        return new WebServerFactoryCustomizer<ConfigurableWebServerFactory>() {
            @Override
            public void customize(ConfigurableWebServerFactory factory) {
                factory.setPort(8082);
            }
        };
    }

  • 2、由于SpringBoot默认是以jar包方式启动嵌入式 Servlet 容器来启动SpringBoot的web应用,没有web.xml文件
    • 注册三大组件用以下方式(Servlet、Filter、Listener)
      • 1、ServletRegistrationBean
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("Hello MyServlet");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("Hello MyServlet");
    }
}

    /**
     * 注册Servlet组件
     * @return ServletRegistrationBean
     */
    @Bean
    public ServletRegistrationBean myServlet(){
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
        return registrationBean;
    }
///    
   public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("MyFilter process...");
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {

    }
}

    /**
     * 注册拦截器
     * @return FilterRegistrationBean
     */
    @Bean
    public FilterRegistrationBean myFilter(){
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new MyFilter());
        filterRegistrationBean.setUrlPatterns(Arrays.asList("/myServlet","/myFilter"));
        return filterRegistrationBean;
    }
///    
public class MyListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("contextInitialized...web应用启动");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("contextDestroyed...web应用销毁");
    }
}    

    /**
     * 注册监听器
     * @return ServletListenerRegistrationBean
     */
    @Bean
    public ServletListenerRegistrationBean myListener(){
        ServletListenerRegistrationBean<MyListener> listenerRegistrationBean = new ServletListenerRegistrationBean<>(new MyListener());
        return listenerRegistrationBean;
    }

使用其他Servlet容器

  • SpringBoot支持的Servlet容器
    • Jetty(长链接应用)
    • Undertow(不支持jsp):高性能,非阻塞
  • 切换其他服务器
    • 1、在生成树(或者pom.xml文件)中去除服务器的相关依赖
    • 2、导入相关依赖
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-tomcatartifactId>
                    <groupId>org.springframework.bootgroupId>
                exclusion>
            exclusions>
        dependency>
        
        
		<dependency>
			<artifactId>spring-boot-starter-undertowartifactId>
			<groupId>org.springframework.bootgroupId>
		dependency>

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

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
//导入BeanPostProcessorsRegistrar:Spring注解版;给容器中导入一些组件
//导入了EmbeddedServletContainerCustomizerBeanPostProcessor:
//后置处理器:bean初始化前后(创建完对象,还没赋值赋值)执行初始化工作
public class EmbeddedServletContainerAutoConfiguration {
    
    @Configuration
	@ConditionalOnClass({ Servlet.class, Tomcat.class })//判断当前是否引入了Tomcat依赖;
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)//判断当前容器没有用户自己定义EmbeddedServletContainerFactory:嵌入式的Servlet容器工厂;作用:创建嵌入式的Servlet容器
	public static class EmbeddedTomcat {

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

	}
/SpringBoot 2.0后
@Configuration(
    proxyBeanMethods = false
)
@AutoConfigureOrder(-2147483648)
@ConditionalOnClass({ServletRequest.class})
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@EnableConfigurationProperties({ServerProperties.class})
@Import({ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})
public class ServletWebServerFactoryAutoConfiguration {
    public ServletWebServerFactoryAutoConfiguration() {
    }
	
  • 步骤:

    • 1)、SpringBoot根据导入的依赖情况,给容器中添加相应的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】

    • 2)、容器中某个组件要创建对象就会惊动后置处理器;EmbeddedServletContainerCustomizerBeanPostProcessor;只要是嵌入式的Servlet容器工厂,后置处理器就工作;

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


自动配置原理(细)

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

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
//导入BeanPostProcessorsRegistrar:Spring注解版;给容器中导入一些组件
//导入了EmbeddedServletContainerCustomizerBeanPostProcessor:
//后置处理器:bean初始化前后(创建完对象,还没赋值赋值)执行初始化工作
public class EmbeddedServletContainerAutoConfiguration {
    
    @Configuration
	@ConditionalOnClass({ Servlet.class, Tomcat.class })//判断当前是否引入了Tomcat依赖;
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)//判断当前容器没有用户自己定义EmbeddedServletContainerFactory:嵌入式的Servlet容器工厂;作用:创建嵌入式的Servlet容器
	public static class EmbeddedTomcat {

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

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

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

	}

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

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

	}

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

public interface EmbeddedServletContainerFactory {

   //获取嵌入式的Servlet容器
   EmbeddedServletContainer getEmbeddedServletContainer(
         ServletContextInitializer... initializers);

}

2)、EmbeddedServletContainer:(嵌入式的Servlet容器)

3)、以TomcatEmbeddedServletContainerFactory为例

@Override
public EmbeddedServletContainer getEmbeddedServletContainer(
      ServletContextInitializer... initializers) {
    //创建一个Tomcat
   Tomcat tomcat = new Tomcat();
    
    //配置Tomcat的基本环节
   File baseDir = (this.baseDirectory != null ? this.baseDirectory
         : createTempDir("tomcat"));
   tomcat.setBaseDir(baseDir.getAbsolutePath());
   Connector connector = new Connector(this.protocol);
   tomcat.getService().addConnector(connector);
   customizeConnector(connector);
   tomcat.setConnector(connector);
   tomcat.getHost().setAutoDeploy(false);
   configureEngine(tomcat.getEngine());
   for (Connector additionalConnector : this.additionalTomcatConnectors) {
      tomcat.getService().addConnector(additionalConnector);
   }
   prepareContext(tomcat.getHost(), initializers);
    
    //将配置好的Tomcat传入进去,返回一个EmbeddedServletContainer;并且启动Tomcat服务器
   return getTomcatEmbeddedServletContainer(tomcat);
}

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

ServerProperties、EmbeddedServletContainerCustomizer

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

怎么修改的原理?

5)、容器中导入了EmbeddedServletContainerCustomizerBeanPostProcessor

//初始化之前
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
      throws BeansException {
    //如果当前初始化的是一个ConfigurableEmbeddedServletContainer类型的组件
   if (bean instanceof ConfigurableEmbeddedServletContainer) {
       //
      postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
   }
   return bean;
}

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

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

ServerProperties也是定制器

步骤:

1)、SpringBoot根据导入的依赖情况,给容器中添加相应的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】

2)、容器中某个组件要创建对象就会惊动后置处理器;EmbeddedServletContainerCustomizerBeanPostProcessor;

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

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

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

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

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

1)、SpringBoot应用启动运行run方法

2)、refreshContext(context);SpringBoot刷新IOC容器【创建IOC容器对象,并初始化容器,创建容器中的每一个组件】;如果是web应用创建AnnotationConfigEmbeddedWebApplicationContext,否则:AnnotationConfigApplicationContext

3)、refresh(context);刷新刚才创建好的ioc容器;

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

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容器


使用外置的Servlet容器

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

  • 优点:简单、便携;

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

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

步骤

1)、必须创建一个war项目;(利用idea创建好目录结构)

2)、将嵌入式的Tomcat指定为provided;

<dependency>
   <groupId>org.springframework.bootgroupId>
   <artifactId>spring-boot-starter-tomcatartifactId>
   <scope>providedscope>
dependency>

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

public class ServletInitializer extends SpringBootServletInitializer {

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

}

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


Docker

1、简介

Docker是一个开源的应用容器引擎;是一个轻量级容器技术;

Docker支持将软件编译成一个镜像;然后在镜像中各种软件做好配置,将镜像发布出去,其他使用者可以直接使用这个镜像;

运行中的这个镜像称为容器,容器启动是非常快速的。

2、核心概念

docker主机(Host):安装了Docker程序的机器(Docker直接安装在操作系统之上);

docker客户端(Client):连接docker主机进行操作;

docker仓库(Registry):用来保存各种打包好的软件镜像;

docker镜像(Images):软件打包好的镜像;放在docker仓库中;

docker容器(Container):镜像启动后的实例称为一个容器;容器是独立运行的一个或一组应用


SpringBoot与数据访问


原生JDBC的使用

        <dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-jdbcartifactId>
		dependency>
		<dependency>
			<groupId>mysqlgroupId>
			<artifactId>mysql-connector-javaartifactId>
			<scope>runtimescope>
		dependency>
spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://116.62.46.122:3306/test?serverTimezone=GMT%2B8&useSSL=false
    driver-class-name: com.mysql.jdbc.Driver

效果:

默认数据源;

数据源的相关配置都在DataSourceProperties里面;

自动配置原理:

org.springframework.boot.autoconfigure.jdbc:

1、参考DataSourceConfiguration,根据配置创建数据源,默认使用Tomcat连接池;可以使用spring.datasource.type指定自定义的数据源类型;

2、SpringBoot默认可以支持;

org.apache.tomcat.jdbc.pool.DataSource、HikariDataSource、BasicDataSource、

3、自定义数据源类型

/**
 * Generic DataSource configuration.
 */
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(name = "spring.datasource.type")
static class Generic {

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

}

4、DataSourceInitializer:ApplicationListener

作用:

	1)、runSchemaScripts();运行建表语句;

	2)、runDataScripts();运行插入数据的sql语句;

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

schema-*.sql、data-*.sql
默认规则:schema.sql,schema-all.sql;
可以使用   
	schema:
      - classpath:department.sql
      指定位置

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


整合Druid数据源

  • 1、导入 Druid 依赖的jar包
        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>1.1.10version>
        dependency>
  • 2、配置相关的yml文件内容
spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://116.62.46.122:3306/test?serverTimezone=GMT%2B8&useSSL=false
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    #   数据源其他配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
    filters: stat,wall,slf4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
  • 3、配置Druid的配置文件,即可访问 Druid 的监控后台

配合拦截器的链接地址:http://localhost:8080/druid/

//导入druid数据源
@Configuration
public class DruidConfig {

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DruidDataSource druid(){
        return new DruidDataSource();
    }

    //配置Druid的监控
    // 1、配置一个管理后台的Servlet
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
        Map<String,String> initParam = new HashMap<>(8);

        //配置监控的参数,登录后台的账号密码(eg:用户名,密码等)
        initParam.put("loginUsername","admin");
        initParam.put("loginPassword","123456");
        //默认是允许全部
//        initParam.put("allow","localhost");
        initParam.put("allow","");

        servletRegistrationBean.setInitParameters(initParam);
        return servletRegistrationBean;
    }

    //2、注册一个web监控的过滤器
    @Bean
    public FilterRegistrationBean webStatFilter(){
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        Map<String,String> initParam = new HashMap<>(8);

        //不拦截那些应用
        initParam.put("exclusions","*.js,*.css,/druid/*");

        filterRegistrationBean.setInitParameters(initParam);
        filterRegistrationBean.setUrlPatterns(Arrays.asList("/*"));
        return filterRegistrationBean;
    }

整合 mybatis

基础章

  • 1、导入相关的场景启动器:改启动器为 mybatis 官方为配设 SpringBoot 做的
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            2.1.1
        
  • 2、注入 Druid 数据源(参考上一部分):
  • 3、编写相关的接口,加上 @Component 和 @Mapper
    • 插入时,若想获得主键,可增加配置
//@Component 注解可加可不加
@Component
@Mapper //指定这是一个操作数据库的mapper
public interface UserMapper {

    /**
     * 根据 id 查询用户
     * @param id 用户 id
     * @return 返回用户
     */
    @Select("select * from user where id=#{id}")
    public User getUserById(Integer id);

    /**
     * 根据 id 删除用户
     * @param id 用户 id
     * @return 返回影响行数
     */
    @Delete("delete from user where id=#{id}")
    public int deleteUserById(Integer id);

    /**
     * 插入用户
     * @param user 用户消息
     * @return 返回影响行数
     */
    @Options(useGeneratedKeys = true,keyProperty = "id")
    @Insert("insert into user(name,age) values(#{name},#{age})")
    public int insertUser(User user);

    /**
     * 根据用户 id 更新用户信息
     * @param user 用户信息
     * @return 返回值
     */
    @Update("update user set name = #{name} , age=#{age} where id=#{id}")
    public int updateUser(User user);

}

配置章

以配置类方式配置
  • 若数据库采用蛇形命名法,而实体类用驼峰命名法,则需要更改映射规则,可以采用添加配置类形式
@Configuration
public class MyBatisConfig {

    @Bean
    public ConfigurationCustomizer configurationCustomizer(){
        return new ConfigurationCustomizer() {
            @Override
            public void customize(org.apache.ibatis.session.Configuration configuration) {
                configuration.setMapUnderscoreToCamelCase(true);
            }
        };
    }
}
  • 若一个一个类扫描太过麻烦,可在主配置类上添加配置注解 @MapperScan 来指定扫描哪个包下接口,然后改包下接口就可不加 @Mapper。( @MapperScan(“com.spring.mapper”))
@MapperScan(value = "com.springboot.mapper")
@SpringBootApplication
public class SpringBootDataMybatisApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDataMybatisApplication.class, args);
    }
}
以配置文件方式配置
  • 1、编写一个主配置文件,资料在GitHub 的 MyBatis页面查找



    
        
    


  • 2、编写每个接口的映射,资料在GitHub 的 MyBatis页面查找



    
    
        insert into role(role_name,role_introduction) values(#{roleName},#{roleIntroduction})
    


  • 3、在 application.yml 中添加 mybatis 配置文件的路径
mybatis:
  config-location: classpath:mybatis/mybatis-config.xml #指定主配置类
  mapper-locations: classpath:mybatis/mapper/*.xml #指定相关映射文件位置

整合 SpringBoot 的 JPA

  • JPA也是 ORM 思想(object、relational、mapping)
  • 1、导入场景启动器(创建项目时可添加),编写数据源
        
            org.springframework.boot
            spring-boot-starter-data-jpa
        
  • 2、编写一个实体类,添加注解表示这是一个与表格对应的实体类
//使用JPA注解配置映射关系
@Entity  //告诉JPA这是一个实体类
@Table(name = "user") //表示表名为user,没有标注默认是实体类名的小写
public class User {
    @Id //标志这是一个主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) //表示这是一个自增主键
    private Integer id;
    @Column(name = "name",length = 50) // 和表的一列对应,长度为50
    private String name;
    @Column // 不加默认列名为属性名
    private Integer age;
    
}
  • 3、编写一个基本的操作接口(继承JpaRepository,不需要重写它的方法,泛型第一个表示对应的表格实体类,第二个表示主键类型)以及编写基本的配置(更新数据库和显示 sql 语句)
// 继承JpaRepository来实现对数据库的操作
public interface UserRepository extends JpaRepository {
}

//

spring:
  jpa:
    hibernate:
      ddl-auto: update # 表示如果更新或者创建表格时更新结构
    show-sql: true #表示输出sql语句
  • 4、编写 Controller ,使用 UserRepository 来实现基本增删查改(类似Hibernate)
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    UserRepository userRepository;
    
    @GetMapping("/getUserById/{id}")
    public User getUserById(@PathVariable("id") Integer id){
        return userRepository.findById(id).get();
    }
    
    @GetMapping("/insertUser")
    public User insertUser(User user){
        return userRepository.save(user);
    }
}

SpringBoot启动原理以及监听


SpringBoot 的 Application启动原理

几个重要的事件回调机制

配置在META-INF/spring.factories

ApplicationContextInitializer

SpringApplicationRunListener

只需要放在ioc容器中

ApplicationRunner

CommandLineRunner

启动流程:

1、创建SpringApplication对象

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

2、运行run方法

public ConfigurableApplicationContext run(String... args) {
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   ConfigurableApplicationContext context = null;
   FailureAnalyzers analyzers = null;
   configureHeadlessProperty();
    
   //获取SpringApplicationRunListeners;从类路径下META-INF/spring.factories
   SpringApplicationRunListeners listeners = getRunListeners(args);
    //回调所有的获取SpringApplicationRunListener.starting()方法
   listeners.starting();
   try {
       //封装命令行参数
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(
            args);
      //准备环境
      ConfigurableEnvironment environment = prepareEnvironment(listeners,
            applicationArguments);
       		//创建环境完成后回调SpringApplicationRunListener.environmentPrepared();表示环境准备完成
       
      Banner printedBanner = printBanner(environment);
       
       //创建ApplicationContext;决定创建web的ioc还是普通的ioc
      context = createApplicationContext();
       
      analyzers = new FailureAnalyzers(context);
       //准备上下文环境;将environment保存到ioc中;而且applyInitializers();
       //applyInitializers():回调之前保存的所有的ApplicationContextInitializer的initialize方法
       //回调所有的SpringApplicationRunListener的contextPrepared();
       //
      prepareContext(context, environment, listeners, applicationArguments,
            printedBanner);
       //prepareContext运行完成以后回调所有的SpringApplicationRunListener的contextLoaded();
       
       //s刷新容器;ioc容器初始化(如果是web应用还会创建嵌入式的Tomcat);Spring注解版
       //扫描,创建,加载所有组件的地方;(配置类,组件,自动配置)
      refreshContext(context);
       //从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
       //ApplicationRunner先回调,CommandLineRunner再回调
      afterRefresh(context, applicationArguments);
       //所有的SpringApplicationRunListener回调finished方法
      listeners.finished(context, null);
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass)
               .logStarted(getApplicationLog(), stopWatch);
      }
       //整个SpringBoot应用启动完成以后返回启动的ioc容器;
      return context;
   }
   catch (Throwable ex) {
      handleRunFailure(context, listeners, analyzers, ex);
      throw new IllegalStateException(ex);
   }
}

SpringBoot事件监听

  • 1、实现以下方法
    • ApplicationContextInitializer
    • SpringApplicationRunListener
    • ApplicationRunner
    • CommandLineRunner
public class HelloApplicationContextInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializer...initialize..."+applicationContext);
    }
}
///
public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {

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

    }

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

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

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

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

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

}
///
@Component
public class HelloApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("ApplicationRunner...run....");
    }
}
//
@Component
public class HelloCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
    }
}
  • 2、在resource目录下创建META-INF然后创建spring.factories文件,在其中指定ApplicationContextInitializerSpringApplicationRunListener的全类名
org.springframework.context.ApplicationContextInitializer=\
com.springboot.listener.HelloApplicationContextInitializer

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

自定义场景启动器

starter:
1、这个场景需要使用到的依赖是什么?

2、如何编写自动配置
@Configuration  //指定这个类是一个配置类
@ConditionalOnXXX  //在指定条件成立的情况下自动配置类生效
@AutoConfigureAfter  //指定自动配置类的顺序
@Bean  //给容器中添加组件
@ConfigurationPropertie//结合相关xxxProperties类来绑定相关的配置
@EnableConfigurationProperties //让xxxProperties生效加入到容器中

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

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

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

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

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

步骤:

1)、启动器模块


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0modelVersion>
	<parent>
		<groupId>org.springframework.bootgroupId>
		<artifactId>spring-boot-starter-parentartifactId>
		<version>2.2.2.RELEASEversion>
		<relativePath/> 
	parent>
	<groupId>com.examplegroupId>
	<artifactId>test-spring-boot-autoconfigurerartifactId>
	<version>0.0.1-SNAPSHOTversion>
	<name>test-spring-boot-autoconfigurername>
	<description>Demo project for Spring Bootdescription>

	<properties>
		<java.version>1.8java.version>
	properties>

	<dependencies>
		
		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starterartifactId>
		dependency>

	dependencies>

project>
package com.springboot.starter;

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

/**
 * @author Ming
 * @date 2020/1/17 - 15:03
 */
@Component
@ConfigurationProperties(prefix = "springboot.hello")
public class HelloProperties {

    private String prefix;
    private String suffix;

    public String getPrefix() {
        return prefix;
    }

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

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }
}
package com.springboot.starter;

import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author Ming
 * @date 2020/1/17 - 15:02
 */
public class HelloService {

    HelloProperties helloProperties;

    public HelloProperties getHelloProperties() {
        return helloProperties;
    }

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

    public String sayHello(String name){
        return helloProperties.getPrefix() + "-" + name + ": 这个是测试的语句" + helloProperties.getSuffix();
    }

}
package com.springboot.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;

/**
 * @author Ming
 * @date 2020/1/17 - 15:08
 */
@Configuration
@ConditionalOnWebApplication  //web应用才生效
@EnableConfigurationProperties(HelloProperties.class)
public class HelloServiceAutoConfiguration {

    @Autowired
    HelloProperties helloProperties;

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

}

2)在将两个模块添加导 Maven 仓库中
3)在其他工程的使用

  • 在其他工程需要使用需要将场景启动器添加到依赖
        
            com.example
            test-spring-boot-starter
            1.0-SNAPSHOT
        
  • 可在 application.properties 文件中配置相关的属性值
springboot.hello.prefix=HEAD HELLO
springboot.hello.suffix=HELLO WORLD

  • 然后在类里面即可直接注入
package com.springboot.controller;

import com.springboot.starter.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Ming
 * @date 2020/1/17 - 15:20
 */
@RestController
@RequestMapping("/hello")
public class HelloController {

    @Autowired
    HelloService helloService;

    @GetMapping("sayHello")
    public String sayHello(){
        return helloService.sayHello("haha");
    }

}

你可能感兴趣的:(SpringBoot,java)