springboot 基础

高级

一、Spring-Boot

前言：SpringBoot 是什么

​ SpringBoot为什么

​ SpringBoot怎么用

简化Spring应用开发的一个框架；

整个Spring技术栈的一个大整合；

J2EE开发的一站式解决方案；

1.所需工具

小技巧pom.xml文件右键–>Diagrams—->show Dependecies

Maven 3.6.1 + jdk1.8 + idea2019

2.annotation head

2.1**@SpringBootApplication**

​ 标注的类是主程序类

将主类（标注了**@SpringBootApplication**）的所有的下面的包里面的所有组件扫描到Spring容器中。

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

pom.xml profile 请参照springboot quick 官网 快速入门

@SpringBootApplication下的
@Import({AutoConfigurationImportSelector.class})

会自动导入所对应的扫描的配置文件，不许要我们自己 操作。

    
	org.springframework.boot    
	 spring-boot-starter-parent  
   2.2.5.RELEASE   
    

spring-boot-starter-parent 是个SpringBoot 的一个父类。

spring-boot-starter下有很多对应的模块，

3. springBoot配置文件

application.yml and application.properties file

3.1 application.yml

在resource 文件下 文件名固定 特别注意空格缩进

application.yml file里面
server:  
	port: 8081

@Component
@ConfigurationProperties(prefix="person")
public class Person { ... }
public class Dog { ... }

person:
    name: zhangsan
    age: 19
    boss: false
    time: 2019/12/12
    lists:
      - zhangsan
      - lisi
      - wangwu
    maps: {k1: v1,k2: 19}
    dog:
      name: 小贝
      age: 8

@SpringBootTest 测试文件

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    private Person person;
    @Test
    void contextLoads() {
        System.out.println(person);
    }
}

3.2 application.properties

两个 写法一样；

spring.http.encoding.enabled=true

person.age=19
person.name=张三
person.boss=false
person.lists={a,b,c}
person.maps.k1=v1
person.maps.k2=v2
person.time=2016/1/7
person.dog.name=rose
person.dog.age=18

3.3 @value

1 @Value获取和@ConfigurationProperties获取值比较

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

配置文件yml还是propertes都能取得到值；

如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某一项值，使用@Value；

如果说，我们专门编写了一个javaBean来和配置文件进行映射，我们就直接用@ConfigurationPropertes；

@RestController
public class HelloController {

    @Value("${person.name}")
    private String name;

    @RequestMapping("/hello")
    public String hello(){
        return "Hello World quick!"+name;
    }
}

使用 @value 可以直接获取到配置文件中的值

4.注解专栏

这几个前文有介绍

@SpringBootApplication

@ConfigurationProperties

@Value

4.1 @RestController

等于@ResponseBody + Controller

把类下面所有的方法返回值取消转发页面，以字符串类型返回。

4.2 @PropertySource

@PropertySource(value = "classpath:person.properties")
@Component
@ConfigurationProperties(prefix="person")
public class Person { ... }

把指定配置文件引入到作用域

4.3 @ImprotResource

导入spring的配置文件，让其生效 写在主类上

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

4.3.1@Configuration

指名当前类是配置类，来代替Bean

springboot 推荐的方式是 @Bean的方式 给容器中添加组件 方便管理 以方法的形式注入

4.3.1.1 @Bean

以方法的形式装配bean

@Configuration
public class MyAppconfig {
    @Bean  //方法名就是以bean类型装配的id名
    public HelloService helloService(){
        System.out.println("连带配置方法！");
        return new HelloService();
    }
}

测试类

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    ApplicationContext ioc;
    @Test
    void test2(){
        boolean helloService = ioc.containsBean("helloService");
        System.out.println(helloService);
    }

5. 占位符用法

5.1随机数

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

5.2 占位符默认值

spring.http.encoding.enabled=true
#在后面加随机的uuid数
person.age=张三${random.uuid}
person.name=张三
person.boss=false
person.lists={a,b,c}
person.maps.k1=v1
person.maps.k2=v2
person.time=2016/1/7
#在属性里面找person.hello,没有就选用hello_dog
person.dog.name=${person.hello:hello}_dog
person.dog.age=18

6. Profile

6.1 多Profile文件

我们自己编写配置文件时，文件名可以是 application-{profile}.properties/yml

