基于SpringBoot+Vue开发的前后端分离博客项目-Java后端接口开发

文章目录

1. 前言
2. 新建Springboot项目
3. 整合mybatis plus
- 第一步：导依赖
- 第二步：写配置文件
- 第三步：mapper扫描+分页插件
- 第四步：代码生成配置
- 第五步：执行代码生成
4. 统一结果封装
5. 逻辑整理
- 5.1. 登录逻辑
- 5.2. 用户访问后端逻辑
1.6. 整合shiro+jwt+会话共享
- 6.1. 导入pom依赖
- 6.2. 编写配置
- 6.4. AccountRealm
- 6.5. JwtToken
- 6.6. JwtUtils
- 6.7. AccountProfile
- 6.8. shiro redis配置
- 6.9. JwtFilter
- 6.10. 权限注解测试
7. 全局异常处理
8. 实体校验
9. 跨域问题
- 9.1.全局跨域处理
- 9.2. jwtfliter 之前跨域
10.登录接口开发
- 10.1. 登录对象封装
- 10.2. 用户接口
- 10.3. 全局异常丰富
11.博客接口开发
- 11.1. 接口开发
11.2.实体类校验
- 11.3. 博文接口测试
12. 后端接口开发总结

作者：吕一明
项目代码：https://github.com/MarkerHub/vueblog
项目视频：https://www.bilibili.com/video/BV1PQ4y1P7hZ/

1. 前言

从零开始搭建一个项目骨架，最好选择合适，熟悉的技术，并且在未来易拓展，适合微服务化体系等。所以一般以Springboot作为我们的框架基础，这是离不开的了。
然后数据层，我们常用的是Mybatis，易上手，方便维护。但是单表操作比较困难，特别是添加字段或减少字段的时候，比较繁琐，所以这里我推荐使用Mybatis Plus为简化开发而生，为简化开发而生，只… CRUD 操作，从而节省大量时间。
作为一个项目骨架，权限也是我们不能忽略的，Shiro配置简单，使用也简单，所以使用Shiro作为我们的的权限。
考虑到项目可能需要部署多台，这时候我们的会话等信息需要共享，Redis是现在主流的缓存中间件，也适合我们的项目。
然后因为前后端分离，所以我们使用jwt作为我们用户身份凭证。
ok，我们现在就开始搭建我们的项目脚手架！
技术栈：

SpringBoot
mybatis plus
shiro
lombok
redis
hibernate validatior
jwt

导图：http://www.markerhub.com/map/131

2. 新建Springboot项目

这里，我们使用IDEA来开发我们项目，新建步骤比较简单，我们就不截图了。
开发工具与环境：

idea
mysql
jdk 8
maven3.3.9

新建好的项目结构如下，SpringBoot版本使用的目前最新的2.2.6.RELEASE版本

pom.xml

    <!--web启动器--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--热部署--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional></dependency><!--数据库驱动--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency>

devtools：项目的热加载重启插件
lombok：简化代码的工具

3. 整合mybatis plus

接下来，我们来整合mybatis plus，让项目能完成基本的增删改查操作。步骤很简单：可以去官网看看：https://mp.baomidou.com/guide/install.html

第一步：导依赖

pom中导入mybatis plus的jar包，因为后面会涉及到代码生成，所以我们还需要导入页面模板引擎，这里我们用的是freemarker。

   <!--mybatis-plus--><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.2.0</version></dependency><!--mp代码生成器--><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-generator</artifactId><version>3.2.0</version></dependency><!--模板引擎--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-freemarker</artifactId></dependency>

第二步：写配置文件

