Spring Boot - SpringBoot 技术总结【推荐】 - 《Java架构技术》

SpringBoot 基础应用
SpringBoot原理深入
Springboot整和Mybatis
- 使用配置文件的方式：
Spring Boot 整合 Redis
SpringBoot视图技术
- Thymeleaf
SpringBoot项目部署

SpringBoot 基础应用

SpringBoot约定优于配置的设计，springboot的设计是为了尽快的跑起来spring应用程序，并且尽可能减少你的配置文件。约定优于配置：其实就是一种约定编程，是一种软件设计范式。

Spring的优缺点

spring优点：
- spring是Java企业版的(J 2EE)轻量级的代替品,无需开发重量级的Enterprise Java Bean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象实现了EJB的功能
spring缺点
- spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，spring用xml配置，而且是很多xml配置。spring2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显示xml配置。spring3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替xml。这些配置都代表了开发时的损耗，因为在思考spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的事件，spring的实用，但它要求的回报也不少。
- 项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖版本，不兼容问题会验证阻碍项目的开发进度。例如SSM整合：spring、springmvc、Mybatis、Spring-Matis整合包、数据库驱动等引入数量繁多、容易存在版本冲突。

SpringBoot的出现就是为了解决上述spring的问题

SpringBoot对上述Spring的缺点进行了改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发效率，一定程度上缩短了项目周期。

起步依赖

起步依赖本质上是一个Maven项目对象模型(POM),定义了对其他库的传递依赖，这些东西加载一起即支持某项功能。起步依赖就是将具备某种功能的依赖坐标打包到一起，并提供了一些默认的功能，这些依赖是没有兼容问题的。

自动配置

SpringBoot的自动配置，指的是SpringBoot会自动将一些配置类的bean注册进IOC容器，我们可以需要的地方使用@autowired或者@resource等注解来使用。
“自动”的表现形式就是我们只需要引我们想用功能的包，相关的配置不用管，springBoot会自动注入这些配置bean，我们可以直接使用这些bean即可。
所以SpringBoot：简单、快速、方便地搭建项目；对主流开发框架的无配置集成；极大提高了开发、部署效率

SpringBoot 初体验

使用传统的开发方式，创建一个maven项目
打开官网https://docs.spring.io/spring-boot/docs/2.4.3/reference/html/ 查看如何构建springboot项目
引入springBoot的依赖包

spring-boot-starter-parent 是一个父依赖，所有的springboot项目都会间接或直接的继承
spring-boot-starter-web springMVC相关的功能，在之前学习springMVC是需要配置web.xml 和 spring-mvc.xml 以及需要创建webapp/的目录，而springBoot提供的web依赖不需要在配置直接使用jar包即可。
spring-boot-maven-plugin 是编译项目打包为一个可执行的jar

 <!--  引入springBoot
        所有springboot项目会直接或者间接的继承spring-Boot-start-parent
        1.指定项目的编码格式为UTF-8
        2.指定JDK版本为1.8
        3.对项目依赖的版本进行管理,当前项目再引入其他常用的依赖时就需要再指定版本号，避免版本冲突的问题
        4.默认的资源过滤和插件管理
      -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
    </parent>
    <dependencies>
        <!-- 引入spring web 及springMVC相关的依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!-- 该插件可以将project打包为一个可以执行的jar 项目运行插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

编写Controller

如下代码和之前springMVC是一模一样的使用方式

@RestController
@RequestMapping("/hello")
public class HelloController {

    @GetMapping("/boot")
    public String hello() {
        return "hello spring boot";
    }
}

SpringBoot的启动类

注意 springBoot的启动类一般都要放在包的二级目录下：因为springboot为自动扫描启动类所在包及其子包下的所有内容

/**
 * @program: springboot-demo
 * @Description: springBoot的启动类，通常放在二级包中比如：com.prim.SpringBootDemo1Application
 * springboot项目会自动的包扫描，会扫描启动类所在的包及其子包下的所有内容
 * @author: sufulu
 * @version: 1.0.0
 * @create: 2021-02-27 23:11
 * @PackageName: com.prim
 * @ClassName: SpringBootDemo1Application.java
 **/
//标识当前类为springBoot项目的启动类
@SpringBootApplication
public class SpringBootDemo1Application {
    public static void main(String[] args) {
        /**
         * 第一个参数：springBoot的启动类的class
         * 第二个参数：main方法的参数
         * 样板代码
         */
        SpringApplication.run(SpringBootDemo1Application.class, args);
    }
}

