springboot+springsecurity+JWT

最新推荐文章于 2024-05-04 03:06:18 发布
最新推荐文章于 2024-05-04 03:06:18 发布
阅读量828 收藏 3
点赞数
分类专栏： Sprng Security 文章标签： java spring jwt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45498999/article/details/105973865
版权

springboot+springsecurity+JWT

目录结构：
在这里插入图片描述
springbootApplication里面的配置，如有需要可以自行添加
在这里插入图片描述
实现JWT功能

在pom.xml中的配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
    </parent>

    <groupId>com.my</groupId>
    <artifactId>my-springsecurity</artifactId>
    <version>1.0-SNAPSHOT</version>


    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>2.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- oracle数据库驱动 -->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.3</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>5.0.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>5.0.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.30</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- &lt;!&ndash; 资源文件拷贝插件 &ndash;&gt;
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-resources-plugin</artifactId>
                 <configuration>
                     <encoding>UTF-8</encoding>
                 </configuration>
             </plugin>-->
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

在application.yml中的配置

server:
  port: ${PORT:8080}
spring:
  application:
    name: my-springsecurity
  datasource:
    url: jdbc:oracle:thin:@localhost:1521:orcl
    username: scott
    password: oracle
    driver-class-name: oracle.jdbc.driver.OracleDriver
  redis:
    host: ${REDIS_HOST:127.0.0.1}
    port: ${REDIS_PORT:6379}
    timeout: 5000 #连接超时 毫秒
#  main:
#    allow-bean-definition-overriding: true #同名bean覆盖

auth:
  redisAge: 600 #单位秒
# 无法扫描到resources下的templates中的静态文件时可以配置，如果可以无需配置
#注入到TomcatConfig
bw:
  factory:
    doc:
      root: E:\JAVAIDEA\My\springboot\my-springsecurity\src\main\resources\templates

首先需要继承WebSecurityConfigurerAdapter类，配置security中的认证授权相关配置

SecurityConfig 类

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

    //token 过滤器，解析token
    @Autowired
    MyJwtTokenFilter jwtTokenFilter;

    
    @Autowired
    MyUserDetailsService myUserDetailsService;

    @Autowired
    private SendSmsSecurityConfig sendSmsSecurityConfig;

    //加密机制
    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }


    //认证
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService)
                .passwordEncoder(passwordEncoder());
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
//                .antMatchers("/admin/api/**").hasRole("ADMIN")
//                .antMatchers("/user/api/**").hasRole("USER")
                .antMatchers("/SendSms").permitAll()
                .antMatchers("/userlogout").permitAll()
                .antMatchers("/**").permitAll()
                .anyRequest().authenticated()//任何请求登录后访问
                .and()
                // 基于token，所以不需要session
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
//                .sessionManagement() //会话管理
//                .maximumSessions(1); //限制登录人数
                .and().csrf().disable();

        //登录操作
        http.formLogin()
                .loginPage("/login.html")//登录路径
                .loginProcessingUrl("/farmerlogin")//登录表单提交请求
                .usernameParameter("username")//设置登录账号参数，默认username
                .passwordParameter("password")//设置登录密码参数，默认password
//                .defaultSuccessUrl("/home.html")//登录成功跳转，不能和successHandler一起使用
//                .failureUrl("/login.html")// 登录失败跳转，不能和failureHandler一起使用
                .permitAll()
                //登录成功处理
                .successHandler(new LoginSuccessHandler())
                //登录失败处理
                .failureHandler(new LoginFailureHandler())
                .and().apply(sendSmsSecurityConfig);


        //退出操作
        http.logout()
                .logoutUrl("/aaa")//退出提交参数
                .logoutSuccessUrl("/login.html");//退出后跳转，不能和logoutSuccessHandler一起使用
//        .logoutSuccessHandler();//退出处理

        // 禁用缓存
        http.headers().cacheControl();

        http.addFilterBefore(jwtTokenFilter, UsernamePasswordAuthenticationFilter.class)
                // 添加权限不足 filter
                .exceptionHandling().accessDeniedHandler(new MyAccessDeniedHandler())
                //其他异常处理类
                .authenticationEntryPoint(new MyAuthenticationException());
    }

    //忽略拦截
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/css/**", "/elementuidemo/**",
                "/img/**", "/js/**", "/plugins/**", "/static/json/**", "/pages/**");
    }
    
}

配置相关配件：

LoginSuccessHandler 类（登陆成功处理）

登录成功处理：继承SavedRequestAwareAuthenticationSuccessHandler类，该类继承AuthenticationSuccessHandler类，AuthenticationSuccessHandler登录成功父类，之所以用SavedRequestAwareAuthenticationSuccessHandler类，里面可以实现其他的方法，如：登录成功跳转到登录之前请求的页面

/**
 * <p>
 * AuthenticationSuccessHandler登录成功父类
 * SavedRequestAwareAuthenticationSuccessHandler 继承AuthenticationSuccessHandler
 * <p>
 * 登录成功处理
 */
