（三）SpringBoot+dubbo+Spring Sercurity+VUE实例----（后端）

女爷i 2023-07-01 05:22 48阅读 0赞

下面写个简单的token单一点登录系统来验证下。当访问系统未登录时，跳转到登录页，登录后进入首页，左侧导航栏展示默认菜单（首页）和有权限的菜单。

一、写在前面：关于session和token的使用，网上争议一直很大。总的来说争议在这里：

（1）session是空间换时间，而token是时间换空间。session占用空间，但是可以管理过期时间，token管理部了过期时间，但是不占用空间.  
（2）sessionId失效问题和token内包含。  
（3）session基于cookie，app请求并没有cookie 。  
（4）token更加安全(每次请求都需要带上)。

二、效果：

前端：vue；

后端：springboot+dubbo+mybatis+spring sercurity+JWT+ token单一点登录。

效果：

分别启动前后端服务，访问首页[http://localhost:9528/\#/][http_localhost_9528]index，由于未登录，跳转到登录页

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70][]

登录后跳转到首页，[http://localhost:9528/\#/dashboard][http_localhost_9528_dashboard]

![20200221105822288.png][]

左侧菜单栏展开，显示所有的权限：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 1][]此时在postman调用一次登录接口，再次回到浏览器刷新或者调用接口（如点击用户管理页），跳转到登录页面。证明单一点登录实现。

三、数据库：

1、t\_user:

![20200221111134999.png][]

2、t\_role:

![20200221111216420.png][]

3、t\_authority:

![202002211112483.png][]

4、t\_user\_role：

![20200221111316744.png][]

5、t\_role\_authoriy：

![20200221111340663.png][]

四、后端代码：

![20200221111440254.png][]

*  api:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 2][]

1、pom:

2、dto：

public class AuthorityDTO implements Serializable {
    
        private Integer id;
    
        private String authorityName;
    
        private String authorityCode;
    }

public class RoleDTO implements Serializable {
    
        private Integer id;
    
        private String roleCode;
    
        private String roleName;
    }

public class UserDTO implements Serializable {
    
        private Integer id;
    
        private String userName;
    
        private String password;
    
        private String userNickName;
    
        //验证码
        private String code;
    
        private List<RoleDTO> roles;
    }

*  service:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 3][]

1、pom:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.demo</groupId>
      <artifactId>mysercurity-service</artifactId>
      <version>0.0.1-SNAPSHOT</version>
    
      
      <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.1.RELEASE</version>
      </parent>
      <dependencies>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <dependency>
          <groupId>com.demo</groupId>
          <artifactId>mysercurity-api</artifactId>
          <version>1.0.0-SNAPSHOT</version>
        </dependency>
    
        
        <dependency>
          <groupId>org.mybatis.spring.boot</groupId>
          <artifactId>mybatis-spring-boot-starter</artifactId>
          <version>1.1.1</version>
        </dependency>
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.21</version>
        </dependency>
    
    
        
        <dependency>
          <groupId>com.alibaba.spring.boot</groupId>
          <artifactId>dubbo-spring-boot-starter</artifactId>
          <version>2.0.0</version>
        </dependency>
    
        <dependency>
          <groupId>commons-collections</groupId>
          <artifactId>commons-collections</artifactId>
          <version>3.2.1</version>
        </dependency>
        <dependency>
          <groupId>commons-lang</groupId>
          <artifactId>commons-lang</artifactId>
          <version>2.5</version>
        </dependency>
    
        
            <dependency>
                <groupId>com.github.sgroschupf</groupId>
                <artifactId>zkclient</artifactId>
                <version>0.1</version>
                <exclusions>
                    <exclusion>
                        <artifactId>log4j</artifactId>
                        <groupId>log4j</groupId>
                    </exclusion>
                    <exclusion>
                        <artifactId>slf4j-log4j12</artifactId>
                        <groupId>org.slf4j</groupId>
                    </exclusion>
                </exclusions>
            </dependency>
    
      </dependencies>
    
    </project>

