spring security 初次学习

最新推荐文章于 2023-02-11 15:15:29 发布
最新推荐文章于 2023-02-11 15:15:29 发布
阅读量219 收藏
点赞数
分类专栏： java  初级 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50990903/article/details/120502694
版权

Spring-Security

一：概述

web应用的安全性包括用户认证（Authentication）和 用户授权（Authonization）两个部分，也是Spring Security总要核心功能。

（1）用户认证指的是：验证某个用户是否为系统中的的合法主体，通俗点说就是系统认为用户是否能登录

（2）用户授权指的是：验证某个用户是否有权限执行某个操作，通俗点讲就是系统判断用户是狗有权限去做某些事情。

二：入门案例

2.1-引入依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <!--Hutool Java工具包-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>4.5.7</version>
        </dependency>
        <!--JWT(Json Web Token)登录支持-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--Swagger-UI API文档生产工具-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>

2.2- jwt token 工具类

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * JwtToken生成的工具类
 * Created by macro on 2018/4/26.
 */
@Component
public class JwtTokenUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(JwtTokenUtil.class);
    private static final String CLAIM_KEY_USERNAME = "sub";
    private static final String CLAIM_KEY_CREATED = "created";
    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expiration;

    /**
     * 根据负责生成JWT的token
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    /**
     * 从token中获取JWT中的负载
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            LOGGER.info("JWT格式验证失败:{}",token);
        }
        return claims;
    }

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

    /**
     * 从token中获取登录用户名
     */
    public String getUserNameFromToken(String token) {
        String username;
        try {
            Claims claims = getClaimsFromToken(token);
            username =  claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    /**
     * 验证token是否还有效
     *
     * @param token       客户端传入的token
     * @param userDetails 从数据库中查询出来的用户信息
     */
    public boolean validateToken(String token, UserDetails userDetails) {
        String username = getUserNameFromToken(token);
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }

    /**
     * 判断token是否已经失效
     */
    private boolean isTokenExpired(String token) {
        Date expiredDate = getExpiredDateFromToken(token);
        return expiredDate.before(new Date());
    }

    /**
     * 从token中获取过期时间
     */
    private Date getExpiredDateFromToken(String token) {
        Claims claims = getClaimsFromToken(token);
        return claims.getExpiration();
    }

    /**
     * 根据用户信息生成token
     */
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

    /**
     * 判断token是否可以被刷新
     */
    public boolean canRefresh(String token) {
        return !isTokenExpired(token);
    }

    /**
     * 刷新token
     */
    public String refreshToken(String token) {
        Claims claims = getClaimsFromToken(token);
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }
}

2.3-SpringSecurity的配置类

import cn.hh.mall.enty.UmsAdmin;
import cn.hh.mall.enty.UmsPermission;
import cn.hh.mall.service.UmsAdminService;
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.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;


/**
 * SpringSecurity的配置
 * Created by macro on 2018/4/26.
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled=true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UmsAdminService adminService;
    @Autowired
    private RestfulAccessDeniedHandler restfulAccessDeniedHandler;
    @Autowired
    private RestAuthenticationEntryPoint restAuthenticationEntryPoint;

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.csrf()// 由于使用的是JWT，我们这里不需要csrf
                .disable()
                .sessionManagement()// 基于token，所以不需要session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                .antMatchers(HttpMethod.GET, // 允许对于网站静态资源的无授权访问
                        "/",
                        "/*.html",
                        "/favicon.ico",
                        "/**/*.html",
                        "/**/*.css",
                        "/**/*.js",
                        "/swagger-resources/**",
                        "/v2/api-docs/**"
                )
                .permitAll()
                .antMatchers("/admin/login", "/admin/register")// 对登录注册要允许匿名访问
                .permitAll()
                .antMatchers(HttpMethod.OPTIONS)//跨域请求会先进行一次options请求
                .permitAll()
