2. 程式人生 > 其它 >SpringBoot 整合security 實現自定義Token和clientId登入及退出(一)

SpringBoot 整合security 實現自定義Token和clientId登入及退出(一)

阿新 • • 發佈：2020-12-20

技術標籤：securitytokenspring bootspringjava

1.資料庫建立
user表
在這裡插入圖片描述
user_token表
在這裡插入圖片描述

2.建立對Token和使用者資訊操作的service及實體類
話不多說，直接上程式碼
TokenInfo.java

/**
 * Token資訊
 */
public class TokenInfo {
    private Integer userId;
    private String accessToken;
    private String clientId;
    private String ip;
    private LocalDateTime updateTime;
 

    ...

userInfo

/**
 * 使用者資訊
 */
public class UserInfo {
    private String userId;
    private String username;
    private String role;
    private String realName;
    private String password;
    ...

service(實現類，介面就不寫了)
TokenServiceImpl.java

@Service
@SuppressWarnings("all")
public class
 
 TokenServiceImpl implements TokenService {

    @Autowired
    private TokenMapper tokenMapper;

    /**
     * 過期時間5分鐘
     */
    private static final long EXPIRE_TIME = 5 * 60 * 1000;

    /**
     * 加密金鑰
     */
    private static final String KEY = "demo";

    @Override
    public TokenInfo findByUserId
 
(String userId) {
        return tokenMapper.findByUserId(userId);
    }

    @Override
    public TokenInfo findByClientId(String clientId) {
        return tokenMapper.findByClientId(clientId);
    }

    @Override
    public TokenInfo createToken(UserDetailsInfo userInfo) {
        TokenInfo tokenInfo = new TokenInfo();
        Map<String, Object> header = new HashMap();
        header.put("typ", "JWT");
        header.put("alg", "HS256");
        //setID:使用者ID
        //setExpiration:token過期時間  當前時間+有效時間
        //setSubject:使用者名稱
        //setIssuedAt:token建立時間
        //signWith:加密方式
        JwtBuilder builder = Jwts.builder().setHeader(header)
            .setId(userInfo.getUserId())
            .setExpiration(new Date(System.currentTimeMillis() + EXPIRE_TIME))
            .setSubject(userInfo.getUsername())
            .setIssuedAt(new Date())
            .signWith(SignatureAlgorithm.HS256, KEY);
        tokenInfo.setAccessToken(builder.compact());
        tokenInfo.setIp(userInfo.getIp());
        tokenInfo.setUserId(Integer.valueOf(userInfo.getUserId()));
        String clientId = "";
        // 根據資料庫的使用者資訊查詢Token
        TokenInfo accesstoken = tokenMapper.findByUserId(userInfo.getUserId());
        if (accesstoken != null && equal(accesstoken.getIp(), userInfo.getIp())) {
            clientId = accesstoken.getClientId();
            tokenInfo.setClientId(clientId);
            // 更新Token資訊
            tokenMapper.updateToken(tokenInfo);
        } else {
            clientId = UUID.randomUUID().toString();
            tokenInfo.setClientId(clientId);
            // 登陸Token資訊
            tokenMapper.addToken(tokenInfo);
        }
        return tokenInfo;
    }


    @Override
    public void updateToken(TokenInfo token) {
        tokenMapper.updateToken(token);
    }

    @Override
    public void deleteToken(String clientId) {
        tokenMapper.deleteToken(clientId);
    }

    @Override
    public boolean checkToken(TokenInfo tokenInfo) {

        //根據ClientId查詢資料庫Token
        TokenInfo myToken = tokenMapper.findByClientId(tokenInfo.getClientId());
        if (myToken != null && tokenInfo.getAccessToken().
            equals(myToken.getAccessToken())) {
            Claims claims = null;
            try {
                //token過期後，會丟擲ExpiredJwtException 異常，通過這個來判定token過期，
                claims = Jwts.parser().setSigningKey(KEY).parseClaimsJws(tokenInfo.getAccessToken()).getBody();
            } catch (ExpiredJwtException e) {
                return false;
            }
            return true;
        }
        return false;
    }

}

UserServiceImpl.java

@Service
@SuppressWarnings("all")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public UserInfo findByUserId(Integer userId) {
        return userMapper.findByUserId(userId);
    }

