SpringBoot案例 ¶

集成 ¶

整合jsp ¶

• 声明SpringBoot内嵌tomcat对jsp支持依赖

  xml

  1<dependency>
  2    <groupId>org.apache.tomcat.embed</groupId>
  3    <artifactId>tomcat-embed-jasper</artifactId>
  4</dependency>

• 在main目录下创建webapp，并在包设置设定该目录为web资源目录

• SpringBoot默认支持view不是jsp，需要手动指定jsp文件编译后位置，SpringBoot规定位置为 META-INF/resources

  xml

  1<resource>
  2    <directory>src/main/webapp</directory>
  3    <targetPath>META-INF/resources</targetPath>
  4    <includes>
  5        <include>*.*</include>
  6    </includes>
  7</resource>

• 在核心配置文件中配置视图解析器

  properties

  1spring.mvc.view.prefix=/
  2spring.mvc.view.suffix=.jsp

集成mybatis（逆向工程） ¶

• 声明相关依赖，mysql驱动依赖、mybatis整合SpringBoot的起步依赖

  xml

  1<dependency>
  2    <groupId>mysql</groupId>
  3    <artifactId>mysql-connector-java</artifactId>
  4</dependency>
  5<dependency>
  6    <groupId>org.mybatis.spring.boot</groupId>
  7    <artifactId>mybatis-spring-boot-starter</artifactId>
  8    <version>2.2.0</version>
  9</dependency>

使用mybatis提供的逆向工程生成实体类、映射文件、Dao接口

• 根目录下创建generatorConfig.xml逆向工程配置文件

  xml

   1<?xml version="1.0" encoding="UTF-8"?>
   2<!DOCTYPE generatorConfiguration
   3        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
   4        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
   5
   6<generatorConfiguration>
   7<!--    mysql驱动位置 -->
   8    <classPathEntry location="G:\mysql-connector-java-8.0.25.jar" />
   9
  10    <context id="tables" targetRuntime="MyBatis3">
  11        <!-- 关闭注释生成 -->
  12        <commentGenerator>
  13            <property name="suppressAllComments" value="true" />
  14        </commentGenerator>
  15
  16        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
  17                        connectionURL="jdbc:mysql://192.168.10.129:3306/crm_manage?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"
  18                        userId="crm_manage"
  19                        password="JCRMp3LHkrSZ5y6c">
  20        </jdbcConnection>
  21
  22        <javaTypeResolver >
  23            <property name="forceBigDecimals" value="true" />
  24        </javaTypeResolver>
  25
  26        <javaModelGenerator targetPackage="com.lei.model" targetProject="src/main/java/">
  27            <property name="enableSubPackages" value="true" />
  28            <property name="trimStrings" value="true" />
  29        </javaModelGenerator>
  30
  31        <sqlMapGenerator targetPackage="com.lei.mapper"  targetProject="src/main/java/">
  32            <property name="enableSubPackages" value="true" />
  33        </sqlMapGenerator>
  34
  35        <javaClientGenerator type="XMLMAPPER" targetPackage="com.lei.mapper"  targetProject="src/main/java/">
  36            <property name="enableSubPackages" value="true" />
  37        </javaClientGenerator>
  38
  39        <table tableName="tbl_activity" domainObjectName="Activity"
  40               enableCountByExample="false"
  41               enableSelectByExample="false"
  42               enableDeleteByExample="false"
  43               enableUpdateByExample="false"
  44               selectByExampleQueryId="false"
  45        />
  46    </context>
  47
  48</generatorConfiguration>

• pom.xml中配置逆向工程插件

  xml

   1<plugin>
   2    <groupId>org.mybatis.generator</groupId>
   3    <artifactId>mybatis-generator-maven-plugin</artifactId>
   4    <version>1.4.0</version>
   5    <configuration>
   6      <!--本地逆向工程配置文件位置-->  
   7        <configurationFile>generatorConfig.xml</configurationFile>
   8        <verbose>true</verbose>
   9        <overwrite>true</overwrite>
  10    </configuration>
  11</plugin>

• 使用maven的逆向工程插件，生成对应的mapper、domain

mybatis和SpringBoot整合

1. 在mapper接口上使用注解 @Mapper 注解，将其注入到spring容器

2. 或者使用 @MapperScan(“com.lei.mapper”)注解，将其注解到主配置文件上，指定需要扫描的mapper包

3. 在 SpringBoot 核心配置文件中配置 数据库链接信息

   properties

   1spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
   2spring.datasource.url=jdbc:mysql://192.168.10.129:3306/crm_manage?useSSL=true&useUnicode=true&characterEncoding=utf8
   3spring.datasource.username=crm_manage
   4spring.datasource.password=JCRMp3LHkrSZ5y6c

4. pom.xml配置资源文件用于编译mapper.xml文件

mapper.xml存放位置，两种

• 和接口放在一起，需要在pom.xml中配置资源目录

