Springboot+MybatisPlus+Spring-security-Jwt Api接口实现权限认证实战

最新推荐文章于 2024-08-01 09:55:35 发布
最新推荐文章于 2024-08-01 09:55:35 发布
阅读量3.3k 收藏 17
点赞数 5
分类专栏： mybatisPlus Springboot系列 文章标签： springboot springSercurity mybatisPlus spring jwt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42178134/article/details/97393873
版权

一.前言吐槽

刚开始学习，网上找了很多例子，可能我比较小白，踩了很多坑，不知道为什么有些大佬，都不屑于测试下的，直接丢仓库了，下载很多都是跑不起来的。看得我一脸懵逼的。好啦不吐槽了，记录下自己学习的东东，开始自己的表演！

二.代码

**2.1源码地址：**https://github.com/myjsonman/spring-security-kavy.git

2.2代码结构目录：
在这里插入图片描述

2.3 在IDEA 创建一个简单的Maven 工程添加pom对应的依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-security</artifactId>
            <version>2.0.0.RELEASE</version>
        </dependency>
        <!--  加密的  -->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-crypto</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>
	<!--  JWT  -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- mybatisplus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>net.minidev</groupId>
            <artifactId>json-smart</artifactId>
            <version>2.3</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.noggit</groupId>
            <artifactId>noggit</artifactId>
            <version>0.6</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>

核心依赖：

security：

 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-security</artifactId>
            <version>2.0.0.RELEASE</version>
        </dependency>

JWt：

  <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

2.4 简单的表设计：
设计有点粗超，见谅。

权限表：
CREATE TABLE `user_roles` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) DEFAULT NULL,
  `role_id` int(11) DEFAULT NULL,
  `role_str` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=18 DEFAULT CHARSET=utf8;

用户表：
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `user_img` varchar(255) DEFAULT NULL,
  `updatetime` timestamp NULL DEFAULT NULL,
  `status` char(1) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=20 DEFAULT CHARSET=utf8;

