Spring Boot-基础

 

 

概念

Spring的缺点

      大量的XML配置和复杂的依赖管理。Spring项目每集成一个开源软件，就需要增加一些基础配置，配置越来越多、不易理解、容易配置出错。

什么是Spring Boot  

      Spring Boot是Pivota团队提供的全新框架，其设计目的是用来简化Spring项目的初始搭建以及开发过程，以最少的配置、最快的速度来启动和运行Spring项目。该框架使用了特定的方式来进行配置，从而使得开发人员不再需要定义样板化的配置。  

      Spring Boot默认配置了很多框架的使用方式，就像Maven整合了很多的JAR包，Spring Boot整合集成了很多第三方的框架。

Spring Boot核心思想

      Spring Boot的核心思想是：约定优于配置（即按照约定编程）。Spring Boot所有开发细节都是依据此思想进行实现，并且对已有的开发模式进行了改善，提升了开发效率。   

Spring Boot优势

• 使得开发变简单

           Spring Boot提供了丰富的各种解决方案。

• 使得配置变简单

          Spring Boot提供了丰富的starters，集成主流开源产品只需要简单的配置即可。

• 使得部署变简单

          Spring Boot本身内嵌启动容器Tomcat，只需要一个命令即可启动项目，结合Jenkins、Docker制度化运维非常容易实现。

• 使得监控变简单

       Spring Boot自带监控组件，使用Actuator轻松监控服务各项状态。

构建

1.通过Maven工程构建

      创建Maven工程，然后改造成Spring Boot工程

1.1 点击创建Maven工程

1.2 在src/main/resources目录下创建如下文件结构

• static
• templates
• application.properties或者application-xxx.yml

    如下所示：

1.3 编辑pom.xml文件

• 在pom.xml中添加Spring Boot父工程

<!-- 创建的所有的Spring Boot工程都从这里继承
      好处：统一管理依赖的组件的版本号 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.9.RELEASE</version>
</parent>

• 在pom.xml中添加maven插件

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

• 导入相关依赖组件

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

     完整的pom.xml文件如下：

<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.0</modelVersion>
  <groupId>com.hqyj</groupId>
  <artifactId>springboot</artifactId>
  <version>0.0.1-SNAPSHOT</version>

    <!-- 创建的所有的Spring Boot工程都从这里继承
        好处：统一管理依赖的组件的版本号 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.9.RELEASE</version>
    </parent>
  
    <!-- 依赖组件 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
  
    <!-- Maven插件 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
  
</project>

4.编写环境配置文件

    这里使用application.properties

#配置启动端口，默认端口号为8080
server.port=8080

5.编写Spring Boot工程启动类

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

       注意：启动类需要添加@SpringBootApplication注解。

2.直接创建Spring Boot工程

      点击Spring Starter Project创建Spring Boot工程如下：

     点击下一步，添加Web相关组件，然后Finish。自动构建完整的Spring Boot如下：

      目录结构如下所示：

• src/main/java：项目启动类和主要代码
• src/main/resources：配置信息目录
• src/test/java：测试代码

     resources目录如下：

• static：存放Web访问的静态资源，如：js、css、图片等。
• templates：目录存放页面模板
• application.properties：项目配置信息
• pom.xml：配置项目依赖包和其他配置
• mvnw文件：mvnw 全名是 Maven Wrapper。作用是当运行环境中找不到正确的 Maven 版本时，会自动下载 Maven 信息，之后再运行项目

3.通过Spring网站创建Spring Boot工程

     通过https://start.spring.io网站创建Spring Boot工程，然后下载下来，导入进STS。