• 直接将mapper.xml和接口分开，将mapper.xml放在 resource目录下

  • 在资源目录下创建mapper文件夹，将mapper.xml文件放进去

  • 在SpringBoot核心配置文件中指定mapper所在位置

    properties

    1mybatis.mapper-locations=classpath:mapper/*.xml

  • 不需要在pom.xml中指定资源目录

集成redis ¶

SpringBoot2.x之后，原来使用的jedis被替换成了 lettuce

区别：

• jedis：采用直连，多个线程操作的话，是不安全的，如果要避免不安全，使用jedis pool连接池，像 BIO
• lettuce：采用netty，实例可以多个线程中进行共享，不存在线程不安全的情况！可以减少线程数据，像 NIO

1. 添加依赖

   xml

   1<!-- SpringBoot集成redis起步依赖 -->
   2<dependency>
   3    <groupId>org.springframework.boot</groupId>
   4    <artifactId>spring-boot-starter-data-redis</artifactId>
   5</dependency>

2. 在SpringBoot核心配置文件中添加redis配置

   properties

   1spring.redis.host=192.168.10.129
   2spring.redis.port=6379
   3spring.redis.password=123456

3. redis起步依赖提供了一个操作redis的对象，注入操作redis的对象

   java

   1@Autowired
   2private RedisTemplate<Object,Object> redisTemplate;

4. 事务操作的实现，通过SessionCallback/RedisCallback；默认情况下：redisTemplate每次操作都是采用新的连接执行，而redisTemplate.multi()是无效的(因为连接池连接默认自动提交)，手动提交时会报错ERR EXEC without MULTI

   SessionCallback实现事务操作

   java

    1@Override
    2public void set(String key, String value) {
    3    try {
    4        Boolean execute = redisTemplate.execute(new SessionCallback<Boolean>() {
    5            @Override
    6            public Boolean execute(RedisOperations redisOperations) throws DataAccessException {
    7                redisOperations.multi();
    8                //设置缓存
    9                redisOperations.opsForValue().setIfAbsent(key, value);
   10                //设置超时时间
   11                redisOperations.expire(key, 120L, TimeUnit.SECONDS);
   12                List list = redisOperations.exec();
   13                return (Boolean) list.get(0);
   14            }
   15        });
   16    } finally {
   17        //清除缓存
   18        redisTemplate.delete(key);
   19    }
   20}

   RedisCallback实现事务操作

   java

    1public void set(String key, String value) {
    2    try {
    3        redisTemplate.execute(new RedisCallback<Boolean>() {
    4            @Override
    5            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
    6                redisConnection.multi();
    7                Expiration seconds = Expiration.seconds(60L);
    8                //如果不存在则设置值
    9                redisConnection.set(key.getBytes(),value.getBytes(),seconds, RedisStringCommands.SetOption.SET_IF_ABSENT);
   10                //设置超时时间
   11                redisConnection.expire(key.getBytes(),60L);
   12                List<Object> exec = redisConnection.exec();
   13                return null;
   14            }
   15        });
   16    }finally {
   17        //清除缓存
   18        redisTemplate.delete(key);
   19    }
   20
   21}

集成Dubbo分布式框架 ¶

dubbo简介

• 接口工程：存放实体bean和业务接口
• 服务提供者：业务接口的实现类并将服务暴露且注册到注册中心，调用数据数据持久层
  • 添加依赖：dubbo，注册中心，接口工程
  • 配置服务者核心配置文件
• 服务消费者：处理浏览器客户端发送的请求，从注册中心调用服务提供者所提供的服务
  • 添加依赖：dubbo，注册中心，接口工程
  • 配置服务消费者核心配置文件

集成步骤

1. 创建接口工程（maven项目）、创建服务提供者（SpringBoot项目）、创建服务消费者（SpringBoot项目）

2. 服务提供者

   • 添加依赖

     xml

     1<!--dubbo集成SpringBoot起步依赖-->
     2dubbo-spring-boot-starter
     3<!--注册中心依赖-->
     4zkclient
     5<!--接口工程-->

   • 核心配置文件中配置

     properties

      1#内嵌tomcat端口号
      2#设置上下文根
      3#声明当前工程名字
      4spring.application.name=
      5
      6#设置dubbo配置，注意，没有提示
      7#声明当前工程是一个服务提供者工程
      8spring.dubbo.server=true
      9#指定注册中心
     10spring.dubbo.registry=zookeeper://ip:2181

3. 服务消费者

   • 添加依赖

     xml

     1<!--dubbo集成SpringBoot起步依赖-->
     2dubbo-spring-boot-starter
     3<!--注册中心依赖-->
     4zkclient
     5<!--接口工程-->

   • 核心配置文件中配置

     properties

      1#内嵌tomcat端口号
      2#设置上下文根
      3#声明当前工程名字
      4spring.application.name=
      5
      6#设置dubbo配置，注意，没有提示
      7#声明当前工程是一个服务提供者工程
      8spring.dubbo.server=true
      9#指定注册中心
     10spring.dubbo.registry=zookeeper://ip:2181

集成logback日志 ¶

SpringBoot默认集成了logback日志框架（log4j 原意 log for java）

SpringBoot核心配置文件可以配置日志，当SpringBoot核心配置文件不够使用时，也可以引入自己扩展的日志配置文件 logback-spring.xml

SpringBoot核心配置文件与logback相关配置

1logging:
2  level:
3    #单独给mysql日志级别配置为 debug，其他的为 warn
4    com.lei.mapper: debug
5    root: info   #日志级别
6  file:
7    path: /logs    #指定日志输出的文件路径，/在windows下是直接定位到当前工作文件磁盘下的
8    name: log       #指定日志文件名
9  config: classpath:logback-spring.xml  	#指定自定义配置的logback位置

自定义扩展配置 logback-spring.xml

 1<?xml version="1.0" encoding="UTF-8"?>
 2<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
 3<!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
 4<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
 5<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
 6<configuration  scan="true" scanPeriod="10 seconds">
 7
 8    <!--输出到控制台的追加器-->
 9    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
10        <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
11        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
12            <level>DEBUG</level>
13        </filter>
14        <encoder>
15            <Pattern>%date [%-5p] [%thread] %-5level %logger{50} - %msg%n</Pattern>
16            <!-- 设置字符集 -->
17            <charset>UTF-8</charset>
18        </encoder>
19    </appender>
20
21    <!--输出到文件的追加器-->
22    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
23        <!-- 正在记录的日志文件的路径及文件名 -->
24        <file>D:/log_debug.log</file>
25        <!--日志文件输出格式-->
26        <encoder>
27            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [%-5level] %logger{50} - %msg%n</pattern>
28            <charset>UTF-8</charset> <!-- 设置字符集 -->
29        </encoder>
30        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
31        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
32            <!-- 日志归档 -->
33            <fileNamePattern>d:/debug/log-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
34            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
35                <maxFileSize>100MB</maxFileSize>
36            </timeBasedFileNamingAndTriggeringPolicy>
37            <!--日志文件保留天数-->
38            <maxHistory>10</maxHistory>
39        </rollingPolicy>
40        <!-- 此日志文件只记录debug级别的 -->
41        <filter class="ch.qos.logback.classic.filter.LevelFilter">
42            <level>debug</level>
43            <onMatch>ACCEPT</onMatch>
44            <onMismatch>DENY</onMismatch>
45        </filter>
46    </appender>
47    <!--
48        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<appender>。<logger>仅有一个name属性，一个可选的level和一个可选的addtivity属性。
49        name:用来指定受此logger约束的某一个包或者具体的某一个类。
50        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
51              还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。
52              如果未设置此属性，那么当前logger将会继承上级的级别。
53        addtivity:是否向上级logger传递打印信息。默认是true。
54    -->
55    <!--
56        使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：
57        第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
58        第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别：
59     -->
60    <logger name="com.lei.mapper" level="debug"/>
61    <!--
62        root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
63        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
64        不能设置为INHERITED或者同义词NULL。默认是DEBUG
65        可以包含零个或多个元素，标识这个appender将会添加到这个logger。
66    -->
67
68    <root level="info">
69        <appender-ref ref="CONSOLE" />
70        <appender-ref ref="DEBUG_FILE" />
71    </root>
72
73</configuration>

1. 日志级别从低到高：TRACE < DEBUG <WARN < ERROR < FATAL，设置了日志级别后，低于该级别的信息都不会输出
2. scan：此属性为 true 时，配置文件如果发生改变，将会重新加载，默认为 true
   1. scanPeriod：设置监测配置文件是否有修改的时间间隔，如果没有给出时间间隔，默认为毫秒。当 scan 为 true 时，此属性生效。默认时间间隔为 1 分钟
3. debug ：当此属性设置为true时，控制台将打印出 logback 内部日志信息，实时查看。默认值 false，通常不打印

使用swagger和lombok ¶

OAS规范，Linux基金会的一个项目，试图定义一种用来描述API格式或API定义语言，来规范RESTFUL服务开发过程

Swagger是目前最受欢迎的 OAS 规范开发工具框架；随着项目自动生成API文档（通过一些注解）

Swagger使用

1. pom.xml 添加起步依赖

   xml

    1<!--3.0导入起步依赖-->
    2<dependency>
    3    <groupId>io.springfox</groupId>
    4    <artifactId>springfox-boot-starter</artifactId>
    5    <version>3.0.0</version>
    6</dependency>
    7<!--老版本2.x导入以下依赖-->
    8<dependency>
    9    <groupId>io.springfox</groupId>
   10    <artifactId>springfox-swagger2</artifactId>
   11    <version>2.9.2</version>
   12</dependency>
   13<dependency>
   14    <groupId>io.springfox</groupId>
   15    <artifactId>springfox-swagger-ui</artifactId>
   16    <version>2.9.2</version>
   17</dependency>

2. 2.x的老版本swagger除了需要导入相关依赖，还要编写一个配置类

   java

    1@Configuration
    2@EnableSwagger2  //开启swagger2的支持
    3public class MyConfig {
    4    @Bean
    5    public Docket docket(){
    6        //链式编程，构造器模式，基本是固定的
    7        return new Docket(DocumentationType.SWAGGER_2)
    8                .apiInfo(apiInfo())
    9                .select()
   10                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))   //扫描有ApiOperation注解的方法
   11                .paths(PathSelectors.any())
   12                .build();
   13    }
   14    private ApiInfo apiInfo() {
   15        return new ApiInfoBuilder()
   16                .title("接口文档")
   17                .description("接口文档描述")
   18                .termsOfServiceUrl("https://www.lei.com")
   19                .contact(new Contact("lei","https://www.lei.com","lei@qq.com"))
   20                .license("采用api2.0开源许可证")
   21                .licenseUrl("https://www.lei.com/context.txt")
   22                .version("1.0.0")
   23                .build();
   24    }
   25}

3. 编写控制类，并使用相关注解说明，以便生成接口文档

   java

    1@Api(tags = "SpringBoot使用swagger测试")
    2@RestController
    3public class UserController {
    4    @ApiOperation(value = "获取用户信息",notes = "根据id获取用户信息")
    5    @ApiImplicitParams({
    6            @ApiImplicitParam(paramType = "path",name = "id",value = "用户id",dataTypeClass = String.class)
    7    })
    8    @ApiResponses({
    9            @ApiResponse(code = 400,message = "缺少请求参数"),
   10            @ApiResponse(code = 401,message = "请求路径没有权限"),
   11            @ApiResponse(code = 403,message = "请求路径被隐藏不能访问"),
   12            @ApiResponse(code = 404,message = "请求路径错误"),
   13            @ApiResponse(code = 405,message = "请求方法不支持")
   14    })
   15    @RequestMapping(value = "/query/{id}",method = RequestMethod.GET)
   16    public User query(@PathVariable("id") String id){
   17        User user=new User();
   18        user.setId(id);
   19        user.setName("小王");
   20        return user;
   21    }
   22
   23    @ApiOperation(value = "删除用户",notes = "根据id和用户名删除")
   24    @ApiImplicitParams({
   25            @ApiImplicitParam(paramType = "path",dataTypeClass = String.class,name = "id",value = "用户id"),
   26            @ApiImplicitParam(paramType = "path",dataTypeClass = String.class,name = "name",value = "用户姓名"),
   27    })
   28    @ApiResponses({
   29            @ApiResponse(code = 400,message = "缺少请求参数"),
   30            @ApiResponse(code = 401,message = "请求路径没有权限"),
   31            @ApiResponse(code = 403,message = "请求路径被隐藏不能访问"),
   32            @ApiResponse(code = 404,message = "请求路径错误"),
   33            @ApiResponse(code = 405,message = "请求方法不支持")
   34    })
   35    @RequestMapping(value = "/del/{id}/{name}",method = RequestMethod.POST)
   36    public String del(@PathVariable("id") String id,@PathVariable("name") String name){
   37        return "删除成功";
   38    }
   39}

4. 实体类相关注解

   java

   1@Data
   2@ApiModel(value = "User",description = "User实体类")
   3public class User {
   4    @ApiModelProperty(name = "id",value = "用户id")
   5    private String id;
   6    @ApiModelProperty(name = "name",value = "用户姓名")
   7    private String name;
   8}

5. 浏览器访问

   1. 3.0访问地址：http://localhost:8080/swagger-ui/index.html#/
   2. 2.x访问地址：http://localhost:8080/swagger-ui.html

6. SpringBoot核心配置文件关闭swagger-ui访问

   properties

   1springfox.documentation.swagger-ui.enabled=false

使用jasypt加密敏感信息 ¶

1. 导入依赖

   xml

   1<dependency>
   2    <groupId>com.github.ulisesbocchio</groupId>
   3    <artifactId>jasypt-spring-boot-starter</artifactId>
   4    <version>3.0.3</version>
   5</dependency>

2. SpringBoot核心配置文件配置加密解密的 key

   properties

   1jasypt.encryptor.password=sdjhauidasdw

3. 注入 jasypt bean，并使用加密解密功能生成 密文

   java

    1package com.lei;
    2
    3@SpringBootApplication
    4public class Application implements CommandLineRunner {
    5
    6    @Autowired
    7    private StringEncryptor stringEncryptor;	//注入加密解密的bean
    8
    9    public static void main(String[] args) {
   10        SpringApplication springApplication=new SpringApplication(Application.class);
   11        ApplicationContext context=springApplication.run();
   12        StringEncryptor stringEncryptor=context.getBean(StringEncryptor.class);
   13        String username=stringEncryptor.encrypt("root");
   14        System.out.println("username加密结果 :" + username);
   15        System.out.println("username解密结果："+stringEncryptor.decrypt(username));
   16        String password=stringEncryptor.encrypt("123456");
   17        System.out.println("password加密结果 :" + password);
   18        System.out.println("password解密结果："+stringEncryptor.decrypt(password));
   19    }
   20}
   21//输出
   22/*
   23username加密结果 :KeJAwKEAUZ+HB8NucwwUygG99tWMT7EO/X9J3J50sqFjddx8Nb6jTTQUPEPji2It
   24username解密结果：root
   25password加密结果 :ov7Is+mJiVsT72YCO5t0lgQE4YpEnwYIWkh4dmx6nh+HSg/4W072tGQMzYS0HmE8
   26password解密结果：123456
   27*/

