第一片心意
第一片心意

springBoot2笔记

本文为B站尚硅谷 SpringBoot2 教学视频的笔记总结，连接：点我

1. Spring与SpringBoot

1.1. Spring能做什么

1.1.1. Spring生态

https://spring.io/projects/spring-boot

spring功能覆盖了：

web开发

数据访问

安全控制

分布式

消息服务

移动开发

批处理

…

1.1.2. Spring5重大升级

响应式编程

springBoot2笔记_第1张图片

内部源码设计

使用了 Java8 的一些新特性，如：接口默认实现。重新设计源码架构。

1.2. 为什么用SpringBoot

spring能够快速创建出生产级别的Spring应用。

  1. 优点

    1. 创建独立Spring应用。

    2. 内嵌web服务器。

    3. 自动starter依赖，简化构建配置。

    4. 自动配置Spring以及第三方功能。

    5. 提供生产级别的监控、健康检查及外部化配置。

    6. 无代码生成、无需编写XML。

      SpringBoot是整合Spring技术栈的一站式框架。

      SpringBoot是简化Spring技术栈的快速开发脚手架。

  2. SpringBoot缺点

    1. 人称版本帝，迭代快，需要时刻关注变化。

    2. 封装太深，内部原理复杂，不容易精通。

1.3. 时代背景

1.3.1. 微服务

微服务是一种架构风格。

一个应用可以拆分为一组小型服务。

每个服务运行在自己的进程内，可独立部署和升级。

服务之间使用轻量级HTTP交互。

服务围绕业务功能拆分。

可以利用全自动部署机制独立部署。

去中心化，服务自治。服务可以使用不同的语言、不同的存储技术。

1.3.2. 分布式

springBoot2笔记_第2张图片

分布式的困难：

远程调用

服务发现

负载均衡

服务容错

配置管理

服务监控

链路追踪

日志管理

任务调度

…

分布式的解决

SpringBoot + SpringCloud

springBoot2笔记_第3张图片

1.3.3. 云原生

原生应用如何上云。

上云的困难

服务自愈

弹性伸缩

服务隔离

自动化部署

灰度发布

流量治理

…

上云的解决

springBoot2笔记_第4张图片

2. SpringBoot2入门

2.1. 系统要求

Java 8 & 兼容java14

Maven 3.3+

IntelliJ IDEA 2019.1.2

2.1.1. Maven配置文件

在本地maven的 settings.xml 文件中对应位置添加以下内容：

<mirrors>
    <mirror>
        <id>nexus-aliyunid>
        <mirrorOf>centralmirrorOf>
        <name>Nexus aliyunname>
        <url>http://maven.aliyun.com/nexus/content/groups/publicurl>
    mirror>
mirrors>

<profiles>
    <profile>
        <id>jdk-1.8id>
        <activation>
            <activeByDefault>trueactiveByDefault>
            <jdk>1.8jdk>
        activation>
        <properties>
            <maven.compiler.source>1.8maven.compiler.source>
            <maven.compiler.target>1.8maven.compiler.target>
            <maven.compiler.compilerVersion>1.8maven.compiler.compilerVersion>
        properties>
    profile>
profiles>

2.2. HelloWorld项目

需求：浏览发送 /hello 请求，响应 “Hello，Spring Boot 2”

2.2.1. 创建maven工程

2.2.2. 引入依赖

在创建的项目的 pom 文件正确位置添加以下内容；

<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-parentartifactId>
    <version>2.3.4.RELEASEversion>
parent>

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

2.2.3. 创建主程序

以下是主程序代码：

@SpringBootApplication
public class MainApplication {

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

2.2.4. 编写业务

创建 controller 类，接受 /hello 请求并处理

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01() {
        return "Hello, Spring Boot 2!";
    }
}

2.2.5. 运行&测试

运行MainApplication类

浏览器输入http://localhost:8888/hello，将会输出Hello, Spring Boot 2!。

2.2.6. 配置参数

在 maven 工程的 resources 文件夹中创建application.properties文件，然后添加以下代码

# 3. 设置端口号
server.port=8888

更多配置信息

3.1. 打包部署

在pom.xml添加以下代码插件

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
        plugin>
    plugins>
build>

注意，对于 sprintBoot 官网提供的很多依赖和插件，都不需要手动指定版本号，在 springBoot 中都已经指定好了。

在IDEA的Maven插件上点击运行 clean 、package，把helloworld工程项目的打包成jar包，

打包好的jar包被生成在helloworld工程项目的target文件夹内。

用cmd运行java -jar boot-01-helloworld-1.0-SNAPSHOT.jar，既可以运行helloworld工程项目。

如果需要部署到服务器，只需要将jar包上传到服务器，然后直接在服务器执行即可。

4. 自动配置

4.1. SpringBoot特点

4.1.1. 依赖管理

springBoot 项目通过父项目做依赖管理。


<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-parentartifactId>
    <version>2.3.4.RELEASEversion>
parent>


<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-dependenciesartifactId>
    <version>2.3.4.RELEASEversion>
parent>

开发导入starter场景启动器，可实现以下功能：

  1. 可以通过引入的依赖看到很多 spring-boot-starter-\* ：其中 * 表示某种场景。

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

  3. 更多SpringBoot所有支持的场景

  4. *-spring-boot-starter：以这种方式命名的，是第三方为我们提供的简化开发的场景启动器。

  5. 所有场景启动器最底层的依赖

    <dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starterartifactId>
    <version>2.3.4.RELEASEversion>
    <scope>compilescope>
dependency>

无需关注版本号，自动版本仲裁：

  1. 引入依赖默认都可以不写版本号。

  2. 引入非版本仲裁的依赖，要写版本号。

可以修改默认版本号：

  1. 查看spring-boot-dependencies里面规定当前依赖的版本用的 key。

  2. 在当前项目里面重写配置，如下面的代码：

<properties>
    <mysql.version>5.1.43mysql.version>
properties>

4.1.2. 自动配置

  1. 自动配好Tomcat。

    1. 引入Tomcat依赖。

    2. 配置Tomcat。

      <dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-tomcatartifactId>
    <version>2.3.4.RELEASEversion>
dependency>

  2. 自动配好SpringMVC

    1. 引入SpringMVC全套组件

    2. 自动配好SpringMVC常用组件（功能）

  3. 自动配好Web常见功能，如：字符编码问题

    1. SpringBoot帮我们配置好了所有web开发的常见场景

  4. 默认的包结构

    1. 主程序所在包及其所有子包里面的组件都会被默认扫描

    2. 无需进行包扫描配置

    3. 如果想要改变扫描路径，可使用以下方式

      1. @SpringBootApplication (scanBasePackages=“com.atguigu”)

      2. @ComponentScan 指定扫描路径

        @SpringBootApplication

        等同于

        @SpringBootConfiguration

        @EnableAutoConfiguration

        @ComponentScan(“com.atguigu”)

  5. 各种配置拥有默认值

    1. 默认配置最终都是映射到某个类上，如：MultipartProperties

    2. 配置文件的值最终会绑定到对应的类上，这些类会在容器中创建对象

  6. 按需加载所有自动配置项

    1. 自己开发的项目中有非常多的starter

    2. 引入了哪个场景，这个场景的自动配置才会开启

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

4.2. 容器功能

4.2.1. 组件添加

4.2.1.1. @Component、@Controller、@Service、@Repository

它们是Spring的基本标签，在Spring Boot中并未改变它们原来的功能。

4.2.1.2. @Configuration

配置类，将该类中所有方法返回的对象注册到容器中。

/**
 * 1、配置类里面使用 @Bean 标注在方法上，表示将方法的返回值对象注册到容器中，默认单实例
 * 2、配置类本身也是组件，也会被注册到容器中。
 * 3、proxyBeanMethods：代理bean的方式
 *      Full(proxyBeanMethods = true)：保证每个标注有 @Bean 的方法返回的组件都为单实例，多次调用返回的都是同一个对象
 *      Lite(proxyBeanMethods = false)：每个标注有 @Bean 的方法，每次被调用，返回的组件都是新创建的
 *      组件依赖必须使用Full模式，默认，也就是该属性值为 true。
 */
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类
public class MyConfig {

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册到容器中的单实例对象
     */
    @Bean //给容器中添加组件，以方法名作为组件的id，返回值类型就是组件的类型，返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件，如果有组件依赖，则必须使用 full 模式，也就是设置 proxyBeanMethods 属性为 true。
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}


@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.atguigu.boot")
public class MainApplication {

    public static void main(String[] args) {
        //1、返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        //3、从容器中获取组件
        Pet tom01 = run.getBean("tom", Pet.class);
        Pet tom02 = run.getBean("tom", Pet.class);
        System.out.println("组件："+(tom01 == tom02));

        //4、com.atguigu.boot.config.MyConfig$$EnhancerBySpringCGLIB$$51f1e1ca@1654a892
        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        //如果@Configuration(proxyBeanMethods = true)，代理对象调用方法，SpringBoot总会检查容器中是否有这个组件。
        //保持组件单实例，如果设置 proxyBeanMethods 为 true ，则下面两次获取的都是同一个对象
        User user = bean.user01();
        User user1 = bean.user01();
        System.out.println(user == user1);

        User user01 = run.getBean("user01", User.class);
        Pet tom = run.getBean("tom", Pet.class);

        System.out.println("用户的宠物："+(user01.getPet() == tom));
    }
}

最佳实战

  • 配置类组件之间无依赖关系用Lite模式，可以加速容器启动过程，减少判断

  • 配置类组件之间有依赖关系，方法会被调用，以得到之前单实例组件，用Full模式

4.2.1.3. @Import

配合 @Configuration 注解使用

@Import({User.class, DBHelper.class})：给容器中自动创建出这两个类的组件,默认组件的名字就是全类名。

4.2.1.4. @Conditional

条件装配：满足Conditional指定的条件，则进行组件注入

springBoot2笔记_第5张图片

@ConditionalOnBean(name = "tom")  //容器中有名称为 tom 的组件时，才会给容器中注册 MyConfig 类的对象。
@ConditionalOnMissingBean(name = "tom")  //容器中没有名称为 tom 的组件时，才会给容器中注册 MyConfig 类的对象。
public class MyConfig {}

4.2.2. 原生配置文件引入

4.2.2.1. @ImportResource

导入原生配置文件

@ImportResource(\"classpath:beans.xml\")：导入Spring的配置文件，如果旧项目中使用
spring 的 xml 文件来管理组件，在 sprintBoot 中，可以通过该注解将之前的配置文件导入进来，无需将 xml 文件功能使用 java 代码重新实现一遍。

4.2.3. 配置绑定

使用Java读取properties文件中的内容，并且把它封装到JavaBean中，以供随时使用

传统方法：

public class GetProperties {
    public static void main(String[] args) throws FileNotFoundException, IOException {
        Properties pps = new Properties();
        pps.load(new FileInputStream("a.properties"));
        Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
        while (enum1.hasMoreElements()) {
            String strKey = (String) enum1.nextElement();
            String strValue = pps.getProperty(strKey);
            System.out.println(strKey + "=" + strValue);
            //封装到JavaBean。
        }
    }
}

4.2.3.1. @ConfigurationProperties + @Component

假设有配置文件application.properties，并有以下内容：

mycar.brand=BYD
mycar.price=100000

只有包含在容器中的组件，才会拥有SpringBoot提供的强大功能，因此需要将配置文件绑定到某个组件，并且将组件注册到容器中，可使用如下方式进行组件注册，以及将组件和配置文件绑定：

/**
 * ToString：生成 toString 方法
 * Data：生成 getter、setter 方法
 * Component：将该组件注册到容器中
 * ConfigurationProperties：表示该组件和配置文件中的值进行绑定。
 *      prefix：表示要绑定的配置文件中内容的 key 的前缀。
 */
@ToString
@Data
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
    private String brand;
    private Integer price;
}

4.2.3.2. @EnableConfigurationProperties + @ConfigurationProperties

/**
 * EnableConfigurationProperties：把这个Car这个组件自动注册到容器中，开启Car类和配置文件绑定功能
 */
@EnableConfigurationProperties(Car.class)
public class MyConfig {
    ...
}

/**
 * ConfigurationProperties：表示该组件和配置文件中的值进行绑定。 
 */
@ConfigurationProperties(prefix = "mycar")
public class Car {
    ...
}

推荐使用上面的方式进行组件和配置的绑定。

4.3. 自动配置

SpringBoot默认会在底层配好所有的组件，但是如果用户配置了自己的组件，则以用户的优先。

总结：

  • SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration

  • 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。（xxxxProperties里面读取，xxxProperties和配置文件进行了绑定）。

  • 生效的配置类就会给容器中装配很多组件

  • 只要容器中有这些组件，相当于这些功能就有了

  • 定制化配置

    • 用户直接自己@Bean替换底层的组件，@Bean注解添加到方法上，表示方法返回的值可以被注册到组件中。

    • 用户根据这个组件获取的是配置文件的什么值，然后就可以去修改对应的值。

      自动配置整体流程：xxxxxAutoConfiguration —> 组件 —>
      xxxxProperties里面拿值 ----> application.properties

