spring boot整合spring security以及JWT

首先是pom的依賴：

<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.0.0</version>
		</dependency>
		<!--阿里巴巴druid連接池-->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.10</version>
		</dependency>
		<!--  加載 spring  boot  redis 包  -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
			<version>1.4.1.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.3</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
		</dependency>
		<!--mysql-->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.28</version>
			<scope>runtime</scope>
		</dependency>
		<!--分頁插件-->
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper-spring-boot-starter</artifactId>
			<version>1.2.10</version>
		</dependency>
		<!--spring aop注入-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
		<!--swagger依賴-->
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger2</artifactId>
			<version>2.8.0</version>
		</dependency>
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger-ui</artifactId>
			<version>2.8.0</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!--set跟get的方法-->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>

		<!--spring security跟 JWT-->
		<!--安全-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-security</artifactId>
		</dependency>
		<!--jwt-->
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt</artifactId>
			<version>0.9.1</version>
		</dependency>

		<!--stringUtils等方法的使用-->
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.4</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-context</artifactId>
			<version>2.2.0.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>compile</scope>
		</dependency>

spring security的配置：

package com.china.great.system.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
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.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

/**
 * Author: Liu HongYang
 * createAt: 2020/5/12
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    private final JwtAuthenticationEntryPoint unauthorizedHandler;

    private final AccessDeniedHandler accessDeniedHandler;

    private final UserDetailsService CustomUserDetailsService;

    private final JwtAuthenticationTokenFilter authenticationTokenFilter;

    @Autowired
    public WebSecurityConfig(JwtAuthenticationEntryPoint unauthorizedHandler,
                             @Qualifier("RestAuthenticationAccessDeniedHandler") AccessDeniedHandler accessDeniedHandler,
                             @Qualifier("CustomUserDetailsService") UserDetailsService CustomUserDetailsService,
                             JwtAuthenticationTokenFilter authenticationTokenFilter) {
        this.unauthorizedHandler = unauthorizedHandler;
        this.accessDeniedHandler = accessDeniedHandler;
        this.CustomUserDetailsService = CustomUserDetailsService;
        this.authenticationTokenFilter = authenticationTokenFilter;
    }

    @Autowired
    public void configureAuthentication(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
        authenticationManagerBuilder
                // 設置UserDetailsService
                .userDetailsService(this.CustomUserDetailsService)
                // 使用BCrypt進行密碼的hash
                .passwordEncoder(NoOpPasswordEncoder.getInstance());
    }



    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity
                .exceptionHandling().accessDeniedHandler(accessDeniedHandler).and()
                // 由於使用的是JWT，我們這裏不需要csrf
                .csrf().disable()
                .exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()
                // 基於token，所以不需要session
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()

                .authorizeRequests()

                // 對於獲取token的rest api要允許匿名訪問
                .antMatchers("/api/v1/login", "/api/v1/sign", "/error/**").permitAll()
                // 除上面外的所有請求全部需要鑑權認證
                .anyRequest().authenticated();

        // 禁用緩存
        httpSecurity.headers().cacheControl();

        // 添加JWT filter
        httpSecurity
                .addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }

    @Override
    public void configure(WebSecurity web) {
        web
                .ignoring()
                .antMatchers(
                        "swagger-ui.html",
                        "**/swagger-ui.html",
                        "/favicon.ico",
                        "/**/*.css",
                        "/**/*.js",
                        "/**/*.png",
                        "/**/*.gif",
                        "/swagger-resources/**",
                        "/v2/**",
                        "/**/*.ttf"
                );
        web.ignoring().antMatchers("/v2/api-docs",
                "/swagger-resources/configuration/ui",
                "/swagger-resources",
                "/swagger-resources/configuration/security",
                "/swagger-ui.html"
        );
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

jwt的攔截器：

package com.china.great.system.config;