4. 在SpringBoot核心配置文件配置；EVC(密文) 为默认识别密文的格式，可以通过配置文件修改

   properties

   1jasypt.encryptor.password=sdjhauidasdw
   2jasypt.encryptor.property.prefix=EVC(
   3jasypt.encryptor.property.suffix=)
   4
   5spring.datasource.username=EVC(KeJAwKEAUZ+HB8NucwwUygG99tWMT7EO/X9J3J50sqFjddx8Nb6jTTQUPEPji2It)
   6spring.datasource.password=EVC(ov7Is+mJiVsT72YCO5t0lgQE4YpEnwYIWkh4dmx6nh+HSg/4W072tGQMzYS0HmE8)

使用fastjson替换默认jackson ¶

1. 导入依赖

   xml

   1<dependency>
   2    <groupId>com.alibaba</groupId>
   3    <artifactId>fastjson</artifactId>
   4    <version>2.0.7</version>
   5    </dependency>

2. 配置 HttpMessageConverters Bean

   java

    1@Bean
    2public HttpMessageConverters fastJsonHttpMessageConverters(){
    3    //1、先定义一个convert转换消息的对象
    4    FastJsonHttpMessageConverter fastConverter=new FastJsonHttpMessageConverter();
    5    //2、添加fastjson的配置信息，比如是否要格式化返回的json数据；
    6    FastJsonConfig fastJsonConfig=new FastJsonConfig();
    7    fastJsonConfig.setSerializerFeatures(
    8        SerializerFeature.WriteMapNullValue,
    9        SerializerFeature.WriteNullListAsEmpty,
   10        SerializerFeature.WriteNullNumberAsZero,
   11        //SerializerFeature.UseISO8601DateFormat,
   12        SerializerFeature.WriteClassName,
   13        SerializerFeature.WriteNullStringAsEmpty,
   14        SerializerFeature.WriteDateUseDateFormat  //使用日期格式化
   15    );
   16    //附加：处理中文乱码
   17    List<MediaType> fastMedisTypes = new ArrayList<MediaType>();
   18    fastMedisTypes.add(MediaType.APPLICATION_JSON);
   19    fastConverter.setSupportedMediaTypes(fastMedisTypes);
   20    //3、在convert中添加配置信息
   21    fastConverter.setFastJsonConfig(fastJsonConfig);
   22    HttpMessageConverter<?> converter=fastConverter;
   23    return new HttpMessageConverters(converter);
   24}