运行

     上述三种方法创建项目后，运行Spring Boot项目的启动类，即可启动允许项目，从而可以访问到Controller类里面定义的路由地址。这是因为Spring Boot默认内部集成了Tomcat容器。启动类需要添加@SpringBootApplication 注解。

     同时，整个项目利用注解替代繁琐的XML配置，整个应用程序只有一个入口配置文件，就是application.yml或者application.properties。(必须存在一个以application开头的properties或者yml文件）。

     Spring Boot项目启动时就会从application的yml或者properties文件中读取配置信息，并加载到内存中。

注意事项

Controller必须放在启动类所在包或者子包中，否则扫描不到。

Spring Boot环境配置

1.概念       

        Spring Boot有两个方式配置环境，一种是properties文件，一种是yml文件。Spring Boot会对每个配置项有默认配置值，其中的一些配置项如下：

debug	默认值为false，表示是否开启调试模式
server.port	默认值为8080，表示端口号
server.servlet.context-path	表示应用的上下文，配置了该项，项目的请求地址会根据变化 如：server.servlet.context-path=/api 项目的请求地址为：http://localhost:8080/api/请求url
spring.servlet.multipart.maxFileSize	最大文件上传大小，值为-1则表示不限制
spring.http.encoding.charset	默认值为utf-8，表示字符集编码
spring.jpa.database	数据库类型 如：spring.jpa.database=MYSQL
spring.jpa.showSql	是否在控制台打印SQL语句
spring.jpa.properties.hibernate.dialect	hql方言
spring.datasource.url	数据库连接地址
spring.datasource.username	数据库用户名
spring.datasource.password	数据库密码
spring.datasource.driverClassName	数据库驱动
spring.thymeleaf.cache	默认值为true，表示是否开启页面缓存
spring.mvc.data-format	配置按照给的的时间格式，将字符串类型的日期转换成Date类型的日期
spring.jackson.date-format	配置按照给的的时间格式，将Date类型的日期序列化成JSON格式的字符串类型返回给前端
spring.jackson.time-zone	设置GMT时区，中国要晚八个时区

1.配置xxx.properties文件

      例如：

#配置启动端口，默认端口号为8080
server.port=8081

#配置应用上下文(不常用）
#server.servlet.context-path=/demo

#配置字符集编码，默认utf-8
#spring.http.encoding.charset=utf-8

#配置是否启用Thymeleaf自然模板，默认为true，SpringBoot默认支持Thymeleaf
#spring.thymeleaf.enabled=true

#配置是否启用Thymeleaf缓存，默认为true。
#若spring.thymeleaf.enabled=false，则此配置无效
#spring.thymeleaf.cache=true

#配置按照给的的时间格式，将字符串类型的日期转换成Date类型的日期
spring.mvc.date-format=yyyy-MM-dd

#配置按照给的的时间格式，将Date类型的日期序列化成JSON格式的字符串类型返回给前端
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss

#配置时区（中国时区晚8小时）
#spring.jackson.time-zone=GMT+8
#也支持如下方式配置时区
#spring.jackson.time-zone=Asia/Shanghai

2.配置xxx.yml文件

     如下：

server:
  port: 8081
  servlet:
    context-path:/api
  
spring: 
  datasource:
   #数据库连接字符串
   url: jdbc:mysql://localhost:3306/demo?serverTimezone=Asia/Shanghai
   #数据库驱动
   driver-class-name: com.mysql.cj.jdbc.Driver
   #数据库用户名
   username: root
   #数据库密码
   password: root

Spring Boot多环境配置

多环境概念     

        Spring Boot支持配置多环境。在一个Spring Boot项目的开发过程中：在开发时使用开发环境；在测试时使用测试环境；上线时使用生产环境。每个环境的配置都可能不一样，比如开发环境的数据库是本地地址，而测试环境的数据库是测试地址，因此引入多环境配置。

如何引入指定环境

        需要指定配置某个环境时，在application.properties或者yml文件中使用spring.profiles.active=环境名称，就能引入该环境（该环境配置会覆盖原有的环境配置）。

        如使用yml配置：生产环境application-pro.yml，测试环境application-test.yml，开发环境application-dev.yml。在application.properties中使用spring.profiles.active引入：

#新环境会覆盖主环境
#指定当前项目环境为生产环境
#spring.profiles.active=pro
#指定当前项目环境为测试环境
#spring.profiles.active=test
#指定当前项目环境为开发环境
spring.profiles.active=dev

拦截器

     在提供API的时候，需要对API进行统一的拦截，比如进行接口的安全性校验。拦截器的实现如下：

• 创建一个拦截器类，并实现HandlerInterceptor接口

public class ApiInterceptor implements HandlerInterceptor{
    //在请求之前执行：主要用于权限验证、参数过滤等等
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, 
                    Object o) throws Exception{
        System.out.println("请求之前执行");
        return true;
    }

    //请求时：主要用于日志记录、权限检查、性能监控等
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, 
                    Object o, ModelAndView modelAndView) throws Exception{
        //...
    }
    
    //请求完成
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
                    Object o, Exception e) throws Exception{
        //...
    }
}

