springboot篇】十六. springboot整合shiro和swagger2实现前后分离

最新推荐文章于 2022-08-06 20:25:11 发布
最新推荐文章于 2022-08-06 20:25:11 发布
阅读量596 收藏 4
点赞数 1
分类专栏： springboot 文章标签： shiro spring boot swagger 前后分离
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TheNew_One/article/details/104556208
版权

springboot整合shiro和swagger2实现前后分离

中国加油，武汉加油！

篇幅较长，配合右边目录观看

项目准备
  1. 创建springboot项目nz1904-springboot-08-shiro-swagger
  2. 加入Web的SpringWeb依赖和Lombox依赖
  3. 导相关依赖
    <!--使用Druid这个连接池-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.0</version>
</dependency>
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.54</version>
</dependency>
<!--swagger2相关依赖-->
<dependency>
	<groupId>io.springfox</groupId>
	<artifactId>springfox-swagger2</artifactId>
	<version>2.7.0</version>
</dependency>
<dependency>
	<groupId>io.springfox</groupId>
	<artifactId>springfox-swagger-ui</artifactId>
	<version>2.7.0</version>
</dependency>
<!-- spring跟shiro整合依赖-->
<dependency>
	<groupId>org.apache.shiro</groupId>
	<artifactId>shiro-spring</artifactId>
	<version>1.3.2</version>
</dependency>
<!--下面导入数据库的使用的包-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.48</version>
</dependency>

1. 扩展/配置

1.1 定义SwaggerConfig和ShiroConfig

package com.wpj.config;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootConfiguration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createApi(){
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.wpj.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("这里是springboot整合shiro和swagger前后分离的功能文档")
                .description("这里是nz1904-springboot-08-shiro-swagger测试用的")
                .version("v1.0")
                .build();
    }

}

package com.wpj.config;

import org.springframework.boot.SpringBootConfiguration;

@SpringBootConfiguration
public class ShiroConfig {
    // 暂时不注入组件
}

1.2 对原生Token对象进行扩展

package com.wpj.token;

import org.apache.shiro.authc.UsernamePasswordToken;

/**
 * 对原生的token对象进行拓展
 */
public class CustomToken extends UsernamePasswordToken {

    // 这个token是在认证通过之后  用户访问其他资源的时候 来进行你给身份识别的
    private String token;   // 用户身份唯一的标识

    public CustomToken(String token) {
        this.token = token;
    }

    @Override
    public Object getPrincipal() {
        return token;
    }
}

1.3 定义业务异常

package com.wpj.exception;

/**
 * 业务异常
 */
public class BusinessException extends RuntimeException {
    
    private int messageCode;
    
    private String defaultMessage;
    
    public BusinessException(int messageCode, String defaultMessage){
        super(defaultMessage);
        this.messageCode = messageCode;
        this.defaultMessage = defaultMessage;
    }

    public String getDefaultMessage() {
        return defaultMessage;
    }

    public int getMessageCode() {
        return messageCode;
    }
}

1.4 定义常量类

package com.wpj.constant;

public class Constant {

    public static final String REQ_TOKEN = "token";

}

1.5 定义请求返回的类和枚举和接口

package com.wpj.result;

import lombok.Data;

/**
 * 最终响应给前端数据的对象
 */
@Data
public class DataResult <T> {
    private int code;   //返回的码值
    private String msg; //返回的错误信息提示
    private T data;   //返回的数据

    //下面这一块是对构造器进行封装

    public DataResult(int code,T data){
       this.code=code;
       this.data=data;
       this.msg=null;
    }

    public DataResult(int code,String msg,T data){
          this.code=code;
          this.data=data;
          this.msg=msg;
    }

    public DataResult(int code,String msg){
        this.code=code;
        this.msg=msg;
    }

    public DataResult(){
        this.code=BaseResponseCode.SUCCESS.getCode();
        this.msg=BaseResponseCode.SUCCESS.getMsg();
        this.data=null;
    }

    public DataResult(T data){
        this.code=BaseResponseCode.SUCCESS.getCode();
        this.msg=BaseResponseCode.SUCCESS.getMsg();
        this.data=data;
    }

    public DataResult(ResponseCodeInterface responseCodeInterface){
         this.data=null;
         this.code=responseCodeInterface.getCode();
         this.msg=responseCodeInterface.getMsg();
    }