# DataSource Config
spring:datasource:driver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://localhost:3306/vueblog?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghaiusername: rootpassword: root
mybatis-plus:mapper-locations: classpath*:/mapper/**Mapper.xml

上面除了配置数据库的信息，还配置了myabtis plus的mapper的xml文件的扫描路径，这一步不要忘记了。

第三步：mapper扫描+分页插件

开启mapper接口扫描，添加分页插件

新建一个config包：通过@mapperScan注解指定要变成实现类的接口所在的包，然后包下面的所有接口在编译之后都会生成相应的实现类。PaginationInterceptor是一个分页插件。

com.gblfy.config.MybatisPlusConfig

package com.gblfy.config;import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;@Configuration
@EnableTransactionManagement
@MapperScan("com.gblfy.mapper")
public class MybatisPlusConfig {@Beanpublic PaginationInterceptor paginationInterceptor() {PaginationInterceptor paginationInterceptor = new PaginationInterceptor();return paginationInterceptor;}
}

第四步：代码生成配置

如果你没再用其他插件，那么现在就已经可以使用mybatis plus了，官方给我们提供了一个代码生成器，然后我写上自己的参数之后，就可以直接根据数据库表信息生成entity、service、mapper等接口和实现类。

com.gblfy.CodeGenerator

package com.gblfy.generator;import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;// 演示例子，执行 main 方法控制台输入模块表名回车自动生成对应项目目录中
public class CodeGenerator {/*** <p>* 读取控制台内容* </p>*/public static String scanner(String tip) {Scanner scanner = new Scanner(System.in);StringBuilder help = new StringBuilder();help.append("请输入" + tip + "：");System.out.println(help.toString());if (scanner.hasNext()) {String ipt = scanner.next();if (StringUtils.isNotEmpty(ipt)) {return ipt;}}throw new MybatisPlusException("请输入正确的" + tip + "！");}public static void main(String[] args) {// 代码生成器AutoGenerator mpg = new AutoGenerator();// 全局配置GlobalConfig gc = new GlobalConfig();String projectPath = System.getProperty("user.dir");gc.setOutputDir(projectPath + "/src/main/java");
//        gc.setOutputDir("D:\\test");gc.setAuthor("gblfy");gc.setOpen(false);// gc.setSwagger2(true); 实体属性 Swagger2 注解gc.setServiceName("%sService");mpg.setGlobalConfig(gc);// 数据源配置DataSourceConfig dsc = new DataSourceConfig();dsc.setUrl("jdbc:mysql://localhost:3306/vueblog?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=UTC");// dsc.setSchemaName("public");dsc.setDriverName("com.mysql.cj.jdbc.Driver");dsc.setUsername("root");dsc.setPassword("root");mpg.setDataSource(dsc);// 包配置PackageConfig pc = new PackageConfig();pc.setModuleName(null);pc.setParent("com.gblfy");mpg.setPackageInfo(pc);// 自定义配置InjectionConfig cfg = new InjectionConfig() {@Overridepublic void initMap() {// to do nothing}};// 如果模板引擎是 freemarkerString templatePath = "/templates/mapper.xml.ftl";// 如果模板引擎是 velocity// String templatePath = "/templates/mapper.xml.vm";// 自定义输出配置List<FileOutConfig> focList = new ArrayList<>();// 自定义配置会被优先输出focList.add(new FileOutConfig(templatePath) {@Overridepublic String outputFile(TableInfo tableInfo) {// 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！return projectPath + "/src/main/resources/mapper/"+ "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;}});cfg.setFileOutConfigList(focList);mpg.setCfg(cfg);// 配置模板TemplateConfig templateConfig = new TemplateConfig();templateConfig.setXml(null);mpg.setTemplate(templateConfig);// 策略配置StrategyConfig strategy = new StrategyConfig();strategy.setNaming(NamingStrategy.underline_to_camel);strategy.setColumnNaming(NamingStrategy.underline_to_camel);strategy.setEntityLombokModel(true);strategy.setRestControllerStyle(true);strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));strategy.setControllerMappingHyphenStyle(true);strategy.setTablePrefix("m_");mpg.setStrategy(strategy);mpg.setTemplateEngine(new FreemarkerTemplateEngine());mpg.execute();}
}

首先我在数据库中新建了一个user表：