SpringBoot 快速构建

上述我们构建了一个springBoot的项目，项目构建确实比SSM构建要快速，但是还是需要进行一定的配置。所以SpringBoot提供了Spring Initializr方式快速构建springboot项目。必须联网在开发工具指定各项参数后，由spring提供的URL所对应的服务器生成，生成之后IDEA下载到本地工作空间中。

点击下一步：进行如下的选择和配置

选择需要用到的功能：这里选择Spring Web.

生成的项目结构如下：

修改端口号：在配置文件application.properties中添加如下

server.port=8081

SpringBoot的单元测试

单元测试依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

springboot的单元测试实现：

//@RunWith(SpringJUnit4ClassRunner.class)//运行器,Spring的测试环境
@RunWith(SpringRunner.class)//运行器,SpringBoot的测试环境
@SpringBootTest
//标记当前类为springboot的测试类，加载项目的ApplicationContext上下文环境
class Springbootdome2ApplicationTests {

    @Autowired
    private HelloController helloController;

    @Test
    void contextLoads() {
        String hello = helloController.hello();
        System.out.println(hello);
    }

}

SpringBoot热部署

在开发过程中，通常会修改一段业务代码，在修改之后往往需要重启服务，有些服务需要很久才能启动成功，这种不必要的重复操作极大的降低了程序开发效率。SpringBoot框架提供了热部署，无需手动重启项目。

添加SpringBoot的热部署依赖

<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-devtools</artifactId>
     </dependency>

开启IDEA的自动编译

开启IDEA在运行中自动编译的功能

快捷键：command + option + shift + / 打开如下的对话框，勾选如下图选项

修改项目代码后，如果出现了：Completed initialization 则说明热部署成功了。

Spring Boot全局配置文件

SpringBoot中使用一个application.properties或者application.yaml或yml 作为全局配置文件，该文件存在在src/main/resource目录或者类路径的/config,一般都会选择resource目录下。

我们可以从SpringBoot的源码中看到如下：定义了配置文件的几种方式，必须符合如下的表达式

application.properties配置

数据库的配置,jdbcTemplate

引入数据库驱动和jdbcTemplate的相关依赖

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

配置数据源信息：

# 修改Tomcat的版本号
server.port=8081
# 定义数据库的链接信息 JdbcTemplate
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/spring_db
spring.datasource.username=root
spring.datasource.password=123456

测试是否能获取到jdbcTemplate对象：

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @GetMapping("/jdbc")
    public String jdbc() {
        return jdbcTemplate.toString();
    }

application.properties自定义配置属性注入到实体类的对应属性中

首先创建两个实体类：

public class Pet {
    //品种
    private String type;
    //名称
    private String name;
}

@Component
//将配置文件中所有以person开头的配置信息注入当前类中
//前提1:必须要保证配置文件中person.xx与当前Person类的属性名一致
//前提2：必须保证当前person中的数据都具有set方法
@ConfigurationProperties(prefix = "person")
public class Person {
    private int id;
    private String name;
    private List hobby;
    private String[] family;
    private Map map;
    private Pet pet;
}

application.properites文件中自定义配置

# 自定义配置信息 注入到Person对象中
person.id=100
person.name=sd
# list类型
person.hobby=喝酒,抽烟,烫头
# 数组类型
person.family=妻,妾
# map类型
person.map.k1=v1
person.map.k2=v2
# 对象类型
person.pet.type=dog
person.pet.name=旺财

调用Person查看配置信息: 通过@Autowired即可获取Person，因为Person是通过Component spring生成Person对象保存在IOC容器中。

    @Autowired
    private Person person;

    @Test
    void contextLoads() {
        System.out.println(person);
    }

解决配置文件中文乱码的问题：

通过IDEA 配置

通过在properties文件中配置
```
# 解决中文乱码
server.tomcat.uri-encoding=utf-8
server.servlet.encoding.force=true
server.servlet.encoding.charset=UTF-8
server.servlet.encoding.enabled=true
```
application.yaml配置文件
:::tips springboot的三种配置文件是可以共存的，也就是说同时配置三种配置文件都会生效。springboot可以存在0-N个配置文件，但是名称必须是application*.yml/yaml/properties ::: 使用方式如下： ```yaml server: port: 8081 person: id: 100 name: 郭德纲 hobby:
- play
- 抽烟
- 喝酒 family:
- 郭麒麟
- 郭小宝 map: k1: v1 k2: v2 pet: type: dog name: 金毛


<a name="eSRMm"></a>
#### 配置文件属性值的注入
在上述我们使用`@ConfigurationProperties(prefix="person")` 注入属性，还有另外一种是项目开发中常用的使用`@Value()` 注入属性，代码如下：
```java
@Component
public class Student {
    // 通过注入配置文件的person.id的值
    @Value("${person.id}")
    private int number;
    @Value("${person.name}")
    private String name;
}