3. 查看

   java

   1/*
   2* AbstractMessageConverterMethodProcessor类
   3* writeWithMessageConverters 写入响应消息的方法
   4*   genericConverter.write(body, targetType, selectedMediaType, outputMessage)
   5* 可以查看消息转换器，fastjson在列表第一个
   6*  */

集成Thymeleaf ¶

1. Thymeleaf 是一个流行的 java 模板引擎，以 html 为载体
2. Thymeleaf模板引擎页面访问，必须经过中央调度器（不能直接访问，类似于页面放在 WEB-INF 目录下）
3. http://www.thymeleaf.org

Thymeleaf起步

1. 添加thymeleaf起步依赖

   xml

   1<dependency>
   2    <groupId>org.springframework.boot</groupId>
   3    <artifactId>spring-boot-starter-thymeleaf</artifactId>
   4</dependency>

2. 在 templates 目录下创建模板文件 hello.html，并引入命名空间

   html

    1<!DOCTYPE html>
    2<!--suppress ALL -->
    3<html lang="en"  xmlns:th="http://www.thymeleaf.org" >
    4<head>
    5    <meta charset="UTF-8">
    6    <title>Title</title>
    7</head>
    8<body>
    9<h1 th:text="${msg}"></h1>
   10</body>
   11</html>

