欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

详解SpringBoot+SpringSecurity+jwt整合及初体验

程序员文章站 2024-02-21 15:39:54
原来一直使用shiro做安全框架,配置起来相当方便,正好有机会接触下springsecurity,学习下这个。顺道结合下jwt,把安全信息管理的问题扔给客户端, 准备...
原来一直使用shiro做安全框架,配置起来相当方便,正好有机会接触下springsecurity,学习下这个。顺道结合下jwt,把安全信息管理的问题扔给客户端,

准备

首先用的是springboot,省去写各种xml的时间。然后把依赖加入一下

<!--安全-->
<dependency>
  <groupid>org.springframework.boot</groupid>
  <artifactid>spring-boot-starter-security</artifactid>
</dependency>

<!--jwt-->
<dependency>
  <groupid>io.jsonwebtoken</groupid>
  <artifactid>jjwt</artifactid>
  <version>0.9.1</version>
</dependency>

application.yml加上一点配置信息,后面会用

jwt:
 secret: secret
 expiration: 7200000
 token: authorization

可能用到代码,目录结构放出来一下

详解SpringBoot+SpringSecurity+jwt整合及初体验

配置

securityconfig配置

首先是配置securityconfig,代码如下

@configuration
@enablewebsecurity// 这个注解必须加,开启security
@enableglobalmethodsecurity(prepostenabled = true)//保证post之前的注解可以使用
public class securityconfig extends websecurityconfigureradapter {

  @autowired
  jwtauthenticationentrypoint jwtauthenticationentrypoint;

  @autowired
  jwtuserdetailsservice jwtuserdetailsservice;

  @autowired
  jwtauthorizationtokenfilter authenticationtokenfilter;


  //先来这里认证一下
  @autowired
  public void configureglobal(authenticationmanagerbuilder auth) throws exception {
    auth.userdetailsservice(jwtuserdetailsservice).passwordencoder(passwordencoderbean());
  }

  //拦截在这配
  @override
  protected void configure(httpsecurity http) throws exception {
    http
        .exceptionhandling().authenticationentrypoint(jwtauthenticationentrypoint)
        .and()
        .authorizerequests()
        .antmatchers("/login").permitall()
        .antmatchers("/haha").permitall()
        .antmatchers("/sysuser/test").permitall()
        .antmatchers(httpmethod.options, "/**").anonymous()
        .anyrequest().authenticated()    // 剩下所有的验证都需要验证
        .and()
        .csrf().disable()           // 禁用 spring security 自带的跨域处理
        .sessionmanagement().sessioncreationpolicy(sessioncreationpolicy.stateless);
      // 定制我们自己的 session 策略:调整为让 spring security 不创建和使用 session

    http.addfilterbefore(authenticationtokenfilter, usernamepasswordauthenticationfilter.class);

  }

  @bean
  public passwordencoder passwordencoderbean() {
    return new bcryptpasswordencoder();
  }

  @bean
  @override
  public authenticationmanager authenticationmanagerbean() throws exception {
    return super.authenticationmanagerbean();
  }

}

ok,下面娓娓道来。首先我们这个配置类继承了websecurityconfigureradapter,这里面有三个重要的方法需要我们重写一下:

configure(httpsecurity http):这个方法是我们配置拦截的地方,exceptionhandling().authenticationentrypoint(),这里面主要配置如果没有凭证,可以进行一些操作,这个后面会看jwtauthenticationentrypoint这个里面的代码。进行下一项配置,为了区分必须加入.and()。authorizerequests()这个后边配置那些路径有需要什么权限,比如我配置的那几个url都是permitall(),及不需要权限就可以访问。值得一提的是antmatchers(httpmethod.options, "/**"),是为了方便后面写前后端分离的时候前端过来的第一次验证请求,这样做,会减少这种请求的时间和资源使用。csrf().disable()是为了防止csdf攻击的,至于什么是csdf攻击,请自行百度。

另起一行,以示尊重。sessionmanagement().sessioncreationpolicy(sessioncreationpolicy.stateless);因为我们要使用jwt托管安全信息,所以把session禁止掉。看下sessioncreationpolicy枚举的几个参数:

public enum sessioncreationpolicy {
 always,//总是会新建一个session。
 never,//不会新建httpsession,但是如果有session存在,就会使用它。
 if_required,//如果有要求的话,会新建一个session。
 stateless;//这个是我们用的,不会新建,也不会使用一个httpsession。

 private sessioncreationpolicy() {
 }
 }

http.addfilterbefore(authenticationtokenfilter, usernamepasswordauthenticationfilter.class);这行代码主要是用于jwt验证,后面再说。