//                .antMatchers("/**")//测试时全部运行访问
//                .permitAll()
                .anyRequest()// 除上面外的所有请求全部需要鉴权认证
                .authenticated();
        // 禁用缓存
        httpSecurity.headers().cacheControl();
        // 添加JWT filter
        httpSecurity.addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
        //添加自定义未授权和未登录结果返回
        httpSecurity.exceptionHandling()
                .accessDeniedHandler(restfulAccessDeniedHandler)
                .authenticationEntryPoint(restAuthenticationEntryPoint);
    }

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

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        //获取登录用户信息
        return username -> {
            UmsAdmin admin = adminService.getAdminByUsername(username);
            if (admin != null) {
                List<UmsPermission> permissionList = adminService.getPermissionList(admin.getId());
                return new AdminUserDetails(admin,permissionList);
            }
            throw new UsernameNotFoundException("用户名或密码错误");
        };
    }

    @Bean
    public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter(){
        return new JwtAuthenticationTokenFilter();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}
相关依赖及方法说明
  • configure(HttpSecurity httpSecurity)：用于配置需要拦截的url路径、jwt过滤器及出异常后的处理器；
  • configure(AuthenticationManagerBuilder auth)：用于配置UserDetailsService及PasswordEncoder；
  • RestfulAccessDeniedHandler：当用户没有访问权限时的处理器，用于返回JSON格式的处理结果；
  • RestAuthenticationEntryPoint：当未登录或token失效时，返回JSON格式的结果；
  • UserDetailsService:SpringSecurity定义的核心接口，用于根据用户名获取用户信息，需要自行实现；
  • UserDetails：SpringSecurity定义用于封装用户信息的类（主要是用户信息和权限），需要自行实现；
  • PasswordEncoder：SpringSecurity定义的用于对密码进行编码及比对的接口，目前使用的是BCryptPasswordEncoder；
  • JwtAuthenticationTokenFilter：在用户名和密码校验前添加的过滤器，如果有jwt的token，会自行根据token信息进行登录。

2.3-登录结果类

import cn.hh.mall.common.CommonResult;
import cn.hutool.json.JSONUtil;
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;

/**
 * 当访问接口没有权限时，自定义的返回结果
 * Created by macro on 2018/4/26.
 */
@Component
public class RestfulAccessDeniedHandler implements AccessDeniedHandler{
    @Override
    public void handle(HttpServletRequest request,
                       HttpServletResponse response,
                       AccessDeniedException e) throws IOException, ServletException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        response.getWriter().println(JSONUtil.parse(CommonResult.forbidden(e.getMessage())));
        response.getWriter().flush();
    }
}









import cn.hh.mall.common.CommonResult;
import cn.hutool.json.JSONUtil;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

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

/**
 * 当未登录或者token失效访问接口时，自定义的返回结果
 * Created by macro on 2018/5/14.
 */
@Component
public class RestAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        response.getWriter().println(JSONUtil.parse(CommonResult.unauthorized(authException.getMessage())));
        response.getWriter().flush();
    }
}

2.4-添加AdminUserDetails

import cn.hh.mall.enty.UmsAdmin;
import cn.hh.mall.enty.UmsPermission;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

/**
 * SpringSecurity需要的用户详情
 * Created by macro on 2018/4/26.
 */
public class AdminUserDetails implements UserDetails {
    private UmsAdmin umsAdmin;
    private List<UmsPermission> permissionList;
    public AdminUserDetails(UmsAdmin umsAdmin, List<UmsPermission> permissionList) {
        this.umsAdmin = umsAdmin;
        this.permissionList = permissionList;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        //返回当前用户的权限
        return permissionList.stream()
                .filter(permission -> permission.getValue()!=null)
                .map(permission ->new SimpleGrantedAuthority(permission.getValue()))
                .collect(Collectors.toList());
    }

    @Override
    public String getPassword() {
        return umsAdmin.getPassword();
    }

    @Override
    public String getUsername() {
        return umsAdmin.getUsername();
    }

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

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

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

    @Override
    public boolean isEnabled() {
        return umsAdmin.getStatus().equals(1);
    }
}

2.5-添加JwtAuthenticationTokenFilter

在用户名和密码校验前添加的过滤器，如果请求中有jwt的token且有效，会取出token中的用户名，然后调用SpringSecurity的API进行登录操作。

import cn.hh.mall.utils.JwtTokenUtil;
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.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.web.filter.OncePerRequestFilter;

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