2、application.properties:

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf-8&useSSL=false
    spring.datasource.username=root
    spring.datasource.password=wtyy
    
    mybatis.mapper-locations=classpath*:Mapper/*Mapper.xml
    
    server.port=9998

3、provider.xml：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://code.alibabatech.com/schema/dubbo
         http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
        <dubbo:application name="mysercurity-service"/>
        <dubbo:provider timeout="3000" retries="0"/>
        
        <dubbo:registry protocol="zookeeper" address="192.168.57.xxx:2181,192.168.57.xx:2181,192.168.59.xxx:2181"
                        register="false"   check="false"/>
        <dubbo:protocol name="dubbo" port="20881"/>
    
        <dubbo:service interface="com.demo.service.UserService" ref="userService"></dubbo:service>
        <dubbo:service interface="com.demo.service.RoleService" ref="roleService"></dubbo:service>
    </beans>

4、serviceImpl:

package com.demo.service.impl;
    import com.demo.dao.UserRoleDao;
    import com.demo.dto.RoleDTO;
    import com.demo.service.RoleService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import java.util.List;
    
    @Service("roleService")
    public class RoleServiceImpl implements RoleService {
    
        @Autowired
        private UserRoleDao userRoleDao;
    
        @Override
        public List<RoleDTO> findRoleByUserId(Integer id) {
            return userRoleDao.findRoleByUserId(id);
        }
    }

package com.demo.service.impl;
    import com.demo.dao.AuthorityDao;
    import com.demo.dao.UserDao;
    import com.demo.dao.UserRoleDao;
    import com.demo.dto.AuthorityDTO;
    import com.demo.dto.RoleDTO;
    import com.demo.dto.UserDTO;
    import com.demo.exception.UsernameNotFoundException;
    import com.demo.service.RoleService;
    import com.demo.service.UserService;
    import org.apache.commons.collections.CollectionUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.stream.Collectors;
    
    @Service("userService")
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserDao userDao;
    
        @Autowired
        private UserRoleDao userRoleDao;
    
        @Autowired
        private AuthorityDao authorityDao;
    
        @Autowired
        private RoleService roleService;
    
        @Override
        public UserDTO findByUserName(String username) {
    
            UserDTO user = userDao.findByUserName(username);
            if(user == null){
                throw new UsernameNotFoundException("用户不存在");
            }
            List<RoleDTO> roles = roleService.findRoleByUserId(user.getId());
            user.setRoles(roles);
            return user;
        }
    
        @Override
        public List<UserDTO> getAllUsers() {
            return userDao.getAllUsers();
        }
    
        @Override
        public List<AuthorityDTO> getAuthortiesByUserId(Integer userId) {
            List<RoleDTO> roles = userRoleDao.findRoleByUserId(userId);
            if(CollectionUtils.isNotEmpty(roles)){
                List<Integer> roleIds = roles.stream().map(RoleDTO::getId).collect(Collectors.toList());
                return authorityDao.getAuthortiesByRoleIds(roleIds);
            }
            return new ArrayList<>();
        }
    
    }

5、dao:

public interface AuthorityDao {
        List<AuthorityDTO> getAuthortiesByRoleIds(@Param("roleIds") List<Integer> roleIds);
    }

<?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.demo.dao.AuthorityDao">
        <select id="getAuthortiesByRoleIds" resultType="com.demo.dto.AuthorityDTO">
            select
            a.id id,
            a.authority_code authorityCode,
            a.authority_name authorityName
            from t_role_authoriy ra left join t_authority a on ra.authority_id = a.id
            where ra.role_id in
            <foreach collection="roleIds" item="item" open="(" close=")" separator=",">
              #{item}
            </foreach>
            and ra.is_delete = 0
        </select>
    </mapper>

public interface UserDao {
        public UserDTO findByUserName(@Param("userName") String userAccount);
        List<UserDTO> getAllUsers();
    }

<?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.demo.dao.UserDao">
        <select id="findByUserName" resultType="com.demo.dto.UserDTO">
            select
            id,
            user_nick_name  userNickName,
            user_name userName,
            user_nick_name userNickName,
            user_password password
            from t_user where user_name = #{userName}
            and is_delete = 0
        </select>
    
        <select id="getAllUsers" resultType="com.demo.dto.UserDTO">
             select
            id,
            user_nick_name  userNickName,
            user_name userName,
            user_nick_name userNickName
            from t_user
        </select>
    </mapper>

public interface UserRoleDao {
        List<RoleDTO> findRoleByUserId(@Param("userId") Integer userId);
    }

6、启动类：

package com.demo;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.ImportResource;
    
    @SpringBootApplication
    @MapperScan("com.demo.dao")
    @ImportResource("classpath:provider.xml")
    public class ServiceStart {
        public static void main(String args[]){
            SpringApplication.run(ServiceStart.class,args);
        }
    }

*  rest:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 4][]

1、pom:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.demo</groupId>
      <artifactId>mysercurity-rest</artifactId>
      <version>0.0.1-SNAPSHOT</version>
    
      <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.1.RELEASE</version>
      </parent>
      <dependencies>
    
        
        <dependency>
          <groupId>com.demo</groupId>
          <artifactId>mysercurity-api</artifactId>
          <version>1.0.0-SNAPSHOT</version>
        </dependency>
    
        
        <dependency>
          <groupId>com.alibaba.spring.boot</groupId>
          <artifactId>dubbo-spring-boot-starter</artifactId>
          <version>2.0.0</version>
        </dependency>
    
    
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
    
    
    
        <dependency>
          <groupId>io.jsonwebtoken</groupId>
          <artifactId>jjwt</artifactId>
          <version>0.9.0</version>
        </dependency>
    
        
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
    
        <dependency>
          <groupId>org.springframework.session</groupId>
          <artifactId>spring-session-data-redis</artifactId>
        </dependency>
    
        <dependency>
          <groupId>redis.clients</groupId>
          <artifactId>jedis</artifactId>
        </dependency>
        
        <dependency>
          <groupId>org.apache.httpcomponents</groupId>
          <artifactId>httpclient</artifactId>
          <version>4.5.6</version>
        </dependency>
    
        <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>1.2.31</version>
        </dependency>
    
        <dependency>
          <groupId>commons-collections</groupId>
          <artifactId>commons-collections</artifactId>
          <version>3.2.1</version>
        </dependency>
        <dependency>
          <groupId>commons-lang</groupId>
          <artifactId>commons-lang</artifactId>
          <version>2.5</version>
        </dependency>
    
    
       
        <dependency>
          <groupId>com.github.sgroschupf</groupId>
          <artifactId>zkclient</artifactId>
          <version>0.1</version>
          <exclusions>
            <exclusion>
              <artifactId>log4j</artifactId>
              <groupId>log4j</groupId>
            </exclusion>
            <exclusion>
              <artifactId>slf4j-log4j12</artifactId>
              <groupId>org.slf4j</groupId>
            </exclusion>
          </exclusions>
        </dependency>
    
      </dependencies>
    </project>

2、配置文件：

（1）application.properties:

server.port=9999
    server.context-path=/demo
    spring.redis.host=localhost
    spring.redis.port=6379
    #spring.redis.password=
    spring.redis.database=1
    spring.redis.pool.max-active=8
    spring.redis.pool.max-wait=-1
    spring.redis.pool.max-idle=500
    spring.redis.pool.min-idle=0
    spring.redis.timeout=0

(2) consumer.xml:

<?xml version="1.0" encoding="UTF-8"?>
    <beans
            xmlns="http://www.springframework.org/schema/beans"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:dubbo="http://code.alibabatech.com/schema/dubbo" xsi:schemaLocation="http://www.springframework.org/schema/beans            http://www.springframework.org/schema/beans/spring-beans-3.1.xsd            http://code.alibabatech.com/schema/dubbo            http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
        <dubbo:application name="mysercurity-test" />
        <dubbo:consumer timeout="3000" retries="0" check="false"/>
        <dubbo:registry protocol="zookeeper" address="192.168.57.xxx:2181,192.168.57.xx:2181,192.168.59.xxx:2181" register="true"  timeout="100000"/>
    
        
        <dubbo:reference interface="com.demo.service.UserService" id="userService"
                         url="dubbo://127.0.0.1:20881"/>
        <dubbo:reference interface="com.demo.service.RoleService" id="roleService"
                         url="dubbo://127.0.0.1:20881"/>
    </beans>

3、config:

package com.demo.config;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.CorsRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
    
    @Configuration
    public class WebMvcConfig extends WebMvcConfigurerAdapter {
    
        @Override
        public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/**").allowedHeaders("*")
                    .allowedMethods("*")
                    .allowedOrigins("*")
                    .allowCredentials(true);
        }
    }

4、常量：

（1）CommonEnums：

package com.demo.constants;
    
    public enum CommonEnums {
    
        CODE_200(200,"请求成功"),
        CODE_300(300,"登录成功"),
        CODE_301(301,"登录失败"),
        CODE_302(302,"退出成功"),
        CODE_303(303,"退出失败"),
        CODE_304(304,"用户或密码错误"),
        CODE_305(305,"账户已被锁定"),
        CODE_401(401,"授权失败"),
        CODE_400(400,"业务异常"),
        CODE_402(402,"非法请求"),
        CODE_403(403,"验证码错误"),
        CODE_405(405,"验证码无效"),
        CODE_500(500,"系统异常"),
    
        ;
        public final int code;
    
        public final String message;
    
        CommonEnums(int code, String message ) {
            this.code = code;
            this.message = message;
        }
    
        public int getCode() {
            return this.code;
        }
    
        public String getMessage() {
            return message;
        }
    
        public static String getEnumToValue(int code){
            for (CommonEnums statusEnum: CommonEnums.values()) {
                if (statusEnum.code == code){
                    return statusEnum.message;
                }
            }
            return "";
        }
    }

（2）Constants :

package com.demo.constants;
    public class Constants {
    
        public static final long EXPIRATIONTIME = (long)1000 * 60 * 60 * 24 * 1; //1 days
        public static final String SECRET = "spring-security-jwt";
        public static final String HEADER_STRING = "token";
        public static final String TOKEN_PREFIX = "Bearer";
        public static final String TOKEN_JWT="token_jwt:";
        public static final String JWT_USER="jwt_user:";
        public static final String LOCK="lock:";
        public static final String ERROR_NUM="error_num:";
    }

5、dto:

(1)JWTUserDTO:

package com.demo.dto;
    
    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.core.userdetails.UserDetails;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.List;
    
    /**
     * 登录用户
     */
    public class JWTUserDTO  implements UserDetails {
    
        private Integer id;
        private String userName;
        private String password;
        private String userNickName;
        private List<RoleDTO> roles = new ArrayList<>();
        private Collection<? extends GrantedAuthority> authorities;
    
        public JWTUserDTO(){
    
        }
    
        public JWTUserDTO(Integer id, String userName, String password, String userNickName,
                       Collection<? extends GrantedAuthority> authorities, List<RoleDTO> roles){
            this.id = id;
            this.userName = userName;
            this.userNickName = userNickName;
            this.password = password;
            this.authorities = authorities;
            this.roles = roles;
        }
    
        @Override
        public String getUsername() {
            return userName;
        }
    
        @Override
        public boolean isAccountNonExpired() {
            return false;
        }
    
        @Override
        public boolean isAccountNonLocked() {
            return false;
        }
    
        @Override
        public boolean isCredentialsNonExpired() {
            return false;
        }
    
        @Override
        public boolean isEnabled() {
            return false;
        }
    
        public void setUsername(String username) {
            this.userName = username;
        }
    
        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
            return authorities;
        }
    
        @Override
        public String getPassword() {
            return password;
        }
    
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public void setAuthorities(Collection<? extends GrantedAuthority> authorities) {
            this.authorities = authorities;
        }
    
        public List<RoleDTO> getRoles() {
            return roles;
        }
    
        public void setRoles(List<RoleDTO> roles) {
            this.roles = roles;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public String getUserNickName() {
            return userNickName;
        }
    
        public void setUserNickName(String userNickName) {
            this.userNickName = userNickName;
        }
    }

