002-SpringBoot

从此，程序员们有了更多时间去陪妹子逛街买裙子。

没有女朋友的小伙伴们，也有了更多时间思考追女孩的方案（一定要勇敢地行动呀）。

从一定程度上讲，Spring Boot 降低了程序员群体的单身比例。

 args 是命令行参数，此处没啥作用；

另一个参数是 SpringBootHelloApplication.class ，包含类的信息。

后端服务化的方式，也是当前主流方式。

前端是静态的 HTML 页面，通过 Ajax 请求 Spring Boot 的后端接口。

Spring Boot 返回数据一般采用 JSON 格式，前端接收后将数据显示。

前端的请求，到达 Spring Boot 的控制器后，控制器处理请求，然后将返回数据交给模板引擎。

模板引擎负责根据数据生成 HTML 页面，最后将 HTML 返回给浏览器。

简单的目的就是提高开发效率；

简单主要是依赖 Spring Boot 实现

明确的目的是统一规范，从而降低沟通成本，最终也是为了提高开发效率。

明确就是靠 RESTful 风格来规范。

# 公众号appid
wxmp.appid=111
# 公众号secret
wxmp.secret=222

//微信公众号参数
@Component//注册为组件
public class WxMpParam {
     @Value("${wxmp.appid}")//注入wxmp.appid配置项
     private String appid;
     @Value("${wxmp.secret}")//注入wxmp.secret配置项
     private String secret;
     //省略get set方法
}

@RestController 
public class HelloController {
   @Autowired
   private WxMpParam wxMpParam;
   @GetMapping("/hello") 
   public Map hello() {
     Map<String, String> map = new HashMap<String, String>();
        map.put("appid",wxMpParam.getAppid());
        map.put("secret",wxMpParam.getSecret());
         return map;
   }
}

前后端实际上互相不必直接沟通，

他们之间的交流是通过 API 文档完成的

在控制器类中编写获取商品列表的接口供前端调用。

它是衡量硬盘读写性能的一个指标

一般建议：要采用 IOPS > 3800 的云磁盘。

在购买云服务器时务必关注下云硬盘的 IOPS 值

打包后生成的文件内容

显式指定打包方式为 war

<groupId>com.imooc</groupId>
 <artifactId>spring-boot-cors</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>spring-boot-cors</name>
 <description>Demo project for Spring Boot</description>
  <packaging>war</packaging>

由于 Spring Boot 内置了 Tomcat ，所以在打包时需要排除内置的 Tomcat ，

避免内置 Tomcat 和 war 包部署运行的 Tomcat 产生冲突。

在 pom.xml 中添加如下依赖即可：

<!--打war包时排除内置的tomcat-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>

然后，还需要继承 SpringBootServletInitializer 类并重写 configure 方法

目的：，告诉 Tomcat 当前应用的入口在哪

@SpringBootApplication
public class SpringBootCorsApplication extends SpringBootServletInitializer {
 @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringBootCorsApplication.class);
    }
 public static void main(String[] args) {
  SpringApplication.run(SpringBootCorsApplication.class, args);
 }
}

子主题

最后，即可同样使用 mvn clean package -Dmaven.test.skip=true 命令打包应用了

运行命令后会在 target 目录下生成 war 文件

将该文件放置于 Tomcat 的 webapps 目录下运行即可。

nginx 下载链接

$.ajax({
      type: "GET",
      url: "http://x.x.x.x:8080/goods", //后端接口地址
      dataType: "json",
      contentType: "application/json; charset=utf-8",
      success: function (res) {
        $.each(res, function (i, v) {
          row = "<tr>";
          row += "<td>" + v.id + "</td>";
          row += "<td>" + v.name + "</td>";
          row += "<td>" + v.price + "</td>";
          row += "<td>" + v.pic + "</td>";
          row += "</tr>";
          $("#goodsTable").append(row);
        });
      },
      error: function (err) {
        console.log(err);
      }
    });

HTTP 代表协议

 x.x.x.x 代表云服务器公网地址

 8080 是后端项目的启动端口，

最后 goods 是控制器中设定的后端接口路径。

nginx 已启动成功

<!-- 热部署 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
  </dependency>
  <!-- web -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <!-- jdbc -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
  </dependency>
  <!-- myql驱动 -->
  <dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
  </dependency>

项目目录

***************************
APPLICATION FAILED TO START
***************************
Description:
Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.
Reason: Failed to determine a suitable driver class

没有合适的数据库驱动、也没有合适的 URL 属性。

Spring Boot 自动配置JdbcTemplate之余，还在尝试自动配置数据源 DataSource 

数据源 DataSource，即 JdbcTemplate 要操作的真实数据库信息。

报错信息已经提示，没有合适的数据库驱动、也没有合适的 URL 属性。

# 配置数据库驱动
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# 配置数据库url
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/shop?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
# 配置数据库用户名
spring.datasource.username=root
# 配置数据库密码
spring.datasource.password=123456

指定了编码方式

指定了时区

后端访问接口

GoodsController

<!-- 热部署 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
  </dependency>
  <!-- web -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <!-- jdbc -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
  </dependency>
  <!-- myql驱动 -->
  <dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
  </dependency>

GoodsDo

GoodsDao

注意，Spring Boot 进行测试时，需要添加注解 @SpringBootTest 。

添加注解后，该类可以直接通过 @Test 标注的方法发起单元测试，容器环境都已准备好，非常方便。

通过@SpringBootTest注解，开启测试类功能，当测试方法启动时，启动了Spring容器