    @Override
    public UserInfo findByUserName(String userName) {
        return userMapper.findByUserName(userName);
    }

    @Override
    public List<UserInfo> selectAll() {
        return userMapper.selectAll();
    }
}

3.工具類建立
SecurityUtils.java

/**
 * Security工具類
 */
public class SecurityUtils {

    private static final String MD5_KEY = "0123456789AbCDeF";

    /**
     * 獲取當前登入資訊
     * @return
     */
    public static Authentication getAuthentication() {
        if (SecurityContextHolder.getContext() != null) {
            return SecurityContextHolder.getContext().getAuthentication();
        }
        return null;
    }

    public static void setAuthentication(Authentication authentication) {
        if (SecurityContextHolder.getContext() != null) {
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
    }

    public static Integer getUserId() {
        Integer userId = null;
        Authentication authentication = getAuthentication();
        if (authentication != null) {
            Object principal = authentication.getPrincipal();
            if (principal != null && principal instanceof UserDetailsInfo) {
                userId = Integer.valueOf(((UserDetailsInfo) principal).getUserId());
            }
        }
        return userId;
    }
    
    public static String getUsername() {
        String userName = null;
        Authentication authentication = getAuthentication();
        if (authentication != null) {
            Object principal = authentication.getPrincipal();
            if (principal != null && principal instanceof UserDetails) {
                userName = ((UserDetails) principal).getUsername();
            }
        }
        return userName;
    }

    public static boolean hasRole(String role) {
        if (SecurityContextHolder.getContext() == null) {
            return false;
        }
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        for (GrantedAuthority grantedAuthority : authentication.getAuthorities()) {
            if (role.equals(grantedAuthority.getAuthority())) {
                return true;
            }
        }
        return false;
    }

}

ClientIdUtil.java

public class ClientIdUtil {
    /**
     * 使用者ip獲取
     * @param request
     * @return
     */
    public static String getIp(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        if (ip.equals("0:0:0:0:0:0:0:1")) {
            ip = "127.0.0.1";
        }
        return ip;
    }
}

MD5Util.java

/**
 * MD5加密
 * @author:admin
 * @date:Created at 2020/12/13
 */
public class MD5Util {
    public static String MD5(String s) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] bytes = md.digest(s.getBytes("utf-8"));
            return toHex(bytes);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private static String toHex(byte[] bytes) {
        final char[] HEX_DIGITS = "0123456789AbCDeF".toCharArray();
        StringBuilder ret = new StringBuilder(bytes.length * 2);
        for (int i = 0; i < bytes.length; i++) {
            ret.append(HEX_DIGITS[(bytes[i] >> 4) & 0x0f]);
            ret.append(HEX_DIGITS[bytes[i] & 0x0f]);
        }
        return ret.toString();
    }

    /**
     * 密碼加強版
     *
     * @param str
     * @return
     */
    public static String MD55(String str) {
        String pwd1 = MD5Util.MD5(str);
        return pwd1.substring(0, 10) + pwd1.substring(22) + pwd1.substring(10, 22);

    }
}

4.實現UserDetailsService
UserDetailsInfo.java

public class UserDetailsInfo extends User {
    private String userId;
    private String role;
    private String realName;
    private String ip;
    ...

DemoUserDetailsService.java

/**
 * 通過使用者名稱取得使用者資訊
 */
@Service
@SuppressWarnings("all")
public class DemoUserDetailsService implements UserDetailsService {
    @Autowired
    private UserService userService;
    @Override
    public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        // 取得資料庫中的使用者資訊
        UserInfo user = userService.findByUserName(userName);
        // 使用者不存在
        if (user == null) {
            throw new UsernameNotFoundException("user is not exist");
        }
        GrantedAuthority grantedAuthority = new SimpleGrantedAuthority(user.getRole());
        authorities.add(grantedAuthority);
        // 設定UserDetailsInfo使用者資訊
        UserDetailsInfo userDetails = new UserDetailsInfo(user.getUserId(),
            user.getUsername(),user.getPassword(),authorities);
        return userDetails;
    }
}

4.使用者身份驗證
DemoAuthenticationProvider.java

/**
 * 使用者身份驗證
 * @author:zhuolun.he
 * @date:Created at 2020/12/13
 */
@Component
@SuppressWarnings("all")
public class DemoAuthenticationProvider implements AuthenticationProvider {