:::tips @Value注解对于包含Map集合、对象以及YAML格式的行内式写法的配置文件的属性注入都不支持，如果强行赋值会出现错误。
错误信息：Could not resolve placeholder ‘person.hobby’ in value “${person.hobby}” :::

注意：如果properties和yml配置文件同时存在那么，properties的优先级要高于yml，properties会覆盖yml相同的配置信息。

自定义配置

使用@PropertiesSource

自定义配置文件：my.properties

product.id=99
product.name=huawei

读取自定义配置文件：

@Component
@PropertySource("classpath:my.properties")//通过该注解加载自定义的配置文件
@ConfigurationProperties(prefix = "product")//配置属性注入
public class Product {
    private int id;
    private String name;
}

使用@Configuration编写自定义配置类

在springboot框架中，推荐使用配置类的方式向容器中添加和配置组件。通常使用@Configuration注解定义一个配置类，SpringBoot会自动扫描和识别配置类，从而代替传统spring框架中的xml配置文件。还需要在配置类中的方法上使用@Bean注解进行组件配置，将方法的返回对象注入到Spring容器中，并且组件名称默认使用的是方法名，也可以使用@Bean注解的name或value属性自定义组件的名称。

@Configuration //标识当前类是一个配置类，springboot会扫描该类，将所有标识@Bean注解的返回值注入到容器中
public class MyConfig {

    @Bean //注入的名称就是方法的名称，注入的类型就是返回值的类型
//    @Bean(name = "myservice2") //注入的名称就是方法的名称，注入的类型就是返回值的类型
    public MyService myService() {
        return new MyService();
    }
    @Bean("service_")
    public MyService myService2(){
        return new MyService();
    }
}

测试类,查询IOC容器中是否存在：

    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void testConfig() {
        System.out.println(applicationContext.containsBean("service_"));//true
    }

SpringBoot原理深入

针对springBoot的依赖管理、自动配置进行深入分析。

依赖管理

为什么导入dependency时不需要指定版本？

在springboot入门程序中，项目pom.xml文件spring-boot-starter-parent统一父项目依赖进入该pom文件，可以找到：

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.4.3</version>
  </parent>

上述代码，spring-boot-starter-parent的父项目是spring-boot-dependencies 进入该pom文件：可以看到这里面定义了各种版本信息，而且这些版本是没有兼容性问题的。

我们再看spring-boot-starter-parent

spring-boot-starter-parent父依赖启动器的作用主要是进行版本统一管理。

具体的jar包依赖，是由具体的starter引入的例如：spring-boot-starter-web 依赖启动器的主要作用就是提供Web
开发地城的所有依赖，而引入依赖的版本号由spring-boot-starter-parent父依赖进行的统一管理。springBoot还提供了各种功能场景的启动器。
Spring Boot官方并不是针对所有场景开发的技术框架都提供了场景启动器，例如数据库操作框架MyBatis、阿里巴巴的Druid数据源等，Spring Boot官方就没有提供对应的依赖启动器。为了充分利用Spring Boot框架的优势，在Spring Boot官方没有整合这些技术框架的情况下，MyBatis、Druid等技术框架所在的开发团队主动与Spring Boot框架进行了整合，实现了各自的依赖启动器，例如mybatis-spring-boot-starter、druid-spring-boot-starter等。我们在pom.xml文件中引入这些第三方的依赖启动器时，切记要配置对应的版本号。

自动配置

关于springboot的自动配置，我们就需要分析项目的启动类：

@SpringBootApplication
public class Springbootdome2Application {

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

}

启动类中主要有两个一个是@SpringBootApplication 注解和 SpringApplication.run()方法
首先我们看@SpringBootApplication