/**
 * JWT登录授权过滤器
 * Created by macro on 2018/4/26.
 */
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    private static final Logger LOGGER = LoggerFactory.getLogger(JwtAuthenticationTokenFilter.class);
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;
    @Value("${jwt.tokenHeader}")
    private String tokenHeader;
    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {
        String authHeader = request.getHeader(this.tokenHeader);
        if (authHeader != null && authHeader.startsWith(this.tokenHead)) {
            String authToken = authHeader.substring(this.tokenHead.length());// The part after "Bearer "
            String username = jwtTokenUtil.getUserNameFromToken(authToken);
            LOGGER.info("checking username:{}", username);
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
                if (jwtTokenUtil.validateToken(authToken, userDetails)) {
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    LOGGER.info("authenticated user:{}", username);
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            }
        }
        chain.doFilter(request, response);
    }
}

2.6-添加UmsAdminController类

import com.macro.mall.tiny.common.api.CommonResult;
import com.macro.mall.tiny.dto.UmsAdminLoginParam;
import com.macro.mall.tiny.mbg.model.UmsAdmin;
import com.macro.mall.tiny.mbg.model.UmsPermission;
import com.macro.mall.tiny.service.UmsAdminService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 后台用户管理
 * Created by macro on 2018/4/26.
 */
@Controller
@Api(tags = "UmsAdminController", description = "后台用户管理")
@RequestMapping("/admin")
public class UmsAdminController {
    @Autowired
    private UmsAdminService adminService;
    @Value("${jwt.tokenHeader}")
    private String tokenHeader;
    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @ApiOperation(value = "用户注册")
    @RequestMapping(value = "/register", method = RequestMethod.POST)
    @ResponseBody
    public CommonResult<UmsAdmin> register(@RequestBody UmsAdmin umsAdminParam, BindingResult result) {
        UmsAdmin umsAdmin = adminService.register(umsAdminParam);
        if (umsAdmin == null) {
            CommonResult.failed();
        }
        return CommonResult.success(umsAdmin);
    }

    @ApiOperation(value = "登录以后返回token")
    @RequestMapping(value = "/login", method = RequestMethod.POST)
    @ResponseBody
    public CommonResult login(@RequestBody UmsAdminLoginParam umsAdminLoginParam, BindingResult result) {
        String token = adminService.login(umsAdminLoginParam.getUsername(), umsAdminLoginParam.getPassword());
        if (token == null) {
            return CommonResult.validateFailed("用户名或密码错误");
        }
        Map<String, String> tokenMap = new HashMap<>();
        tokenMap.put("token", token);
        tokenMap.put("tokenHead", tokenHead);
        return CommonResult.success(tokenMap);
    }

    @ApiOperation("获取用户所有权限（包括+-权限）")
    @RequestMapping(value = "/permission/{adminId}", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult<List<UmsPermission>> getPermissionList(@PathVariable Long adminId) {
        List<UmsPermission> permissionList = adminService.getPermissionList(adminId);
        return CommonResult.success(permissionList);
    }
}

2.7-添加UmsAdminService接口

import com.macro.mall.tiny.mbg.model.UmsAdmin;
import com.macro.mall.tiny.mbg.model.UmsPermission;

import java.util.List;

/**
 * 后台管理员Service
 * Created by macro on 2018/4/26.
 */
public interface UmsAdminService {
    /**
     * 根据用户名获取后台管理员
     */
    UmsAdmin getAdminByUsername(String username);

    /**
     * 注册功能
     */
    UmsAdmin register(UmsAdmin umsAdminParam);

    /**
     * 登录功能
     * @param username 用户名
     * @param password 密码
     * @return 生成的JWT的token
     */
    String login(String username, String password);