(2)ResponseMessage:

package com.demo.dto;
    
    import com.demo.constants.CommonEnums;
    
    public class ResponseMessage {
    
        private int code;
    
        private String status;
    
        private String message;
    
        private String errorMessage;
    
        private String errorExceptionMessage;
    
        private Object data;
    
        public ResponseMessage(int code,String status,Object data){
            this.code = code;
            this.status = status;
            this.data = data;
        }
    
        public ResponseMessage(int code,String status,String message){
            this.code = code;
            this.status = status;
            this.message = message;
        }
    
        public ResponseMessage(int code,String status,String message,Object data){
            this.code = code;
            this.status = status;
            this.message = message;
            this.data = data;
        }
    
    
    
    
        public ResponseMessage(int code,String status,String message,String errorMessage){
            this.code = code;
            this.status = status;
            this.message = message;
            this.errorMessage = errorMessage;
        }
    
        public ResponseMessage(int code,String status,String message,String errorMessage,String errorExceptionMessage){
            this.code = code;
            this.status = status;
            this.message = message;
            this.errorMessage = errorMessage;
            this.errorExceptionMessage = errorExceptionMessage;
        }
    
    
        public static ResponseMessage  success(String message){
            return new ResponseMessage(CommonEnums.CODE_200.code,"success",message);
        }
        public static ResponseMessage  success(Object data){
            return new ResponseMessage(CommonEnums.CODE_200.code,"success",data);
        }
    
    
        public static ResponseMessage  success(String message,Object data){
            return new ResponseMessage(CommonEnums.CODE_200.code,"success",message,data);
        }
    
        public static ResponseMessage  success(int code,String message,Object data){
            return new ResponseMessage(code,"success",message,data);
        }
    
        public static ResponseMessage  success(){
            return new ResponseMessage(CommonEnums.CODE_200.code,null,CommonEnums.CODE_200.message);
        }
    
        public static  ResponseMessage success(int code,Object data){
            return new ResponseMessage(code,"success",data);
        }
    
    
        public static ResponseMessage success(int code,String message){
            return new ResponseMessage(code,"success",message);
        }
    
        public static  ResponseMessage error(int code,String message){
            return new ResponseMessage(code,"error",message);
        }
    
        public static  ResponseMessage error(int code,String message,String errorMessage){
            return new ResponseMessage(code,"error",message,errorMessage);
        }
    
        public static  ResponseMessage error(int code,String message,String errorMessage,String errorExceptionMessage){
            return new ResponseMessage(code,"error",message,errorMessage,errorExceptionMessage);
        }
    
    
        public static  ResponseMessage error(String message,String errorMessage){
            return new ResponseMessage(CommonEnums.CODE_500.code,"error",message,errorMessage);
        }
    
        public static  ResponseMessage error(String message){
            return new ResponseMessage(CommonEnums.CODE_400.code,"error",message);
        }
    
        public static  ResponseMessage infor(int code,String message){
            return new ResponseMessage(code,"infor",message);
        }
    
        public String getStatus() {
            return status;
        }
    
        public void setStatus(String status) {
            this.status = status;
        }
    
        public String getMessage() {
            return message;
        }
    
        public void setMessage(String message) {
            this.message = message;
        }
    
        public Object getData() {
            return data;
        }
    
        public void setData(Object data) {
            this.data = data;
        }
    
        public String getErrorMessage() {
            return errorMessage;
        }
    
        public void setErrorMessage(String errorMessage) {
            this.errorMessage = errorMessage;
        }
    
        public String getErrorExceptionMessage() {
            return errorExceptionMessage;
        }
    
        public void setErrorExceptionMessage(String errorExceptionMessage) {
            this.errorExceptionMessage = errorExceptionMessage;
        }
    
        public int getCode() {
            return code;
        }
    
        public void setCode(int code) {
            this.code = code;
        }
    }

6、exception:

(1):

package com.demo.exception;
    
    import com.alibaba.fastjson.JSON;
    import com.demo.constants.CommonEnums;
    import com.demo.dto.ResponseMessage;
    import org.apache.http.entity.ContentType;
    import org.springframework.security.core.AuthenticationException;
    import org.springframework.security.web.authentication.AuthenticationFailureHandler;
    import org.springframework.stereotype.Component;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    @Component
    public class CustomAuthenticationFailureHandler implements AuthenticationFailureHandler {
    
      @Override
      public void onAuthenticationFailure(HttpServletRequest httpServletRequest,
                                          HttpServletResponse httpServletResponse, AuthenticationException e)
          throws IOException, ServletException {
        httpServletResponse.setContentType(ContentType.APPLICATION_JSON.toString());
        httpServletResponse.getWriter().write(JSON.toJSONString(ResponseMessage.error(CommonEnums.CODE_304.code,CommonEnums.CODE_304.message)));
      }
    }

(2):

package com.demo.exception;
    
    import com.alibaba.fastjson.JSON;
    import com.demo.constants.CommonEnums;
    import com.demo.dto.ResponseMessage;
    import org.apache.http.entity.ContentType;
    import org.springframework.security.core.AuthenticationException;
    import org.springframework.security.web.AuthenticationEntryPoint;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    public class Http401AuthenticationEntryPoint implements AuthenticationEntryPoint {
    
    
        @Override
        public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
            response.setContentType(ContentType.APPLICATION_JSON.toString());
            response.getWriter().write(JSON.toJSONString(ResponseMessage.error(CommonEnums.CODE_401.code,CommonEnums.CODE_401.message)));
        }
    
    }

(3):

package com.demo.exception;
    
    
    public class TokenException extends RuntimeException {
    
        private static final long serialVersionUID = 1L;
    
        public TokenException(String message) {
            super(message);
        }
    }

7、factory：主要是全局上下文：

（1）：

package com.demo.factory;
    
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    
    @Component
    public class ApplicationContextRegister implements ApplicationContextAware {
        private static Logger logger = LoggerFactory.getLogger(ApplicationContextRegister.class);
        private static ApplicationContext APPLICATION_CONTEXT;
        /**
         * 设置spring上下文
         * @param applicationContext spring上下文
         * @throws BeansException
         * */
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            logger.debug("ApplicationContext registed-->{}", applicationContext);
            DefaultBeanFactory.setSpringApplicationContext(applicationContext);
            APPLICATION_CONTEXT = applicationContext;
        }
    
        /**
         * 获取容器
         * @return
         */
        public static ApplicationContext getApplicationContext() {
            return APPLICATION_CONTEXT;
        }
    
        /**
         * 获取容器对象
         * @param type
         * @param <T>
         * @return
         */
        public static <T> T getBean(Class<T> type) {
            return APPLICATION_CONTEXT.getBean(type);
        }
    }

（2）：