@Component
public class LoginSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {

    @Value("${auth.redisAge}")
    int redisAge;
    @Autowired
    StringRedisTemplate stringRedisTemplate;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        System.out.println("登录成功");
        //从authentication中获取用户信息
        final User farmerDetail = (User) authentication.getPrincipal();
        //生成jwt
        String token = jwtTokenUtil.generateToken(farmerDetail);
        httpServletResponse.addHeader("token", "Bearer " + token);
        //把token保存到redis中，farmerDetail.getUsername()用户名作为key，也可以用id作为key值farmerDetail.getId()
        stringRedisTemplate.opsForValue().set(farmerDetail.getUsername(),token,redisAge, TimeUnit.SECONDS);
        httpServletResponse.setContentType("application/json");
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.getWriter().write("{\"result\":\"ok\"}");

    }
}

LoginFailureHandler 类（登录失败处理）

登录失败处理：继承SimpleUrlAuthenticationFailureHandler类，该类继承SimpleUrlAuthenticationFailureHandler类，SimpleUrlAuthenticationFailureHandler类登录失败父类，之所以用SimpleUrlAuthenticationFailureHandler类，里面可以实现其他方法，如：登录失败跳转到登录页面

/**
 *
 * AuthenticationFailureHandler登录失败父类
 * SimpleUrlAuthenticationFailureHandler 继承AuthenticationFailureHandler
 *
 * 登录失败处理
 */
@Component
public class LoginFailureHandler extends SimpleUrlAuthenticationFailureHandler {

    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {

        httpServletResponse.setContentType("application/json;charset=UTF-8");
        httpServletResponse.setStatus(401);
        PrintWriter out = httpServletResponse.getWriter();
        out.write("{\"error_code\":\"401\",\"name\":\""+e.getClass()+"\",\"message\":\""+e.getMessage()+"\"}");

    }
}

MyAccessDeniedHandler 类（权限不足处理）

权限不足处理：实现的AccessDeniedHandler类，进行的权限校验

/**
 * Spring security权限不足处理类
 * 只有登录后（即接口有传token）接口权限不足才会进入AccessDeniedHandler，
 * 如果是未登陆或者会话超时等，不会触发AccessDeniedHandler，而是会直接跳转到登陆页面。
 */
@Component
public class MyAccessDeniedHandler 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();
        response.getWriter().write("{\"result\":\"权限不足\"}");
        printWriter.flush();
    }
}

MyAuthenticationException 类（异常处理）

异常处理：实现AuthenticationEntryPoint类，实现异常的处理，如果不配置此类，则spring security默认会跳转到登录页面

/**
 * Spring security其他异常处理类,比如请求路径不存在等，
 * 如果不配置此类，则Spring security默认会跳转到登录页面
 */
@Component
public class MyAuthenticationException implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
        System.out.println("AuthenticationEntryPoint检测到异常:"+e);
        httpServletResponse.setStatus(200);
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.setContentType("application/json; charset=utf-8");
        PrintWriter printWriter = httpServletResponse.getWriter();
        httpServletResponse.getWriter().write("AuthenticationEntryPoint检测到异常:"+e);
        printWriter.flush();
    }
}

MyUserDetailsService 类（从数据库查询用户信息）

UserDetailsService验证用户名、密码和授权处理，实现从数据库查询用户功能（仅用于测试，用户和权限在一张表中，根据需求可以进行多表查询赋予权限）

/**
 * 根据账号查询用户
 */
@Component
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;



    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        //从数据库读取该用户
        User user = userMapper.findByUserName(username);
        // 用户不存在，抛出异常
        if (user == null){
            throw new UsernameNotFoundException("用户不存在");
        }
        //将数据库形式的roles解析为UserDtails的权限集
//        farmer.setAuthorities(AuthorityUtils.commaSeparatedStringToAuthorityList(farmer.getRoles()));
        List<GrantedAuthority> authorities = generateAuthorities(user.getRoles());
        user.setAuthorities(authorities);
        return user;

        //基于内存验证用户信息