• 创建类继承WebMvcConfigurationSupport

     使用@SpringBootConfiguration注解

@SpringBootConfiguration
public class WebConfig extends WebMvcConfigurationSupport{
    //注册拦截器
    @Override
    protected void addInterceptors(InterceptorRegistry registry){
        super.addInterceptors(registry);
        registry.addInterceptor(new ApiInterceptor());
    }
}

自定义JSON解析

      Spring Boot中使用@ResponseBody和@RestController注解返回的字符串默认使用Jackson引擎，自定义使用fastJSON如下所示：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.58</version>
</dependency>

      然后在WebConfig类中重写configureMessageConverters方法：

@SpringBootConfiguration
public class WebConfig extends WebMvcConfigurationSupport{
    @Override
    protected void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        super.configureMessageConverters(converters);
        /*
         1.需要先定义一个 convert 转换消息的对象；
         2.添加 fastjson 的配置信息，比如是否要格式化返回的 JSON 数据
         3.在 convert 中添加配置信息
         4.将 convert 添加到 converters 中
        */
        //1.定义一个 convert 转换消息对象
        FastJsonHttpMessageConverter fastConverter=new FastJsonHttpMessageConverter();
        //2.添加 fastjson 的配置信息，比如是否要格式化返回 JSON 数据
        FastJsonConfig fastJsonConfig=new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
        fastConverter.setFastJsonConfig(fastJsonConfig);
        converters.add(fastConverter);
    }
}

异常处理

     利用Spring的AOP的特性可以很方便的实现异常的统一处理。在Controller控制器类中添加如下方法即可：

@ExceptionHandler
public String doError(Exception ex) throws Exception{
    ex.printStackTrace();
    return ex.getMessage();
}

      使用了@ExceptionHandler注解，发生异常后就会调用该方法。这样解决了为每个方法添加try catch重复代码块问题。

单元测试

     如下：