configure(websecurity web):这个方法我代码中没有用,这个方法主要用于访问一些静态的东西控制。其中ignoring()方法可以让访问跳过filter验证。configureglobal(authenticationmanagerbuilder auth):这个方法是主要进行验证的地方,其中jwtuserdetailsservice代码待会会看,passwordencoder(passwordencoderbean())是密码的一种加密方式。

还有两个注解:@enablewebsecurity,这个注解必须加,开启security。
@enableglobalmethodsecurity(prepostenabled = true),保证post之前的注解可以使用

以上,我们可以确定了哪些路径访问不需要任何权限了,至于哪些路径需要什么权限接着往下看。

securityuserdetails

security 中也有类似于shiro中主体的概念,就是在内存中存了一个东西,方便程序判断当前请求的用户有什么权限,需要实现userdetails这个接口,所以我写了这个类,并且继承了我自己的类sysuser。

public enum sessioncreationpolicy {
 always,//总是会新建一个session。
 never,//不会新建httpsession,但是如果有session存在,就会使用它。
 if_required,//如果有要求的话,会新建一个session。
 stateless;//这个是我们用的,不会新建,也不会使用一个httpsession。

 private sessioncreationpolicy() {
 }
 }

authorities就是我们的权限,构造方法中我手动把密码set进去了,这不合适,包括权限我也是手动传进去的。这些东西都应该从数据库搜出来,我现在只是体验一把security,角色权限那一套都没写,所以说明一下就好了,这个构造方法就是传进来一个标志(我这里用的是username,或者应该用userid什么的都可以),然后给你一个完整的主体信息,供其他地方使用。ok,next。

jwtuserdetailsservice

securityconfig配置里面不是有个方法是做真正的认证嘛,或者说从数据库拿信息,具体那认证信息的方法就是在这个方法里面。

@service
public class jwtuserdetailsservice implements userdetailsservice {

  @override
  public userdetails loaduserbyusername(string user) throws usernamenotfoundexception {
    system.out.println("jwtuserdetailsservice:" + user);
    list<grantedauthority> authoritylist = new arraylist<>();
    authoritylist.add(new simplegrantedauthority("role_user"));
    return new securityuserdetails(user,authoritylist);
  }

}

继承了security提供的userdetailsservice接口,实现loaduserbyusername这个方法,我们这里手动模拟从数据库搜出来一个叫user的权限,通过刚才的构造方法,模拟生成当前user的信息,供后面jwt filter一大堆验证。至于为什么user权限要加上“role_”前缀,待会会说。

ok,现在我们知道了怎么配置各种url是否需要权限才能访问,也知道了哪里可以拿到我们的主体信息,那么继续。

jwtauthorizationtokenfilter

千呼万唤始出来,jwt终于可以上场了。至于怎么生成这个token凭证,待会会说,现在假设前端已经拿到了token凭证,要访问某个接口了,看看怎么进行jwt业务的拦截吧。

@component
public class jwtauthorizationtokenfilter extends onceperrequestfilter {

  private final userdetailsservice userdetailsservice;
  private final jwttokenutil jwttokenutil;
  private final string tokenheader;

  public jwtauthorizationtokenfilter(@qualifier("jwtuserdetailsservice") userdetailsservice userdetailsservice,
                    jwttokenutil jwttokenutil, @value("${jwt.token}") string tokenheader) {
    this.userdetailsservice = userdetailsservice;
    this.jwttokenutil = jwttokenutil;
    this.tokenheader = tokenheader;
  }

  @override
  protected void dofilterinternal(httpservletrequest request, httpservletresponse response, filterchain chain) throws servletexception, ioexception {
    final string requestheader = request.getheader(this.tokenheader);
    string username = null;
    string authtoken = null;
    if (requestheader != null && requestheader.startswith("bearer ")) {
      authtoken = requestheader.substring(7);
      try {
        username = jwttokenutil.getusernamefromtoken(authtoken);
      } catch (expiredjwtexception e) {
      }
    }

    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());
        securitycontextholder.getcontext().setauthentication(authentication);
      }

    }
    chain.dofilter(request, response);
  }
}

提前说一下,关于@value注解参数开头写了。

