吃个小菜
吃个小菜

Spring全家桶--SpringBoot

SpringBoot

  • 一、SpringBoot入门
    • 1.1 什么是SpringBoot
    • 1.2 SpringBoot优缺点
    • 1.3 SpringBoot快速入门
      • 1.3.1 通过Maven导入依赖
      • 1.3.2 直接上代码运行
    • 1.4 简化配置
    • 1.5 简化部署
  • 二、了解自动配置原理
    • 2.1 SpringBoot特点
      • 2.1.1 依赖管理
      • 2.1.2 自动配置
    • 2.2 常见注解
      • 2.2.1 @Bean
      • 2.2.2 @Configuration
      • 2.2.3 @Import
      • 2.2.4 @Conditional
      • 2.2.5 @ImportResource
      • 2.2.6 @ConfigurationProperties
    • 2.3 自动配置原理入门
      • 2.3.1 回顾注解
      • 2.3.2 @SpringBootConfiguration
      • 2.3.3 @ComponentScan
      • 2.3.4 @EnableAutoConfiguration
        • @AutoConfigurationPackage
        • @Import(AutoConfigurationImportSelector.class)
      • 2.3.5 总结
    • 2.4 开发小技巧
      • 2.4.1 lombok
      • 2.4.2 dev-tools
      • 2.4.3 Spring Initailizr
  • 三、SpringBoot2核心功能
    • 3.1 配置文件
      • 3.1.1 properties
      • 3.1.2 yaml
      • 3.1.简介
    • 3.2 Web开发
      • 3.2.1 静态资源访问
      • 3.2.2 欢迎页支持
      • 3.2.3 自定义Favicon
      • 3.2.4 请求映射
      • 3.2.5 普通参数与基本注解
      • 3.2.6 视图解析流程
      • 3.2.7 Thymeleaf
      • 3.2.8 SpringBoot实战
      • 3.2.9 拦截器
      • 3.2.10 文件上传功能
      • 3.2.11 异常处理
      • 3.2.12 Web原生组件注入
      • 3.2.13 嵌入式Servlet容器
      • 3.2.14 SpringBoot原理套路
    • 3.3 数据访问
      • 3.3.1 数据源的自动配置
      • 3.3.2 使用Druid数据源
      • 3.3.3 整合Mybatis操作
      • 3.3.4 整合Mybatis-Plus完成CRUD
    • 3.4 单元测试
      • 3.4.1 Junit5的变化
      • 3.4.2 Junit5常用注解
      • 3.4.3 断言
      • 3.4.4 前置条件（assumptions）
      • 3.4.5 嵌套测试
      • 3.5.6 参数化测试
    • 3.5 指标监控
      • 3.5.1 SpringBoot Actuator
      • 3.5.2 Actuator Endpoint
      • 3.5.3 定制Endpoint
    • 3.6 原理解析
      • 3.6.1 Profile功能
      • 3.6.2 外部化配置

一、SpringBoot入门

1.1 什么是SpringBoot

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

Spring全家桶--SpringBoot_第1张图片

官网这个图我们来简单了解一下，可以通过SpringBoot快速构建一个一个小的模块，我们可以认为是开发出一个个的微服务

之后通过SpringCloud协调你开发的微服务模块，这些微服务可以通过springdata进行数据交互

学习SpringBoot之前应该先学习SSM框架之后再来学习，这样才能体会到它带来的便利！

1.2 SpringBoot优缺点

优点：

  1. 创建独立Spring应用
  2. 内嵌web服务器
  3. 自动starter依赖，简化构建配置
  4. 自动配置Spring以及第三方功能
  5. 提供生产级别的监控、健康检查及外部化配置
  6. 无代码生成、无需编写XML

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

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

什么是脚手架？？？
对于程序员来说脚手架就是代码生成器。不用重复的进行创建类和基本的增删改查等工作。只需要按照步骤配置好，就能自动完成基础类和各个实现类等的创建了。

缺点：

  1. 更新快，需要不断学习新技术
  2. 封装太深，不利于精通

1.3 SpringBoot快速入门

环境如下：

Spring全家桶--SpringBoot_第2张图片

Spring全家桶--SpringBoot_第3张图片

1.3.1 通过Maven导入依赖

pom文件


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>com.caqgroupId>
    <artifactId>SpringBootStudyartifactId>
    <version>1.0-SNAPSHOTversion>
	    <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>
project>

在SpringBoot中我们想进行WEB开发，可以直接导入一个spring-boot-starter-web即可

在原来的SSM阶段我们要导入大量的包，springboot中这一个包就可以把SSM阶段WEB开发需要的都导入进来

Spring全家桶--SpringBoot_第4张图片

1.3.2 直接上代码运行

主程序代码

@SpringBootApplication代表这是一个springboot应用

ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);属于固定写法

package com.caq.boot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

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

控制层代码

@RestController是@ResponseBody的结合@Controller

@Controller是创建

@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。

package com.caq.boot.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Controller {
    @RequestMapping("/hello")
    public String handle01(){
        return "Hello SpringBoot 2 !";
    }
}

运行主程序访问8080端口

Spring全家桶--SpringBoot_第5张图片

Spring全家桶--SpringBoot_第6张图片

测试成功~~

1.4 简化配置

写一个application.properties配置文件，所有的配置文件都可以写这里面

比如我们改tomcat的端口号为8089

如下所示：

server.port=8089

重新启动程序访问测试

Spring全家桶--SpringBoot_第7张图片

1.5 简化部署

把项目打成jar包，直接在目标服务器执行即可。

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

通过如下命令运行我们的程序

java -jar 运行我们的jar包

dir查看当前目录下的文件

Spring全家桶--SpringBoot_第8张图片

测试依旧可以访问，我还更改了返回的字符串

Spring全家桶--SpringBoot_第9张图片

二、了解自动配置原理

2.1 SpringBoot特点

2.1.1 依赖管理

父项目是用来解决依赖管理的

标签是maven中的继承，是用来做依赖管理的

spring-boot-dependencies是spring-boot-starter-parent的父项目。它几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制

spring-boot-starter-* ： *就某种场景

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

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

修改默认版本号

在pom里直接写 这个标签，写你想要的版本即可

1、查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
2、在当前项目里面重写配置
    <properties>
        <mysql.version>5.1.43mysql.version>
    properties>

2.1.2 自动配置

  • 自动配好SpringMVC

    • 引入SpringMVC全套组件
    • 自动配好SpringMVC常用组件（功能）

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

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

  • 默认的包结构

    • 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
    • 无需以前的包扫描配置
    • 想要改变扫描路径，@SpringBootApplication(scanBasePackages=“com.example”)
@SpringBootApplication
等同于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.caq.boot")

  • @EnableAutoConfiguration帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot，并创建对应配置类的Bean，并把该Bean实体交给IoC容器进行管理。

  • 各种配置拥有默认值

    • 默认配置最终都是映射到某个类上，如：MultipartProperties
    • 配置文件的值最终会绑定每个类上，这个类会在容器中创建对象

  • 按需加载所有自动配置项

    • 非常多的starter
    • 引入了哪些场景这个场景的自动配置才会开启
    • SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

那么它是如何自动配置的呢？

我们需要先了解下SpringBoot底层的相关注解

2.2 常见注解

2.2.1 @Bean

==@Bean给容器中添加组件。==以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例

组件的概念在上面提到了就是符合某种规范的类，可以理解为给容器中添加对象

/**
User类和Pet要提前写好
*/
@Bean
public User user01(){
    return new User("zs",12);
}