默认是properties 的配置：

指定激活

application-dev.properties
server.port=8083

application.properties
spring.http.encoding.enabled=true
server.port=8081
spring.profiles.active=dev
#最后配置成为8083

6.2 yml 文件的激活代码段

server:
  port: 8081

spring:
  profiles: pen
---
server:
  port: 8088

spring:
  profiles: dev
---
server:
  port: 8018

spring:
  profiles:
    active: dev

下面写的激活哪个段，就是哪个端口

6.3 激活指定Profile

1. 命令行：

java -jar testMaven1-1.0-SNAPSHOT.jar –spring.profile.active=dev

可以直接在测试的时候，配置传入命令行参数

2. 虚拟机参数

   -Dspring.profile.active=dev

7. 配置文件加载位置优先级

spring boot 启动会扫描一下位置的的application.properties或者.yml 文件作为

Spring boot 的默认配置文件

--file :./config/
–-file:./  
–-classpath:/config/
--classpath:/
顺利执行成功

以上优先级优高到低，所有位置的文件都会被加载，高优先级配置内容会覆盖

低优先级的配置内容

我们也可以通过spring.config.location来改变默认配置

#修改默认访问路径
server.servlet.context-path=/boot02

可以直接从命令行指定配置文件，形成一种互补 命令行参数都是 –

#spring.config.localion=C:/Users/thisissirz/Desktop/WeGame/application.properties

命令行指定参数是，能成功就都成功，不能成功就都不成功，不能形成互补

7.1 外部配置加载顺序

1. 命令行改配置

--server.port=8089

在同级目录下，不用指定文件，默认配置

2. jar包外向jar包内进行寻找：优先级加载带profile

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

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

3.再来加载不带profile

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

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

4.精髓

• SpringBoot启动大量的自动配置类

• 我们看我们需要的功能有没有SpringBoot默认的自动配置类

• 我们在来看这个配置类中到底配置了那些组件：（只要我们要用的配置类有，我们就不需要再来配置了）

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

  xxxAutoConfigurartion:自动配置类；

  给容器中添加组件

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

二、日志

Springboot 默认的日志文件 springBoot选用SLF4j和logback

1.使用SLF4j

开发的时候，日志记录方法的调用，不应该直接调用日志的实现类，而是调用日志抽象层里面的方法

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

public class HelloWorld{
   public static  void main(String[] args){
      Logger logger = LoggerFactory.getLogger(HelloWorld.class);
      logger.info("Hello World!");
   }
}
//Logger logger = Logger.getLogger(Test.class);
//logger.trace("");
//logger.info("");
//logger.debug("");
//logger.warn("");
//logger.error("");

详情图解

偷天换日，偷梁换柱，狸猫换太子猫

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

1.将系统中其他日志框架先排除出去；

2. 用中间包来替换原有的日志框架；
3. 我们导入slf4j其他的实现
4. 如果我们要引入其他框架，一定要先把这个框架默认的日志依赖移除掉
   springboot自动适配所有的日志，而且底层使用的是slf4j+logback的方式记录日志引入其他框架的时候，只需要把这个框架依赖的的日志框架排除掉

2.日志等级及写入文件

logging.level.com.whgc=trace
#日志等级
#是路径，不用写文件名字 ,写的默认是文件夹 使用spring.log 作为默认文件夹
logging.file.path=D:/springboot.log
#在控制台输出的日志的格式     
logging.pattern.console = %d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n

#日期输出格式
#		%d表示时间
#		%-Slevel：级别从左显示5个字符宽度
#		%logger{50} 表示logger名字最长50个字符，否则按照句点分割。
#		%msg ： 日志消息
#		%n 换行符

@SpringBootApplication
public class HelloApplication {

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

        Logger logger = LoggerFactory.getLogger(HelloApplication.class);
        //由低到高，springboot 默认的是info级别及以后的内容
        logger.trace("trace");
        logger.info("info");
        logger.debug("debug");
        logger.warn("warn");
        logger.error("error");
    }
}

logging.file.path	logging.level	Description
none(没有)	都输出	只在控制台输出
none	none	指定文件名
指定路径	none	输出日志到spring.log文件

3.指定配置

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

SpringBoot官网/log

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