@SpringBootTest
class SpringBootHikariApplicationTests {
 @Autowired
 private DataSource dataSource;// 自动注入数据源
 @Autowired
 private GoodsDao goodsDao;

 //打印数据源信息
 @Test // 测试方法
 void printDataSource() {
  System.out.println(dataSource);
 }

 //批量插入测试
 @Test
 void insertBatch() {
  // 开始时间
  long startTime = System.currentTimeMillis();
  // 执行1000次插入
  GoodsDo goods = new GoodsDo();
  goods.setName("测试");
  goods.setPic("测试图片");
  goods.setPrice("1.0");
  for (int i = 0; i < 1000; i++) {
   goodsDao.insert(goods);
  }
  // 输出操作时间
  System.out.println("use time:" + (System.currentTimeMillis() - startTime)+"ms");
 }
}

默认数据源类型为 HikariDataSource 

插入 1000 条数据的时间大概为 1500ms

（注意时间可能跟电脑性能等很多因素相关，此处只是进行简单的对比测试）。

use time:1518ms
com.zaxxer.hikari.HikariDataSource

<!-- 热部署 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
  </dependency>
  <!-- web -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <!-- jdbc -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
  </dependency>
  <!-- myql驱动 -->
  <dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
  </dependency>
  <!-- springboot druid -->
  <dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid-spring-boot-starter</artifactId>
   <version>1.1.22</version>
  </dependency>

use time:1428ms
com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceWrapper

其实只能得出一个结论，在某些场景下 Druid 的速度不比 Hikari 慢，甚至还略胜一筹。

当然我们只是对两种数据源的默认配置、单一线程情况进行了简单测试，

Druid配置代码

注意设定了监控功能的账号和密码。

此时打开网址 http://127.0.0.1:8080/druid 

即可显示 Druid 登录页面

将接口标注为数据访问层组件

//商品服务类 
@Service
public class GoodsService {
 @Autowired
 private IGoodsDao goodsDao;

 // 新增商品 
 public void add(GoodsDo goods) {
  goodsDao.save(goods);
 }

 //删除商品 
 public void remove(Long id) {
  goodsDao.deleteById(id);
 }

 //编辑商品信息 
 public void edit(GoodsDo goods) {
  goodsDao.save(goods);
 }

 //按id获取商品信息 
 public Optional<GoodsDo> getById(Long id) {
  return goodsDao.findById(id);
 }

 //获取商品信息列表 
 public Iterable<GoodsDo> getList() {
  return goodsDao.findAll();
 }
}

此处需要解释下 Optional 类，它是一个包装类。

它的内容是空或者包含的对象，所以可以避免空指针问题。

首先建立数据库 shop ，数据库中不必有表 goods ，如果有 goods 表的话，可以将它删除。

因为设置了 spring.jpa.hibernate.ddl-auto=update ， JPA 会在项目启动时自动建立表结构。

@RunWith(SpringRunner.class)
@SpringBootTest
public class JpaAddTest {
 @Autowired
 private IGoodsDao goodsDao;

 //新增测试 
 @Test
 public void testAdd() {
  GoodsDo goods = new GoodsDo();
  goods.setName("梨张");
  goods.setPic("梨图片");
  goods.setPrice("2.0");
  GoodsDo result = goodsDao.save(goods);
  System.out.println("新增商品id：" + result.getId());
  assertNotNull(result);
 }
}

运行测试类，控制台输出新增商品id：1，说明插入一条数据成功，且插入数据 id 为 1 。
同时查看数据库，发现已经自动构建表结构：

MySQL 数据库已自动构建表结构

当调用 save 方法，如果给参数中 id 属性赋值，则会进行数据更新操作

@RunWith(SpringRunner.class)
@SpringBootTest
public class JpaEditTest {
   @Autowired
   private IGoodsDao goodsDao;

   //修改测试 
   @Test
   public void testEdit() {
    GoodsDo goods = new GoodsDo();
    goods.setId(1L);
    goods.setName("梨张");
    goods.setPic("梨图片");
    goods.setPrice("100.0");
    GoodsDo result = goodsDao.save(goods);
    assertNotNull(result);
   }
}

此时查看数据库中数据，发现金额已修改成功。

进行按 id 查询、查询所有操作，并打印查询结果。

@RunWith(SpringRunner.class)
@SpringBootTest
public class JpaQueryTest {
   @Autowired
   private IGoodsDao goodsDao;

   //按id查询 
   @Test
   public void testQueryById() {
    Optional<GoodsDo> goodsOptional = goodsDao.findById(1L);
    GoodsDo goods = goodsOptional.get();
    System.out.println(goods.getId() + "-" + goods.getName() + "-" + goods.getPic() + "-" + goods.getPrice());
   }

   //查询全部 
   @Test
   public void testQueryAll() {
    Iterable<GoodsDo> goodsIt = goodsDao.findAll();
    for (GoodsDo goods : goodsIt) {
     System.out.println(goods.getId() + "-" + goods.getName() + "-" + goods.getPic() + "-" + goods.getPrice());
    }
   }
}

指定删除 id 为 1 的商品。

@RunWith(SpringRunner.class)
@SpringBootTest
public class JpaRemoveTest {
   @Autowired
   private IGoodsDao goodsDao;

   //删除测试 
   @Test
   public void testRemove() {
    goodsDao.deleteById(1L);
   }
}

运行后，数据库中商品信息被删除，大功告成！

MyBatis-Plus 

MyBatis-Generator