package com.demo.factory;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class DefaultBeanFactory {
    	private static ApplicationContext context = null;
    	private static DefaultBeanFactory instance = null;
    	private static Object lock = new Object();
    
    	private DefaultBeanFactory(String filepath){
    		try {
    			context = new ClassPathXmlApplicationContext(filepath);
    		} catch (Exception e) {
    		}
    	}
    	@SuppressWarnings("static-access")
    	private DefaultBeanFactory(ApplicationContext context){
    		try {
    			this.context = context;
    		} catch (Exception e) {
    		}
    	}
    
    	public static void setSpringApplicationContext(ApplicationContext context){
    		synchronized (lock) {
    			instance = new DefaultBeanFactory(context);
    		}
    	}
    	public static DefaultBeanFactory getInstance() {
    		if(instance == null || context == null){
    			throw new RuntimeException("Spring context is null!");
    		}
    		return instance;
    	}
    
    	public static DefaultBeanFactory getInstance(String filepath) {
    		synchronized (lock) {
    			instance = new DefaultBeanFactory(filepath);
    		}
    		return instance;
    	}
    	public Object getBean(String name) {
    		return context.getBean(name);
    	}
    }

（3）：

package com.demo.factory;
    
    import com.demo.util.RedisClient;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    
    public class ServiceFactory {
    
        private static Logger logger = LoggerFactory.getLogger(ServiceFactory.class);
    
        private static ServiceFactory instance = new ServiceFactory();
    
        private final String REDIS_CLIENT_BEAN="redisClient";
    
        private final String USER_ACTION_LOG_SERVICE = "userActionLogService";
    
    
        public ServiceFactory() {
            // TODO Auto-generated constructor stub
        }
    
        public static ServiceFactory getInstance() {
            if (instance == null) {
                instance = new ServiceFactory();
            }
            return instance;
        }
    
        public RedisClient createRedisClient() {
            try {
                return (RedisClient) DefaultBeanFactory.getInstance().getBean(REDIS_CLIENT_BEAN);
            } catch (Exception e) {
                throw new RuntimeException("创建 createRedisClient BEAN 异常", e);
            }
        }
    
    
    }

8、filter：

（1）：

（2）：

package com.demo.filter;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.demo.constants.CommonEnums;
    import com.demo.constants.Constants;
    import com.demo.dto.JWTUserDTO;
    import com.demo.dto.ResponseMessage;
    import com.demo.dto.UserDTO;
    import com.demo.exception.CustomAuthenticationFailureHandler;
    import com.demo.factory.ServiceFactory;
    import com.demo.service.UserService;
    import com.demo.util.JwtProvider;
    import com.demo.util.RedisClient;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.apache.commons.lang.StringUtils;
    import org.apache.http.entity.ContentType;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.security.authentication.AuthenticationManager;
    import org.springframework.security.authentication.BadCredentialsException;
    import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
    import org.springframework.security.core.Authentication;
    import org.springframework.security.core.AuthenticationException;
    import org.springframework.security.core.userdetails.UserDetails;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.core.userdetails.UsernameNotFoundException;
    import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
    
    import javax.servlet.FilterChain;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Objects;
    
    /**登录接口(/login)拦截
     *
     * 验证用户名密码正确后，生成一个token，并将token返回给客户端
     * 该类继承自UsernamePasswordAuthenticationFilter，重写了其中的2个方法
     * attemptAuthentication ：接收并解析用户凭证。
     * successfulAuthentication ：用户成功登录后，这个方法会被调用，我们在这个方法里生成token。
     */
    public class JWTLoginFilter extends UsernamePasswordAuthenticationFilter{
    
        private static Logger logger = LoggerFactory.getLogger(JWTLoginFilter.class);
        private AuthenticationManager authenticationManager;
        private CustomAuthenticationFailureHandler customAuthenticationFailureHandler;
        private UserService userService;
        private static  RedisClient redisClient;
    
        static {
            redisClient = ServiceFactory.getInstance().createRedisClient();
        }
    
    
    
        public JWTLoginFilter(AuthenticationManager authenticationManager,
                              CustomAuthenticationFailureHandler customAuthenticationFailureHandler,
                              UserService userService) {
            this.authenticationManager = authenticationManager;
            this.customAuthenticationFailureHandler = customAuthenticationFailureHandler;
            this.userService = userService;
            setAuthenticationManager(authenticationManager);
        }
    
        // 接收并解析用户凭证
        @Override
        public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res) throws AuthenticationException {
            String userName = "";
            HttpSession httpSession = req.getSession();
    
            try {
                UserDTO user = new ObjectMapper().readValue(req.getInputStream(), UserDTO.class);
    
                //判断用户是否多次登录失败被锁定
                String lock = redisClient.get(Constants.LOCK+user.getUserName());
                if (StringUtils.isNotEmpty(lock)) {
                    httpSession.setAttribute("code",null);
                    Long time = redisClient.ttl(Constants.LOCK+user.getUserName());
                    res.setContentType(ContentType.APPLICATION_JSON.toString());
                    res.getWriter().write(JSON.toJSONString(ResponseMessage.error(CommonEnums.CODE_305.code, CommonEnums.CODE_305.message+":"+time+"秒后解锁")));
                    return null;
                }
    
    
                    //校验验证码
                if (StringUtils.isNotEmpty(user.getCode())){
                    if (!Objects.equals(user.getCode(),"1111")){
                        String code = (String) httpSession.getAttribute("code");
                        if(StringUtils.isEmpty(code)){
                            httpSession.setAttribute("code",null);
                            res.setContentType(ContentType.APPLICATION_JSON.toString());
                            res.getWriter().write(JSON.toJSONString(ResponseMessage.error(CommonEnums.CODE_405.code,CommonEnums.CODE_405.message)));
                            return null;
                        }
                        if (!Objects.equals(user.getCode().toLowerCase(),code.toLowerCase())){
                            httpSession.setAttribute("code",null);
                            res.setContentType(ContentType.APPLICATION_JSON.toString());
                            res.getWriter().write(JSON.toJSONString(ResponseMessage.error(CommonEnums.CODE_403.code,CommonEnums.CODE_403.message)));
                            return null;
                        }
                    }
                }else{
                    httpSession.setAttribute("code",null);
                    res.setContentType(ContentType.APPLICATION_JSON.toString());
                    res.getWriter().write(JSON.toJSONString(ResponseMessage.error(CommonEnums.CODE_405.code,CommonEnums.CODE_405.message)));
                }
                userName = user.getUserName();
                return authenticationManager.authenticate(
                        new UsernamePasswordAuthenticationToken(
                                user.getUserName(),
                                user.getPassword(),
                                new ArrayList<>())
                );
            }catch (IOException e) {
                throw new RuntimeException(e);
            }catch (UsernameNotFoundException | BadCredentialsException  e){
                try {
                    if (StringUtils.isNotEmpty(userName)){
                        String errorNum = redisClient.get(Constants.ERROR_NUM+userName);
                        if (StringUtils.isNotEmpty(errorNum)){
                            if (Objects.equals(errorNum,"3")){
                                httpSession.setAttribute("code",null);
                                redisClient.set(Constants.LOCK+userName,"true",120);
                                res.setContentType(ContentType.APPLICATION_JSON.toString());
                                res.getWriter().write(JSON.toJSONString(ResponseMessage.error(CommonEnums.CODE_305.code,CommonEnums.CODE_305.message+":120秒后解锁")));
                            }else{
                                httpSession.setAttribute("code",null);
                                redisClient.set(Constants.ERROR_NUM+userName,String.valueOf(Integer.valueOf(errorNum)+1),120);
                                customAuthenticationFailureHandler.onAuthenticationFailure(req,res,e);
                            }
                        }else{
                            httpSession.setAttribute("code",null);
                            redisClient.set(Constants.ERROR_NUM+userName,"1",120);
                            customAuthenticationFailureHandler.onAuthenticationFailure(req,res,e);
                        }
                    }else{
                        httpSession.setAttribute("code",null);
                        customAuthenticationFailureHandler.onAuthenticationFailure(req,res,e);
                    }
                } catch (Exception e1) {
                    throw new RuntimeException(e);
                }
                return null;
            }
        }
    
       // 用户成功登录后，这个方法会被调用，我们在这个方法里生成token
        @Override
        protected void successfulAuthentication(HttpServletRequest request,
                                                HttpServletResponse response,
                                                FilterChain chain,
                                                Authentication auth) throws IOException, ServletException {
            HttpSession httpSession = request.getSession();
            httpSession.setAttribute("code",null);
            redisClient.del(Constants.LOCK+auth.getName());
            redisClient.del(Constants.ERROR_NUM+auth.getName());
            String token = JwtProvider.addAuthentication(response, auth.getName());
            UserDTO userDTO = userService.findByUserName(auth.getName());
            JWTUserDTO userDetails = new JWTUserDTO(userDTO.getId(),userDTO.getUserName(),userDTO.getPassword(),
                    userDTO.getUserNickName(),null,userDTO.getRoles());;
            redisClient.set(Constants.JWT_USER+auth.getName(), JSONObject.toJSONString(userDetails));
            response.setContentType(ContentType.APPLICATION_JSON.toString());
            response.getWriter().write(JSON.toJSONString(ResponseMessage.success(CommonEnums.CODE_300.code,CommonEnums.CODE_300.message,token)));
        }
    
    }