    @Autowired
    private DemoUserDetailsService demoUserDetailsService;

    /**
     * 自定義驗證方式
     * @param authentication 認證資訊
     * @return 使用者認證資訊
     * @throws AuthenticationException
     */
    @Override
    public Authentication authenticate(Authentication authentication)
        throws AuthenticationException {
        //認證資訊取得
        String username = authentication.getName();
        String password = (String) authentication.getCredentials();

        // 獲取使用者資訊
        UserDetails user = demoUserDetailsService.loadUserByUsername(username);
        if (user ==null) {
            throw new BadCredentialsException("Username not found");
        }
        try {
            // 驗證密碼（MD5加密）
            password = MD5Util.MD5(password);
        } catch (Exception e){
            throw new BadCredentialsException("Password encode failed");
        }
        // 判斷使用者密碼是否正確
        if (!password.equals(user.getPassword())) {
            throw new BadCredentialsException("Wrong password");
        }
        // 使用者認證資訊設定
        Collection<? extends GrantedAuthority> authorities = user.getAuthorities();
        UsernamePasswordAuthenticationToken userInfo = new
            UsernamePasswordAuthenticationToken(user,password,authorities);
        userInfo.setDetails(user);
        return userInfo;
    }

    @Override
    public boolean supports(Class<?> authentication) {
        return UsernamePasswordAuthenticationToken.class.isAssignableFrom(authentication);
    }
}

5.過濾器建立
SecurityFilter.java

/**
 * 過濾器
 */
public class SecurityFilter implements Filter {

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

    @Autowired
    private TokenService tokenService;

    /**
     * 放行的url:login/logout
     */
    @Value("${spring.security.url}")
    private String[] urls;

    private static final String FILTER_APPLIED = "_spring_security_filterSecurityInterceptor_filterApplied";

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        logger.info("init in Security");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        if (request.getAttribute(FILTER_APPLIED) != null) {
            filterChain.doFilter(request, response);
            return;
        }
        request.setAttribute(FILTER_APPLIED, true);
        HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
        // url放行
        for (String doUrl : urls) {
            if (httpRequest.getRequestURI().endsWith(doUrl)) {
                filterChain.doFilter(request, response);
                return;
            }
        }
        // 使用者資訊過濾
        Object userInfo = SecurityUtils.getAuthentication().getPrincipal();
        if (userInfo == null || !(userInfo instanceof UserDetailsInfo)) {
            response.setContentType("application/json;charset=UTF-8");
            ResultData data = new ResultData(0,"Security authentication invalid");
            response.getWriter().write((new Gson()).toJson(data));
            return;
        }
        // clientId和accessToken取得
        String clientId = httpRequest.getHeader("clientId");
        String accessToken = httpRequest.getHeader("accessToken");
        TokenInfo tokenInfo = new TokenInfo();
        tokenInfo.setClientId(clientId);
        tokenInfo.setAccessToken(accessToken);
        // 對Token驗證過濾
        if (!tokenService.checkToken(tokenInfo)) {
            response.setContentType("application/json;charset=UTF-8");
            ResultData data = new ResultData(0,"Security authentication invalid");
            response.getWriter().write((new Gson()).toJson(data));
            return;
        }
        filterChain.doFilter(request, response);
    }
    
    @Override
    public void destroy() {}
}

相關推薦

SpringBoot 整合security 實現自定義Token和clientId登入及退出(一)

技術標籤：securitytokenspring bootspringjava 1.資料庫建立 user表user_token表 2.建立對Token和使用者資訊操作的service及實體類 話不多說，直接上程式碼 TokenInfo.java

springboot~security中自定義forbidden和unauthorized返回值

對於spring-security來說，當你訪問一個受保護資源時，需要檢查你的token，當沒有傳遞，或者傳遞的token有錯誤時，將出現401unauthorized異常；當你傳遞的token是有效的，但解析後並沒有訪問這個資源的許可權時，將返

Android實現自定義手勢和識別手勢的功能