# 指定MyBatis配置文件位置
mybatis.mapper-locations=classpath:mapper/*.xml

该文件就是 goods 表对应的映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 本映射文件对应GoodsDao接口 -->
<mapper namespace="com.imooc.springbootmybatis.GoodsDao">
 <!-- 对应GoodsDao中的insert方法 -->
 <insert id="insert" parameterType="com.imooc.springbootmybatis.GoodsDo">
  insert into goods (name,price,pic) values (#{name},#{price},#{pic})
 </insert>
 <!-- 对应GoodsDao中的delete方法 -->
 <delete id="delete" parameterType="java.lang.Long">
  delete from goods where id=#{id}
 </delete>
 <!-- 对应GoodsDao中的update方法 -->
 <update id="update" parameterType="com.imooc.springbootmybatis.GoodsDo">
  update goods set name=#{name},price=#{price},pic=#{pic} where id=#{id}
 </update>
 <!-- 对应GoodsDao中的selectOne方法 -->
 <select id="selectOne" resultMap="resultMapBase" parameterType="java.lang.Long">
  select <include refid="sqlBase" /> from goods where id = #{id}
 </select>
 <!-- 对应GoodsDao中的selectAll方法 -->
 <select id="selectAll" resultMap="resultMapBase">
  select <include refid="sqlBase" /> from goods
 </select>
 <!-- 可复用的sql模板 -->
 <sql id="sqlBase">
  id,name,price,pic
 </sql>
 <!-- 保存SQL语句查询结果与实体类属性的映射 -->
 <resultMap id="resultMapBase" type="com.imooc.springbootmybatis.GoodsDo">
  <id column="id" property="id" />
  <result column="name" property="name" />
  <result column="price" property="price" />
  <result column="pic" property="pic" />
 </resultMap>
</mapper>

@FixMethodOrder是控制@Test方法执行顺序的注解

@FixMethodOrder有三种选择

使用MethodSorters.NAME_ASCENDING ，这是使用方法名称排名的，即按照ASCLL码值逐个比较方法名，排序执行

此处通过 @FixMethodOrder(MethodSorters.NAME_ASCENDING) 注解，使测试方法按名称顺序依次执行。

这样就可以一次性测试 GoodsDao 中的所有方法了，

//GoodsDao测试类 
@SpringBootTest
@FixMethodOrder(MethodSorters.NAME_ASCENDING) // 按方法名称顺序测试
class GoodsDaoTest {

 @Autowired
 private GoodsDao goodsDao;

 //新增一个商品 
 @Test
 void test_01() {
  GoodsDo goods = new GoodsDo();
  goods.setName("手机");
  goods.setPic("phone.jpg");
  goods.setPrice("2000");
  int count = goodsDao.insert(goods);
  assertEquals(1, count);// count值为1则测试通过
 }

 //更新商品信息 
 @Test
 void test_02() {
  GoodsDo goods = new GoodsDo();
  goods.setId(1L);
  goods.setName("手机");
  goods.setPic("phone.jpg");
  goods.setPrice("3000");
  int count = goodsDao.update(goods);
  assertEquals(1, count);// count值为1则测试通过
 }

 //获取商品信息 
 @Test
 void test_03() {
  GoodsDo goods = goodsDao.selectOne(1L);
  assertNotNull(goods);// goods不为null则测试通过
 }

 // 删除商品 
 @Test
 void test_04() {
  int count = goodsDao.deletex(1L);//此处应为delete(1L)
  assertEquals(1, count);// count值为1则测试通过
 }

 //获取商品信息列表 
 @Test
 void test_05() {
  List<GoodsDo> goodsList = goodsDao.selectAll();
  assertEquals(0, goodsList.size());// goodsList.size()值为0则测试通过
 }
}

说明所有测试都通过了。

JUnit 测试结果

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <!-- 热部署 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
  </dependency>
  <!-- Web支持 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <!-- JDBC -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
  </dependency>
  <!-- MySQL驱动 -->
  <dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
  </dependency>
  <!-- 集成MyBatis -->
  <dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis-spring-boot-starter</artifactId>
   <version>2.1.2</version>
  </dependency>
  <!-- junit -->
  <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <scope>test</scope>
  </dependency>
  <!-- 测试 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
   <exclusions>
    <exclusion>
     <groupId>org.junit.vintage</groupId>
     <artifactId>junit-vintage-engine</artifactId>
    </exclusion>
   </exclusions>
  </dependency>

//商品数据库访问接口 
@Repository // 标注数据访问组件
public interface GoodsDao {
 //查询商品信息(根据id查询单个商品信息) 
 public GoodsDo selectForUpdate(Long id);

 //修改商品信息(根据id修改其他属性值) 
 public int update(GoodsDo Goods);
}

实现查询剩余库存与扣减库存功能。

注意，在查询商品剩余库存时，采用面向对象的方法

将对应 id 的商品信息全部取出，更加方便点。

采用 selectForUpdate 命名

// 订单数据库访问接口
@Repository // 标注数据访问组件
public interface OrderDao {
   /*/新增订单 
   public int insert(OrderDo order);
}

实现生成订单的功能

@SpringBootApplication
@MapperScan("com.imooc.springboottransaction") // 指定MyBatis扫描的包，以便将数据访问接口注册为Bean
public class SpringBootTransactionApplication {
 public static void main(String[] args) {
  SpringApplication.run(SpringBootTransactionApplication.class, args);
 }
}

扫描数据访问接口所在的包。

