package org.fh; import com.alibaba.druid.support.http.StatViewServlet; import com.alibaba.druid.support.http.WebStatFilter; import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /** * 说明：druid数据库连接池的配置类(必须与启动类包目录同级) * 作者：FH Admin * from：fhadmin.cn */ @Configuration public class DruidConfiguration { @Bean public ServletRegistrationBean<StatViewServlet> statViewServlet() { // 创建servlet注册实体 ServletRegistrationBean<StatViewServlet> servletRegistrationBean = new ServletRegistrationBean<StatViewServlet>(new StatViewServlet(), "/druid/*"); // 设置ip白名单 //servletRegistrationBean.addInitParameter("allow", "127.0.0.1"); // 设置ip黑名单，如果allow与deny共同存在时,deny优先于allow //servletRegistrationBean.addInitParameter("deny", "192.168.0.1"); // 设置控制台管理用户 //servletRegistrationBean.addInitParameter("loginUsername", "druid"); //servletRegistrationBean.addInitParameter("loginPassword", "fhadmin"); // 是否可以重置数据 servletRegistrationBean.addInitParameter("resetEnable", "false"); return servletRegistrationBean; } @Bean public FilterRegistrationBean<WebStatFilter> statFilter() { // 创建过滤器 FilterRegistrationBean<WebStatFilter> filterRegistrationBean = new FilterRegistrationBean<WebStatFilter>(new WebStatFilter()); // 设置过滤器过滤路径 filterRegistrationBean.addUrlPatterns("/*"); // 忽略过滤的形式 filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"); return filterRegistrationBean; } } 

集成DruidDruid简介Java程序很大一部分要操作数据库，为了提高性能操作数据库的时候，又不得不使用数据库连接池。Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP 等 DB 池的优点，同时加入了日志监控。Druid 可以很好的监控 DB 池连接和 SQL 的执行情况，天生就是针对监控而生的 DB 连接池。Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。Spring Boot 2.0 以上默认使用 Hikari 数据源，可以说 Hikari 与 Driud 都是当前 Java Web 上最优秀的数据源，我们来重点介绍 Spring Boot 如何集成 Druid 数据源，如何实现数据库监控。Github地址：https://github.com/alibaba/druid/com.alibaba.druid.pool.DruidDataSource 基本配置参数如下：配置缺省值说明name配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。 如果没有配置，将会生成一个名字，格式是：“DataSource-” + System.identityHashCode(this)jdbcUrl连接数据库的url，不同数据库不一样。例如： mysql : jdbc:mysql://10.20.153.104:3306/druid2 oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnautousername连接数据库的用户名password连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter。详细看这里：https://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilterdriverClassName根据url自动识别这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)initialSize0初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时maxActive8最大连接池数量maxIdle8已经不再使用，配置了也没效果minIdle最小连接池数量maxWait获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。poolPreparedStatementsfalse是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。maxOpenPreparedStatements-1要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100validationQuery用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。validationQueryTimeout单位:秒，检测连接是否有效的超时时间。底层调用jdbcStatement对象的void setQueryTimeout(int seconds)方法testOnBorrowtrue申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能testOnReturnfalse归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能testWhileIdlefalse建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效timeBetweenEvictionRunsMillis1分钟( 1.0.14 )有两个含义： 1) Destroy线程会检测连接的间隔时间 2) testWhileIdle的判断依据，详细看testWhileIdle属性的说明numTestsPerEvictionRun不再使用，一个DruidDataSource只支持一个EvictionRunminEvictableIdleTimeMillis30分钟( 1.0.14 )连接保持空闲而不被驱逐的最长时间connectionInitSqls物理连接初始化的时候执行的sqlexceptionSorter根据dbType自动识别当数据库抛出一些不可恢复的异常时，抛弃连接filters属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有： 监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wallproxyFilters类型是List<com.alibaba.druid.filter.Filter>，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系配置数据源添加上 Druid 数据源依赖，这个依赖可以从Maven仓库官网Maven Respository中获取<dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.23</version> </dependency>切换数据源；之前已经说过 Spring Boot 2.0 以上默认使用 com.zaxxer.hikari.HikariDataSource数据源，但可以通过 spring.datasource.type 指定数据源。spring: datasource: username: root password: 123456 #时区报错增加时区配置 url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=utf8 driver-class-name: com.mysql.cj.jdbc.Driver type: com.alibaba.druid.pool.DruidDataSource数据源切换之后，在测试类中注入 DataSource，然后获取到它，输出一看便知是否成功切换；切换成功！既然切换成功，就可以设置数据源连接初始化大小、最大连接数、等待时间、最小连接数 等设置项；可以查看源码spring: datasource: username: root password: 123456 #时区报错增加时区配置 url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=utf8 driver-class-name: com.mysql.cj.jdbc.Driver type: com.alibaba.druid.pool.DruidDataSource #Spring Boot 默认是不注入这些属性值的，需要自己绑定 #druid 数据源专有配置 initialSize: 5 minIdle: 5 maxActive: 20 maxWait: 60000 timeBetweenEvictionRunsMillis: 60000 minEvictableIdleTimeMillis: 300000 validationQuery: SELECT 1 FROM DUAL testWhileIdle: true testOnBorrow: false testOnReturn: false poolPreparedStatements: true #配置监控统计拦截的filters，stat:监控统计、log4j：日志记录、wall：防御sql注入 #如果允许时报错 java.lang.ClassNotFoundException: org.apache.log4j.Priority #则导入 log4j 依赖即可，Maven 地址：https://mvnrepository.com/artifact/log4j/log4j filters: stat,wall,log4j maxPoolPreparedStatementPerConnectionSize: 20 useGlobalDataSourceStat: true connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500导入Log4j 的依赖<!-- log4j--> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency>现在需要程序员自己为 DruidDataSource 绑定全局配置文件中的参数，再添加到容器中，而不再使用 Spring Boot 的自动生成了；我们需要 自己添加 DruidDataSource 组件到容器中，并绑定属性；package com.sxau.config; import com.alibaba.druid.pool.DruidDataSource; import com.alibaba.druid.support.http.StatViewServlet; import com.alibaba.druid.support.http.WebStatFilter; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import javax.sql.DataSource; import java.util.Arrays; import java.util.HashMap; import java.util.Map; @Configuration public class DruidConfig { /* 将自定义的 Druid数据源添加到容器中，不再让 Spring Boot 自动创建 绑定全局配置文件中的 druid 数据源属性到 com.alibaba.druid.pool.DruidDataSource从而让它们生效 @ConfigurationProperties(prefix = "spring.datasource")：作用就是将 全局配置文件中 前缀为 spring.datasource的属性值注入到 com.alibaba.druid.pool.DruidDataSource 的同名参数中 */ @ConfigurationProperties(prefix = "spring.datasource") @Bean public DataSource druidDataSource() { return new DruidDataSource(); } //配置 Druid 监控管理后台的Servlet； //内置 Servlet 容器时没有web.xml文件，所以使用 Spring Boot 的注册 Servlet 方式 @Bean public ServletRegistrationBean statViewServlet() { ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*"); // 这些参数可以在 com.alibaba.druid.support.http.StatViewServlet // 的父类 com.alibaba.druid.support.http.ResourceServlet 中找到 Map<String, String> initParams = new HashMap<>(); initParams.put("loginUsername", "admin"); //后台管理界面的登录账号 initParams.put("loginPassword", "123456"); //后台管理界面的登录密码 //后台允许谁可以访问 //initParams.put("allow", "localhost")：表示只有本机可以访问 //initParams.put("allow", "")：为空或者为null时，表示允许所有访问 initParams.put("allow", ""); //deny：Druid 后台拒绝谁访问 //initParams.put("kuangshen", "192.168.1.20");表示禁止此ip访问 //设置初始化参数 bean.setInitParameters(initParams); return bean; } //配置 Druid 监控 之 web 监控的 filter //WebStatFilter：用于配置Web和Druid数据源之间的管理关联监控统计 @Bean public FilterRegistrationBean webStatFilter() { FilterRegistrationBean bean = new FilterRegistrationBean(); bean.setFilter(new WebStatFilter()); //exclusions：设置哪些请求进行过滤排除掉，从而不进行统计 Map<String, String> initParams = new HashMap<>(); initParams.put("exclusions", "*.js,*.css,/druid/*,/jdbc/*"); bean.setInitParameters(initParams); //"/*" 表示过滤所有请求 bean.setUrlPatterns(Arrays.asList("/*")); return bean; } } 去测试类中测试一下；看是否成功！package com.sxau; import com.alibaba.druid.pool.DruidDataSource; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import javax.sql.DataSource; import java.sql.Connection; import java.sql.SQLException; @SpringBootTest class Springboot05JdbcApplicationTests { //DI注入数据源 @Autowired DataSource dataSource; @Test void contextLoads() throws SQLException { //查看一下默认的数据源：class com.zaxxer.hikari.HikariDataSource System.out.println(dataSource.getClass()); //获得数据库连接 Connection connection = dataSource.getConnection(); System.out.println(connection); DruidDataSource druidDataSource = (DruidDataSource) dataSource; System.out.println("druidDataSource 数据源最大连接数：" + druidDataSource.getMaxActive()); System.out.println("druidDataSource 数据源初始化连接数：" + druidDataSource.getInitialSize()); //关闭连接 connection.close(); } }输出结果 ：可见配置参数已经生效！配置Druid数据源监控Druid 数据源具有监控的功能，并提供了一个 web 界面方便用户查看，类似安装 路由器 时，人家也提供了一个默认的 web 页面。所以第一步需要设置 Druid 的后台管理页面，比如 登录账号、密码 等；配置后台管理；package com.sxau.config; import com.alibaba.druid.pool.DruidDataSource; import com.alibaba.druid.support.http.StatViewServlet; import com.alibaba.druid.support.http.WebStatFilter; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import javax.sql.DataSource; import java.util.Arrays; import java.util.HashMap; import java.util.Map; @Configuration public class DruidConfig { /* 将自定义的 Druid数据源添加到容器中，不再让 Spring Boot 自动创建 绑定全局配置文件中的 druid 数据源属性到 com.alibaba.druid.pool.DruidDataSource从而让它们生效 @ConfigurationProperties(prefix = "spring.datasource")：作用就是将全局配置文件中 前缀为 spring.datasource的属性值注入到 com.alibaba.druid.pool.DruidDataSource 的同名参数中 */ @ConfigurationProperties(prefix = "spring.datasource") @Bean public DataSource druidDataSource() { return new DruidDataSource(); } //配置 Druid 监控管理后台的Servlet； //内置 Servlet 容器时没有web.xml文件，所以使用 Spring Boot 的注册 Servlet 方式 @Bean public ServletRegistrationBean statViewServlet() { ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*"); // 这些参数可以在 com.alibaba.druid.support.http.StatViewServlet // 的父类 com.alibaba.druid.support.http.ResourceServlet 中找到 Map<String, String> initParams = new HashMap<>(); initParams.put("loginUsername", "admin"); //后台管理界面的登录账号 initParams.put("loginPassword", "123456"); //后台管理界面的登录密码 //后台允许谁可以访问 //initParams.put("allow", "localhost")：表示只有本机可以访问 //initParams.put("allow", "")：为空或者为null时，表示允许所有访问 initParams.put("allow", ""); //deny：Druid 后台拒绝谁访问 //initParams.put("kuangshen", "192.168.1.20");表示禁止此ip访问 //设置初始化参数 bean.setInitParameters(initParams); return bean; } }配置完毕后，我们可以选择访问 ：http://localhost:8080/druid/login.html进入之后配置 Druid web 监控 filter 过滤器//配置 Druid 监控 之 web 监控的 filter //WebStatFilter：用于配置Web和Druid数据源之间的管理关联监控统计 @Bean public FilterRegistrationBean webStatFilter() { FilterRegistrationBean bean = new FilterRegistrationBean(); bean.setFilter(new WebStatFilter()); //exclusions：设置哪些请求进行过滤排除掉，从而不进行统计 Map<String, String> initParams = new HashMap<>(); initParams.put("exclusions", "*.js,*.css,/druid/*,/jdbc/*"); bean.setInitParameters(initParams); //"/*" 表示过滤所有请求 bean.setUrlPatterns(Arrays.asList("/*")); return bean; }

在单体架构下，我们大多使用的是单体数据库，通过数据库的ACID特性支持，实现了本地事务。但是在微服务架构下复杂的业务关系中，分布式事务是不可避免的问题之一。Seata是Spring Cloud Alibaba分布式事务解决方案中间件，解决了微服务场景下面临的分布式事务问题。本文介绍如何通过搭建Seata环境，并通过其AT模式，实现分布式事务。本文中使用的环境版本：1、Seata服务端z下载下载seata-server-1.4.0：https://github.com/seata/seata/releases/tag/v1.4.0同时下载seata-server-0.0.9，后续需要其中的配置文件和脚本：https://github.com/seata/seata/releases/tag/v0.9.02、Seata服务file.conf,registry.conf配置在conf目录下，先把配置文件备份后再进行更改修改file.conf，mode选择数据库模式，并配置数据库连接信息 ## store mode: file、db、redis mode = "db" ## database store property db { ## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp)/HikariDataSource(hikari) etc. datasource = "druid" ## mysql/oracle/postgresql/h2/oceanbase etc. dbType = "mysql" driverClassName = "com.mysql.jdbc.Driver" url = "jdbc:mysql://127.0.0.1:3306/seata" user = "xxxxx" password = "xxxxxx" minConn = 5 maxConn = 100 globalTable = "global_table" branchTable = "branch_table" lockTable = "lock_table" queryLimit = 100 maxWait = 5000 }修改registry.conf，使用nacos作为注册和配置中心。可以在nacos中创建一个命名空间，把生成的命名空间的值拷过来 registry { # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa type = "nacos" nacos { application = "seata-server" serverAddr = "127.0.0.1:8848" group = "SEATA_GROUP" namespace = "202274f4-218e-42bf-9251-e996df6340f8" cluster = "default" username = "nacos" password = "nacos" } config { # file、nacos 、apollo、zk、consul、etcd3 type = "nacos" nacos { serverAddr = "127.0.0.1:8848" namespace = "202274f4-218e-42bf-9251-e996df6340f8" group = "SEATA_GROUP" username = "nacos" password = "nacos" }3、导入Seate参数配置到nacos配置中心首先，把seata-server-0.9的 nacos-config.txt 和nacos-config.sh脚本拷贝到1.4版本的 seata/conf下。我们需要把nacos-config.txt的参数通过脚本nacos-config.sh导入到nacos配置中心，之后微服务项目也从nacos配置中心读取配置。这样就不用像老版本那样，需要把两个配置文件拷到微服务项目的resourcce目录下了。修改nacos-config.txt，首先修改数据库配置：store.mode=db store.db.url=jdbc:mysql://127.0.0.1:3306/seata?useUnicode=true store.db.user=hydra store.db.password=1234560.9中的参数格式还是使用横线模式，在1.4中规范有所变动，需要把横线变成驼峰，启动需要改动的参数有：store.db.db-type=mysql store.db.driver-class-name=com.mysql.jdbc.Driver需要改成驼峰：store.db.dbType=mysql store.db.driverClassName=com.mysql.jdbc.Driver并且，如果使用的是mysql8.0以上的版本，需要改一下驱动的名称。其他参数的具体意义可以查看官方文档：https://seata.io/zh-cn/docs/user/configurations.html ，并按照上面的规则进行修改。额外需要注意参数的参数是：service.vgroupMappingservice.vgroupMapping.my_test_tx_group=default官方解释为事务群组，具体使用多少个事务群体没有明确指出。但通过查看文档和部分开源项目发现，大多都采用将key值设置为服务端的服务名，有多少个微服务就添加多少行。在接下来的demo中要使用两个微服务作为示例，因此添加：service.vgroupMapping.order-service-group=default service.vgroupMapping.stock-service-group=default使用gitbash运行nacos-config.sh脚本，参数是nacos的ip：sh nacos-config.sh 127.0.0.1这样执行完成后参数默认是存在nacos config的public命名空间下，可以在nacos创建一个seata的命名空间，把所有参数拷贝过去，方便进行区分。4、建表：在seata数据库中新建表branch_table, global_table, lock_table，在业务数据库中新建表undo_log，用于回滚，这些脚本也是seata-server-0.9中也可以直接找到。-- the table to store GlobalSession data drop table if exists `global_table`; create table `global_table` ( `xid` varchar(128) not null, `transaction_id` bigint, `status` tinyint not null, `application_id` varchar(32), `transaction_service_group` varchar(32), `transaction_name` varchar(128), `timeout` int, `begin_time` bigint, `application_data` varchar(2000), `gmt_create` datetime, `gmt_modified` datetime, primary key (`xid`), key `idx_gmt_modified_status` (`gmt_modified`, `status`), key `idx_transaction_id` (`transaction_id`) ); -- the table to store BranchSession data drop table if exists `branch_table`; create table `branch_table` ( `branch_id` bigint not null, `xid` varchar(128) not null, `transaction_id` bigint , `resource_group_id` varchar(32), `resource_id` varchar(256) , `lock_key` varchar(128) , `branch_type` varchar(8) , `status` tinyint, `client_id` varchar(64), `application_data` varchar(2000), `gmt_create` datetime, `gmt_modified` datetime, primary key (`branch_id`), key `idx_xid` (`xid`) ); -- the table to store lock data drop table if exists `lock_table`; create table `lock_table` ( `row_key` varchar(128) not null, `xid` varchar(96), `transaction_id` long , `branch_id` long, `resource_id` varchar(256) , `table_name` varchar(32) , `pk` varchar(36) , `gmt_create` datetime , `gmt_modified` datetime, primary key(`row_key`) ); -- the table to store seata xid data -- 0.7.0+ add context -- you must to init this sql for you business databese. the seata server not need it. -- 此脚本必须初始化在你当前的业务数据库中，用于AT 模式XID记录。与server端无关（注：业务数据库） -- 注意此处0.3.0+ 增加唯一索引 ux_undo_log drop table `undo_log`; CREATE TABLE `undo_log` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `branch_id` bigint(20) NOT NULL, `xid` varchar(100) NOT NULL, `context` varchar(128) NOT NULL, `rollback_info` longblob NOT NULL, `log_status` int(11) NOT NULL, `log_created` datetime NOT NULL, `log_modified` datetime NOT NULL, `ext` varchar(100) DEFAULT NULL, PRIMARY KEY (`id`), UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;5、启动在启动nacos-server的情况下，点击 seata/bin/seata-server.bat启动seata。6、微服务改造在微服务中引入seata的依赖：<dependency> <groupId>io.seata</groupId> <artifactId>seata-spring-boot-starter</artifactId> <version>1.3.0</version> </dependency> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-seata</artifactId> <exclusions> <exclusion> <groupId>io.seata</groupId> <artifactId>seata-spring-boot-starter</artifactId> </exclusion> </exclusions> </dependency>如果微服务中使用的是druid连接池，可以把已有的druid依赖删除，在seata-spring-boot-starter-1.3.0中已经引入了druid-1.1.12。修改每一个微服务yml，配置nacos和seata，tx-service-group就是nacos-config.txt 中service.vgroupMapping的key，我们这里使用微服务的名称加上group后缀server: port: 8763 spring: application: name: order-service cloud: nacos: server-addr: 127.0.0.1:8848 datasource: url: jdbc:mysql://localhost:3306/tenant?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC username: hydra password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver type: com.alibaba.druid.pool.DruidDataSource druid: initial-size: 8 min-idle: 1 max-active: 10 max-wait: 60000 seata: enabled: true application-id: ${spring.application.name} tx-service-group: ${spring.application.name}-group enable-auto-data-source-proxy: true config: type: nacos nacos: server-addr: 127.0.0.1:8848 namespace: 202274f4-218e-42bf-9251-e996df6340f8 group: SEATA_GROUP username: nacos password: nacos registry: type: nacos nacos: application: seata-server server-addr: 127.0.0.1:8848 namespace: 202274f4-218e-42bf-9251-e996df6340f8 group: SEATA_GROUP username: nacos password: nacos配置seata的数据库代理，在使用mybatis-plus时的配置方式如下：@Configuration public class DataSourceProxyConfig { @Bean public SqlSessionFactory sqlSessionFactoryBean(DataSource dataSource) throws Exception { // 订单服务中引入了mybatis-plus，所以要使用特殊的SqlSessionFactoryBean MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean(); // 代理数据源 sqlSessionFactoryBean.setDataSource(new DataSourceProxy(dataSource)); // 生成SqlSessionFactory return sqlSessionFactoryBean.getObject(); } }调用测试，以OrderService调用StockService为例，在被调用的service方法上加上@Transactional注解StockService提供接口：@Service public class StockService { @Autowired private StockMapper stockMapper; @Transactional public String reduce(){ System.out.println("减库存"); Stock stock = stockMapper.selectOne(new LambdaQueryWrapper<Stock>().eq(Stock::getId, 1)); System.out.println(stock.toString()); stock.setQuantity(stock.getQuantity()-1); int result = stockMapper.updateById(stock); if (result==1){ throw new RuntimeException("异常测试，准备rollBack"); } return "stock reduce success"; } }OrderService调用StockService的服务：使用了FeignClient调用StockService，并在发起事务的方法上加上@GlobalTransactional注解：@Service public class OrderService { @Autowired private OrderMapper orderMapper; @Autowired private StockClient stockClient; @GlobalTransactional public String buy(){ Order order=new Order(); order.setId(1L).setMoney(20D); int result = orderMapper.insert(order); if (result==1){ System.out.println("插入订单成功"); } return stockClient.reduce(); } }调用OrderService的接口，会在StockService中抛出异常，reduce方法中的本地事务先执行回滚。再查看日志，在order表上执行了回滚操作：在上面的日志中，打印出了全局事务的xid、分支的branchId、以及seata使用的模式，在使用AT模式的二阶段提交完成后，显示回滚状态为回滚完成。查看业务数据库的und_log表，已经插入了回滚记录：这样，就以Seata中默认的AT模式实现了分布式事务。在该模式下，可以应对大多数的业务场景，并且基本可以做到无业务入侵，对于程序员来说，只需要添加注解，不需要做其他的业务功能改造，就可以以无感知的方式就可以实现分布式事务的解决。

在上一篇文章中，介绍了基于Mybatis-plus实现多租户架构，但是在实际工作中可能会存在一些不足：如果是基于现有的系统改造，那么在所有的表上都需要加租户字段，会非常复杂如果第三方系统调用我们的接口，可能无法要求他们在请求中携带租户信息，因此要重写大量的需要单独过滤的sql语句​​​针对上面的问题，接下来继续介绍一下基于Sharding-Sphere的分表来实现多租户，与之前在一张表中存放数据不同，我们会将不同租户的数据存放在同一数据库的不同表中，相对于前一种模式，这样会具有更高的数据隔离性。​​​首先来假设一个应用场景，某航空票务公司网站中，海航系、南航系和国航系被分为3个租户，租户间数据分表存放，它们下属的各个航空公司分别隶属于以上租户，那么随之各自的订单数据也存放在各自的租户数据表中。​​​首先先进行准备工作，为3个租户分别建表：CREATE TABLE `t_order_0` ( `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT, `order_number` varchar(32) DEFAULT NULL, `money` decimal(18,4) DEFAULT NULL, `postage` decimal(18,4) DEFAULT NULL, `address` varchar(128) DEFAULT NULL, `company` varchar(20) DEFAULT NULL, PRIMARY KEY (`id`) ) 注意相同表结构的表需要建立三张，分别是t_order_0，t_order_1和t_order_2。​​​导入Sharding-Sphere依赖和数据库连接池druid的依赖：<dependency> <groupId>org.apache.shardingsphere</groupId> <artifactId>sharding-jdbc-spring-boot-starter</artifactId> <version>4.1.1</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.22</version> </dependency>注意这里引入的是druid而不是druid-spring-boot-starter，因为在高版本的sharding-sphere中，如果使用starter版本可能报错找不到url。​​​在application.yml中进行配置数据源及分表规则：spring: shardingsphere: datasource: names: ds0 ds0: type: com.alibaba.druid.pool.DruidDataSource driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/tenant?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC username: hydra password: 123456 sharding: defaultDataSourceName: ds0 tables: t_order: actualDataNodes: ds0.t_order_$->{0..2} tableStrategy: standard: shardingColumn: company preciseAlgorithmClassName: com.cn.hydra.shardingtest.algorithm.OrderShardingAlgorithm props: sql: show: true对上面的参数进行说明：datasource：这里因为还用不到分库，所以只进行了一个数据源的配置，如果存在多个则与ds0结构相同defaultDataSourceName：选择默认数据源tables：开始数据分片规则配置，注意下面的t_order是逻辑表名称actualDataNodes ：由数据源名加表名组成，以小数点分隔，多个表以逗号分隔，支持行表达式tableStrategy：分表策略standard：用于单分片键的标准分片场景shardingColumn：分片列名称preciseAlgorithmClassName：分片算法实现类，这个类由对我们自己实现，定义分片逻辑props.sql.show：打印sql语句​​​创建一个枚举类，存放航空公司名称到租户id的对应关系，并写一个根据航空公司查找租户编码的方法，在后面分片规则中使用：public enum Rules { NANHANG(0,Arrays.asList("NANFANG","XIAMEN","CHONGQING")), HAIHANG(1, Arrays.asList("SHOUDU","CHANGAN","JINPENG")), GUOHANG(2,Arrays.asList("GUOHANG","SHENZHEN","SHANHANG")); public static int searchCode(String company){ for (Rules value : Rules.values()) { if (value.getCompany().contains(company)){ return value.getCode(); } } return -1; } private int code; private List<String> company; Rules(int code,List<String> company){ this.code=code; this.company=company; } public int getCode() { return code; } public List<String> getCompany() { return company; } }接下来是分表的核心，分片逻辑类需要实现PreciseShardingAlgorithm接口，并重写doSharding方法。之后对订单表的操作都会执行这里的doSharding方法选择实际执行sql的数据库表：public class OrderShardingAlgorithm implements PreciseShardingAlgorithm<String> { @Override public String doSharding(Collection<String> collection, PreciseShardingValue<String> preciseShardingValue) { int tenant = Rules.searchCode(preciseShardingValue.getValue()); String targetTable="t_order_"+tenant; if (collection.contains(targetTable)){ return targetTable; } throw new UnsupportedOperationException("找不到租户："+preciseShardingValue); } }之前在yml中定义了分片列是company，因此这里通过preciseShardingValue能够拿到company的值。再根据上面枚举类的对应关系，可以获得租户id，最后返回真正执行sql的表名。​​​创建一个简单的订单Service进行测试，用来执行创建订单和查询订单的操作，参数都是航空公司的名称：@Service public class OrderService { @Autowired OrderMapper orderMapper; public void createOrder(String company){ Order order=new Order(); order.setOrderNumber(UUID.randomUUID().toString().replaceAll("-","")); order.setMoney(new BigDecimal(100)); order.setCompany(company); orderMapper.insert(order); } public void getOrder(String company){ List<Order> orders = orderMapper.selectList(new LambdaQueryWrapper<Order>().eq(Order::getCompany, company)); orders.stream().forEach(System.out::println); } }首先调用创建订单方法进行测试，发送一个请求：http://127.0.0.1:8083/create?company=SHOUDU查看执行结果的日志打印情况，被分为逻辑sql和实际执行的sql两部分。在逻辑sql语句中，可以看到使用的是逻辑表t_order，在实际sql中实际执行在t_order_1中，因为航空公司名称参数SHOUDU对应的租户编码是1，在分片算法中进行了实际表名的计算。将参数换成SHENZHEN再执行一次：http://127.0.0.1:8083/create?company=SHENZHEN查看执行结果，实际执行的sql语句的表被换成了t_order_2：接下来看一下可能发生的特殊情况，首先，如果传递的分片列的参数不在我们定义的映射规则内，那么会抛出UnsupportedOperationException异常：如果在sql中没有涉及到分片列，那么数据会被插入到所有的表中，可以看到在下面的情况中，同一个订单被同时插入到了3张表中：执行查询订单的方法进行测试：http://127.0.0.1:8083/list?company=SHENZHEN同样根据分片规则在表t_order_2中进行了实际的查询操作：通过上面的实验，可以看出Sharding-Sphere的配置比较简单，在使用起来也是很方便的，通过客户端分片技术，能够很简单的实现基于分表的多租户需求。

Dataway 是基于 DataQL 服务聚合能力，为应用提供的一个接口配置工具。使得使用者无需开发任何代码就配置一个满足需求的接口。整个接口配置、测试、冒烟、发布。一站式都通过 Dataway 提供的 UI 界面完成。UI 会以 Jar 包方式提供并集成到应用中并和应用共享同一个 http 端口，应用无需单独为 Dataway 开辟新的管理端口。这种内嵌集成方式模式的优点是，可以使得大部分老项目都可以在无侵入的情况下直接应用 Dataway。进而改进老项目的迭代效率，大大减少企业项目研发成本。Dataway 工具化的提供 DataQL 配置能力。这种研发模式的变革使得，相当多的需求开发场景只需要配置即可完成交付。从而避免了从数据存取到前端接口之间的一系列开发任务，例如：Mapper、BO、VO、DO、DAO、Service、Controller 统统不在需要。Dataway 是 Hasor 生态中的一员，因此在 Spring 中使用 Dataway 首先要做的就是打通两个生态。根据官方文档中推荐的方式我们将 Hasor 和 Spring Boot 整合起来。这里是原文：https://www.hasor.net/web/extends/spring/for_boot.html第一步：引入相关依赖<dependency> <groupId>net.hasor</groupId> <artifactId>hasor-spring</artifactId> <version>4.1.3</version> </dependency> <dependency> <groupId>net.hasor</groupId> <artifactId>hasor-dataway</artifactId> <version>4.1.3-fix20200414</version><!-- 4.1.3 包存在UI资源缺失问题 --> </dependency>hasor-spring 负责 Spring 和 Hasor 框架之间的整合。hasor-dataway 是工作在 Hasor 之上，利用 hasor-spring 我们就可以使用 dataway了。第二步：配置 Dataway，并初始化数据表dataway 会提供一个界面让我们配置接口，这一点类似 Swagger 只要jar包集成就可以实现接口配置。找到我们 springboot 项目的配置文件 application.properties# 是否启用 Dataway 功能（必选：默认false） HASOR_DATAQL_DATAWAY=true # 是否开启 Dataway 后台管理界面（必选：默认false） HASOR_DATAQL_DATAWAY_ADMIN=true # dataway API工作路径（可选，默认：/api/） HASOR_DATAQL_DATAWAY_API_URL=/api/ # dataway-ui 的工作路径（可选，默认：/interface-ui/） HASOR_DATAQL_DATAWAY_UI_URL=/interface-ui/ # SQL执行器方言设置（可选，建议设置） HASOR_DATAQL_FX_PAGE_DIALECT=mysqlDataway 一共涉及到 5个可以配置的配置项，但不是所有配置都是必须的。其中 HASOR_DATAQL_DATAWAY 、HASOR_DATAQL_DATAWAY_ADMIN 两个配置是必须要打开的，默认情况下 Datawaty 是不启用的。Dataway 需要两个数据表才能工作，下面是这两个数据表的简表语句。下面这个 SQL 可以在 dataway的依赖 jar 包中 “META-INF/hasor-framework/mysql” 目录下面找到，建表语句是用 mysql 语法写的。CREATE TABLE `interface_info` ( `api_id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'ID', `api_method` varchar(12) NOT NULL COMMENT 'HttpMethod：GET、PUT、POST', `api_path` varchar(512) NOT NULL COMMENT '拦截路径', `api_status` int(2) NOT NULL COMMENT '状态：0草稿，1发布，2有变更，3禁用', `api_comment` varchar(255) NULL COMMENT '注释', `api_type` varchar(24) NOT NULL COMMENT '脚本类型：SQL、DataQL', `api_script` mediumtext NOT NULL COMMENT '查询脚本：xxxxxxx', `api_schema` mediumtext NULL COMMENT '接口的请求/响应数据结构', `api_sample` mediumtext NULL COMMENT '请求/响应/请求头样本数据', `api_create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', `api_gmt_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间', PRIMARY KEY (`api_id`) ) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COMMENT='Dataway 中的API'; CREATE TABLE `interface_release` ( `pub_id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'Publish ID', `pub_api_id` int(11) NOT NULL COMMENT '所属API ID', `pub_method` varchar(12) NOT NULL COMMENT 'HttpMethod：GET、PUT、POST', `pub_path` varchar(512) NOT NULL COMMENT '拦截路径', `pub_status` int(2) NOT NULL COMMENT '状态：0有效，1无效（可能被下线）', `pub_type` varchar(24) NOT NULL COMMENT '脚本类型：SQL、DataQL', `pub_script` mediumtext NOT NULL COMMENT '查询脚本：xxxxxxx', `pub_script_ori` mediumtext NOT NULL COMMENT '原始查询脚本，仅当类型为SQL时不同', `pub_schema` mediumtext NULL COMMENT '接口的请求/响应数据结构', `pub_sample` mediumtext NULL COMMENT '请求/响应/请求头样本数据', `pub_release_time`datetime DEFAULT CURRENT_TIMESTAMP COMMENT '发布时间（下线不更新）', PRIMARY KEY (`pub_id`) ) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COMMENT='Dataway API 发布历史。'; create index idx_interface_release on interface_release (pub_api_id);第三步：配置数据源作为 Spring Boot 项目有着自己完善的数据库方面工具支持。我们这次采用 druid + mysql + spring-boot-starter-jdbc 的方式。首先引入依赖<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.30</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.21</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.10</version> </dependency>然后增加数据源的配置# db spring.datasource.url=jdbc:mysql://xxxxxxx:3306/example spring.datasource.username=xxxxx spring.datasource.password=xxxxx spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.datasource.type:com.alibaba.druid.pool.DruidDataSource # druid spring.datasource.druid.initial-size=3 spring.datasource.druid.min-idle=3 spring.datasource.druid.max-active=10 spring.datasource.druid.max-wait=60000 spring.datasource.druid.stat-view-servlet.login-username=admin spring.datasource.druid.stat-view-servlet.login-password=admin spring.datasource.druid.filter.stat.log-slow-sql=true spring.datasource.druid.filter.stat.slow-sql-millis=1如果项目已经集成了自己的数据源，那么可以忽略第三步。第四步：把数据源设置到 Hasor 容器中Spring Boot 和 Hasor 本是两个独立的容器框架，我们做整合之后为了使用 Dataway 的能力需要把 Spring 中的数据源设置到 Hasor 中。首先新建一个 Hasor 的 模块，并且将其交给 Spring 管理。然后把数据源通过 Spring 注入进来。@DimModule @Component public class ExampleModule implements SpringModule { @Autowired private DataSource dataSource = null; @Override public void loadModule(ApiBinder apiBinder) throws Throwable { // .DataSource form Spring boot into Hasor apiBinder.installModule(new JdbcModule(Level.Full, this.dataSource)); } }Hasor 启动的时候会调用 loadModule 方法，在这里再把 DataSource 设置到 Hasor 中。第五步：在SprintBoot 中启用 Hasor@EnableHasor() @EnableHasorWeb() @SpringBootApplication(scanBasePackages = { "net.example.hasor" }) public class ExampleApplication { public static void main(String[] args) { SpringApplication.run(ExampleApplication.class, args); } }这一步非常简单，只需要在 Spring 启动类上增加两个注解即可。第六步：启动应用应用在启动过程中会看到 Hasor Boot 的欢迎信息_ _ ____ _ | | | | | _ \ | | | |__| | __ _ ___ ___ _ __ | |_) | ___ ___ | |_ | __ |/ _` / __|/ _ \| '__| | _ < / _ \ / _ \| __| | | | | (_| \__ \ (_) | | | |_) | (_) | (_) | |_ |_| |_|\__,_|___/\___/|_| |____/ \___/ \___/ \__|在后面的日志中还可以看到类似下面这些日志。2020-04-14 13:52:59.696 [main] INFO n.h.core.context.TemplateAppContext - loadModule class net.hasor.dataway.config.DatawayModule 2020-04-14 13:52:59.697 [main] INFO n.hasor.dataway.config.DatawayModule - dataway api workAt /api/ 2020-04-14 13:52:59.697 [main] INFO n.h.c.e.AbstractEnvironment - var -> HASOR_DATAQL_DATAWAY_API_URL = /api/. 2020-04-14 13:52:59.704 [main] INFO n.hasor.dataway.config.DatawayModule - dataway admin workAt /interface-ui/ 2020-04-14 13:52:59.716 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[901d38f22faa419a8593bb349905ed0e] -> bindType ‘class net.hasor.dataway.web.ApiDetailController’ mappingTo: ‘[/interface-ui/api/api-detail]’. 2020-04-14 13:52:59.716 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[c6eb9f3b3d4c4c8d8a4f807435538172] -> bindType ‘class net.hasor.dataway.web.ApiHistoryListController’ mappingTo: ‘[/interface-ui/api/api-history]’. 2020-04-14 13:52:59.717 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[eb841dc72ad54023957233ef602c4327] -> bindType ‘class net.hasor.dataway.web.ApiInfoController’ mappingTo: ‘[/interface-ui/api/api-info]’. 2020-04-14 13:52:59.717 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[96aebb46265245459ae21d558e530921] -> bindType ‘class net.hasor.dataway.web.ApiListController’ mappingTo: ‘[/interface-ui/api/api-list]’. 2020-04-14 13:52:59.718 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[7467c07f160244df8f228321f6262d3d] -> bindType ‘class net.hasor.dataway.web.ApiHistoryGetController’ mappingTo: ‘[/interface-ui/api/get-history]’. 2020-04-14 13:52:59.719 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[97d8da5363c741ba99d87c073a344412] -> bindType ‘class net.hasor.dataway.web.DisableController’ mappingTo: ‘[/interface-ui/api/disable]’. 2020-04-14 13:52:59.720 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[8ddc3316ef2642dfa4395ca8ac0fff04] -> bindType ‘class net.hasor.dataway.web.SmokeController’ mappingTo: ‘[/interface-ui/api/smoke]’. 2020-04-14 13:52:59.720 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[cc06c5fb343b471aacedc58fb2fe7bf8] -> bindType ‘class net.hasor.dataway.web.SaveApiController’ mappingTo: ‘[/interface-ui/api/save-api]’. 2020-04-14 13:52:59.720 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[7915b2b1f89a4e73891edab0264c9bd4] -> bindType ‘class net.hasor.dataway.web.PublishController’ mappingTo: ‘[/interface-ui/api/publish]’. 2020-04-14 13:52:59.721 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[0cfa34586455414591bdc389bff23ccb] -> bindType ‘class net.hasor.dataway.web.PerformController’ mappingTo: ‘[/interface-ui/api/perform]’. 2020-04-14 13:52:59.721 [main] INFO net.hasor.core.binder.ApiBinderWrap - mapingTo[37fe4af3e2994ac当看到 “dataway api workAt /api/ ” 、 dataway admin workAt /interface-ui/ 信息时，就可以确定 Dataway 的配置已经生效了。第七步：访问接口管理页面进行接口配置在浏览器中输入 “http://127.0.0.1:8080/interface-ui/” 就可以看到期待已久的界面了。第八步：新建一个接口Dataway 提供了2中语言模式，我们可以使用强大的 DataQL 查询语言，也可以直接使用 SQL 语言（在 Dataway 内部 SQL 语言也会被转换为 DataQL 的形式执行。）首先我们在 SQL 模式下尝试执行一条 select 查询，立刻就可以看到这条 SQL 的查询结果。同样的方式我们使用 DataQL 的方式需要这样写：var query = @@sql()<% select * from interface_info %> return query()其中 var query = @@sql()<% ... %> 是用来定义SQL外部代码块，并将这个定义存入 query 变量名中。<% %> 中间的就是 SQL 语句。最后在 DataQL 中调用这个代码块，并返回查询结果。当接口写好之后就可以保存发布了，为了测试方便，我选用 GET 方式。接口发布之后我们直接请求：http://127.0.0.1:8080/api/demos，就看到期待已久的接口返回值了。最后总结经过上面的几个步骤我们介绍了如何基于 Spring Boot 项目使用 Dataway 来简单的配置接口。Dataway 的方式确实给人耳目一新，一个接口竟然可以如此简单的配置出来无需开发任何一行代码，也不需要做任何 Mapping 实体映射绑定。

问题描述：我是在两个服务之间调用时，在第二个服务打了断点调试，还有就是数据量大的时候，导致了超时，产生了这个异常。原因： 就是连接池为了防止程序取得连接后忘记归还的情况, 而提供了一些参数来设置一个租期, 使用这个可以在一定程度上防止连接泄漏，总括就是系统中事务执行时间过长或者是事务长时间未提交。解决方案：可全局搜索参数：removeAbandonedTimeout首先，检查druid版本是否在1.1.5以后，如果还有问题请进行以下操作。设置removeAbandonedTimeout超时时间，设置成1800（根据估算程序运行时间进行设置，我这边初始设置的是120），并且将removeAbandoned设置为true直接关闭removeAbandoned  改为false或者尝试增加连接池连接数

在系统设计的时候，你是否也遇到过这两个问题：1、大量请求造成数据库压力过大2、大量数据库查询造成请求执行时间过长本文将介绍在高并发、大数据环境下，以上两种问题的应对思路。​​​​​一、请求合并首先思考一个场景，在高并发的系统中，在每秒内有大量的请求要访问数据库，如果不考虑缓存，怎么才能够处理降低数据库压力。有的同学可能会说这多简单啊，增加带宽，加内存提升服务器性能。如果不用这些方法呢？那么就可以用到请求合并的方法，将一段时间内的请求进行合并，然后统一提交查询数据库，能够做到将几十个甚至上百个查询进行批量处理。当然，这么做也有一个前提，就是这些请求对实时性的要求不能太高。在这个条件下，牺牲一定的处理时间，来减少网络连接数，这么处理是一种性价比非常高的方法。​​​​​首先我们模拟一个场景，在不进行合并请求的情况下进行1000次请求，使用Postman进行请求测试，并使用Druid连接池进行数据库的监控：可以看出，实际进行了1000次数据库的访问。在超高流量的情况下，这种访问方式是十分危险的，所以减少数据库的访问就成了当务之急。​​​​​再看看之前提到的请求合并，实现起来有这么几个问题需要解决：​​​​​1、以什么粒度作为合并请求的规则：这里推荐按照时间粒度去合并请求，不推荐按照请求数量达到一定值再进行合并是因为有可能一段时间内请求数量比较少，达不到阈值则无法执行，造成早到达的请求等待非常长的时间。Java中的ScheduledExecutorService提供了定时调度机制，且本身实现了ExecutorService接口，所以本身也支持线程池的所有功能。​​​​​2、如何存放一段时间的请求：存放请求的方式就比较多了，我们知道，在高并发系统的设计中，消息队列被普遍应用于解耦，使用消息队列存放请求是非常合适的做法。由于我们这里是单机环境，能够保证线程安全的阻塞队列LinkedBlockingQueue就能简单实现我们的需求。​​​​​3、如何将请求的结果返回给请求自从JAVA 1.5以后引入了Future接口，用于处理异步调用和并发事务。Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。简单的说，我们可以用它来接收线程的执行结果。好了，请求的合并、执行、返回三大步骤都梳理清楚了，让我们看看具体怎么实现。 @Service public class BatchQueryService { //队列用来存放请求 private LinkedBlockingQueue<Request> queue = new LinkedBlockingQueue<>(); @Autowired ItemService queryItemService; //封装请求 class Request { String code; CompletableFuture<Map<String, Object>> future; public String getCode() { return code; } public void setCode(String code) { this.code = code; } public CompletableFuture<Map<String, Object>> getFuture() { return future; } public void setFuture(CompletableFuture<Map<String, Object>> future) { this.future = future; } } @PostConstruct public void init() { ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1); scheduledExecutorService.scheduleAtFixedRate(() -> { int size = queue.size(); if (size == 0) return; List<Request> requests = new ArrayList<>(size); for (int i = 0; i < size; i++) { Request request = queue.poll(); requests.add(request); } System.out.println("批量处理了" + size + "条请求"); List<String> codes = new ArrayList<>(); for (Request request : requests) { codes.add(request.getCode()); } List<Map<String, Object>> responses = queryItemService.queryByCodes(codes); //结果集完成--> 把请求分发给每一个具体的Request Map<String, Map<String, Object>> responseMap = new HashMap<>(); for (Map<String, Object> response : responses) { String code = response.get("code").toString(); responseMap.put(code, response); } //返回请求 for (Request request : requests) { Map<String, Object> result = responseMap.get(request.getCode()); request.future.complete(result); } }, 0, 200, TimeUnit.MILLISECONDS); } //根据code进行单个查询 public Map<String, Object> queryItem(String code) { Request request = new Request(); request.setCode(code); CompletableFuture<Map<String, Object>> future = new CompletableFuture<>(); request.setFuture(future); queue.add(request); try { return future.get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } return null; } }使用1000个线程对请求合并方法进行测试：@ResponseBody @RequestMapping("/batchQuery") public String batchQuery(){ Thread thread[]=new Thread[1000]; for (int i = 0; i <1000 ; i++) { int j=i; thread[i]=new Thread(new Runnable() { @Override public void run() { queryService.queryItem(j + ""); } }); thread[i].start(); try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } return "ok"; }看一下控制台输出结果：Druid监控：原本1000次的数据库操作被我们减少到了7次，实际对数据库的访问降到了之前的0.7%。当然，实际业务环境中可能定时调度的时间间隔不会增加到200ms这么大，这里只是为了演示一下请求合并能够发挥的巨大潜能。最后对请求合并进行一下总结：​​​​​优点显而易见，通过请求合并减少了数据库的网络连接，降低数据库压力。最大化的利用的系统的IO，来提升系统的吞吐性能。当然它也存在一定的局限性，仅能够用于对请求实时性要求不高的高并发系统，如果系统的应用场景不是在高并发场景下，那么根本没有使用请求合并的必要。​​​​​二、分而治之​​​​​其实在学数据结构和算法的时候，大家应该都接触过分而治之的思想，其实说白了就是递归调用本函数的一个过程，在这个过程中，不断把任务变小，简化计算的流程。这种思想，在进行系统架构的时候同样适用。如果一个请求要访问大量的数据，那么我们就可以将这个任务拆分分别执行，最终再将执行结果返回给客户端。这里就要引入JDK 1.7后提供的一个多线程执行框架Fork/Join，它能够把一个大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果。ForkJoin框架为我们提供了RecursiveAction和RecursiveTask来创建ForkJoin的任务，简单来说：Recursiveaction  用于创建没有返回值的任务RecursiveTask  用于创建有返回值的任务​​​​​举个例子，还是用上一小节中我们的数据，现在数据库中存储了id从0到9999的一万件商品，我们要对其总值进行求和（别问为什么不直接用sum()函数，举个例子而已）。@ResponseBody @RequestMapping("/single") public int single() { long startTime = System.currentTimeMillis(); int sum = 0; for (int i = 0; i < 1000; i++) { sum += itemService.queryByCode(i + "").getPrice(); } System.out.println(sum); long endTime = System.currentTimeMillis(); System.out.println("程序运行时间：" + (endTime - startTime) + "ms"); return sum; }看一下程序运行时间，5235毫秒：使用ForkJoin对任务进行划分：public class ForkJoinTask extends RecursiveTask<Integer> { private int arr[]; private int start; private int end; private static final int MAX = 500; public ForkJoinTask(int[] arr, int start, int end){ this.arr=arr; this.start = start; this.end = end; } @Override protected Integer compute() { int sum=0; if((end - start) < MAX) { //直接做业务工作 for (int i = start; i < end; i++) { sum += arr[i]; } return sum; } else{ //继续拆分 int middle = (start + end) / 2; ForkJoinTask left=new ForkJoinTask(arr, start, middle); ForkJoinTask right=new ForkJoinTask(arr, middle, end); left.fork(); right.fork(); return left.join() + right.join(); } } }再运行测试：@ResponseBody @RequestMapping("/fork") public int forkJoin() { long startTime = System.currentTimeMillis(); int arr[] = new int[10000]; for (int i = 0; i < 1000; i++) { arr[i]=i; } ForkJoinPool pool=new ForkJoinPool(); ForkJoinTask task=new ForkJoinTask(arr,0,arr.length); Integer sum = pool.invoke(task); System.out.println(sum); long endTime = System.currentTimeMillis(); System.out.println("程序运行时间：" + (endTime - startTime) + "ms"); return sum; }再看一下程序运行时间，只有6毫秒：是不是觉得快了很多，直接将运行速度提升了800多倍！其实ForkJoin运行速度快的原因还有一个黑科技，那就是当一个线程在完成自己的任务队列的处理任务后，会帮助其他线程完成任务，完成后再放回其他队列，这也被称为工作窃取。如上图所示，线程1在完成自己的任务后，发现线程2还有任务没有完成，这时它会去取到线程2没有完成的任务，做完后再把结果放回线程2。​​​​​除此之外，我们还可以通过增加线程数量进一步加快运行速度，线程数量的选择可以根据具体业务环境进行配置优化。ForkJoinPool pool=new ForkJoinPool(Runtime.getRuntime().availableProcessors()*4);总结：本文分别从请求合并和分而治之两种角度介绍了系统的优化，可以看出，在平常的工作中，代码优化这一条路还有很长要走。文中所有的代码大家可以从我的github获取。https://github.com/trunks2008/RequestMerge

前言  时光匆匆，不知不觉岁月的脚步已度过半年，时常感叹岁月如歌，时光在我们指尖流逝，换为一段段优雅的代码，在诉说着时光的印记。小阿杰加入掘金以来，在今年上半年才开始创作的历程，也收获了很多志同道合的朋友们。  告别2021，迎接2022。回首2021，如昨日般历历在目，迎接未来已充满豪情壮志。2021年，感谢家人的支持，2021年感谢朋友们的帮助和鼓励，2021年感谢掘友们的砥砺前行，一直在卷的道路上越走越远。回首2021  在2021年6月份，参加了2021 年中总结的征文【新晋奶爸，在技术路上不断前进 ｜2021 年中总结】，是对自己2021年上半年的一个总结，不知不觉，已经到了2021年的岁末。时光如梭，年末的总结又吹响了号角，2021年下半年经历了双十一，也进行了多次掘金的活动，收获了很多。回顾掘金收获  2021年在掘金，截止2012年12月20日，在掘金共计发文91篇，发布沸点79个，收获了211个关注着，关注了174位掘友，文章总计被阅读了70695次，文章被点赞了1720次，文章被评论了227次，掘力值为：2429。共创建了四个专栏，其中专栏关注最多的是61人关注。专栏1 ： Spring Boot 快速入门专栏2 ： 从零开始搭建个人技术博客专栏3 ： Java全栈架构师专栏4 ： Spring Cloud系列  从收藏数、点赞数、阅读数、评论数几个维度，人肉进行了分析如下：收藏数在2021年收藏数最多的文章是：【Spring Boot 快速入门】十一、Spring Boot集成AutoGenerator代码生成器点赞数在2021年点赞数最多的文章是：新晋奶爸，在技术路上不断前进 ｜2021 年中总结阅读数在2021年阅读数最多的文章是：【Spring Boot 快速入门】十、Spring Boot集成Druid数据监控评论数在2021年评论数最多的文章是：【Spring Boot 快速入门】十一、Spring Boot集成AutoGenerator代码生成器

脚手架项目地址：https://github.com/Vip-Augus/springboot-noteTable of Contents generated with DocTocSpringBoot 速记一、引入依赖二、配置 Swagger 参数一、引入依赖二、配置邮箱的参数三、写模板和发送内容一、引用 Redis 依赖二、参数配置三、代码使用一、添加 mybatis 和 druid 依赖二、配置数据库和连接池参数三、其他 mybatis 配置@ExceptionHandler 错误处理@ModelAttribute 视图属性常规配置HTTPS 配置构建项目SpringBoot 基础配置Spring Boot Starters@SpringBootApplicationWeb 容器配置@ConfigurationPropertiesProfile@ControllerAdvice 用来处理全局数据CORS 支持，跨域资源共享注册 MVC 拦截器开启 AOP 切面控制整合 Mybatis 和 Druid整合 Redis发送 HTML 样式的邮件整合 Swagger (API 文档)总结参考资料构建项目相比于使用 IDEA 的模板创建项目，我更推荐的是在 Spring 官网上选择参数一步生成项目https://start.spring.io/我们只需要做的事情，就是修改组织名和项目名，点击 Generate the project，下载到本地，然后使用 IDEA 打开这个时候，不需要任何配置，点击 Application 类的 run 方法就能直接启动项目。SpringBoot 基础配置Spring Boot Starters引用自参考资料 1 描述：“starter的理念：starter 会把所有用到的依赖都给包含进来，避免了开发者自己去引入依赖所带来的麻烦。需要注意的是不同的 starter 是为了解决不同的依赖，所以它们内部的实现可能会有很大的差异，例如 jpa 的 starter 和 Redis 的 starter 可能实现就不一样，这是因为 starter 的本质在于 synthesize，这是一层在逻辑层面的抽象，也许这种理念有点类似于 Docker，因为它们都是在做一个“包装”的操作，如果你知道 Docker 是为了解决什么问题的，也许你可以用 Docker 和 starter 做一个类比。”我们知道在 SpringBoot 中很重要的一个概念就是，「约定优于配置」，通过特定方式的配置，可以减少很多步骤来实现想要的功能。例如如果我们想要使用缓存 Redis在之前的可能需要通过以下几个步骤：在 pom 文件引入特定版本的 redis在 .properties 文件中配置参数根据参数，新建一个又一个 jedis 连接定义一个工具类，手动创建连接池来管理经历了上面的步骤，我们才能正式使用 Redis但在 Spring Boot 中，一切因为 Starter 变得简单在 pom 文件中引入 spring-boot-starter-data-redis在 .properties 文件中配置参数通过上面两个步骤，配置自动生效，具体生效的 bean 是 RedisAutoConfiguration，自动配置类的名字都有一个特点，叫做 xxxAutoConfiguration。可以来简单看下这个类：@Configuration @ConditionalOnClass(RedisOperations.class) @EnableConfigurationProperties(RedisProperties.class) @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class }) public class RedisAutoConfiguration { @Bean @ConditionalOnMissingBean(name = "redisTemplate") public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { RedisTemplate<Object, Object> template = new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); return template; } @Bean @ConditionalOnMissingBean public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { StringRedisTemplate template = new StringRedisTemplate(); template.setConnectionFactory(redisConnectionFactory); return template; } } @ConfigurationProperties(prefix = "spring.redis") public class RedisProperties {...}可以看到，Redis 自动配置类，读取了以 spring.redis 为前缀的配置，然后加载 redisTemplate 到容器中，然后我们在应用中就能使用 RedisTemplate 来对缓存进行操作~（还有很多细节没有细说，例如 @ConditionalOnMissingBean 先留个坑(●´∀｀●)ﾉ）@Autowired private RedisTemplate redisTemplate; ValueOperations ops2 = redisTemplate.opsForValue(); Book book = (Book) ops2.get("b1");@SpringBootApplication该注解是加载项目的启动类上的，而且它是一个组合注解：@SpringBootConfiguration @EnableAutoConfiguration @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) public @interface SpringBootApplication {...}下面是这三个核心注解的解释：注解名解释@SpringBootConfiguration表明这是一个配置类，开发者可以在这个类中配置 Bean@EnableAutoConfiguration表示开启自动化配置@ComponentScan完成包扫描，默认扫描的类位于当前类所在包的下面通过该注解，我们执行 mian 方法：SpringApplication.run(SpringBootLearnApplication.class, args);就可以启动一个 SpringApplicaiton 应用了。Web 容器配置常规配置配置名解释server.port=8081配置了容器的端口号，默认是 8080server.error.path=/error配置了项目出错时跳转的页面server.servlet.session.timeout=30msession 失效时间，m 表示分钟，如果不写单位，默认是秒 sserver.servlet.context-path=/项目名称，不配置时默认为/。配置后，访问时需加上前缀server.tomcat.uri-encoding=utf-8Tomcat 请求编码格式server.tomcat.max-threads=500Tomcat 最大线程数server.tomcat.basedir=/home/tmpTomcat 运行日志和临时文件的目录，如不配置，默认使用系统的临时目录HTTPS 配置配置名解释server.ssl.key-store=xxx秘钥文件名server.ssl.key-alias=xxx秘钥别名server.ssl.key-store-password=123456秘钥密码想要详细了解如何配置 HTTPS，可以参考这篇文章 Spring Boot 使用SSL-HTTPS@ConfigurationProperties这个注解可以放在类上或者 @Bean 注解所在方法上，这样 SpringBoot 就能够从配置文件中，读取特定前缀的配置，将属性值注入到对应的属性。使用例子：@Configuration @ConfigurationProperties(prefix = "spring.datasource") public class DruidConfigBean { private Integer initialSize; private Integer minIdle; private Integer maxActive; private List<String> customs; ... } application.properties spring.datasource.initialSize=5 spring.datasource.minIdle=5 spring.datasource.maxActive=20 spring.datasource.customs=test1,test2,test3其中，如果对象是列表结构，可以在配置文件中使用 , 逗号进行分割，然后注入到相应的属性中。Profile使用该属性，可以快速切换配置文件，在 SpringBoot 默认约定中，不同环境下配置文件名称规则为 application-{profile}.propertie，profile 占位符表示当前环境的名称。1、配置 application.propertiesspring.profiles.active=dev2、在代码中配置 在启动类的 main 方法上添加 setAdditionalProfiles("{profile}");SpringApplicationBuilder builder = new SpringApplicationBuilder(SpringBootLearnApplication.class); builder.application().setAdditionalProfiles("prod"); builder.run(args);3、启动参数配置java -jar demo.jar --spring.active.profile=dev@ControllerAdvice 用来处理全局数据@ControllerAdvice 是 @Controller 的增强版。主要用来处理全局数据，一般搭配 @ExceptionHandler 、@ModelAttribute 以及 @InitBinder 使用。@ExceptionHandler 错误处理/** * 加强版控制器，拦截自定义的异常处理 * */ @ControllerAdvice public class CustomExceptionHandler { // 指定全局拦截的异常类型，统一处理 @ExceptionHandler(MaxUploadSizeExceededException.class) public void uploadException(MaxUploadSizeExceededException e, HttpServletResponse response) throws IOException { response.setContentType("text/html;charset=utf-8"); PrintWriter out = response.getWriter(); out.write("上传文件大小超出限制"); out.flush(); out.close(); } }@ModelAttribute 视图属性@ControllerAdvice public class CustomModelAttribute { // @ModelAttribute(value = "info") public Map<String, String> userInfo() throws IOException { Map<String, String> map = new HashMap<>(); map.put("test", "testInfo"); return map; } } @GetMapping("/hello") public String hello(Model model) { Map<String, Object> map = model.asMap(); Map<String, String> infoMap = (Map<String, String>) map.get("info"); return infoMap.get("test"); }key : @ModelAttribute 注解中的 value 属性使用场景：任何请求 controller 类，通过方法参数中的 Model 都可以获取 value 对应的属性关注公众号Java后端编程，回复 Java 获取最新学习资料 。CORS 支持，跨域资源共享CORS（Cross-Origin Resource Sharing），跨域资源共享技术，目的是为了解决前端的跨域请求。“引用：当一个资源从与该资源本身所在服务器不同的域或端口请求一个资源时，资源会发起一个跨域HTTP请求”详细可以参考这篇文章-springboot系列文章之实现跨域请求(CORS)，这里只是记录一下如何使用：例如在我的前后端分离 demo 中，如果没有通过 Nginx 转发，那么将会提示如下信息：“Access to fetch at ‘http://localhost:8888/login‘ from origin ‘http://localhost:3000‘ has been blocked by CORS policy: Response to preflight request doesn’t pass access control check: The value of the ‘Access-Control-Allow-Credentials’ header in the response is ‘’ which must be ‘true’ when the request’s credentials mode is ‘include’”为了解决这个问题，在前端不修改的情况下，需要后端加上如下两行代码：// 第一行，支持的域 @CrossOrigin(origins = "http://localhost:3000") @RequestMapping(value = "/login", method = RequestMethod.GET) @ResponseBody public String login(HttpServletResponse response) { // 第二行，响应体添加头信息（这一行是解决上面的提示） response.setHeader("Access-Control-Allow-Credentials", "true"); return HttpRequestUtils.login(); }注册 MVC 拦截器在 MVC 模块中，也提供了类似 AOP 切面管理的扩展，能够拥有更加精细的拦截处理能力。核心在于该接口：HandlerInterceptor，使用方式如下：/** * 自定义 MVC 拦截器 */ public class MyInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 在 controller 方法之前调用 return true; } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { // 在 controller 方法之后调用 } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { // 在 postHandle 方法之后调用 } }注册代码：/** * 全局控制的 mvc 配置 */ @Configuration public class MyWebMvcConfig implements WebMvcConfigurer { @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new MyInterceptor()) // 表示拦截的 URL .addPathPatterns("/**") // 表示需要排除的路径 .excludePathPatterns("/hello"); } }拦截器执行顺序：preHandle -> controller -> postHandle -> afterCompletion，同时需要注意的是，只有 preHandle 方法返回 true，后面的方法才会继续执行。开启 AOP 切面控制切面注入是老生常谈的技术，之前学习 Spring 时也有了解，可以参考我之前写过的文章参考一下：Spring自定义注解实现AOPSpring 源码学习(八) AOP 使用和实现原理在 SpringBoot 中，使用起来更加简便，只需要加入该依赖，使用方法与上面一样。<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency>整合 Mybatis 和 DruidSpringBoot 整合数据库操作，目前主流使用的是 Druid 连接池和 Mybatis 持久层，同样的，starter 提供了简洁的整合方案项目结构如下：一、添加 mybatis 和 druid 依赖二、配置数据库和连接池参数# 数据库配置 spring.datasource.type=com.alibaba.druid.pool.DruidDataSource spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true spring.datasource.username=root spring.datasource.password=12345678 # druid 配置 spring.datasource.druid.initial-size=5 spring.datasource.druid.max-active=20 spring.datasource.druid.min-idle=5 spring.datasource.druid.max-wait=60000 spring.datasource.druid.pool-prepared-statements=true spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20 spring.datasource.druid.max-open-prepared-statements=20 spring.datasource.druid.validation-query=SELECT 1 spring.datasource.druid.validation-query-timeout=30000 spring.datasource.druid.test-on-borrow=true spring.datasource.druid.test-on-return=false spring.datasource.druid.test-while-idle=false #spring.datasource.druid.time-between-eviction-runs-millis= #spring.datasource.druid.min-evictable-idle-time-millis= #spring.datasource.druid.max-evictable-idle-time-millis=10000 # Druid stat filter config spring.datasource.druid.filters=stat,wall spring.datasource.druid.web-stat-filter.enabled=true spring.datasource.druid.web-stat-filter.url-pattern=/* # session 监控 spring.datasource.druid.web-stat-filter.session-stat-enable=true spring.datasource.druid.web-stat-filter.session-stat-max-count=10 spring.datasource.druid.web-stat-filter.principal-session-name=admin spring.datasource.druid.web-stat-filter.principal-cookie-name=admin spring.datasource.druid.web-stat-filter.profile-enable=true # stat 监控 spring.datasource.druid.web-stat-filter.exclusions=*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/* spring.datasource.druid.filter.stat.db-type=mysql spring.datasource.druid.filter.stat.log-slow-sql=true spring.datasource.druid.filter.stat.slow-sql-millis=1000 spring.datasource.druid.filter.stat.merge-sql=true spring.datasource.druid.filter.wall.enabled=true spring.datasource.druid.filter.wall.db-type=mysql spring.datasource.druid.filter.wall.config.delete-allow=true spring.datasource.druid.filter.wall.config.drop-table-allow=false # Druid manage page config spring.datasource.druid.stat-view-servlet.enabled=true spring.datasource.druid.stat-view-servlet.url-pattern=/druid/* spring.datasource.druid.stat-view-servlet.reset-enable=true spring.datasource.druid.stat-view-servlet.login-username=admin spring.datasource.druid.stat-view-servlet.login-password=admin #spring.datasource.druid.stat-view-servlet.allow= #spring.datasource.druid.stat-view-servlet.deny= spring.datasource.druid.aop-patterns=cn.sevenyuan.demo.*三、其他 mybatis 配置本地工程，将 xml 文件放入 resources 资源文件夹下，所以需要加入以下配置，让应用进行识别： <build> <resources> <resource> <directory>src/main/resources</directory> <includes> <include>**/*</include> </includes> </resource> </resources> ... </build>通过上面的配置，我本地开启了三个页面的监控：SQL 、 URL 和 Sprint 监控，如下图：通过上面的配置，SpringBoot 很方便的就整合了 Druid 和 mybatis，同时根据在 properties 文件中配置的参数，开启了 Druid 的监控。但我根据上面的配置，始终开启不了 session 监控，所以如果需要配置 session 监控或者调整参数具体配置，可以查看官方网站整合 Redis我用过 Redis 和 NoSQL，但最熟悉和常用的，还是 Redis ，所以这里记录一下如何整合一、引用 Redis 依赖<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <exclusions> <exclusion> <artifactId>lettuce-core</artifactId> <groupId>io.lettuce</groupId> </exclusion> </exclusions> </dependency> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency>二、参数配置# redis 配置 spring.redis.database=0 spring.redis.host=localhost spring.redis.port=6379 spring.redis.password= spring.redis.jedis.pool.max-active=8 spring.redis.jedis.pool.max-idle=8 spring.redis.jedis.pool.max-wait=-1ms spring.redis.jedis.pool.min-idle=0三、代码使用@Autowired private RedisTemplate redisTemplate; @Autowired private StringRedisTemplate stringRedisTemplate; @GetMapping("/testRedis") public Book getForRedis() { ValueOperations<String, String> ops1 = stringRedisTemplate.opsForValue(); ops1.set("name", "Go 语言实战"); String name = ops1.get("name"); System.out.println(name); ValueOperations ops2 = redisTemplate.opsForValue(); Book book = (Book) ops2.get("b1"); if (book == null) { book = new Book("Go 语言实战", 2, "none name", BigDecimal.ONE); ops2.set("b1", book); } return book; }这里只是简单记录引用和使用方式，更多功能可以看这里：发送 HTML 样式的邮件之前也使用过，所以可以参考这篇文章：一、引入依赖 <!-- mail --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-mail</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency>二、配置邮箱的参数# mail spring.mail.host=smtp.qq.com spring.mail.port=465 spring.mail.username=xxxxxxxx spring.mail.password=xxxxxxxx spring.mail.default-encoding=UTF-8 spring.mail.properties.mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory spring.mail.properties.mail.debug=true如果使用的是 QQ 邮箱，需要在邮箱的设置中获取授权码，填入上面的 password 中三、写模板和发送内容MailServiceImpl.java @Autowired private JavaMailSender javaMailSender; @Override public void sendHtmlMail(String from, String to, String subject, String content) { try { MimeMessage message = javaMailSender.createMimeMessage(); MimeMessageHelper helper = new MimeMessageHelper(message, true); helper.setFrom(from); helper.setTo(to); helper.setSubject(subject); helper.setText(content, true); javaMailSender.send(message); } catch (MessagingException e) { System.out.println("发送邮件失败"); log.error("发送邮件失败", e); } } mailtemplate.html <!DOCTYPE html> <html lang="en" xmlns:th="http://www.thymeleaf.org"> <head> <meta charset="UTF-8"> <title>邮件</title> </head> <body> <div th:text="${subject}"></div> <div>书籍清单 <table border="1"> <tr> <td>图书编号</td> <td>图书名称</td> <td>图书作者</td> </tr> <tr th:each="book:${books}"> <td th:text="${book.id}"></td> <td th:text="${book.name}"></td> <td th:text="${book.author}"></td> </tr> </table> </div> </body> </html> test.java @Autowired private MailService mailService; @Autowired private TemplateEngine templateEngine; @Test public void sendThymeleafMail() { Context context = new Context(); context.setVariable("subject", "图书清册"); List<Book> books = Lists.newArrayList(); books.add(new Book("Go 语言基础", 1, "nonename", BigDecimal.TEN)); books.add(new Book("Go 语言实战", 2, "nonename", BigDecimal.TEN)); books.add(new Book("Go 语言进阶", 3, "nonename", BigDecimal.TEN)); context.setVariable("books", books); String mail = templateEngine.process("mailtemplate.html", context); mailService.sendHtmlMail("xxxx@qq.com", "xxxxxxxx@qq.com", "图书清册", mail); }通过上面简单步骤，就能够在代码中发送邮件，例如我们每周要写周报，统计系统运行状态，可以设定定时任务，统计数据，然后自动化发送邮件。整合 Swagger (API 文档)一、引入依赖<!-- swagger --> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.9.2</version> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger-ui</artifactId> <version>2.9.2</version> </dependency>二、配置 Swagger 参数SwaggerConfig.java @Configuration @EnableSwagger2 @EnableWebMvc public class SwaggerConfig { @Bean Docket docket() { return new Docket(DocumentationType.SWAGGER_2) .select() .apis(RequestHandlerSelectors.basePackage("cn.sevenyuan.demo.controller")) .paths(PathSelectors.any()) .build().apiInfo( new ApiInfoBuilder() .description("Spring Boot learn project") .contact(new Contact("JingQ", "https://github.com/vip-augus", "=-=@qq.com")) .version("v1.0") .title("API 测试文档") .license("Apache2.0") .licenseUrl("http://www.apache.org/licenese/LICENSE-2.0") .build()); } }设置页面 UI@Configuration @EnableRedisHttpSession(maxInactiveIntervalInSeconds = 60) public class MyWebMvcConfig implements WebMvcConfigurer { @Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("swagger-ui.html") .addResourceLocations("classpath:/META-INF/resources/"); registry.addResourceHandler("/webjars/**") .addResourceLocations("classpath:/META-INF/resources/webjars/"); } }通过这样就能够识别 @ApiOperation 等接口标志，在网页查看 API 文档，参考文档：Spring Boot实战：集成Swagger2总结这边总结的整合经验，只是很基础的配置，在学习的初期，秉着先跑起来，然后不断完善和精进学习。而且单一整合很容易，但多个依赖会出现想不到的错误，所以在解决环境问题时遇到很多坑，想要使用基础的脚手架，可以尝试跑我上传的项目。数据库脚本在 resources 目录的 test.sql 文件中

前言  Druid Spring Boot Starter 用于帮助你在Spring Boot项目中轻松集成Druid数据库连接池和监控。本文将结合Spring Boot集成Druid，进行数据源监控。初识Druid  Druid是阿里开源的一个JDBC应用组件， 其包括三部分：DruidDriver 代理Driver，能够提供基于Filter－Chain模式的插件体系； DruidDataSource 高效可管理的数据库连接池；SQLParser SQL语法分析；Druid是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。下载Druid  Druid是一个开源项目，源码托管在github上，源代码仓库地址是 github.com/alibaba/dru… 。同时每次Druid发布正式版本和快照的时候，都会把源码打包，你可以从上面的下载地址中找到相关版本的源码。DruidDataSource支持数据库  理论上说，支持所有有jdbc驱动的数据库。实际测试过的有数据库支持状态mysql支持，大规模使用oracle支持，大规模使用sqlserver支持postgres支持db2支持h2支持derby支持sqlite支持sybase支持Druid自动识别DriverClass   Druid是根据url前缀来识别DriverClass的，这样使得配置更方便简洁。前缀DriverCLass描述信息jdbc:odpscom.aliyun.odps.jdbc.OdpsDriverjdbc:derbyorg.apache.derby.jdbc.EmbeddedDriverjdbc:mysqlcom.mysql.jdbc.Driverjdbc:oracleoracle.jdbc.driver.OracleDriverjdbc:microsoftcom.microsoft.jdbc.sqlserver.SQLServerDriverjdbc:sybase:Tdscom.sybase.jdbc2.jdbc.SybDriverjdbc:jtdsnet.sourceforge.jtds.jdbc.Driverjdbc:postgresqlorg.postgresql.Driverjdbc:fakecom.alibaba.druid.mock.MockDriverjdbc:mockcom.alibaba.druid.mock.MockDriverjdbc:hsqldborg.hsqldb.jdbcDriverjdbc:db2com.ibm.db2.jdbc.app.DB2DriverDB2的JDBC Driver十分混乱，这个匹配不一定对jdbc:sqliteorg.sqlite.JDBCjdbc:ingrescom.ingres.jdbc.IngresDriverjdbc:h2org.h2.Driverjdbc:mckoicom.mckoi.JDBCDriverjdbc:cloudscapecom.cloudscape.core.JDBCDriverjdbc:informix-sqlicom.informix.jdbc.IfxDriverjdbc:timestencom.timesten.jdbc.TimesTenDriverjdbc:as400com.ibm.as400.access.AS400JDBCDriverjdbc:sapdbcom.sap.dbtech.jdbc.DriverSapDBjdbc:JSQLConnectcom.jnetdirect.jsql.JSQLDriverjdbc:JTurbocom.newatlanta.jturbo.driver.Driverjdbc:firebirdsqlorg.firebirdsql.jdbc.FBDriverjdbc:interbaseinterbase.interclient.Driverjdbc:pointbasecom.pointbase.jdbc.jdbcUniversalDriverjdbc:edbcca.edbc.jdbc.EdbcDriverjdbc:mimer:multi1com.mimer.jdbc.Driver快速开始加入依赖  Druid 0.1.18 之后版本都发布到maven中央仓库中，所以你只需要在项目的pom.xml中加上dependency就可以了。<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <!-- mybatis-spring-boot-starter --> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.1</version> </dependency> <!-- druid --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.11</version> </dependency>  主要使用到的依赖是druid这个依赖，其他的是MySQL和MyBatis的依赖。方便连接数据库使用。配置DruidMoniterConfig  配置一个Druid监控管理后台,主要是为了在WEB端可以查看监控管理信息。主要的配置信息有用户名、用户名密码、允许访问的权限路径、黑名单的IP等信息。然后需要配置一个web监控的filter，过滤静态文件/** * @ClassName DruidMoniterConfig * @Description: DruidMoniterConfig * @Author JavaZhan @公众号:Java全栈架构师 * @Date 2020/6/13 * @Version V1.0 **/ @Configuration public class DruidMoniterConfig{ @Bean public ServletRegistrationBean statViewServlet(){ ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*"); Map<String,String> initParams = new HashMap<>(); initParams.put("loginUsername","admin"); initParams.put("loginPassword","admin"); initParams.put("allow",""); initParams.put("deny","192.168.127.98"); bean.setInitParameters(initParams); return bean; } @Bean public FilterRegistrationBean webStatFilter(){ FilterRegistrationBean bean = new FilterRegistrationBean(); bean.setFilter(new WebStatFilter()); Map<String,String> initParams = new HashMap<>(); initParams.put("exclusions","*.js,*.css,/druid/*"); bean.setInitParameters(initParams); bean.setUrlPatterns(Arrays.asList("/*")); return bean; } }基础配置信息  配置文件主要包含数据源的URL、数据库用户名、数据库密码、驱动类等数据源相关配置信息。server.port=8888 # mysql spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull spring.datasource.username=test spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.datasource.type=com.alibaba.druid.pool.DruidDataSource mybatis.mapper-locations=classpath*:mapper/**/*.xml启动类/** * @ClassName DemoMyBatisApplication * @Description: DemoMyBatisApplication * @Author JavaZhan @公众号:Java全栈架构师 * @Date 2020/6/13 * @Version V1.0 **/ @SpringBootApplication @MapperScan("com.example.demo.mapper") public class DemoMyBatisApplication { public static void main(String[] args) { SpringApplication.run(DemoMyBatisApplication.class, args); } }监控页面  启动项目之后，在浏览器中输入http://127.0.0.1:8888/druid/，自动跳转到http://127.0.0.1:8888/druid/login.html页面，需要输入用户名和密码信息输入用户名和密码后，进入监控页面，页面信息如下：主要包含：数据源、SQL监控、SQL防火墙、Web应用、URI监控、session监控、 Spring监控、 JSON API等信息。好了Spring Boot集成Druid数据监控就已经完成了。结语  Spring Boot集成Druid数据监控，方便我们进行数据库连接的数据信息分析，对sql进行监控，都是基础入门的教程，更深入的配置将在以后教程中讲解。