Spring Boot 2.x 综合示例-整合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 分层架构

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

经典的三层、展示层、服务层、数据库访问层。

所以在项目结构中我们可以设计成

3.2 数据库设计

本次只是为了演示相关技术,所以采用单表设计,就设计一个t_article表,用户名与密码采用固定的。数据库设计尽量符合相关标准(本文中已小写下滑线来命名字段)

数据库 article

1)表 t_article设计

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

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实例是一样的

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

3)选择依赖,我们选择Web

注:也可以使用HelloWorld示例项目,Copy一份,来做。

4.1.2 初始化项目结构

在springstudy包名下增加包名

1)controller mvc控制层

2)dao mybatis的数据库访问层

3)domain 实体类对应数据库字段

4)service 服务层

  impl 服务实现

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

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

如下图:是浏览器的截图和数据库插入的数据展示。

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

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 如下图:

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

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)运行:在浏览器中验证

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

 注意:本页面没有用到thymeleaf的模板语句。

4.5.5 添加文章功能

注意,我们使用了layui的弹窗组件。

1)建立模板页面: resources/templates/article/add.html

2   建立路由:在ArticleController中增加前端页面路由/article/

3)  建立数据路由:ArticleController中编写bootstrap-table的ajax请求方法 save

4)运行:编写页面的ajax方法,在浏览器中验证

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

保存新增数据代码

   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简单说明

有必要简单了解下这个认证框架,采用官方的图片说明

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

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是如何实现一个认证,又是如何实现一个授权的呢?

这里涉及到几个概念

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

1)Subject:当前用户,Subject 可以是一个人,但也可以是第三方服务、守护进程帐户、时钟守护任务或者其它–当前和软件交互的任何事件。

解读:你去公园,Subject就是你(人)
2)SecurityManager:管理所有Subject,SecurityManager 是 Shiro 架构的核心,配合内部安全组件共同组成安全伞。

解读:SecurityManager就是公园的门票管理系统(包括了闸机、后台服务等)
3)Realms:用于进行权限信息的验证,我们自己实现。Realm 本质上是一个特定的安全 DAO:它封装与数据源连接的细节,得到Shiro 所需的相关的数据。在配置 Shiro 的时候,你必须指定至少一个Realm 来实现认证(authentication)和/或授权(authorization)。

解读:就是你拿的票,你可以买一个大的门票,也可以买包含特殊项目的门票。不同的门票对应不同的授权。

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

下面我实际操作如何整合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中,我们继承两个接口,一个是认证、一个是授权。

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

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

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

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 

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

登录后可以进入文章列表页面

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 运行效果

Spring Boot 2.x 综合示例-整合thymeleaf、mybatis、shiro、logging、cache开发一个文章发布管理系统

  

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)运行查看效果

上一篇:18.Mysql搜索引擎及其区别


下一篇:collections系列之OrderedDict【有序字典】与DefaultDict【默认字典】