dev—->开发环境-------------开发环境需要激活

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

logback-spring.xml :日志框架就不加载日志的配置项，有SpringBoot 解析日志配置，可以使用SpringBoot的高级Profile功能

三、web开发

使用SpringBoot;

1、创建SpringBoot应用，选中我们需要的模块；

2、SpringBoot已经默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以运行起来

3、自己编写业务代码

自动配置原理？

这个场景SpringBoot帮我们配置了什么？能不能修改？能修改哪些配置？能不能扩展？xxx

xxxAutoConfiguration:帮我们给容器中自动配置组件;
xxxProperties:配置类来封装配置文件的内容;

1. 导包(引入坐标)webjars

1. webjars : 以jar包的方式引入静态资源；

页面坐标前端资源引入

localhost:8080/webjars/jquery/3.3.0/jquery.js

"org.webjars" % "jquery" % "3.3.0"

资源映射

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));
                }

            }
        }

2. 所有/webjars/** ，

都会去 “classpath:/META-INF/resources/webjars/” 下面找

在访问的时候只需要写webjars下面资源的名称即可
<dependency>
      <groupId>org.webjarsgroupId>
      <artifactId>jqueryartifactId>
      <version>3.3.0version>
dependency>

3. /** 访问当前项目的任何资源，(静态资源的文件夹)

都会去下面几个找

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

localhost:8080/abc====去静态资源里面找的

http: //127.0.0.1:8080/webjars/bootstrap/4.3.1/css/bootstrap.min.css 如此访问

4. 欢迎页；静态资源文件夹下的所有index.html页面；被“/**”映射；localhost:8080/ 找index页面
5. 所有的**/favicon.ico 都是在静态资源文件下找；(定义图标，图标名要和 favicon.ico一样 )

2. 模板引擎

SpringBoot 内嵌的tomcat不支持jsp。

而我们用的是html 推荐使用模板引擎来整合

模板引擎：jsp 、Velocity、Freemarker、Thymeleaf

SpringBoot 推荐Thymeleaf ; 语法简单，功能强大

静态资源文件的访问路径会和 Controller 中的 url 有重叠的可能

例如：

	@GetMapping("/{path1}/{path2}")
    public String error(@PathVariable String path){
        return "/"+path1+"/"+path2;
    }

/css/me.css 会直接映射到 templates 下面去找 而不是 static 下面

1. Thymeleaf

如果要引入Thymeleaf的话，  
<dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-thymeleafartifactId>
dependency>
指定版本
<properties>
   <thymeleaf.version>3.0.9.RelEasethymeleaf.version>
   
   <thymeleaf-layout-dialect.version>2.2.2thymeleaf-layout-dialect.version>
properties>

2. 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";
只要我们把html页面放在classpath:/templates/里面，就可以直接访问了
  classpath = resource    自动添加前缀  和后缀

3. Thymeleaf用法

@Controller
public Class HelloController{
   
	 @RequestMapping("/success")
    public String success(Map<String,Object> map){
        map.put("hello","
你好！
");
        map.put("key", Arrays.asList("zhangsan","wangwu","zhaoliu"));
        return "success";
    }
}

<html lang="en" xmlns:th="http://www.thymeleaf.org">  有提示，类似于dtd xsd.. 配置信息
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h1>成功页面！h1>
<hr/>
   		取值[[${emps.getPageNum()}]]
<div th:text="${hello}" th:class="${hello}">div>
<div th:utext="${hello}">div>
<hr/>
  			循环遍历方式
<h3 th:each="ke:${key}" th:text="${ke}">h3>
<hr/>
<h1>
<span th:each="keys:${key}" th:text="${keys}">  span>
h1>
body>
html>

3. 扩展MVC

需要配置什么视图解析器只要在类中配置就行了，在这里面可以写拦截器，过滤器，视图解析器

1.编写一个类(@Configuration), 继承WebMvcConfigurationSupport类型 也可以实现WebMvcConfigurer接口；不能标注@EnableWebMvc

使用继承(WebMvcConfigurationSupport)就是全面接管的意思，导致html无法访问到css等静态资源

如果静态资源无法被html访问的话，实现addResourceHandlers方法就行了配置到静态路径下，默认实现(WebMvcConfigurer)不用实现也能访问.之前一直用的xxxxSupport所以一直无法访问静态资源

@Configuration
public class MyConfigur implements WebMvcConfigurer{
 /*   @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**").
                addResourceLocations("classpath:/static/");
    }*/
}

2. 如果要拦在Controller 里面拦就好了

3. @RequestMapping({"/index","/","/login"})
      public String index(){
          return "login";
      }
   

4. 容器中所有的WebMvcConfigurer都会一起起作用；

5. 我们的配置类也会被调用；

   效果：SpringMvc的自动配置和我们的扩展配置都会起作用；

1. 全面接管SpringMvc

SpringBoot对SpringMvc 所有Mvc部分自动配置全部失效，

添加==@EnableWebMvc==注解 或者继承WebMvcConfigurationSupport类

WebMvcConfigurationSupport是springMvc最基本的功能

@Configuration
public class MyConfigur  extends WebMvcConfigurationSupport {
   
    @Override
    protected void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/abc").setViewName("/success");
       //需要在控制器里写对应的接收方式
    }
}