角色表：
CREATE TABLE `role` (
  `id` int(50) NOT NULL AUTO_INCREMENT,
  `role_name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `updatetime` timestamp NULL DEFAULT NULL,
  `role_desc` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

在这里写下项目的流程:

1.创建一个springboot项目
2.导入springSecurity和jwt 依赖
3.创建实体类
4.创建service层
5.创建mapper层
6.创建UserDetail去实现UserDetails
7.创建JwtUserDetailsServiceImpl去实现UserDetailsService
8.创建用户登录获取权限的拦截器
9.配置config 处理拦截器
10.jwt的工具类生成token

开始Spring boot的一个简单API

2.5 实体

@Data
public class Role {

    private Integer id;

    private String roleName;

    private Timestamp updatetime;

    private String roleDesc;

}

@Data
public class User implements Serializable {

    private Integer id;
    
    @NotBlank(message = "用户名不能为空")
    @Size(min=5, max=20,message = "用户名不能小于5位，大于20位")
    private String username;

    @NotBlank(message = "密码不能为空")
    @Size(min=6,max = 20,message = "密码不能小于6位,大于20位")
    private String password;

    private String userImg;

    private Date updatetime;

    private String status;
}

@Data
public class UserRoles {
    private  Integer id;
    private  Integer userId;
    private  Integer roleId;
    private String roleStr;

}

2.6 service:


public interface UserService {

    /**
     * 注册用户
     * @return
     */
    void register(User user,String str);


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

}

2.7 实现类

package com.kavy.springsecuritydemo.service.serviceImp;

import com.kavy.springsecuritydemo.entity.User;
import com.kavy.springsecuritydemo.entity.UserDetail;
import com.kavy.springsecuritydemo.entity.UserRoles;
import com.kavy.springsecuritydemo.exception.CustomException;
import com.kavy.springsecuritydemo.mapper.UserMapper;
import com.kavy.springsecuritydemo.mapper.UserRolesMapper;
import com.kavy.springsecuritydemo.result.ResultCode;
import com.kavy.springsecuritydemo.result.ResultJson;
import com.kavy.springsecuritydemo.service.UserService;
import com.kavy.springsecuritydemo.utils.JwtUtils;
import com.kavy.springsecuritydemo.utils.ResponseUserToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.DisabledException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.apache.commons.lang.StringUtils;


import java.util.Date;
@Service
public class UserServiceImp implements UserService {

    @Autowired
    UserMapper userMapper;
    @Autowired
    private UserRolesMapper userRolesMapper;
    @Autowired
    private JwtUtils jwtUtils;

    @Autowired
    private AuthenticationManager authenticationManager;


    @Override
    public void register(User user,String str) {

        //查询用户
        User oldUser = userMapper.findByUsername(user.getUsername());

        if (oldUser != null) {

           throw new CustomException(ResultJson.failure(ResultCode.BAD_REQUEST, "用户已存在"));
        }
        //加密
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
        user.setPassword(encoder.encode(user.getPassword()));
        user.setUpdatetime(new Date(System.currentTimeMillis()));
        user.setStatus("0");
        userMapper.insert(user);

        if (StringUtils.isNotBlank(str)){
            //权限插入
            String[] roles = str.split(",");
            for (String role : roles) {
                //如果原先有绑定权限就删除
               // userRolesMapper.deleteById(user.getId());

                UserRoles userRoles = new UserRoles();
                userRoles.setUserId(user.getId());
                userRoles.setRoleId(Integer.parseInt(role));
                userRoles.setRoleStr(str);
                userRolesMapper.insert(userRoles);
            }
        }

    }

    @Override
    public ResponseUserToken login(String username, String password) {
        //用户验证
        final Authentication authentication = authenticate(username, password);
        //存储认证信息
        SecurityContextHolder.getContext().setAuthentication(authentication);
        //生成token ，查看源代码会发现调用getPrincipal()方法会返回一个实现了`UserDetails`接口的对象
        final UserDetail userDetail = (UserDetail) authentication.getPrincipal();

        //通过工具类生成token
         final String token = "Bearer "+jwtUtils.generateAccessToken(userDetail);

        //存储token
        jwtUtils.putToken(username, token);
        // 学习 测试用,把用户的信息也返回了
        return new ResponseUserToken(token, userDetail);
    }


    private Authentication authenticate(String username, String password) {
        try {
            //该方法会去调用userDetailsService.loadUserByUsername()去验证用户名和密码，如果正确，则存储该用户名密码到“security 的 context中”
            return authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password));
        } catch (DisabledException | BadCredentialsException e) {
            throw new CustomException(ResultJson.failure(ResultCode.LOGIN_ERROR, e.getMessage()));
        }
    }
}

2.8 Mapper
注：说是MybatisPlus 其实就是保存数据的时候用了,不过我已经整合好了,大家Mybatis 和Plus 两个可以无缝切换使用 。 BaseMapper<> 这个是MybatisPlus 的写法;

RoleMapper:

package com.kavy.springsecuritydemo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.kavy.springsecuritydemo.entity.Role;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;


public interface RoleMapper extends BaseMapper<Role> {

    /**
     * 创建用户角色
     * @param userId
     * @param roleId
     * @return
     */
    int insertRole(long userId, long roleId);

    /**
     * 根据角色id查找角色
     * @param roleId
     * @return
     */
    Role findRoleById(long roleId);

    /**
     * 根据用户id查找该用户角色
     * @param userId
     * @return
     */
    List<Role> findRoleByUserId(@Param("userId") Integer userId);
}

UserMapper:

@Mapper
public interface UserMapper extends BaseMapper<User> {

    User findByUsername(String username);


}

UserRolesMapper：

public interface UserRolesMapper extends BaseMapper<UserRoles> {
}

roleMapper.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.kavy.springsecuritydemo.mapper.RoleMapper">



    <insert id="insertRole">
        insert into user_roles (user_id, role_id) VALUES (#{userId}, #{roleId});
    </insert>


    <select id="findRoleById" resultType="Role">
      select id, role_name, role_desc from role where id = #{roleId}
    </select>

    <select id="findByUsername" parameterType="String" resultType="User">
    SELECT id, username, password from user where username = #{username};
    </select>
    <select id="findRoleByUserId" resultType="Role">
        select * from role where id in (SELECT role_id from user_roles where user_id = #{userId});
    </select>


</mapper>

userMapper.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.kavy.springsecuritydemo.mapper.UserMapper">


    <insert id="insert" parameterType="User" useGeneratedKeys="true" keyProperty="id">
        insert into user (username, password,updatetime,status) VALUES (#{username}, #{password},#{updatetime},#{status});
    </insert>
    <select id="findByUsername" parameterType="String" resultType="User">
    SELECT id, username, password from user where username = #{username};
    </select>

    <select id="queryByUsername" parameterType="String" resultType="User">
    SELECT id, username, password from user where username = #{username};
    </select>


</mapper>

Controller:

package com.kavy.springsecuritydemo.controller;

import com.kavy.springsecuritydemo.entity.User;
import com.kavy.springsecuritydemo.result.ResultCode;
import com.kavy.springsecuritydemo.result.ResultJson;
import com.kavy.springsecuritydemo.service.UserService;
import com.kavy.springsecuritydemo.utils.ResponseUserToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;


@RestController
@RequestMapping("/api")
public class UserController {

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

    @Autowired
    UserService userService;

    @GetMapping("/hello")
    public String hello(){

        return "hi security!";
    }

    /**
     * 注册
     * @param user
     */
    @PostMapping("/register")
    public ResultJson signUp( User user ,String str) {
        if (user==null){
            ResultJson.failure(ResultCode.BAD_REQUEST);
        }
        userService.register(user,str);

         return ResultJson.success();

    }

    /**
     * 获取token
     * @param user
     * @return
     */
    @PostMapping("/login")
    public ResultJson<ResponseUserToken> login(@RequestBody User user) {

        final ResponseUserToken response = userService.login(user.getUsername(), user.getPassword());
        return ResultJson.ok(response);
    }



}

标题党

卧槽 发现贴得有点啰嗦，Security 和JWT呢。别急大佬，别喷，马上=。=上代码

网咯配图（咱也画不出来，也不敢问，都是围观大佬的）：

在这里插入图片描述
1.开始整合JWT认证

创建一个JwtUserDetailsServiceImpl 去实现 UserDetailsService接口，UserDetailsService接口就一个方法 loadUserByUsername（）

package com.kavy.springsecuritydemo.service.serviceImp;

import com.kavy.springsecuritydemo.entity.Role;
import com.kavy.springsecuritydemo.entity.User;
import com.kavy.springsecuritydemo.entity.UserDetail;
import com.kavy.springsecuritydemo.mapper.RoleMapper;
import com.kavy.springsecuritydemo.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.authority.AuthorityUtils;
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.crypto.password.PasswordEncoder;

import java.util.List;

@Configuration
public class JwtUserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private PasswordEncoder passwordEncoder;
    @Autowired
   private UserMapper userMapper;
    @Autowired
    private RoleMapper roleMapper;
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

            User user = userMapper.findByUsername(username);
            if (user == null) {
                throw new UsernameNotFoundException(String.format("No userDetail found with username '%s'.", username));
            }
            //查询权限封装
        List<Role> roleByUserId = roleMapper.findRoleByUserId(user.getId());

        return new UserDetail(user.getUsername(),roleByUserId,user.getPassword());

}


}

再创建UserDetail 去实现UserDetails 接口，JWT通过这个接口去获取用户密码和权限

package com.kavy.springsecuritydemo.entity;

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
@Data
public class UserDetail implements UserDetails {

    private long id;
    private String username;
    private String password;
    private List<Role> roles;
    //private Collection<? extends GrantedAuthority> authorities;

    public UserDetail(
            String username,
            List<Role> roles,
            String password) {
        this.username = username;
        this.password = password;
        this.roles = roles;
    }
    //getAuthorities获取用户包含的权限，返回权限集合，权限是一个继承了GrantedAuthority的对象；
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        // 根据自定义逻辑来返回用户权限，如果用户权限返回空或者和拦截路径对应权限不同，验证不通过
        if (!roles.isEmpty()){

            List<GrantedAuthority> authorities = new ArrayList<>();
            for (Role role : roles) {
                authorities.add(new SimpleGrantedAuthority(role.getRoleName()));
            }
            return authorities;
        }
        return null;
    }

    //getPassword和getUsername用于获取密码和用户名；
    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }

    //isAccountNonExpired方法返回boolean类型，用于判断账户是否未过期，未过期返回true反之返回false；
    @JsonIgnore
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
    //isAccountNonLocked方法用于判断账户是否未锁定；
    @JsonIgnore
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }
    //isCredentialsNonExpired用于判断用户凭证是否没过期，即密码是否未过期；
    @JsonIgnore
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    //isEnabled方法用于判断用户是否可用。
    @JsonIgnore
    @Override
    public boolean isEnabled() {
        return true;
    }
}

拦截器filter

package com.kavy.springsecuritydemo.filter;

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

import com.kavy.springsecuritydemo.service.serviceImp.JwtUserDetailsServiceImpl;
import com.kavy.springsecuritydemo.utils.JwtUtils;
import org.apache.commons.lang.StringUtils;
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.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import io.jsonwebtoken.ExpiredJwtException;

@Component
public class JwtRequestFilter extends OncePerRequestFilter {
	@Autowired
	private JwtUserDetailsServiceImpl jwtUserDetailsService;
	
	@Autowired
	private JwtUtils jwtTokenUtil;
	

	
	@Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
			throws ServletException, IOException {
		//获取header 的Authorization
		final String requestTokenHeader = request.getHeader("Authorization");
		String username = null;
		String jwtToken = null;
		// JWT报文表头的格式是"Bearer token". 去除"Bearer ",直接获取token
		// only the Token
		if (StringUtils.isNotEmpty(requestTokenHeader) && requestTokenHeader.startsWith("Bearer ")) {
			jwtToken = requestTokenHeader.substring(7);
			try {
				//获取username
				username = jwtTokenUtil.getUsernameFromToken(jwtToken);
			} catch (IllegalArgumentException e) {
				System.out.println("Unable to get JWT Token");
			} catch (ExpiredJwtException e) {
				System.out.println("JWT Token has expired");
			}
		} else {
			logger.warn("JWT Token does not begin with Bearer String");
		}
		// Once we get the token validate it.
		if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
			//获取 userDetails
			UserDetails userDetails = this.jwtUserDetailsService.loadUserByUsername(username);
			// if token is valid configure Spring Security to manually set
			// authentication
			if (jwtTokenUtil.validateToken(jwtToken, userDetails)) {
				UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
						userDetails, null, userDetails.getAuthorities());
				usernamePasswordAuthenticationToken
				.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

				SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
			}
		}
		chain.doFilter(request, response);
	}
}

错误返回：

package com.kavy.springsecuritydemo.filter;

import java.io.IOException;
import java.io.Serializable;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

/**
 * 用来解决匿名用户访问无权限资源时的异常
 */
@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint, Serializable {
	private static final long serialVersionUID = 1L;

	@Override
	public void commence(HttpServletRequest request, HttpServletResponse response,
			AuthenticationException authException) throws IOException {
		response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");
	}
}

核心配置config：

package com.kavy.springsecuritydemo.config;

import com.kavy.springsecuritydemo.filter.JwtAuthenticationEntryPoint;
import com.kavy.springsecuritydemo.filter.JwtRequestFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
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.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.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

/**
 * @EnableWebSecurity注解继承WebSecurityConfigurerAdapter的类，这样就构成了Spring Security的配置。
 *
 */

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    private UserDetailsService userDetailsService;
    private BCryptPasswordEncoder bCryptPasswordEncoder;
    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    public WebSecurityConfig(UserDetailsService userDetailsService, BCryptPasswordEncoder bCryptPasswordEncoder) {
        this.userDetailsService = userDetailsService;
        this.bCryptPasswordEncoder = bCryptPasswordEncoder;
    }


        @Autowired
        private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        // We don't need CSRF for this example
        httpSecurity.csrf().disable()
                //用来解决匿名用户访问无权限资源时的异常
                .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint).and().sessionManagement()
                //禁用session 无状态
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                // dont authenticate this particular request
                .and()
                .authorizeRequests()
                //注册 register 和登录 login 不需要验证 就可以访问，其他的都需要token验证才可以访问
                .antMatchers(HttpMethod.POST, "/api/login", "/api/register", "/error/**").permitAll()
                .anyRequest().authenticated()
                .and()
                .addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);

        // disable page caching
        httpSecurity
                .headers()
                .frameOptions().sameOrigin()  // required to set for H2 else H2 Console will be blank.
                .cacheControl();
    }

    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder);

    }

/*    @Override
    protected void configure(HttpSecurity http) throws Exception {
         http.formLogin() // 表单方式
      //  http.httpBasic() // HTTP Basic方式
                .loginPage("/login.html")   //.loginPage("/login.html")指定了跳转到登录页面的请求URL
                .loginProcessingUrl("/login") //.loginProcessingUrl("/login")对应登录页面form表单的action="/login"
                .and()
                .authorizeRequests() // 授权配置
                .antMatchers("/login.html").permitAll()   // 表示跳转到登录页面的请求不被拦截，否则会进入无限循环。
                .anyRequest()  // 所有请求
                .authenticated() // 都需要认证
                .and().csrf().disable();
    }*/



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


}

JWT的工具类：
用来生成token的

package com.kavy.springsecuritydemo.utils;

import com.kavy.springsecuritydemo.entity.UserDetail;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.CompressionCodecs;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
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;


@Component
public class JwtUtils {

    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;

    private final SignatureAlgorithm SIGNATURE_ALGORITHM = SignatureAlgorithm.HS256;


    //获取token
    public String generateAccessToken(UserDetail userDetail) {
        Map<String, Object> claims = generateClaims(userDetail);
        claims.put(CLAIM_KEY_AUTHORITIES, authoritiesToArray(userDetail.getAuthorities()).get(0));
        return generateAccessToken(userDetail.getUsername(), claims);
    }

    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = getUsernameFromToken(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }


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


    /**
     * 生成token的过期时间
     * @return
     */
    private Date generateExpirationDate(long expiration) {
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

    /**
     * 从token中获取claims
     *
     **/
    public Claims getClaimsFromToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            claims = null;
        }
        return claims;
    }

    /**
     *  获取用户名
     * @param token
     * @return
     */
    public String getUsernameFromToken(String token) {
        String username;
        try {
            final Claims claims = getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }
    /**
     *  获取token 过期时间
     * @param token
     * @return
     */
    public Date getExpirationDateFromToken(String token) {
        Date expiration;
        try {
            final Claims claims = getClaimsFromToken(token);
            expiration = claims.getExpiration();
        } catch (Exception e) {
            expiration = null;
        }
        return expiration;
    }

    /**
     *     判断token 是否过期
     * @param token
     * @return
     */
    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }

    /**
     *  判断token是否可以刷新
     * @param token
     * @return
     */
    public Boolean canTokenBeRefreshed(String token) {
        final Date created = getCreatedDateFromToken(token);
        return !isTokenExpired(token);
    }

    /**
     * 从token中获取创建时间
     * @param token
     * @return
     */
    public Date getCreatedDateFromToken(String token) {
        Date created;
        try {
            final Claims claims = getClaimsFromToken(token);
            created = claims.getIssuedAt();
        } catch (Exception e) {
            created = null;
        }
        return created;
    }
    /**
     *   刷新token
     * @param token
     * @return
     */

    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;
    }


    /**
     *  claims
     * @param userDetail
     * @return
     */
    private Map<String, Object> generateClaims(UserDetail userDetail) {
        Map<String, Object> claims = new HashMap<>(16);
        claims.put(CLAIM_KEY_USER_ID, userDetail.getId());
        System.out.println("userDetail.getId()--------->>>"+userDetail.getId());
        System.out.println("userDetail--->"+userDetail.toString());
        return claims;
    }

    // 传入 username 过期时间 claims 获取token
    private String generateAccessToken(String subject, Map<String, Object> claims) {
        // subject  --->userDetail.getUsername()  access_token_expiration过期时间
        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;
    }



    /**
     *      生成token
     * @param subject
     * @param claims
     * @param expiration
     * @return
     */
    private String generateToken(String subject, Map<String, Object> claims, long expiration) {
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject) //username  设置面向用户
               // .setId(UUID.randomUUID().toString())
                .setIssuedAt(new Date())  //签发时间
                .setExpiration(generateExpirationDate(expiration)) //生成token的过期时间
                .compressWith(CompressionCodecs.DEFLATE)
                .signWith(SIGNATURE_ALGORITHM, secret)  //SignatureAlgorithm.HS512, secret 生成签名
                .compact();
    }

}

整个Security就完成了，在此我只做了注册和获取token的两个，嗯，还有一些返回的封装和错误码返回处理，没有贴出来，具体可以去看下源码，其他的可以根据自己需求写了；

测试：
没有获取到token,所以会报错
在这里插入图片描述
注册：
在这里插入图片描述

注册成功，通过注册的用户和密码获取token
在这里插入图片描述

通过获取到的token，再次访问hello接口
在这里插入图片描述

特别卷.
关注
专栏目录
springboot+security+mybatis+redis+jwt，鉴权框架搭建
06-22
本项目集成了springboot+security+mybatis+redis+jwt用于学习security鉴权功能，其中有集成了redis，mybatis，jasypt，jwt，thymeleaf，knife4j，mybatis-plus 项目搭建已经比较成熟，能够直接进行使用，通过代码可以学习security的权限配置，菜单权限，注解权限等 有学习SPI机制的学习
SpringBoot+Shiro+JWT+Mybatis-Plus搭建admin-shiro管理系统
热门推荐
qq_45660133的博客
12-30 1万+
从零开始搭建一个项目骨架，最好选择合适，熟悉的技术，并且在未来易拓展，适合微服务化体系等。所以一般以Springboot作为我们的框架基础，这是离不开的了。 然后数据层，我们常用的是Mybatis，易上手，方便维护。但是单表操作比较困难，特别是添加字段或减少字段的时候，比较繁琐，所以这里我推荐使用Mybatis Plus，（为简化开发而生，只需简单配置，即可快速进行) CRUD 操作，从而节省大量时间。 作为一个项目骨架，权限也是我们不能忽略的，Apache Shiro 是一款强大易用的 Java 安全框架
Java开发者LLM实战——使用LangChain4j构建本地RAG系统.markdown-body pre,.markdown-body pre＞code.hljs{color:#333；backg
最新发布
2401_85377976的博客
08-01 926
RAG（Retrieval-Augmented Generation）的核心思想是：将传统的信息检索（IR）技术与现代的生成式大模型（如chatGPT）结合起来。具体来说，RAG模型在生成答案之前，会首先从一个大型的文档库或知识库中检索到若干条相关的文档片段。再将这些检索到的片段作为额外的上下文信息，输入到生成模型中，从而生成更为准确和信息丰富的文本。RAG的工作原理可以分为以下几个步骤：1.接收请求：首先，系统接收到用户的请求（例如提出一个问题）。2.信息****检索（R)
Springboot + SpringSecurity + mybatis + mysql实现JWT验证&授权
seegirlshere的博客
06-21 266
1.重写WebSecurityConfigurerAdapter的configure(HttpSecurity http)方法 2.
2021-03-17 学习笔记：springboot+springsecurity+mybatis+JWT+Redis 
okludawei的博客
03-17 635
springboot+springsecurity+mybatis+JWT+Redis 目录 一、springboot 1.新建项目 2.application.yml的配置 3.写一个小demo 二、druid 三、springsecurity 1.依赖 2.工具类 3.实现springsecurity 4.权限访问控制 5 .jwt生成token的工具类6.springsecurity核心 一、springboot 1.新建项目 使用...
SpringBoot+SpringSecurity+MybatisPlus+JWT
weixin_43695820的博客
01-13 1144
SpringBoot+SpringSecurity+MybatisPlus+JWT
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证
08-26
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证，可根据注解的格式不同，做到角色权限控制，角色加资源权限控制等，粒度比较细化。 @PreAuthorize("hasAnyRole('ADMIN','USER')")：具有admin或...
springboot+security+jwt+mybaits-plus+mysql实现权限管理
03-13
通过Spring Boot的便捷性，Spring Security的安全性，JWT的无状态认证，MyBatis-Plus的高效数据操作，以及MySQL的稳定存储，实现了用户登录、角色分配、权限验证等功能，为开发人员提供了一个可参考的权限管理解决...
通用权限管理系统+springboot+mybatis plus+spring security+jwt+redis+mysql
05-30
后端使用SpringBoot框架进行业务逻辑开发，利用Spring Security实现权限控制。数据库采用MySQL进行数据存储，使用MyBatis进行数据访问。 权限控制模块设计包括用户、角色和权限三个主要模块。用户模块用于管理用户...
基于SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端商城系统源码
05-13
yshop基于当前流行技术组合的前后端分离商城系统： SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含分类、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、...
SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统
04-30
基于当前流行技术组合的前后端分离商城系统：SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含商城、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、优惠券...
SpringBoot+MyBatis-plus+SpringSecurity+JWT 验证码认证
zhouzhiwengang的专栏
01-13 1204
本文基于SpringBoot+MyBatis-plus+SpringSecurity+JWT 登入认证，实现前后端分离基础之上追加验证码登入认证功能。 1、springsecurity 验证码模式核心代码 创建验证码过滤器 在filter中增加VerificationCodeLoginFilter。这里过滤的是”/auth/code”的请求，用不同的请求地址来区分不同的登录认证方式。 package com.digipower.sercurity.filter; import java.io.I
Springboot + Spring Security +JWT + mybatis plus 实现前后端分离登录认证及权限控制
秋收的麦穗的博客
11-22 2897
前言: 参考文章: Springboot + Spring Security 实现前后端分离登录认证及权限控制 springboot+Spring-Security+JWT 实现用户登录和权限认证 项目主要代码来源于参考的第一篇文章,jwt来源于第二篇 改变: 将第一篇文章的项目改成我熟悉的无xml文件模式 将第二篇文章的jwt加入第一篇文章代码 代码部分修改… 项目结构 一.基于权限控制 编写controller接口 a.管理员资源接口,需要有管理员相关权限或角色才可以访问 /** * @
【Spring Cloud & Alibaba 实战 | 总结篇】Spring Cloud Gateway + Spring Security OAuth2 + JWT 实现微服务统一认证授权和鉴权，
竹林幽深
10-08 5649
https://blog.51cto.com/u_12386660/4903587
SpringBoot 整合 Spring Security 、JWT 实现认证、权限控制
z1259678404的博客
02-16 1456
引入依赖包（gradle） maven 请自行转换 dependencies { compile group: 'io.jsonwebtoken', name: 'jjwt', version: '0.9.1' implementation 'org.springframework.boot:spring-boot-starter-security' implementation 'org.springframework.boot:spring-boot-starte...
Spring Boot整合Spring Security（九）简单的鉴权
时雨吹雪的博客
02-12 646
使用Spring Security 6.0进行权限校验
Spring+Security+JWT+MyBatisPlus
白玉梁的专栏
09-17 1260
数据库： Sql： create table jwttest.permissions ( id int auto_increment primary key, path varchar(255) null, role_ids varchar(255) default '1' null, description varchar(255) null ); create t.
Spring Boot+Spring Security+JWT实现系统认证与授权
Cloud-Future的博客
08-03 3009
Spring Boot+Spring Security+JWT实现系统认证与授权 Spring Boot整合Spring Security实现JWT认证 Spring Boot项目使用JWT认证 JWT认证 OAuth2 JWT认证
Spring Cloud Alibaba+Spring Boot+Mybatis+Spring Security Oauth2实现数据中台+多租户saas企业分布式微服务开发架构
m0_65038841的博客
12-09 4377
基于Spring Cloud Alibaba 分布式微服务高并发数据平台化(中台)思想+多租户saas设计的企业开发架构，支持源码二次开发、支持其他业务系统集成、集中式应用权限管理、支持拓展其他任意子项目 一、架构技术选型 序号 场景 框架 备注 1 核心框架 Spring Boot 2 SOA Spring Cloud 3 安全框架 Spring Security Oauth2 4 注册中心/配置中心 Nacos ...
springboot + mybatisplus + redis + driver +knife4j + swagger + jwt + springSecurity
02-08
Spring Boot是一个用于创建独立的、基于生产级别的Spring应用程序的框架。它简化了Spring应用程序的配置和部署过程，提供了一种快速开发的方式。 MyBatis Plus是MyBatis的增强工具，它提供了更简单、更便捷的方式来操作数据库。它封装了常用的CRUD操作，提供了更高效的查询方式，并且支持代码生成。 Redis是一个开源的内存数据库，它提供了高性能的键值存储功能。在Spring Boot中，可以使用Redis作为缓存、消息队列等功能的支持。 Driver是指数据库驱动程序，它是连接Java应用程序与数据库之间的桥梁。在Spring Boot中，可以选择不同的数据库驱动程序来连接不同的数据库。 Knife4j是一款基于Swagger的API文档生成工具，它提供了更加美观、易用的界面来展示API文档，并且支持在线调试API接口。 Swagger是一款流行的API文档生成工具，它可以根据代码注解自动生成API文档，并且提供了一套强大的工具来测试和调试API接口。 JWT（JSON Web Token）是一种用于身份验证和授权的开放标准。在Spring Boot中，可以使用JWT来生成和验证身份令牌，实现无状态的身份验证。 Spring Security是Spring提供的安全框架，它可以用于保护Web应用程序的安全性。在Spring Boot中，可以使用Spring Security来实现用户认证、授权等功能。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值