import com.china.great.system.entity.SystemLoginUser;
import com.china.great.system.service.impl.CustomUserDetailsServiceImpl;
import com.china.great.system.util.JwtUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.annotation.Resource;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 *
 * token過濾器來驗證token有效性
 * token校驗
 * @author: LiuHongYang
 * createAt: 2020/5/1
 */
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    private static final Logger logger = LoggerFactory.getLogger(JwtAuthenticationTokenFilter.class);

    @Value("${jwt.header}")
    private String token_header;

    @Resource
    private JwtUtils jwtUtils;

    @Autowired
    private CustomUserDetailsServiceImpl customUserDetailsService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
        String auth_token = request.getHeader(this.token_header);
        final String auth_token_start = "Bearer ";
        if (StringUtils.isNotEmpty(auth_token) && auth_token.startsWith(auth_token_start)) {
            auth_token = auth_token.substring(auth_token_start.length());
        } else {
            // 不按規範,不允許通過驗證
            auth_token = null;
        }

        String username = jwtUtils.getUsernameFromToken(auth_token);

        logger.info(String.format("Checking authentication for userDetail %s.", username));

        if (jwtUtils.containToken(username, auth_token) && username != null) {/* && SecurityContextHolder.getContext().getAuthentication() == null*/
            //SystemUser userDetail = jwtUtils.getUserFromToken(auth_token);
            SystemLoginUser userDetail = (SystemLoginUser) customUserDetailsService.loadUserByUsername(username);
            logger.info("jwtFIlter方法內的 userdetail=" + userDetail);
            if (jwtUtils.validateToken(auth_token, userDetail)) {
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(username, userDetail.getPassword());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                logger.info(String.format("Authenticated userDetail %s, setting security context", username));
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        chain.doFilter(request, response);
    }
}

驗證失敗的方法：

package com.china.great.system.config;

import com.alibaba.fastjson.JSONObject;
import com.china.great.system.common.CommonResultUtil;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.Serializable;

/**
 *
 *
 * @author: LiuHongYang
 * createAt: 2020/5/1
 */
@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint, Serializable {

    private static final long serialVersionUID = -8970718410437077606L;

    @Override
    public void commence(HttpServletRequest request,
                         HttpServletResponse response,
                         AuthenticationException authException) throws IOException {
        //驗證爲未登陸狀態會進入此方法，認證錯誤
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/javascript;charset=utf-8");
        response.getWriter().print(JSONObject.toJSONString(CommonResultUtil.tokenErr()));
    }
}

權限驗證失敗的方法：

package com.china.great.system.config;

import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * 權限不足處理類
 *
 * @author: LiuHongYang
 * createAt: 2020/5/1
 */
@Component("RestAuthenticationAccessDeniedHandler")
public class RestAuthenticationAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse response, AccessDeniedException e) throws IOException, ServletException {
        //登陸狀態下，權限不足執行該方法
        System.out.println("權限不足：" + e.getMessage());
        response.setStatus(200);
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        PrintWriter printWriter = response.getWriter();
        String body = "驗證錯誤,權限不足";
        printWriter.write(body);
        printWriter.flush();
    }
}

用戶：

package com.china.great.system.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

@Data
public class SystemUser implements Serializable {
    private long id;
    private String username;
    private String password;
    private String phone;
    private String email;
    private String realName;
    private Date createTime;
    private Date updateTime;
    private String icon;


}

登陸用戶：

package com.china.great.system.entity;

import lombok.Data;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * @Author: Liu HongYang
 * @DateTime: 2020/5/4 7:04 下午
 * @Description: TODO
 */
@Data
public class SystemLoginUser implements UserDetails,Serializable {

    private long id;
    private String username;
    private String password;
    //private String roles;