4.3.1. 最佳实践

  • 引入场景依赖：官方文档

  • 查看自动配置了哪些（选做）

    • 自己分析，引入场景对应的自动配置一般都生效了

    • 配置文件中debug=true开启自动配置报告。Negative（不生效），Positive（生效）；

  • 是否需要修改

    • 参照文档修改配置项：官方文档

    • 自己分析，xxxxProperties绑定了配置文件的哪些值。

  • 自定义加入或者替换组件

    • @Bean、@Component…

  • 自定义器 XXXXXCustomizer；

4.4. 开发小技巧

4.4.1. Lombok

简化JavaBean开发

Lombok 使用注解方式代替构造器、getter/setter、toString()等冗余代码。

spring boot已经管理Lombok，只需在自己的项目中引入依赖：

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
dependency>

然后给IDEA安装插件：IDEA中File->Settings->Plugins，搜索安装Lombok插件。

@NoArgsConstructor
//@AllArgsConstructor
@Data
@ToString
@EqualsAndHashCode
public class User {

    private String name;
    private Integer age;

    private Pet pet;

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

@Slf4j
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(@RequestParam("name") String name){
        log.info("请求进来了....");
        return "Hello, Spring Boot 2!"+"你好："+name;
    }
}

4.4.2. Spring Initializer（项目初始化向导）

Spring Initializer是创建Spring Boot工程向导。

在IDEA中，菜单栏New -> Project -> Spring Initializer。

  1. 在创建项目时，选择需要使用到的场景

    springBoot2笔记_第6张图片

  2. 项目创建好之后，观察 pom 文件，就会发现，已经引入了我们上一步勾选到的所有场景用到的依赖

    springBoot2笔记_第7张图片

  3. 自动创建好了标准的目录结构

    springBoot2笔记_第8张图片

  4. 自动编写好主类

    springBoot2笔记_第9张图片

5. 配置文件

5.1. 文件类型

5.1.1. properties

同以前的properties用法

5.1.2. yaml

5.1.2.1. 简介

YAML 是 “YAML Ain’t Markup Language”（YAML 不是一种标记语言）的递归缩写。在开发这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种标记语言）。

非常适合用来做以数据为中心的配置文件。

5.1.2.2. 基本语法

  • key: value；kv之间有空格

  • 大小写敏感

  • 使用缩进表示层级关系

  • 缩进不允许使用tab，只允许使用空格

  • 缩进的空格数不重要，只要相同层级的元素左对齐即可

  • #表示注释

  • 字符串无需加引号，如果有一些特殊字符，则添加单引号'，单引号括起来的字符串中的所有字符，会保持原样不动。双引号""表示字符串内容会被转义，也就是说，如果字符串中出现了 \n ，则该字符最后会被转义为换行符进行展现。

5.1.2.3. 数据类型

  1. 字面量：单个的、不可再分的值。date、boolean、string、number、null

    k: v

  2. 对象：键值对的集合。map、hash、set、object

    #行内写法：
map1: { k1:v1,k2:v2,k3:v3 }
#或
map2:
  k1: v1
  k2: v2
  k3: v3

  3. 数组：array、list、queue

    #行内写法：  
k1: [ v1,v2,v3 ]
#或者
k2:
  - v1
  - v2
  - v3

5.1.2.4. 示例

@ConfigurationProperties(prefix = "person")
@Component
@ToString
@Data
public class Person {
    private String userName;
    private Boolean boss;
    private Date birth;
    private Integer age;
    private Pet pet;
    private String[] interests;
    private List<String> animal;
    private Map<String, Object> score;
    private Set<Double> salarys;
    private Map<String, List<Pet>> allPets;
}

@ToString
@Data
public class Pet {
    private String name;
    private Double weight;
}

yaml文件表示以上对象

person:
  #  单引号会将 \n 作为字符串输出   双引号会将 \n 作为换行输出
  boss: true
  birth: 2019/12/9
  age: 18
  #  interests: [篮球,足球]
  interests:
    - 篮球
    - 足球
  animal: [ 阿猫,阿狗 ]
  #  score:
  #    english: 80
  #    math: 90
  score: { english:80,math:90 }
  salarys:
    - 9999.98
    - 9999.99
  pet:
    name: 阿狗
    weight: 99.99
  allPets:
    sick:
      - { name: 阿狗,weight: 99.99 }
      - name: 阿猫
        weight: 88.88
      - name: 阿虫
        weight: 77.77
    health:
      - { name: 阿花,weight: 199.99 }
      - { name: 阿明,weight: 199.99 }
  # 如果出现了大写字母，除了和 bean 类属性完全保持一致外，也可以使用 -小写字母 来表示大写字母
  user-name: zhangsan

5.2. 配置提示

自定义的类和配置文件绑定一般没有提示，如果想要在配置文件中编写自定义类对应属性时出现提示，则可以在 pom 文件中添加以下依赖：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-configuration-processorartifactId>
    <optional>trueoptional>
dependency>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
            <configuration>
                
                <excludes>
                    <exclude>
                        <groupId>org.springframework.bootgroupId>
                        <artifactId>spring-boot-configuration-processorartifactId>
                    exclude>
                excludes>
            configuration>
        plugin>
    plugins>
build>

配置好之后，重新运行一下项目的启动类，之后在配置文件中编写配置类对应属性时，就会出现提示。

项目启动类只需要运行一次即可，无需一直运行。

6. Web开发

6.1. SpringMVC自动配置概览

  1. 大多场景我们都无需自定义配置

  2. 内容协商视图解析器和BeanName视图解析器

  3. 支持静态资源（包括webjars）

  4. 自动注册 Converter，GenericConverter，Formatter

  5. 支持 HttpMessageConverters ，对接收的 Http 请求内容进行各种自动转换

  6. 自动注册 MessageCodesResolver （国际化用）

  7. 静态 index.html 页支持，首页

  8. 支持自定义 Favicon

  9. 自动使用 ConfigurableWebBindingInitializer ，（DataBinder负责将请求数据绑定到JavaBean上）

  10. 不用@EnableWebMvc注解，使用 @Configuration + WebMvcConfigurer 自定义规则

  11. 声明 WebMvcRegistrations 改变默认底层组件

  12. 使用 @EnableWebMvc+@Configuration+DelegatingWebMvcConfiguration 全面接管SpringMVC

6.2. 简单功能分析

6.2.1. 静态资源访问

6.2.1.1. 静态资源目录

只要静态资源放在类路径下，比如：/static (或者是 /public 、 /resources 、/META-INF/resources)，就可以直接访问

访问方式：当前项目根路径 / + 静态资源名