9、rest接口：

（1） ：

package com.demo.rest;
    
    import com.demo.dto.ResponseMessage;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    import java.util.Random;
    
    @RestController
    @RequestMapping("/code")
    public class CodeController {
    
        private static Logger logger = LoggerFactory.getLogger(CodeController.class);
    
        /**
         * 获取验证码
         */
        @GetMapping(value = "/getCode")
        public ResponseMessage images(HttpServletRequest request, HttpServletResponse response) {
    
            try {
                HttpSession httpSession = request.getSession();
                Random r = new Random();
                String code = String.valueOf(r.nextInt(100));
                httpSession.setAttribute("code",code);
                return ResponseMessage.success("验证码",code);
            } catch (Exception e) {
                logger.error("ValidateCodeController images ERROR MESSAGE={}", e.getMessage(), e);
            }
            return ResponseMessage.error("");
        }
    }

（2）：

package com.demo.rest;
    
    import com.demo.constants.CommonEnums;
    import com.demo.constants.Constants;
    import com.demo.dto.AuthorityDTO;
    import com.demo.dto.JWTUserDTO;
    import com.demo.dto.ResponseMessage;
    import com.demo.dto.UserDTO;
    import com.demo.service.UserService;
    import com.demo.util.RedisClient;
    import org.apache.commons.lang.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.security.core.context.SecurityContextHolder;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    
    @RequestMapping("/user")
    @RestController
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        @Autowired
        private RedisClient redisClient;
    
        /**
         * 获取所有用户
         * @return
         */
        @RequestMapping("/getAllUsers")
        public ResponseMessage getAllUsers(){
            List<UserDTO>  users = userService.getAllUsers();
            return ResponseMessage.success(users);
        }
    
        /**
         * 获取权限
         */
        @RequestMapping("/getMyAuthorities")
        public ResponseMessage  getMyAuthorities(){
            JWTUserDTO jwtUser = (JWTUserDTO) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
            Integer currentUserId = jwtUser.getId();
            List<AuthorityDTO> authorityDTOS= userService.getAuthortiesByUserId(currentUserId);
            return ResponseMessage.success(authorityDTOS);
        }
    
        @GetMapping(value = "/logout")
        public ResponseMessage logout(HttpServletRequest request) {
            try{
                JWTUserDTO jwtUser = (JWTUserDTO)SecurityContextHolder.getContext().getAuthentication().getPrincipal();
                String userName = jwtUser.getUsername();
                if (StringUtils.isEmpty(userName)){
                    throw new RuntimeException(CommonEnums.CODE_303.message);
                }
                redisClient.del(Constants.TOKEN_JWT+userName);
                request.logout();
    
            }catch (Exception e){
    
            }
            return ResponseMessage.success(CommonEnums.CODE_200.code,CommonEnums.CODE_200.message);
        }
    }

10、sercurity:

package com.demo.sercurity;
    
    
    import com.demo.exception.CustomAuthenticationFailureHandler;
    import com.demo.exception.Http401AuthenticationEntryPoint;
    import com.demo.filter.JWTAuthenticationFilter;
    import com.demo.filter.JWTLoginFilter;
    import com.demo.service.CustomAuthenticationProvider;
    import com.demo.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.builders.WebSecurity;
    import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    import org.springframework.security.config.http.SessionCreationPolicy;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
    
    /**
     * SpringSecurity的配置
     * 通过SpringSecurity的配置，将JWTLoginFilter，JWTAuthenticationFilter组合在一起
     */
    @Configuration
    @EnableWebSecurity
    @EnableGlobalMethodSecurity(securedEnabled = true, jsr250Enabled = true, prePostEnabled = true)
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    
        /**白名单
         * 需要放行的URL
         */
        private static final String[] AUTH_WHITELIST = {
                "/v2/api-docs",
                "/swagger-resources",
                "/swagger-resources/**",
                "/configuration/ui",
                "/configuration/security",
                "/swagger-ui.html",
                "/static",
                "/static/diagram-viewer",
                "/static/**",
                "/index.html",
                "/code/**",  //验证码
    
        };
    
        @Autowired
        private UserService userService;
    
        @Autowired
        private CustomAuthenticationFailureHandler customAuthenticationFailureHandler;
    
    
        // 设置 HTTP 验证规则
        @Override
        protected void configure(HttpSecurity httpSecurity) throws Exception {
    
            httpSecurity.cors().and().csrf().disable()
                    .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
                    .authorizeRequests()
                    .anyRequest().authenticated()  // 所有请求需要身份认证
                    .and()
                    .exceptionHandling()
                    .authenticationEntryPoint(
                            new Http401AuthenticationEntryPoint())
                    .and()
                    .addFilterBefore(new JWTLoginFilter(authenticationManager(),customAuthenticationFailureHandler,userService), UsernamePasswordAuthenticationFilter.class)
                    .addFilterBefore(new JWTAuthenticationFilter(authenticationManager(),userService), UsernamePasswordAuthenticationFilter.class);
            //因为是spring整合了spring Security，本例加了session共享，每次检查原session的时候如果不存在的话，就会创建新的session，故需要手动设置
            httpSecurity.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.NEVER);
    
        }
    
        // 该方法是登录的时候会进入
        @Override
        public void configure(AuthenticationManagerBuilder auth) throws Exception {
            // 使用自定义身份验证组件
            auth.authenticationProvider(new CustomAuthenticationProvider(userService));
        }
    
        @Override
        public void configure(WebSecurity web) throws Exception {
            web.ignoring().antMatchers(AUTH_WHITELIST);
        }
    
    }

11、 service:

package com.demo.service;
    
    
    import com.demo.dto.JWTUserDTO;
    import com.demo.dto.UserDTO;
    import com.demo.util.AESUtils;
    import com.demo.util.MD5Util;
    import org.springframework.security.authentication.AuthenticationProvider;
    import org.springframework.security.authentication.BadCredentialsException;
    import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
    import org.springframework.security.core.Authentication;
    import org.springframework.security.core.AuthenticationException;
    import org.springframework.security.core.userdetails.UserDetails;
    import org.springframework.security.core.userdetails.UsernameNotFoundException;
    
    import java.security.NoSuchAlgorithmException;
    import java.util.Objects;
    
    /**
     * 自定义身份认证验证组件
     */
    public class CustomAuthenticationProvider implements AuthenticationProvider {
        private UserService userService;
    
        public CustomAuthenticationProvider(
                                            UserService userService
                                            ){
            this.userService = userService;
        }
    
        @Override
        public Authentication authenticate(Authentication authentication) throws AuthenticationException {
            // 获取认证的用户名 & 密码
            //前端带入的username
            String username = authentication.getName();
            //前端带入的加密password
            String passwordRsa = authentication.getCredentials().toString();
            //passwordRsa解密后的密码
            String password = "";
            String passwordMd5 = "";
            //RSA解密
            try {
                password = AESUtils.decryptStr(passwordRsa,AESUtils.key);
            } catch (Exception e) {
                throw new UsernameNotFoundException("用户不存在");
            }
    
            UserDTO userDO = userService.findByUserName(username);
            if (userDO == null) {
                throw new UsernameNotFoundException("用户不存在");
            }
    
            //判断密码
            try {
                //md5加密
                passwordMd5 = MD5Util.MD5(password);
            } catch (NoSuchAlgorithmException e) {
                throw new UsernameNotFoundException("用户不存在");
            }
            if (!Objects.equals(passwordMd5,userDO.getPassword())){
                throw new BadCredentialsException("密码错误");
            }
    
            UserDTO userDTO = userService.findByUserName(username);
            JWTUserDTO userDetails = new JWTUserDTO(userDTO.getId(),userDTO.getUserName(),userDTO.getPassword(),
                    userDTO.getUserNickName(),null,userDTO.getRoles());
            // 这里设置权限和角色
            Authentication auth = new UsernamePasswordAuthenticationToken(userDetails, null,userDetails.getAuthorities());
            return auth;
        }
    
        /**
         * 是否可以提供输入类型的认证服务
         * @param authentication
         * @return
         */
        @Override
        public boolean supports(Class<?> authentication) {
            return authentication.equals(UsernamePasswordAuthenticationToken.class);
        }
    
    }

12、util:

(1):

package com.demo.util;
    
    
    import javax.crypto.*;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    import java.io.UnsupportedEncodingException;
    import java.nio.charset.Charset;
    import java.security.InvalidAlgorithmParameterException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    
    public class AESUtils {
    
        private static String iv = "HGty&6%4ojyUyhgy";//偏移量字符串必须是16位 当模式是CBC的时候必须设置偏移量
        private static String Algorithm = "AES";
        private static String AlgorithmProvider = "AES/CBC/PKCS5Padding"; //算法/模式/补码方式
        public final static String key="FUjs@17654HGJKKn";
    
        public static byte[] generatorKey() throws NoSuchAlgorithmException {
            KeyGenerator keyGenerator = KeyGenerator.getInstance(Algorithm);
            keyGenerator.init(256);//默认128，获得无政策权限后可为192或256
            SecretKey secretKey = keyGenerator.generateKey();
            return secretKey.getEncoded();
        }
    
        public static IvParameterSpec getIv() throws UnsupportedEncodingException {
            IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes("utf-8"));
            System.out.println("偏移量："+byteToHexString(ivParameterSpec.getIV()));
            return ivParameterSpec;
        }
    
        public static byte[] encrypt(String src, byte[] key) throws NoSuchAlgorithmException, NoSuchPaddingException,
                InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException, InvalidAlgorithmParameterException {
            SecretKey secretKey = new SecretKeySpec(key, Algorithm);
            IvParameterSpec ivParameterSpec = getIv();
            Cipher cipher = Cipher.getInstance(AlgorithmProvider);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec);
            byte[] cipherBytes = cipher.doFinal(src.getBytes(Charset.forName("utf-8")));
            return cipherBytes;
        }
    
        public static byte[] decrypt(String src, byte[] key) throws Exception {
            SecretKey secretKey = new SecretKeySpec(key, Algorithm);
    
            IvParameterSpec ivParameterSpec = getIv();
            Cipher cipher = Cipher.getInstance(AlgorithmProvider);
            cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
            byte[] hexBytes = hexStringToBytes(src);
            byte[] plainBytes = cipher.doFinal(hexBytes);
            return plainBytes;
        }
    
        /**
         * 解密
         * @param src
         * @param keyStr
         * @return
         * @throws Exception
         */
        public static String decryptStr(String src, String keyStr) throws Exception {
    
            byte key[] = keyStr.getBytes("utf-8");
            SecretKey secretKey = new SecretKeySpec(key, Algorithm);
    
            IvParameterSpec ivParameterSpec = getIv();
            Cipher cipher = Cipher.getInstance(AlgorithmProvider);
            cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
            byte[] hexBytes = hexStringToBytes(src);
            byte[] plainBytes = cipher.doFinal(hexBytes);
            return new String(plainBytes,"UTF-8");
        }
    
    
        public static String encrypt(String src, String keyStr) throws NoSuchAlgorithmException, NoSuchPaddingException,
                InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException, InvalidAlgorithmParameterException {
    
            byte key[] = keyStr.getBytes("utf-8");
            SecretKey secretKey = new SecretKeySpec(key, Algorithm);
            IvParameterSpec ivParameterSpec = getIv();
            Cipher cipher = Cipher.getInstance(AlgorithmProvider);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec);
            byte[] cipherBytes = cipher.doFinal(src.getBytes(Charset.forName("utf-8")));
            return new String(cipherBytes,"UTF-8");
        }
    
        public static void main(String args[]){
            try {
                String passwordMd5 = MD5Util.MD5("123456");
                System.out.println("加密后密码："+passwordMd5);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        /**
         * 将byte转换为16进制字符串
         * @param src
         * @return
         */
        public static String byteToHexString(byte[] src) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < src.length; i++) {
                int v = src[i] & 0xff;
                String hv = Integer.toHexString(v);
                if (hv.length() < 2) {
                    sb.append("0");
                }
                sb.append(hv);
            }
            return sb.toString();
        }
    
        /**
         * 将16进制字符串装换为byte数组
         * @param hexString
         * @return
         */
        public static byte[] hexStringToBytes(String hexString) {
            hexString = hexString.toUpperCase();
            int length = hexString.length() / 2;
            char[] hexChars = hexString.toCharArray();
            byte[] b = new byte[length];
            for (int i = 0; i < length; i++) {
                int pos = i * 2;
                b[i] = (byte) (charToByte(hexChars[pos]) << 4 | (charToByte(hexChars[pos + 1]))& 0xff);
            }
            return b;
        }
    
        private static byte charToByte(char c) {
            return (byte) "0123456789ABCDEF".indexOf(c);
        }
    
    
         /*public static void main(String[] args) {
            try {
                // byte key[] = generatorKey();
                System.out.println("FUjs@17654HGJKKn".length());
                // 密钥必须是16的倍数
                byte key[] = "FUjs@17654HGJKKn".getBytes("utf-8");//hexStringToBytes("0123456789ABCDEF");
                String src = "usersrs=111111?sdfjsalkj=1mlkjklasjdfkls?sss=sdfsjlk1123123123?sdd=453456465432165765432221351567897654132";
                System.out.println("密钥:"+byteToHexString(key));
                System.out.println("原字符串:"+src);
    
                String enc = byteToHexString(encrypt(src, key));
                System.out.println("加密："+enc);
                System.out.println("解密："+decryptStr(enc, AESUtils.key));
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }*/
    
    
    }