4. 修改SpringBoot默认配置

模式：

1. SpringBoot在自动配置很多组件的时候，先看容器中有没有用户组件配置的（@Bean、@Compoent）如果有就用用户自己配置的，如果没有，才自动配置；如果有些组件可以有多个（ViewResolver）将用户自己配的和自己默认的组合起来；

2）、在SpringBoot中会有非常多的xxxConfigurer帮助我们进行自动配置比如WebMvcConfigurer等类或接口

3）、在SpringBoot中会有很多的xxxCustomizer帮助我们进行定制配置

5. 拦截器

拦截请求，比如：未登录就直接访问的内部页面。检查登录

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

@Configuration
public class MyConfigur implements WebMvcConfigurer{
    //注册拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/**")
            .excludePathPatterns("main.html","/","/dashboard","/login","/index","/");
    }//对未拦截的资源放行，静态资源SpringBoot已经帮我们做好了
}

6. RestfulCRUD

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

	普通crud	RestfulCRUD
查询	getEmp	emp—GET
添加	addEmp?xxx	emp—-POST
修改	updateEmp?id=xxx&xxx=xx	emp/{id}—PUT
删除	deleteEmp?id = 1	emp/{id}—DELETE

1. thymeleaf公共页面元素抽取

1. 抽取公共片段
 copy is 变量 name 
   ©
div>
2. 引入公共片段
<div th:insert="~{footer::copy}">  div>
~{templatename::selector}:模板名(需要引用哪个页面的名字)::选择器（变量名）
~{templatename::fragmentname}:模板名：：片段名
3. 默认效果
insert的功能片段在div标签中

有三种引入功能片段th属性

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

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

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

 copy is 变量 name 
   ©
div>
<div th:insert="~{footer::copy}">  div>
简写
<div th:insert="footer::copy">  div>

7. 各种请求注解

指定接收的请求，一般是见名知意

1. @GetMapping("/emp")	
   等价于@RequestMapping(value = "",method = RequestMethod.GET)
   

2. @PostMapping("/addemp")  
   等价于@RequestMapping(value = "",method = RequestMethod.POST)
   

3. @DeleteMapping("/delete{empid}")
   等价于@RequestMapping(value = "",method = RequestMethod.DELETE)
   

8. 定制错误页面

原理：

SpringBoot默认的错误处理机制

默认效果：

​ 1）、浏览器，返回一个默认的错误页面

​ 可以参照ErrorMvcAutoConfiguration ; 错误自动配置； 给容器中添加了以下组件

1. DefaultErrorAttributes : 帮我们在页面共享信息；
2. BasicErrorController : 处理默认/error请求
3. ErrorPageCustomizer : 系统出现错误以后来到error请求进行处理；（web.xml注册的错误页面规则）
4. DefaultErrorViewResolver : //模板引擎可以解析这个页面地址就用模板引擎解析 //模板引擎不可 用，就在静态资源文件夹下找errorViewName对应的页面 error/404.html

步骤：

​ 一但系统出现4xx或者5xx之类的错误；ErrorPageCustomizer就会生效（定制错误的响应规则）；就会来到/error请求；就会被BasicErrorController处理；

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

1）、如何定制错误的页面；