@SpringBootTest(classes = DemoApplication.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class TestDB {
    @Test
    public void test(){
        //...
    }
}

热部署配置

    在pom.xml文件中添加如下：

<!-- 添加热部署依赖
    热部署：指的是对程序进行了修改操作时，程序会自动重启 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

Spring Date JPA

概念       

1.JPA

       JPA(Java Persistent API）是Sun官方提出的Java持久化规范，Java的持久化API。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合ORM技术

2.Spring Data JPA

       Spring Data JPA是Spring Data的一个子项目，满足JPA规范，对JPA进行了二次封装，底层采用Hibernate实现。在JPA规范下提供了Repository层的实现，虽然ORM框架都实现了JPA规范，但使用不同的ORM框架底层实现存在差异，导致系统移植性差。而通过使用Spring Data JPA提供的规范，可以在不同的ORM框架之间进行切换，而不需要修改代码。Hibernate是Spring Date JPA的默认实现

         如下图所示：

       Spring Data JPA简化了Dao操作，使得程序员将重心放在业务上。

使用

• 在pom.xml文件中引入spring-boot-starter-data-jpa

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

• 在配置文件中配置数据源和JPA参数

spring: 
  datasource:
   #数据库连接字符串
   url: jdbc:mysql://localhost:3306/demo?serverTimezone=Asia/Shanghai
   #数据库驱动
   driver-class-name: com.mysql.cj.jdbc.Driver
   #数据库用户名
   username: root
   #数据库密码
   password: root
  jpa:
    #配置是否显示SQL语句
    show-sql: true
    hibernate:
    #配置是否根据映射实体类自动建表：create每次都会创建表；update只会在没有的时候创建，有则使用。
    ddl-auto: update
    #配置数据库方言：在Hibernate的core核心包的dialect包下
    database-platform: org.hibernate.dialect.MySQL57Dialect

接口

       Spring Data JPA有四个接口：Repository接口、CrudRepository接口、PagingAndSortingRepository接口、JpaRepository接口。从右到左依次继承关系，后者拥有前者全部方法。

1.Repository接口

• 定义

       Repository是Spring Data的核心接口，属于标识接口，该接口源码定义如下:

/**
 * @see CrudRepository
 * @param <T> the domain type the repository manages
 * @param <ID> the type of the id of the entity the repository manages
 * @author Oliver Gierke
 */
@Indexed
public interface Repository<T, ID> {
}

     其中T指的是映射实体类类型，TD指的是映射实体类中主键属性的类型。

• 使用

     使用有两种方式：一种是数据访问接口类直接继承Repository接口，另一种是在数据访问接口类上使用@RepositoryDefinition注解实现继承。 Spring Data JPA要求数据访问接口类都需要继承Repository，Spring Data JPA会动态创建该数据接口类的数据访问组件，并将该组件交由Spring容器管理。

     数据访问接口类定义查询方法规则见后面。

      方式一：

    如下所示：

     学生映射实体类：

@Entity
@Table(name = "stu")
public class Student implements Serializable{
    private static final long serialVersionUID = -5852080440103183169L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;  //id
    private String name; //学生姓名
    private Character sex; //学生性别

    public Student() {}
    //get和set方法
    //toString方法
}

      定义数据接口直接继承：

/**
 * 定义学生数据访问接口
 */
public interface StudentRepository extends Repository<Student, Integer>{
    //通过学生性别查询所有学生信息
    List<Student> findBySex(Character sex);
}

       方式二：

/**
 * 定义学生数据访问接口
 */
@RepositoryDefinition(domainClass = Student.class, idClass = Integer.class)
public interface StudentRepository {
    //通过学生性别查询所有学生信息
    List<Student> findBySex(Character sex);
}

      domainClass指的是映射实体类，idClass指的是映射实体类中主键属性的类型。

• 测试

     定义测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
public class StudentRepositoryTests {
    @Autowired
    private StudentRepository studentRepository;

    @Test
    public void findBySexTest() {
        //获取到所有性别为男的学生信息
        List<Student> students = studentRepository.findBySex('男');
        //打印
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

     可以看出，并没有写什么Dao，只需要编写相应的业务方法即可。点击运行效果如下：

• Repository接口的查询方法规则定义

         具体规则如下：

Keyword	Sample	JPQL snippet
And	findByFirstnameAndLastname	...where x.firstname = ?1 and x.lastname = ?2
Or	findByFirstnameOrLastname	...where x.firstname = ?1 or x.lastname = ?2
Between	findByAgeBetween	...where x.age between 1? and ?2
LessThan	findByAgeLessThan	...where x.age < ?1
GreaterThan	findByAgeGreaterThan	...where x.age >?1
After	findByAgeAfter	...where x.age >?1
Before	findByAgeBefore	...where x.age <?1
IsNull	findByAgeIsNull	...where x.age is null
IsNotNull, NotNull	findByAge(Is)NotNull	...where x.age not null
Like	findByFirstnameLike	...where x.firstname like ?1
NotLike	findByFirstnameNotLike	...where x.firstname not like ?1
StartingWith	findByFirstnameStartingWith	...where x.firstname like ?1
EndingWith	findByFirstnameEndingWith	...where x.firstname like ?1
Containing	findByFirstnameContaining	...where x.firstname like ?1
OrderBy	findByAgeOrderByLastnameDesc	...where x.age=?1 order by x.lastname desc
Not	findByFirstnameNot	...where x.firstname <> ?1
In	findByAgeIn(Collection<Age> ages)	...where x.age in ?1
NotIn	findByAgeNotIn(Collection<Age> ages)	...where x.age not in ?1
TRUE	findByActiveTrue()	...where x.active=true
FALSE	findByActiveFalse()	...where x.active=false

         注意事项如下：

1.查询方法名必须以findBy开头

2.对于有多个参数的查询方法，参数的顺序必须保证一致。

3.当查询条件比较复杂时，必然造成查询方法的方法名过于臃肿，可以考虑在查询方法上使用@Query注解来自定义JPQL @Query注解属性如下：      value属性：指定JPQL或者SQL语句      nativeQuery属性：默认false，指定是否使用原生SQL语句。

     注意：自定义JPQL中可以使用索引参数或命名参数来占位，其中索引参数有别于HQL，从1开始计数。另外若命名参数与查询方法形参不一致时，可以使用@Parem注解来进行参数绑定。

         比如查询指定性别的员工列表信息如下：

@Query(value = "from Emp where sex=:sex")
List<Emp> selectBySex(Integer sex);

      等价于：

@Query(value = "from Emp where sex=?1")
List<Emp> selectBySex(Integer sex);

      等价于：

@Query(value = "from Emp where sex=:sex")
List<Emp> selectBySex(@Param("sex")Integer s);

2.CrudRepository接口

• 定义

       CrudRepository继承自Repository接口，源码如下：

@NoRepositoryBean
public interface CrudRepository<T, ID> extends Repository<T, ID> {
    ...
}

     该接口提供了一系列CRUD（增删改查）的方法，如下所示：

       使用CruedRepository接口的增删改操作都需要事务的支持。默认在Dao层自动使用事务支持，在业务层上则需要使用@Transactional注解来添加事务支持。

       该注解在业务组件类或业务方法上使用，用于配置声明式事务。常用属性如下：

propagation	指定事务的传播特性，默认值为Propagation.REQUIRED
isolation	指定事务的隔离级别，默认值为Isolation.DEFAULT
rollbackFor	指定回滚事务的异常类型，默认回滚RuntimeException（运行时异常），可以通过配置该属性来指定特定的回滚异常类型
noRollbackFor	指定不回滚事务的异常类型
readOnly	指定是否是只读事务

       注意：若在业务组件类上使用@Transactional注解，表示将事务应用到该业务组件类所有的业务方法上；若在业务方法上使用@Transactional注解，则表示将事务应用到该业务方法上。若同时在业务组件类上和业务方法上都使用@Transactional注解，则作用效果使用就近原则。

3.PagingAndSortingRepository接口

• 定义

      PagingAndSortingRepository继承自CrudRepository接口，源码如下：

@NoRepositoryBean
public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
    Iterable<T> findAll(Sort sort);

    Page<T> findAll(Pageable pageable);
}

     该接口提供了分页和排序的功能。

• 使用

       使用PageRequest类的方法创建分页对象Pageable。有三个重载方法：

public static PageRequest of(int page, int size)
public static PageRequest of(int page, int size, Sort sort)	注意，先排序再分页
public static PageRequest of(int page, int size, Direction direction, String... properties)
描述： page表示页码，从0开始计数，0表示第一页 size表示每页的记录数

     使用如下所示：

Pageable pageable = PageRequest.of(4, 3);

得到Pageable对象后，使用继承了PagingAndSortingRepository的数据接口组件类对象调用Page<Emp> org.springframework.data.repository.PagingAndSortingRepository.findAll(Pageable pageable)方法，得到Page<Emp>，里面包含了查询的所有记录数。

Page<Emp> pages = empPagingAndSortingRepository.findAll(pageable);

      然后可以通过Page<Emp>获取相应信息如下：

/**
 * List<T> getContent() 返回分页查询的结果集
 */
List<Emp> emps = pages.getContent();
for (Emp emp : emps) {
    System.out.println(emp);
}
System.out.println("每页记录数：" + pages.getSize());
System.out.println("总记录数：" + pages.getTotalElements());
System.out.println("总页数：" + pages.getTotalPages());
//从0开始计数
System.out.println("当前页码：" + pages.getNumber());
System.out.println("当前页的记录数" + pages.getNumberOfElements());

4.JpaRepository接口

• 定义

      JpaRepository接口继承自PagingAndSortingRepository接口，拥有全部父类方法。该接口对继承的方法的返回值进行了适配处理，如返回List<T>，建议数据访问接口类都继承JpaRepository接口，功能最强大。

       源码如下：

@NoRepositoryBean
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, 
            QueryByExampleExecutor<T> {
    List<T> findAll();

    List<T> findAll(Sort sort);

    List<T> findAllById(Iterable<ID> ids);

    <S extends T> List<S> saveAll(Iterable<S> entities);

    void flush();

    <S extends T> S saveAndFlush(S entity);

    void deleteInBatch(Iterable<T> entities);

    void deleteAllInBatch();

    T getOne(ID id);

    @Override
    <S extends T> List<S> findAll(Example<S> example);

    @Override
    <S extends T> List<S> findAll(Example<S> example, Sort sort);
}

5.JpaSpecificationExecutor<T, TD>接口

Spring Boot整合Druid数据源

1.Druid概述     

      DRUID是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、PROXOOL等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，据说是目前最好的连接池。 Spring Boot默认使用HikarPool连接池。

2.整合

• 在pom.xml中导入Druid依赖和组件自动扫描

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.20</version>
</dependency>
<!-- 组件扫描 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

• 配置DruidDataSource数据源组件

           方式一：创建配置包，然后创建配置类DruidConfiguration，而配置DruidDataSource数据源组件

@Configuration
public class DruidConfiguration {

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean(initMethod = "init", destroyMethod = "close")
    public DruidDataSource druidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}

         方式二：在启动器类中配置DruidDataSource数据源组件

     上面两个方式中，可以直接通过DruidDataSource对象设置数据库相关信息，如：dataSource.setUrl(jdbcUrl)；但是可以通过配置@ConfigurationProperties(prefix = "spring.datasource")来自动装配在环境配置文件里面配置相关信息。如：application-dev.yml

spring: 
  datasource:
   #数据库连接字符串
   url: jdbc:mysql://localhost:3306/demo?serverTimezone=Asia/Shanghai
   #数据库驱动
   driver-class-name: com.mysql.cj.jdbc.Driver
   #数据库用户名
   username: root
   #数据库密码
   password: root
   #设置初始连接数
   initial-size: 2
   #设置最大连接数
   max-active: 20
   #最小连接数
   min-idle: 2
   #设置数据源类型
   type: com.alibaba.druid.pool.DruidDataSource
  jpa:
   #配置是否显示SQL语句
   show-sql: true
   hibernate:
   #配置是否根据映射实体类自动建表:create每次都会创建表；update只会在没有的时候创建，有则使用。
     ddl-auto: update
   #配置数据库方言：在Hibernate的core核心包的dialect包下
   database-platform: org.hibernate.dialect.MySQL57Dialect

配置Druid监控视图Servlet组件

配置Druid监控请求资源拦截Filter组件

Spring Boot整合JSP

1.关闭Thymeleaf自然模板

spring.thymeleaf.enabled=false

2.配置视图解析器的前缀和后缀

spring: 
  mvc:
    view:
      #配置视图解析器的前缀
      prefix: /WEB-INF/jsp/
      #配置视图解析器后缀
      suffix: .jsp

3.添加JSP依赖和JSTL依赖

<!-- jsp依赖 -->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <scope>provided</scope>
</dependency>
<!-- jstl依赖 -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

VO DO TO PO