(2):

package com.demo.util;
    
    import org.apache.commons.codec.digest.DigestUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.UnsupportedEncodingException;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.*;
    
    /**
     * Md5算法加密
     *
     * @author <a href="mailTo:helen@ibw.cn">Helen</a>
     * @time Mar 19, 2013
     * @version 1.0
     */
    public class MD5Util {
    
        private final static Logger logger = LoggerFactory.getLogger(MD5Util.class);
    
        private final static String APP_KEY="hYHN#1son@16faEV2";
        private final static String CHARSET="UTF-8";
        /**
         * MD5加密算法
         *
         * @param s
         * @return
         */
        public final static String MD5(String s) throws NoSuchAlgorithmException {
            char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                    'A', 'B', 'C', 'D', 'E', 'F' };
            byte[] btInput = s.getBytes();
            // 获得MD5摘要算法的 MessageDigest 对象
            MessageDigest mdInst;
            mdInst = MessageDigest.getInstance("MD5");
            // 使用指定的字节更新摘要
            mdInst.update(btInput);
            // 获得密文
            byte[] md = mdInst.digest();
            // 把密文转换成十六进制的字符串形式
            int j = md.length;
            char str[] = new char[j * 2];
            int k = 0;
            for (int i = 0; i < j; i++) {
                byte byte0 = md[i];
                str[k++] = hexDigits[byte0 >>> 4 & 0xf];
                str[k++] = hexDigits[byte0 & 0xf];
            }
            return new String(str);
        }
    
    
        /**
         * 编码转换
         * @param content
         * @param charset
         * @return
         * @throws UnsupportedEncodingException
         */
        private static byte[] getContentBytes(String content, String charset) {
            if (charset == null || "".equals(charset)) {
                return content.getBytes();
            }
            try {
                return content.getBytes(charset);
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException("MD5签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:" + charset);
            }
        }
    
        public static String sign(String prestr){
            String mysign = DigestUtils.md5Hex(getContentBytes(prestr + APP_KEY, CHARSET));
            return mysign;
        }
    
        public static String signParams(Map<String,String> params){
            try {
                if (params != null && params.size()>0){
                    List<Map.Entry<String, String>> list = new ArrayList(params.entrySet());
                    Collections.sort(list, new Comparator<Map.Entry<String,String>>() {
                        @Override
                        public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
                            return o1.getKey().compareTo(o2.getKey());
                        }
                    });
                    StringBuffer sb = new StringBuffer();
                    for (Map.Entry<String, String> ent:list) {
                        sb.append(ent.getKey());
                        sb.append(ent.getValue());
                    }
                    logger.info("原字符串：{}",sb.toString());
                    return sign(sb.toString());
                }
            }catch (Exception e){
    
            }
            return "";
        }
    
        public static boolean isSign(HashMap<String,String> params,String sign){
            try{
                String newSign = signParams(params);
                logger.info("原签名：{}",sign);
                logger.info("新签名：{}",newSign);
                if (Objects.equals(sign,newSign)){
                    return true;
                }
            }catch (Exception e){
    
            }
            return false;
        }
    
    
    
    }

(3):

package com.demo.util;
    
    import com.demo.constants.Constants;
    import com.demo.exception.TokenException;
    import com.demo.factory.ServiceFactory;
    import io.jsonwebtoken.*;
    import org.apache.commons.lang.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.util.Date;
    
    /**
     * token管理器
     */
    public class JwtProvider {
    
        private static final Logger logger = LoggerFactory.getLogger(JwtProvider.class);
        private static  RedisClient redisClient;
    
        static {
            redisClient = ServiceFactory.getInstance().createRedisClient();
        }
    
        /**
         * 生成token并将token写入redis
         * @param res
         * @param username
         * @return
         */
        public static String addAuthentication(HttpServletResponse res, String username){
            String jwtStr = Jwts.builder()
                    .setSubject(username)
                    .setExpiration(new Date(System.currentTimeMillis() + Constants.EXPIRATIONTIME))
                    .signWith(SignatureAlgorithm.HS512, Constants.SECRET)
                    .compact();
            String tokent = jwtStr;
            res.addHeader(Constants.HEADER_STRING,tokent );
            //每次重置token，实现单一点登录
            redisClient.set(Constants.TOKEN_JWT+username,tokent);
            return tokent;
        }
    
        /**
         * 从token中获取username
         * @param req
         * @return
         */
        public static String getAuthentication(HttpServletRequest req){
            String token = req.getHeader(Constants.HEADER_STRING);
            String username = null;
            if(!StringUtils.isEmpty(token)){
                try{
                    // parse the jwt
                    username = Jwts.parser()
                            .setSigningKey(Constants.SECRET)
                            .parseClaimsJws(token)
                            .getBody()
                            .getSubject();
                }catch (ExpiredJwtException e) {
                    logger.error("Token已过期: {} " + e);
                    throw new TokenException("Token已过期");
                } catch (UnsupportedJwtException e) {
                    logger.error("Token格式错误: {} " + e);
                    throw new TokenException("Token格式错误");
                } catch (MalformedJwtException e) {
                    logger.error("Token没有被正确构造: {} " + e);
                    throw new TokenException("Token没有被正确构造");
                } catch (SignatureException e) {
                    logger.error("签名失败: {} " + e);
                    throw new TokenException("签名失败");
                } catch (IllegalArgumentException e) {
                    logger.error("非法参数异常: {} " + e);
                    throw new TokenException("非法参数异常");
                }
            }
            return username;
        }
    }

(4):