​ 1）、有模板引擎的情况下；error/状态码; 【将错误页面命名为 错误状态码.html 放在模板引擎文件夹里面的 error文件夹下】，发生此状态码的错误就会来到 对应的页面；

​ 我们可以使用4xx和5xx作为错误页面的文件名来匹配这种类型的所有错误，精确优先（优先寻找精确的状态码.html）；

​ 页面能获取的信息；

​ timestamp：时间戳

​ status：状态码

​ error：错误提示

​ exception：异常对象

​ message：异常消息

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

<h1>status:[[${status}]]h1>
<h2>timestamp:[[${timestamp}]]h2>

​ 2）、没有模板引擎（模板引擎找不到这个错误页面），静态资源文件夹下找；

​ 3）、以上都没有错误页面，就是默认来到SpringBoot默认的错误提示页面；

9. 定制Servlet容器

1. Servlet的相关配置

1、修改和server有关的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）；

server.port=8081
server.context-path=/crud
server.tomcat.uri-encoding=UTF-8
//通用的Servlet容器设置
server.xxx
//Tomcat的设置
server.tomcat.xxx

2、编写一个~~EmbeddedServletContainerCustomizer~~(现在已经废弃，用其他的代替了)：嵌入式的Servlet容器的定制器；来修改Servlet容器的配置,和上面的效果是一样的。

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

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

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

1. ServletRegistrationBean

@Bean//一定要写bean，注册到容器中
public ServletRegistrationBean myServlet(){
    ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");//MyServlet is myself class ,
    return registrationBean;
}
//ServletRegistrationBean is system self , myServlet write in the MyServerConfig.class
//MyServerConfig.class alike MyMvcConfig.class

2. FilterRegistrationBean

@Bean
public FilterRegistrationBean myFilter(){
    FilterRegistrationBean registrationBean = new FilterRegistrationBean();
    registrationBean.setFilter(new MyFilter());
    registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
    return registrationBean;
}

3. ServletListenerRegistrationBean

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

3. 使用外置的Servlet容器

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

​ 优点：简单、便携；

​ 缺点：默认不支持JSP、优化定制比较复杂（使用定制器【ServerProperties、自定义EmbeddedServletContainerCustomizer】，自己编写嵌入式Servlet容器的创建工厂【EmbeddedServletContainerFactory】）；

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

p46 步骤

1）、必须创建一个war项目；（利用idea创建好目录结构）

2）、将嵌入式的Tomcat指定为provided；

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

public class ServletInitializer extends SpringBootServletInitializer {

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

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

p51 原理 :

jar包：执行SpringBoot主类的main方法，启动ioc容器，创建嵌入式的Servlet容器；

war包：启动服务器，服务器启动SpringBoot应用【SpringBootServletInitializer】，启动ioc容器；

四、Docker

1、简介

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

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

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

2、核心概念

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

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

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

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

docker容器(Container) : 镜像启动后的实例称为一个容器；容器是独立运行的一个或一组应用。
使用Docker的步骤:
1 ）、安装Docker
2 ）、去Docker仓库找到这 个软件对应的镜像；
3 ）、使用Docker运行这 个镜像,这个镜像就会生成一个Docker容器；
4 ）、对于容器的启动停就是对软件的启动停止。

3、install Docker

1)、install Linux 虚拟机

2)、用远程操作软件连接

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

Centos 7 里面的命令
#1、检查内核版本，必须是3.10及以上
uname -r
#2、安装docker
yum install docker
#3、输入y确认安装
#4、 启动docker
systemctl start docker
#查看版本
docker -V
#5、开机启动docker
systemctl enable docker
#6、停止docker
systemctl stop docker

4、Docker常用命令

install images

#1. 搜索镜像文件
docker search [mysql]
#2. 拉取镜像文件  :tag是可选的，tag 表示标签，多为软件的版本号 默认是latest  进入官网查看tag
docker pull [mysql]:[tag]
#3. 查看本地所有镜像
docker images 
#4. 删除指定的本地镜像
docker rmi images-id
#5. 容器ip地址    连接数据库docker images mysql时会用到
docker inspect 容器名称（容器ID）

运行操作

打开指定端口，重启防火墙