    public SystemLoginUser(long id,String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    //public SystemLoginUser(String username, String password, String roles) {
      //  this.username = username;
        //this.password = password;
        //this.roles = roles;
    //}

    /*@Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        //List<GrantedAuthority> authorities = new ArrayList<>();
       *//* for (Role role : roles) {
            authorities.add(new SimpleGrantedAuthority("ROLE_" + role.getAuthority()));
        }*//*
        //return authorities;
    }*/

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

user的dao：

package com.china.great.system.dao;

import com.china.great.system.entity.Blog;
import com.china.great.system.entity.SystemLoginUser;
import com.china.great.system.entity.SystemUser;
import com.github.pagehelper.PageInfo;
import org.apache.catalina.User;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface UserMapper {

    /**
    *
    * 獲取用戶列表
    *
    * */
    List<SystemUser> getList(int pageSize, int pageNum);

    /**
    *根據用戶名，查詢用戶詳情
    *
    * */
    SystemLoginUser getUser(String username);

    /**
     * 登陸
     * @param username
     * @param password
     * @return
     */
    String login(String username, String password);

    /**
     * 登出
     * @param token
     */
    void logout(String token);

    /**
     * 刷新Token
     * @param oldToken
     * @return
     */
    String refresh(String oldToken);

    /**
     * 根據Token獲取用戶信息
     * @param token
     * @return
     */
    SystemUser getUserByToken(String token);

    /**
     *
     * 增加方法
     * */
    int insert(SystemUser blog);

    /**
     *
     *修改方法
     * */
    int update(SystemUser blog);

    /**
     *
     *刪除方法
     * */
    int delete(int id);

}

service：

package com.china.great.system.service;

import com.china.great.system.entity.SystemLoginUser;
import com.china.great.system.entity.SystemUser;
import com.github.pagehelper.PageInfo;


public interface SystemUserService {

    /**
     *
     * */
    PageInfo getList(int pageSize, int pageNum);

    /**
     *
     * */
    SystemLoginUser getUser(String username);

    /**
     * 登陸
     * @param username
     * @param password
     * @return
     */
    String login(String username, String password);

    /**
     * 登出
     * @param token
     */
    void logout(String token);

    /**
     * 刷新Token
     * @param oldToken
     * @return
     */
    String refresh(String oldToken);

    /**
     * 根據Token獲取用戶信息
     * @param token
     * @return
     */
    SystemUser getUserByToken(String token);

    /**
     *
     * 增加
     * */
    int insert(SystemUser blog);

    /**
     *
     * 編輯
     * */
    int update(SystemUser blog);

    /**
     *
     * 刪除
     * */
    int delete(int id);

}

userservice的實現類：

package com.china.great.system.service.impl;

import com.china.great.system.controller.SystemUserController;
import com.china.great.system.dao.UserMapper;
import com.china.great.system.entity.Blog;
import com.china.great.system.entity.SystemLoginUser;
import com.china.great.system.entity.SystemUser;
import com.china.great.system.service.SystemUserService;
import com.china.great.system.util.JwtUtils;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.catalina.User;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class SystemUserImpl implements SystemUserService {
    private static final Logger logger = LoggerFactory.getLogger(SystemUserImpl.class);

    @Autowired
    UserMapper systemUserDao;

    private final AuthenticationManager authenticationManager;
    private final UserDetailsService userDetailsService;
    private final JwtUtils jwtTokenUtil;

    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @Autowired
    public SystemUserImpl(AuthenticationManager authenticationManager, @Qualifier("CustomUserDetailsService") UserDetailsService userDetailsService, JwtUtils jwtTokenUtil, UserMapper authMapper) {
        this.authenticationManager = authenticationManager;
        this.userDetailsService = userDetailsService;
        this.jwtTokenUtil = jwtTokenUtil;
        this.systemUserDao = authMapper;
    }

    @Override
    public PageInfo getList(int pageSize, int pageNum) {
        PageHelper.startPage(pageNum,10);
        List<SystemUser> list = systemUserDao.getList(pageNum,pageNum);
        PageInfo pageInfo = new PageInfo(list);
        return pageInfo;
    }

    @Override
    public SystemLoginUser getUser(String username) {
        logger.debug("進入到userImpl方法");
        return systemUserDao.getUser(username);
    }

    @Override
    public String login(String username, String password) {
        //用戶驗證
        logger.debug("2=============進入到systemuserimpl的login方法，username跟password爲="+username+":"+password);
        final Authentication authentication = authenticate(username, password);
        //存儲認證信息
        SecurityContextHolder.getContext().setAuthentication(authentication);
        //生成token
        logger.info("2.1========準備生成token");
        final SystemLoginUser userDetail = (SystemLoginUser) authentication.getPrincipal();
        final String token = this.tokenHead +" "+ jwtTokenUtil.generateAccessToken(userDetail);
        //存儲token
        jwtTokenUtil.putToken(username, token);
        logger.info("7========token生成完畢，並且put完畢");
        return token;
    }

    @Override
    public void logout(String token) {

    }

    @Override
    public String refresh(String oldToken) {
        return null;
    }

    @Override
    public SystemUser getUserByToken(String token) {
        return null;
    }

    @Override
    public int insert(SystemUser user) {
        return systemUserDao.insert(user);
    }

    @Override
    public int update(SystemUser user) {
        return systemUserDao.update(user);
    }

    @Override
    public int delete(int id) {
        return systemUserDao.delete(id);
    }


    private Authentication authenticate(String username, String password) {
            //該方法會去調用userDetailsService.loadUserByUsername()去驗證用戶名和密碼，如果正確，則存儲該用戶名密碼到“security 的 context中”
            return authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password));
    }

}