原理：静态映射 /**。

请求进来之后，先去找Controller看能不能处理。不能处理的所有请求将会交给静态资源处理器，如果静态资源也找不到，则响应404页面。

改变默认的静态资源路径：

spring:
  mvc:
    # 表示访问静态资源时，需要在最前面添加 res 进行访问，以和其他的访问区分开。注意，如果配置了该参数，则默认的首页访问将会失效
    static-path-pattern: /res/**

  resources:
    # 表示访问的静态资源在 /haha 目录下，而不是默认的资源路径下。
    static-locations: [ classpath:/haha/ ]

6.2.1.2. 静态资源访问前缀

默认无前缀

spring:
  mvc:
    static-path-pattern: /res/**

当前项目 + static-path-pattern + 静态资源名 = 在静态资源文件夹下找

6.2.1.3. webjar

可用jar方式添加css，js等资源文件：https://www.webjars.org/，项目会自动映射
/webjars/**

例如，添加jquery：

<dependency>
    <groupId>org.webjarsgroupId>
    <artifactId>jqueryartifactId>
    <version>3.5.1version>
dependency>

访问地址为：http://localhost:8080/webjars/jquery/3.5.1/jquery.js，后面地址要按照依赖里面的包路径编写。

6.2.2. 欢迎页支持

静态资源路径下添加 index.html 文件。

  • 可以配置静态资源路径。

  • 但是不可以配置静态资源的访问前缀，否则会导致index.html不能被默认访问。

    spring:
  #  mvc:
  #    static-path-pattern: /res/**   这个会导致welcome page功能失效

  resources:
    static-locations: [ classpath:/haha/ ]

controller能自动处理 /index 请求。

6.2.3. 自定义Favicon

Favicon指网页标签上的小图标。

将favicon.ico 放在静态资源目录下即可。

spring:
# 7.  mvc:
# 8.    static-path-pattern: /res/**   这个会导致 Favicon 功能失效

8.1. 请求参数处理

8.1.1. 请求映射

8.1.1.1. rest使用与原理

  • @xxxMapping：@GetMapping、@PostMapping、@PutMapping、@DeleteMapping

  • Rest风格支持（使用HTTP请求方式动词来表示对资源的操作）

    • 以前：/getUser 获取用户、/deleteUser 删除用户、/editUser修改用户、/saveUser保存用户、

    • 现在： /user GET-获取用户、DELETE-删除用户、PUT-修改用户、POST-保存用户

  • 核心Filter；HiddenHttpMethodFilter

    • 用法：开启页面表单的Rest功能，页面 form的属性method=post，隐藏域 _method=put、delete等（如果直接get或post，无需隐藏域）

    • SpringBoot中手动开启 filter 支持

      spring:
  mvc:
    hiddenmethod:
      filter:
        enabled: true   #开启页面表单的Rest功能

  • 之后就可以在 controller 处理中使用了：

    @RequestMapping("/bug.jpg")
public String hello() {
    //request
    return "aaaa";
}

//    @RequestMapping(value = "/user",method = RequestMethod.GET)
@GetMapping("/user")
public String getUser() {

    return "GET-张三";
}

//    @RequestMapping(value = "/user",method = RequestMethod.POST)
@PostMapping("/user")
public String saveUser() {
    return "POST-张三";
}

//    @RequestMapping(value = "/user",method = RequestMethod.PUT)
@PutMapping("/user")
public String putUser() {
    return "PUT-张三";
}

@DeleteMapping("/user")
//    @RequestMapping(value = "/user",method = RequestMethod.DELETE)
public String deleteUser() {
    return "DELETE-张三";
}

  • 扩展：将表单中的 _method 这个名称换成其他的

    • 在配置类中添加以下代码，将自定义的 HiddenHttpMethodFilter 注册到容器中

      @Bean
public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
    HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();
    methodFilter.setMethodParam("_m");
    return methodFilter;
}

Rest原理（表单提交要使用REST的时候）

  • 表单提交会带上 _method=PUT

  • 请求过来后被HiddenHttpMethodFilter拦截

    • 请求是否正常，并且是POST

      • 获取到_method的值。

      • 兼容以下请求；PUT、DELETE、PATCH

      • 原生request（post），包装模式requesWrapper重写了getMethod方法，返回的是传入的值。

      • 过滤器链放行的时候使用wrapper，所以以后的方法调用getMethod时，调用的是 requesWrapper 实现的方法。

Rest使用客户端工具：如PostMan可直接发送put、delete等方式请求，无需
fliter。

8.1.2. 普通参数与基本注解

8.1.2.1. 注解

@PathVariable：从 rest 风格的请求路径中获取对应变量的值

@RequestHeader： 获取请求头

@RequestParam： 获取请求参数（问号后的参数，url?a=1&b=2）

@CookieValue： 获取Cookie值

@RequestAttribute： 获取request域属性

@RequestBody： 获取请求体[POST]

@MatrixVariable： 矩阵变量

示例：

@RestController
public class ParameterTestController {

    //  car/2/owner/zhangsan
    @GetMapping("/car/{id}/owner/{username}")
    public Map<String, Object> getCar(@PathVariable("id") Integer id,
                                      @PathVariable("username") String name,
                                      @PathVariable Map<String, String> pv,
                                      @RequestHeader("User-Agent") String userAgent,
                                      @RequestHeader Map<String, String> header,
                                      @RequestParam("age") Integer age,
                                      @RequestParam("inters") List<String> inters,
                                      @RequestParam Map<String, String> params,
                                      @CookieValue("_ga") String _ga,
                                      @CookieValue("_ga") Cookie cookie) {

        Map<String, Object> map = new HashMap<>();
        map.put("id", id);
        map.put("name", name);
        map.put("pv", pv);
        map.put("userAgent", userAgent);
        map.put("headers", header);
        map.put("age", age);
        map.put("inters", inters);
        map.put("params", params);
        map.put("_ga", _ga);
        System.out.println(cookie.getName() + "===>" + cookie.getValue());
        return map;
    }

    @PostMapping("/save")
    public Map postMethod(@RequestBody String content) {
        Map<String, Object> map = new HashMap<>();
        map.put("content", content);
        return map;
    }
}

RequestAttribute

用例：

@Controller
public class RequestController {

    @GetMapping("/goto")
    public String goToPage(HttpServletRequest request) {

        request.setAttribute("msg", "成功了...");
        request.setAttribute("code", 200);
        return "forward:/success";  // 转发到  /success请求
    }

    @GetMapping("/params")
    public String testParam(Map<String, Object> map,
                            Model model,
                            HttpServletRequest request,
                            HttpServletResponse response) {
        map.put("hello", "world666");
        // 通过 module 对象添加的属性值，通过转发之后，最后也会放到 request 对象中，之后也可以获取到
        model.addAttribute("world", "hello666");
        request.setAttribute("message", "HelloWorld");

        Cookie cookie = new Cookie("c1", "v1");
        response.addCookie(cookie);
        return "forward:/success";
    }

    @ResponseBody
    @GetMapping("/success")
    public Map success(@RequestAttribute(value = "msg", required = false) String msg,
                       @RequestAttribute(value = "code", required = false) Integer code,
                       HttpServletRequest request) {
        // 查看运行结果得知，通过 @RequestAttribute 注解获取请求对象属性值，和通过 request.getAttribute 方法获取的值，都是一样的。
        Object msg1 = request.getAttribute("msg");

        Map<String, Object> map = new HashMap<>();
        Object hello = request.getAttribute("hello");
        Object world = request.getAttribute("world");
        Object message = request.getAttribute("message");

        map.put("reqMethod_msg", msg1);
        map.put("annotation_msg", msg);
        map.put("hello", hello);
        map.put("world", world);
        map.put("message", message);

        return map;

    }
}

Map、Model（map、model里面的数据会被放在request的请求域
request.setAttribute）

@MatrixVariable与UrlPathHelper

语法： 请求路径：/cars/sell;low=34;brand=byd,audi,yd

SpringBoot默认禁用矩阵变量的功能

手动开启：将UrlPathHelper的removeSemicolonContent设置为false，让其支持矩阵变量。

矩阵变量必须有url路径变量才能被解析

手动开启矩阵变量：

  • 实现WebMvcConfigurer接口：

    @Configuration(proxyBeanMethods = false)
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        UrlPathHelper urlPathHelper = new UrlPathHelper();
        // 不移除 : 后面的内容，矩阵变量的功能就可以生效
        urlPathHelper.setRemoveSemicolonContent(false);
        configurer.setUrlPathHelper(urlPathHelper);
    }
}

  • 或者是在配置类中创建返回WebMvcConfigurerBean：

    @Configuration(proxyBeanMethods = false)
public class WebConfig {
    @Bean
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void configurePathMatch(PathMatchConfigurer configurer) {
                UrlPathHelper urlPathHelper = new UrlPathHelper();
                // 不移除 ; 后面的内容，矩阵变量功能就可以生效
                urlPathHelper.setRemoveSemicolonContent(false);
                configurer.setUrlPathHelper(urlPathHelper);
            }
        }
    }
}

@MatrixVariable使用案例

@RestController
public class ParameterTestController {

    // /cars/sell;low=34;brand=byd,audi,yd
    @GetMapping("/cars/{path}")
    public Map carsSell(@MatrixVariable("low") Integer low,
                        @MatrixVariable("brand") List<String> brand,
                        @PathVariable("path") String path) {
        Map<String, Object> map = new HashMap<>();

        map.put("low", low);
        map.put("brand", brand);
        map.put("path", path);
        return map;
    }

    // /boss/1;age=20/2;age=10
    @GetMapping("/boss/{bossId}/{empId}")
    public Map boss(@MatrixVariable(value = "age", pathVar = "bossId") Integer bossAge,
                    @MatrixVariable(value = "age", pathVar = "empId") Integer empAge) {
        Map<String, Object> map = new HashMap<>();

        map.put("bossAge", bossAge);
        map.put("empAge", empAge);
        return map;
    }
}

8.2. 数据响应与内容协商

8.2.1. HTTPMessageConverter原理

返回值处理器ReturnValueHandler原理：

返回值处理器判断是否支持这种类型返回值 supportsReturnType

返回值处理器调用 handleReturnValue 进行处理

RequestResponseBodyMethodProcessor 可以处理返回值标了 @ResponseBody
注解的。

利用 MessageConverters 进行处理，将数据写为json

内容协商（浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型）：

服务器最终根据自己自身的能力，决定服务器能生产出什么样内容类型的数据，

SpringMVC会挨个遍历所有容器底层的 HttpMessageConverter ，看谁能处理

得到MappingJackson2HttpMessageConverter可以将对象写为json

利用MappingJackson2HttpMessageConverter将对象转为json再写出去。

8.2.2. 内容协商

根据客户端接收能力不同，返回不同媒体类型的数据。

引入XML依赖：

<dependency>
    <groupId>com.fasterxml.jackson.dataformatgroupId>
    <artifactId>jackson-dataformat-xmlartifactId>
dependency>

Http协议中规定，Accept字段告诉服务器本客户端可以接收的数据类型：

spring:
  contentnegotiation:
    favor-parameter: true  #开启请求参数内容协商模式

发请求：http://localhost:8080/test/person?format=json

springBoot2笔记_第10张图片

http://localhost:8080/test/person?format=xml

springBoot2笔记_第11张图片

Http协议中规定，Accept字段告诉服务器本客户端可以接收的数据类型。

可用Postman软件分别测试返回json和xml：只需要改变请求头中Accept字段（application/json、application/xml）。

内容协商原理：

  1. 判断当前响应头中是否已经有确定的媒体类型MediaType。

  2. 获取客户端（PostMan、浏览器）支持接收的内容类型。（获取客户端Accept请求头字段application/xml）

    1. contentNegotiationManager 内容协商管理器，默认使用基于请求头的策略

    2. HeaderContentNegotiationStrategy 确定客户端可以接收的内容类型

  3. 遍历循环所有当前系统的 MessageConverter，看谁支持操作这个对象（Person）

  4. 找到支持操作Person的converter，把converter支持的媒体类型统计出来。

  5. 客户端需要application/xml，服务端有10种MediaType。

  6. 进行内容协商的最佳匹配媒体类型

  7. 查找到支持将对象转为最佳匹配媒体类型的converter，调用它进行转化。

导入了jackson处理xml的包，xml的converter就会自动进来

8.2.2.1. MessageConverter

实现多协议数据兼容：json、xml、x-guigu（这个是自创的）

  1. @ResponseBody 响应数据出去，调用 RequestResponseBodyMethodProcessor 处理

  2. Processor 处理方法返回值，通过 MessageConverter 处理

  3. 所有 MessageConverter 合起来可以支持各种媒体类型数据的操作（读、写）

  4. 内容协商找到最终的 messageConverter

SpringMVC 要实现什么功能，只需要在配置入口给容器中添加一个
WebMvcConfigurer 即可。

以下是代码示例：

@Data
public class Person {
    private String userName;
    private Integer age;
    private Date birth;
    private Pet pet;
}

/**
 * 自定义Converter
 */
public class GuiguMessageConverter implements HttpMessageConverter<Person> {

    @Override
    public boolean canRead(Class<?> clazz, MediaType mediaType) {
        return false;
    }

    @Override
    public boolean canWrite(Class<?> clazz, MediaType mediaType) {
        return clazz.isAssignableFrom(Person.class);
    }

    /**
     * 服务器要统计所有MessageConverter都能写出哪些内容类型
     * application/x-guigu
     *
     * @return
     */
    @Override
    public List<MediaType> getSupportedMediaTypes() {
        return MediaType.parseMediaTypes("application/x-guigu");
    }

    @Override
    public Person read(Class<? extends Person> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        return null;
    }

    @Override
    public void write(Person person, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        // 自定义协议数据的写出
        String data = person.getUserName() + ";" + person.getAge() + ";" + person.getBirth();
        // 写出去
        OutputStream body = outputMessage.getBody();
        body.write(data.getBytes());
    }
}

@Configuration(proxyBeanMethods = false)
public class WebConfig {
    @Bean
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
                converters.add(new GuiguMessageConverter());
            }
        };
    }
}

@Controller
public class ResponseTestController {

    /**
     * 1、浏览器发请求直接返回 xml    [application/xml]        jacksonXmlConverter
     * 2、如果是ajax请求 返回 json   [application/json]      jacksonJsonConverter
     * 3、如果硅谷app发请求，返回自定义协议数据  [appliaction/x-guigu]   xxxxConverter，返回值格式为：属性值1;属性值2;
     * 

     * 步骤：
     *   1、添加自定义的MessageConverter进系统底层
     *   2、系统底层就会统计出所有MessageConverter能操作哪些类型
     *   3、客户端内容协商 [guigu--->guigu]
     * 

     */
    @ResponseBody  // 利用返回值处理器里面的消息转换器进行处理
    @GetMapping(value = "/test/person")
    public Person getPerson() {
        Person person = new Person();
        person.setAge(28);
        person.setBirth(new Date());
        person.setUserName("zhangsan");
        return person;
    }

}

启动项目后，用Postman发送/test/person（请求头Accept:application/x-guigu)，将返回自定义协议数据的内容。

日后开发要注意，有可能我们添加的自定义的功能会覆盖默认很多功能，导致一些默认的功能失效。

8.3. 视图解析

视图解析：SpringBoot默认不支持
JSP，需要引入第三方模板引擎技术实现页面渲染。

springBoot2笔记_第12张图片

视图解析原理流程

  1. 目标方法处理的过程中，所有数据都会被放在 ModelAndViewContainer 里面。包括数据和视图地址

  2. 方法的参数是一个自定义类型对象（从请求参数中确定的），把他重新放在 ModelAndViewContainer

  3. 任何目标方法执行完成以后都会返回 ModelAndView（数据和视图地址）。

  4. processDispatchResult 处理派发结果（页面该如何响应）

    1. render(mv, request, response); 进行页面渲染逻辑

      1. 根据方法的String返回值得到 View 对象【定义了页面的渲染逻辑】

        1. 所有的视图解析器尝试是否能根据当前返回值得到View对象

        2. 得到了 redirect:/main.html --> Thymeleaf new RedirectView()

        3. ContentNegotiationViewResolver 里面包含了下面所有的视图解析器，内部还是利用下面所有视图解析器得到视图对象。

        4. view.render(mv.getModelInternal(), request, response);视图对象调用自定义的render进行页面渲染工作
          RedirectView 如何渲染【重定向到一个页面】

          1. 获取目标url地址
          2. response.sendRedirect(encodedURL);

视图解析：

  • 返回值以 forward: 开始： new InternalResourceView(forwardUrl); --> 转发 request.getRequestDispatcher(path).forward(request, response);

  • 返回值以 redirect: 开始： new RedirectView() --》 render就是重定向

  • 返回值是普通字符串： new ThymeleafView（）—>

8.4. 拦截器

登录检查与静态资源放行

8.4.1. 自定义拦截器

  1. 编写一个拦截器实现HandlerInterceptor接口。

  2. 然后将拦截器注册到容器中（实现WebMvcConfigurer的addInterceptors()）。

  3. 指定拦截规则（注意，如果是拦截所有，静态资源也会被拦截】。

编写一个实现HandlerInterceptor接口的拦截器：

/**
 * 登录检查
 *   1、配置好拦截器要拦截哪些请求
 *   2、把这个拦截器放在容器中
 */
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 目标方法执行之前
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String requestURI = request.getRequestURI();
        log.info("preHandle拦截的请求路径是{}", requestURI);

        // 登录检查逻辑
        HttpSession session = request.getSession();
        Object loginUser = session.getAttribute("loginUser");

        if (loginUser != null) {
            // 放行
            return true;
        }

        // 拦截未登录的页面访问，并且重定向或转发到首页
        request.setAttribute("msg", "请先登录");
        response.sendRedirect("/"); // 重定向
        request.getRequestDispatcher("/").forward(request, response);  // 转发
        return false;
    }

    /**
     * 目标方法执行完成以后
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("postHandle执行{}", modelAndView);
    }

    /**
     * 页面渲染以后
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("afterCompletion执行异常{}", ex);
    }
}

将拦截器注册到容器中并指定拦截规则：

/**
 * 1、编写一个拦截器实现HandlerInterceptor接口
 * 2、拦截器注册到容器中（实现WebMvcConfigurer的addInterceptors）
 * 3、指定拦截规则【如果是拦截所有，静态资源也会被拦截】，所以需要单独指定需要放行的静态资源
 */
@Configuration
public class AdminWebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**")  // 拦截的请求，所有请求都被拦截包括静态资源
                .excludePathPatterns("/", "/login", "/css/**", "/fonts/**", "/images/**", "/js/**"); // 放行的请求
    }
}

8.4.2. 拦截器执行时机和原理

  1. 根据当前请求，找到HandlerExecutionChain（可以处理请求的handler以及handler的所有拦截器）

  2. 先来顺序执行所有拦截器的 preHandle() 方法。

    1. 如果当前拦截器preHandle()返回为true，则执行下一个拦截器的preHandle()

    2. 如果当前拦截器返回为false，直接倒序执行所有已经执行了的拦截器的 afterCompletion()。

  3. 如果任何一个拦截器返回false，直接跳出不执行目标方法。

  4. 所有拦截器都返回true，才执行目标方法。

  5. 倒序执行所有拦截器的postHandle()方法。

  6. 前面的步骤有任何异常都会直接倒序触发 afterCompletion()。

  7. 页面成功渲染完成以后，也会倒序触发 afterCompletion()。