@Target({ElementType.TYPE})//注解的适用范围，Type表示注解可以描述在类、接口、注解或枚举中
@Retention(RetentionPolicy.RUNTIME)//表示注解的生命周期，Runtime运行时
@Documented//表示注解可以记录在java doc 中
@Inherited//表示可以被子类继承该注解
@SpringBootConfiguration//表明该类为配置类
@EnableAutoConfiguration//启动自动配置功能
// 扫描组件
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    //根据class来排除特定的类，使其不能加入spring容器，传入参数value类型是class类型
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};

    // 根据classname来排除特定的类，使其不能加入spring容器。
    //传入参数value类型是class的全类名字符串数组
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};

    // 指定扫描包，参数是包名的字符串数组
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};

    // 扫描特定的包，参数类似是class类型数组
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};

    // 
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "nameGenerator"
    )
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    // 
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

@SpringBootConfiguration 注解：

该注解上有一个@Configuration注解，在上述和spring的时候讲到过，这个注解表示是一个配置类

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration // 配置类的作用等同于配置文件，配置类也是容器中的一个对象
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

@SprngBootConfiguration的作用与@Configuration注解相同，都是标识一个可以被组件扫描器扫描的配置类.只不过被重新包装了作为主配置类。

再看EnableAutoConfiguration

开启自动配置功能，以前需要我们配置的数据，由springBoot帮助我们自动配置。这个注解就是SpringBoot实现自动配置的关键。

@AutoConfigurationPackage //自动配置包

// spring的底层@Import 给容器中导入一个组件：
// 导入的组件是AutoConfigurationPackages.Registrar.class
@Import({AutoConfigurationImportSelector.class})

// 该注解告诉springBoot开启自动配置功能，自动配置才能生效
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    // 表示返回不会被导入到spring容器的类
    Class<?>[] exclude() default {};
    // 返回不会被导入到spring容器中的类名
    String[] excludeName() default {};
}

可以发现它是一个组合注解，Spring中很多以Enable开头的注解，其作用就是借助@Import 来收集并注册特定场景相关的Bean,并加载到IOC容器。@EnableAutoConfiguration 就是借助@import来收集所有复合自动配置条件的bean定义，并加载到IOC容器。

@AutoConfigurationPackage 注解

该注解内部源码信息，代码具体如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class) 导入Registrar中的注册的组件
public @interface AutoConfigurationPackage {
}

@AutoConfigurationPackage 注解的功能是由@Import注解实现的，它是Spring框架的底层注解，它的作用就是给容器中导入某个组件类。将Registrar这个组件类导入到容器中，可查看Registrar类中的registerBeanDefinitions方法

    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

        @Override
        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
        }

        @Override
        public Set<Object> determineImports(AnnotationMetadata metadata) {
            return Collections.singleton(new PackageImports(metadata));
        }

    }

@AutoConfigurationPackage注解的作用就是将主程序类所在包及所有子包下的组件扫描到spring容器中。

因此在定义项目包结构时，要求定义的包结构非常规范，项目主程序启动类要定义在最外层的根目录位置，然后在根目录位置内部建立子包和类进行业务开发，这样才能够保证定义的类能够被组件扫描器扫描。

@Import(AutoConfigurationImportSelector.class) 注解

该注解就是将AutoConfigurationImportSelector类导入到IOC容器中，该类可以帮助springboot应用将所有符合条件的@Configuration配置都加载到当前Springboot创建并使用的IOC容器中。
继续分析这个类，该类通过selectImports 方法告诉springboot都需要导入哪些组件

    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        }
        AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }

查看getAutoConfigurationEntry()方法

    protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        //判断EnabledAutoConfiguration注解有没有开启，默认开启
        if (!isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        }
        //获得注解的属性信息
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        //获取默认支持的自动配置类列表
        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        //去重
        configurations = removeDuplicates(configurations);
        //去除一些多余的配置类，根据EnabledAutoConfiguration的exculusions属性进行排除
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        //根据pom文件中加入的依赖文件筛选最终符合当前项目运行环境对应的自动配置类
        configurations = getConfigurationClassFilter().filter(configurations);
        //触发自动配置导入监听事件
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationEntry(configurations, exclusions);
    }