集成認證的接口：

package com.china.great.system.service.impl;

import com.china.great.system.entity.SystemLoginUser;
import com.china.great.system.service.SystemRoleService;
import com.china.great.system.service.SystemUserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Component;

/**
 * 實現了DetailsService接口，用來做登陸驗證
 * 登陸身份認證
 * @author: LiuHongYang
 * createAt: 2020/5/14
 */
@Component(value="CustomUserDetailsService")
public class CustomUserDetailsServiceImpl implements UserDetailsService {
    private static final Logger logger = LoggerFactory.getLogger(SystemUserImpl.class);
   // private final UserMapper authMapper;
    @Autowired
    private SystemUserService systemUserService;
    @Autowired
    private SystemRoleService systemRoleService;
    //private final RoleMapper roleMapper;

    /*public CustomUserDetailsServiceImpl(UserMapper authMapper, RoleMapper roleMapper) {
        this.authMapper = authMapper;
        this.roleMapper = roleMapper;
    }*/

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        SystemLoginUser userDetail = systemUserService.getUser(username);
        logger.info("4================userDetail的值是："+userDetail.toString());
        if (userDetail == null) {
            throw new UsernameNotFoundException(String.format("No userDetail found with username '%s'.", username));
            //Collection<GrantedAuthority> authList = getAuthorities();
            //SystemLoginUser userDetail = new SystemLoginUser("amos","123456",authList);

        }

        /**  * 獲取用戶的角色權限,爲了降低實驗的難度，這裏去掉了根據用戶名獲取角色的步驟     * @param    * @return   */
    /*private Collection<GrantedAuthority> getAuthorities(){
        List<GrantedAuthority> authList = new ArrayList<GrantedAuthority>();
        authList.add(new SimpleGrantedAuthority("ROLE_USER"));
        authList.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
        return authList;
    }*/
       /* Role role = systemRoleService.getRole(userDetail.getId());
        userDetail.setRoles(role);*/
        return userDetail;
    }
}

CustomUserDetailsServiceImpl：

package com.china.great.system.service.impl;

import com.china.great.system.entity.SystemLoginUser;
import com.china.great.system.service.SystemRoleService;
import com.china.great.system.service.SystemUserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Component;

/**
 * 實現了DetailsService接口，用來做登陸驗證
 * 登陸身份認證
 * @author: LiuHongYang
 * createAt: 2020/5/14
 */
@Component(value="CustomUserDetailsService")
public class CustomUserDetailsServiceImpl implements UserDetailsService {
    private static final Logger logger = LoggerFactory.getLogger(SystemUserImpl.class);
   // private final UserMapper authMapper;
    @Autowired
    private SystemUserService systemUserService;
    @Autowired
    private SystemRoleService systemRoleService;
    //private final RoleMapper roleMapper;

    /*public CustomUserDetailsServiceImpl(UserMapper authMapper, RoleMapper roleMapper) {
        this.authMapper = authMapper;
        this.roleMapper = roleMapper;
    }*/

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        SystemLoginUser userDetail = systemUserService.getUser(username);
        logger.info("4================userDetail的值是："+userDetail.toString());
        if (userDetail == null) {
            throw new UsernameNotFoundException(String.format("No userDetail found with username '%s'.", username));
            //Collection<GrantedAuthority> authList = getAuthorities();
            //SystemLoginUser userDetail = new SystemLoginUser("amos","123456",authList);

        }

        /**  * 獲取用戶的角色權限,爲了降低實驗的難度，這裏去掉了根據用戶名獲取角色的步驟     * @param    * @return   */
    /*private Collection<GrantedAuthority> getAuthorities(){
        List<GrantedAuthority> authList = new ArrayList<GrantedAuthority>();
        authList.add(new SimpleGrantedAuthority("ROLE_USER"));
        authList.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
        return authList;
    }*/
       /* Role role = systemRoleService.getRole(userDetail.getId());
        userDetail.setRoles(role);*/
        return userDetail;
    }
}