这个我们自定义一个名字，不用方法名作为实例的名字了
@Bean("tiger")
public Pet animal01(){
    return new Pet("li");
}

如下，SpringApplication.run（）返回值是把IOC容器返回给我们了

ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

我们用返回的IOC容器进行测试看看通过@Bean添加的组件有没有添加成功

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

        boolean tiger1 = run.containsBean("tiger");
        System.out.println(tiger1);

        boolean user01 = run.containsBean("user01");
        System.out.println(user01);
    }
}

Spring全家桶--SpringBoot_第10张图片

2.2.2 @Configuration

组件(component):

组件也是抽象的概念,可以理解为一些符合某种规范的类组合在一起就构成了组件。他可以提供某些特定的功能。J2EE来说，有什么servlet，jsp, javabean，ejb都是组件。但实际他们都是类，只不过有他们特殊的规定。组件和类的关系:符合某种规范的类的组合构成组件

@Configuration作用是告诉SpringBoot这是一个配置类 == 配置文件

之前的Spring学习中，我们通过XML配置文件进行管理bean

通过@Configuration注解可以不用写XML配置文件，将它写在类上面可以把这个类当成配置类来用。对象的管理在这个配置类中进行

@Configurationpublic class Myconfig {}

@Configuration(proxyBeanMethods = true)，默认值是true的。那么它有什么用呢？

Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】

Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】

组件依赖必须使用Full模式默认。其他默认是否Lite模式

我们打印Myconfig对象可以看到是EnhancerBySpringCGLIB，这个就代表它是一个被SpringCGLIB增强了的代理对象

com.caq.boot.config.Myconfig E n h a n c e r B y S p r i n g C G L I B EnhancerBySpringCGLIB EnhancerBySpringCGLIBdfb5b12f@55f45b92

如果代理对象调用配置类中注册组件使用的方法返回值一定是单实例

********配置类********
@Configuration(proxyBeanMethods = true)
public class Myconfig {
    @Bean
    public User user01(){
        return new User("zs",12);
    }

    @Bean("tiger")  //这个我们自定义一个名字，不用方法名作为实例的名字了
    public Pet animal01(){
        return new Pet("li");
    }
}
   

********主程序类********
@SpringBootApplication
public class MainApplication {
public static void main(String[] args) {
    //1.返回值是IOC容器
    ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
    
    Myconfig myconfig = run.getBean(Myconfig.class);
    System.out.println("对配置类中的这个组件注册方法调用看获取到的对象是不是同一对象");
    User user02 = myconfig.user01();
    User user03 = myconfig.user01();
    System.out.println(user02==user03);
    }
}

********测试结果*******
...
com.caq.boot.config.Myconfig$$EnhancerBySpringCGLIB$$3ea98f23@1d81e101
对配置类中的这个组件注册方法调用看获取到的对象是不是同一对象
true

2.2.3 @Import

和@Bean功能类似，都是注册组件的

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

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        String[] beanNamesForType = run.getBeanNamesForType(User.class);
        for (String s : beanNamesForType) {
            System.out.println(s);
        }
    }
}


*************打印结果************
com.caq.boot.bean.User
user01

2.2.4 @Conditional

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

@ConditionalOnBean(name = “tiger”)如果容器中有tiger这个组件才会执行下面的配置

@ConditionalOnMissingBean(name = “tiger”)如果容器中没有tiger这个组件才会执行下面的配置

@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = true)
@ConditionalOnBean(name = "tiger")
//@ConditionalOnMissingBean(name = "tiger")
public class Myconfig {
    @Bean
    public User user01(){
        return new User("zs",12);
    }

//    @Bean("tiger")
    public Pet animal01(){
        return new Pet("li");
    }
}

Spring全家桶--SpringBoot_第11张图片

2.2.5 @ImportResource

可以引入xml配置文件中的bean

======================beans.xml=========================

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="zs" class="com.caq.boot.bean.User">
        <property name="name" value="zhangsan">property>
        <property name="age" value="18">property>
    bean>

    <bean id="dog" class="com.caq.boot.bean.Pet">
        <property name="name" value="tomcat">property>
    bean>
beans>

@ImportResource("classpath:beans.xml")
public class MyConfig {}

2.2.6 @ConfigurationProperties

将我们的类和配置文件进行绑定
@ConfigurationProperties(prefix = “mycar”)和配置文件绑定，prefix是和配置文件中的前缀对应

配置绑定可以理解为字面意思，将要配置给对象的属性写在配置文件中。通过@ConfigurationProperties注解来实现赋值

Spring全家桶--SpringBoot_第12张图片

**************************car的实体类*******************
//只有在容器中的组件才有SpringBoot提供的功能
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
    private String brand;
    private String price;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price='" + price + '\'' +
                '}';
    }
}


**********************web层代码***************************
@RestController
//@RestController是@ResponseBody的结合@Controller
public class Controller {

    @RequestMapping("/hello")
    public String handle01() {
        return "Hello SpringBoot 2 !" + "你好";
    }

    @Autowired
    Car car;

    @RequestMapping("/car")
    public Car car() {
        return car;
    }
}

运行springboot程序，访问可以发现成功把配置文件中的值注入到对象里了，绑定成功了

Spring全家桶--SpringBoot_第13张图片

第二种配置文件绑定的方式

@Component+@ConfigurationProperties这种方式需要手动的把要绑定的类注册到容器中，如果是外部的类的话很不方便

@EnableConfigurationProperties(Car.class)+@ConfigurationProperties

其中@EnableConfigurationProperties(Car.class)能实现

1.开启car配置绑定功能

2.把这个car组件自动注册到容器中

@Configuration
@EnableConfigurationProperties(Car.class)
public class Myconfig {}

@ConfigurationProperties(prefix = "mycar")
public class Car {}

2.3 自动配置原理入门

2.3.1 回顾注解

什么是元注解?

元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。它的作用和目的就是给其他普通的标签进行解释说明的。

Retention 的英文意为保留期的意思。当 @Retention 应用到一个注解上的时候，它解释说明了这个注解的的存活时间。

它的取值如下：

  • RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
  • RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM 中。
  • RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到 JVM 中，所以在程序运行时可以获取到它们。

@Documented有什么用？

@Documented 保存到javadoc

顾名思义，这个元注解肯定是和文档有关。它的作用是能够将注解中的元素包含到 Javadoc 中去。（Javadoc用于描述类或者方法的作用）

@Target 限定使用场景
Target 是目标的意思，@Target 指定了注解运用的地方。当一个注解被 @Target 注解时，这个注解就被限定了运用的场景。类比到标签，原本标签是你想张贴到哪个地方就到哪个地方，但是因为 @Target 的存在，它张贴的地方就非常具体了，比如只能张贴到方法上、类上、方法参数上等等。

@Target 有下面的取值:

  1. ElementType.ANNOTATION_TYPE 可以给一个注解进行注解
  2. ElementType.CONSTRUCTOR 可以给构造方法进行注解
  3. ElementType.FIELD 可以给属性进行注解
  4. ElementType.LOCAL_VARIABLE 可以给局部变量进行注解
  5. ElementType.METHOD 可以给方法进行注解
  6. ElementType.PACKAGE 可以给一个包进行注解
  7. ElementType.PARAMETER 可以给一个方法内的参数进行注解
  8. ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举

@Inherited 注解继承

Inherited 是继承的意思，它的意思是@Inherited注解了B注解，B再注解别人，那么如果它的子类没有被任何注解应用的话，那么这个子类就继承了超类的注解，代码来解释。

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@interface Test {}

@Test
public class A {}

public class B extends A {}

注解 Test 被 @Inherited 修饰，之后类 A 被 Test 注解，类 B 继承 A,类 B 也拥有 Test 这个注解。