3. SpringBoot核心配置文件配置关闭缓存，方便开发，启动类需要设置动态更新资源

   properties

   1spring.thymeleaf.cache=false
   2spring.thymeleaf.prefix=classpath:templates/
   3spring.thymeleaf.suffix=.html

Thymeleaf表达式

1. ${}：标准表达式，和el表达式一致，推荐使用
2. *{}：选择变量表达式，必须使用 th:object 属性来绑定这个对象
3. @{}：路径表达式，

Thymeleaf常见属性

1. 标准表达式
   1. th:text
   2. th:method
   3. th:action
   4. th:id
   5. th:name
   6. th:onclick
2. th:each="user,userStat:${userList}"：遍历，依赖于一个html元素
3. 条件判断
   1. th:if="${sex} eq 1：满足条件显示
   2. th:unless="${sex} eq 1"：满足条件不显示，和 th:if 相反
   3. th:switch/th:case：选择，满足显示，否则不显示
4. th:inline=""：内敛表达式，有三个值
   1. text：然后在修饰标签里面，可以通过 [[${}]] 取值，而不需要 th:text="${}" 取值
   2. javascript：可以在 js 中直接取得后台返回过来值，通过 [[${}]]
5. 字面量：字符串的意思，分为字符字面量、数字字面量、boolean字面量
6. 字符串拼接
   1. th:text="|这里为需要拼接的${data}字符串|"
7. 数学运算

后台发送过来的值时，才使用 Thymeleaf 属性

Thymeleaf对象

基本表达式对象

1. #request
2. #session

功能表达式对象

1. #dates：java.util.Date 对象的实用方法
2. #calendars：和dates类似，但是是java.util.Calendar 对象
3. #numbers：格式化数字对象的实用方法
4. #strings：字符串对象的实用方法
5. #objects：对 objects 操作的实用方法
6. #arrays：数组的实用方法
7. #bools：对布尔值求值的实用方法
8. #lists：list 的实用方法，
9. #sets：set 的实用方法
10. #maps：map 的实用方法
11. #aggregates：对数组或集合创建聚合的实用方法

实例

 1<!DOCTYPE html>
 2<!--suppress ALL -->  <!--防止模板引擎取值时报红-->
 3<html lang="en"  xmlns:th="http://www.thymeleaf.org" >
 4<head>
 5    <meta charset="UTF-8">
 6    <title>Title</title>
 7</head>
 8<body>
 9<!--
10uList：{user1,user2,user3..}
11sex：1   1表示男，0表示女
12msg：hello
13-->
14<!--循环-->
15<div th:each="user,uStatus:${uList}">
16    index：<span th:text="${uStatus.index} "></span>
17    count：<span th:text="${uStatus.count} "></span>
18    current：<span th:text="${uStatus.current} "></span>
19    id：<span th:text="${user.id} "></span>
20    name：<span th:text="${user.name} "></span>
21    <br>
22</div>
23<!--判断-->
24<div>
25    <span th:if="${sex} eq 1">男</span>
26    <span th:if="${sex} eq 0">女</span>
27</div>
28<!--inline-->
29<script th:inline="javascript">
30    console.log([[${sex}]])
31</script>
32<!--字符串拼接-->
33<div th:text="|字符串拼接${msg}|"></div>
34<!--路径表达式-->
35<a th:href="@{/t2(msg=hello)}" th:text="跳转"/>
36<!--常用对象-->
37<div>
38    <span th:text="${#request.getRequestURL()}"></span><br>
39    <span th:text="${#session}"></span><br>
40    <span th:text="${#request.getScheme()}"></span><br>
41</div>
42<!--#lists对象使用-->
43<div>
44    uList长度：<span th:text="${#lists.size(uList)}"></span><br>
45</div>
46</body>
47</html>

配置 ¶

多数据源 ¶

核心配置，指定mapper接口扫描位置和sqlsession/sqlfactory的映射关系、mapper 和 sqlsession/sqlfactory 的对应关系

多数据源注意事务问题，如果存在多个事务管理器，需明确指定使用哪一个@Transactional("db1TransactionManager")