dofilterinternal() 这个方法就是这个过滤器的精髓了。首先从header中获取凭证authtoken,从中挖掘出来我们的username,然后看看上下文中是否有我们以这个username为标识的主体。没有,ok,去new一个(如果对象也可以new就好了。。。)。然后就是验证这个authtoken 是否在有效期呢啊,验证token是否对啊等等吧。其实我们刚刚把我们securityuserdetails这个对象叫做主体,到这里我才发现有点自做多情了,因为生成security承认的主体是通过usernamepasswordauthenticationtoken类似与这种类去实现的,之前之所以叫securityuserdetails为主体,只是它存了一些关键信息。然后将主体信息————authentication,存入上下文环境,供后面使用。

我的很多工具类代码都放到了jwttokenutil,下面贴一下代码:

@component
public class jwttokenutil implements serializable {
  private static final long serialversionuid = -3301605591108950415l;

  @value("${jwt.secret}")
  private string secret;

  @value("${jwt.expiration}")
  private long expiration;

  @value("${jwt.token}")
  private string tokenheader;

  private clock clock = defaultclock.instance;

  public string generatetoken(userdetails userdetails) {
    map<string, object> claims = new hashmap<>();
    return dogeneratetoken(claims, userdetails.getusername());
  }

  private string dogeneratetoken(map<string, object> claims, string subject) {
    final date createddate = clock.now();
    final date expirationdate = calculateexpirationdate(createddate);

    return jwts.builder()
        .setclaims(claims)
        .setsubject(subject)
        .setissuedat(createddate)
        .setexpiration(expirationdate)
        .signwith(signaturealgorithm.hs512, secret)
        .compact();
  }

  private date calculateexpirationdate(date createddate) {
    return new date(createddate.gettime() + expiration);
  }

  public boolean validatetoken(string token, userdetails userdetails) {
    securityuserdetails user = (securityuserdetails) userdetails;
    final string username = getusernamefromtoken(token);
    return (username.equals(user.getusername())
        && !istokenexpired(token)
    );
  }

  public string getusernamefromtoken(string token) {
    return getclaimfromtoken(token, claims::getsubject);
  }

  public <t> t getclaimfromtoken(string token, function<claims, t> claimsresolver) {
    final claims claims = getallclaimsfromtoken(token);
    return claimsresolver.apply(claims);
  }

  private claims getallclaimsfromtoken(string token) {
    return jwts.parser()
        .setsigningkey(secret)
        .parseclaimsjws(token)
        .getbody();
  }


  private boolean istokenexpired(string token) {
    final date expiration = getexpirationdatefromtoken(token);
    return expiration.before(clock.now());
  }

  public date getexpirationdatefromtoken(string token) {
    return getclaimfromtoken(token, claims::getexpiration);
  }

}

根据注释你能猜个大概吧,就不再说了,有些东西是jwt方面的东西,今天就不再多说了。

jwtauthenticationentrypoint

前面还说了一个发现没有凭证走一个方法,代码也贴一下。

@component
public class jwtauthenticationentrypoint implements authenticationentrypoint {
  @override
  public void commence(httpservletrequest request,
             httpservletresponse response,
             authenticationexception authexception)
      throws ioexception, servletexception {

    system.out.println("jwtauthenticationentrypoint:"+authexception.getmessage());
    response.senderror(httpservletresponse.sc_unauthorized,"没有凭证");
  }
}

实现authenticationentrypoint这个接口,发现没有凭证,往response中放些东西。

run code

下面跑一下几个接口,看看具体是怎么具体访问某个方法的吧,还有前面一点悬念一并解决。

登录

先登录一下,看看怎么生成token扔给前端的吧。

@restcontroller
public class logincontroller {

  @autowired
  @qualifier("jwtuserdetailsservice")
  private userdetailsservice userdetailsservice;

  @autowired
  private jwttokenutil jwttokenutil;

  @postmapping("/login")
  public string login(@requestbody sysuser sysuser, httpservletrequest request){
    final userdetails userdetails = userdetailsservice.loaduserbyusername(sysuser.getusername());
    final string token = jwttokenutil.generatetoken(userdetails);
    return token;
  }

  @postmapping("haha")
  public string haha(){
    userdetails userdetails = (userdetails) org.springframework.security.core.context.securitycontextholder.getcontext().getauthentication().getprincipal();
    return "haha:"+userdetails.getusername()+","+userdetails.getpassword();
  }
}

我们前面配置中已经把login设置为随便访问了,这边通过jwt生成一个token串,具体方法请看jwttokenutil.generatetoken,已经写了。只要知道这里面存了username、加密规则、过期时间就好了。

然后跑下haha接口,发现没问题,正常打印,说明主体也在上下文中了。

需要权限

然后我们访问一个需要权限的接口吧。

@restcontroller
@requestmapping("/sysuser")
public class sysusercontroller {

  @getmapping(value = "/test")
  public string test() {
    return "hello spring security";
  }