2.3.2 @SpringBootConfiguration

这是注解@SpringBootConfiguration的源码，因为@Inherited注解

所以@SpringBootApplication注解的类继承了这个超类的三个注解@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

image-20220211114648764

之后我们在分别看这三个注解

Spring全家桶--SpringBoot_第14张图片

原来@SpringBootConfiguration是@Configuration是用来表示类为配置类的

2.3.3 @ComponentScan

Spring部分就学过，是知道扫描哪些，spring注解

2.3.4 @EnableAutoConfiguration

EnableAutoConfiguration的目的是启动SpringBoot的自动配置机制。

Spring全家桶--SpringBoot_第15张图片

  • @AutoConfigurationPackage：自动配置包
  • @Import：给IOC容器导入组件

@AutoConfigurationPackage

我们可以发现，依靠的还是@Import注解，再点进去查看，我们发现重要的就是以下的代码：

Spring全家桶--SpringBoot_第16张图片

它的作用就是在默认的情况下将主配置类(@SpringBootApplication)的所在包及其子包里边的组件扫描到Spring容器中。

这个扫描的和Component扫描的对象不同

比如说，你用了Spring Data JPA，可能会在实体类上写@Entity注解。这个@Entity注解由@AutoConfigurationPackage扫描并加载，而我们平时开发用的@Controller/@Service/@Component/@Repository这些注解是由ComponentScan来扫描并加载的。

@Import(AutoConfigurationImportSelector.class)

使用Import自动导入所有符合自动配置条件的Bean定义并加载到IOC容器

2.3.5 总结

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

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

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

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

  • 定制化配置

    • 用户直接自己@Bean替换底层的组件
    • 用户去看这个组件是获取的配置文件什么值就去修改。

2.4 开发小技巧

2.4.1 lombok

lombok能简化JavaBean的开发

在pom文件里添加依赖

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

并在idea中下载插件

Spring全家桶--SpringBoot_第17张图片

以前的getset方法我们不用写了，通过注解@Data,它就可以在编译的时候自动生成getset方法了

Spring全家桶--SpringBoot_第18张图片

@NoArgsConstructor//为JavaBean添加无参构造
@AllArgsConstructor//为JavaBean添加有参构造
@Data
@ToString
public class Pet {
    private String name;
}

Slf4j

简化日志开发

添加@Slf4j注解既有此功能

Spring全家桶--SpringBoot_第19张图片

2.4.2 dev-tools

项目或者页面修改以后：Ctrl+F9；

修改后的页面效果就会立马显示出来

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

2.4.3 Spring Initailizr

这个功能能帮我们快速构建SpringBoot项目

如下：

Spring全家桶--SpringBoot_第20张图片

Spring全家桶--SpringBoot_第21张图片

选中想要开发的项目需要的组件

Spring全家桶--SpringBoot_第22张图片

目录结构直接给我们创建好了，而且SpringBoot的启动程序也写好了

我们只需要关注逻辑代码即可~

Spring全家桶--SpringBoot_第23张图片

三、SpringBoot2核心功能

3.1 配置文件

3.1.1 properties

就是正常的配置文件，和前面学的一样

3.1.2 yaml

3.1.简介

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

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

这个我太熟悉了啊，当时在专科的时候参加云计算竞赛，要写容器编排。我搁那天天练这个啊，当时也不知道格式啥的，就是死记硬背。

我想说的是，这个很重要，后面学ansible的时候也会用到这个，给爷狠学！！！

基本语法

  • key: value；kv之间有空格

  • 大小写敏感

  • 使用缩进表示层级关系

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

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

  • '#'表示注释

  • 字符串无需加引号，如果要加，’'与""表示字符串内容 会被 转义/不转义

数据类型

  • 字面量：单个的、不可再分的值。date、boolean、string、number、null
k: v
  • 对象：键值对的集合。map、hash、set、object
行内写法：  k: {k1:v1,k2:v2,k3:v3}#或k:   k1: v1  k2: v2  k3: v3
  • 数组：一组按次序排列的值。array、list、queue
行内写法：  k: [v1,v2,v3]#或者k: - v1 - v2 - v3

示例

person:  userName: zs  boss: true  birth: 2019/12/9  age: 18#  interests: [唱,跳,rap]  interests:    - 唱    - 跳    - rap#  集合也可以跟数组一样用-的形式来表示#  也可以写成[]的形式  animal: [Cat,Dog]#  map的两种写法#  score:#    english: 99#    math: 80#  score: {english:90,math:78}#   这里面的冒号后面不用跟空格，因为这是json的表示方法# 也可以写成键值对的形式{k:V,K:V}  score: {english:90,math:78}  salarys:    - 9999.98    - 9999.97  pet:    name: dog    weight: 99.97  allPets:    sick:#     以下这两种都表示对象，分别是k:v的形式和{}的形式      - {name: dog,weight: 34}      - name: cat        weight: 23    health:      - {name: A,weight: 10}      - {name: B,weight: 20}

访问测试

Spring全家桶--SpringBoot_第24张图片

配置提示

自定义的类和配置文件绑定一般没有提示。

导入一个依赖即可~

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

之后就能愉快的自动提示了

Spring全家桶--SpringBoot_第25张图片

3.2 Web开发

3.2.1 静态资源访问