1. 配置文件

   properties

   1my.datasource.db1.url=jdbc:mysql://192.168.10.131:3306/db1?useSSL=true&useUnicode=true&characterEncoding=utf8
   2my.datasource.db1.username=root
   3my.datasource.db1.password=123456
   4
   5my.datasource.db2.url=jdbc:mysql://192.168.10.131:3306/db2?useSSL=true&useUnicode=true&characterEncoding=utf8
   6my.datasource.db2.username=root
   7my.datasource.db2.password=123456

2. 配置数据源相关

   db1数据源

   xml

    1<?xml version="1.0" encoding="UTF-8"?>
    2<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3       xmlns:tx="http://www.springframework.org/schema/tx"
    4       xmlns:aop="http://www.springframework.org/schema/aop"
    5       xmlns="http://www.springframework.org/schema/beans"
    6       xsi:schemaLocation="http://www.springframework.org/schema/beans
    7    http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    8    http://www.springframework.org/schema/aop
    9     http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
   10
   11    <bean id="db1DataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   12        <property name="url" value="${my.datasource.db1.url}"/>
   13        <property name="username" value="${my.datasource.db1.username}"/>
   14        <property name="password" value="${my.datasource.db1.password}"/>
   15    </bean>
   16    <!--    SqlSessionFactory -->
   17    <bean id="db1SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
   18        <property name="dataSource" ref="db1DataSource"/>
   19        <property name="mapperLocations" value="classpath*:sql/db1/*Mapper.xml"/>
   20    </bean>
   21    <!-- 这里的配置可以使用注解 @MapperScan   -->
   22<!--    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
   23        <property name="basePackage" value="com.lei.**.db1dao"/>
   24        <property name="sqlSessionFactoryBeanName" value="db1SqlSessionFactory"/>
   25    </bean>-->
   26    <!--    sqlSessionTemplate -->
   27    <bean id="db1SqlSession" class="org.mybatis.spring.SqlSessionTemplate">
   28        <!-- 只能使用构造方法注入，因为该类没有 set 方法-->
   29        <constructor-arg ref="db1SqlSessionFactory"/>
   30    </bean>
   31
   32    <bean id="db1TransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   33        <property name="dataSource" ref="db1DataSource"/>
   34    </bean>
   35    <!-- 自动为spring容器中那些配置@aspectJ切面的bean创建代理-->
   36    <aop:aspectj-autoproxy/>
   37</beans>

   db2数据源

   xml

    1<?xml version="1.0" encoding="UTF-8"?>
    2<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3       xmlns:tx="http://www.springframework.org/schema/tx"
    4       xmlns:aop="http://www.springframework.org/schema/aop"
    5       xmlns="http://www.springframework.org/schema/beans"
    6       xsi:schemaLocation="http://www.springframework.org/schema/beans
    7    http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    8    http://www.springframework.org/schema/aop
    9     http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
   10
   11    <bean id="db2DataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   12        <property name="url" value="${my.datasource.db2.url}"/>
   13        <property name="username" value="${my.datasource.db2.username}"/>
   14        <property name="password" value="${my.datasource.db2.password}"/>
   15    </bean>
   16    <!--    SqlSessionFactory -->
   17    <bean id="db2SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
   18        <property name="dataSource" ref="db2DataSource"/>
   19        <property name="mapperLocations" value="classpath*:sql/db2/*Mapper.xml"/>
   20    </bean>
   21<!--    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">-->
   22<!--        <property name="basePackage" value="com.lei.**.db2dao"/>-->
   23<!--        <property name="sqlSessionFactoryBeanName" value="db2SqlSessionFactory"/>-->
   24<!--    </bean>-->
   25    <!-- sqlSessionTemplate -->
   26    <bean id="db2SqlSession" class="org.mybatis.spring.SqlSessionTemplate">
   27        <!-- 只能使用构造方法注入，因为该类没有 set 方法-->
   28        <constructor-arg ref="db2SqlSessionFactory"/>
   29    </bean>
   30
   31    <bean id="db2TransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   32        <property name="dataSource" ref="db2DataSource"/>
   33    </bean>
   34    <aop:aspectj-autoproxy/>
   35</beans>

3. 启动类配置相关注解

   java

    1@SpringBootApplication
    2//@EnableTransactionManagement
    3//导入数据源配置文件
    4@ImportResource({"classpath*:config/db1.xml","classpath*:config/db2.xml"})
    5//绑定mapper接口和sqlsession
    6@MapperScan(basePackages ="com.lei.**.db1dao", sqlSessionTemplateRef = "db1SqlSession")
    7@MapperScan(basePackages ="com.lei.**.db2dao", sqlSessionTemplateRef = "db2SqlSession")
    8public class TwoApplication {
    9    public static void main(String[] args) {
   10        SpringApplication.run(TwoApplication.class, args);
   11    }
   12}

进行测试，多数据源配置成功

注意：定义扫描dao接口时，可能多个数据源扫描了同一位置，此时后扫描到的dao接口时，不再创建实例bean，此时可以通过数据源配置文件导入先后顺序来控制

1<!-- 
2	这里的db1配置扫描的mapper范围会将db2的mapper扫描到
3	因此先加载db2配置，这样db2 的 mapper 先实例化，后续db1扫描到就会忽略
4-->
5
6<!--分布式关系数据库-->
7<import resource="classpath:config/db2.xml"/>
8<import resource="classpath:config/db1.xml"/>

事务支持 ¶

声明式事务

@Transactional：可以标注在类上或方法上，事务支持

@EnableTransactionManagement：Application 类上，表示开启事务，可以省略

编程式事务

事务管理器 PlatformTransactionManager、事务状态 TransactionStatus、事务属性的定义 TransactionDefinition