springBoot2笔记_第13张图片

8.5. 文件上传

8.5.1. 页面表单代码

页面代码/static/form/form_layouts.html

<form role="form" th:action="@{/upload}" method="post" enctype="multipart/form-data">

    <div class="form-group">
        <label for="exampleInputFile">头像label>
        <input type="file" name="headerImg" id="exampleInputFile">
    div>

    <div class="form-group">
        <label for="exampleInputFile">生活照label>
        <input type="file" name="photos" multiple>
    div>
    <button type="submit" class="btn btn-primary">提交button>
    
form>

第一个 div 是单文件，第二个 div 是多文件。

8.5.2. 控制层代码

/**
 * MultipartFile 自动封装上传过来的文件
 */
@PostMapping("/upload")
public String upload(@RequestParam("email") String email,
                     @RequestParam("username") String username,
                     // 单文件，需要使用 MultipartFile 类接收参数
                     @RequestPart("headerImg") MultipartFile headerImg,
                     // 多文件，需要使用 MultipartFile[] 数组来接收参数
                     @RequestPart("photos") MultipartFile[] photos) throws IOException {

    log.info("上传的信息：email={}，username={}，headerImg={}，photos={}",
            email,username,headerImg.getSize(),photos.length);

    if(!headerImg.isEmpty()){
        //保存到文件服务器，OSS服务器
        String originalFilename = headerImg.getOriginalFilename();
        headerImg.transferTo(new File("H:\\cache\\"+originalFilename));
    }

    if(photos.length > 0){
        for (MultipartFile photo : photos) {
            if(!photo.isEmpty()){
                String originalFilename = photo.getOriginalFilename();
                photo.transferTo(new File("H:\\cache\\"+originalFilename));
            }
        }
    }
}

注意：如果 controller 中的方法接收了文件参数，则不可再使用@RequestBody注解来将所有请求参数封装到 pojo 对象中接收，而只能使用@RequestParam注解来接收单个参数。

文件上传相关的配置类：

org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.MultipartProperties

文件大小相关配置项：

# 单文件大小
spring.servlet.multipart.max-file-size=10MB
# request请求大小
spring.servlet.multipart.max-request-size=100MB

10.1. 自动配置原理

文件上传自动配置类-MultipartAutoConfiguration-MultipartProperties，自动配置好了
StandardServletMultipartResolver 【文件上传解析器】

原理步骤：

  1. 请求进来使用文件上传解析器判断（isMultipart）并封装（resolveMultipart，返回MultipartHttpServletRequest）文件上传请求

  2. 参数解析器解析请求中的文件内容，并封装成MultipartFile

  3. 将request中文件信息封装为一个Map：MultiValueMap

可以使用FileCopyUtils工具类实现文件流的拷贝。

10.2. 异常处理

10.2.1. 错误处理

10.2.1.1. 默认规则

默认情况下，Spring Boot 会使用 /error 请求处理所有异常。

对于机器客户端（如PostMan），它将生成JSON响应，其中包含错误信息，HTTP状态和异常消息的详细信息。对于浏览器客户端，响应一个"
whitelabel"错误视图，以HTML格式呈现相同的数据。

{
    "timestamp":"2020-11-22T05:53:28.416+00:00", 
    "status":404, 
    "error": "Not Found",
    "message": "No message available", 
    "path": "/asadada"
}

springBoot2笔记_第14张图片

想要对其进行自定义，可以添加View并解析为error

要完全替换默认行为，可以实现
ErrorController 并注册该类型的Bean定义，或添加ErrorAttributes类型的组件以使用现有机制并替换其内容。

/error/ 目录下的4xx，5xx页面会被自动解析

springBoot2笔记_第15张图片

10.2.1.2. 自定义错误处理实现

有三种实现方式。

  1. @ControllerAdvice+@ExceptionHandler 处理全局异常
/**
 * 处理整个web controller的异常
 */
@Slf4j
@ControllerAdvice
public class GlobalExceptionHandler {

    /**
     * ExceptionHandler 注解中的参数为要处理的异常类型，将来所有的异常类型，符合要求的，都会由该方法处理
     */
    @ExceptionHandler({ArithmeticException.class, NullPointerException.class})
    public String handleArithException(Exception e) {
        log.error("异常是：{}", e);
        return "login"; // 视图地址
    }
}
  1. @ResponseStatus
/**
 * ResponseStatus注解，表示处理服务器内部异常，依据是请求的状态码，符合指定状态码编号的异常，将会由该类处理。
 */
@ResponseStatus(code = HttpStatus.FORBIDDEN, reason = "用户数量太多")
public class UserTooManyException extends RuntimeException {

    public UserTooManyException() {
    }

    public UserTooManyException(String message) {
        super(message);
    }
}
  1. 自定义实现 HandlerExceptionResolver 接口
@Order(value = Ordered.HIGHEST_PRECEDENCE)  // 优先级，数字越小优先级越高
@Component
public class CustomerHandlerExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest request,
                                         HttpServletResponse response,
                                         Object handler, Exception ex) {
        try {
            response.sendError(511, "我喜欢的错误");
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new ModelAndView();
    }
}

默认情况下，springBoot 会按照上面的优先级依次查找可以处理错误的处理器。

10.2.1.3. 自定义错误处理逻辑

  1. 自定义错误页 error/404.html、error/5xx.html，然后 sprintBoot 会进行匹配，匹配到精确错误状态码页面就匹配精确，没有就找
    4xx.html；如果都没有就触发白页。

  2. @ControllerAdvice+@ExceptionHandler 处理全局异常，底层是有 ExceptionHandlerExceptionResolver 支持的。

  3. @ResponseStatus+自定义异常 ，底层是 ResponseStatusExceptionResolver。 responseStatus注解底层调用
    response.sendError(statusCode, resolvedReason)，使用tomcat的
    /error 页面。

  4. Spring底层的异常，如参数类型转换异常，是由DefaultHandlerExceptionResolver处理的：response.sendError(HttpServletResponse.SC_BAD_REQUEST, ex.getMessage());

    springBoot2笔记_第16张图片

  5. 自定义实现 HandlerExceptionResolver 处理异常，可以作为默认的全局异常处理规则

    springBoot2笔记_第17张图片

  6. ErrorViewResolver 实现自定义异常处理：

    1. response.sendError ，error请求就会转给controller

    2. 如果你的异常没有任何人能处理，则 tomcat底层调用 response.sendError，将error请求转给controller

  7. basicErrorController 要去的页面地址是 ErrorViewResolver ；

10.3. Web原生组件注入

官方文档 - Servlets, Filters, and listeners

10.3.1. 使用原生的注解

@WebServlet(urlPatterns = "/my")
public class MyServlet extends HttpServlet {

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

@Slf4j
@WebFilter(urlPatterns = {"/css/*", "/images/*"}) // my
public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("MyFilter初始化完成");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        log.info("MyFilter工作");
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
        log.info("MyFilter销毁");
    }
}

@Slf4j
@WebListener
public class MyServletContextListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        log.info("MyServletContextListener监听到项目初始化完成");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        log.info("MyServletContextListener监听到项目销毁");
    }

}

最后还要在主启动类添加注解@ServletComponentScan注解

@ServletComponentScan(basePackages = "com.atguigu.admin")
@SpringBootApplication
public class Boot05WebAdminApplication {

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

}

10.3.2. Spring方式注入

ServletRegistrationBean, FilterRegistrationBean,
ServletListenerRegistrationBean

@Configuration
public class MyRegistrConfig {

    @Bean
    public ServletRegistrationBean myServlet(){
        MyServlet myServlet = new MyServlet();
        return new ServletRegistrationBean(myServlet,"/my","/my02");
    }


    @Bean
    public FilterRegistrationBean myFilter(){
        MyFilter myFilter = new MyFilter();
//        return new FilterRegistrationBean(myFilter,myServlet());
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(myFilter);
        filterRegistrationBean.setUrlPatterns(Arrays.asList("/my","/css/*"));
        return filterRegistrationBean;
    }

    @Bean
    public ServletListenerRegistrationBean myListener(){
        MyServletContextListener myServletContextListener = new MyServletContextListener();
        return new ServletListenerRegistrationBean(myServletContextListener);
    }
}

10.4. 嵌入式Servlet容器

Spring Boot默认使用Tomcat服务器，若需更改其他服务器，则修改工程pom.xml：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-tomcatartifactId>
        exclusion>
    exclusions>
dependency>

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

10.5. 定制化原理

10.5.1. 定制化的常见方式

  1. 修改配置文件

  2. xxxxxCustomizer

  3. 编写自定义的配置类 xxxConfiguration + @Bean 替换、增加容器中默认组件，视图解析器

  4. Web应用：编写一个配置类实现 WebMvcConfigurer 即可定制化 web功能 + @Bean 给容器中再扩展一些组件

    @Configuration
public class AdminWebConfig implements WebMvcConfigurer {
}

  5. @EnableWebMvc + WebMvcConfigurer — @Bean 可以全面接管SpringMVC，所有规则全部自己重新配置；实现定制和扩展功能（高级功能）。

原理：

  1. WebMvcAutoConfiguration：默认的SpringMVC自动配置功能类，如静态资源、欢迎页等。

  2. 一旦使用 @EnableWebMvc，就会@Import(DelegatingWebMvcConfiguration.class)。

  3. DelegatingWebMvcConfiguration的作用，只保证SpringMVC最基本的使用

    1. 把所有系统中的WebMvcConfigurer拿过来，所有功能的定制都是这些WebMvcConfigurer合起来一起生效。

    2. 自动配置了一些非常底层的组件，如RequestMappingHandlerMapping，这些组件依赖的组件都是从容器中获取，比如：public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport

  4. WebMvcAutoConfiguration里面的配置要能生效必须@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)。

  5. @EnableWebMvc 导致WebMvcAutoConfiguration 失效。

10.5.2. 原理分析套路

场景starter - xxxxAutoConfiguration - 导入xxx组件 - 绑定xxxProperties -
绑定配置文件项。

11. 数据访问

11.1. SQL

11.1.1. 数据源的自动配置-HikariDataSource

11.1.1.1. 导入JDBC场景

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

接着导入数据库驱动包（MySQL为例）。


<mysql.version>8.0.22mysql.version>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    
dependency>

<properties>
    <java.version>1.8java.version>
    <mysql.version>5.1.49mysql.version>
properties>

11.1.1.2. 分析自动配置

  1. DataSourceAutoConfiguration ： 数据源的自动配置。

  2. 修改数据源相关的配置：spring.datasource。

  3. 数据库连接池的配置：自己容器中没有DataSource才自动配置的。

  4. 底层配置好的连接池是：HikariDataSource。

    @Configuration(proxyBeanMethods = false)
@Conditional(PooledDataSourceCondition.class)
@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
@Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
      DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.OracleUcp.class,
      DataSourceConfiguration.Generic.class, DataSourceJmxConfiguration.class })
protected static class PooledDataSourceConfiguration

  5. DataSourceTransactionManagerAutoConfiguration：事务管理器的自动配置。

  6. JdbcTemplateAutoConfiguration：JdbcTemplate的自动配置，可以来对数据库进行CRUD。

    1. 可以修改前缀为spring.jdbc的配置项来修改JdbcTemplate。

    2. @Bean @Primary JdbcTemplate：Spring容器中有这个JdbcTemplate组件，使用@Autowired。

  7. JndiDataSourceAutoConfiguration：JNDI的自动配置。

  8. XADataSourceAutoConfiguration：分布式事务相关的。

11.1.1.3. 修改配置项

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db_account
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

11.1.1.4. 单元测试数据源

@Slf4j
@SpringBootTest(classes = {JdbcTemplate.class})
class Boot05WebAdminApplicationTests {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Test
// 用@org.junit.Test会报空指针异常，可能跟JUnit新版本有关
    void contextLoads() {
        Long aLong = jdbcTemplate.queryForObject("select count(*) from account_tbl", Long.class);
        log.info("记录总数：{}", aLong);
    }

}

11.1.2. 使用Druid数据源

11.1.2.1. druid官方github地址

Druid官网

Druid是数据库连接池，能够提供强大的监控和扩展功能。

官方文档 - Druid连接池介绍

Spring Boot整合第三方技术的两种方式：

  1. 自定义

  2. 找starter场景

11.1.2.2. 自定义方式

  1. 添加依赖

    <dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.1.17version>
dependency>

  2. 配置Druid数据源

    @Configuration
public class MyDataSourceConfig {