    /**
     * 获取用户所有权限（包括角色权限和+-权限）
     */
    List<UmsPermission> getPermissionList(Long adminId);
}

实现类

import cn.hh.mall.enty.UmsAdmin;import cn.hh.mall.enty.UmsPermission;import cn.hh.mall.utils.JwtTokenUtil;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Value;import org.springframework.security.authentication.BadCredentialsException;import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;import org.springframework.security.core.AuthenticationException;import org.springframework.security.core.context.SecurityContextHolder;import org.springframework.security.core.userdetails.UserDetails;import org.springframework.security.core.userdetails.UserDetailsService;import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;import org.springframework.security.crypto.password.PasswordEncoder;import org.springframework.stereotype.Service;import java.util.ArrayList;import java.util.Date;import java.util.List;/** * UmsAdminService实现类 * Created by macro on 2018/4/26. */@Servicepublic class UmsAdminServiceImpl implements UmsAdminService {    private static final Logger LOGGER = LoggerFactory.getLogger(UmsAdminServiceImpl.class);    @Autowired    private UserDetailsService userDetailsService;    @Autowired    private JwtTokenUtil jwtTokenUtil;    @Autowired    private PasswordEncoder passwordEncoder;    @Value("${jwt.tokenHead}")    private String tokenHead;    /*@Autowired    private UmsAdminMapper adminMapper;    @Autowired    private UmsAdminRoleRelationDao adminRoleRelationDao;*/    @Override    public UmsAdmin getAdminByUsername(String username) {        /*UmsAdminExample example = new UmsAdminExample();        example.createCriteria().andUsernameEqualTo(username);        List<UmsAdmin> adminList = adminMapper.selectByExample(example);        if (adminList != null && adminList.size() > 0) {            return adminList.get(0);        }*/        UmsAdmin umsAdmin=new UmsAdmin();        umsAdmin.setUsername("tom");        String password = new BCryptPasswordEncoder().encode("123");        umsAdmin.setPassword(password);        return umsAdmin;    }    @Override    public UmsAdmin register(UmsAdmin umsAdminParam) {        UmsAdmin umsAdmin = new UmsAdmin();        BeanUtils.copyProperties(umsAdminParam, umsAdmin);        umsAdmin.setCreateTime(new Date());        umsAdmin.setStatus(1);        //查询是否有相同用户名的用户        /*UmsAdminExample example = new UmsAdminExample();        example.createCriteria().andUsernameEqualTo(umsAdmin.getUsername());        List<UmsAdmin> umsAdminList = adminMapper.selectByExample(example);        if (umsAdminList.size() > 0) {            return null;        }*/        //将密码进行加密操作        String encodePassword = passwordEncoder.encode(umsAdmin.getPassword());        umsAdmin.setPassword(encodePassword);//        adminMapper.insert(umsAdmin);        return umsAdmin;    }    @Override    public String login(String username, String password) {        String token = null;        try {            UserDetails userDetails = userDetailsService.loadUserByUsername(username);            if (!passwordEncoder.matches(password, userDetails.getPassword())) {                throw new BadCredentialsException("密码不正确");            }            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());            SecurityContextHolder.getContext().setAuthentication(authentication);            token = jwtTokenUtil.generateToken(userDetails);        } catch (AuthenticationException e) {            LOGGER.warn("登录异常:{}", e.getMessage());        }        return token;    }    @Override    public List<UmsPermission> getPermissionList(Long adminId) {        List<UmsPermission> list=new ArrayList<>();        UmsPermission umsPermission=new UmsPermission();        umsPermission.setValue("pms:brand:read");        list.add(umsPermission);        return list;    }}

2.8-swagger配置

import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import springfox.documentation.builders.ApiInfoBuilder;import springfox.documentation.builders.PathSelectors;import springfox.documentation.builders.RequestHandlerSelectors;import springfox.documentation.service.ApiInfo;import springfox.documentation.spi.DocumentationType;import springfox.documentation.spring.web.plugins.Docket;import springfox.documentation.swagger2.annotations.EnableSwagger2;/** * Swagger2API文档的配置 */@Configuration@EnableSwagger2public class Swagger2Config {    @Bean    public Docket createRestApi(){        return new Docket(DocumentationType.SWAGGER_2)                .apiInfo(apiInfo())                .select()                //为当前包下controller生成API文档                .apis(RequestHandlerSelectors.basePackage("cn.hh.mall.controller"))                //为有@Api注解的Controller生成API文档//                .apis(RequestHandlerSelectors.withClassAnnotation(Api.class))                //为有@ApiOperation注解的方法生成API文档//                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))                .paths(PathSelectors.any())                .build();    }    private ApiInfo apiInfo() {        return new ApiInfoBuilder()                .title("SwaggerUI演示")                .description("mall-tiny")                .contact("macro")                .version("1.0")                .build();    }}

2.9-公共响应类

import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;@Data@AllArgsConstructor@NoArgsConstructorpublic class CommonResult<T> {    private String code;    private String msg;    private T data;    public static CommonResult unauthorized(String msg){        return new CommonResult("200",msg,null);    }    public static CommonResult forbidden(String msg){        return new CommonResult("200",msg,null);    }    public static CommonResult failed(){        return new CommonResult("500","",null);    }    public static CommonResult success(Object data){        return new CommonResult("200","",data);    }    public static CommonResult validateFailed(String msg){        return new CommonResult("500",msg,null);    }}

10-其他类

import lombok.Data;import java.util.Date;@Datapublic class UmsAdmin {    private Long id;    private String password;    private String username;    private Integer status;    private Date createTime;}import lombok.Data;@Datapublic class UmsAdminLoginParam {    private String username;    private String password;}import lombok.Data;@Datapublic class UmsPermission {    private String value;}

11-给接口添加权限，例：

Swagger api地址：http://localhost:8080/swagger-ui.html

@PreAuthorize("hasAuthority('pms:brand:read')")public CommonResult<List<PmsBrand>> getBrandList() {    return CommonResult.success(brandService.listAllBrand());}

三：解析

3.1-JWT

JWT是JSON WEB TOKEN的缩写，它是基于 RFC 7519 标准定义的一种可以安全传输的的JSON对象，由于使用了数字签名，所以是可信任和安全的。

JWT的组成

  • JWT token的格式：header.payload.signature

  • header中用于存放签名的生成算法

    {"alg": "HS512"}Copy to clipboardErrorCopied

  • payload中用于存放用户名、token的生成时间和过期时间

    {"sub":"admin","created":1489079981393,"exp":1489684781}Copy to clipboardErrorCopied

  • signature为以header和payload生成的签名，一旦header和payload被篡改，验证将失败

    //secret为加密算法的密钥String signature = HMACSHA512(base64UrlEncode(header) + "." +base64UrlEncode(payload),secret)Copy to clipboardErrorCopied
JWT实例

这是一个JWT的字符串

eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsImNyZWF0ZWQiOjE1NTY3NzkxMjUzMDksImV4cCI6MTU1NzM4MzkyNX0.d-iki0193X0bBOETf2UN3r3PotNIEAV7mzIxxeI5IxFyzzkOZxS0PGfF_SK6wxCv2K8S0cZjMkv6b5bCqc0VBwCopy to clipboardErrorCopied

可以在该网站上获得解析结果：https://jwt.io/ img

JWT实现认证和授权的原理
  • 用户调用登录接口，登录成功后获取到JWT的token；
  • 之后用户每次调用接口都在http的header中添加一个叫Authorization的头，值为JWT的token；
  • 后台程序通过对Authorization头中信息的解码及数字签名校验来获取其中的用户信息，从而实现认证和授权。

3.2-匹配方式

  1. antMatcher(String … antPatterns)

参数是不定向参数，每个参数是一个ant表达式，用于匹配URL规则。规则如下

？：匹配一个字符

*：匹配0个或多个字符

**：匹配0个或多个目录

eg：放行js和css文件夹下所有脚本文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EZKhpNUS-1632708042719)(C:\Users\hanya\AppData\Roaming\Typora\typora-user-images\image-20210921170410606.png)]

或放行js文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8HNeSoSs-1632708042720)(C:\Users\hanya\AppData\Roaming\Typora\typora-user-images\image-20210921170419702.png)]