jwt的工具類：

package com.china.great.system.util;

import com.china.great.system.entity.SystemLoginUser;
import com.china.great.system.entity.SystemUser;
import com.china.great.system.service.impl.SystemUserImpl;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.CompressionCodecs;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author: liuhongyang
 * createAt: 2020/5/14
 */
@Component
public class JwtUtils {
    private static final Logger logger = LoggerFactory.getLogger(SystemUserImpl.class);

    public static final String ROLE_REFRESH_TOKEN = "ROLE_REFRESH_TOKEN";

    private static final String CLAIM_KEY_USER_ID = "user_id";
    private static final String CLAIM_KEY_AUTHORITIES = "scope";

    private Map<String, String> tokenMap = new ConcurrentHashMap<>(32);

    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.expiration}")
    private Long access_token_expiration;

    @Value("${jwt.expiration}")
    private Long refresh_token_expiration;

    @Value("${jwt.header}")
    private String token_header;

    private final SignatureAlgorithm SIGNATURE_ALGORITHM = SignatureAlgorithm.HS256;

    public void getUserFromToken(String token) {
        SystemLoginUser userDetail;
        try {
            final Claims claims = getClaimsFromToken(token);
            long userId = getUserIdFromToken(token);
            String username = claims.getSubject();
            //String roleName = claims.get(CLAIM_KEY_AUTHORITIES).toString();
            //Role role = Role.builder().name(roleName).build();
            //userDetail = new SystemUser(userId, username);
        } catch (Exception e) {
            userDetail = null;
        }
       // return userDetail;
    }

    public long getUserIdFromToken(String token) {
        long userId;
        try {
            final Claims claims = getClaimsFromToken(token);
            userId = Long.parseLong(String.valueOf(claims.get(CLAIM_KEY_USER_ID)));
        } catch (Exception e) {
            userId = 0;
        }
        return userId;
    }

    public String getUsernameFromToken(String token) {
        String username;
        try {
            final Claims claims = getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    public Date getCreatedDateFromToken(String token) {
        Date created;
        try {
            final Claims claims = getClaimsFromToken(token);
            created = claims.getIssuedAt();
        } catch (Exception e) {
            created = null;
        }
        return created;
    }

    public String generateAccessToken(SystemLoginUser userDetail) {
        logger.info("5===========進入到jwtutils方法，userdetail爲，" + userDetail.toString());
        Map<String, Object> claims = generateClaims(userDetail);
        //claims.put(CLAIM_KEY_AUTHORITIES, authoritiesToArray(userDetail.getAuthorities()).get(0));
        logger.info("6===========執行完Map<String, Object> claims = generateClaims(userDetail)方法，claims，"+claims);
        return generateAccessToken(userDetail.getUsername(), claims);
    }

    public Date getExpirationDateFromToken(String token) {
        Date expiration;
        try {
            final Claims claims = getClaimsFromToken(token);
            expiration = claims.getExpiration();
        } catch (Exception e) {
            expiration = null;
        }
        return expiration;
    }

    public Boolean canTokenBeRefreshed(String token, Date lastPasswordReset) {
        final Date created = getCreatedDateFromToken(token);
        return !isCreatedBeforeLastPasswordReset(created, lastPasswordReset)
                && (!isTokenExpired(token));
    }

    public String refreshToken(String token) {
        String refreshedToken;
        try {
            final Claims claims = getClaimsFromToken(token);
            refreshedToken = generateAccessToken(claims.getSubject(), claims);
        } catch (Exception e) {
            refreshedToken = null;
        }
        return refreshedToken;
    }


    public Boolean validateToken(String token, SystemLoginUser userDetails) {
        SystemLoginUser userDetail = (SystemLoginUser) userDetails;
        final long userId = getUserIdFromToken(token);
        final String username = getUsernameFromToken(token);
//        final Date created = getCreatedDateFromToken(token);
        return (username.equals(userDetail.getUsername())
                && !isTokenExpired(token)
//                && !isCreatedBeforeLastPasswordReset(created, userDetail.getLastPasswordResetDate())
        );
    }

    public String generateRefreshToken(SystemLoginUser userDetail) {
        Map<String, Object> claims = generateClaims(userDetail);
        // 只授於更新 token 的權限
        //String roles[] = new String[]{JwtUtils.ROLE_REFRESH_TOKEN};
        //claims.put(CLAIM_KEY_AUTHORITIES, JSONUtil.toJSON(roles));
        return generateRefreshToken(userDetail.getUsername(), claims);
    }

    public void putToken(String userName, String token) {
        tokenMap.put(userName, token);
    }

    public void deleteToken(String userName) {
        tokenMap.remove(userName);
    }

    public boolean containToken(String userName, String token) {
        if(StringUtils.isNotBlank(userName) && StringUtils.isNotBlank(token)){;
            String username = tokenMap.get(userName);
            String tokenheader = this.token_header +" "+ token;
        }
        if (userName != null && tokenMap.containsKey(userName) ) {/*&& tokenMap.get(userName).equals(this.token_header +" "+ token)*/
            return true;
        }
        return false;
    }
    private Claims getClaimsFromToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            claims = null;
        }
        return claims;
    }

    private Date generateExpirationDate(long expiration) {
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }

    private Boolean isCreatedBeforeLastPasswordReset(Date created, Date lastPasswordReset) {
        return (lastPasswordReset != null && created.before(lastPasswordReset));
    }

    private Map<String, Object> generateClaims(SystemLoginUser userDetail) {
        Map<String, Object> claims = new HashMap<>(16);
        claims.put(CLAIM_KEY_USER_ID, userDetail.getId());
        return claims;
    }

    private String generateAccessToken(String subject, Map<String, Object> claims) {
        return generateToken(subject, claims, access_token_expiration);
    }

    private List authoritiesToArray(Collection<? extends GrantedAuthority> authorities) {
        List<String> list = new ArrayList<>();
        /*for (GrantedAuthority ga : authorities) {
            list.add(ga.getAuthority());
        }*/
        return list;
    }


    private String generateRefreshToken(String subject, Map<String, Object> claims) {
        return generateToken(subject, claims, refresh_token_expiration);
    }



    private String generateToken(String subject, Map<String, Object> claims, long expiration) {
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setId(UUID.randomUUID().toString())
                .setIssuedAt(new Date())
                .setExpiration(generateExpirationDate(expiration))
                .compressWith(CompressionCodecs.DEFLATE)
                .signWith(SIGNATURE_ALGORITHM, secret)
                .compact();
    }

}