    // 默认的自动配置是判断容器中没有才会配：@ConditionalOnMissingBean(DataSource.class)，因此这儿手动注册了组件，自动配置就会失效
    @ConfigurationProperties("spring.datasource")
    @Bean
    public DataSource dataSource() throws SQLException {
        DruidDataSource druidDataSource = new DruidDataSource();

        // 加入监控功能
        druidDataSource.setFilters("stat,wall");
        druidDataSource.setMaxActive(10);
        return druidDataSource;
    }

}

  3. 更多配置项

    1. 配置Druid的监控页功能：

    2. Druid内置提供了一个StatViewServlet用于展示Druid的统计信息。官方文档 - 配置_StatViewServlet配置。这个StatViewServlet的用途包括：

      1. 提供监控信息展示的html页面

      2. 提供监控信息的JSON API

      3. Druid内置提供一个StatFilter，用于统计监控信息。官方文档 - 配置_StatFilter

      4. WebStatFilter用于采集web-jdbc关联监控的数据，如SQL监控、URI监控。官方文档 - 配置_配置WebStatFilter

      5. Druid提供了WallFilter，它是基于SQL语义分析来实现防御SQL注入攻击的。官方文档 - 配置 wallfilter

11.1.2.3. starter整合方式

  1. 引入依赖

    <dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druid-spring-boot-starterartifactId>
    <version>1.1.17version>
dependency>

  2. 配置示例：

    spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db_account
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

    druid:
      aop-patterns: com.atguigu.admin.*  #监控SpringBean
      filters: stat,wall     # 底层开启功能，stat（sql监控），wall（防火墙）

      stat-view-servlet: # 配置监控页功能
        enabled: true
        login-username: admin
        login-password: admin
        resetEnable: false

      web-stat-filter: # 监控web
        enabled: true
        urlPattern: /*
        exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'


      filter:
        stat: # 对上面filters里面的stat的详细配置
          slow-sql-millis: 1000
          logSlowSql: true
          enabled: true
        wall:
          enabled: true
          config:
            drop-table-allow: false

分析自动配置

扩展配置项 spring.datasource.druid

DruidSpringAopConfiguration.class,
监控SpringBean，配置项：spring.datasource.druid.aop-patterns

DruidStatViewServletConfiguration.class,
监控页的配置：spring.datasource.druid.stat-view-servlet，默认开启

DruidWebStatFilterConfiguration.class,
web监控配置：spring.datasource.druid.web-stat-filter，默认开启

DruidFilterConfiguration.class： 所有Druid自己filter的配置

private static final String FILTER_STAT_PREFIX = "spring.datasource.druid.filter.stat";
private static final String FILTER_CONFIG_PREFIX = "spring.datasource.druid.filter.config";
private static final String FILTER_ENCODING_PREFIX = "spring.datasource.druid.filter.encoding";
private static final String FILTER_SLF4J_PREFIX = "spring.datasource.druid.filter.slf4j";
private static final String FILTER_LOG4J_PREFIX = "spring.datasource.druid.filter.log4j";
private static final String FILTER_LOG4J2_PREFIX = "spring.datasource.druid.filter.log4j2";
private static final String FILTER_COMMONS_LOG_PREFIX = "spring.datasource.druid.filter.commons-log";
private static final String FILTER_WALL_PREFIX = "spring.datasource.druid.filter.wall";

SpringBoot配置示例：https://github.com/alibaba/druid/tree/master/druid-spring-boot-starter

配置项列表：https://github.com/alibaba/druid/wiki/DruidDataSource配置属性列表

11.1.3. 整合MyBatis操作

MyBatis的GitHub仓库

MyBatis官方

starter的命名方式：

  • SpringBoot官方的Starter：spring-boot-starter-*

  • 第三方的： *-spring-boot-starter

引入依赖：

<dependency>
    <groupId>org.mybatis.spring.bootgroupId>
    <artifactId>mybatis-spring-boot-starterartifactId>
    <version>2.1.4version>
dependency>

11.1.3.1. 配置模式

  • 项目全局配置文件

    • SqlSessionFactory：已经自动配置好了

    • SqlSession：自动配置了SqlSessionTemplate 组合了SqlSession

    • @Import(AutoConfiguredMapperScannerRegistrar.class)

  • @Mapper：只要我们写的操作MyBatis的接口标注了@Mapper就会被自动扫描进来

    // MyBatis配置项绑定类
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })
public class MybatisAutoConfiguration implements InitializingBean

    @ConfigurationProperties(prefix = MybatisProperties.MYBATIS_PREFIX)
public class MybatisProperties

    public static final String MYBATIS_PREFIX = "mybatis";

修改配置文件中所有的 mybatis 开头的：

spring:
  datasource:
    username: root
    password: 1234
    url: jdbc:mysql://localhost:3306/my
    driver-class-name: com.mysql.jdbc.Driver

# 12. 配置mybatis规则
mybatis:
  config-location: classpath:mybatis/mybatis-config.xml  #全局配置文件位置
  mapper-locations: classpath:mybatis/*.xml  #sql映射文件位置

Mapper接口对应配置文件：


DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lun.boot.mapper.UserMapper">
    <select id="getUser" resultType="com.lun.boot.bean.User">
        select * from user where id=#{id}
    select>
mapper>

Mapper 接口开发：

@Mapper
public interface UserMapper {
    public User getUser(Integer id);
}

POJO：

public class User {
    private Integer id;
    private String name;
    // getters and setters...
}

DB：

CREATE TABLE `user`
(
    `id`   int(11) NOT NULL AUTO_INCREMENT,
    `name` varchar(45) DEFAULT NULL,
    PRIMARY KEY (`id`)
) ENGINE = InnoDB
  AUTO_INCREMENT = 3
  DEFAULT CHARSET = utf8mb4;

Controller and Service：

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    @ResponseBody
    @GetMapping("/user/{id}")
    public User getUser(@PathVariable("id") Integer id) {

        return userService.getUser(id);
    }

}


@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getUser(Integer id) {
        return userMapper.getUser(id);
    }

}

配置private Configuration configuration;
也就是配置mybatis.configuration相关内容，就是相当于修改mybatis全局配置文件中的值。（也就是说配置了mybatis.configuration，就不需配置mybatis全局配置文件了）

# 13. 配置mybatis规则
mybatis:
  #  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml
  configuration:
    map-underscore-to-camel-case: true
  
# 14.  可以不写全局配置文件，所有全局配置文件的配置都放在configuration配置项中即可

小结

  1. 导入MyBatis官方Starter。

  2. 编写Mapper接口，需标注@Mapper注解。

  3. 编写SQL映射文件并绑定Mapper接口。

  4. 在application.yaml中指定Mapper配置文件的所处位置，以及指定全局配置文件的信息（建议：配置在mybatis.configuration下）。

14.1. 注解模式

Mapper接口：

@Mapper
public interface CityMapper {

    @Select("select * from city where id=#{id}")
    public City getById(Long id);

}

14.1.1. 混合模式

Mapper接口：

/**
 * 方法上有注解的，使用的是注解模式，方法上没有注解的，使用的是配置文件模式，需要在对应的配置文件中有对应的sql。
 */
@Mapper
public interface UserMapper {
    
    public User getUser(Integer id);

    @Select("select * from user where id=#{id}")
    public User getUser2(Integer id);

    public void saveUser(User user);

    @Insert("insert into user(`name`) values(#{name})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    public void saveUser2(User user);

}

Mapper文件：


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lun.boot.mapper.UserMapper">

    <select id="getUser" resultType="com.lun.boot.bean.User">
        select *
        from user
        where id = #{id}
    select>