//        UserDetails userDetails = Farmer.withUsername("123").password("123").roles("USER").build();
//        return userDetails;
    }

    //自定义实现权限转换
    private List<GrantedAuthority> generateAuthorities(String roles){
        List<GrantedAuthority> authorities = new ArrayList<>();
        String[] roleArray = roles.split(",");
        if (roles != null && !"".equals(roles)){
            for (String role : roleArray) {
                authorities.add(new SimpleGrantedAuthority(role));
            }
        }
        return authorities;
    }
}

MyJwtTokenFilter 类（token过滤器）

token过滤器进行解析判断是否登录，继承OncePerRequestFilter类

/**
 * token 过滤器，在这里解析token，拿到该用户角色，设置到springsecurity的上下文环境中，让springsecurity自动判断权限
 * 所有请求最先进入此过滤器，包括登录接口，而且在springsecurity的密码验证之前执行
 */
@Component
public class MyJwtTokenFilter extends OncePerRequestFilter {

    @Autowired
    MyUserDetailsService myUserDetailsService;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;
    @Autowired
    StringRedisTemplate stringRedisTemplate;

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain)
            throws ServletException, IOException {

        String authHeader = request.getHeader("Authorization");
        String tokenHead = "Bearer ";

        if (authHeader != null && authHeader.startsWith(tokenHead)) {
            String token = authHeader.substring(tokenHead.length());
            String username = jwtTokenUtil.getUsernameFromToken(token);
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                UserDetails userDetails = this.myUserDetailsService.loadUserByUsername(username);
                //从redis中取出存储的token
                String redisToken = stringRedisTemplate.opsForValue().get(userDetails.getUsername());
                //验证令牌是否有效
                if (token.equals(redisToken) && jwtTokenUtil.validateToken(token, userDetails)) {
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            }
        }
        chain.doFilter(request, response);
    }
}

JwtTokenUtil 类（JWT工具类）

JWT工具类

@Component
public class JwtTokenUtil implements Serializable {
    /**
     * 密钥
     */
    private final String secret = "aaaa";
    @Value("${auth.redisAge}")
    private Long redisAge;


    /**
     * 生成token的过期时间
     */
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + redisAge * 1000);
    }
    /**
     * 从数据声明生成令牌
     * @param claims 数据声明
     * @return 令牌
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder().setClaims(claims).setExpiration(generateExpirationDate()).signWith(SignatureAlgorithm.HS512, secret).compact();
    }

    /**
     * 从令牌中获取数据声明
     *
     * @param token 令牌
     * @return 数据声明
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
        } catch (Exception e) {
            claims = null;
        }
        return claims;
    }

    /**
     * 生成令牌
     *
     * @param userDetails 用户
     * @return 令牌
     */
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>(2);
        claims.put("sub", userDetails.getUsername());
        claims.put("created", new Date());
        return generateToken(claims);
    }

    /**
     * 从令牌中获取用户名
     *
     * @param token 令牌
     * @return 用户名
     */
    public String getUsernameFromToken(String token) {
        String username;
        try {
            Claims claims = getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    /**
     * 判断令牌是否过期
     *
     * @param token 令牌
     * @return 是否过期
     */
    public Boolean isTokenExpired(String token) {
        try {
            Claims claims = getClaimsFromToken(token);
            Date expiration = claims.getExpiration();
            return expiration.before(new Date());
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 刷新令牌
     *
     * @param token 原令牌
     * @return 新令牌
     */
    public String refreshToken(String token) {
        String refreshedToken;
        try {
            Claims claims = getClaimsFromToken(token);
            claims.put("created", new Date());
            refreshedToken = generateToken(claims);
        } catch (Exception e) {
            refreshedToken = null;
        }
        return refreshedToken;
    }

    /**
     * 验证令牌
     *
     * @param token       令牌
     * @param userDetails 用户
     * @return 是否有效
     */
    public Boolean validateToken(String token, UserDetails userDetails) {
        User user = (User) userDetails;
        String username = getUsernameFromToken(token);
        return (username.equals(user.getUsername()) && !isTokenExpired(token));
    }
}

User 类（实现UserDetails类）

在pojo文件中，写User实体类实现UserDetails类

public class User implements UserDetails{

    private int id;
    private String username;
    private String password;
    private String roles;


    private List<GrantedAuthority> authorities;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String getPassword() {
        return password;
    }

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

    public String getRoles() {
        return roles;
    }

    public void setRoles(String roles) {
        this.roles = roles;
    }

    public void setAuthorities(List<GrantedAuthority> authorities) {
        this.authorities = authorities;
    }

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


    //账号是否没过期
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
    //账号是否没被锁定
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }
    //密码是否没过期
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    //账号是否可用
    @Override
    public boolean isEnabled() {
        return true;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", roles='" + roles + '\'' +
                ", authorities=" + authorities +
                '}';
    }
}

dao层，mapper.xml，数据库可以进行简单的配置进行测试。数据库为Oracle，可以自行配置mysql或Oracle
在这里插入图片描述
在这里插入图片描述在这里插入图片描述数据库就四个字段，id，username，password，权限。

controller中有三个测试类

@RestController
@RequestMapping("/admin/api")
public class AdminController {

    @GetMapping("hello")
    @PreAuthorize("hasRole('ROLE_ADMIN')")
    public String hello(){
        return "hello,admin";
    }
}

@RestController
@RequestMapping("/app/api")
public class AppController {

    @GetMapping("hello")
    public String hello(){
        return "hello,app";
    }
}

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

    @GetMapping("/hello")
    @PreAuthorize("hasAuthority('ROLE_USER')")
    public String hello(){
        return "hello,user";
    }
}

在Postman中进行登录测试

登录成功显示： farmerlogin是在SecurityConfig中自定义的，默认为login
在这里插入图片描述
会在Headers中生成一个token
在这里插入图片描述
这个token是自己定义的，在登录成功处理类中生成的token令牌
在这里插入图片描述
在验证时，在Key中存放 Authorization ，在Value中把生成的token保存进去，然后会在MyJwtTokenFilter类中进行令牌校验
成功示例：
在这里插入图片描述

退出登录时

/**
 * 退出操作
 */
@RestController
@RequestMapping("/")
public class LogoutController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 退出
     * @param username 账号，存入redis中的key值
     */
    @RequestMapping("/userlogout")
    public void logout(@RequestParam("username") String username) {
    	//删除redis中的key
        stringRedisTemplate.delete(username);
    }
}