# 指定MyBatis配置文件位置
mybatis.mapper-locations=classpath:mapper/*.xml

该文件就是 goods 表对应的映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 本映射文件对应GoodsDao接口 -->
<mapper namespace="com.imooc.springboottransaction.GoodsDao">
   <!-- 对应GoodsDao中的selectForUpdate方法 -->
   <select id="selectForUpdate" resultMap="resultMapBase" parameterType="java.lang.Long">
    select <include refid="sqlBase" /> from goods where id = #{id} for update
   </select>
   <!-- 对应GoodsDao中的update方法 -->
   <update id="update" parameterType="com.imooc.springboottransaction.GoodsDo">
    update goods set name=#{name},num=#{num} where id=#{id}
   </update>
   <!-- 可复用的sql模板 -->
   <sql id="sqlBase">
    id,name,num
   </sql>
   <!-- 保存SQL语句查询结果与实体类属性的映射 -->
   <resultMap id="resultMapBase" type="com.imooc.springboottransaction.GoodsDo">
    <id column="id" property="id" />
    <result column="name" property="name" />
    <result column="num" property="num" />
   </resultMap>
</mapper>

该文件是 order 表对应的映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 本映射文件对应OrderDao接口 -->
<mapper namespace="com.imooc.springboottransaction.OrderDao">
   <!-- 对应OrderDao中的insert方法 -->
   <insert id="insert" parameterType="com.imooc.springboottransaction.OrderDo">
    insert into `order` (goods_id,count) values (#{goodsId},#{count})
   </insert>
</mapper>

/**
 * 订单服务类
 */
@Service // 注册为服务类
public class OrderService {
 @Autowired
 private GoodsDao goodsDao;
 @Autowired
 private OrderDao orderDao;

 /**
  * 下单
  * 
  * @param goodsId 购买商品id
  * @param count   购买商品数量
  * @return 生成订单数
  */
 @Transactional // 实现事务
 public int createOrder(Long goodsId, Long count) {
  // 锁定商品库存
  GoodsDo goods = goodsDao.selectForUpdate(goodsId);
  // 扣减库存
  Long newNum = goods.getNum() - count;
  goods.setNum(newNum);
  goodsDao.update(goods);
  // 生成订单
  OrderDo order = new OrderDo();
  order.setGoodsId(goodsId);
  order.setCount(count);
  int affectRows = orderDao.insert(order);
  return affectRows;
 }
}

在数据库中构造一条测试数据如下：

测试数据

编写测试方法发起测试：

/**
 * 订单测试
 */
@SpringBootTest
class OrderTest {

 @Autowired
 private OrderService orderService;

 /**
  * 新增一个商品
  */
 @Test
 void testCreateOrder() {
  // 购买id为1的商品1份
  int affectRows = orderService.createOrder(1L, 1L);
  assertEquals(1, affectRows);
 }
}

运行测试方法后，手机的库存变为 19 ，且生成一条订单记录，测试通过，具体结果如下：

正常测试结果

修改下单方法，在扣减库存后抛出异常，看看事务能否回滚到修改全部未发生的状态。

为了便于测试我们将库存重新设为 20 ，然后将下单方法修改如下：

运行测试方法后，抛出异常，查看数据库发现，库存还是 20

说明 goodsDao.update(goods); 的修改没有提交到数据库，具体结果如下：

模拟异常测试结果

Exception 受检查的异常

RuntimeException 非受检查的异常

@Transactional(rollbackFor = Exception.class) // 抛出异常即回滚
 public int createOrder(Long goodsId, Long count) throws Exception {
  // 锁定商品库存
  GoodsDo goods = goodsDao.selectForUpdate(goodsId);
  // 扣减库存
  Long newNum = goods.getNum() - count;
  goods.setNum(newNum);
  goodsDao.update(goods);
  if (count > goods.getNum()) {
   throw new Exception();
  }
  // 生成订单
  OrderDo order = new OrderDo();
  order.setGoodsId(goodsId);
  order.setCount(count);
  int affectRows = orderDao.insert(order);
  return affectRows;
 }

有一个 MySQL 的数据库负责存储交易数据。

公司还有一套 ERP 企业信息化管理系统，要求订单信息同步录入 ERP 数据库，便于公司统一管理

而该 ERP 系统采用的数据库为 SQL Server 。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <!-- 热部署 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
  </dependency>
  <!-- Web支持 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <!-- JDBC -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
  </dependency>
  <!-- MySQL驱动 -->
  <dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
  </dependency>
  <!-- SQL Server驱动 -->
  <dependency>
   <groupId>com.microsoft.sqlserver</groupId>
   <artifactId>mssql-jdbc</artifactId>
  </dependency>
  <!-- 集成MyBatis -->
  <dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis-spring-boot-starter</artifactId>
   <version>2.1.2</version>
  </dependency>
  <!-- junit -->
  <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <scope>test</scope>
  </dependency>
  <!-- 测试 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
   <exclusions>
    <exclusion>
     <groupId>org.junit.vintage</groupId>
     <artifactId>junit-vintage-engine</artifactId>
    </exclusion>
   </exclusions>
  </dependency>

【DAO 数据访问接口】通过配置类com.imooc.springbootmultidb.mapper1 包中的 DAO 数据访问接口会自动调用 sqlSessionTemplate1 组件，实现具体数据库操作

【数据源】而 sqlSessionTemplate1 操作的数据源已经通过配置类设置为 db1 。

【映射文件】同时， DAO 数据访问接口对应的映射文件已经指定到 classpath:mapper1/ 目录去寻找。