1. 先完成自定義手勢的Activity 1.1 因為需要儲存手勢檔案所以需要宣告許可權：

淺析SpringBoot整合Jackson如何自定義配置

　　承接上一篇：SpringSecurity登入報錯403問題：com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field異常，繼續研究下 Jackson。

SpringBoot整合MarkDown實現圖片上傳和回顯

SpringBoot整合MarkDown實現檔案上傳和回顯（採用先上傳後回顯）. application.yml檔案中進行如下配置

在springboot程式中jackson自定義註解和欄位解析器

一、需求提出和兩種解決方案 最近有個需求，需要在springboot程式中在返回給前端json串的時候將部分欄位加密。在之前的一篇文章中，曾經說過對整個請求體進行加密的方法，可以使用spring擴充套件的引數解析器做處理

springboot整合security實現許可權控制

1.建表，五張表，如下：1.1.使用者表CREATE TABLE `t_sys_user` (`user_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT \'使用者ID\',`user_name` varchar(30) NOT NULL COMMENT \'使用者名稱\',`user_password` v

Flink例項（二十）：自定義時間和視窗的操作符（一）KeyedProcessFunction（一）

前言 　　在Flink中比如某些運算元（join,coGroup,keyBy,groupBy）要求在資料元上定義key。另外有些運算元操作，例如reduce，groupReduce，Aggregate，Windows需要資料在處理之前根據key進行分組。

springboot使用jira-rest-java-client-api整合jira，自定義對查詢board和sprint的支援

公司內部使用jira作專案管理，我接到新的需求，要在測試報告上獲取jira的所有專案，再根據專案獲取board看板，再根據看板獲取Sprint，最後獲取未完成的bug資訊。效果如下：

基於SpringBoot整合oauth2實現token認證

這篇文章主要介紹了基於SpringBoot整合oauth2實現token 認證,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

SpringBoot整合JWT實現token驗證的流程

JWT官網： https://jwt.io/ JWT(Java版)的github地址:https://github.com/jwtk/jjwt 什麼是JWT Json web token (JWT),是為了在網路應用環境間傳遞宣告而執行的一種基於JSON的開放標準（(RFC 7519).定義了一種簡潔的，

vue自定義標籤和單頁面多路由的實現程式碼

1. 自定義元件標籤（如在主頁插入頂欄/側邊欄等）   比如說要將Header.vue插入Home.vue中顯示：定義好Header.vue，然後在Home.vue的script中匯入Header.vue：

Java kafka如何實現自定義分割槽類和攔截器

生產者傳送到對應的分割槽有以下幾種方式： （1）指定了patition，則直接使用；(可以查閱對應的java api,有多種引數)

SpringBoot2.3整合redis快取自定義序列化的實現

1.引言 我們使用redis作為快取中介軟體時，當我們第一次查詢資料的時候，是去資料庫查詢，然後查到的資料封裝到實體類中，實體類會被序列化存入快取中，當第二次查資料時，會直接去快取中查詢被序列化的資料，然後反

Vue | 自定義指令和動態路由實現許可權控制

功能概述： 根據後端返回介面，實現路由動態顯示 實現按鈕（HTML元素）級別許可權控制

vue自定義指令和動態路由實現許可權控制

功能概述： 根據後端返回介面，實現路由動態顯示 實現按鈕（HTML元素）級別許可權控制

Springboot如何實現自定義異常資料

一、原始碼分析 自定義異常資料之前我們先看看一下原始碼 上述程式碼意思是如果你沒有提供就使用springboot提供的類

SpringBoot快速整合jxls-poi(自定義模板,支援本地檔案匯出,線上檔案匯出)

在專案持續整合的過程中，有時候需要實現報表匯出和文件匯出，類似於excel中這種文件的匯出，在要求不高的情況下，有人可能會考慮直接匯出csv檔案來簡化匯出過程。但是匯出xlsx檔案，其實過程相對更復雜。解決方案就

SpringBoot自動配置之自定義starter的實現程式碼

前言：前面已經介紹了自動配置的很多原理，現在我們著手自己定義一個starter。

自定義token生成器，包含生成和驗證

1. 結合XOR的特性，思考能否自己寫一個TOKEN驗證工具。模仿了JavaWebToken 的三段方式。