SendSmsSecurityConfig类为短信登录的配置类，须在SecurityConfig进行声明
SendSms文件中的类为短信登录相关的配置，和本章并无冲突，遇到相关配置可直接删除
test测试文件里面是发送短信测试

TomcatConfig类不重要，需要了可以配置：

TomcatConfig类的配置说明 https://blog.csdn.net/weixin_45498999/article/details/105973351

代码资源：https://download.csdn.net/download/weixin_45498999/12500298

佛说"獨"
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合security与jwt
08-05
springboot2.0整合security与jwt， 还整合了redis,与swagger-ui
SpringBoot 整合 Spring Security 、JWT 实现认证、权限控制
z1259678404的博客
02-16 1418
引入依赖包（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...
springSecurity中jwt机制及应用详解
最新发布
2401_84092666的博客
05-04 686
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！这种格式是OAuth2附带token的一种规范格式至于什么是OAuth2，那是另一个话题了这样一来，服务器就能够收到这个令牌了，通过对令牌的验证，即可知道该令牌是否有效。它们的完整交互流程是非常简单清晰的：令牌的组成为了保证令牌的安全性，jwt令牌由三个部分组成，分别是：header：令牌头部，记录了整个令牌的类型和签名算法payload：令牌负荷，记录了保存的主体信息，比如你要保存的用户信息就可以放到这里s
SpringBoot整合SpringSecurity和JWT
hello，word！
03-03 4252
SpringBoot整合SpringSecurity和JWT，SpringSecurity提供了Spring EL表达式，允许我们在定义接口访问的方法上面添加注解，来控制访问权限。
SpringBoot + SpringSecurity + JWT
飘然生的博客
01-24 1106
一、pom依赖 1.POM依赖 <!--security--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> <version>2.2.4.RELEASE&l
Springboot+Security+Jwt
点点的博客
12-13 1万+
工程目录 文章目录 工程目录 前言 一、Security是什么？ 二、使用步骤 1.引入pom.xml文件 2.application.yml文件 。。。。。。 总结:代码足够详细，有耐心的可以看，没耐心的浪费时间！ 前言 随着业务的发展，传统的不分离前后端的Java项目逐渐减少，更多的时候是做到前后端分离，会话管理也就从传统的Session会话管理变为Jwt管理会话，本篇文章就是SpringBoot使用Jwt管理会话同时整合Security，完成权限操作。
Spring Security学习笔记
Shawn的个人博客
05-09 1892
文章目录一、Security简介1、简介2、security框架快速搭建二、Spring Security认证1、登录校验流程2、SpringSecurity原理初探2.1 过滤器介绍2.2 认证流程详解3、SpringBoot整合前期准备3.1 思路分析3.2 数据库与框架搭建3.3 相应工具类创建4、自定义UserDetailsService5、自定义登录接口6、认证过滤器7、退出登录8、自定义认证(可选)三、Spring Security授权1、 权限系统初步介绍1.1 介绍1.2 授权基本流程1.3
SpringBoot+SpringSecurity+JWT整合
seeyouagain_的博客
01-04 9908
SpringSecurity入门简单案例适合新手学习
SpringBoot 集成 SpringSecurity+JWT
asksl的博客
11-29 4158
SpringBoot 集成 SpringSecurity+JWT
SpringBoot+SpringSecurity+JWT实现认证和授权
热门推荐
oyc的博客
01-17 5万+
一、背景： 在 B/S 系统中，登录功基本都是依靠 Cookie 来实现的，用户登录成功之后主要需要客户端和服务端完成以下两项工作： （1）服务端将登录状态记录到 Session 中，或者签发Token； （2）客户端利用Cookie保存于服务端对应的 Session ID 或 Token。之后每次请求都会带上Cookie信息(包含Session ID或者Token），当服务端收到请求后，通过验证 Cookie 中的信息来判断用户是否登录 。 单点登录：单点登录（Single Sign On, S.
springBoot整合spring security+JWT实现单点登录与权限管理前后端分离--筑基中期
qq_43788185的博客
09-05 1396
写在前面 在前一篇文章当中，我们介绍了springBoot整合spring security单体应用版，在这篇文章当中，我将介绍springBoot整合spring secury+JWT实现单点登录与权限管理。 本文涉及的权限管理模型是基于资源的动态权限管理。数据库设计的表有 user 、role、user_role、permission、role_permission。 单点登录当中，关于访问者信息的存储有多种解决方案。如将其以key-value的形式存储于redis数据库中，访问者令牌中存放key。校验
详解SpringBoot+SpringSecurity+jwt整合及初体验
08-25
SpringBoot+SpringSecurity+jwt整合详解 SpringBoot是当前最流行的Java框架之一，它提供了便捷的方式来构建基于Web的应用程序。然而，在构建Web应用程序时，安全性是不可忽视的重要方面。因此，本文将详细介绍如何...
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证
08-26
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证，可根据注解的格式不同，做到角色权限控制，角色加资源权限控制等，粒度比较细化。 @PreAuthorize("hasAnyRole('ADMIN','USER')")：具有admin或...
Springboot+SpringSecurity+JWT实现用户登录和权限认证示例
08-19
主要介绍了Springboot+SpringSecurity+JWT实现用户登录和权限认证示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
通用权限管理系统+springboot+mybatis plus+spring security+jwt+redis+mysql
05-30
后端使用SpringBoot框架进行业务逻辑开发，利用Spring Security实现权限控制。数据库采用MySQL进行数据存储，使用MyBatis进行数据访问。 权限控制模块设计包括用户、角色和权限三个主要模块。用户模块用于管理用户...
springboot+security+jwt+mybaits-plus+mysql实现权限管理
03-13
1.传统spring boot框架 2.security框架 3.jwt取代session 4.mybatis-plus+mysql【sql文件项目中有】 5.不想下载，可以看博客，博客中有写
在springboot+springsecurity的基础上+JWT（私钥加密，公钥解密）
furenqiang的博客
12-23 3349
一、已经完成了springboot+springsecurity的工作若没完成，请移步 security的使用：三个工具类 ，放在项目专门存放工具类的包下面 （1）、jwtUtils.java: JWT生成TOKEN package com.aliyun.vuelogin.util; import com.aliyun.vuelogin.common.Payload; import io.js...
Spring Boot+Spring Security+JWT实现系统认证与授权
Cloud-Future的博客
08-03 2925
Spring Boot+Spring Security+JWT实现系统认证与授权 Spring Boot整合Spring Security实现JWT认证 Spring Boot项目使用JWT认证 JWT认证 OAuth2 JWT认证
springboot+springsecurity+jwt
weixin_43213137的博客
03-03 352
什么是JWT——What is JSON Web Token? 首先JWT全称是JSON Web Token，它是根据开放标准RFC7519所定义的一个紧凑和独立的在各方安全的传输信息的JSON格式对象。它所传递的信息能够被验证和信任，因为它是数字签证。 以上是官方解释，大白话就是它是来做安全认证的，客户端和服务端的身份认证，可以通过JSON Web Token来做，当然使用springsecur...
SpringBoot+SpringSecurity+JWT
09-19
在SpringBoot和SpringSecurity的结合中，可以使用JWT来实现认证和授权的功能。 为了在SpringBoot中使用SpringSecurity和JWT，你需要进行以下几个步骤： 1. 引入相关依赖：在项目的pom.xml文件中添加SpringSecurity...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值