代码

数据源 2 的配置方法是一样的

【DAO 数据访问接口】通过上面的配置类com.imooc.springbootmultidb.mapper2 包中的 DAO 数据访问接口会自动调用 sqlSessionTemplate2 组件，实现具体数据库操作

【数据源】而 sqlSessionTemplate2 操作的数据源已经通过配置类设置为db2 ，

【映射文件】同时， DAO 数据访问接口对应的映射文件已经指定到 classpath:mapper2/ 目录去寻找。

代码

首先在 com.imooc.springbootmultidb.mapper1 创建 OrderDao

操作的是数据源 1 中的 order 表

//数据访问接口 
@Repository
public interface OrderDao {
 public int insert(OrderDo order);
}

在 com.imooc.springbootmultidb.mapper2 创建 ErpOrderDao

操作的是数据源 2 中的 erporder 表。

//数据访问接口 
@Repository
public interface ErpOrderDao {
 public int insert(ErpOrderDo erpOrder);
}

//ERP订单数据类 
public class ErpOrderDo {
 //订单id 
 private Long id;
 //商城系统订单id 
 private Long outId;
 //商品id 
 private Long goodsId;
 //购买数量 
 private Long count;
 // 省略 get set
}

//订单数据类 
public class OrderDo {
 //订单id 
 private Long id;
 //商品id 
 private Long goodsId;
 //购买数量 
 private Long count;
 // 省略 get set
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 本映射文件对应OrderDao接口 -->
<mapper namespace="com.imooc.springbootmultidb.mapper1.OrderDao">
 <!-- 对应OrderDao中的insert方法 -->
 <insert id="insert"
  parameterType="com.imooc.springbootmultidb.mapper1.OrderDo"
  useGeneratedKeys="true" keyProperty="id">
  insert into `order`
  (goods_id,count) values (#{goodsId},#{count})
 </insert>
</mapper>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 本映射文件对应ErpOrderDao接口 -->
<mapper
 namespace="com.imooc.springbootmultidb.mapper2.ErpOrderDao">
 <!-- 对应ErpOrderDao中的insert方法 -->
 <insert id="insert"
  parameterType="com.imooc.springbootmultidb.mapper2.ErpOrderDo">
  insert into erp_order (out_id,goods_id,count) values
  (#{outId},#{goodsId},#{count})
 </insert>
</mapper>

// 多数据源测试 
@SpringBootTest
class MultidbTest {
 @Autowired
 private OrderDao orderDao;// 对应数据源1
 @Autowired
 private ErpOrderDao erpOrderDao;// 对应数据源2

 //插入测试 
 @Test
 void testInsert() {
  // 数据源1插入数据
  OrderDo order = new OrderDo();
  order.setCount(1L);
  order.setGoodsId(1L);
  int affectRows1 = orderDao.insert(order);
  // 数据源2插入数据
  ErpOrderDo erpOrder = new ErpOrderDo();
  erpOrder.setCount(order.getCount());
  erpOrder.setGoodsId(order.getGoodsId());
  erpOrder.setOutId(order.getId());
  int affectRows2 = erpOrderDao.insert(erpOrder);
  assertEquals(1, affectRows1);
  assertEquals(1, affectRows2);
 }
}

<!--分布式事务 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jta-atomikos</artifactId>
  </dependency>

/**
 * 数据源配置类
 */
@Configuration // 标注为配置类
public class DataSourceConfig {
 // 注入数据源1配置项
 @Value("${spring.datasource.db1.jdbc-url}")
 private String db1_url;
 @Value("${spring.datasource.db1.username}")
 private String db1_username;
 @Value("${spring.datasource.db1.password}")
 private String db1_password;
 // 注入数据源2配置项
 @Value("${spring.datasource.db2.jdbc-url}")
 private String db2_url;
 @Value("${spring.datasource.db2.username}")
 private String db2_username;
 @Value("${spring.datasource.db2.password}")
 private String db2_password;

 /**
  * 数据源1
  */
 @Bean // 返回值注册为组件
 public DataSource db1() throws SQLException {
  MysqlXADataSource dataSource = new MysqlXADataSource();
  dataSource.setUrl(db1_url);
  dataSource.setUser(db1_username);
  dataSource.setPassword(db1_password);
  AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();
  atomikosDataSourceBean.setXaDataSource(dataSource);
  atomikosDataSourceBean.setUniqueResourceName("db1");
  return atomikosDataSourceBean;

 }

 /**
  * 数据源2
  */
 @Bean // 返回值注册为组件
 public DataSource db2() {
  SQLServerXADataSource dataSource = new SQLServerXADataSource();
  dataSource.setURL(db2_url);
  dataSource.setUser(db2_username);
  dataSource.setPassword(db2_password);
  AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();
  atomikosDataSourceBean.setXaDataSource(dataSource);
  atomikosDataSourceBean.setUniqueResourceName("db2");
  return atomikosDataSourceBean;
 }
}

继续修改 DataSourceConfig 类，在其中配置分布式事务管理器组件。

当项目中使用事务时，会通过配置的分布式事务管理器管理分布式事务操作。

//分布式事务管理器 
 @Bean(name = "jtaTransactionManager")
 public JtaTransactionManager jtaTransactionManager() {
  UserTransactionManager userTransactionManager = new UserTransactionManager();
  UserTransaction userTransaction = new UserTransactionImp();
  return new JtaTransactionManager(userTransaction, userTransactionManager);
 }

在测试方法上添加 @Transactional 开启事务，然后在两个数据源操作中间模拟抛出异常。

//插入测试 
 @Test
 @Transactional // 开启事务
 void testInsert() {
  // 数据源1插入数据
  OrderDo order = new OrderDo();
  order.setCount(1L);
  order.setGoodsId(1L);
  int affectRows1 = orderDao.insert(order);
  // 模拟抛出异常
  int a = 1 / 0;
  // 数据源2插入数据
  ErpOrderDo erpOrder = new ErpOrderDo();
  erpOrder.setCount(order.getCount());
  erpOrder.setGoodsId(order.getGoodsId());
  erpOrder.setOutId(order.getId());
  int affectRows2 = erpOrderDao.insert(erpOrder);
  assertEquals(1, affectRows1);
  assertEquals(1, affectRows2);
 }

此时运行测试类，可以发现数据源 1 的事务已回滚，验证成功！

如果运行测试类报错 master..xp_sqljdbc_xa_init_ex 相关信息，是 SQL Server 默认配置不支持分布式事务问题 

Spring Boot默认使用LogBack日志系统，如果不需要更改为其他日志系统如Log4j2等，则无需多余的配置，LogBack默认将日志打印到控制台上。

如果要使用LogBack，原则上是需要添加dependency依赖的

但是因为新建的Spring Boot项目一般都会引用spring-boot-starter或者spring-boot-starter-web，

而这两个起步依赖中都已经包含了对于spring-boot-starter-logging的依赖，所以，无需额外添加依赖。

新建一个项目，Spring Boot 版本选择 2.2.5 ，Group 为 com.imooc ， Artifact 为 spring-boot-log。生成项目后导入 Eclipse 开发环境

运行启动类，可以清楚地看到控制台打印的日志信息。

下图也输出了几条 INFO 级别的日志

日期时间：精确到毫秒。

日志级别：打印 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 等级别日志信息。

进程 ID：当前项目进程 ID 。

分隔符：--- 是分隔符，分隔符后面代表具体的日志内容。

线程名：方括号中间的内容表示线程名称。

类名：当前日志打印所属的类名称。

日志内容：开发人员设定的日志具体内容。

想指定打印的日志的级别，可以通过配置文件来设置。

# 设置日志级别
logging.level.root=WARN

上面的配置表示项目日志的记录级别为 WARN 

所以会打印 WARN 及优先级更高的 ERROR 级别的日志。

此时编写一个测试类（LogTest），看看具体打印日志的情况。

@SpringBootTest
class LogTest {
 private Logger logger = LoggerFactory.getLogger(this.getClass());

 @Test
 void testPrintLog() {
  logger.trace("trace log");
  logger.debug("debug log");
  logger.info("info log");
  logger.warn("warn log");
  logger.error("error log");
 }
}

运行测试类，控制台打印内容如下，说明我们指定的日志级别生效了。

控制台打印指定级别日志

Tips: logging.level.root=WARN 中的 root 

可以改为指定包名或类名

表示设置指定包或者类的日志级别。

控制台日志保存的内容十分有限

大多数情况下，需要将日志写入文件，便于追溯。

可以通过配置文件指定日志文件，

# 设置日志文件
logging.file=C:\\logs\\spring-boot-log.log

以上配置会将日志打印到 C:\\logs\\spring-boot-log.log 文件中。

也可以指定日志文件输出的目录

Spring Boot 项目会在指定输出目录下新建 spring.log 文件，并在文件中写入日志。

# 设置日志目录
logging.path=C:\\logs

简化日志模板代码

自动生成常用的 getter /setter/toString 等模板代码

下载 lombok 插件

安装 lombok 插件

引入 lombok 依赖

使用注解输出日志

Spring Boot 的默认异常处理机制

实际上只能做到提醒开发者 “这个后端接口不存在” 的作用，

作用非常有限

对于返回视图的控制器

如果没发生异常就跳转正常页面

如果发生异常可以自定义错误信息页面。

对于返回 JSON 数据的控制器

最好是定义统一的数据返回格式，便于前端根据返回信息进行正常或者异常情况的处理。

/**
 * 自定义异常
 */
public class BaseException extends Exception {
 /**
  * 错误码
  */
 private int code;
 /**
  * 错误提示信息
  */
 private String msg;

 public BaseException(int code, String msg) {
  super();
  this.code = code;
  this.msg = msg;
 }
 // 省略get set
}

/**
 * 密码错误异常
 */
public class PasswordException extends BaseException {
 public PasswordException() {
  super(10001, "密码错误");
 }
}

/**
 * 验证码错误异常
 */
public class VerificationCodeException extends BaseException {
 public VerificationCodeException() {
  super(10002, "验证码错误");
 }
}

Spring Boot 版本选择 2.2.5 ，Group 为 com.imooc ， Artifact 为 spring-boot-task 

生成项目后导入 Eclipse 开发环境。

在启动类上添加 @EnableScheduling 注解，开启定时任务功能。

@SpringBootApplication
@EnableScheduling // 开启定时任务
public class SpringBootTaskApplication {
 public static void main(String[] args) {
  SpringApplication.run(SpringBootTaskApplication.class, args);
 }
}

新建 MySpringTask 任务类

添加 @Component 注解注册 Spring 组件，定时任务方法需要在 Spring 组件类才能生效。

注意，类中方法添加了 @Scheduled 注解，所以会按照 @Scheduled 注解参数指定的规则定时执行。

//任务类 
@Component
public class MySpringTask {
 //每2秒执行1次 
 @Scheduled(fixedRate = 2000)
 public void fixedRateMethod() throws InterruptedException {
  System.out.println("fixedRateMethod:" + new Date());
  Thread.sleep(1000);
 }
}

//任务类 
@Component
public class MySpringTask {
 //执行结束2秒后执行下次任务 
 @Scheduled(fixedDelay = 2000)
 public void fixedDelayMethod() throws InterruptedException {
  System.out.println("fixedDelayMethod:" + new Date());
  Thread.sleep(1000);
 }
}

Cron 表达式

以本节开头的两个需求为例：

// 任务类 
@Component
public class MySpringTask {
 //在每分钟的00秒执行 
 @Scheduled(cron = "0 * * * * ?")
 public void jump() throws InterruptedException {
  System.out.println("心跳检测:" + new Date());
 }
 //在每天的00:00:00执行 
 @Scheduled(cron = "0 0 0 * * ?")
 public void stock() throws InterruptedException {
  System.out.println("置满库存:" + new Date());
 }
}

Spring Boot 版本选择 2.2.5 ，Group 为 com.imooc ， Artifact 为 spring-boot-quartz

生成项目后导入 Eclipse 开发环境。

需要引入 Quartz 框架相关依赖。

<!-- Quartz -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-quartz</artifactId>
  </dependency>

同样需要，在启动类上添加 @EnableScheduling 注解，开启定时任务功能。

@SpringBootApplication
@EnableScheduling // 开启定时任务
public class SpringBootQuartzApplication {
 public static void main(String[] args) {
  SpringApplication.run(SpringBootQuartzApplication.class, args);
 }
}

Quartz 定时任务需要通过 Job 、 Trigger 、 JobDetail 来设置

开发一个 Job 组件

然后在配置类中设定 Trigger 及 JobDetail 。

preHandle 需要返回布尔类型的值。 

如果preHandle 返回 true 时，对控制器方法的请求才能到达控制器，继而到达 postHandle 和 afterCompletion 方法；

如果 preHandle 返回 false ，后面的方法都不会执行。

直接请求 http://127.0.0.1:8080/info接口

由于此时未登录，所以请求被拦截，网页输出如下：

访问被拦截

登录成功后，访问正常通过拦截器

请求登录方法 http://127.0.0.1:8080/login?username=imooc&password=123

访问 http://127.0.0.1:8080/info

内存占用情况

磁盘使用情况

数据库连接情况

打开 Spring Initializr ， Spring Boot 版本选择 2.2.5 ，Group 为 com.imooc ， Artifact 为 spring-boot-monitor-manager

生成项目后导入 Eclipse 开发环境。

监控管理端需要使用网页展示监控信息，所以引入 Web 依赖，

另外添加 Spring Boot Admin 管理端依赖项。

<!-- Web 依赖 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

  <!-- Spring Boot Admin 管理端依赖项 -->
  <dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-starter-server</artifactId>
   <version>2.2.3</version>
  </dependency>

在启动类上添加 @EnableAdminServer 注解开启 Spring Boot Admin 监控管理功能，代码如下：

@SpringBootApplication
@EnableAdminServer // 开启监控管理
public class SpringBootMonitorManagerApplication {
 public static void main(String[] args) {
  SpringApplication.run(SpringBootMonitorManagerApplication.class, args);
 }
}

然后运行启动类，访问 http://127.0.0.1:8080 会发现界面上已经显示监控信息了。

Spring Boot Admin 监控管理页面

打开 Spring Initializr ， Spring Boot 版本选择 2.2.5 ，Group 为 com.imooc ， Artifact 为 spring-boot-monitor-client

生成项目后导入 Eclipse 开发环境。

直接引入 Web 依赖和监控客户端依赖。

<!-- Web 依赖 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

  <!-- Spring Boot Admin监控客户端依赖 -->
  <dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-starter-client</artifactId>
   <version>2.2.3</version>
  </dependency>

修改客户端的配置文件 application.properties ，以便指定客户端指向的服务端的地址。

总览配置文件

（1）修改端口号

（2）指定监控管理端地址

（3）设置是客户端的名称

启动客户端程序，然后刷新服务端网页，会发现监控管理页面已经显示了客户端信息。

监控页面展示客户端信息

此时，关闭客户端程序，然后稍等一会刷新下监控管理页面，会发现监控管理页已经显示了离线项目实例信息。

（注意服务端发现客户端离线是需要一定时间的）

监控页面展示离线客户端信息

使用 Spring Boot Admin 后，默认显示的项目实例信息比较少。

CLIENT1 实例默认显示信息

默认设置主要是为了保证项目实例的安全性，只展示了非常少的信息，

可以通过配置文件指定展示哪些信息，如下。

# 配置客户端展示哪些信息，*表示展示全部信息
management.endpoints.web.exposure.include=*

此时刷新监控管理页，会发现已经展示各类运行参数信息。

全面展示项目实例运行参数信息

为监控服务端项目引入邮件依赖。

<!-- 邮件依赖 -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-mail</artifactId>
  </dependency>

只需要配置常规的邮件收发信息即可。

# 网易邮箱发件服务器
spring.mail.host=smtp.163.com
# 网易邮箱发件端口
spring.mail.prot=25
# 发件人账号
spring.mail.username=taqsxxkj@163.com
# 发件授权密码，注意授权码是用于登录第三方邮件客户端的专用密码
spring.mail.password=123456
spring.mail.properties.mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory
# Spring Boot Admin 发件收件信息
spring.boot.admin.notify.mail.from=taqsxxkj@163.com
spring.boot.admin.notify.mail.to=taqsxxkj@163.com
spring.boot.admin.notify.mail.cc=taqsxxkj@163.com

此处特别注意发件授权密码不是普通邮箱的登录密码，而是授权密码，以网易邮箱为例在下图位置设置。

网易邮箱授权密码设置

启动监控服务端和客户端，然后关闭客户端，稍等一会检查指定的报警接收邮箱，就会发现已收到报警邮件了。

项目实例离线邮件报警内容

系统初始化时，告知访问路径所需要的对应权限。

登录时，告知真实用户名和密码。

登录成功时，告知当前用户具备的权限。

用户访问接口时，Spring Security自动判断能否访问。

数据库表结构

api 表中的 path 字段表示接口的访问路径，另外所有的 id 都是自增主键。

用户表 user：保存用户名、密码，及用户拥有的角色 id 。
角色表 role ：保存角色 id 与角色名称。
角色权限表 roleapi：保存角色拥有的权限信息。
权限表 api：保存权限信息，在前后端分离的项目中，权限指的是控制器中的开放接口。

定义 Spring Security 配置类，通过注解 @EnableWebSecurity 开启安全管理功能。

@Configuration
@EnableWebSecurity // 开启安全管理
public class SecurityConfig {
 @Autowired
 private SecurityService securityService;
}

Spring Security 提供了很多种密码加密组件，使用官方推荐的 BCryptPasswordEncoder ，直接注册为 Bean 即可。

之前在数据库中预定义的密码字符串即为 123 加密后的结果。

Spring Security 在验证密码时，会自动调用注册的加密组件，将用户输入的密码加密后再与数据库密码比对。

@Bean
 PasswordEncoder passwordEncoder() {
  return new BCryptPasswordEncoder();
 }
    public static void main(String[] args) {
  //输出 $2a$10$kLQpA8S1z0KdgR3Cr6jJJ.R.QsIT7nrCdAfsF4Of84ZBX2lvgtbE.
  System.out.println(new BCryptPasswordEncoder().encode("123"));
 }

通过注册 UserDetailsService 类型的组件，组件中设置用户密码及权限信息即可。

@Bean
 public UserDetailsService userDetailsService() {
  return username -> {
   List<UserDo> users = securityService.getUserByUsername(username);
   if (users == null || users.size() == 0) {
    throw new UsernameNotFoundException("用户名错误");
   }
   String password = users.get(0).getPassword();
   List<String> apis = securityService.getApisByUsername(username);
   // 将用户名username、密码password、对应权限列表apis放入组件
   return User.withUsername(username).password(password).authorities(apis.toArray(new String[apis.size()]))
     .build();
  };
 }

同样，通过注册组件，将访问路径需要的权限信息告知 Spring Security 。

@Bean
 public WebSecurityConfigurerAdapter webSecurityConfigurerAdapter() {
  return new WebSecurityConfigurerAdapter() {
   @Override
   public void configure(HttpSecurity httpSecurity) throws Exception {
    // 开启跨域支持
    httpSecurity.cors();
    // 从数据库中获取权限列表
    List<String> paths = securityService.getApiPaths();
    for (String path : paths) {
     /* 对/xxx/**路径的访问，需要具备xxx权限
     例如访问 /addGoods，需要具备addGoods权限 */
     httpSecurity.authorizeRequests().antMatchers("/" + path + "/**").hasAuthority(path);
    }
    // 未登录时自动跳转/notLogin
    httpSecurity.authorizeRequests().and().formLogin().loginPage("/notLogin")
      // 登录处理路径、用户名、密码
      .loginProcessingUrl("/login").usernameParameter("username").passwordParameter("password")
      .permitAll()
      // 登录成功处理
      .successHandler(new AuthenticationSuccessHandler() {
       @Override
       public void onAuthenticationSuccess(HttpServletRequest httpServletRequest,
         HttpServletResponse httpServletResponse, Authentication authentication)
         throws IOException, ServletException {
        httpServletResponse.setContentType("application/json;charset=utf-8");
        ResultBo result = new ResultBo<>();
        ObjectMapper mapper = new ObjectMapper();
        PrintWriter out = httpServletResponse.getWriter();
        out.write(mapper.writeValueAsString(result));
        out.close();
       }
      })
      // 登录失败处理
      .failureHandler(new AuthenticationFailureHandler() {
       @Override
       public void onAuthenticationFailure(HttpServletRequest httpServletRequest,
         HttpServletResponse httpServletResponse, AuthenticationException e)
         throws IOException, ServletException {
        httpServletResponse.setContentType("application/json;charset=utf-8");
        ResultBo result = new ResultBo<>(new Exception("登录失败"));
        ObjectMapper mapper = new ObjectMapper();
        PrintWriter out = httpServletResponse.getWriter();
        out.write(mapper.writeValueAsString(result));
        out.flush();
        out.close();
       }
      });
    // 禁用csrf(跨站请求伪造)
    httpSecurity.authorizeRequests().and().csrf().disable();
   }
  };
 }

未登录的访问会自动跳转到/notLogin 访问路径。

通过 /login 访问路径可以发起登录请求，用户名和密码参数名分别为 username 和 password 。

登录成功或失败会返回 ResultBo 序列化后的 JSON 字符串，包含登录成功或失败信息。

访问 /xxx 形式的路径，需要具备 xxx 权限。

用户所具备的权限已经通过上面的 UserDetailsService 组件告知 Spring Security 了。