只要静态资源放在类路径下： called /static (or /public or /resources or /META-INF/resources

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

原理： 静态映射/**

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

Spring全家桶--SpringBoot_第26张图片

启动成功后，直接访问 当前项目根路径/ + 静态资源名

Spring全家桶--SpringBoot_第27张图片

改变默认的静态资源路径

改变为AAA文件为静态资源文件夹

Spring全家桶--SpringBoot_第28张图片

webjar

WebJars是一个很神奇的东西，可以让大家以jar包的形式来使用前端的各种框架、组件。

完成依赖添加

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

进行测试

可以尝试CTRL+f9快速编译

记得重启之后在访问，便可访问web静态资源了

Spring全家桶--SpringBoot_第29张图片

3.2.2 欢迎页支持

静态资源路径下 index.html

  • 可以配置静态资源路径

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

就是把index页面放到静态资源目录下，他会自动访问这个页面

如果访问不了，记得clean一下（Maven插件clean功能）

Spring全家桶--SpringBoot_第30张图片

3.2.3 自定义Favicon

favicon.ico 放在静态资源目录下即可更换网站图标

设置静态资源访问路径会导致 Favicon 功能失效

Spring全家桶--SpringBoot_第31张图片

3.2.4 请求映射

@xxxMapping

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

以前访问资源路径:

  • /getUser 获取用户
  • /deleteUser 删除用户
  • /editUser 修改用户
  • /saveUser 存用户

现在访问资源路径:

/user

  • GET-获取用户
  • DELETE-删除用户
  • PUT-修改用户
  • POST-保存用户

核心Filter; HiddenHttpMethodFilter

SpringBoot中手动开启

#开启rest风格在springboot里要手动开启
spring:
  mvc:
    hiddenmethod:
      filter:
        enabled: true

表单

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
测试REST风格
<form action="/user" method="get">
    <input value="REST-GET 提交" type="submit">
form>

<form action="/user" method="post">
    <input value="REST-POST 提交" type="submit">
form>

表单method=post, 隐藏域 _method=put 
<form action="/user" method="post">
    <input name="_method" type="hidden" value="put">
    <input value="REST-put 提交" type="submit">
form>

<form action="/user" method="post">
    <input name="_method" type="hidden" value="DELETE">
    <input value="REST-delete 提交" type="submit">
form>
body>
html>

3.2.5 普通参数与基本注解

基本注解：

@PathVariablev 获取路径变量

@RequestHeader 获取请求头

@RequestParams 获得请求参数

@CookieValue 获取Cookie的值

@RequestBody 获取请求体

DOCTYPE html><html lang="en"><head>    <meta charset="UTF-8">    <title>Titletitle>head><body>测试REST风格<form action="/user" method="get">    <input value="REST-GET 提交" type="submit">form><form action="/user" method="post">    <input value="REST-POST 提交" type="submit">form><form action="/user" method="post">    <input name="_method" type="hidden" value="put">    <input value="REST-put 提交" type="submit">form><form action="/user" method="post">    <input name="_method" type="hidden" value="DELETE">    <input value="REST-delete 提交" type="submit">form><hr>测试基本注解<ur>    <a href="car/3/owner/zs?age=18&interest=girl&interest=boy">car/{id}}/owner/{username}a>    <li>@PathVariable(路径变量)li>    <li>@RequestHeader（获取请求头）li>    <li>@RequestParam（获取请求参数）li>    <li>@CookieValue（获取cookie）li>    <li>@RequestAttribute（获取request域属性）li>    <li>@RequestBody（获取请求体）li>    <li>@MatrixVariable（矩阵变量）li>ur><form action="/save" method="post">    测试@RequestBody注解<br>    用户名:<input name="UserName"><br>    邮箱：<input name="email"><br>    <input type="submit" value="提交">form>body>html>

@GetMapping用于将HTTP get请求映射到特定处理程序的方法注解
具体来说，@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。

@PostMapping用于将HTTP post请求映射到特定处理程序的方法注解
具体来说，@PostMapping是一个组合注解，是@RequestMapping(method = RequestMethod.POST)的缩写

package com.caq.boot.controller;import org.springframework.web.bind.annotation.*;import sun.management.Agent;import java.util.HashMap;import java.util.List;import java.util.Map;@RestControllerpublic class ParameterController {    @GetMapping("/car/{id}/owner/{username}")    public Map<String,Object> getCar(@PathVariable("id") Integer id,                                     @PathVariable("username") String username,                                     @PathVariable Map<String,String> pv,                                     @RequestHeader("user-Agent") String userAgent,                                     @RequestHeader Map<String,String> header,                                     @RequestParam("age") Integer age,                                     @RequestParam("interest") List<String> interest,                                     @RequestHeader Map<String,String> param                                     ){        /*        @CookieValue("_ga")        传入一个Map可以接受所有的参数        @PathVariable带key了就拿特点的，不带了就拿所有的        @RequestHeader同上         */        HashMap<String, Object> map = new HashMap<>();        map.put("id",id);        map.put("username",username);//        map.put("pv",pv);//        map.put("userAgent",userAgent);//        map.put("header",header);//        map.put("age",age);//        map.put("interest",interest);        map.put("param",param);        map.put("_ga",_ga);        return map;    }    @PostMapping("/save")    public Map postMethod(@RequestBody String content){        HashMap map = new HashMap<>();        map.put("content",content);        return map;    }}

3.2.6 视图解析流程

  1. 目标方法处理的过程中，所有数据都会被放在ModelAndViewContainer 里面。包括数据和视图地址
  2. 方法的参数是一个自定义类型对象（从请求参数中确定的），把他重新放在 ModelAndViewContainer
  3. 任何目标方法执行完成以后都会返回 ModelAndView（数据和视图地址）
  4. processDispatchResult 处理派发结果（页面改如何响应）

视图解析：

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

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

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

3.2.7 Thymeleaf

为什么用Thymeleaf？

JSP不好用，Thymeleaf好用它适用于SpringBoot模块。它使用html作为模板页，通过html一些特殊标签语法代表其含义，不破坏html的结构

Spring全家桶--SpringBoot_第32张图片

Thymeleaf是一款现代化、服务端Java模板引擎

Thymeleaf是Springboot官方支持的模板引擎，有着动静分离等独有特点

  • Thymeleaf的主要目标是为您的开发工作流程带来优雅自然的模板-HTML可以在浏览器中正确显示，也可以作为静态原型工作，从而可以在开发团队中加强协作。
  • Thymeleaf拥有适用于Spring Framework的模块，与您喜欢的工具的大量集成以及插入您自己的功能的能力，对于现代HTML5 JVM Web开发而言，Thymeleaf是理想的选择——尽管它还有很多工作要做。
  1. 基本语法
表达式名字 语法 用途
变量取值 ${…} 获取请求域、session域、对象等值
选择变量 *{…} 获取上下文对象值
消息 #{…} 获取国际化等值
链接 @{…} 生成链接
片段表达式 ~{…} jsp:include作用，引入公共页面片段
标签 作用 示例
th:id 替换id
th:text 文本替换

bigsai
th:utext 支持html的文本替换

content
th:object 替换对象
th:value 替换值
th:each 迭代
th:href 替换超链接 超链接
th:src 替换资源

2. thymeleaf使用

我们只需要给request域中放一些数据，然后跳转到页面我们就能通过thymeleaf来取得这些值

引入依赖包

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

控制层代码

package com.caq.boot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class ViewTestController {

    @GetMapping("/thymeleaf")
    public String forwardTest(Model model){
        //model中的数据会被放在请求域中 request.setAttribute("a",aa)
        model.addAttribute("message","你好thymeleaf");
        model.addAttribute("link","http://www.baidu.com");
        return "success";
    }
}

html页面

DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title >Titletitle>
head>
<body>
<h1 th:text="${message}">哈哈h1>
<h2>
    <a href="www.jd.com" th:href="${link}">去百度a>
    <a href="www.jd.com" th:href="@{link}">去百度a>
h2>
body>
html>

补充：

假如在这个页面上有一个请求，url 为 “showAgain”

那么访问全 url 就是：http://localhost:8080/first/showAgain 相对路径，就是show.html 同级目录

假如在这个页面上有一个请求，url 为 “/showAgain”

那么访问全 url 就是 http://localhost:8080/showAgain 绝对路径，就是从根目录 拼接 url

@GetMapping("/responsive_table")
public String responsive_table(){
    return "table/responsive_table";
}

Spring全家桶--SpringBoot_第33张图片

3.2.8 SpringBoot实战

学了这么多我们来用SpringBoot构建一个后台管理系统

我们只关注业务逻辑的实现，前端代码展示不关注

1. SpringBoot项目创建

选中web开发常用的组件

thymeleaf、web-starter、devtools、lombok

2. 静态资源处理

自动配置好，我们只需要把所有静态资源放到static文件夹下即可

3. 路径构建

th:action="@{/login}"

4. 模板抽取

因为left side和header section部分所有的页面都是一样的，所以我们抽取出来一个公共部分，需要的这段代码的地方直接引用公共代码，这样让我们的代码更加简介。

怎么抽取呢？

我们用thymeleaf，fragment类似于JSP的tag，在html中文件中，可以将多个地方出现的元素块用fragment包起来使用。

  1. th:insert:保留自己的主标签，保留th:fragment的主标签。
  2. th:replace:不要自己的主标签，保留th:fragment的主标签。
  3. th:include:保留自己的主标签，不要th:fragment的主标签。（官方3.0后不推荐）
<div th:insert="footer :: copy">div>  
<div th:replace="footer :: copy">div>  
<div th:include="footer :: copy">div>

结果为：

<div>  
    <footer>  
       the content of footer   
    footer>    
div>    

<footer>  
    the content of footer 
footer>    

<div>  
    the content of footer 
div>

5. 页面跳转

如果账户密码匹配了就把账号密码封装到User对象中然后把对象保存到session域，以便后面的页面根据是否登录做判断。

密码匹配保存对象重定向至新页面

不配通过thymeleaf传入渲染后的数据到view层提示账号或密码错误之后返回到登录页

@PostMapping("/login")
public String main(User user, HttpSession session, Model model){

    if(StringUtils.hasLength(user.getUserName()) && "123456".equals(user.getPassword())){
        //把登陆成功的用户保存起来
        session.setAttribute("loginUser",user);
        //登录成功重定向到main.html;  重定向防止表单重复提交
        return "redirect:/main.html";
    }else {
        model.addAttribute("msg","账号密码错误");
        //回到登录页面
        return "login";
    }
}

3.2.9 拦截器

SpringBoot中的拦截器和我们javaweb阶段学的filter很像

拦截器就是用来拦截请求，根据拦截规则进行放行

拦截器的使用步骤

  1. 编写一个拦截器实现HandlerInterceptor接口
  2. 拦截器注册到容器中（实现WebMvcConfigurer的addInterceptors）
  3. 指定拦截规则（如果是拦截所有，静态资源也会被拦截）

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

package com.caq.admin.interceptor;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * 登录检查
 * 配置拦截器要拦截哪些请求
 * 把配置放在容器中
 */
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
    /**
     * 目标方法执行前
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String requestURI = request.getRequestURI();
        log.info("拦截的请求是"+requestURI);
        //        登录检查逻辑
        HttpSession session = request.getSession();

        Object loginUser = session.getAttribute("loginUser");
        if (loginUser != null){
            return true;
        }

        //拦截住，未登录，跳转到登录页
//        session.setAttribute("msg","Please login");
        request.setAttribute("msg","Please Login！！！");
        request.getRequestDispatcher("/").forward(request,response);
        return false;
    }

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

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

2.拦截器注册到容器中（实现WebMvcConfigurer的addInterceptors）

  • 指定拦截规则（如果是拦截所有，静态资源也会被拦截）
package com.caq.admin.config;

import com.caq.admin.interceptor.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 编写一个拦截器实现HandlerInterceptor接口
 * 拦截器注册到容器中（实现WebMvcConfigurer的addInterceptors）
 * 指定拦截规则（如果是拦截所有，静态资源也会被拦截）
 */
@Configuration
public class AdminWebConfig implements WebMvcConfigurer {

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

3.测试

我们访问main页面进行测试，原来写的拦截规则就可以去掉了，因为拦截器会帮我们自动拦截。

为了测试拦截器的常用方法的执行顺序我们在访问main页面的时候进行日志打印，查看我们访问main页面时所执行的方法

  @GetMapping("/main.html")
    public String mainPage(HttpSession session,Model model){
        log.info("当前方法是：{}","mainPage");
//        //是否登录，拦截器，过滤器
//        Object loginUser = session.getAttribute("loginUser");
//        if (loginUser != null){
            return "main";
//        }else {
//            model.addAttribute("msg","请重新登陆");
//            return "login";
//        }
    }

测试一：直接访问main页面

我们直接访问main页面进行测试，发现拦截器帮我们拦截了下来并提示我们需要先登录才能访问

Spring全家桶--SpringBoot_第34张图片

测试二：登录之后，查看拦截器方法的执行顺序

preHandle在目标方法执行前执行

目标方法执行

postHandle在目标方法执行后执行

afterCompletion在页面渲染后执行

Spring全家桶--SpringBoot_第35张图片

3.2.10 文件上传功能

MultipartFile headerImg 允许上传单个文件

MultipartFile[] photos 允许上传多个文件

表单代码

<form method="post" action="/upload" enctype="multipart/form-data">
    <input type="file" name="file"><br>
    <input type="submit" value="提交">
form>

控制层代码

package com.caq.admin.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.multipart.MultipartFile;

/**
 * 文件上传测试
 */
@Slf4j
@Controller
public class FormTestController {

    @GetMapping("/form_layouts")
    public String form_layouts(){
        return "form/form_layouts";
    }

    @PostMapping("/upload")
    public String upload(@RequestParam("email") String email,
                         @RequestParam("username") String username,
                         @RequestPart("headerImg")MultipartFile headerImg,
                         @RequestPart("photos")MultipartFile[] photos){
        log.info("上传的信息:email={},username={}.headerImg={},photos={}",email,username,headerImg.getSize(),photos.length);

        return "main";
    }


}

测试结果为

Spring全家桶--SpringBoot_第36张图片

3.2.11 异常处理

官网给出的解释如下：

默认情况下，Spring Boot提供/error处理所有错误的映射

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

Spring全家桶--SpringBoot_第37张图片

我们自定义错误页的时候，可以通过thymeleaf把错误信息打印到错误页面

<section class="error-wrapper text-center">
    <h1><img alt="" src="images/404-error.png">h1>
    <h2 th:text="${status}">page not foundh2>
    <h3 th:text="${message}">We Couldn’t Find This Pageh3>
    <a class="back-btn" th:href="@{/main.html}"> Back To Homea>
section>

Spring全家桶--SpringBoot_第38张图片

Spring全家桶--SpringBoot_第39张图片

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

error/404.html error/5xx.html；有精确的错误状态码页面就匹配精确，没有就找 4xx.html；如果都没有就触发白页

3.2.12 Web原生组件注入

简单API的使用，不用过多说明。会用即可

使用Servlet API

@ServletComponentScan(“com.caq.admin”) 指定原生的servlet组件都放在哪里

@WebServlet(urlPatterns = “/my”) 直接响应，没有经过spring的拦截器

@WebListener

@WebFilter(urlPatterns = {"/css/","/images/"})

只有结合这几个注解开发，我们的原生组件才能注入过来

日常开发推荐以上这种方式

使用RegistrationBean

@Configuration
public class MyRegistConfig {

    @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(){
        MySwervletContextListener mySwervletContextListener = new MySwervletContextListener();
        return new ServletListenerRegistrationBean(mySwervletContextListener);
    }
}

3.2.13 嵌入式Servlet容器

  • 默认支持的webServer

    • Tomcat, Jetty, or Undertow
    • ServletWebServerApplicationContext 容器启动寻找ServletWebServerFactory 并引导创建服务器
<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-tomcatartifactId>
        exclusion>
    exclusions>
dependency>

原理

  • SpringBoot应用启动发现当前是Web应用。web场景包-导入tomcat

  • web应用会创建一个web版的ioc容器 ServletWebServerApplicationContext

  • ServletWebServerApplicationContext 启动的时候寻找 ServletWebServerFactory``（Servlet 的web服务器工厂---> Servlet 的web服务器）

  • SpringBoot底层默认有很多的WebServer工厂；TomcatServletWebServerFactory, JettyServletWebServerFactory, or UndertowServletWebServerFactory

  • 底层直接会有一个自动配置类。ServletWebServerFactoryAutoConfiguration

  • ServletWebServerFactoryAutoConfiguration导入了ServletWebServerFactoryConfiguration（配置类）

  • ServletWebServerFactoryConfiguration 配置类 根据动态判断系统中到底导入了那个Web服务器的包。（默认是web-starter导入tomcat包），容器中就有 TomcatServletWebServerFactory

  • TomcatServletWebServerFactory 创建出Tomcat服务器并启动；TomcatWebServer 的构造器拥有初始化方法initialize---this.tomcat.start();

  • 内嵌服务器，就是手动把启动服务器的代码调用（tomcat核心jar包存在）

3.2.14 SpringBoot原理套路

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

3.3 数据访问

3.3.1 数据源的自动配置

我们发现只要导入jdbc场景，SpringBoot就会自动给我们导入HiKariDS

HiKariDS它是性能最好的数据源

导入JDBC场景

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

Spring全家桶--SpringBoot_第40张图片

导入jdbc之后并没有导入数据库的驱动，是因为官方不知道我们要导入什么数据库

之后数据库的版本要和驱动版本对应

Spring全家桶--SpringBoot_第41张图片

有两种修改方式

  1. 重新声明版本（maven的属性的就近优先原则）

  2. 直接依赖引入具体版本（maven的就近依赖原则）

Spring全家桶--SpringBoot_第42张图片

配置文件

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

测试

@Slf4j
@SpringBootTest
class AdminSystemApplicationTests {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Test
    void contextLoads() {
        Long aLong = jdbcTemplate.queryForObject("select count(*) from user", Long.class);
        log.info("总数有"+aLong);
    }

}


2022-02-19 11:50:03.332  INFO 7200 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2022-02-19 11:50:03.804  INFO 7200 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
2022-02-19 11:50:04.120  INFO 7200 --- [           main] c.caq.admin.AdminSystemApplicationTests  : Started AdminSystemApplicationTests in 4.476 seconds (JVM running for 6.428)

2022-02-19 11:50:04.521  INFO 7200 --- [           main] c.caq.admin.AdminSystemApplicationTests  : 总数有5

3.3.2 使用Druid数据源

修改默认的数据源步骤：

  1. 导入第三方数据源
  2. 设置配置类
  3. 测试
<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.1.17version>
dependency>

@Configuration
public class MyDataSourceConfig {

    //把组件的东西和配置文件的东西进行绑定
    @ConfigurationProperties("spring.datasource")
    @Bean
    public DataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
}

@Slf4j
@SpringBootTest
class AdminSystemApplicationTests {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() {
        Long aLong = jdbcTemplate.queryForObject("select count(*) from user", Long.class);
        log.info("总数有"+aLong);
        log.info("数据源类型：{}",dataSource.getClass());
    }

}


...........
2022-02-19 12:12:09.644  INFO 16124 --- [           main] c.caq.admin.AdminSystemApplicationTests  : 总数有5
2022-02-19 12:12:09.644  INFO 16124 --- [           main] c.caq.admin.AdminSystemApplicationTests  : 数据源类型：class com.alibaba.druid.pool.DruidDataSource

开启druid监控功能

步骤：

  1. 配置监控页，开启监控功能
  2. sql查询进行测试
@Configuration
public class MyDataSourceConfig {

    //把组件的东西和配置文件的东西进行绑定
    @ConfigurationProperties("spring.datasource")
    @Bean
    public DataSource dataSource() throws SQLException {
        DruidDataSource druidDataSource = new DruidDataSource();

        //加入监控功能
        druidDataSource.setFilters("stat");

        return druidDataSource;
    }

    /**
     * 配置druid的监控页
     * @return
     */
    @Bean
    public ServletRegistrationBean statViewServlet(){
        StatViewServlet statViewServlet = new StatViewServlet();
        ServletRegistrationBean<StatViewServlet> registrationBean = new ServletRegistrationBean<>(statViewServlet,"/druid/*");

        return registrationBean;
    }
}

@Autowired
JdbcTemplate jdbcTemplate;

@ResponseBody
@GetMapping("/sql")
public String queryFormDb()   {
    Long aLong = jdbcTemplate.queryForObject("select count(*) from user", Long.class);

    return aLong.toString();
}

Spring全家桶--SpringBoot_第43张图片

Spring全家桶--SpringBoot_第44张图片

使用官方starter方式

使用官方的stater方式之后，我们就不用写配置类了。所有的功能设置我们都可以由配置文件来完成

所有功能开启参照如下步骤即可：

  1. 引入依赖
  2. 设置配置文件
  3. 测试

引入druid-starter

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

设置配置文件

写配置文件这种方式简化了我们去写配置类往spring容器中注入组件这种方式，因为它们有自动配置功能…

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mp
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver
    druid:
      aop-patterns: com.caq.admin.* # 监控SpringBean

      filters: stat,wall  # 底层开启功能，stat（sql监控），wall（防火墙）

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

      web-stat-filter:
        enabled: true
        url-pattern: /*
        exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'

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

测试

功能都被完整的开启了

Spring全家桶--SpringBoot_第45张图片

3.3.3 整合Mybatis操作

引入依赖：

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

Spring全家桶--SpringBoot_第46张图片

原生操作

  • 创建实体类
  • 写mybatis主配置文件
  • 写接口
  • 写mapper映射文件
  • 获得sqlsession
  • 测试

SpringBoot整合Mybatis

释放了mybatis-config.xml文件,通过yml文件中的指定来替换。数据库映射mapper.xml文件通过在接口上写@Mapper注解和方法上写注解的方式实现

yml文件

mybatis:
#  通过yml配置文件的方式解放了mybatis-config.xml文件
  configuration:
    map-underscore-to-camel-case: true #开启驼峰命名

Mapper接口

package com.caq.admin.mapper;

import com.caq.admin.bean.Account;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;

//通过写@Mapper注解的方式释放了写mapper.xml映射文件的方式

@Mapper
public interface AccountMapper {

    @Select("select * from account where id = #{id}")
    Account test(Long id);

}

service层

package com.caq.admin.service;

import com.caq.admin.bean.Account;
import com.caq.admin.mapper.AccountMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AccountService {

    @Autowired
    AccountMapper accountMapper;

    public Account getAcc(Long id){
        return accountMapper.test(id);
    }
}

controller层

@Controller
@Slf4j
public class IndexController {
    @Autowired
    AccountService accountService;

    @ResponseBody
    @GetMapping("/account")
    public Account getAccount(@RequestParam("id") Long id){
        return accountService.getAcc(id);
    }
}

测试

Spring全家桶--SpringBoot_第47张图片

3.3.4 整合Mybatis-Plus完成CRUD

引入mp依赖

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

Spring全家桶--SpringBoot_第48张图片

编写mysql数据源信息

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/mybatis-plus?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

编写实体类

package com.pyy.mp.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

编写Mapper接口继承BaseMapper

@Repository和@Controller、@Service、@Component的作用差不多，都是把对象交给spring管理。

@Repository用在持久层的接口上，这个注解是将接口的一个实现类交给spring管理。

package com.pyy.mp.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pyy.mp.pojo.User;
import org.springframework.stereotype.Repository;

@Repository
public interface UserMapper extends BaseMapper<User> {

}

在我们学习MP的时候，直接写个mapper就好了。但是在我们的web开发阶段，我们将Mapper分成service接口和实现类。面向接口编程使程序更灵活，逻辑更清楚

面向接口编程是先把客户的业务逻辑线提取出来，作为接口，业务具体实现通过该接口的实现类来完成。当客户需求变化时，只需编写该业务逻辑的新的实现类，通过更改配置文件中该接口的实现类就可以完成需求，不需要改写现有代码，减少对系统的影响。（这个概念的理解很重要，先记着后面实践的时候会越来越清晰！）

package com.caq.admin.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.caq.admin.bean.User;

public interface UserService extends IService<User> {
}







package com.caq.admin.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.caq.admin.bean.User;
import com.caq.admin.mapper.UserMapper;
import org.springframework.stereotype.Service;

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

}

在SpringBoot启动类中添加MapperScan注解扫描Mapper类

因为MP是第三方技术，要和Spring整合的话需要交给Spring来管理。所以一定要加@MapperScan注解在SB启动类上

package com.pyy.mp;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan("com.pyy.mp")
@SpringBootApplication
public class MpApplication {

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

}

测试

package com.caq.admin.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.caq.admin.bean.User;
import com.caq.admin.service.impl.UserServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.List;

@Controller
public class testController {

    //    @Autowired
//    UserService userService;
//    @Autowired
//    UserMapper userMapper;

    @Autowired
    UserServiceImpl userServiceImpl;

    @GetMapping("/")
    public String test1(@RequestParam(value = "pn",defaultValue = "1") Integer pn, Model model) {
//        List list = userService.list(null);
//        model.addAttribute("users",list);
//        List list = userMapper.selectList(null);
//        model.addAttribute("users",list);
        List<User> list = userServiceImpl.list(null);
//        model.addAttribute("users",list);

//        分页数据
        Page<User> userPage = new Page<>(pn,2);

//        分页查询的结果
        IPage<User> page = userServiceImpl.page(userPage, null);

        long current = page.getCurrent();
        long pages = page.getPages();
        long total = page.getTotal();
        List<User> records = page.getRecords();

        model.addAttribute("page",page);

        return "a";
    }

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

    <table>
        <thead>
        <tr>
            <th>#th>
            <th>idth>
            <th>nameth>
            <th>ageth>
            <th>emailth>
            <th>操作th>
        tr>
        thead>
        <tbody>
        <tr th:each="user,stat:${page.records}">
            <td th:text="${stat.count}">序号td>
            <td th:text="${user.id}">idtd>
            <td th:text="${user.name}">nametd>
            <td th:text="${user.age}">agetd>
            <td th:text="${user.email}">emailtd> 
            <td>
                <a th:href="@{/user/delete/{id}(id=${user.id})}" type="button">删除button>
            td>
        tr>
        tbody>
    table>
    当前第[[${page.current}]]页  总计 [[${page.pages}]]页  共[[${page.total}]]条记录
    <ul>
        <li><a href="#">← 前一页a>li>
        <li th:each="num:${#numbers.sequence(1,page.pages)}">
            <a th:href="@{/(pn=${num})}">[[${num}]]a>
        li>
        <li><a href="#">下一页 → a>li>
    ul>

html>

为了提高访问速度，我写了个简陋的前端页面，但是实现了RD功能

完成CRUD功能需要很多thymeleaf知识点，不是我们学习重点，所以现写到RD功能

Spring全家桶--SpringBoot_第49张图片

3.4 单元测试

3.4.1 Junit5的变化

Junit5是SpringBoot2.2.0版本后开始引入的默认单元测试默认库

Spring全家桶--SpringBoot_第50张图片

以前：

@SpringBootTest + @RunWith(SpringTest.class)

SpringBoot整合Junit以后。

  • 编写测试方法：@Test标注（注意需要使用junit5版本的注解）
  • Junit类具有Spring的功能，@Autowired、比如 @Transactional 标注测试方法，测试完成后自动回滚

3.4.2 Junit5常用注解

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

  • @ParameterizedTest :表示方法是参数化测试，下方会有详细介绍

  • @RepeatedTest :表示方法可重复执行，下方会有详细介绍

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

  • @BeforeEach :表示在每个单元测试之前执行

  • @AfterEach :表示在每个单元测试之后执行

  • @BeforeAll :表示在所有单元测试之前执行

  • @AfterAll :表示在所有单元测试之后执行

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

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

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

  • @ExtendWith :为测试类或测试方法提供扩展类引用

import org.junit.jupiter.api.Test; //注意这里使用的是jupiter的Test注解！！


public class TestDemo {

  @Test
  @DisplayName("第一次测试")
  public void firstTest() {
      System.out.println("hello world");
  }

3.4.3 断言

简单的断言

断言（assertions）是测试方法中的核心部分，用来对测试需要满足的条件进行验证。这些断言方法都是 org.junit.jupiter.api.Assertions 的静态方法。JUnit 5 内置的断言可以分成如下几个类别：

检查业务逻辑返回的数据是否合理。

所有的测试运行结束以后，会有一个详细的测试报告；

方法 说明
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());
}

数组断言

通过 assertArrayEquals 方法来判断两个对象或原始类型的数组是否相等

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

组合断言

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

@Test
@DisplayName("assert all")
public void all() {
 assertAll("Math",
    () -> assertEquals(2, 1 + 1),
    () -> assertTrue(1 > 0)
 );
}

异常断言

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

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

}

超时断言

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

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

快速失败

通过 fail 方法直接使得测试失败

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

3.4.4 前置条件（assumptions）

JUnit 5 中的前置条件（assumptions【假设】）类似于断言，不同之处在于不满足的断言会使得测试方法失败，而不满足的前置条件只会使得测试方法的执行终止。前置条件可以看成是测试方法执行的前提，当该前提不满足时，就没有继续执行的必要。

@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 对象才会被执行；当条件不满足时，测试执行并不会终止。

3.4.5 嵌套测试

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

@DisplayName("A stack")
class TestingAStackDemo {

    Stack<Object> stack;

    @Test
    @DisplayName("is instantiated with new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
    }

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

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")
        void isEmpty() {
            assertTrue(stack.isEmpty());
        }

        @Test
        @DisplayName("throws EmptyStackException when popped")
        void throwsExceptionWhenPopped() {
            assertThrows(EmptyStackException.class, stack::pop);
        }

        @Test
        @DisplayName("throws EmptyStackException when peeked")
        void throwsExceptionWhenPeeked() {
            assertThrows(EmptyStackException.class, stack::peek);
        }

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

            String anElement = "an element";

            @BeforeEach
            void pushAnElement() {
                stack.push(anElement);
            }

            @Test
            @DisplayName("it is no longer empty")
            void isNotEmpty() {
                assertFalse(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when popped and is empty")
            void returnElementWhenPopped() {
                assertEquals(anElement, stack.pop());
                assertTrue(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when peeked but remains not empty")
            void returnElementWhenPeeked() {
                assertEquals(anElement, stack.peek());
                assertFalse(stack.isEmpty());
            }
        }
    }
}

3.5.6 参数化测试

参数化测试是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() {
    return Stream.of("apple", "banana");
}

3.5 指标监控

3.5.1 SpringBoot Actuator

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

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

1.0和2.0的区别

Spring全家桶--SpringBoot_第51张图片

如何使用

  1. 引入场景

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

  3. 暴露所有监控信息为HTTP

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

  4. 测试

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/endpointName/detailPath

可视化

https://github.com/codecentric/spring-boot-admin

3.5.2 Actuator Endpoint

最常使用的端点

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：日志记录

Health Endpoint

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

重要的几点：

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

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

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

访问如下网址即可查看健康检查

localhost:8080/actuator/health

Spring全家桶--SpringBoot_第52张图片

Metrics Endpoint

metrics 度量

Endpoint 端点

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

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

  • 简化核心Metrics开发

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

Spring全家桶--SpringBoot_第53张图片

管理Endpoint

开启与禁用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

暴露Endpoints

支持的暴露方式

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

  • JMX：默认暴露所有Endpoint

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

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

3.5.3 定制Endpoint

定制 Health 信息

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;

@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();
        }
        return Health.up().build();
    }

}

构建Health
Health build = Health.down()
                .withDetail("msg", "error service")
                .withDetail("code", "500")
                .withException(new RuntimeException())
                .build();
management:
    health:
      enabled: true
      show-details: always #总是显示详细信息。可显示每个模块的状态信息

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

    }
}

定制info信息

常用两种方式

  1. 编写配置文件
info:
  appName: boot-admin
  version: 2.0.1
  mavenProjectName: @project.artifactId@  #使用@@可以获取maven的pom文件值
  mavenProjectVersion: @project.version@
  1. 编写InfoContributor
import java.util.Collections;

import org.springframework.boot.actuate.info.Info;
import org.springframework.boot.actuate.info.InfoContributor;
import org.springframework.stereotype.Component;

@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信息

3.6 原理解析

3.6.1 Profile功能

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

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

  • 指定环境配置文件 application-{env}.yaml

  • 激活指定环境

    • 配置文件激活
    • 命令行激活：java -jar xxx.jar –spring.profiles.active=prod --person.name=haha
      • 修改配置文件的任意值，命令行优先

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

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

测试

package com.caq.admin.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController02 {

    //${}是取值运算符，之后的：后面的意思是默认值
    @Value("${person.name:ls}")
    private String name;

    @GetMapping("/test2")
    public String hello(){
        return "hello" + name;
    }
}

默认配置文件application.yml

为空

#person.name=zs

生产环境配置文件application-prod.yml

person:
  name: prod-zs

测试环境配置文件application-test.yml

person:
  name: test-zs

启动SpringBoot，访问测试

package com.caq.admin;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan("com.caq.admin")
@SpringBootApplication
public class SbMpApplication {

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

}

Spring全家桶--SpringBoot_第54张图片

默认配置文件application.yml

为空

#person.name=zs
spring:
  profiles:
    active: test

生产环境配置文件application-prod.yml

person:
  name: prod-zs
  
server:
  port: 8080

测试环境配置文件application-test.yml

person:
  name: test-zs
  
server:
  port: 8000

Spring全家桶--SpringBoot_第55张图片

3.6.2 外部化配置

Profile功能

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

  1. application-profile功能

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

  • 指定环境配置文件 application-{env}.yaml

  • 激活指定环境

    • 配置文件激活
    • 命令行激活：java -jar xxx.jar –spring.profiles.active=prod --person.name=haha
      • 修改配置文件的任意值，命令行优先

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

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

  1. @Profile条件装配功能
@Configuration(proxyBeanMethods = false)
@Profile("production")
public class ProductionConfiguration {

    // ...

}
  1. profile分组
spring.profiles.group.production[0]=proddb
spring.profiles.group.production[1]=prodmq

使用：--spring.profiles.active=production  激活

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

  • 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
  • 面向对象面向过程 3213213333332132 java
    面向对象：把要完成的一件事，通过对象间的协作实现。 面向过程：把要完成的一件事，通过循序依次调用各个模块实现。 我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。 1、面向对象 package bigDemo.ObjectOriented; /** * 大象类 * * @Description * @author FuJian
  • Java Hotspot: Remove the Permanent Generation bookjovi HotSpot
      openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122   JEP 122: Remove the Permanent Generation Author Jon Masamitsu Organization Oracle Created 2010/8/15 Updated 2011/
  • 正则表达式向前查找向后查找,环绕或零宽断言 dcj3sjt126com 正则表达式
    向前查找和向后查找 1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。     对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。 2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
  • BaseDao 171815164 seda
    import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.PreparedStatement; import java.sql.ResultSet; public class BaseDao { public Conn
  • Ant标签详解--Java命令 g21121 Java命令
            这一篇主要介绍与java相关标签的使用         终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。           1
  • [简单]代码片段_电梯数字排列 53873039oycg 代码
           今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下:       import java.util.Arrays; public class 电梯数字排列_S3_Test { public static void main(S
  • Hessian原理 云端月影 hessian原理
    Hessian 原理分析 一．      远程通讯协议的基本原理 网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
  • 区分Activity的四种加载模式----以及Intent的setFlags aijuans android
      在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。 这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。 加载模式分类及在哪里配置 Activity有四种加载模式： standard singleTop
  • hibernate几个核心API及其查询分析 antonyup_2006 html.netHibernatexml配置管理
    (一)  org.hibernate.cfg.Configuration类         读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.)         Configuration co
  • PL/SQL的流程控制 百合不是茶 oraclePL/SQL编程循环控制
    PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有   流程控制; 分支语句 if 条件 then 结果 else 结果 end if ; 条件语句 case when 条件 then 结果; 循环语句 loop
  • 强大的Mockito测试框架 bijian1013 mockito单元测试
    一.自动生成Mock类        在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类  &nbs
  • 精通Oracle10编程SQL(11)开发子程序 bijian1013 oracle数据库plsql
    /* *开发子程序 */ --子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用 --PL/SQL有两种类型的子程序：过程和函数 --开发过程 --建立过程：不带任何参数 CREATE OR REPLACE PROCEDURE out_time IS BEGIN DBMS_OUTPUT.put_line(systimestamp); E
  • 【EhCache一】EhCache版Hello World bit1129 Hello world
    本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍   环境准备 1.新建Maven项目   2.添加EhCache的Maven依赖 <dependency> <groupId>ne
  • 学习EJB3基础知识笔记 白糖_ beanHibernatejbosswebserviceejb
    最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。   EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
  • angular.bootstrap boyitech AngularJSAngularJS APIangular中文api
    angular.bootstrap 描述：     手动初始化angular。     这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。   使用方法：     angular .
  • java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数 bylijinnan java
    public class SearchInShiftedArray { /** * 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。 * 请在这个特殊数组中找出给定的整数。 * 解答： * 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
  • 天使还是魔鬼？都是我们制造 ducklsl 生活教育情感
    ----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！     从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！     自己挑了两部先看了看，但是发现看完之后，心里久久不能平
  • [机器智能与生物]研究生物智能的问题 comsci 生物
          我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别....       但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
  • 获取Android Device的信息 dai_lm android
    String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT; phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI; phoneInfo += ", TAGS: " + android.os.Build.TAGS; ph
  • 最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现 datamachine java算法字符串匹配
    原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
  • 小学5年级英语单词背诵第一课 dcj3sjt126com englishword
    long 长的 show 给...看，出示 mouth 口，嘴 write 写   use 用，使用 take 拿，带来 hand 手 clever 聪明的   often 经常 wash 洗 slow 慢的 house 房子   water 水 clean 清洁的 supper 晚餐 out 在外   face 脸，
  • macvim的使用实战 dcj3sjt126com macvim
    macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳   1. 下载macvim https://code.google.com/p/macvim/   2. 了解macvim :h               vim的使用帮助信息 :h macvim  
  • java二分法查找 蕃薯耀 java二分法查找二分法java二分法
    java二分法查找 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 11:40:03 星期二 http:/
  • Spring Cache注解+Memcached hanqunfeng springmemcached
    Spring3.1 Cache注解  依赖jar包： <!-- simple-spring-memcached --> <dependency> <groupId>com.google.code.simple-spring-memcached</groupId> <artifactId>simple-s
  • apache commons io包快速入门 jackyrong apache commons
    原文参考 http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html   Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍：   1）  工具类   2
  • 如何学习编程 lampcy java编程C++c
    首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
  • 架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy nannan408 Spring3
    1.前言。    如题。 2.描述。    @DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。 @DependsOn({"steelAxe","abc"}) @Comp
  • Spring4+quartz2的配置和代码方式调度 Everyday都不同 代码配置spring4quartz2.x定时任务
    前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API……   quartz定时任务必须搞清楚几个概念： JobDetail——处理类 Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
  • Hibernate入门 tntxia Hibernate
      前言   使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。   Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。   如
  • Math类 xiaoxing598 Math
    一、Java中的数字（Math）类是final类，不可继承。 1、常数 PI：double圆周率 E：double自然对数 2、截取（注意方法的返回类型） double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数 int round(float f) 返回四舍五入后的整数 long round
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他