1. 通过PlatformTransactionManager实现编程式事务

   java

    1@Override
    2public StudentEntity update(StudentEntity studentEntity) {
    3    //事务定义
    4	DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    5    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    6    //新开事务
    7    TransactionStatus status = transactionManager.getTransaction(definition);
    8    try {
    9        studentsDao.update(studentEntity);
   10        //事务定义
   11        DefaultTransactionDefinition definition1 = new DefaultTransactionDefinition();
   12        definition1.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
   13        //新开事务
   14        TransactionStatus status1 = transactionManager.getTransaction(definition1);
   15        try {
   16            StudentEntity studentEntity1=new StudentEntity();
   17            BeanUtils.copyProperties(studentEntity,studentEntity1);
   18            studentEntity1.setId(2L);
   19            studentEntity1.setName("后续更新");
   20            studentsDao.update(studentEntity1);
   21            int a=10/0;
   22            transactionManager.commit(status1);
   23        }catch (Exception e){
   24            transactionManager.rollback(status1);
   25        }
   26        //提交事务
   27        transactionManager.commit(status);
   28    }catch (Exception e){
   29        //回滚事务
   30        transactionManager.rollback(status);
   31    }
   32}

2. 通过transactionTemplate实现编程式事务

   java

    1@Override
    2public StudentEntity update(StudentEntity studentEntity) {
    3	transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    4    this.transactionTemplate.execute(new TransactionCallbackWithoutResult() {
    5        @Override
    6        protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
    7            try {
    8                studentsDao.update(studentEntity);
    9                //设置事务的传播级别
   10                transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER);
   11                //新开事务
   12                transactionTemplate.execute(new TransactionCallbackWithoutResult() {
   13                    @Override
   14                    protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
   15                        try {
   16                            StudentEntity studentEntity1=new StudentEntity();
   17                            BeanUtils.copyProperties(studentEntity,studentEntity1);
   18                            studentEntity1.setId(2L);
   19                            studentEntity1.setName("后续更新");
   20                            studentsDao.update(studentEntity1);
   21                        }catch(Exception e){
   22                            //标记事务为回滚
   23                            transactionStatus.setRollbackOnly();
   24                        }
   25                    }
   26                });
   27                int a=10/0;
   28            }catch (Exception e){
   29                transactionStatus.setRollbackOnly();
   30            }
   31        }
   32    });
   33}

注：以上两种编程式事务，都是事务嵌套；外层事务和内层事务通过事务传播级别关联；设置不同的事务传播级别，可以实现：内部事务抛错外部回滚，内部抛错外部提交等；通过事务传播级别，设置事务管理器中的事务是否RollbackOnly

注意：SpringBoot集成mybatis时，通过sqlSession进行数据库操作时，必须注意 sqlSession 可以设置自动提交，但是连接池连接的自动提交并不能在获取sqlSession时设置

openSession(boolean autoCommit)，autoCommit 可选参数传递 true 值即可开启自动提交功能，没有提供同时设置 Connection 和 autoCommit 的方法，这是因为 MyBatis 会依据传入的 Connection 来决定是否启用 autoCommit

SqlSessionTemplate

SqlSessionTemplate 是 MyBatis-Spring 的核心，作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession，SqlSessionTemplate 是线程安全的，可以被多个 DAO 或映射器所共享使用，SqlSessionTemplate 将会保证使用的 SqlSession 与当前 Spring 的事务相关

 1@Override
 2public StudentEntity update(StudentEntity studentEntity) {
 3    SqlSession sqlSession=null;
 4    TransactionDefinition definition = new DefaultTransactionDefinition();
 5    TransactionStatus status = transactionManager.getTransaction(definition);
 6    try {
 7        //这里通过sqlSessionTemplate获取到的sqlSession总是加入当前已存在事务
 8        sqlSession = sqlSessionTemplate.getSqlSessionFactory().openSession(ExecutorType.SIMPLE,false);
 9        StudentsDao mapper = sqlSession.getMapper(StudentsDao.class);
10        mapper.update(studentEntity);
11        //sqlSessionTemplate的特性，这里的提交失效，以外层事务为准
12        sqlSession.commit();
13    }catch (Exception e){
14        sqlSession.rollback();
15    }finally {
16        if (sqlSession!=null){
17            sqlSession.close();
18        }
19    }
20    //这里提交或回滚，包括sqlSessionTemplate进行的sql操作
21    transactionManager.commit(status);
22    return this.queryById(studentEntity.getId());
23}

rollback-only

当事务嵌套时,事务传播特性(propagation)为REQUIRED时,以下情况会出现rollback-only

1. 当里层事务抛错,标记为回滚,但是错误被捕获,外层未抛错出来,此时里层缺已经标记为只能rollbackOnly,外层提交事务就会抛错rollback-only
2. 当外层为只读事务时,里层事务抛错,此时只读事务提交也会抛错rollback-only

业务代码执行时，记录错误

 1@Override
 2@Transactional("db1TransactionManager")
 3public Object testB() {
 4    Db1Tb1 db1Tb1=new Db1Tb1();
 5    db1Tb1.setAge(12);
 6    db1Tb1.setName("db1");
 7    db1Tb1Dao.insert(db1Tb1);
 8
 9    DefaultTransactionDefinition transactionDefinition=new DefaultTransactionDefinition();
10    //注意事务传播级别，新开事务
11    //用于记录业务代码中的错误，业务代码回滚，错误信息提交
12    transactionDefinition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
13    TransactionStatus transaction = platformTransactionManager.getTransaction(transactionDefinition);
14    try {
15        db1Tb1.setAge(16);
16        db1Tb1Dao.insert(db1Tb1);
17        platformTransactionManager.commit(transaction);
18    }catch (Exception e){
19        platformTransactionManager.rollback(transaction);
20    }
21    //这里抛错 不会影响第新开事务的数据插入
22    int i =1/0;
23    return null;
24}