查看getCandidateConfigurations方法：里面有一个重要的方法loadFactoryNames，这个方法是让SpringFactoryLoader去加载一些组件的名字

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {

        //这个方法需要传入两个参数getSpringFactoriresLoaderFactoryClass()和getBeanClassLoader()
        //getSpringFactoriresLoaderFactoryClass() 方法返回的是EnableAutoConfiguration.class
        //getBeanClassLoader() 这个方法返回的是beanClassLoader 类加载器

        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
                getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
                + "are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

loadFactoryNames方法@EnableAutoConfiguration从classpath搜寻META-INF/spring.factories配置文件。

并将其中org.springframework.boot.autoconfigure.EnableAutoConfiguration 对应的配置项通过反射实例化为对应的标注了@Configuration的JavaConfig形式的配置类，并加载到IOC容器中

在上述我们引入了starter-web 那么对应的web的环境依赖启动器，对应WebMvcAutoConfiguration``` 自动配置就会生效，如下是自动配置类，通过@Configuration`的javaConfig的方式进行配置的。

总结

springboot底层实现自动配置的步骤是：

springboot应用启动
@SpringBootApplication起作用
@EnableAutoConfiguration
@AutoConfigurationPackage 这个组合注解主要是@Import(Registrar.class) 将Registrar类导入到IOC容器中，而Registrar类作用是扫描主配置类同级目录以及子包，并将相应的组件导入到springBoot创建管理的容器中
@import(AutoConfigurationImportSelector.class) 将AutoConfigurationImportSelector

类导入容器中，AutoConfigurationImportSelector类作用是通过selectImports方法执行的过程中，会使用内部工具类SpringFactoriesLoader，查找classpath上所有jar包中的META-INF/spring.factories进行加载，实现将配置类信息交给SpringFactory加载器进行一系列的容器创建过程

@ComponentScan注解具体扫描的包的根路径由Spring Boot项目主程序启动类所在包位置决定，在扫描过程中由前面介绍的@AutoConfigurationPackage注解进行解析，从而得到Spring Boot项目主程序启动类所在包的具体位置

|- @SpringBootConfiguration
 |- @Configuration //通过javaConfig的方式来添加组件到IOC容器中
|- @EnableAutoConfiguration
 |- @AutoConfigurationPackage //自动配置包，与@ComponentScan扫描到的添加到IOC 
 |- @Import(AutoConfigurationImportSelector.class) //到META-INF/spring.factories中定义的bean添加到IOC容器中 
|- @ComponentScan //包扫描

Springboot整和Mybatis

创建一个新的moudle,选择如下的配置

数据源配置，在application.yml中进行配置如下：

spring:
datasource:
 url: jdbc:mysql://localhost:3306/springbootdata?serverTimezone=UTC&characterEncoding=UTF-8
 username: root
 password: 123456

创建POJO类

public class Comment {
 private Integer id;
 private String content;
 private String author;
 private String aId;
}

创建mapper包，新建CommentMapper接口,使用Mybatis注解的方式实现

public interface CommentMapper {
 @Select("select * from t_comment where id=#{id}")
 Comment findById(String id);
}

在启动类中，添加@MapperScan

@SpringBootApplication
//扫描mapper包 生成对应的动态代理类 注入到IOC容器中
@MapperScan("com.prim.springbootdata.mapper")
public class SpringbootDataApplication {
 public static void main(String[] args) {
     SpringApplication.run(SpringbootDataApplication.class, args);
 }
}

在application.yml中配置，开启mybatis驼峰命名匹配的映射
```
mybatis:
configuration:
 map-underscore-to-camel-case: true # 开启驼峰命名
```
:::success Comment{id=1, content=’很全、很详细’, author=’lucy’, aId=’1’} :::

使用配置文件的方式：

使用Free Mybatis Plugin 插件快速生成映射文件

mybatis 配置映射文件，然后就可以直接使用了

mybatis:
configuration:
 map-underscore-to-camel-case: true # 开启驼峰命名
mapper-locations: classpath:mapper/*.xml # 加载映射文件
type-aliases-package: com.prim.springbootdata.pojo # 配置实体类别名

Spring Boot 整合 Redis

引入Redis启动器

     <!-- redis依赖包 -->
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-redis</artifactId>
     </dependency>

redis的相关配置

spring:
datasource:
 url: jdbc:mysql://localhost:3306/springbootdata?serverTimezone=UTC&characterEncoding=UTF-8
 username: root
 password: 123456
redis: # Redis配置
 host: 172.16.160.130
 port: 6379
 database: 0 # #Redis数据库索引(默认为0)
 jedis:
   pool:
     max-active: 50 # 连接池最大连接数(使用负值表示没有限制)
     max-wait: 3000 # #连接池最大阻塞等待时间(使用负值表示没有限制)
     max-idle: 20 #连接池中的最大空闲连接
     min-idle: 2 #连接池中的最小空闲连接
 timeout: 5000 #连接超时时间(毫秒)

配置Redis的工具类 ```java @Component // 注入到IOC容器中 public class RedisUtils { @Autowired private RedisTemplate redisTemplate;

/**
- 读取缓存 *
- @return */ public Object get(final String key) { return redisTemplate.opsForValue().get(key); }
  
  /**
- 写入缓存 */ public boolean set(String key, Object value) { boolean result = false; try {
```
 //写入Redis 1天后缓存失效
 redisTemplate.opsForValue().set(key, value, 1, TimeUnit.DAYS);
 result = true;
```
  } catch (Exception e) {
```
 e.printStackTrace();
```
  } return result; }
  
  /**
- 删除缓存 */ public boolean delete(String key) { boolean result = false; try {
```
 redisTemplate.delete(key);
 result = true;
```
  } catch (Exception e) {
```
 e.printStackTrace();
```
  } return result; } }