    public DataResult(ResponseCodeInterface responseCodeInterface,T data){
         this.data=data;
         this.code=responseCodeInterface.getCode();
         this.msg=responseCodeInterface.getMsg();
    }

    /**
     * 不带数据的返回
     * @param <T>
     * @return
     */
    public static <T>DataResult success(){
       return new DataResult();
    }

    /**
     * 带数据的返回
     * @param data
     * @param <T>
     * @return
     */
    public static <T>DataResult success(T data){
       return new DataResult(data);
    }

    /**
     * 自己给参数的问题
     * @param code
     * @param msg
     * @param data
     * @param <T>
     * @return
     */
    public static <T>DataResult getResult(int code,String msg,T data){
        return new <T>DataResult(code,msg,data);
    }
    
    /**
     * 自己给参数的问题
     * @param code
     * @param msg
     * @param <T>
     * @return
     */
    public static <T>DataResult getResult(int code,String msg){
        return new <T>DataResult(code,msg);
    }

    /**
     * 直接传递一个枚举进来
     * @param baseResponseCode
     * @param <T>
     * @return
     */
    public static <T>DataResult getResult(BaseResponseCode baseResponseCode){
        return new <T>DataResult(baseResponseCode);
    }
    
    /**
     * 直接传递一个枚举进来
     * @param baseResponseCode
     * @param <T>
     * @return
     */
    public static <T>DataResult getResult(BaseResponseCode baseResponseCode,T data){
        return new <T>DataResult(baseResponseCode,data);
    }
    
}

package com.wpj.result;

public enum BaseResponseCode implements ResponseCodeInterface{
    /**
     * 接下来就要和前端约束好所有的码值以及含义
     */
    SUCCESS(0,"操作成功"),
    SYSTEM_ERROR(5000001,"系统错误"),
    METHOD_INVALIDATE(4000001,"数据校验出错"),
    DATA_ERROR(4000002,"传入数据异常"),
    TOKEN_NOT_NULL(4010001,"用户认证异常");

    //整个构造函数
    BaseResponseCode(int code,String msg){
        this.code=code;
        this.msg=msg;
    }

    private int code;
    private String msg;

    @Override
    public int getCode() {
        return code;
    }

    @Override
    public String getMsg() {
        return msg;
    }
}

package com.wpj.result;

/**
 * 返回码的一个接口
 */
public interface ResponseCodeInterface {
    /**
     * 返回的码的一个获取
     * @return
     */
    int getCode();

    /**
     * 返回消息的获取
     * @return
     */
    String getMsg();
}

1.6 自定义过滤器拦截请求

package com.wpj.filter;

import com.alibaba.fastjson.JSONObject;
import com.wpj.constant.Constant;
import com.wpj.exception.BusinessException;
import com.wpj.token.CustomToken;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authz.AuthorizationException;
import org.apache.shiro.web.filter.AccessControlFilter;
import org.springframework.http.MediaType;
import org.springframework.util.StringUtils;

import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * 对身份进行二次校验的时候就会进来这里
 */