mybatis的xml：

<?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.china.great.system.dao.UserMapper">

    <select id="getList" resultType="com.china.great.system.entity.SystemUser">
        SELECT su.* from system_user su
    </select>


    <select id="getUser" resultType="com.china.great.system.entity.SystemLoginUser" parameterType="java.lang.String">
        SELECT su.id,su.username,su.password from system_user su WHERE su.username = #{username}
    </select>

    <insert id="insert" parameterType="com.china.great.system.entity.SystemUser">
        insert into system_user (
            username,
            password,
            phone,
            email,
            real_name,
            create_time
        )values (
            #{username},
            #{password},
            #{phone},
            #{email},
            #{realName},
            now()
        )
    </insert>

    <update id="update" parameterType="com.china.great.system.entity.SystemUser">
        update
            system_user
        set
            username=#{username},
            phone=#{phone},
            email=#{email},
            real_name=#{realName},
            update_time=now()
         where
            id = #{id}
    </update>

    <delete id="delete" parameterType="int">
        delete from system_user where id = #{id}
    </delete>

</mapper>

最後是controller：

package com.china.great.system.controller;

import com.china.great.system.common.CommonResultUtil;
import com.china.great.system.config.RedisConfig;
import com.china.great.system.entity.Blog;
import com.china.great.system.entity.SystemLoginUser;
import com.china.great.system.entity.SystemUser;
import com.china.great.system.service.SystemUserService;
import com.github.pagehelper.PageInfo;
import io.swagger.annotations.Api;
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.*;

import java.util.List;

@RestController
@Api("用戶相關的api")
@RequestMapping("/api/v1")
public class SystemUserController {
    private static final Logger LOGGER = LoggerFactory.getLogger(SystemUserController.class);

    @Autowired
    private SystemUserService systemUserService;
    @Autowired
    private RedisConfig redisConfig;