  1. anyRequest()匹配所有请求，.anyRequest().authenticated()设置全部内容都进行认证，不能放在第一行

  2. 基于角色授权.hasRole(“abc”) eg：数据库权限数据为ROLE_abc表示有abc角色，基于角色要以ROLE_开头

  3. permitAll()和authenticated(),底层都是access()方法，可以用access()自定义授权策略

四：两个重要接口

4.1 UserDetailsService

UserDetailsService() 是security获得用户信息调用的接口，如果要自定义认证逻辑只需要实现此接口即可

4.2 PasswordEncoder

PasswordEncoder() 是security用来做用户输入的密码，与数据库密码比对的接口，我们一般使用BCryptPasswordEncoder()实现类

五：原理

5.1：认证

概括图

5.1.1 认证流程原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EUryPUIR-1632708042722)(C:\Users\hanya\AppData\Roaming\Typora\typora-user-images\image-20210921172149407.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LEKHQEnY-1632708042722)(C:\Users\hanya\AppData\Roaming\Typora\typora-user-images\image-20210921172158873.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dkVWHTZ1-1632708042723)(C:\Users\hanya\AppData\Roaming\Typora\typora-user-images\image-20210921172205665.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yWIKYtfj-1632708042723)(C:\Users\hanya\AppData\Roaming\Typora\typora-user-images\image-20210921172213787.png)]