public class CustomAccessControllerFilter extends AccessControlFilter {
    @Override
    protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object o) throws Exception {
        return false;
    }

    @Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        HttpServletRequest request = (HttpServletRequest) servletRequest;

        // 校验身份
        try {
            // 获取token
            String token = request.getHeader(Constant.REQ_TOKEN);
            // 判断token是否为空
            if (StringUtils.isEmpty(token)) {
                // 身份非法
                throw new BusinessException(400001, "用户的请求token不能为空。");
            } else {
                // 封装token交给shiro去认证，查看是否合法
                CustomToken customToken = new CustomToken(token);
                // 用户第一次登陆并不会执行，是在认证成功之后访问其他资源的时候才执行
                // login最终会执行到Realm中的doGetAuthenticationInfo方法里
                getSubject(servletRequest, servletResponse).login(customToken);
            }
        } catch (BusinessException e) {
            // 返回json格式信息通知前端出问题了
            resultResponse(e.getMessageCode(), e.getDefaultMessage(), servletResponse);
        } catch (AuthenticationException e) {
            if(e.getCause() instanceof BusinessException) {
                // 将异常的实例进行转换
                BusinessException err = (BusinessException) e.getCause();
                resultResponse(err.getMessageCode(), err.getDefaultMessage(), servletResponse);
            } else {
                // 执行这里就说明这个异常是shiro返回的
                resultResponse(400001, "用户认证失败", servletResponse);
            }
        } catch (AuthorizationException e) {
            if(e.getCause() instanceof BusinessException) {
                // 将异常的实例进行转换
                BusinessException err = (BusinessException) e.getCause();
                resultResponse(err.getMessageCode(), err.getDefaultMessage(), servletResponse);
            } else {
                // 执行这里就说明这个异常是shiro返回的
                resultResponse(403001, "用户没有访问权限", servletResponse);
            }
        } catch (Exception e) { // 一些未考虑的异常
            if(e.getCause() instanceof BusinessException) {
                // 将异常的实例进行转换
                BusinessException err = (BusinessException) e.getCause();
                resultResponse(err.getMessageCode(), err.getDefaultMessage(), servletResponse);
            } else {
                // 执行这里就说明这个异常是shiro返回的
                resultResponse(500001, "系统出现异常", servletResponse);
            }
        }

        return true;
    }

    /**
     * 通知前端出错的信息
     * @param messageCode
     * @param defaultMessage
     * @param response
     */
    private void resultResponse(int messageCode, String defaultMessage, ServletResponse response) {
        // 构建返回的数据
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("code", messageCode);
        jsonObject.put("msg", defaultMessage);

        // 设置下返回类型
        response.setContentType(MediaType.APPLICATION_JSON_UTF8.toString());
        // 获取输出流
        try {
            ServletOutputStream out = response.getOutputStream();
            out.write(jsonObject.toJSONString().getBytes());
            out.flush();
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1.7 自定义HashedCredentialsMatcher认证

package com.wpj.filter;

import com.wpj.exception.BusinessException;
import com.wpj.service.IUserService;
import com.wpj.token.CustomToken;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.springframework.beans.factory.annotation.Autowired;

public class CustomHashedCredentialsMatcher extends HashedCredentialsMatcher {

    @Autowired
    private IUserService userService;

    /**
     * 下面这个方法 返回true 或者 false就决定了 这个是成功呢还是失败
     * @param token
     * @param info
     * @return
     */
    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
        //  把前面传递过来的token取出来  再把存储到服务器的token取出来做比较
        // 如果一致那么就返回true  否则就返回  false
        CustomToken token1= (CustomToken) token;
        // 取出 Principal的值 (下面这个值 就是从前端传递过来进行比较的)
        String tokenVal= (String) token1.getPrincipal();
        // 从redis  或者  数据库    或者 session取出这个信息来
        boolean flag=false;
        try{
            flag = userService.tokenExistsOrNot(tokenVal);
        }catch (Exception err){
            throw new BusinessException(500001,"查询token存在失败"+err.getMessage());
        }
        //进行比较 判定前端的token和服务端的token是否一致  如果一致  那么返回true  否则返回false
        if(!flag){
            throw new BusinessException(4010000,"授权信息无效请重新登录");
        }
        return true;
    }
}

1.8 自定义Realm

package com.wpj.realm;

import com.wpj.token.CustomToken;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

public class CustomRealm extends AuthorizingRealm {
    /**
     * 授权的方法
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        return simpleAuthorizationInfo;
    }

    /**
     * 认证的方法
     * 将前端放进去的token 取出来 放到校验的SimpleAuthenticationInfo中去 方便后面进行校验
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //取出前端传递过来的token
        CustomToken customToken= (CustomToken) authenticationToken;
        String token = (String) customToken.getPrincipal();

        //在这里要将前端传递过来的token给封装到 SimpleAuthenticationInfo 对象中去
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(token,token,getName());
        return simpleAuthenticationInfo;
    }
}

1.9 ShiroConfig注入组件

package com.wpj.config;

import com.wpj.filter.CustomAccessControllerFilter;
import com.wpj.filter.CustomHashedCredentialsMatcher;
import com.wpj.realm.CustomRealm;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;

import javax.servlet.Filter;
import java.util.LinkedHashMap;
import java.util.Map;

@SpringBootConfiguration
public class ShiroConfig {
    /**
     * 项目认证(请求资源的时候 身份的认证)的realm
     * @return
     */
    @Bean
    public CustomRealm customRealm(){
        CustomRealm customRealm = new CustomRealm();
        customRealm.setCredentialsMatcher(customHashedCredentialsMatcher());
        return customRealm;
    }

    /**
     * 凭证匹配器的申明
     * @return
     */
    @Bean
    public CustomHashedCredentialsMatcher customHashedCredentialsMatcher(){
        return new CustomHashedCredentialsMatcher();
    }

    /**
     * 安全管理器
     * @return
     */
    @Bean
    public DefaultWebSecurityManager securityManager(){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(customRealm());
        return securityManager;
    }

    /**
     * 配置的是目标过滤器的代理
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //配置安全管理器
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        //接下来配置些过滤器
        //配置自己的那个过滤器
        Map<String, Filter> map = new LinkedHashMap<>();
        map.put("token",new CustomAccessControllerFilter());
        shiroFilterFactoryBean.setFilters(map);

        //对请求过滤和拦截的设置
        Map<String,String> reqMap=new LinkedHashMap<>();
        //放入不拦截的页面  拦截的页面....
        reqMap.put("/user/login","anon");
        //Swagger的所有请求的资源和请求的地址都不需要拦截
        reqMap.put("/swagger/**","anon");
        reqMap.put("/v2/api-docs","anon");
        reqMap.put("/swagger-ui.html","anon");
        reqMap.put("/swagger-resources/**","anon");
        reqMap.put("/webjars/**","anon");
        reqMap.put("/favicon.ico","anon");
        reqMap.put("/captcha.jpg","anon");
        reqMap.put("/csrf","anon");
        //设置我们自己的校验
        reqMap.put("/**","token,authc");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(reqMap);
        return shiroFilterFactoryBean;
    }

    /**
     * 开启aop的注解的支持
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultSecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor attributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        attributeSourceAdvisor.setSecurityManager(securityManager);
        return attributeSourceAdvisor;
    }
    @Bean
    @ConditionalOnMissingBean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }
}

2. 实例/业务

2.1 定义User类

在这里插入图片描述

package com.wpj.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
	// 在User类名上alt+/ 自己生成
    private static final long serialVersionUID = 8434196542261610760L;
    
    private Integer id;
    private String name;
    private String pwd;
	private String token;
    private Date expireDate;  //token的过期时间
}

2.2 定义vo（暂时用不着）

package com.wpj.vo;

import com.wpj.pojo.User;

/**
 * 横向扩展
 */
public class CustomUser extends User {
}

package com.wpj.vo;

/**
 * 纵向扩展
 */
public class UserVo {

    private CustomUser customUser;

}

2.3 定义mapper及其xml文件

package com.wpj.mapper;

import com.wpj.pojo.User;

import java.util.List;

/**
 * 用户的DAO接口
 */
public interface IUserMapper {
    /**
     * 通过名字找到用户
     * @param userName
     * @return
     */
    User findUserByName(String userName);

    /**
     * 更新token到数据库
     * @param user
     */
    void updateToken(User user);

    /**
     * 查询所有的用户
     * @return
     */
    List<User> findUserList();
    /**
     * 查看当前的token是否在数据库中存在
     * @param token
     * @return
     */
    User findUserByToken(String token);
}

<?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.wpj.mapper.IUserMapper">

    <!--通过用户名找用户-->
    <select id="findUserByName" parameterType="string" resultType="user">
        select * from user where name=#{value}
    </select>

    <!--更新数据库用户的token-->
    <update id="updateToken" parameterType="user">
        update user set token=#{token} where id=#{id}
    </update>

    <!--查找所有的用户-->
    <select id="findUserList" resultType="user">
        select * from user
    </select>

    <!--查看token是否存在-->
    <select id="findUserByToken" parameterType="String" resultType="user">
        select * from user where token=#{value}
    </select>

</mapper>

2.4 application配置

mybatis.type-aliases-package=com.wpj.pojo
mybatis.mapper-locations=classpath:mapper/*.xml

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql:///nz1904-shiro-swagger
spring.datasource.username=root
spring.datasource.password=123456

2.5 定义IUserService及其实现类

package com.wpj.service;

import com.wpj.pojo.User;

import java.util.List;

public interface IUserService {
    /**
     * 登陆
     * @param user
     * @return
     */
    User login(User user);

    /**
     * 通过名字找到用户
     * @param userName
     * @return
     */
    User findUserByName(String userName);

    /**
     * 更新token到数据库
     * @param user
     */
    void updateToken(User user);

    /**
     * 查询所有的用户
     * @return
     */
    List<User> findUserList()throws Exception;

    /**
     * 判定这个token是否存在
     * @param token
     * @return
     */
    boolean tokenExistsOrNot(String token);
}

package com.wpj.service.impl;

import com.wpj.exception.BusinessException;
import com.wpj.mapper.IUserMapper;
import com.wpj.pojo.User;
import com.wpj.result.DataResult;
import com.wpj.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;
import java.util.UUID;

@Service
@Transactional
public class UserServiceImpl implements IUserService {

    @Autowired
    private IUserMapper iUserMapper;

    @Override
    public User login(User user){
        //这个类里面应该干什么?
        /**第一步：获取到前端传递过来的用户名
         *第二步：通过用户名 获取用户对象
         * 第三步：校验
         * 第四步：生成token保存到数据库
         * 第五步：将token封装到返回数据里面给前端
         */
        //获取用户名
        String userName = user.getUserName();
        //通过用户名 找用户名找对象
        User userResult = findUserByName(userName);
        //第三步：校验
        if(null==userResult){  //说明用户名不对
            throw new BusinessException(40001,"用户名不对");
        }
        //说明：用户名是对的
        //比较密码
        if(!(userResult.getPassword().equals(user.getPassword()))){
            throw new BusinessException(40002,"密码不对");
        }
        //执行到这里说明用户身份合法的
        //先将数据保存到一个类里面
        //首先要生成token这个值
        String token= UUID.randomUUID().toString();
        Date date=new Date();
        //设置这个值给user对象
        userResult.setToken(token);
        userResult.setExpireDate(date);
        //下面就是更新这个数据库的数据
        updateToken(userResult);
        //将这个信息返回给前端
        //一般情况下 密码是不需要返回的
        userResult.setPassword("");
        //设置返回数据的对象
        //DataResult<User> userDataResult = new DataResult<>(0,"认证成功",userResult);
        return userResult;
    }

    @Override
    public User findUserByName(String userName) {
        return iUserMapper.findUserByName(userName);
    }

    @Override
    public void updateToken(User user) {
        iUserMapper.updateToken(user);
    }

    @Override
    public List<User> findUserList() throws Exception{
        List<User> userList = iUserMapper.findUserList();
        //接下来对数据进行封装
        DataResult<List<User>> dataResult = new DataResult<>(0, "请求完美", userList);
        return userList;
    }

    @Override
    public boolean tokenExistsOrNot(String token) {
        //通过token查询用户信息
        User userResult = iUserMapper.findUserByToken(token);
        //接下来就要判断了
        if(null!=userResult){
            return true;
        }
        return false;
    }

}

2.5 定义Controller

package com.wpj.controller;

import com.wpj.exception.BusinessException;
import com.wpj.pojo.User;
import com.wpj.result.BaseResponseCode;
import com.wpj.result.DataResult;
import com.wpj.service.IUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@Api(tags = {"用户接口"})
public class UserController {

    @Autowired
    private IUserService userService;

    private Logger logger= LoggerFactory.getLogger(UserController.class);

    /**
     * 登陆的接口
     * @param user
     * @return
     */
    @RequestMapping(value = "/user/login",method = RequestMethod.POST)
    @ApiOperation(value = "用户登陆的接口")
    public DataResult<User> login(@RequestBody User user){
        //这个里面应该干什么?
        /**
         * 说白了 调用业务逻辑层的方法
         *  异常的捕获
         *  返回数据
         */
        DataResult<User> dataResult=null;
        try {
            User user1 = userService.login(user);
            dataResult=DataResult.success(user1);
        } catch (Exception e) {
            if(e instanceof BusinessException){  //说明是业务异常
                BusinessException err= (BusinessException) e;
                //应该干什么?
                dataResult=new DataResult<>(err.getMessageCode(),err.getDefaultMessage());
            }else{
                //dataResult=new DataResult<>(500001,"系统异常造成登陆失败");
                dataResult=DataResult.getResult(BaseResponseCode.SYSTEM_ERROR.getCode(),BaseResponseCode.SYSTEM_ERROR.getMsg());
            }
            return dataResult;
        }
        return dataResult;
    }

    /**
     * 查找所有的用户数据
     * @return
     */
    @RequestMapping(value = "/user/list",method = RequestMethod.GET)
    @ApiOperation(value = "获取所有的用户信息")
    @ApiImplicitParam(paramType = "header",name = "token",value = "用户token",required = true,dataType = "String")
    public DataResult<List<User>> findUserList(){
        //定义返回数据
        DataResult<List<User>> userLists;
        try{
            //返回用户数据
            List<User> users = userService.findUserList();
            userLists=DataResult.success(users);
            logger.info("获取数据成功....");
        }catch (Exception err){
            //说明获取信息失败了
            logger.error("获取用户信息失败:"+err.fillInStackTrace());
            userLists=DataResult.getResult(BaseResponseCode.SYSTEM_ERROR.getCode(),BaseResponseCode.SYSTEM_ERROR.getMsg());
        }
        return userLists;
    }
}

2.6 定义全局配置类

/**
 * 全局的配置文件
 */
@SpringBootConfiguration
@ComponentScan(basePackages = {"com.wpj"})
@MapperScan(basePackages = {"com.wpj.mapper"})
public class AppConfig {

}

2.7 启动主启动类访问localhost:8080/swagger-ui.html

杰KaMi
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合Shiro和Swagger
XXuan_的博客
03-15 772
Shiro是一款十分好用的权限管理框架 可以和SpringBoot整合实现页面的权限控制 首先导入pom依赖 <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring --> <dependency> <groupId>org.apache....
SpringBoot + Shiro实现前后端全分离接口安全框架
09-02
SpringBoot-Shiro前后端分离框架,通过shiro控制权限，实现前后端全分离接口安全。
springboot+shiro+swagger2前后端分离整合
03-03
springboot+shiro+swagger2前后端分离整合： https://blog.csdn.net/wmlwml0000/article/details/104631552
swagger --＞ springboot+shiro整合swagger
weixin_40571937的博客
09-02 1158
1. 添加swagger依赖： <!--swagger2--> <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 --> <dependency> <groupId>io.springfox</groupId> <artifactId>springf
Springboot整合shiro安全框架+swagger
BUG专业户
08-06 1427
springboot+swagger+shiro
以后直接拿着用：SpringBoot+shiro+Swagger实现前后分离的框架
yuemmm的博客
03-04 481
文章目录1、导包2、封装token3、编写过滤器4、编写凭证匹配器5、编写realm6、编写Swagger的配置文件7、编写shiro的配置文件8、编写项目的配置文件9、结果集的封装9.1、接口的封装9.2、返回信息码值和提示信息的封装9.3、返回数据的封装10、controller的编写11、Service的编写11.1、Service接口的编写11.2、Service实现的编写12、Mappe...
Springboot+Vue前后的分离整合项目实战
09-09
适用人群Java开发人员，Vue开发人员，前后端分离开发人员，权限管理和配置开发人员课程概述【讲师介绍】讲师职称：              现某知名大型互联网公司资深架构师，技术总监，职业规划师，首席面试官，曾在某上市培训机构，高校任教多年。            Array（Array老师）10多年互联网公司实战经验，知名的大型互联网公司的架构师，高管等职，在企业长期从事于技术的源码阅读和新技术的研究；擅长于职业规划，面试辅导，从事面试官多年；擅长于JAVA,人工智能AI应用,Xmind等等，曾服役于国内某上市培训机构数年，独特的培训思路，培训体系，培训方式，实践的职场技能，职场现状，职场晋升等让你快速适应企业职场的所需。 【课程介绍】技术选型开发环境：Eclipse/Idea ，JDK 1.8以上 后端技术核心框架：SpringBoot2.x框架系列（同样适用Springcloud F版本以后的版本），如下（节选）：    持久层框架：MyBatis 3.x + Mybatis-plus 3.x日志管理：SLF4J 1.7 + Log4j2 2.7工具类：Apache Commons、Jackson 、fastjson、Gson权限验证前端技术  Vue  Vue-cliElementUI ---https://element.eleme.io/JSX （JavaScript Xml）前台的权限验证和路由设置开发模式       前后端分离的开发数据库       Mysql5IDE    Intellij Idea
springboot_learn：整合了MyBatis，Shiro，Thymeleaf，Swagger2，Redis，Spring Data JPA等框架的Spring Boot，欢迎Star和Fork
02-03
《Spring Boot深度实践：整合MyBatis、Shiro、Thymeleaf、Swagger2、Redis与Spring Data JPA》 Spring Boot，作为Spring生态的重要组成部分，以其简洁的配置和快速的开发能力，深受广大开发者喜爱。本项目...
DataBaseTest:四郎2.fastdfs 3.mybatis 4.swagger
05-10
【标题】"DataBaseTest:四郎2.fastdfs 3.mybatis 4.swagger" 涵盖了四个关键的IT技术领域，分别是权限管理、分布式文件系统、持久化框架和API文档生成工具。接下来，我们将深入探讨这些知识点。 1. **Shiro权限管理...
基于springboot的火车票订票系统源码数据库.zip
最新发布
03-13
接下来，我们将深入探讨该项目的核心技术和实现细节。 一、SpringBoot基础 SpringBoot是Spring生态系统的组成部分，它通过预配置的 Starter POMs 和自动配置功能，简化了Spring应用的创建和管理。在本项目中，...
基于SpringBoot+Vue的外卖网上点餐系统源码+项目说明.zip
01-08
项目的架构是SpringBoot和Vue的前后端分离，数据库为MySQL+Redis，MyBatis、Swagger接口文档、Shiro安全框架，3个客户端分别对应3个角色具有不同操作权限， 使用了主流的 **七牛云图片文件服务器** /本地存储两种...
springboot+shiro+swagger2自动生成接口文档
╃緣分天空╃
03-21 750
swagger2很简单，没有什么说的内容，主要就是注意下各种除了get post 请求外其他请求的注解方式 例如PUT方式的 @RequestBody 主要说shiro过滤问题,如果shiro config配置出问题，将导致swagger-ui无法正常显示和测试。 最近刚发现 ShiroFilterFactoryBean 添加过滤链的时候没有使用LInkedHashMap而...
解决springboot+swagger+shiro后过滤器执行顺序的问题
weixin_38405770的博客
12-17 1144
1、首先说问题吧，springboot整合swagger+shiro在访问http://localhost:8080/swagger-ui.html时被拦截了，但是配置的拦截链是放行的，好像没有起作用，拦截器配置代码如下 @Bean(name = "shiroFilter") public ShiroFilterFactoryBean shiroFilter(@Qualifier("securityManager") SecurityManager securityManager, ..
springboot项目集成swagger，并让shiro放行
龙ygl龙的博客
05-20 4642
其实写接口文档的工具有很多。比如wiki，confluence（这个用的也挺多的。安装步骤可以参见我这篇博客https://blog.csdn.net/qq_29281307/article/details/89345052） 但是总结下来，还是觉得swaggerui比较好用，不仅可以在编程过程中就生成api文档，而且还可以通过swagger调试接口，这对于后台开发人员来说真是太方便了。避免再去...
Shiro的使用（六）—SpringBoot整合shiro和Swagger2实现前后端分离
孔明的博客
03-03 1175
通过扩展AccessControlFilter，HashedCredentialsMatcher完成了自定义身份校验器，访问控制过滤器等核心技术。 使用了全局业务异常，处理项目中可能出现的异常信息，并使用了枚举定义输出信息。 封装了通用的返回结果集，可在实际开发项目中，直接进行使用。
springboot集成swagger2（shiro配置）
大神，带带我的博客
08-08 2706
  1.maven配置 &lt;dependency&gt;     &lt;groupId&gt;io.springfox&lt;/groupId&gt;     &lt;artifactId&gt;springfox-swagger2&lt;/artifactId&gt;     &lt;version&gt;2.9.2&lt;/version&gt; &l
SpringBoot集成swagger2，及shiro配置免认证
ko8be24的博客
10-11 1610
1.引入maven依赖，本文采用2.9.2版本 maven仓库地址：https://mvnrepository.com（根据情况选择自己的版本） <!-- swagger2 --> <dependency> <groupId>io.springfox</groupId> <artifactId>springfo...
spring boot 集成shiro,swagger 加入拦截器后 swagger 不能访问
热门推荐
Radom&7
05-29 1万+
在shiro的配置文件中放行swagger： filterMap.put("/swagger-ui.html", "anon"); filterMap.put("/swagger-resources", "anon"); filterMap.put("/v2/api-docs", "anon"); filterMap.p
springboot整合shiro前后端分离
03-16
Spring Boot整合Shiro可以实现前后端分离的安全认证和授权功能。前端通过Ajax请求后端接口，后端接口通过Shiro进行安全认证和授权，返回相应的结果给前端。 具体实现步骤如下： 1. 引入Shiro和Spring Boot相关依赖...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值