#1.			自定义容器名				后台运行  指定镜像模板
docker run --name [container-name] -d [image-name]:[TAG]
eg:docker run --name myredis -d redis:latest
#2. 查看运行中的容器  add (-a) 是查看所有容器，即时是停止的
docker ps (-a)
#3. 停止
docker stop [container-name/container-id]
#4. 启动容器
docker start [container-name/container-id]
#5. 删除指定容器
docker rm [container-id]
#6. 端口映射 把容器端口映射到虚拟机端口
-p [虚拟机端口:容器端口]
eg: docker run -d -p 6379:6379 redis
#7. 容器日志
docker logs [container-name/container-id]

更多命令

5、docker 启动 mysql…

启动文档

正确start mysql

docker run -p 3306:3306 --name [some-mysql] -e MYSQL_ROOT_PASSWORD=[my-secret-pw] -d [mysql:tag]
#1. 如果您想更改所有表的默认编码和排序规则以使用UTF-8（utf8mb4）
docker run -p 3307:3306 --name [some-mysql] -e MYSQL_ROOT_PASSWORD=[my-secret-pw] -d mysql:[tag] --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

#2.重新启动刚刚停止的容器 有之前修改的数据
docker restart [containerID/names]

启动了没运行成功的容器会占用一个集装箱。记得即时清除

五、数据库连接/访问

1. mysql—jdbc

1)、Spring Initializr spring初始化器勾选jdbc或者后期导入坐标

默认坐标是新版mysql8.0以后的 查看当前全局时区和本次session时区：（mysql官方文档）

• UTC代表的是全球标准时间,后面插入数据有问题我再回来补听说是家里的时间和全国标准时间不同。

spring:
  datasource:
    username: root
    password: 1008611		#mysql对编码格式的要求以及时区确定
    url: jdbc:mysql://localhost:3306/stu?characterEncoding=UTF-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver

• 在DataSourceConfiguration 里面有很多默认连接数据库的可以选择的方式。

prefix = "spring.datasource.dbcp2"
prefix = "spring.datasource.hikari"  如果不指认默认是这个
prefix = "spring.datasource.tomcat"

• JdbcTemplate底层是SpringBoot自己配置的，可以直接使用

 @RestController
 public class HelloController {
     @Autowired
     JdbcTemplate jdbcTemplate;
     @GetMapping("/query")
     public Map<String,Object> query(){
         List<Map<String,Object>> list = jdbcTemplate.queryForList("select * from user");
         return list.get(0);
     }
 }

2、工作中常用的bruid数据源

仓库可以查看后台

• sql监控
• sql防火墙
• web应用
• 并发，请求次数
• 数据源…

    com.alibaba
    druid
    1.1.20

spring:
  datasource:
    username: root
    password: 1008611
    #这里要连接linux上的 docker 启动的mysql
    url: jdbc:mysql://localhost:3306/stu?characterEncoding=UTF-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    #alibaba内部的一些配置，一些数据源监控
    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 #log4j,stat,wall,建议去掉log4j,版本比较怪异
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

config file ,not write Controller,url is /druid

@Configuration
public class DataSources {

   @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid(){
        return new DruidDataSource();
    }
    //配置Druid的监控
    //1、配置一个管理后台的Servlet
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean bean = new ServletRegistrationBean(newStatViewServlet(), "/druid/*");
        Map<String,String> initParams = new HashMap<>();
        initParams.put("loginUsername","admin");
        initParams.put("loginPassword","123456");
        initParams.put("allow","");//默认就是允许所有访问
        initParams.put("deny","192.168.0.1");
        bean.setInitParameters(initParams);
        return bean;
    }
    //2、配置一个web监控的filter
    @Bean
    public FilterRegistrationBean webStatFilter(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());
        Map<String,String> initParams = new HashMap<>();
        initParams.put("exclusions","*.js,*.css,/druid/*");
        bean.setInitParameters(initParams);
        bean.setUrlPatterns(Arrays.asList("/*"));
        return  bean;
    }
}

3. Mybatis

1. 配置数据源相关属性，见上一小节
2. 建表，建javaBean

1）、MapperFile,注解版

不需要写XXXMapper.xml 和 Mybatis.xml

@Mapper//扫描该文件
public interface DepartmentMapper {
   
    @Select("select * from department where id=#{id}")
    public Department query(Integer id);
   