RESTFul风格 ¶

主要是用@PathVariable("")注解

1. controller代码

   java

   1@RestController
   2public class TestController {
   3    @RequestMapping("/test/{id}/{name}")
   4    public String test(@PathVariable("id") Integer id,
   5                       @PathVariable("name") String name){
   6        return id+" "+name;
   7    }
   8}

2. 访问地址：127.0.0.1:8080/test/123/唐磊

注意请求路径不清楚的情况，restful风格，通常使用对应的方法请求mapping注解，例：

 1//请求访问时，会出现请求模糊的错误
 2@RestController
 3public class TestController {
 4    @RequestMapping("/test/{id}/{name}")
 5    public String test(@PathVariable("id") Integer id,
 6                       @PathVariable("name") String name){
 7        return id+" "+name;
 8    }
 9    @RequestMapping("/test/{id}/{desc}")
10    public String test2(@PathVariable("id") Integer id,
11                       @PathVariable("desc") String name){
12        return id+" "+name;
13    }
14}

修改为以下代码无误，然后通过对应的请求方式发送请求

 1@RestController
 2public class TestController {
 3    @PostMapping("/test/{id}/{name}")
 4    public String test(@PathVariable("id") Integer id,
 5                       @PathVariable("name") String name){
 6        return id+" "+name;
 7    }
 8    @GetMapping("/test/{id}/{desc}")
 9    public String test2(@PathVariable("id") Integer id,
10                       @PathVariable("desc") String name){
11        return id+" "+name;
12    }
13}

普通java程序 ¶

SpringBoot实现普通java程序，有两种方法

1. 在SpringBoot启动方法中获取 ConfigurableApplicationContext

   java

   1//获得容器，然后取得bean并执行
   2ConfigurableApplicationContext context=SpringApplication.run(Application.class, args);

2. 在SpringBoot启动类实现CommandLineRunner接口，并重写run方法

   java

    1//实现CommandLineRunner接口，并重写run方法
    2CommandLineRunner
    3@SpringBootApplication
    4public class Application implements CommandLineRunner
    5CommandLineRunner {
    6    //注入bean
    7    @Autowired
    8    private UserService userService;
    9    public static void main(String[] args) {
   10        SpringApplication.run(Application.class, args);
   11    }
   12//重写接口方法，调用bean方法，SpringBoot容器启动后会回调该方法
   13    @Override
   14    public void run(String... args) throws Exception {
   15        userService.say();
   16    }
   17}

拦截器 Interceptor ¶

1. 实现HandlerInterceptor接口并实现相关方法

   java

    1@Order(1)    //order代表拦截器执行顺序
    2@Component	 //注册到spring容器，以便后续将拦截在WebMvcConfigurer中注册
    3public class LoginInterceptor implements HandlerInterceptor {
    4    //预处理回调方法，实现处理器的预处理，如登录检查；true表示执行下一流程、false中断流程（需要通过response来响应）
    5    @Override
    6    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    7        if (request.getSession().getAttribute("user")==null){
    8            response.sendRedirect(request.getContextPath()+"/user/err");
    9            return false;
   10        }
   11        return true;
   12    }
   13
   14    //后处理回调方法，在控制器后视图层前，可以通过modelAndView来处理视图层
   15    @Override
   16    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
   17        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
   18    }
   19
   20    //整个请求处理完毕后的回调方法，即在视图渲染完毕后回调；如性能监控，在此输出结束时间，还可以进行资源清理（类似于finally）
   21    @Override
   22    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
   23        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
   24    }
   25}

2. 注册 WebMvcConfigurer bean，添加拦截器到SpringBoot容器，并配置需要拦截的请求

   java

    1@Bean
    2WebMvcConfigurer createWebMvcConfigurer(@Autowired LoginInterceptor loginInterceptor) {
    3    return new WebMvcConfigurer() {
    4        //需要被拦截的请求 **代表当前请求路径下的所有请求，*代表当前请求路径同级请求
    5        // /user/* 表示拦截/user/xx的请求，/user/** 表示拦截 /user/xx/xx...的请求
    6        String[] addPath={"/user/**"};
    7        String[] excludePath={"/user/login","/user/err"};
    8        public void addInterceptors(InterceptorRegistry registry) {
    9            registry.addInterceptor(loginInterceptor)
   10                .addPathPatterns(addPath)      //需要拦截的请求地址
   11                .excludePathPatterns(excludePath);  //不需要拦截的请求地址
   12        }
   13    };
   14}

3. 编写测试类

   java

    1@RestController
    2@RequestMapping("/user")
    3public class UserController {
    4    //登录，可不登录访问
    5    @RequestMapping("/login")
    6    public String login(HttpServletRequest request, HttpServletResponse response) throws IOException {
    7        User user= (User) request.getSession().getAttribute("user");
    8        if (user==null){
    9            user=new User();
   10            user.setId(UUID.randomUUID().toString());
   11            request.getSession().setAttribute("user",user);
   12        }else {
   13            response.sendRedirect(request.getContextPath()+"/user/home");
   14        }
   15        return "login";
   16    }
   17    //需要登录后访问
   18    @RequestMapping("/home")
   19    public String home(HttpServletRequest request){
   20        User user= (User) request.getSession().getAttribute("user");
   21        return "home"+user;
   22    }
   23    //错误，可不登录访问，未登录时跳转这个请求
   24    @RequestMapping("/err")
   25    public String err(){
   26        return "err";
   27    }
   28}