    @RequestMapping(value = "/getlist", method = RequestMethod.GET)
    @ApiOperation(value="獲取列表")
    public Object getList(@RequestParam(value="pageSize", defaultValue="20") int pageSize,
    @RequestParam(value="pageNum", defaultValue="1") int pageNum){
        PageInfo list = systemUserService.getList(pageSize,pageNum);
        //LOGGER.info(list.toString());
        redisConfig.set("aa","bb");
        return CommonResultUtil.success(list);
    }

    @RequestMapping(value = "/getuser", method = RequestMethod.GET)
    @ApiOperation(value="獲取用戶")
    public Object getUser(){
        SystemLoginUser user = systemUserService.getUser("amos");
        LOGGER.info(user.toString());
        return CommonResultUtil.success(user);
    }

    @PostMapping(value = "/login")
    @ApiOperation(value = "登陸", notes = "登陸成功返回token,登陸之前請先註冊賬號")
    public Object login(@RequestBody SystemUser user){
        LOGGER.debug("進入到logincontroller");
        String response = systemUserService.login(user.getUsername(), user.getPassword());
        LOGGER.info("回到login的controller，response的值爲："+response);
        return CommonResultUtil.success(response);
    }


    @RequestMapping(value = "/insertUser", method = RequestMethod.POST)
    @ApiOperation(value="增加用戶")
    public Object insert(@RequestBody SystemUser blog){
        int i = systemUserService.insert(blog);
        if (i > 0){
            return CommonResultUtil.success(i);
        }
        return CommonResultUtil.err(i);
    }

    @RequestMapping(value = "/updateUser", method = RequestMethod.POST)
    @ApiOperation(value="修改用戶")
    public Object update(@RequestBody SystemUser blog){
        int i = systemUserService.update(blog);
        if (i > 0){
            return CommonResultUtil.success(i);
        }
        return CommonResultUtil.err(i);
    }

    @RequestMapping(value = "/deleteUser", method = RequestMethod.GET)
    @ApiOperation(value="刪除用戶")
    public Object delete(@RequestParam int id){
        int i = systemUserService.delete(id);
        if (i > 0){
            return CommonResultUtil.success(i);
        }
        return CommonResultUtil.err(i);
    }

}

配置文件：application-dev.properties

server.port: 8091

spring.datasource.url=jdbc:mysql://33.533.23.63:3306/amos_cloud
spring.datasource.username=root
spring.datasource.password=Admin123!
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

#ɨ��mybatis��mapper
mybatis.mapper-locations=classpath:mapper/*.xml

#����redis
spring.redis.host=111.54.22.11
spring.redis.password=22
spring.redis.port=6379
#���ӳ������������ʹ�ø�ֵ��ʾû�����ƣ�
spring.redis.pool.max-active=8
#���ӳ���������ȴ�ʱ�䣨ʹ�ø�ֵ��ʾû�����ƣ�
spring.redis.pool.max-wait=-1
#���ӳ��е�����������
spring.redis.pool.max-idle=8
#���ӳ��е���С��������
spring.redis.pool.min-idle=0
#���ӳ�ʱʱ�䣨���룩
spring.redis.timeout=30000

#��־����
logging.config=classpath:logback-spring.xml
logging.path=/root/tools/distAPI/

#swagger��������
swagger.enable=true

jwt.header: Authorization
jwt.secret: mySecret
#token有效期一天：86400(單位：秒)（後改爲30分鐘）
jwt.expiration: 1800
jwt.tokenHead: Bearer

大功告成

spring boot整合spring security以及JWT

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

free AI online tools All In One

痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU啓動那些事（12.A）- uSDHC eMMC啓動時間(RT1170)

linux安裝cuda和cudnn

Mellanox網卡開啓SR-IOV

模擬手機設備：使用 Playwright 實現移動端自動化測試

HTML 00 Tutorial

全面系統的AI學習路徑，幫助普通人也能玩轉AI

從零開始：使用 Playwright 腳本錄製實現自動化測試

uni-app實現上拉加載

spring choud中eurake的搭建

docker鏡像跟容器常用命令

spring cloud在eurake註冊一條數據

mybatis的xml中用foreach分隔逗號的寫法

centos 7修改jenkins的端口號

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結