    <insert id="saveUser" useGeneratedKeys="true" keyProperty="id">
        insert into user(`name`)
        values (#{name})
    insert>

mapper>

最佳实践：

  • 引入mybatis-starter

  • 配置application.yaml，指定mapper-location位置

  • 编写Mapper接口并标注@Mapper注解

    • 简单方法直接注解方式

    • 复杂方法编写mapper.xml进行绑定映射

  • 将@MapperScan(\"com.atguigu.admin.mapper\")注解写到主程序类上后，其他的接口就可以不用标注@Mapper注解了，不过不推荐这么做，可能会引起阅读困难。

    @MapperScan("com.lun.boot.mapper")
@SpringBootApplication
public class MainApplication {

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

}

14.1.2. 整合MyBatisPlus

14.1.2.1. 什么是MyBatis-Plus

IDEA的MyBatis的插件 - MyBatisX

MyBatisPlus官网

MyBatisPlus官方文档

MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis
的基础上只做增强不做改变，为简化开发、提高效率而生。

建议安装 MybatisX 插件

14.1.2.2. 整合步骤

添加依赖：

<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-boot-starterartifactId>
    <version>3.4.1version>
dependency>

自定配置原理：

  1. MybatisPlusAutoConfiguration为配置类，MybatisPlusProperties为配置项绑定。

  2. SqlSessionFactory会自动配置好，底层是容器中默认的数据源。

  3. mapperLocations会自动配置好，有默认值classpath:/mapper/**/*.xml，这表示任意包的类路径下的所有mapper文件夹下任意路径下的所有xml都是sql映射文件。建议将sql映射文件放在mapper目录下。

  4. 容器中也自动配置好了SqlSessionTemplate。

  5. @Mapper 标注的接口也会被自动扫描，建议直接使用@MapperScan(\"com.lun.boot.mapper\")批量扫描。

MyBatisPlus优点之一：只需要我们的Mapper继承MyBatisPlus的BaseMapper
接口就可以拥有CRUD能力，减轻开发工作。

/**
 * 泛型为要操作的表对应的 pojo 类
 */
public interface UserMapper extends BaseMapper<User> {
}

14.1.2.3. CRUD功能

官方文档 - CRUD接口

使用MyBatis Plus提供的IService，ServiceImpl，可以减轻Service层开发工作。

/**
 *  Service 的CRUD不用实现
 */
public interface UserService extends IService<User> {
}

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService {
}

添加分页插件：

@Configuration
public class MyBatisConfig {
    /**
     * MybatisPlusInterceptor，添加分页插件
     */
    @Bean
    public MybatisPlusInterceptor paginationInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        // paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        // paginationInterceptor.setLimit(500);
        // 开启 count 的 join 优化,只针对部分 left join

        //这是分页拦截器
        PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor();
        paginationInnerInterceptor.setOverflow(true);
        paginationInnerInterceptor.setMaxLimit(500L);
        mybatisPlusInterceptor.addInnerInterceptor(paginationInnerInterceptor);

        return mybatisPlusInterceptor;
    }
}

@GetMapping("/user/delete/{id}")
public String deleteUser(@PathVariable("id") Long id,
                         @RequestParam(value = "pn",defaultValue = "1")Integer pn,
                         RedirectAttributes ra){
// removeById就是 MyBatis 提供的方法
    userService.removeById(id);
    ra.addAttribute("pn",pn);
    return "redirect:/dynamic_table";
}

@GetMapping("/user/delete/{id}")
    public String deleteUser(@PathVariable("id") Long id,
                             @RequestParam(value = "pn", defaultValue = "1") Integer pn,
                             RedirectAttributes ra) {
        userService.removeById(id);
        ra.addAttribute("pn", pn);
        return "redirect:/dynamic_table";
    }


    @GetMapping("/dynamic_table")
    public String dynamic_table(@RequestParam(value = "pn", defaultValue = "1") Integer pn, Model model) {
        // 构造分页参数
        Page<User> page = new Page<>(pn, 2);
        // 调用page进行分页
        Page<User> userPage = userService.page(page, null);

        // userPage.getRecords()
        // userPage.getCurrent()
        // userPage.getPages()

        model.addAttribute("users", userPage);

        return "table/dynamic_table";
    }

14.2. NoSQL

14.2.1. redis

Redis
是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。
它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。
Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence），并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。

14.2.1.1. 添加依赖

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

自动配置：

  1. RedisAutoConfiguration自动配置类 --> RedisProperties 属性类 --> spring.redis.xxx 是对redis的配置。

  2. 连接工厂LettuceConnectionConfiguration、JedisConnectionConfiguration是准备好的，默认使用lettuce 客户端。

  3. 自动注入了RedisTemplate，xxxTemplate。

  4. 自动注入了StringRedisTemplate，key，value都是String 类型。

  5. 底层只要我们使用StringRedisTemplate、RedisTemplate就可以操作Redis。

redis相关配置：

redis:
  host: r-bp1nc7reqesxisgxpipd.redis.rds.aliyuncs.com
  port: 6379
  password: lfy:Lfy123456
  client-type: lettuce
  lettuce:
    pool:
      max-active: 10
      min-idle: 5

尽量使用 host+port 的形式，而不是直接写 url ，防止 url 中的一些特殊字符造成无法解析

14.2.1.2. RedisTemplate与Lettuce

@Autowired
RedisTemplate redisTemplate;

@Test
void testRedis() {
    ValueOperations<String, String> operations = redisTemplate.opsForValue();

    operations.set("hello", "world");

    String hello = operations.get("hello");
    System.out.println(hello);
}

14.2.1.3. 切换至jedis

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


<dependency>
    <groupId>redis.clientsgroupId>
    <artifactId>jedisartifactId>
dependency>

相关配置：

redis:
  host: r-bp1nc7reqesxisgxpipd.redis.rds.aliyuncs.com
  port: 6379
  password: lfy:Lfy123456
  client-type: jedis
  jedis:
    pool:
      max-active: 10

15. 单元测试

15.1. JUnit5的一些变化

Spring Boot 2.2.0 版本开始引入 JUnit 5 作为单元测试默认库。

JUnit 5官方文档

作为最新版本的JUnit框架，JUnit5与之前版本的JUnit框架有很大的不同。由三个不同子项目的几个不同模块组成。

JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

JUnit Platform: Junit
Platform是在JVM上启动测试框架的基础，不仅支持Junit自制的测试引擎，其他测试引擎也都可以接入。

JUnit Jupiter: JUnit
Jupiter提供了JUnit5的新的编程模型，是JUnit5新特性的核心。内部包含了一个测试引擎，用于在Junit
Platform上运行。

JUnit Vintage: 由于JUint已经发展多年，为了照顾老的项目，JUnit
Vintage提供了兼容JUnit4.x，JUnit3.x的测试引擎。

注意：

SpringBoot 2.4 以上版本移除了默认对 Vintage 的依赖。如果需要兼容JUnit4需要自行引入（不能使用JUnit4的功能 @Test）

JUnit 5’s Vintage已经从spring-boot-starter-test从移除。如果需要继续兼容Junit4需要自行引入Vintage依赖：

<dependency>
    <groupId>org.junit.vintagegroupId>
    <artifactId>junit-vintage-engineartifactId>
    <scope>testscope>
    <exclusions>
        <exclusion>
            <groupId>org.hamcrestgroupId>
            <artifactId>hamcrest-coreartifactId>
        exclusion>
    exclusions>
dependency>

要使用添加JUnit 5，需添加对应的starter：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-testartifactId>
    <scope>testscope>
dependency>

Spring的JUnit5的基本单元测试模板（Spring的JUnit4的是@SpringBootTest+@RunWith(SpringRunner.class)）：

@SpringBootTest
class SpringBootApplicationTests {

    @Autowired
    private Component component;
    
    @Test
    //@Transactional 标注后连接数据库，对其操作有回滚功能
    public void contextLoads() {
      Assertions.assertEquals(5, component.getFive());
    }
}

15.2. 常用注解

官方文档 - Annotations

@Test：表示该方法是测试方法，但是与JUnit4的@Test不同，他的职责非常单一，不能声明任何属性，拓展的测试将会由Jupiter提供额外测试

@ParameterizedTest：表示方法是参数化测试。

@RepeatedTest：表示方法可重复执行。

@DisplayName：为测试类或者测试方法设置展示名称。

@BeforeEach：表示在每个单元测试之前执行，执行多次。

@AfterEach：表示在每个单元测试之后执行，执行多次。

@BeforeAll：表示在所有单元测试之前执行，执行一次。

@AfterAll：表示在所有单元测试之后执行，执行一次。

@Tag：表示单元测试类别，类似于JUnit4中的@Categories。

@Disabled：表示测试类或测试方法不执行，类似于JUnit4中的@Ignore。

@Timeout：表示测试方法运行如果超过了指定时间将会返回错误。

@ExtendWith：为测试类或测试方法提供扩展类引用。

@DisplayName("junit5功能测试类")
public class Junit5Test {

    @DisplayName("测试displayname注解")
    @Test
    void testDisplayName() {
        System.out.println(1);
    }

    @ParameterizedTest
    @ValueSource(strings = {"racecar", "radar", "able was I ere I saw elba"})
    void palindromes(String candidate) {
        // 参数有多少个，就执行多少次
        assertTrue(StringUtils.hasLength(candidate));
        System.out.println("断言成功了");
    }

    @Disabled
    @DisplayName("测试方法2")
    @Test
    void test2() {
        System.out.println(2);
    }

    @RepeatedTest(5)
    void test3() {
        System.out.println("重复执行的测试方法");
    }

    /**
     * 规定方法超时时间。超出时间测试出异常
     *
     * @throws InterruptedException
     */
    @Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
    @Test
    void testTimeout() throws InterruptedException {
        Thread.sleep(100);
    }

    @BeforeEach
    void testBeforeEach() {
        // 每个测试方法执行之前执行
        System.out.println("单个测试开始了...");
    }

    @AfterEach
    void testAfterEach() {
        // 每个测试方法执行之后执行
        System.out.println("单个测试结束了...\n");
    }

    @BeforeAll
    static void testBeforeAll() {
        // 只会在最开始执行一次
        System.out.println("所有测试就要开始了...");
    }

    @AfterAll
    static void testAfterAll() {
        // 只会在结束之后 执行一次
        System.out.println("所有测试结束了...");
    }

}

springBoot2笔记_第18张图片

15.3. 断言机制（assertions）

断言Assertion是测试方法中的核心部分，用来对测试需要满足的条件进行验证。这些断言方法都是org.junit.jupiter.api.Assertions的静态方法。检查业务逻辑返回的数据是否合理。所有的测试运行结束以后，会有一个详细的测试报告。

15.3.1. 简单断言

用来对单个值进行简单的验证。如：

方法 说明
assertEquals 判断两个对象或两个原始类型是否相等
assertNotEquals 判断两个对象或两个原始类型是否不相等
assertSame 判断两个对象引用是否指向同一个对象
assertNotSame 判断两个对象引用是否指向不同的对象
assertTrue 判断给定的布尔值是否为 true
assertFalse 判断给定的布尔值是否为 false
assertNull 判断给定的对象引用是否为 null
assertNotNull 判断给定的对象引用是否不为 null 
@Test
@DisplayName("simple assertion")
public void simple() {
    assertEquals(3, 1 + 2, "simple math");
    assertNotEquals(3, 1 + 1);

    assertNotSame(new Object(), new Object());
    Object obj = new Object();
    assertSame(obj, obj);

    assertFalse(1 > 2);
    assertTrue(1 < 2);

    assertNull(null);
    assertNotNull(new Object());
}

注意，使用断言时，如果断言成功了，则没有任何输出，如果断言失败了，则会返回具体的错误信息，并且终止测试的执行。

15.3.2. 数组断言

通过 assertArrayEquals 方法来判断两个对象或原始类型的数组是否相等，判断时，是根据数组的内容，一个一个进行比较的，所以如果两个数组中的内容一样，但是顺序不一样，也会判断为失败。

@Test
@DisplayName("array assertion")
public void array() {
    assertArrayEquals(new int[]{1, 2}, new int[]{1, 2});
}

15.3.3. 组合断言

assertAll()方法接收多个 org.junit.jupiter.api.Executable 函数式接口的实例作为要验证的断言，可以通过 lambda 表达式很容易的提供这些断言。

@Test
@DisplayName("assert all")
public void all() {
    assertAll(
            "Math",  // 错误提示信息
            () -> assertEquals(2, 1 + 1),
            () -> assertTrue(1 > 1)
    );
}

springBoot2笔记_第19张图片

15.3.4. 异常断言

在JUnit4时期，想要测试方法的异常情况时，需要用@Rule注解的ExpectedException变量还是比较麻烦的。而JUnit5提供了一种新的断言方式**Assertions.assertThrows()**，配合函数式编程就可以使用。

@Test
@DisplayName("异常测试")
public void exceptionTest() {
    ArithmeticException exception = Assertions.assertThrows(
            // 扔出断言异常
            ArithmeticException.class, () -> System.out.println(1 % 0));
}

该断言想要测试的是，我认为该方法应该抛出一个特定的异常，然后我来判断一下是不是，如果没有抛出该异常，我就认为断言失败了。上面这个例子，断言是成功的。当然了，如果是使用更大的异常类（父类）去判断，也是可以的。

15.3.5. 超时断言

JUnit5还提供了 Assertions.assertTimeout() 为测试方法设置超时时间。

@Test
@DisplayName("超时测试")
public void timeoutTest() {
    // 如果测试方法运行时间超过1s将会异常
    Assertions.assertTimeout(Duration.ofMillis(1000), () -> Thread.sleep(500));
}

15.3.6. 快速失败

通过 fail 断言直接使测试失败。

@Test
@DisplayName("fail")
public void shouldFail() {
    fail("This should fail");
}

在这里插入图片描述

15.4. 前置条件（assumptions）

Unit 5 中的前置条件（assumptions【假设】）类似于断言，不同之处在于不满足的断言assertions会使测试方法失败，而不满足的前置条件会使测试方法执行终止。

前置条件可以看成是测试方法执行的前提，当该前提不满足时，就没有继续执行的必要。

@DisplayName("前置条件")
public class AssumptionsTest {
    private final String environment = "DEV";

    @Test
    @DisplayName("simple")
    public void simpleAssume() {
        // 简单断言
        assumeTrue(Objects.equals(this.environment, "DEV"));
        assumeFalse(() -> Objects.equals(this.environment, "PROD"));
    }

    @Test
    @DisplayName("assume then do")
    public void assumeThenDo() {
        assumingThat(
                Objects.equals(this.environment, "DEV"), // 前置条件，如果不满足该条件，则下面的测试方法不会执行
                () -> System.out.println("In DEV")
        );
    }
}

assumeTrue 和 assumFalse 确保给定的条件为 true 或 false，不满足条件会使得测试执行终止。

assumingThat 的参数是表示条件的布尔值和对应的 Executable 接口的实现对象。只有条件满足时，Executable 对象才会被执行；当条件不满足时，后面的测试方法并不会执行。

15.5. 嵌套测试

官方文档 - Nested Tests

JUnit 5 可以通过 Java 中的内部类和@Nested 注解实现嵌套测试，从而可以更好的把相关的测试方法组织在一起。在内部类中可以使用@BeforeEach 和@AfterEach注解，而且嵌套的层次没有限制。

@DisplayName("嵌套测试")
public class TestingAStackDemo {

    Stack<Object> stack;

    @BeforeEach
    void testOuter(){
        System.out.println("外层，每个方法执行前执行");
    }

    @ParameterizedTest
    @DisplayName("参数化测试")
    @ValueSource(ints = {1, 2, 3, 4, 5})
    void testParameterized(int i) {
        System.out.println(i);
    }


    @ParameterizedTest
    @DisplayName("参数化测试")
    @MethodSource("stringProvider")
    void testParameterized2(String i) {
        System.out.println(i);
    }


    static Stream<String> stringProvider() {
        System.out.println("开始提供方法参数");
        return Stream.of("apple", "banana", "atguigu");
    }

    @Test
    @DisplayName("new Stack()")
    void isInstantiatedWithNew() {
        System.out.println("外层，断言 stack 对象是否为 null");
        new Stack<>();
        // 嵌套测试情况下，外层的Test不能驱动内层的Before(After)Each/All之类的方法运行
        assertNull(stack);
    }

    @Nested
    @DisplayName("when new")
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            System.out.println("内层第一层，给 stack 引用创建空对象");
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")
        void isEmpty() {
            System.out.println("内层第一层，断言 stack 是否为空");
            assertTrue(stack.isEmpty());
        }

        @Test
        @DisplayName("throws EmptyStackException when popped")
        void throwsExceptionWhenPopped() {
            System.out.println("内层第一层，断言移除顶层元素是否会报异常");
            assertThrows(EmptyStackException.class, stack::pop);
        }

        @Test
        @DisplayName("throws EmptyStackException when peeked")
        void throwsExceptionWhenPeeked() {
            System.out.println("内层第一层，断言查看顶层元素是否会报异常");
            assertThrows(EmptyStackException.class, stack::peek);
        }

        @Nested
        @DisplayName("after pushing an element")
        class AfterPushing {

            String anElement = "an element";

            @BeforeEach
            void pushAnElement() {
                System.out.println("内层第二层，给 stack 对象放入元素");
                stack.push(anElement);
            }

            /**
             * 内层的Test可以驱动外层的Before(After)Each/All之类的方法运行
             */
            @Test
            @DisplayName("it is no longer empty")
            void isNotEmpty() {
                System.out.println("内层第二层，断言 stack 对象是否为空");
                assertFalse(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when popped and is empty")
            void returnElementWhenPopped() {
                System.out.println("内层第二层，断言 stack 顶层对象是否为内容设置的对象，在移除顶层对象之后，stack 对象是否为空");
                assertEquals(anElement, stack.pop());
                assertTrue(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when peeked but remains not empty")
            void returnElementWhenPeeked() {
                System.out.println("内层第二层，断言 stack 顶层对象是否为内容设置的对象，不移除顶层对象，stack 对象是否为空");
                assertEquals(anElement, stack.peek());
                assertFalse(stack.isEmpty());
            }
        }
    }
}

springBoot2笔记_第20张图片

从上面的运行结果可以看出，测试都是先开始执行外部类的测试方法，然后再执行内部类的测试方法，并且外部类的 @BeforeEach 方法会在内部类的每个测试方法执行前都执行一次，不管是第几层内部类。

15.6. 参数化测试

官方文档 - Parameterized Tests

参数化测试是JUnit5很重要的一个新特性，它使得用不同的参数多次运行测试方法成为了可能，也为我们的单元测试带来许多便利。

利用@ValueSource等注解指定入参，我们就可以使用不同的参数进行多次单元测试，而不需要每新增一个参数就新增一个单元测试，省去了很多冗余代码。

  • @ValueSource:为参数化测试指定入参来源，支持八大基础类以及String类型,Class类型

  • @NullSource: 表示为参数化测试提供一个null的入参

  • @EnumSource: 表示为参数化测试提供一个枚举入参

  • @CsvFileSource：表示读取指定CSV文件内容作为参数化测试入参

  • @MethodSource：表示读取指定方法的返回值作为参数化测试入参(注意方法返回需要是一个流)

参数化测试支持外部的各类入参，如:CSV,YML,JSON 文件，甚至方法的返回值也可以作为入参。只需要实现ArgumentsProvider接口，任何外部文件都可以作为它的入参。

@ParameterizedTest
@ValueSource(strings = {"one", "two", "three"})
@DisplayName("参数化测试1")
public void parameterizedTest1(String string) {
    System.out.println(string);
    Assertions.assertTrue(StringUtils.isNotBlank(string));
}


@ParameterizedTest
@MethodSource("method")    // 指定方法名
@DisplayName("方法来源参数")
public void testWithExplicitLocalMethodSource(String name) {
    System.out.println(name);
    Assertions.assertNotNull(name);
}

static Stream<String> method() {
    // 注意需要返回一个 stream 流，并且是静态方法
    return Stream.of("apple", "banana");
}

15.7. 迁移指南

官方文档 - Migrating from JUnit 4

在进行迁移的时候需要注意如下的变化：

  • 注解在 org.junit.jupiter.api 包中，断言在org.junit.jupiter.api.Assertions 类中，前置条件在
    org.junit.jupiter.api.Assumptions 类中。

  • 把@Before 和@After 替换成**@BeforeEach** 和**@AfterEach**。

  • 把@BeforeClass 和@AfterClass 替换成**@BeforeAll** 和**@AfterAll**。

  • 把@Ignore 替换成**@Disabled**。

  • 把@Category 替换成**@Tag**。

  • 把@RunWith、@Rule 和@ClassRule 替换成**@ExtendWith**。

16. 指标监控

16.1. SpringBoot Actuator

16.1.1. 简介

未来每一个微服务在云上部署以后，我们都需要对其进行监控、追踪、审计、控制等。SpringBoot就抽取了Actuator场景，使得我们每个微服务只需快速引用即可获得生产级别的应用监控、审计等功能。

官方文档 - Spring Boot Actuator: Production-ready Features

16.1.2. 1.x与2.x的不同

SpringBoot Actuator 1.x

  • 支持SpringMVC

  • 基于继承方式进行扩展

  • 层级Metrics配置

  • 自定义Metrics收集

  • 默认较少的安全策略

SpringBoot Actuator 2.x

  • 支持SpringMVC、JAX-RS以及Webflux

  • 注解驱动进行扩展

  • 层级&名称空间Metrics

  • 底层使用MicroMeter，强大、便捷默认丰富的安全策略

16.1.3. 使用

添加依赖

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

访问http://localhost:8080/actuator/**

以 HTTP 方式暴露所有监控信息。

management:
  endpoints:
    enabled-by-default: true #暴露所有端点信息
    web:
      exposure:
        include: '*'  #以web方式暴露

下面是一些监控指标：

  • http://localhost:8080/actuator/beans

  • http://localhost:8080/actuator/configprops

  • http://localhost:8080/actuator/metrics

  • http://localhost:8080/actuator/metrics/jvm.gc.pause

  • http://localhost:8080/actuator/metrics/endpointName/detailPath

16.2. Actuator Endpoint

16.2.1. 常用端点

ID 描述
auditevents 暴露当前应用程序的审核事件信息。需要一个AuditEventRepository组件。
beans 显示应用程序中所有Spring Bean的完整列表。
caches 暴露可用的缓存。
conditions 显示自动配置的所有条件信息，包括匹配或不匹配的原因。
configprops 显示所有@ConfigurationProperties。
env 暴露Spring的属性ConfigurableEnvironment
flyway 显示已应用的所有Flyway数据库迁移。 需要一个或多个Flyway组件。
health 显示应用程序运行状况信息。
httptrace 显示HTTP跟踪信息（默认情况下，最近100个HTTP请求-响应）。需要一个HttpTraceRepository组件。
info 显示应用程序信息。
integrationgraph 显示Spring integrationgraph 。需要依赖spring-integration-core。
loggers 显示和修改应用程序中日志的配置。
liquibase 显示已应用的所有Liquibase数据库迁移。需要一个或多个Liquibase组件。
metrics 显示当前应用程序的“指标”信息。
mappings 显示所有@RequestMapping路径列表。
scheduledtasks 显示应用程序中的计划任务。
sessions 允许从Spring Session支持的会话存储中检索和删除用户会话。需要使用Spring Session的基于Servlet的Web应用程序。
shutdown 使应用程序正常关闭。默认禁用。
startup 显示由ApplicationStartup收集的启动步骤数据。需要使用SpringApplication进行配置BufferingApplicationStartup。
threaddump 执行线程转储。

如果您的应用程序是Web应用程序（Spring MVC，Spring
WebFlux或Jersey），则可以使用以下附加端点：

ID 描述
heapdump 返回hprof堆转储文件。
jolokia 通过HTTP暴露JMX bean（需要引入Jolokia，不适用于WebFlux）。需要引入依赖jolokia-core。
logfile 返回日志文件的内容（如果已设置logging.file.name或logging.file.path属性）。支持使用HTTPRange标头来检索部分日志文件的内容。
prometheus 以Prometheus服务器可以抓取的格式公开指标。需要依赖micrometer-registry-prometheus。

其中最常用的Endpoint：

  • Health：监控状况

  • Metrics：运行时指标

  • Loggers：日志记录

16.2.2. Health Endpoint

健康检查端点，一般用于云平台，平台会定时检查应用的健康状况，Health Endpoint可以为平台返回当前应用的一系列组件健康状况的集合。

重要的几点：

  • health endpoint返回的结果，是一系列健康检查后的一个汇总报告。

  • 很多的健康检查默认已经自动配置好了，比如：数据库、redis等。

  • 可以很容易的添加自定义的健康检查机制。

16.2.3. Metrics Endpoint

提供详细的、层级的空间指标信息，这些信息可以被pull（主动推送）或者push（被动获取）方式得到：

  • 通过Metrics对接多种监控系统。

  • 简化核心Metrics开发。

  • 添加自定义Metrics或者扩展已有Metrics。

16.2.4. 管理Endpoints

16.2.4.1. 开启与禁用Endpoints

默认所有的Endpoint除了shutdown都是开启的。

需要开启或者禁用某个Endpoint。配置模式为management.endpoint.\.enabled = true

management:
  endpoint:
    beans:
      enabled: true

或者禁用所有的Endpoint然后手动开启指定的Endpoint：

management:
  endpoints:
    enabled-by-default: false
  endpoint:
    beans:
      enabled: true
    health:
      enabled: true

16.2.4.2. 暴露Endpoints

支持的暴露方式:

  • HTTP：默认只暴露health和info。

  • JMX：默认暴露所有Endpoint。

除过health和info，剩下的Endpoint都应该进行保护访问。如果引入Spring
Security，则会默认配置安全访问规则。

ID JMX Web
auditevents Yes No
beans Yes No
caches Yes No
conditions Yes No
configprops Yes No
env Yes No
flyway Yes No
health Yes Yes
heapdump N/A No
httptrace Yes No
info Yes Yes
integrationgraph Yes No
jolokia N/A No
logfile N/A No
loggers Yes No
liquibase Yes No
metrics Yes No
mappings Yes No
prometheus N/A No
scheduledtasks Yes No
sessions Yes No
shutdown Yes No
startup Yes No
threaddump Yes No

若要更改公开的Endpoint，请配置以下的包含和排除属性：

Property Default
management.endpoints.jmx.exposure.exclude
management.endpoints.jmx.exposure.include *
management.endpoints.web.exposure.exclude
management.endpoints.web.exposure.include info, health

官方文档 - Exposing Endpoints

16.3. 定制Endpoint

16.3.1. 定制 Health 信息

management:
  health:
    enabled: true
    show-details: always #总是显示详细信息。可显示每个模块的状态信息

通过实现HealthIndicator接口，或继承MyComHealthIndicator类来自定义。

@Component
public class MyHealthIndicator implements HealthIndicator {

    @Override
    public Health health() {
        int errorCode = check(); // perform some specific health check
        if (errorCode != 0) {
            return Health.down().withDetail("Error Code", errorCode).build();
        }
        // 构建 health
        Health build = Health.down()
                .withDetail("msg", "error service")
                .withDetail("code", "500")
                .withException(new RuntimeException())
                .build();
        return Health.up().build();
    }

}

@Component
public class MyComHealthIndicator extends AbstractHealthIndicator {

    /**
     * 真实的检查方法
     *
     * @param builder
     * @throws Exception
     */
    @Override
    protected void doHealthCheck(Health.Builder builder) throws Exception {
        // mongodb， 获取连接进行测试
        Map<String, Object> map = new HashMap<>();
        // 检查完成
        if (1 == 2) {
//            builder.up(); //健康
            builder.status(Status.UP);
            map.put("count", 1);
            map.put("ms", 100);
        } else {
//            builder.down();
            builder.status(Status.OUT_OF_SERVICE);
            map.put("err", "连接超时");
            map.put("ms", 3000);
        }

        builder.withDetail("code", 100)
                .withDetails(map);
    }
}

16.3.2. 定制info信息

常用两种方式

  1. 编写配置文件

    info:
  appName: boot-admin
  version: 2.0.1
  mavenProjectName: @project.artifactId@  #使用@@可以获取maven的pom文件值
  mavenProjectVersion: @project.version@

  2. 编写InfoContributor

    @Component
public class ExampleInfoContributor implements InfoContributor {

    @Override
    public void contribute(Info.Builder builder) {
        builder.withDetail("example", Collections.singletonMap("key", "value"));
    }

}

然后访问http://localhost:8080/actuator/info，就会输出以上方式返回的所有info信息

16.3.3. 定制Metrics信息

16.3.3.1. SpringBoot支持自动适配的Metrics

  • JVM metrics, report utilization of:

    • Various memory and buffer pools

    • Statistics related to garbage collection

    • Threads utilization

    • Number of classes loaded/unloaded

  • CPU metrics

  • File descriptor metrics

  • Kafka consumer and producer metrics

  • Log4j2 metrics: record the number of events logged to Log4j2 at each level

  • Logback metrics: record the number of events logged to Logback at each level

  • Uptime metrics: report a gauge for uptime and a fixed gauge representing the application’s absolute start time

  • Tomcat metrics (server.tomcat.mbeanregistry.enabled must be set to true for all Tomcat metrics to be registered)

  • Spring Integration metrics

16.3.3.2. 定制Metrics

@Component
@Endpoint(id = "myservice")
public class MyServiceEndPoint {

    @ReadOperation
    public Map getDockerInfo(){
        //端点的读操作  http://localhost:8080/actuator/myservice
        return Collections.singletonMap("dockerInfo","docker started.....");
    }

    @WriteOperation
    public void stopDocker(){
        System.out.println("docker stopped.....");
    }

}

也可以使用下面的方式

//也可以使用下面的方式
@Bean
MeterBinder queueSize(Queue queue) {
    return (registry) -> Gauge.builder("queueSize", queue::size).register(registry);
}

上面这个方法写到配置类中。

16.4. 定制Endpoint

@Component
@Endpoint(id = "container")
public class DockerEndpoint {

    @ReadOperation
    public Map getDockerInfo(){
        return Collections.singletonMap("info","docker started...");
    }

    @WriteOperation
    private void restartDocker(){
        System.out.println("docker restarted....");
    }

}

场景：

开发ReadinessEndpoint来管理程序是否就绪，或者是开发LivenessEndpoint来管理程序是否存活。

当然，这个也可以直接使用：https://docs.spring.io/spring-boot/docs/current/reference/html/production-ready-features.html#production-ready-kubernetes-probes

17. Profile

17.1. Profile功能

为了方便多环境适配，Spring Boot简化了profile功能。

17.1.1. application-profile功能

  • 默认配置文件application.yaml任何时候都会加载。

  • 指定环境配置文件application-{env}.yaml，env表示绑定的环境名称，比如test、dev、prod等

  • 激活指定环境

    • 配置文件激活：spring.profiles.active=prod，在默认配置文件中指定

    • 命令行激活：java -jar xxx.jar --spring.profiles.active=prod --person.name=haha

      • 修改配置文件的任意值，命令行优先

  • 默认配置与环境配置同时生效

  • 同名配置项，profile配置优先

17.1.2. @Profile条件装配功能

加到类上：

@Profile(value = {"prod", "default"})// 加载application-prod.yaml以及application.yaml里的配置
@Component
@ConfigurationProperties("person")
@Data
public class Worker {
    private String name;
    private Integer age;
}

加到方法上：

@Configuration
public class MyConfig {

    @Profile("prod")
    @Bean
    public Color red() {
        return new Color();
    }

    @Profile("test")
    @Bean
    public Color green() {
        return new Color();
    }
}

17.1.3. profile分组

properties：

spring.profiles.group.production[0]=proddb
spring.profiles.group.production[1]=prodmq
spring.profiles.active=production

yaml：

profiles:
  active: [ default, test, prod ]

17.2. 外部化配置

官方文档 - Externalized Configuration

17.2.1. 外部配置源

Java属性文件、YAML文件、环境变量、命令行参数

17.2.2. 配置文件查找位置

classpath 根路径。

classpath 根路径下config目录。

jar包当前目录。

jar包当前目录的config目录。

/config 子目录的直接子目录。

17.2.3. 配置文件加载顺序

  1. 当前jar包内部的application.properties和application.yml。

  2. 当前jar包内部的application-{profile}.properties 和application-{profile}.yml。

  3. 引用的外部jar包的application.properties和application.yml。

  4. 引用的外部jar包的application-{profile}.properties和application-{profile}.yml。

指定环境优先，外部优先，后面的可以覆盖前面的同名配置项。

你可能感兴趣的:(sprintBoot,java,spring,boot)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • Spring Boot中实现跨域请求 BABA8891 springboot后端java
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • java工厂模式 3213213333332132 java抽象工厂
    工厂模式有 1、工厂方法 2、抽象工厂方法。 下面我的实现是抽象工厂方法, 给所有具体的产品类定一个通用的接口。 package 工厂模式; /** * 航天飞行接口 * * @Description * @author FuJianyong * 2015-7-14下午02:42:05 */ public interface SpaceF
  • nginx频率限制+python测试 ronin47 nginx 频率 python
           部分内容参考：http://www.abc3210.com/2013/web_04/82.shtml 首先说一下遇到这个问题是因为网站被攻击，阿里云报警，想到要限制一下访问频率，而不是限制ip（限制ip的方案稍后给出）。nginx连接资源被吃空返回状态码是502，添加本方案限制后返回599，与正常状态码区别开。步骤如下：
  • java线程和线程池的使用 dyy_gusi ThreadPoolthreadRunnabletimer
    java线程和线程池 一、创建多线程的方式     java多线程很常见，如何使用多线程，如何创建线程，java中有两种方式，第一种是让自己的类实现Runnable接口，第二种是让自己的类继承Thread类。其实Thread类自己也是实现了Runnable接口。具体使用实例如下： 1、通过实现Runnable接口方式 1 2
  • Linux 171815164 linux
    ubuntu kernel http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.1.2-unstable/ 安卓sdk代理 mirrors.neusoft.edu.cn        80 输入法和jdk sudo apt-get install fcitx su
  • Tomcat JDBC Connection Pool g21121 Connection
           Tomcat7 抛弃了以往的DBCP 采用了新的Tomcat Jdbc Pool 作为数据库连接组件，事实上DBCP已经被Hibernate 所抛弃，因为他存在很多问题，诸如：更新缓慢，bug较多，编译问题，代码复杂等等。        Tomcat Jdbc P
  • 敲代码的一点想法 永夜-极光 java随笔感想
                  入门学习java编程已经半年了,一路敲代码下来,现在也才1w+行代码量,也就菜鸟水准吧,但是在整个学习过程中,我一直在想,为什么很多培训老师,网上的文章都是要我们背一些代码?比如学习Arraylist的时候,教师就让我们先参考源代码写一遍,然
  • jvm指令集 程序员是怎么炼成的 jvm 指令集
    转自：http://blog.csdn.net/hudashi/article/details/7062675#comments       将值推送至栈顶时 const ldc  push   load指令 const系列 该系列命令主要负责把简单的数值类型送到栈顶。(从常量池或者局部变量push到栈顶时均使用) 0x02 &nbs
  • Oracle字符集的查看查询和Oracle字符集的设置修改 aijuans oracle
    本文主要讨论以下几个部分：如何查看查询oracle字符集、 修改设置字符集以及常见的oracle utf8字符集和oracle exp 字符集问题。 一、什么是Oracle字符集 Oracle字符集是一个字节数据的解释的符号集合,有大小之分,有相互的包容关系。ORACLE 支持国家语言的体系结构允许你使用本地化语言来存储，处理，检索数据。它使数据库工具，错误消息，排序次序，日期，时间，货
  • png在Ie6下透明度处理方法 antonyup_2006 css浏览器FirebugIE
    由于之前到深圳现场支撑上线，当时为了解决个控件下载，我机器上的IE8老报个错，不得以把ie8卸载掉，换个Ie6,问题解决了，今天出差回来，用ie6登入另一个正在开发的系统，遇到了Png图片的问题，当然升级到ie8(ie8自带的开发人员工具调试前端页面JS之类的还是比较方便的，和FireBug一样，呵呵)，这个问题就解决了，但稍微做了下这个问题的处理。 我们知道PNG是图像文件存储格式，查询资
  • 表查询常用命令高级查询方法(二) 百合不是茶 oracle分页查询分组查询联合查询
    ----------------------------------------------------分组查询 group by    having   --平均工资和最高工资   select avg(sal)平均工资,max(sal)  from emp ;  --每个部门的平均工资和最高工资
  • uploadify3.1版本参数使用详解 bijian1013 JavaScriptuploadify3.1
    使用：     绑定的界面元素<input id='gallery'type='file'/>$("#gallery").uploadify({设置参数，参数如下}); 设置的属性： id: jQuery(this).attr('id'),//绑定的input的ID langFile: 'http://ww
  • 精通Oracle10编程SQL(17)使用ORACLE系统包 bijian1013 oracle数据库plsql
    /* *使用ORACLE系统包 */ --1.DBMS_OUTPUT --ENABLE:用于激活过程PUT,PUT_LINE,NEW_LINE,GET_LINE和GET_LINES的调用 --语法：DBMS_OUTPUT.enable(buffer_size in integer default 20000); --DISABLE:用于禁止对过程PUT,PUT_LINE,NEW
  • 【JVM一】JVM垃圾回收日志 bit1129 垃圾回收
    将JVM垃圾回收的日志记录下来，对于分析垃圾回收的运行状态，进而调整内存分配(年轻代，老年代，永久代的内存分配)等是很有意义的。JVM与垃圾回收日志相关的参数包括： -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -Xloggc -XX:+PrintGC 通
  • Toast使用 白糖_ toast
    Android中的Toast是一种简易的消息提示框，toast提示框不能被用户点击，toast会根据用户设置的显示时间后自动消失。     创建Toast 两个方法创建Toast makeText(Context context, int resId, int duration)     参数：context是toast显示在
  • angular.identity boyitech AngularJSAngularJS API
    angular.identiy 描述: 返回它第一参数的函数. 此函数多用于函数是编程. 使用方法: angular.identity(value); 参数详解: Param Type Details value * to be returned. 返回值: 传入的value 实例代码: <!DOCTYPE HTML>
  • java-两整数相除，求循环节 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class CircleDigitsInDivision { /** * 题目：求循环节，若整除则返回NULL，否则返回char*指向循环节。先写思路。函数原型：char*get_circle_digits(unsigned k,unsigned j)
  • Java 日期 周 年 Chen.H javaC++cC#
    /** * java日期操作(月末、周末等的日期操作) * * @author * */ public class DateUtil { /** */ /** * 取得某天相加(减)後的那一天 * * @param date * @param num *
  • [高考与专业]欢迎广大高中毕业生加入自动控制与计算机应用专业 comsci 计算机
          不知道现在的高校还设置这个宽口径专业没有,自动控制与计算机应用专业,我就是这个专业毕业的,这个专业的课程非常多,既要学习自动控制方面的课程,也要学习计算机专业的课程,对数学也要求比较高.....如果有这个专业,欢迎大家报考...毕业出来之后,就业的途径非常广.....      以后
  • 分层查询（Hierarchical Queries） daizj oracle递归查询层次查询
    Hierarchical Queries If a table contains hierarchical data, then you can select rows in a hierarchical order using the hierarchical query clause: hierarchical_query_clause::= start with condi
  • 数据迁移 daysinsun 数据迁移
    最近公司在重构一个医疗系统，原来的系统是两个.Net系统，现需要重构到java中。数据库分别为SQL Server和Mysql，现需要将数据库统一为Hana数据库，发现了几个问题，但最后通过努力都解决了。 1、原本通过Hana的数据迁移工具把数据是可以迁移过去的，在MySQl里面的字段为TEXT类型的到Hana里面就存储不了了，最后不得不更改为clob。 2、在数据插入的时候有些字段特别长
  • C语言学习二进制的表示示例 dcj3sjt126com cbasic
    进制的表示示例 # include <stdio.h> int main(void) { int i = 0x32C; printf("i = %d\n", i); /* printf的用法 %d表示以十进制输出 %x或%X表示以十六进制的输出 %o表示以八进制输出 */ return 0; }
  • NsTimer 和 UITableViewCell 之间的控制 dcj3sjt126com ios
    情况是这样的: 一个UITableView, 每个Cell的内容是我自定义的 viewA viewA上面有很多的动画, 我需要添加NSTimer来做动画, 由于TableView的复用机制, 我添加的动画会不断开启, 没有停止, 动画会执行越来越多.   解决办法: 在配置cell的时候开始动画, 然后在cell结束显示的时候停止动画   查找cell结束显示的代理
  • MySql中case when then 的使用 fanxiaolong casewhenthenend
    select "主键", "项目编号", "项目名称","项目创建时间", "项目状态","部门名称","创建人" union (select pp.id as "主键", pp.project_number as &
  • Ehcache（01）——简介、基本操作 234390216 cacheehcache简介CacheManagercrud
    Ehcache简介 目录 1       CacheManager 1.1      构造方法构建 1.2      静态方法构建 2       Cache 2.1&
  • 最容易懂的javascript闭包学习入门 jackyrong JavaScript
    http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html 闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。 下面就是我的学习笔记，对于Javascript初学者应该是很有用的。 一、变量的作用域 要理解闭包，首先必须理解Javascript特殊
  • 提升网站转化率的四步优化方案 php教程分享 数据结构PHP数据挖掘Google活动
    网站开发完成后,我们在进行网站优化最关键的问题就是如何提高整体的转化率，这也是营销策略里最最重要的方面之一，并且也是网站综合运营实例的结果。文中分享了四大优化策略：调查、研究、优化、评估，这四大策略可以很好地帮助用户设计出高效的优化方案。 PHP开发的网站优化一个网站最关键和棘手的是，如何提高整体的转化率，这是任何营销策略里最重要的方面之一，而提升网站转化率是网站综合运营实力的结果。今天，我就分
  • web开发里什么是HTML5的WebSocket？ naruto1990 Webhtml5浏览器socket
    当前火起来的HTML5语言里面，很多学者们都还没有完全了解这语言的效果情况，我最喜欢的Web开发技术就是正迅速变得流行的 WebSocket API。WebSocket 提供了一个受欢迎的技术，以替代我们过去几年一直在用的Ajax技术。这个新的API提供了一个方法，从客户端使用简单的语法有效地推动消息到服务器。让我们看一看6个HTML5教程介绍里 的 WebSocket API：它可用于客户端、服
  • Socket初步编程——简单实现群聊 Everyday都不同 socket网络编程初步认识
    初次接触到socket网络编程，也参考了网络上众前辈的文章。尝试自己也写了一下，记录下过程吧：   服务端：（接收客户端消息并把它们打印出来）   public class SocketServer { private List<Socket> socketList = new ArrayList<Socket>(); public s
  • 面试：Hashtable与HashMap的区别（结合线程） toknowme
    昨天去了某钱公司面试，面试过程中被问道 Hashtable与HashMap的区别？当时就是回答了一点，Hashtable是线程安全的，HashMap是线程不安全的，说白了，就是Hashtable是的同步的，HashMap不是同步的，需要额外的处理一下。   今天就动手写了一个例子，直接看代码吧 package com.learn.lesson001; import java
  • MVC设计模式的总结 xp9802 设计模式mvc框架IOC
    随着Web应用的商业逻辑包含逐渐复杂的公式分析计算、决策支持等，使客户机越 来越不堪重负，因此将系统的商业分离出来。单独形成一部分，这样三层结构产生了。 其中‘层’是逻辑上的划分。 三层体系结构是将整个系统划分为如图2.1所示的结构[3] （1）表现层（Presentation layer）：包含表示代码、用户交互GUI、数据验证。 该层用于向客户端用户提供GUI交互，它允许用户
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他