Spring Boot 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统
一、概述
经过HelloWorld示例（Spring Boot 快速入门（上）HelloWorld示例）（ Spring Boot 快速入门 详解 HelloWorld示例详解）两篇的学习和练习，相信你已经知道了Spring Boot是如此的简单，但又有不少疑惑，那么多注解如何记住，他的生态怎么样，缓存、NoSQL、定时器、邮件发送等细节功能如何处理。
如果你觉得一篇一篇看文章学习太耗时间，你看这篇就够啦，如果你觉得这篇太长，可以跳过本章看其他章节。
本章是一个文章发布管理系统综合示例，主要以操作数据库、集成权限为主功能来实现Spring Boot周边核心功能。主要包括了
本章实现的功能
1、实现Thymeleaf模板
2、实现Rest Api
3、实现基于Shiro的权限登录
4、实现基于Mybatis的增删改查
5、实现基于ehcache的缓存
6、实现日志输出
7、实现全局配置
同时本章也向读者提供如何设计一个系统的思路。
通常我们编写一个小系统需要
1、需求分析：这里简单描述要演练什么样的系统
2、系统设计：包括了数据库和程序分层设计
3、编码：这里指编码
4、测试：这里只包括单元测试
5、上线：这里指运行代码
二、需求分析
本章以开发一个文章发布管理系统为假想的需求，涉及到的功能
1.有一个管理员可以登录系统发布文章
2.可以发布文章、编辑文字、删除文章
3.有一个文章列表
这是个典型的基于数据库驱动的信息系统，使用spring boot+mysql即可开发。
三、系统设计
本章需要演练的内容，实际上是一个小型的信息管理系统（文章发布管理系统），有权限、有增删改查、有缓存、有日志、有数据库等。已经完全具备一个信息系统应有的功能。
针对此类演练的示例，我们也应该从标准的项目实战思维来演练，而不能上来就开始新建项目、贴代码等操作。
3.1 分层架构
经典的三层、展示层、服务层、数据库访问层。
所以在项目结构中我们可以设计成
3.2 数据库设计
本次只是为了演示相关技术，所以采用单表设计，就设计一个t_article表，用户名与密码采用固定的。数据库设计尽量符合相关标准（本文中已小写下滑线来命名字段）
数据库 article
1）表 t_article设计
2）创建Table语句
SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------------------------- -- Table structure for t_article -- ---------------------------- DROP TABLE IF EXISTS `t_article`; CREATE TABLE `t_article` ( `id` int(11) NOT NULL AUTO_INCREMENT, `title` varchar(255) NOT NULL, `content` varchar(255) NOT NULL, `post_time` datetime NOT NULL, `post_status` int(11) NOT NULL, `create_by` datetime NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4; SET FOREIGN_KEY_CHECKS = 1;
四、编码与测试
程序的编码应在整个设计中占到20%的工作量，有人说，那么那些复杂的业务、算法难道不花时间，复杂业务模型、复杂算法应该在系统设计阶段去作为关键技术去攻克。不要等到编码了，才去慢慢做。
编码与测试我们可以经历一些标准的路径。
1、创建项目，建立适合的项目目录
2、整合mybatis建立数据库访问层并测试
3、编写service服务层
4、编写应用层
5、整合thymeleaf编写前端
6、给系统加入Shiro权限认证
7、给系统加入logging日志
8、给系统加入缓存
9、给系统加入完整的测试代码
4.1 项目结构（复习使用IDEA创建项目）
4.1.1 使用IDEA创建项目
使用IDEA（本教程之后都使用IDEA来创建）创建名为 springstudy的项目
1）File>New>Project，如下图选择Spring Initializr 然后点击 【Next】下一步
2）填写GroupId（包名）、Artifact（项目名） ，本项目中 GroupId=com.fishpro Artiface=springstudy，这个步骤跟HelloWorld实例是一样的
3）选择依赖，我们选择Web
注：也可以使用HelloWorld示例项目，Copy一份，来做。
4.1.2 初始化项目结构
在springstudy包名下增加包名
1）controller mvc控制层
2）dao mybatis的数据库访问层
3）domain 实体类对应数据库字段
4）service 服务层
impl 服务实现
4.1.3 application.yml
个人习惯使用yml格式配置文件（缩进）
直接修改application.properties改为 application.yml
4.1.4 指定程序端口为8991
在application.yml中输入
server: port: 8991
4.2 增加Mybatis支持，编写数据库访问代码
4.2.1 编辑Pom.xml 增加依赖
本章使用mybatis和阿里巴巴的driud连接池来链接操作数据库
在pom.xml中增加依赖如下，注意有4个依赖引入，分别是mysql链接支持、jdbc支持、druid的alibaba连接池支持、mybatis支持。
<!--jdbc数据库支持-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!--druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.28</version>
</dependency>
<!--mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.4</version>
</dependency>
如果依赖未自动导入，点击右下方 Import Changes 即可。
4.2.2 com.alibaba.druid连接池配置
（中文文档 https://github.com/alibaba/druid/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98）
本章只是演练（配置、使用），不说明具体功能说明及配置含义。
1）在resouces\application.yml 配置Druid的应用程序配置
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/demo_article?useSSL=false&useUnicode=true&characterEncoding=utf8
#mysql用户名
username: root
#mysql密码
password: 123
#初始化线程池数量
initialSize: 1
#空闲连接池的大小
minIdle: 3
#最大激活量
maxActive: 20
# 配置获取连接等待超时的时间
maxWait: 60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
minEvictableIdleTimeMillis: 30000
validationQuery: select 'x'
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
# 打开PSCache，并且指定每个连接上PSCache的大小
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
filters: stat,wall,slf4j
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 合并多个DruidDataSource的监控数据
#useGlobalDataSourceStat: true
问题：com.mysql.jdbc.Driver 不能加载问题，因确认 mysql-connector-java 的依赖引入。
4.2.3 配置mybatis
在application.yml中增加
mybatis:
configuration:
#true来开启驼峰功能。
map-underscore-to-camel-case: true
#正则扫描mapper映射的位置
mapper-locations: mybatis/**/*Mapper.xml
#正则扫描实体类package的
typeAliasesPackage: com.fishpro.springstudy.**.domain
4.2.4 编写实体类domain.ArticleDO.java
1)在 com.fishpro.sprintstudy.domain包下新建java类 ArticleDO.java
2)编写代码如下（后期可以采用自动生成的方法）
package com.fishpro.springstudy.domain;
import java.util.Date;
public class ArticleDO {
private Integer id;
private String title;
private String content;
private Date postTime;
private Integer postStatus;
private Date createBy;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Date getPostTime() {
return postTime;
}
public void setPostTime(Date postTime) {
this.postTime = postTime;
}
public Integer getPostStatus() {
return postStatus;
}
public void setPostStatus(Integer postStatus) {
this.postStatus = postStatus;
}
public Date getCreateBy() {
return createBy;
}
public void setCreateBy(Date createBy) {
this.createBy = createBy;
}
}
4.2.5 编写mybatis的mapper的xml
根据配置文件中的配置
#正则扫描mapper映射的位置
mapper-locations: mybatis/**/*Mapper.xml
我们在resources/下创建mybatis文件夹，并创建文件ArticleMapper.xml 包括了
1）获取单个实体
2）获取分页列表
3）插入
4）更新
5）删除
5）批量删除
<?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">
<mapper namespace="com.fishpro.springstudy.dao.ArticleDao">
<select id="get" resultType="com.fishpro.springstudy.domain.ArticleDO">
select `id`,`title`,`content`,`post_time`,`post_status`,`create_by` from t_article where id = #{value}
</select>
<select id="list" resultType="com.fishpro.springstudy.domain.ArticleDO">
select `id`,`title`,`content`,`post_time`,`post_status`,`create_by` from t_article
<where>
<if test="id != null and id != '-1' " > and id = #{id} </if>
<if test="title != null and title != '' " > and title = #{title} </if>
<if test="content != null and content != '' " > and content = #{content} </if>
<if test="postTime != null and postTime != '' " > and post_time = #{postTime} </if>
<if test="postStatus != null and postStatus != '-1' " > and post_status = #{postStatus} </if>
<if test="createBy != null and createBy != '' " > and create_by = #{createBy} </if>
</where>
<choose>
<when test="sort != null and sort.trim() != ''">
order by ${sort} ${order}
</when>
<otherwise>
order by id desc
</otherwise>
</choose>
<if test="offset != null and limit != null">
limit #{offset}, #{limit}
</if>
</select>
<select id="count" resultType="int">
select count(*) from t_article
<where>
<if test="id != null and id != '-1' " > and id = #{id} </if>
<if test="title != null and title != '' " > and title = #{title} </if>
<if test="content != null and content != '' " > and content = #{content} </if>
<if test="postTime != null and postTime != '' " > and post_time = #{postTime} </if>
<if test="postStatus != null and postStatus != '-1' " > and post_status = #{postStatus} </if>
<if test="createBy != null and createBy != '' " > and create_by = #{createBy} </if>
</where>
</select>
<insert id="save" parameterType="com.fishpro.springstudy.domain.ArticleDO" useGeneratedKeys="true" keyProperty="id">
insert into t_article
(
`title`,
`content`,
`post_time`,
`post_status`,
`create_by`
)
values
(
#{title},
#{content},
#{postTime},
#{postStatus},
#{createBy}
)
</insert>
<update id="update" parameterType="com.fishpro.springstudy.domain.ArticleDO">
update t_article
<set>
<if test="title != null">`title` = #{title}, </if>
<if test="content != null">`content` = #{content}, </if>
<if test="postTime != null">`post_time` = #{postTime}, </if>
<if test="postStatus != null">`post_status` = #{postStatus}, </if>
<if test="createBy != null">`create_by` = #{createBy}</if>
</set>
where id = #{id}
</update>
<delete id="remove">
delete from t_article where id = #{value}
</delete>
<delete id="batchRemove">
delete from t_article where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
</mapper>
4.2.6 编写dao
Dao是通过Mybats自动与Mapper对应的
package com.fishpro.springstudy.dao;
import com.fishpro.springstudy.domain.ArticleDO;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface ArticleDao {
ArticleDO get(Integer id);
List<ArticleDO> list(Map<String,Object> map);
int count(Map<String,Object> map);
int save(ArticleDO article);
int update(ArticleDO article);
int remove(Integer id);
int batchRemove(Integer[] ids);
}
注意：自此我们已经完成了实体类到具体数据库的映射操作，下面4.4.7编写一个controller类方法，直接测试。
4.2.7 编写一个RestController测试dao
虽然，原则上，我们需要建立service层，才能编写controller，现在我们不妨先测试下我们编写的Dao是否正确。
ArticleController.cs
package com.fishpro.springstudy.controller;
import com.fishpro.springstudy.dao.ArticleDao;
import com.fishpro.springstudy.domain.ArticleDO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Date;
@RequestMapping("/article")
@RestController
public class ArtcileController {
@Autowired
private ArticleDao articleDao;
@RequestMapping("/test")
public String test(){
ArticleDO articleDO=new ArticleDO();
articleDO.setTitle("testing");
articleDO.setContent("content");
articleDO.setCreateBy(new Date());
articleDO.setPostStatus(0);
articleDO.setPostTime(new Date());
int i= articleDao.save(articleDO);
if(i>0)
return "ok";
else
return "fail";
}
}
在浏览器输入 http://localhost:8991/article/test
如下图：是浏览器的截图和数据库插入的数据展示。
4.3 编写Service服务层代码
服务层代码通常分接口，和接口的实现，具体放在service和service.impl下；
在 com.fishpro.springstudy.service 下建立接口文件 ArticleService.java
在 com.fishpro.springstudy.service.impl下建立接口实现文件 ArticleServiceImpl.java
主要代码如下
ArticleService.java
public interface ArticleService {
ArticleDO get(Integer id);
List<ArticleDO> list(Map<String, Object> map);
int count(Map<String, Object> map);
int save(ArticleDO article);
int update(ArticleDO article);
int remove(Integer id);
int batchRemove(Integer[] ids);
}
ArticleServiceImpl.java
@Service
public class ArticleServiceImpl implements ArticleService {
@Autowired
private ArticleDao articleDao;
@Override
public ArticleDO get(Integer id){
return articleDao.get(id);
}
@Override
public List<ArticleDO> list(Map<String, Object> map){
return articleDao.list(map);
}
@Override
public int count(Map<String, Object> map){
return articleDao.count(map);
}
@Override
public int save(ArticleDO article){
return articleDao.save(article);
}
@Override
public int update(ArticleDO article){
return articleDao.update(article);
}
@Override
public int remove(Integer id){
return articleDao.remove(id);
}
@Override
public int batchRemove(Integer[] ids){
return articleDao.batchRemove(ids);
}
}
注意实现接口文件 ArticleServiceImpl.java 类中实现了注解 @Service
4.4 编写应用层代码
4.4.1 Rest Api简单实践
实际上在4.1最后，我们已经建立了一个Rest Api接口来测试。建立Rest Api在Spring Boot中非常简单
1）在controller包名下建立以Controller结尾的java文件，例如 ArticleController.cs
2）在类名上加入注解 @RestController 表示该类是Rest Api
在类名上加入 @RequestMapping 注解，表示该类的路由例如 @RequestMapping("/article")
3）编写public方法 例如 public String test()，在public方法上添加 @RequestMapping("/test") 表示该方法的路由是 test
例如4.1中
@RequestMapping("/test")
public String test(){
return "test";
}
4）Get还是Post等方法
Post 在方法上加入@PostMapping("/postTest") 和 @ResponseBody （表示返回JSON格式）注解
@PostMapping("/postTest")
@ResponseBody
public ArticleDO postTest(){
ArticleDO model=articleDao.get(1);
return model;
}
在Postman（谷歌下载）http://localhost:8991/article/postTest 如下图：
Get 在方法上加入 @GetMapping
5）参数的注解
HttpServletRequest
通常我们web方法的参数是HttpServletRequest,我们也可以在方法参数中设置HttpServletRequest参数，如下
@GetMapping("/paramTest")
public String paramTest(HttpServletRequest request){
if(request.getParameter("d")!=null)
return request.getParameter("d").toString();
else
return "not find param name d";
}
1）当我们输入 http://localhost:8991/article/paramTest 显示 “not find param name d”
2）当我输入http://localhost:8991/article/paramTest?d=i%20am%20d 显示 i am d
@RequestParam 替换 HttpServletRequest 的 request.getParameter方法
@GetMapping("/paramNameTest")
public String paramNameTest(HttpServletRequest request,@RequestParam("name") String name){
if(!"".equals(name))
return name;
else
return "not find param name ";
}
@PathVariable 参数在路由中显示
@GetMapping("/paramPathTest/{name}")
public String paramPathTest(HttpServletRequest request,@PathVariable("name") String name){
if(request.getParameter("d")!=null)
return request.getParameter("d").toString();
else
return "not find param name d";
}
@RequestBody 参数为Json
@PostMapping("/jsonPostJsonTest")
@ResponseBody
public ArticleDO jsonPostJsonTest(@RequestBody ArticleDO articleDO){
return articleDO;
}
4.4.2 编写文章的新增、编辑、删除、获取列表等Controller层代码
为了统一管理返回状态，我们定义个返回的基础信息包括返回的代码、信息等信息 如下，表示统一使用Json作为返回信息
{"code":1,"msg":"返回信息","data":Object}
对应的返回类
com.fishpro.springstudy.domain.Rsp.java
public class Rsp extends HashMap<String ,Object> {
private static final long serialVersionUID = 1L;
public Rsp() {
put("code", 0);
put("msg", "操作成功");
}
public static Rsp error() {
return error(1, "操作失败");
}
public static Rsp error(String msg) {
return error(500, msg);
}
public static Rsp error(int code, String msg) {
Rsp r = new Rsp();
if(msg==null)
{
msg="发生错误";
}
r.put("code", code);
r.put("msg", msg);
return r;
}
public static Rsp ok(String msg) {
Rsp r = new Rsp();
r.put("msg", msg);
return r;
}
public static Rsp ok(Map<String, Object> map) {
Rsp r = new Rsp();
r.putAll(map);
return r;
}
public static Rsp ok() {
return new Rsp();
}
@Override
public Rsp put(String key, Object value) {
super.put(key, value);
return this;
}
}
在ArticleController.java里面，我们编写 相关的方法，全部的java代码如下：
注意：这里我们不研究分页的方法（后面讲）。
/**
* 文章首页 存放列表页面
* */
@GetMapping()
String Article(){
return "article/index";
}
/**
* 获取文章列表数据 不考虑分页
* */
@ResponseBody
@GetMapping("/list")
public List<ArticleDO> list(@RequestParam Map<String, Object> params){
//查询列表数据
List<ArticleDO> articleList = articleService.list(params);
return articleList;
}
/**
* 文章添加页面的路由
* */
@GetMapping("/add")
String add(){
return "article/add";
}
/**
* 文章编辑页面的路由
* */
@GetMapping("/edit/{id}")
String edit(@PathVariable("id") Integer id,Model model){
ArticleDO article = articleService.get(id);
model.addAttribute("article", article);
return "article/edit";
}
/**
* Post方法，保存数据 这里不考虑权限
*/
@ResponseBody
@PostMapping("/save")
public Rsp save(ArticleDO article){
if(articleService.save(article)>0){
return Rsp.ok();
}
return Rsp.error();
}
/**
* Post方法，修改数据 这里不考虑权限
*/
@ResponseBody
@RequestMapping("/update")
public Rsp update( ArticleDO article){
articleService.update(article);
return Rsp.ok();
}
/**
* Post方法，删除数据 这里不考虑权限
*/
@PostMapping( "/remove")
@ResponseBody
public Rsp remove( Integer id){
if(articleService.remove(id)>0){
return Rsp.ok();
}
return Rsp.error();
}
/**
* Post方法，批量删除数据 这里不考虑权限
*/
@PostMapping( "/batchRemove")
@ResponseBody
public Rsp remove(@RequestParam("ids[]") Integer[] ids){
articleService.batchRemove(ids);
return Rsp.ok();
}
说明：
Article方法 对应 /article/index地址 对应html文件为 resources/templates/article/index.html
add方法对应 /article/add 对应html文件为 resources/templates/article/add.html
edit方法对应 /article/edit 对应html文件为 resources/templates/article/edit.html
4.5 使用Thymeleaf编写前端页面
Thymeleaf是一套Java开发的独立的模板引擎，可以很好与Spring Boot整合，起到事半功倍的效果。
使用Thymeleaf前，我们需要知道
/resources/static 是存放静态文件 包括image css js等
/resources/templates 是存放模板文件
4.5.1 Pom.xml中添加依赖
<!-- 模板引擎 Thymeleaf 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<!--thymeleaf 兼容非严格的html5-->
<dependency>
<groupId>net.sourceforge.nekohtml</groupId>
<artifactId>nekohtml</artifactId>
</dependency>
4.5.2 配置Thymeleaf
编辑 application.yml
spring:
thymeleaf:
mode: LEGACYHTML5
cache: false
prefix: classpath:/templates/
4.5.3 使用Thymeleaf
thymeleaf可以直接使用html后缀，在resources/templates下增加，在本章示例中
resources/templates/article/index.html
resources/templates/article/add.html
resources/templates/article/edit.html
为了快速的开发实例，我们使用前端框架H+作为练习使用。
前端使用jquery、bootstrap.css、bootstrap-table.js
4.5.4 文章列表页面
列表页面主要采用bootstrap-table.js插件。
bootstrap-table.js
因为数据少，我们之间采用客户端分页的模式 sidePagination : "client", // 设置在哪里进行分页，可选值为"client" 或者 "server"
1）建立模板页面： resources/templates/article/index.html
2 建立路由：在ArticleController中增加前端页面路由/article/index
3) 建立数据路由：ArticleController中编写bootstrap-table的ajax请求方法 list
4）运行：在浏览器中验证
注意：本页面没有用到thymeleaf的模板语句。
4.5.5 添加文章功能
注意，我们使用了layui的弹窗组件。
1）建立模板页面： resources/templates/article/add.html
2 建立路由：在ArticleController中增加前端页面路由/article/
3) 建立数据路由：ArticleController中编写bootstrap-table的ajax请求方法 save
4）运行：编写页面的ajax方法，在浏览器中验证
保存新增数据代码
function save() {
$.ajax({
cache : true,
type : "POST",
url : "/article/save",
data : $('#signupForm').serialize(),// 你的formid
async : false,
error : function(request) {
parent.layer.alert("Connection error");
},
success : function(data) {
if (data.code == 0) {
parent.layer.msg("操作成功");
parent.reLoad();
var index = parent.layer.getFrameIndex(window.name); // 获取窗口索引
parent.layer.close(index);
} else {
parent.layer.alert(data.msg)
}
}
});
}
注意：本页面没有用到thymeleaf的模板语句。
4.5.6 修改文章功能
1）建立模板页面： resources/templates/article/edit.html
2 建立路由：在ArticleController中增加前端页面路由/article/edit，并配置模板页面，如下代码，其中thymeleaf标签规则为
a.th开头
b.等于号后面是 “${ }” 标签，在${ } 大括号内存放后台的model数据和数据的逻辑。如${article.title}表示后台的article对象中的title值
c.关于thymeleaf这里不做细化，后面单独实践。
<form class="form-horizontal m-t" id="signupForm">
<input id="id" name="id" th:value="${article.id}" type="hidden">
<div class="form-group">
<label class="col-sm-3 control-label">：</label>
<div class="col-sm-8">
<input id="title" name="title" th:value="${article.title}" class="form-control" type="text">
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">：</label>
<div class="col-sm-8">
<input id="content" name="content" th:value="${article.content}" class="form-control" type="text">
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">：</label>
<div class="col-sm-8">
<input id="postStatus" name="postStatus" th:value="${article.postStatus}" class="form-control" type="text">
</div>
</div>
<div class="form-group">
<div class="col-sm-8 col-sm-offset-3">
<button type="submit" class="btn btn-primary">提交</button>
</div>
</div>
</form>
3) 建立数据路由：ArticleController中编写bootstrap-table的ajax请求方法 update
4）运行：编写页面的ajax方法，在浏览器中验证
function update() {
$.ajax({
cache : true,
type : "POST",
url : "/article/update",
data : $('#signupForm').serialize(),// 你的formid
async : false,
error : function(request) {
parent.layer.alert("Connection error");
},
success : function(data) {
if (data.code == 0) {
parent.layer.msg("操作成功");
parent.reLoad();
var index = parent.layer.getFrameIndex(window.name); // 获取窗口索引
parent.layer.close(index);
} else {
parent.layer.alert(data.msg)
}
}
});
}
4.5.7 删除文章功能
因为删除不需要单独编写界面，流程与新增、编辑都不一样，删除直接在列表页面进行触发。
1) 建立数据路由：ArticleController中编写bootstrap-table的ajax请求方法 remove
2）运行：编写页面的ajax方法，在浏览器中验证
function remove(id) {
layer.confirm('确定要删除选中的记录？', {
btn : [ '确定', '取消' ]
}, function() {
$.ajax({
url : prefix+"/remove",
type : "post",
data : {
'id' : id
},
success : function(r) {
if (r.code==0) {
layer.msg(r.msg);
reLoad();
}else{
layer.msg(r.msg);
}
}
});
})
}
总结：编写代码工作实际上是枯燥无味的，实际上面的，三层结构代码是可以全部自动生成的，没有必要手动来编写，只不过，在这里，拿出来讲解说明部分原理。
4.6 使用Shiro加入权限认证
如何对4.5的功能加入权限认证，这样，其他人就不能随便使用这些具有危险操作的功能。
在Spring Boot中已经支持了很多权限认证套件，比如Shiro 比如Spring Boot Security，本章实践使用Shiro，他简单而强大，非常适合中后端开发者使用。
Shiro对于使用者来说，虽然简单易于使用，但是里面的各种流程，我到现在还是不求甚解。
4.6.1 Shiro简单说明
有必要简单了解下这个认证框架，采用官方的图片说明
1） Authentication：身份认证/登录，验证用户是不是拥有相应的身份；
2）Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；
3）Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；
4）Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；
这里需要说明的是 Authentication 和 Authorization 看起来是差不多，实 Authentication 是身份证认证，你去公园，进大门就要验票，就是这个。Authorization 是授权，就是你去里面玩，你到了某个景点，还要验证下你是否被授权访问，就是这个Authorization
其他几个说明
5）Web Support：Web支持，可以非常容易的集成到Web环境；
6）Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；
7）Concurrency：shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；
8）Testing：提供测试支持；
9）Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
10）Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。
那么Shiro是如何实现一个认证，又是如何实现一个授权的呢？
这里涉及到几个概念
1）Subject：当前用户，Subject 可以是一个人，但也可以是第三方服务、守护进程帐户、时钟守护任务或者其它–当前和软件交互的任何事件。
解读：你去公园，Subject就是你（人）
2）SecurityManager：管理所有Subject，SecurityManager 是 Shiro 架构的核心，配合内部安全组件共同组成安全伞。
解读：SecurityManager就是公园的门票管理系统（包括了闸机、后台服务等）
3）Realms：用于进行权限信息的验证，我们自己实现。Realm 本质上是一个特定的安全 DAO：它封装与数据源连接的细节，得到Shiro 所需的相关的数据。在配置 Shiro 的时候，你必须指定至少一个Realm 来实现认证（authentication）和/或授权（authorization）。
解读：就是你拿的票，你可以买一个大的门票，也可以买包含特殊项目的门票。不同的门票对应不同的授权。
下面我实际操作如何整合Shiro
4.6.2 Pom中加入Shiro依赖
如下代码：注意这里加入了ehcache、shiro、shiro for spring、shiro ehcache、shiro thymeleaf（与thymeleaf完美结合）
<!-- ehchache -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
</dependency>
<!--shiro -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.3.2</version>
</dependency>
<!-- shiro ehcache -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-ehcache</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>com.github.theborakompanioni</groupId>
<artifactId>thymeleaf-extras-shiro</artifactId>
<version>1.2.1</version>
</dependency>
ehcache配置
ehcache 需要在resources下新建config文件夹，并新建ehcache.xml文配置文件
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
updateCheck="false">
<diskStore path="java.io.tmpdir/Tmp_EhCache" />
<defaultCache eternal="false" maxElementsInMemory="1000"
overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0"
timeToLiveSeconds="600" memoryStoreEvictionPolicy="LRU" />
<cache name="role" eternal="false" maxElementsInMemory="10000"
overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0"
timeToLiveSeconds="0" memoryStoreEvictionPolicy="LFU" />
</ehcache>
4.6.3 在Spring Boot中编写Shiro配置
根据4.6.1简要说明，如下图，我们需要使用Shiro就必须要先创建Shiro SecurityManager,
而创建SecurityManager，的过程就是包括设置Realm。
在Realm中，我们继承两个接口，一个是认证、一个是授权。
1) 增加包名 springstudy.config
2）在springstudy.config增加shiro包名，并增加UserRealm.java 表示Shiro权限认证中的用户票据（门票）。代码如下，我们假设了用户admin密码1234569，拥有一些权限。
/**
* 授权 假设
* system:article:index 列表
* system:article:add 增加权限
* system:article:edit 修改权限
* system:article:remove 删除权限
* system:article:batchRemove 批量删除权限
* */
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
Long userId= ShiroUtils.getUserId();
Set<String> permissions=new HashSet<>();
permissions.add("system:article:index");
permissions.add("system:article:add");
permissions.add("system:article:edit");
permissions.add("system:article:remove");
permissions.add("system:article:batchRemove");
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
info.setStringPermissions(permissions);
return info;
}
/**
* 认证 给出一个假设的admin用户
* */
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
String username=(String)authenticationToken.getPrincipal();
Map<String ,Object> map=new HashMap<>(16);
map.put("username",username);
String password =new String((char[]) authenticationToken.getCredentials());
if(!"admin".equals(username) || !"1234569".equals(password)){
throw new IncorrectCredentialsException("账号或密码不正确");
}
UserDO user=new UserDO();
user.setId(1L);
user.setUsername(username);
user.setPassword(password);
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user, password, getName());
return info;
}
3）在shiro包名下，新建一个ShiroUtils.java的类，作为公用的类
@Autowired
private static SessionDAO sessionDAO;
public static Subject getSubjct() {
return SecurityUtils.getSubject();
}
public static UserDO getUser() {
Object object = getSubjct().getPrincipal();
UserDO userDO=new UserDO();
return (UserDO)object;
}
public static Long getUserId() {
return getUser().getId();
}
public static void logout() {
getSubjct().logout();
}
public static List<Principal> getPrinciples() {
List<Principal> principals = null;
Collection<Session> sessions = sessionDAO.getActiveSessions();
return principals;
}
4）在shiro包名下新建BDSessionListener.java，实现 SessionListener接口
private final AtomicInteger sessionCount = new AtomicInteger(0);
@Override
public void onStart(Session session) {
sessionCount.incrementAndGet();
}
@Override
public void onStop(Session session) {
sessionCount.decrementAndGet();
}
@Override
public void onExpiration(Session session) {
sessionCount.decrementAndGet();
}
public int getSessionCount() {
return sessionCount.get();
}
5）在1）中的包名 config下增加类ShiroConfig.java
详细代码见 源码下载
/**
* shiroFilterFactoryBean 实现过滤器过滤
* setFilterChainDefinitionMap 表示设置可以访问或禁止访问目录
* @param securityManager 安全管理器
* */
@Bean
ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
shiroFilterFactoryBean.setSecurityManager(securityManager);
//设置登录页面
shiroFilterFactoryBean.setLoginUrl("/login");
//登录后的页面
shiroFilterFactoryBean.setSuccessUrl("/article/index");
//未认证页面提示
shiroFilterFactoryBean.setUnauthorizedUrl("/403");
//设置无需加载权限的页面过滤器
LinkedHashMap<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
filterChainDefinitionMap.put("/fonts/**", "anon");
filterChainDefinitionMap.put("/css/**", "anon");
filterChainDefinitionMap.put("/js/**", "anon");
filterChainDefinitionMap.put("/index", "anon");
//authc 有权限
//filterChainDefinitionMap.put("/**", "authc");
filterChainDefinitionMap.put("/**", "authc");
//设置过滤器
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
return shiroFilterFactoryBean;
}
6）运行 http://localhost:8991//index
可以看到，跳转到http://localhost:8991/login
4.6.4 增加用户登录模块
在4.6.3中，在shiro过滤器中，我们默认login是可以访问的，其他都不能访问，用户必须经过shiro进行认真后，才能登录访问其他页面。
1）在resources/templates 下新建 login.html
2）实现html5代码
3) 新增LoginController.java(在controller包名下)
@GetMapping("/login")
public String login(){
return "/login";
}
/**
* 登录按钮对应的 服务端api
* @param username 用户名
* @param password 用户密码
* @return Rsp 返回成功或失败 Json格式
* */
@ResponseBody
@PostMapping("/login")
public Rsp ajaxLogin(@RequestParam String username, @RequestParam String password){
UsernamePasswordToken token = new UsernamePasswordToken(username,password);
Subject subject = SecurityUtils.getSubject();
try{
subject.login(token);
return Rsp.ok();
}catch (AuthenticationException e){
return Rsp.error("用户名或密码错误");
}
}
在浏览器 输入 http://localhost:8991/login
登录后可以进入文章列表页面
4.7 加入测试模块
按照标准流程，我们是要加入单页测试。一般单元测试是在每个功能做完后，就把单元测试用例写完。这样就不会忘记，也不需要重复去做某个功能。但是这里写的实战教程，就单独拿出来说下。
本章使用自带的 spring-boot-test-starter 框架进行单元测试
4.7.1 Spring Boot Test 简介
spring-boot-test-starter 中主要使用了以下几个注解完成测试功能
@BeforeClass 在所有测试方法前执行一次，一般在其中写上整体初始化的代码
@AfterClass 在所有测试方法后执行一次，一般在其中写上销毁和释放资源的代码
@Before 在每个测试方法前执行，一般用来初始化方法（比如我们在测试别的方法时，类中与其他测试方法共享的值已经被改变，为了保证测试结果的有效性，我们会在@Before注解的方法中重置数据）
@After 在每个测试方法后执行，在方法执行完成后要做的事情
@Test(timeout = 1000) 测试方法执行超过1000毫秒后算超时，测试将失败
@Test(expected = Exception.class) 测试方法期望得到的异常类，如果方法执行没有抛出指定的异常，则测试失败
@Ignore(“not ready yet”) 执行测试时将忽略掉此方法，如果用于修饰类，则忽略整个类
@Test 编写一般测试用例
@RunWith 在JUnit中有很多个Runner，他们负责调用你的测试代码，每一个Runner都有各自的特殊功能，你要根据需要选择不同的Runner来运行你的测试代码。
4.7.2 MockMVC
测试Web应用程序，通常使用 MockMVC 测试Controller
使用MockMVC的关键是
在独立项目中使用
MockMvcBuilders.standaloneSetup
在web项目中使用
MockMvcBuilders.webAppContextSetup
4.7.3 Pom中加入依赖
这个已经有了
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
4.7.4 编写基于Controller的单元测试
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringstudyApplication.class)
@AutoConfigureMockMvc
public class ArticleControllerTests {
private URL base;
//定义mockmvc
private MockMvc mvc;
//注入WebApplicationContext
@Autowired
private WebApplicationContext webApplicationContext;
/**
* 在测试之前 初始化mockmvc
* */
@Before
public void testBefore() throws Exception{
String url = "http://localhost:8991";
this.base = new URL(url);
//mvc = MockMvcBuilders.standaloneSetup(new ArticleController()).build();
mvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
}
@After
public void testAfter(){
System.out.println("测试后");
}
/**
* 使用一个测试
* */
@Test
public void saveTest() throws Exception{
MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
map.add("title", "是时候认真学习SpringBoot了");
map.add("content", "是时候认真学习SpringBoot了");
mvc.perform(MockMvcRequestBuilders.post("/article/save").accept(MediaType.ALL)
.params(map))
.andExpect(MockMvcResultMatchers.status().isOk())
.andDo(MockMvcResultHandlers.print());
}
}
问题：因为没有使用过MockMvc，总是测试失败，其实对于陌生的功能点，最好找个简明的知识点学习下。
4.8 加入Web全局拦截器WebMvcConfigurer
通常我们在程序中需要全局处理包括
1）时间格式化问题
2）跨域请求问题
3）路由适配大小写问题
等等，这些问题，不可能在每个页面每个功能的时候一一去做处理，这样工作繁琐，并且容易忘记处理。这里需要加入全局配置。
在Spring Boot 2.0 (Spring 5.0)中已经取消了 WebMvcConfigurerAdapter
@Configuration
public class WebConfigurer implements WebMvcConfigurer {
/**
* 注入路径匹配规则 忽略URL大小写
* */
@Override
public void configurePathMatch(PathMatchConfigurer configurer) {
org.springframework.util.AntPathMatcher matcher=new org.springframework.util.AntPathMatcher();
matcher.setCachePatterns(false);
configurer.setPathMatcher(matcher);
}
/**
* 支持跨域提交
* */
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowCredentials(true)
.allowedHeaders("*")
.allowedOrigins("*")
.allowedMethods("*");
}
}
4.9 加入日志(slf4j+logback)功能
日志功能，无论是哪个插件，基本都是相似的，其日志层级包括了
TARCE , DEBUG , INFO , WARN , ERROR , FATAL , OFF
其市场上主要的插件包括
1）slf4j
2）log4j
3）logback
4）log4j2
本章使用slf4j+logback,slf4j是内置的日志记录组件，logback则主要用来保存记录
4.9.1 在Pom.xml 引入依赖
默认已经包括了slf4j，据说springboot的log就是slf4j提供的。
4.9.1 配置日志框架
引入依赖成功后，就可以使用log了，不过想要漂亮的使用log，我们还需要知道一些配置比如我们会有一些疑问
1）日志保存在哪里
2）日志是每天一份还是一直保存到一份里面
3）能不能像增加注解一样指定哪些类或方法使用日志
具体配置如下：
#slf4j日志配置 logback配置见 resources/logback-spring.xml
logging:
level:
root: error
com.fishpor.springstudy: info
logback配置则使用xml，具体路径是 resources/logback-spring.xml ，没有此文件则新建文件，加入如下代码
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
<contextName>logback</contextName>
<!--输出到控制台-->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<!--按天生成日志-->
<appender name="logFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
<Prudent>true</Prudent>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<FileNamePattern>
applog/%d{yyyy-MM-dd}/%d{yyyy-MM-dd}.log
</FileNamePattern>
</rollingPolicy>
<layout class="ch.qos.logback.classic.PatternLayout">
<Pattern>
%d{yyyy-MM-dd HH:mm:ss} -%msg%n
</Pattern>
</layout>
</appender>
<logger name="com.glsafesports.pine" additivity="false">
<appender-ref ref="console"/>
<appender-ref ref="logFile" />
</logger>
<root level="error">
<appender-ref ref="console"/>
<appender-ref ref="logFile" />
</root>
</configuration>
4.9.2 在代码中应用
在ArticleController中加入测试方法
/**
* 测试 log
* */
@GetMapping("/log")
@ResponseBody
public String log(){
logger.info("info:");
logger.error("info:");
logger.warn("info:");
return "log";
}
4.9.3 运行效果
4.10 加入缓存功能
缓存也是我们系统中常用的功能，这里我们使用比较简单的 ehcache。
另外时下更多的使用 redis 来作为缓存，这个后面单独实战。
4.10.1 在Pom.xml中加入依赖
前面介绍Shiro的时候已经
4.10.2 配置缓存
在前介绍过 编写resources\config\ehcache.xml
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
updateCheck="false">
<diskStore path="java.io.tmpdir/Tmp_EhCache" />
<defaultCache eternal="false" maxElementsInMemory="1000"
overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0"
timeToLiveSeconds="600" memoryStoreEvictionPolicy="LRU" />
<cache name="role" eternal="false" maxElementsInMemory="10000"
overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0"
timeToLiveSeconds="0" memoryStoreEvictionPolicy="LFU" />
</ehcache>
在配置Shiro的时候，在ShiroConfig中配置过
这里在config包名下建立EhCacheConfig.java
@Configuration
@EnableCaching
public class EhCacheConfig {
@Bean
public EhCacheCacheManager ehCacheCacheManager(EhCacheManagerFactoryBean bean){
return new EhCacheCacheManager(bean.getObject());
}
@Bean
public EhCacheManagerFactoryBean ehCacheManagerFactoryBean(){
EhCacheManagerFactoryBean cacheManagerFactoryBean=new EhCacheManagerFactoryBean();
cacheManagerFactoryBean.setConfigLocation(new ClassPathResource("config/ehcache.xml"));
cacheManagerFactoryBean.setShared(true);
return cacheManagerFactoryBean;
}
}
4.10.3 编写缓存代码
使用EhCache使用到两个注解
@Cacheable：负责将方法的返回值加入到缓存中，参数3
@CacheEvict：负责清除缓存，参数4
我们新建一个Controller来测试缓存代码 EhCacheController.java
五 打包发布
1） 打开 View>Tool Windows>Terminal
2）在终端输入
>mvn clean
>mvn install
系统会在根目录下生成 target
六 总结
本章快速实践学习了一套完整的基于Spring Boot开发一个信息管理系统的知识点，本章的目的并不是掌握所有涉及的知识点，而是对Spring Boot整体的项目有一定的了解。对开发的环境有一定的了解。
我们发现几乎所有的功能都可以通过引用第三方依赖实现相关功能，换句话说就是大部分功能别人都写好了。
我们通过总结又发现，所有依赖的功能在使用上都是一致的，他们包括
1）引入pom.xml中的依赖
2）配置插件（各个插件有独立的配置，可以参加插件的官方文档）
3）在代码中编写或使用引入的插件
4）编写测试代码测试
5）运行查看效果