4. 测试查看数据是否存入Redis
```java
    @Autowired
    private RedisUtils redisUtils;//IOC获取对象

    @Test
    void testRedis() {
        redisUtils.set("k1", articleDao.selectByPrimaryKey(1));
        System.out.println("success");
    }

    @Test
    void readRedis() {
        Article article = (Article) redisUtils.get("k1");
        System.out.println(article);//Article{id=1, title='Spring Boot基础入门', content='从入门到精通讲解...'}
        redisUtils.delete("k1");//
        Article article2 = (Article) redisUtils.get("k1");
        System.out.println(article2);//null
    }

SpringBoot视图技术

前端模板引擎技术的出现，使前端开发人员无需关注后端业务的具体实现，只关注自己页面的呈现效果即可，并且解决了前端代码错综复杂的问题、实现了前后端分离开发。Spring Boot框架对很多常用的模板引擎技术(如:FreeMarker、Thymeleaf、Mustache等)提供了整合支持
Spring Boot不太支持常用的JSP模板，并且没有提供对应的整合配置，这是因为使用嵌入式Servlet容器的Spring Boot应用程序对于JSP模板存在一些限制 :
在Jetty和Tomcat容器中，Spring Boot应用被打包成war文件可以支持JSP。但Spring Boot默认使用嵌入式Servlet容器以JAR包方式进行项目打包部署，这种JAR包方式不支持JSP。如果使用Undertow嵌入式容器部署Spring Boot项目，也不支持JSP模板。(Undertow 是红帽公司开发的一款基于 NIO 的高性能 Web 嵌入式服务器)
Spring Boot默认提供了一个处理请求路径“/error”的统一错误处理器，返回具体的异常信息。使用JSP模板时，无法对默认的错误处理器进行覆盖，只能根据Spring Boot要求在指定位置定制错误页面。
上面对Spring Boot支持的模板引擎进行了介绍，并指出了整合JSP模板的一些限制。接下来，对其中常用的Thymeleaf模板引擎进行介绍，并完成与Spring Boot框架的整合实现.

Thymeleaf

Thymeleaf是一种现代的基于服务器端的Java模板引擎技术，也是一个优秀的面向Java的XML、XHTML、HTML5页面模板，它具有丰富的标签语言、函数和表达式，在使用Spring Boot框架进行页面设计时，一般会选择Thymeleaf模板

使用方式如下：引入Thymeleaf依赖

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

thymeleaf 模板的参数配置

spring:
  thymeleaf:
 cache: true # 启用模板缓存
 encoding: UTF-8 # 模板编码
 mode: HTML # 应用于模板的模板模式
 prefix: classpath:/templates/ # 指定模板页面的存储路径
 suffix: .html # 指定页面模板名称的后缀

SpringBoot项目部署

需要添加打包组件将项目中的资源、配置、依赖包打到一个jar包中;可以使用maven的package ;
部署:java -jar 包名

添加打包组件

<plugins>

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

部署运行


java -jar 包名

                    <br />

SpringBoot 技术总结【推荐】

SpringBoot 基础应用

Spring的优缺点

SpringBoot的出现就是为了解决上述spring的问题

起步依赖

自动配置

SpringBoot 初体验

SpringBoot 快速构建

SpringBoot的单元测试

SpringBoot热部署

Spring Boot全局配置文件

application.properties配置

application.yaml配置文件

自定义配置

SpringBoot原理深入

依赖管理

自动配置

总结

Springboot整和Mybatis

使用配置文件的方式：

Spring Boot 整合 Redis

SpringBoot视图技术

Thymeleaf

SpringBoot项目部署