    @Delete("delete from department where id=#{id}")
    public int delete(Integer id);
   
    @Update("update department set departmentName=#{departmentName} where id=#{id}")
    public int update(Department department);
   
    @Options(useGeneratedKeys=true,keyProperty = "id")
    //标识主键，是不是获取自动增长的键值，主键是id
    @Insert("insert into department values(default,#{departmentName})")
    public int insert (Department department);
}//DepartmentMapper.java

2）、not annotation

非注解版 mybatis

//@Mapper 如果这里不加@mapper的话，就要在主配置类上加@MapperScan("com.whgc.zyxy.mapper")
//包扫描文件，扫描整个包
public interface EmployeeMapper {
    public Employee findEmp(Integer id);
    public void addEmp(Employee employee);
}
//EmployeeMapper.java

@MapperScan("com.whgc.zyxy.mapper")
@SpringBootApplication
public class Springbootmybatis01Application {

    public static void main(String[] args) throws SQLException {
        SpringApplication.run(Springbootmybatis01Application.class, args);

    }
}
//Springbootmybatis01Application.java

<mapper namespace="com.whgc.zyxy.mapper.EmployeeMapper">
    <insert id="addEmp" parameterType="com.whgc.zyxy.bean.Employee">
        INSERT INTO employee VALUES(default,#{lastName},#{email},#{gender},#{dId})
    insert>
    <select id="findEmp" resultType="com.whgc.zyxy.bean.Employee">
        SELECT * FROM employee WHERE id=#{id}
    select>
mapper>

<configuration>

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

spring:
  datasource:
    username: root
    password: 1008611
    url: jdbc:mysql://192.168.154.130:3306/Mybatis?characterEncoding=UTF-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    #alibaba内部的一些配置，一些数据源监控
    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 #log4j,stat,wall,建议去掉log4j,版本比较怪异
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

mybatis:
  config-location: classpath:mybatis/mybatis-config.xml #Scan mybatis.xml file
  mapper-locations: classpath:mybatis/mapper/*.xml #Scan mapper.xml file
# application.yml

4、整合JPA

1、引入spring-boot-starter-data-jpa
2、配置文件打印SQL语句
3、创建Entity标注JPA注解
4、创建Repository接[ I继承JpaRepository
5、测试方法

SpringData 简单介绍

1、SpringData为我们提供使用统一的API来对数据访问层进行操作;这主要是Spring DataCommons项目来实现的。Spring DataCommons让我们在使用关系型或者非关系型数据访问技术时都基于Spring提供的统一标准,标准包含了CRUD(创建、获取、更新、删除)、查询、排序和分页的相关操作。

2、SpringData统一的Repository接口

Repository : 统一接口

RevisionRepository> : 基于乐观锁机制
CrudRepository :基本CRUD操作
PagingAndSortingRepository :基本CRUD及分页
使用相应的功能只要写一个接口，继承就可以了

3、提供数据访问模板类xxTemplate ;

比如：MongoTemplate、redisTemplate…

4、使用SpringData可以简化访问数据的操作，springData都给我们做了相映的封装，以及制定了规范

1. 整合springdata jpa

<dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-jpaartifactId>
dependency>

2. 配置属性

spring:
  datasource:
    url: jdbc:mysql://192.168.154.130:3306/jpa?characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: 1008611
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      # 没有表的时候，更新或创建数据表
      ddl-auto: update

3. 使用entity

import javax.persistence.*;

@Entity //告诉jpa这是一个实体类，和表映射的类
@Table(name="tb1_user") //和哪个表对应，省略默认类名小写
@JsonIgnoreProperties(value={"hibernateLazyInitializer"}) 
//省略这个属性	hibernateLazyInitializer，默认生成的有这个属性
public class User implements Serializable {

    @Id //@id 标记主鍵
    @GeneratedValue(strategy = GenerationType.IDENTITY) //生产值策略，自增主键
    private Integer id;
    @Column(name="last_name") //字段名
    private String lastName;
    @Column //字段名为属性名
    private String email;
}

4. 编写一个Da0接口来操作实体类对应的数据表( Repository )

//																	实体类，主键类型
public interface UserRepository extends JpaRepository<User,Integer> {
    //不用加注解
}