5.1.2 权限访问流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vg9X7QFM-1632708042724)(C:\Users\hanya\AppData\Roaming\Typora\typora-user-images\image-20210921172242738.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y2iulF7w-1632708042724)(C:\Users\hanya\AppData\Roaming\Typora\typora-user-images\image-20210921172249207.png)]

似夜晓星辰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《spring设计思想》24-ResourcePatternResolver-解析Ant pattern路径的资源
David_lou的专栏
07-23 536
上一节讲完了资源加载器，在demo中可以看到单个资源加载的简单用例。本节讲一下ant格式路径的资源加载， 在spring中我们经常看到引入资源的时候会用到 @Value("classpath*:/META-INF/*.properties") public Resource[] resources; 这种模式的路径，在spring中会解析这条路径，然后查找符合的资源，上面的path就是指向：classpath路径下/META-INF/文件下所有的properties文件 在图片中的三个文件中，
Spring Security UserDetails实现原理详解
09-07
主要介绍了Spring Security UserDetails实现原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring-security首次登录
实习生的博客
11-10 786
fasdf
初步学习整合spring security + jwt
爪哇岛民工的博客
06-03 131
前言 在做前后端分离的项目需要登录功能，选择了权限框架spring security，这里来记录一下学习整合的过程。 什么是jwt jwt是一串加密的字符串，包含了三段信息：第一部分我们称它为头部（header),第二部分我们称其为载荷（payload, 类似于飞机上承载的物品)，第三部分是签证（signature) 用户以后每次请求都会带上这个jwt token。 代码 pom <dependency> <groupId>io.jsonweb
Spring Security 实战干货：用户信息UserDetails相关入门
码农小胖哥
10-09 5502
1. 前言 前一篇介绍了 Spring Security 入门的基础准备。从今天开始我们来一步步窥探它是如何工作的。我们又该如何驾驭它。请多多关注公众号： Felordcn 。本篇将通过 Spring Boot 2.x 来讲解 Spring Security 中的用户主体UserDetails。以及从中找点乐子。 2. Spring Boot 集成 Spring Security ...
spring-security-helloworld
07-07
"级别的项目通常是编程初学者的第一步，而“入门”则表明这适用于那些初次接触Spring Security的人。标签中的“spring security”是核心关键词，指的是这个项目将围绕Spring Security框架进行，帮助新手了解其工作...
手把手带你入门 Spring Security的具体流程
08-18
在这篇文章中，我们将详细介绍 Spring Security 的入门流程，从基本概念到实际应用都是非常详细的，对大家的学习或工作具有一定的参考借鉴价值。 首先，Spring Security 是 Spring 家族中的一个安全管理框架，实际...
spring-security-study
03-19
《Spring Security深度学习指南》 ...通过深入学习“spring-security-study”这个资源，你可以掌握Spring Security的精髓，无论你是初级开发者还是有经验的架构师，都能从中受益匪浅，提升你在Java安全领域的专业能力。
spring-boot学习文档
04-24
这个"spring-boot学习文档"包含初级和高级两部分，旨在帮助开发者从基础到深入理解Spring Boot的核心概念和功能。 初级部分可能涵盖以下知识点： 1. **Spring Boot简介**：解释Spring Boot的基本理念，为何在众多...
SpringBoot-MyBatis：一个REST后端框架，由Spring Boot，MyBatis和Spring Security OAuth集成
01-30
它集成了Spring Boot和MyBatis （后续我又集成了Spring Security OAuth以支持OAuth 2.0），并实现了一个类似的“书籍管理”的模块（支持RESTful API ）以供参考，框架简单易懂。完全可以根据自己的需要，修改这个...
java-sec-code ssrf
weixin_44687621的博客
08-21 786
SSRF漏洞 SSRF(Server-side Request Forge, 服务端请求伪造)。 由攻击者构造的攻击链接传给服务端执行造成的漏洞，一般用来在外网探测或攻击内网服务。 利用伪协议读取文件 由于Java没有php的cURL，所以Java SSRF支持的协议，不能像php使用curl -V查看。 Java网络请求支持的协议可通过下面几种方法检测： 代码中遍历协议 官方文档中查看 import sun.net.www.protocol查看 SSRF是由发起网络请求的方法造成。所以先整理Java能
SpringSecurity框架原理浅谈之UserDetailsService
黄先生的博客
02-11 1935
UserDetailsService的作用就是从特定的地方（通常是数据库）加载用户信息.
AntPathMatcher路径匹配器，Ant风格的URL
白羊座的橙子
09-14 720
在描述路径时有个常见叫法：Ant风格的URL，那么什么是Ant风格？AntPathMatcher的描述中有这么一句话：这是从Apache Ant借用的一个概念。“年轻”的朋友可能从没用过甚至没听过Ant，它是一个构建工具，在2010年之前发挥着大作用，但之后逐渐被Maven/Gradle取代，现已几乎销声匿迹。虽然Ant“已死”，但Ant风格似乎要千古。借助Spring强大的号召力，该概念似乎已是规范一样的存在，大家在不成文的约定着、交流着、书写着。
Spring Security(五) 访问控制 url 匹配及 内置访问控制方法介绍
奥迪的博客
09-28 6867
一、 访问控制 url 匹配制 在前面讲解了认证中所有常用配置，主要是对 http.formLogin()进行操作。而在配置类中 http.authorizeRequests()主要是对 url 进行控制，也就是我们所说的授权（访问控制）。http.authorizeRequests()也支持连缀写法，总体公式为： url 匹配规则. 权限控制方法 通过上面的公式可以有很多 url 匹配规则和很多权限控制方法。这些内容进行各种组合就形成了 Spring Security 中的授权。 在所有匹...
SSRF安全威胁在JAVA代码中的应用
angjiu8534的博客
05-26 793
如上图所示代码，在进行外部url调用的时候，引入了SSRF检测：ssrfChecker.checkUrlWithoutConnection(url)机制。 SSRF安全威胁： 很多web应用都提供了从其他的服务器上获取数据的功能。使用用户指定的URL，web应用可以获取图片，下载文件，读取文件内容等。这个功能如果被恶意使用，可以利用存在缺陷的web应用作为代理攻击远程...
SSRF漏洞详解 一文了解SSRF漏洞
闵行小鱼塘
11-09 5166
本篇总结归纳SSRF漏洞
ant 风格的 url 匹配
iteye_20332的博客
08-21 652
转载自：http://hi.baidu.com/xiaolangs/blog/item/47fefe528359030b0cf3e3ee.html   ANT通配符有三种： 通配符 说明 ? 匹配任何单字符 * 匹配0或者任意数量的字符 ** 匹配0或者更多的目录 例子： URL路径 说明 /app/*.x 匹配(Matches)所有在app路径下的.x文件 ...
Spring Security - UserDetails
崔二旦
06-05 1万+
UserDetails 中几个字段的解释：//返回验证用户密码,无法返回则NULLString getPassword();String getUsername();//账户是否过期,过期无法验证boolean isAccountNonExpired();//指定用户是否被锁定或者解锁,锁定的用户无法进行身份验证boolean isAccountNonLocked()；//指示是否已过期的用户的凭...
Field xxxMapper in xxxServiceImpl required a bean of type XxxMapper解决方法
热门推荐
牧羊少年
06-02 3万+
写一个项目，启动之后无报错就结束了，后来发现是日志配置问题。改了之后出现了“Field stuService in a.imooc.controller.StuController required a bean of type ‘a.imooc.mapper.StuService’ that could not be found.”这个错误，显示是StuService无法注入，提示无法使用@Autowired。怎么能不让用呢，我都用这个那么久了…都是好好的！ 后来在网上找解决的方法，有的说是没有在Serv
springSecurity 学习
最新发布
05-05
Spring Security 是一款基于 Spring 框架的安全框架，...除了以上资源之外，还可以通过实践来学习 Spring Security，例如通过搭建一个简单的 Spring Security 应用程序，逐步深入了解 Spring Security 的使用和原理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值