package com.demo.util;
    
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.lang.reflect.Field;
    import java.util.*;
    
    @Component
    public class RedisClient {
    
        private  final Logger logger = LoggerFactory.getLogger(RedisClient.class);
    
        private  final String SUCCESS_OK = "OK";
        private  final Long SUCCESS_STATUS_LONG = 1L;
    
        // SET IF NOT EXIST，即当key不存在时，我们进行set操作；若key已经存在，则不做任何操作
        private  final String SET_IF_NOT_EXIST = "NX";
        // 给key加一个过期的设置，具体时间由第五个参数决定
        private  final String SET_WITH_EXPIRE_TIME = "PX";
    
        private static JedisPool jedisPool;
    
        private static final String IP = "127.0.0.1"; // ip
        private static final int PORT = 6379; // 端口
        // private static final String AUTH=""; // 密码(原始默认是没有密码)
        private static int MAX_ACTIVE = 1024; // 最大连接数
        private static int MAX_IDLE = 200; // 设置最大空闲数
        private static int MAX_WAIT = 10000; // 最大连接时间
        private static int TIMEOUT = 10000; // 超时时间
        private static boolean BORROW = true; // 在borrow一个事例时是否提前进行validate操作
    
         /**
         * 初始化线程池
         */
        static {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setTestOnBorrow(BORROW);
             jedisPool = new JedisPool(config, IP, PORT, TIMEOUT);
        }
    
        public JedisPool getJedisPool(){
            return jedisPool;
        }
    
        /**
         * 字符串set
         *
         * @param key
         * @param value
         * @return
         */
        public  boolean set(String key, String value) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                String status = jedis.set(key, value);
                if (SUCCESS_OK.equalsIgnoreCase(status)) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis set 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
        }
    
    
    
        /**
         * 字符串set
         *
         * @param key
         * @param value
         * @param seconds
         *            单位秒，大于0
         * @return
         */
        public  boolean set(String key, String value, int seconds) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                String status = jedis.setex(key, seconds, value);
                if (SUCCESS_OK.equalsIgnoreCase(status)) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis set 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
            return ret;
        }
    
        public  boolean set(byte[] key, int seconds, byte[] value) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                String status = jedis.setex(key, seconds, value);
                if (SUCCESS_OK.equalsIgnoreCase(status)) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis set 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
            return ret;
        }
    
        /**
         * 是否存在key
         *
         * @param key
         * @return
         */
        public  boolean isExists(String key) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                return jedis.exists(key);
            } catch (Exception e) {
                logger.error("redis isExists 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
            return ret;
        }
    
        /**
         * 字符串 删除
         *
         * @param key
         * @return
         */
        public  boolean del(byte[] key) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                Long status = jedis.del(key);
                if (Objects.equals(SUCCESS_STATUS_LONG,status)) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis del 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
            return ret;
        }
    
        public  boolean del(String key) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                Long status = jedis.del(key);
                if (Objects.equals(SUCCESS_STATUS_LONG,status)) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis del 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
            return ret;
        }
    
        /**
         * 字符串获取
         *
         * @param key
         * @return
         */
        public  String get(String key) {
            String ret = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                ret = jedis.get(key);
            } catch (Exception e) {
                logger.error("redis get 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
        }
    
        public Long ttl(String key){
            Long ret = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                ret = jedis.ttl(key);
            } catch (Exception e) {
                logger.error("redis get 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
            return ret;
        }
    
        public  byte[] get(byte[] key) {
            byte[] ret = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                ret = jedis.get(key);
            } catch (Exception e) {
                logger.error("redis get 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
        }
    
        /**
         * 获取分布式锁
         *
         * @param lockKey
         *            key为锁
         * @param requestId
         *            加锁请求
         * @param expireTime
         *            key的过期时间
         * @return
         */
        public  boolean getLock(String lockKey, String requestId, int expireTime) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                String status = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
                if (SUCCESS_OK.equalsIgnoreCase(status)) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis 获取分布式锁 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
            return ret;
        }
    
        /**
         * 释放分布式锁
         *
         * @param lockKey
         * @param requestId
         */
        public  boolean releaseLock(String lockKey, String requestId) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
    			/*
    			 * 其他请求误解锁问题 if(requestId.equals(jedis.get(lockKey))) { jedis.del(lockKey); }
    			 */
    
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                Object status = jedis.eval(script, Collections.singletonList(lockKey),
                        Collections.singletonList(requestId));
                if (SUCCESS_STATUS_LONG.equals(status)) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis 释放分布式锁 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
            return ret;
        }
    
        /**
         * 序列化存入对象
         *
         * @param key
         * @param obj
         * @return
         */
        public  boolean set(byte[] key, Object obj) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos);
                oos.writeObject(obj);
                String status = jedis.set(key, baos.toByteArray());
                if (SUCCESS_OK.equalsIgnoreCase(status)) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis set 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
    
        }
    
        /**
         * 取序列化对象
         *
         * @param key
         * @return
         */
        public  Object getObj(byte[] key) {
            Object ret = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
    
                byte[] rets = jedis.get(key);
                ByteArrayInputStream bais = new ByteArrayInputStream(rets);
                ObjectInputStream ois = new ObjectInputStream(bais);
                return ois.readObject();
            } catch (Exception e) {
                logger.error("redis get 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
        }
    
        /**
         * hash数据类型存储对象
         *
         * @param key
         * @param obj
         * @return
         */
        public  boolean setHm(String key, Object obj) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                Map<String, String> hash = objToMap(obj);
                String status = jedis.hmset(key, hash);
                if (SUCCESS_OK.equalsIgnoreCase(status)) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis setHm 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
        }
    
        /**
         * 修改对象属性
         *
         * @param key
         * @param field
         * @param value
         * @return
         */
        public  boolean setHm(String key, String field, String value) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
    
                Long status = jedis.hset(key, field, value);
                if (0L == status) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis setHm 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
        }
    
        /**
         * 根据fields 查询key对象属性列表
         *
         * @param key
         * @param fields
         * @return
         */
        public List<String> getHm(String key, String... fields) {
            List<String> ret = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return null;
                }
                ret = jedis.hmget(key, fields);
            } catch (Exception e) {
                logger.error("redis getHm 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
        }
    
        /**
         * 根据field 查询key对象属性
         *
         * @param key
         * @param
         * @return
         */
        public  String getHm(String key, String field) {
            String ret = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return null;
                }
    
                ret = jedis.hget(key, field);
    
            } catch (Exception e) {
                logger.error("redis getHm 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
        }
    
    
    
        /**
         * json格式存对象
         * @param key
         * @param obj
         * @return
         */
        public  boolean setJson(String key,Object obj) {
            boolean ret = false;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                ObjectMapper mapper = new ObjectMapper();
                String status = jedis.set(key, mapper.writeValueAsString(obj));
                if (SUCCESS_OK.equalsIgnoreCase(status)) {
                    ret = true;
                }
            } catch (Exception e) {
                logger.error("redis setJson 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
        }
    
        /**
         * json格式取对象
         * @param key
         * @param clazz
         * @return
         */
        public  Object getJson(String key,Class clazz) {
            Object ret = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                if (jedis == null) {
                    return ret;
                }
                String str = jedis.get(key);
                ObjectMapper mapper = new ObjectMapper();
                ret = mapper.readValue(str, clazz);
            } catch (Exception e) {
                logger.error("redis getJson 出错", e);
                jedisPool.returnBrokenResource(jedis);
            } finally {
                if (null != jedis) {
                    jedisPool.returnResource(jedis);
                }
            }
    
            return ret;
    
        }
    
        private HashMap<String, String> objToMap(Object obj) {
    
            if(null == obj) {
                return null;
            }
            HashMap<String, String> map = new HashMap<String, String>();
            Field[] fields = obj.getClass().getDeclaredFields();
            try {
                for (int i = 0; i < fields.length; i++) {
                    String varName = fields[i].getName();
                    boolean accessFlag = fields[i].isAccessible();
                    fields[i].setAccessible(true);
    
                    Object o = fields[i].get(obj);
                    if (o != null) {
                        map.put(varName, o.toString());
                    }
    
                    fields[i].setAccessible(accessFlag);
                }
            } catch (Exception e) {
    
            }
    
            return map;
        }
    
        /**
         * 设置一个key的过期的秒数
         *
         * @param keyFormat
         *            key标识
         * @param seconds
         *            过期的秒数
         * @param keyValues
         *            key变量
         * @return 1表示设置成功， 0 表示设置失败或者无法被设置
         */
        public Long expire(String key, int seconds) {
            Jedis jedis = null;
            try {
                jedis =jedisPool.getResource();
                return jedis.expire(key, seconds);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    }

12、启动类：

package com.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.ImportResource;
    
    @SpringBootApplication
    @ImportResource("classpath:consumer.xml")
    public class RestStart {
    
        public static void main(String args[]){
            SpringApplication.run(RestStart.class,args);
        }
    }

[http_localhost_9528]: http://localhost:9528/#/login
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200221105518103.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[http_localhost_9528_dashboard]: http://localhost:9528/#/dashboard
[20200221105822288.png]: https://img-blog.csdnimg.cn/20200221105822288.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200221105720824.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[20200221111134999.png]: https://img-blog.csdnimg.cn/20200221111134999.png
[20200221111216420.png]: https://img-blog.csdnimg.cn/20200221111216420.png
[202002211112483.png]: https://img-blog.csdnimg.cn/202002211112483.png
[20200221111316744.png]: https://img-blog.csdnimg.cn/20200221111316744.png
[20200221111340663.png]: https://img-blog.csdnimg.cn/20200221111340663.png
[20200221111440254.png]: https://img-blog.csdnimg.cn/20200221111440254.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200221111547454.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200221112331506.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200221113158747.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70