  @preauthorize("hasanyrole('user')")
  @postmapping(value = "/testneed")
  public string testneed() {
    return "testneed";
  }
}

访问testneed接口,看到没,@preauthorize("hasanyrole('user')")这个说明需要user权限!我们在刚刚生成securityuserdetails这个的时候已经模拟加入了user权限了,所以可以访问。现在说说为什么加权限的时候需要加入前缀“role_”.看hasanyrole源码:

public final boolean hasanyrole(string... roles) {
  return hasanyauthorityname(defaultroleprefix, roles);
}

private boolean hasanyauthorityname(string prefix, string... roles) {
  set<string> roleset = getauthorityset();

  for (string role : roles) {
    string defaultedrole = getrolewithdefaultprefix(prefix, role);
    if (roleset.contains(defaultedrole)) {
      return true;
    }
  }

  return false;
}

private static string getrolewithdefaultprefix(string defaultroleprefix, string role) {
  if (role == null) {
    return role;
  }
  if (defaultroleprefix == null || defaultroleprefix.length() == 0) {
    return role;
  }
  if (role.startswith(defaultroleprefix)) {
    return role;
  }
  return defaultroleprefix + role;
}

关键是 defaultroleprefix 看这个类最上面
private string defaultroleprefix = "role_";

人家源码这么干的,咱们就这么写呗,咱也不敢问。其实也有不需要前缀的方式,去看看securityexpressionroot这个类吧,用的方法不一样,也就是@preauthorize里面有另外一个参数。

一个重要的问题

先说结论:security上下文环境(里面有主体)生命周期只限于一次请求。

我做了一个测试:

把securityconfig里面configure(httpsecurity http)这个方法里面

http.addfilterbefore(authenticationtokenfilter, usernamepasswordauthenticationfilter.class);

这行代码注释掉,不走那个jwt filter。就是不每次都添加上下上下文环境。

然后logincontroller改成

@restcontroller
public class logincontroller {

  @autowired
  @qualifier("jwtuserdetailsservice")
  private userdetailsservice userdetailsservice;

  @autowired
  private jwttokenutil jwttokenutil;

  @postmapping("/login")
  public string login(@requestbody sysuser sysuser, httpservletrequest request){
    final userdetails userdetails = userdetailsservice.loaduserbyusername(sysuser.getusername());
    final string token = jwttokenutil.generatetoken(userdetails);
    //添加 start
    usernamepasswordauthenticationtoken authentication = new usernamepasswordauthenticationtoken(userdetails, null, userdetails.getauthorities());
    securitycontextholder.getcontext().setauthentication(authentication);
    //添加 end
    return token;
  }

  @postmapping("haha")
  public string haha(){
    userdetails userdetails = (userdetails) org.springframework.security.core.context.securitycontextholder.getcontext().getauthentication().getprincipal();
    return "haha:"+userdetails.getusername()+","+userdetails.getpassword();
  }
}

然后登陆,然后访问/haha,崩了,发现userdetails里面没数据。说明这会上下文环境中我们主体不存在。

为什么会这样呢?

securitycontextpersistencefilter 一次请求,filter链结束之后 会清除掉context里面的东西。所说以,主体数据生命周期是一次请求。

源码如下:

public void dofilter(servletrequest req, servletresponse res, filterchain chain)
    throws ioexception, servletexception {
  ...假装有一堆代码...
  try {
  }
  finally {
    securitycontext contextafterchainexecution = securitycontextholder
        .getcontext();
    // crucial removal of securitycontextholder contents - do this before anything
    // else.
    securitycontextholder.clearcontext();
    repo.savecontext(contextafterchainexecution, holder.getrequest(),
        holder.getresponse());
    request.removeattribute(filter_applied);
  }
}

关键就是finally里面 securitycontextholder.clearcontext(); 这句话。这才体现了那句,把维护信息的事扔给了客户端,你不请求,我也不知道你有啥。

体验小结

配置起来感觉还可以吧,使用jwt方式,生成token.由于上下文环境的生命周期是一次请求,所以在不请求的情况下,服务端不清楚用户有那些权限,真正实现了客户端维护安全信息,所以项目中也没有登出接口,因为没必要。即使前端退出了,你有token,依然可以通过postman请求接口(token没有过期)。不同于shiro可以把信息维护在服务端,要是登出,clear主体信息,访问接口就需要在登录。不过security这样也有好处,可以实现单点登陆了,也方便做分布式。(只要你不同子系统中验证那一套逻辑相同,或者在分布式的情况下有单独的验证系统)。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。