CREATE TABLE `m_user` (`id` bigint(20) NOT NULL AUTO_INCREMENT,`username` varchar(64) DEFAULT NULL,`avatar` varchar(255) DEFAULT NULL,`email` varchar(64) DEFAULT NULL,`password` varchar(64) DEFAULT NULL,`status` int(5) NOT NULL,`created` datetime DEFAULT NULL,`last_login` datetime DEFAULT NULL,PRIMARY KEY (`id`),KEY `UK_USERNAME` (`username`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `m_blog` (`id` bigint(20) NOT NULL AUTO_INCREMENT,`user_id` bigint(20) NOT NULL,`title` varchar(255) NOT NULL,`description` varchar(255) NOT NULL,`content` longtext,`created` datetime NOT NULL ON UPDATE CURRENT_TIMESTAMP,`status` tinyint(4) DEFAULT NULL,PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8mb4;
INSERT INTO `vueblog`.`m_user` (`id`, `username`, `avatar`, `email`, `password`, `status`, `created`, `last_login`) VALUES ('1', 'markerhub', 'https://image-1300566513.cos.ap-guangzhou.myqcloud.com/upload/images/5a9f48118166308daba8b6da7e466aab.jpg', NULL, '96e79218965eb72c92a549dd5a330112', '0', '2020-04-20 10:44:01', NULL);

第五步：执行代码生成

运行CodeGenerator的main方法，输入表名：m_user，m_blog生成结果如下：

简洁！方便！经过上面的步骤，基本上我们已经把mybatis plus框架集成到项目中了。

在UserController中写个测试：


@RestController
@RequestMapping("/user")
public class UserController {@Autowiredprivate UserService userService;@GetMapping("/{id}")public Object test(@PathVariable("id") Long id) {return userService.getById(id);}}

访问：http://localhost:8080/user/1 获得结果如下，整合成功！

4. 统一结果封装

这里我们用到了一个Result的类，这个用于我们的异步统一返回的结果封装。一般来说，结果里面有几个要素必要的

是否成功，可用code表示（如200表示成功，400表示异常）
结果消息
结果数据

所以可得到封装如下：

com.gblfy.common.lang.Result

package com.gblfy.common.lang;import lombok.Data;import java.io.Serializable;@Data
public class Result implements Serializable {private int code;//（200成功 400失败）private String msg;private Object data;//成功的场景 可以根据需求自定义public static Result succ(Object data) {return succ(200, "操作成功", data);}public static Result succ(int code, String msg, Object data) {Result r = new Result();r.setCode(200);r.setMsg(msg);r.setData(data);return r;}//失败的场景 可以根据需求自定义public static Result fail(String msg) {return fail(msg, null);}public static Result fail(String msg, Object data) {return fail(400, msg, data);}public static Result fail(int code, String msg, Object data) {Result r = new Result();r.setCode(code);r.setMsg(msg);r.setData(data);return r;}
}

test方法改造

 /*** 测试地址：http://localhost:8080/user/1* @param id* @return*/@GetMapping("/{id}")public Result test(@PathVariable("id") Long id) {User user = userService.getById(id);return Result.succ(user);}

5. 逻辑整理

5.1. 登录逻辑

1.用户输入用户名密码登录
2.登录请求后端，会对前端传过来的用户名密码进行校验，
- 1>用户名或密码错误就抛出异常，全局异常类就会捕获此异常，进行统一异常处理
- 2>用户名或密码正确，就生成jwt用户身份凭证
3.后端生成的jwt用户身份凭证返回前端，访问后端资源接口时，用户携带者jwt用户身份凭证

5.2. 用户访问后端逻辑

1.用户访问后端资源接口，首先被JwtFilter统一拦截
2.JwtFilter处理
- 1>携带jwt用户身份凭证，shiro登录处理
  - ①携带jwt过期
  - ②jwt不正确
  - ③jwt用户身份凭证正确，访问某资源接口

以上不正常场景，都会抛出异常，由全局异常处理类捕获处理

2>无jwt用户身份凭证，访问某资源接口
3.当访问某一资源接口之前，接口方法上会有角色或者资源权限的注解过滤
- 1>校验通过，正常获取资源，返回后端数据给用户
- 2>校验不通过，抛出异常，由全局异常处理类捕获处理

1.6. 整合shiro+jwt+会话共享

考虑到后面可能需要做集群、负载均衡等，所以就需要会话共享，而shiro的缓存和会话信息，我们一般考虑使用redis来存储这些数据，所以，我们不仅仅需要整合shiro，同时也需要整合redis。在开源的项目中，我们找到了一个starter可以快速整合shiro-redis，配置简单，这里也推荐大家使用。

而因为我们需要做的是前后端分离项目的骨架，所以一般我们会采用token或者jwt作为跨域身份验证解决方案。所以整合shiro的过程中，我们需要引入jwt的身份验证过程。

那么我们就开始整合：

我们使用一个shiro-redis-spring-boot-starter的jar包，具体教程可以看官方文档：

https://github.com/alexxiyang/shiro-redis/blob/master/docs/README.md#spring-boot-starter

6.1. 导入pom依赖

导入shiro-redis的starter包：还有jwt的工具包，以及为了简化开发，我引入了hutool工具包。

  <!--shiro-redis--><dependency><groupId>org.crazycake</groupId><artifactId>shiro-redis-spring-boot-starter</artifactId><version>3.2.1</version></dependency><!-- hutool工具类--><dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.3.3</version></dependency><!-- jwt --><dependency><groupId>io.jsonwebtoken</groupId><artifactId>jjwt</artifactId><version>0.9.1</version></dependency>

6.2. 编写配置

com.gblfy.config.ShiroConfig

package com.gblfy.config;import com.gblfy.shiro.AccountRealm;
import com.gblfy.shiro.JwtFilter;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.mgt.SessionManager;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.spring.web.config.DefaultShiroFilterChainDefinition;
import org.apache.shiro.spring.web.config.ShiroFilterChainDefinition;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;/*** shiro启用注解拦截控制器*/
@Configuration
public class ShiroConfig {@AutowiredJwtFilter jwtFilter;@Beanpublic SessionManager sessionManager(RedisSessionDAO redisSessionDAO) {DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();sessionManager.setSessionDAO(redisSessionDAO);return sessionManager;}@Beanpublic DefaultWebSecurityManager securityManager(AccountRealm accountRealm,SessionManager sessionManager,RedisCacheManager redisCacheManager) {DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(accountRealm);securityManager.setSessionManager(sessionManager);securityManager.setCacheManager(redisCacheManager);/** 关闭shiro自带的session，详情见文档*/DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();defaultSessionStorageEvaluator.setSessionStorageEnabled(false);subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);securityManager.setSubjectDAO(subjectDAO);return securityManager;}@Beanpublic ShiroFilterChainDefinition shiroFilterChainDefinition() {DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();Map<String, String> filterMap = new LinkedHashMap<>();filterMap.put("/**", "jwt"); // 主要通过注解方式校验权限chainDefinition.addPathDefinitions(filterMap);return chainDefinition;}@Bean("shiroFilterFactoryBean")public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager,ShiroFilterChainDefinition shiroFilterChainDefinition) {ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();shiroFilter.setSecurityManager(securityManager);Map<String, Filter> filters = new HashMap<>();filters.put("jwt", jwtFilter);shiroFilter.setFilters(filters);Map<String, String> filterMap = shiroFilterChainDefinition.getFilterChainMap();shiroFilter.setFilterChainDefinitionMap(filterMap);return shiroFilter;}@Beanpublic static DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();//强制使用cglib，防止重复代理和可能引起代理出错的问题//https://zhuanlan.zhihu.com/p/29161098defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);return defaultAdvisorAutoProxyCreator;}/*** 启用shoiro内部Bean生命周期管理** @return*/@Bean(name = "lifecycleBeanPostProcessor")public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {LifecycleBeanPostProcessor lifecycleBeanPostProcessor = new LifecycleBeanPostProcessor();return lifecycleBeanPostProcessor;}/*** 启用shiro注解** @param securityManager* @return*/@Beanpublic AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();advisor.setSecurityManager(securityManager);return advisor;}
}

上面ShiroConfig，我们主要做了几件事情：

引入RedisSessionDAO和RedisCacheManager，为了解决shiro的权限数据和会话信息能保存到redis中，实现会话共享。
重写了SessionManager和DefaultWebSecurityManager，同时在DefaultWebSecurityManager中为了关闭shiro自带的session方式，我们需要设置为false，这样用户就不再能通过session方式登录shiro。后面将采用jwt凭证登录。
在ShiroFilterChainDefinition中，我们不再通过编码形式拦截Controller访问路径，而是所有的路由都需要经过JwtFilter这个过滤器，然后判断请求头中是否含有jwt的信息，有就登录，没有就跳过。跳过之后，有Controller中的shiro注解进行再次拦截，比如@RequiresAuthentication，这样控制权限访问。

那么，接下来，我们聊聊ShiroConfig中出现的AccountRealm，还有JwtFilter。

6.4. AccountRealm

AccountRealm是shiro进行登录或者权限校验的逻辑所在，算是核心了，我们需要重写3个方法，分别是

supports：为了让realm支持jwt的凭证校验
doGetAuthorizationInfo：权限校验
doGetAuthenticationInfo：登录认证校验

我们先来总体看看AccountRealm的代码，然后逐个分析：

com.gblfy.shiro.AccountRealm

package com.gblfy.shiro;import cn.hutool.core.bean.BeanUtil;
import com.gblfy.entity.User;
import com.gblfy.service.UserService;
import com.gblfy.util.JwtUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;@Slf4j
@Component
public class AccountRealm extends AuthorizingRealm {@AutowiredJwtUtils jwtUtils;@AutowiredUserService userService;@Overridepublic boolean supports(AuthenticationToken token) {return token instanceof JwtToken;}@Overrideprotected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {return null;}@Overrideprotected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {JwtToken jwtToken = (JwtToken) token;String userId = jwtUtils.getClaimByToken((String) jwtToken.getPrincipal()).getSubject();User user = userService.getById(Long.valueOf(userId));if (user == null) {throw new UnknownAccountException("账户不存在");}if (user.getStatus() == -1) {throw new LockedAccountException("账户已被锁定");}AccountProfile profile = new AccountProfile();BeanUtil.copyProperties(user, profile);return new SimpleAuthenticationInfo(profile, jwtToken.getCredentials(), getName());}
}

其实主要就是doGetAuthenticationInfo登录认证这个方法，可以看到我们通过jwt获取到用户信息，判断用户的状态，最后异常就抛出对应的异常信息，否者封装成SimpleAuthenticationInfo返回给shiro。接下来我们逐步分析里面出现的新类：

1、shiro默认supports的是UsernamePasswordToken，而我们现在采用了jwt的方式，所以这里我们自定义一个JwtToken，来完成shiro的supports方法。

6.5. JwtToken

com.gblfy.shiro.JwtToken

package com.gblfy.shiro;import org.apache.shiro.authc.AuthenticationToken;public class JwtToken implements AuthenticationToken {private String token;public JwtToken(String jwt) {this.token = jwt;}@Overridepublic Object getPrincipal() {return token;}@Overridepublic Object getCredentials() {return token;}
}

6.6. JwtUtils

是个生成和校验jwt的工具类，其中有些jwt相关的密钥信息是从项目配置文件中配置的：

package com.gblfy.util;import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;import java.util.Date;/*** jwt工具类*/
@Slf4j
@Data
@Component
@ConfigurationProperties(prefix = "gblfy.jwt")
public class JwtUtils {private String secret;private long expire;private String header;/*** 生成jwt token*/public String generateToken(long userId) {Date nowDate = new Date();//过期时间Date expireDate = new Date(nowDate.getTime() + expire * 1000);return Jwts.builder().setHeaderParam("typ", "JWT").setSubject(userId + "").setIssuedAt(nowDate).setExpiration(expireDate).signWith(SignatureAlgorithm.HS512, secret).compact();}/*** 校验jwt是否合法** @param token* @return*/public Claims getClaimByToken(String token) {try {return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();} catch (Exception e) {log.debug("validate is token error ", e);return null;}}/*** token是否过期** @return true：过期*/public boolean isTokenExpired(Date expiration) {return expiration.before(new Date());}
}

6.7. AccountProfile

而在AccountRealm我们还用到了AccountProfile，这是为了登录成功之后返回的一个用户信息的载体，AccountProfile

com.gblfy.shiro.AccountProfile

package com.gblfy.shiro;import lombok.Data;import java.io.Serializable;@Data
public class AccountProfile implements Serializable {private Long id;private String username;private String avatar;private String email;}

6.8. shiro redis配置

第三步，ok，基本的校验的路线完成之后，我们需要少量的基本信息配置：

shiro-redis:enabled: trueredis-manager:host: 127.0.0.1:6379
markerhub:jwt:# 加密秘钥secret: f4e2e52034348f86b67cde581c0f9eb5# token有效时长，7天，单位秒expire: 604800header: token

第四步：另外，如果你项目有使用spring-boot-devtools，需要添加一个配置文件，在resources目录下新建文件夹META-INF，然后新建文件spring-devtools.properties，这样热重启时候才不会报错。

resources/META-INF/spring-devtools.properties

restart.include.shiro-redis=/shiro-[\\w-\\.]+jar

6.9. JwtFilter

第五步：定义jwt的过滤器JwtFilter。

这个过滤器是我们的重点，这里我们继承的是Shiro内置的AuthenticatingFilter，一个可以内置了可以自动登录方法的的过滤器，有些同学继承BasicHttpAuthenticationFilter也是可以的。

我们需要重写几个方法：

createToken：实现登录，我们需要生成我们自定义支持的JwtToken
onAccessDenied：拦截校验，当头部没有Authorization时候，我们直接通过，不需要自动登录；当带有的时候，首先我们校验jwt的有效性，没问题我们就直接执行executeLogin方法实现自动登录
onLoginFailure：登录异常时候进入的方法，我们直接把异常信息封装然后抛出
preHandle：拦截器的前置拦截，因为我们是前后端分析项目，项目中除了需要跨域全局配置之外，我们再拦截器中也需要提供跨域支持。这样，拦截器才不会在进入Controller之前就被限制了。

下面我们看看总体的代码：

com.gblfy.shiro.JwtFilter

package com.gblfy.shiro;import cn.hutool.json.JSONUtil;
import com.gblfy.common.lang.Result;
import com.gblfy.util.JwtUtils;
import io.jsonwebtoken.Claims;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.ExpiredCredentialsException;
import org.apache.shiro.web.filter.authc.AuthenticatingFilter;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMethod;import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;@Component
public class JwtFilter extends AuthenticatingFilter {@AutowiredJwtUtils jwtUtils;@Overrideprotected AuthenticationToken createToken(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {// 获取 tokenHttpServletRequest request = (HttpServletRequest) servletRequest;String jwt = request.getHeader("Authorization");if (StringUtils.isEmpty(jwt)) {return null;}return new JwtToken(jwt);}@Overrideprotected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {// 获取 tokenHttpServletRequest request = (HttpServletRequest) servletRequest;String jwt = request.getHeader("Authorization");if (StringUtils.isEmpty(jwt)) {// 无 jwt(token)直接访问资源方法通过权限朱姐过滤拦截return true;} else {// 校验jwt(token)Claims claim = jwtUtils.getClaimByToken(jwt);if (claim == null || jwtUtils.isTokenExpired(claim.getExpiration())) {throw new ExpiredCredentialsException("token 已失效，请重新登陆");}// 执行登陆return executeLogin(servletRequest, servletResponse);}}/*** 登陆失败处理* 账号锁定  账号不存在等** @param token* @param e* @param request* @param response* @return*/@Overrideprotected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) {HttpServletResponse httpServletResponse = (HttpServletResponse) response;Throwable throwable = e.getCause() == null ? e : e.getCause();Result result = Result.fail(throwable.getMessage());String jsonStr = JSONUtil.toJsonStr(result);try {//响应给前端httpServletResponse.getWriter().print(jsonStr);} catch (IOException ioException) {}return false;}/*** 在JwtFilter处理逻辑之前，进行跨域处理** @param request* @param response* @return* @throws Exception*/@Overrideprotected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {HttpServletRequest httpServletRequest = WebUtils.toHttp(request);HttpServletResponse httpServletResponse = WebUtils.toHttp(response);httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));// 跨域时会首先发送一个OPTIONS请求，这里我们给OPTIONS请求直接返回正常状态if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {httpServletResponse.setStatus(org.springframework.http.HttpStatus.OK.value());return false;}return super.preHandle(request, response);}
}

那么到这里，我们的shiro就已经完成整合进来了，并且使用了jwt进行身份校验。

6.10. 权限注解测试

    /*** 测试地址：http://localhost:8080/user/1* @param id* @return*/@RequiresAuthentication@GetMapping("/{id}")public Result test(@PathVariable("id") Long id) {User user = userService.getById(id);return Result.succ(user);}

7. 全局异常处理

有时候不可避免服务器报错的情况，如果不配置异常处理机制，就会默认返回tomcat或者nginx的5XX页面，对普通用户来说，不太友好，用户也不懂什么情况。这时候需要我们程序员设计返回一个友好简单的格式给前端。

处理办法如下：通过使用@ControllerAdvice来进行统一异常处理，@ExceptionHandler(value = RuntimeException.class)来指定捕获的Exception各个类型异常，这个异常的处理，是全局的，所有类似的异常，都会跑到这个地方处理。

com.gblfy.common.exception.GlobalExceptionHandler

步骤二、定义全局异常处理，@ControllerAdvice表示定义全局控制器异常处理，@ExceptionHandler表示针对性异常处理，可对每种异常针对性处理。

package com.gblfy.common.exception;import com.gblfy.common.lang.Result;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.ShiroException;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;import java.io.IOException;@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {/*** 处理Assert断言的异常*/@ResponseStatus(HttpStatus.BAD_REQUEST)@ExceptionHandler(value = IllegalArgumentException.class)public Result handler(IllegalArgumentException e) throws IOException {log.error("Assert异常:-------------->{}", e.getMessage());return Result.fail(e.getMessage());}/*** @Validated 校验错误异常处理*/@ResponseStatus(HttpStatus.BAD_REQUEST)@ExceptionHandler(value = MethodArgumentNotValidException.class)public Result handler(MethodArgumentNotValidException e) throws IOException {log.error("运行时异常:-------------->", e);BindingResult bindingResult = e.getBindingResult();ObjectError objectError = bindingResult.getAllErrors().stream().findFirst().get();return Result.fail(objectError.getDefaultMessage());}/*** Shiro异常捕获** @param e* @return*/@ResponseStatus(HttpStatus.UNAUTHORIZED)@ExceptionHandler(value = ShiroException.class)public Result handler(ShiroException e) {log.error("运行时异常：----------------{}", e);return Result.fail(401, e.getMessage(), null);}/*** 运行时异常捕获** @param e* @return*/@ResponseStatus(HttpStatus.BAD_REQUEST)@ExceptionHandler(value = RuntimeException.class)public Result handler(RuntimeException e) {log.error("运行时异常：----------------{}", e);return Result.fail(e.getMessage());}}

上面我们捕捉了几个异常：

ShiroException：shiro抛出的异常，比如没有权限，用户登录异常
IllegalArgumentException：处理Assert的异常
MethodArgumentNotValidException：处理实体校验的异常
RuntimeException：捕捉其他异常

8. 实体校验

当我们表单数据提交的时候，前端的校验我们可以使用一些类似于jQuery Validate等js插件实现，而后端我们可以使用Hibernate validatior来做校验。

我们使用springboot框架作为基础，那么就已经自动集成了Hibernate validatior。

那么用起来啥样子的呢？

第一步：首先在实体的属性上添加对应的校验规则，比如：

@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("m_user")
public class User implements Serializable {private static final long serialVersionUID = 1L;@TableId(value = "id", type = IdType.AUTO)private Long id;@NotBlank(message = "昵称不能为空")private String username;private String avatar;@NotBlank(message = "邮箱不能为空")@Email(message = "邮箱格式不正确")private String email;private String password;private Integer status;private LocalDateTime created;private LocalDateTime lastLogin;
}

测试方法

 /*** 测试实体校验** @param user* @return*/@PostMapping("save")public Result save(@Validated @RequestBody User user) {return Result.succ(user);}

postman 测试

http://localhost:8080/user/save

{"username":"gblfy","email": "xxxx"
}

9. 跨域问题

因为是前后端分析，所以跨域问题是避免不了的，我们直接在后台进行全局跨域处理：

9.1.全局跨域处理

com.gblfy.config.CorsConfig

package com.gblfy.config;import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;/*** 解决跨域问题*/
@Configuration
public class CorsConfig implements WebMvcConfigurer {@Overridepublic void addCorsMappings(CorsRegistry registry) {registry.addMapping("/**").allowedOrigins("*").allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS").allowCredentials(true).maxAge(3600).allowedHeaders("*");}
}

9.2. jwtfliter 之前跨域

在JwtFilter勒种添加此方法，解决跨域处理

/*** 在JwtFilter处理逻辑之前，进行跨域处理** @param request* @param response* @return* @throws Exception*/@Overrideprotected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {HttpServletRequest httpServletRequest = WebUtils.toHttp(request);HttpServletResponse httpServletResponse = WebUtils.toHttp(response);httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));// 跨域时会首先发送一个OPTIONS请求，这里我们给OPTIONS请求直接返回正常状态if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {httpServletResponse.setStatus(org.springframework.http.HttpStatus.OK.value());return false;}return super.preHandle(request, response);}

ok，因为我们系统开发的接口比较简单，所以我就不集成swagger2啦，也比较简单而已。下面我们就直接进入我们的正题，进行编写登录接口。

10.登录接口开发

10.1. 登录对象封装

登录的逻辑其实很简答，只需要接受账号密码，然后把用户的id生成jwt，返回给前段，为了后续的jwt的延期，所以我们把jwt放在header上。具体代码如下：

com.gblfy.controller.AccountController

package com.gblfy.common.dto;import lombok.Data;import javax.validation.constraints.NotBlank;
import java.io.Serializable;@Data
public class LoginDto implements Serializable {@NotBlank(message = "昵称不能为空")private String username;@NotBlank(message = "密码不能为空")private String password;
}

10.2. 用户接口

package com.gblfy.controller;import cn.hutool.core.lang.Assert;
import cn.hutool.core.map.MapUtil;
import cn.hutool.crypto.SecureUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.gblfy.common.dto.LoginDto;
import com.gblfy.common.lang.Result;
import com.gblfy.entity.User;
import com.gblfy.service.UserService;
import com.gblfy.util.JwtUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresAuthentication;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;import javax.servlet.http.HttpServletResponse;@RestController
public class AccountController {@AutowiredUserService userService;@AutowiredJwtUtils jwtUtils;/*** 用户登录接口** @param loginDto* @param response* @return*/@PostMapping("/login")public Result login(@Validated @RequestBody LoginDto loginDto, HttpServletResponse response) {User user = userService.getOne(new QueryWrapper<User>().eq("username", loginDto.getUsername()));//使用Assert断言判断用户存不存在  会抛出IllegalArgumentException，需要在全局异常捕获处理Assert.notNull(user, "用户不存在！");if (!user.getPassword().equals(SecureUtil.md5(loginDto.getPassword()))) {return Result.fail("密码不正确！");}//校验通过生成jwtString jwt = jwtUtils.generateToken(user.getId());//将jwt放入headerresponse.setHeader("Authorization", jwt);response.setHeader("Access-control-Expose-Headers", "Authorization");return Result.succ(MapUtil.builder().put("id", user.getId()).put("username", user.getUsername()).put("aAvatar", user.getAvatar()).put("email", user.getEmail()).map());}/*** 用户登出接口** @return*/@RequiresAuthentication@PostMapping("/logout")public Result logout() {SecurityUtils.getSubject().logout();return Result.succ(null);}
}

注意@RequiresAuthentication说明需要登录之后才能访问的接口，其他需要权限的接口可以添加shiro的相关注解。接口比较简单，我们就不多说了，基本增删改查而已。注意的是edit方法是需要登录才能操作的受限资源。

10.3. 全局异常丰富

在GlobalExceptionHandler类中添加校验异常和断言异常处理

/*** 处理Assert断言的异常*/@ResponseStatus(HttpStatus.BAD_REQUEST)@ExceptionHandler(value = IllegalArgumentException.class)public Result handler(IllegalArgumentException e) throws IOException {log.error("Assert异常:-------------->{}", e.getMessage());return Result.fail(e.getMessage());}/*** @Validated 校验错误异常处理*/@ResponseStatus(HttpStatus.BAD_REQUEST)@ExceptionHandler(value = MethodArgumentNotValidException.class)public Result handler(MethodArgumentNotValidException e) throws IOException {log.error("运行时异常:-------------->", e);BindingResult bindingResult = e.getBindingResult();ObjectError objectError = bindingResult.getAllErrors().stream().findFirst().get();return Result.fail(objectError.getDefaultMessage());}

11.博客接口开发

11.1. 接口开发

package com.gblfy.controller;import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.gblfy.common.lang.Result;
import com.gblfy.entity.Blog;
import com.gblfy.service.BlogService;
import com.gblfy.util.ShiroUtil;
import org.apache.shiro.authz.annotation.RequiresAuthentication;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;import java.time.LocalDateTime;/*** <p>* 前端控制器* </p>** @author gblfy* @since 2020-06-02*/
@RestController
public class BlogController {@AutowiredBlogService blogService;/*** 博文列表** @param currentPage* @return*/@GetMapping("/blogs")public Result list(@RequestParam(defaultValue = "1") Integer currentPage) {//当前第几页 一页显示几条 默认5条Page page = new Page(currentPage, 5);//设置分页显示的条件 例如：逻辑删除的 排序等 都可以在这里面追加IPage pageData = blogService.page(page, new QueryWrapper<Blog>().orderByDesc("created"));return Result.succ(pageData);}/*** 博文查询** @param id* @return*/@GetMapping("/blog/{id}")public Result detail(@PathVariable(name = "id") Long id) {Blog blog = blogService.getById(id);Assert.notNull(blog, "该博客已被删除");return Result.succ(blog);}/*** 博文添加和编辑** @param blog* @return*/@RequiresAuthentication@PostMapping("/blog/edit")public Result edit(@Validated @RequestBody Blog blog) {Blog temp = null;if (blog.getId() != null) {temp = blogService.getById(blog.getId());// 只能编辑自己的文章System.out.println(ShiroUtil.getProfile().getId());Assert.isTrue(temp.getUserId().longValue() == ShiroUtil.getProfile().getId().longValue(), "没有权限编辑");} else {temp = new Blog();temp.setUserId(ShiroUtil.getProfile().getId());temp.setCreated(LocalDateTime.now());temp.setStatus(0);}BeanUtil.copyProperties(blog, temp, "id", "userId", "created", "status");blogService.saveOrUpdate(temp);return Result.succ(null);}}

11.2.实体类校验

package com.gblfy.entity;import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import java.time.LocalDateTime;
import java.io.Serializable;import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;import javax.validation.constraints.NotBlank;/*** <p>** </p>** @author gblfy* @since 2020-06-02*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("m_blog")
public class Blog implements Serializable {private static final long serialVersionUID = 1L;@TableId(value = "id", type = IdType.AUTO)private Long id;private Long userId;@NotBlank(message = "标题不能为空")private String title;@NotBlank(message = "摘要不能为空")private String description;@NotBlank(message = "内容不能为空")private String content;@JsonFormat(pattern="yyyy-MM-dd")private LocalDateTime created;private Integer status;}

11.3. 博文接口测试

GET http://localhost:8080/blogs

GET http://localhost:8080/blog/10

POST http://localhost:8080/blog/edit

{"title": "博文标题2222222222222222222",
"description": "博文摘要2222222222222222",
}

从上面测试得出@Validated注解的优先级高于@RequiresAuthentication注解
2.测试请求头中不携带token

{"title": "博文标题2222222222222222222",
"description": "博文摘要2222222222222222",
"content": "博文内容222222222222222222222"
}

3.测试请求头中携带token测试

注：这个Authorization 的值是通过登录接口返回给用户的，简言之，要先访问http://localhost:8080/login接口获取token的值

4.携带token添加博文测试
无id即可

{"title": "博文标题2222222222222222222",
"description": "博文摘要2222222222222222",
"content": "博文内容222222222222222222222"
}

5.携带token编辑博文测试

{"id": 11,
"title": "博文标题55555",
"description": "博文摘要55555",
"content": "博文内容555555"
}

特别注意：Authorization后面不能有空格，token的值要复制全，这个很重要，这个错误不好定位！

12. 后端接口开发总结