详解前后端分离之Java后端

前后端分离的思想由来已久，不妨尝试一下，从上手开始，先把代码写出来再究细节。

代码下载：https://github.com/jimolonely/authserver

前言

以前服务端为什么能识别用户呢？对，是session，每个session都存在服务端，浏览器每次请求都带着sessionid（就是一个字符串），于是服务器根据这个sessionid就知道是哪个用户了。
那么问题来了，用户很多时，服务器压力很大，如果采用分布式存储session，又可能会出现不同步问题，那么前后端分离就很好的解决了这个问题。

前后端分离思想：
在用户第一次登录成功后，服务端返回一个token回来，这个token是根据userid进行加密的，密钥只有服务器知道，然后浏览器每次请求都把这个token放在header里请求，这样服务器只需进行简单的解密就知道是哪个用户了。这样服务器就能专心处理业务，用户多了就加机器。当然，如果非要讨论安全性，那又有说不完的话题了。

下面通过springboot框架搭建一个后台，进行token构建。

构建springboot项目

我的目录结构：（结果未按标准书写，仅作说明）

不管用什么ide，最后我们只看pom.xml里的依赖：

为了尽可能简单，就不连数据库了，登陆时用固定的。

devtools：用于修改代码后自动重启；

jjwt：加密这么麻烦的事情可以用现成的，查看

<parent>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-parent</artifactid>
    <version>1.5.2.release</version>
    <relativepath /> <!-- lookup parent from repository -->
  </parent>

  <properties>
    <project.build.sourceencoding>utf-8</project.build.sourceencoding>
    <project.reporting.outputencoding>utf-8</project.reporting.outputencoding>
    <java.version>1.8</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-starter-web</artifactid>
    </dependency>

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

    <dependency>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-devtools</artifactid>
      <optional>true</optional>
    </dependency>

    <dependency>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-starter-test</artifactid>
      <scope>test</scope>
    </dependency>
  </dependencies>

登录

这里的加密密钥是：base64encodedsecretkey

import java.util.date;

import javax.servlet.servletexception;

import org.springframework.web.bind.annotation.postmapping;
import org.springframework.web.bind.annotation.requestbody;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.requestparam;
import org.springframework.web.bind.annotation.restcontroller;

import io.jsonwebtoken.jwts;
import io.jsonwebtoken.signaturealgorithm;

@restcontroller
@requestmapping("/")
public class homecontroller {

  @postmapping("/login")
  public string login(@requestparam("username") string name, @requestparam("password") string pass)
      throws servletexception {
    string token = "";
    if (!"admin".equals(name)) {
      throw new servletexception("找不到该用户");
    }
    if (!"1234".equals(pass)) {
      throw new servletexception("密码错误");
    }
    token = jwts.builder().setsubject(name).claim("roles", "user").setissuedat(new date())
        .signwith(signaturealgorithm.hs256, "base64encodedsecretkey").compact();
    return token;
  }
}

 测试token

现在就可以测试生成的token了，我们采用postman：

过滤器

这肯定是必须的呀，当然，也可以用aop。

过滤要保护的url，同时在过滤器里进行token验证

token验证：

public class jwtfilter extends genericfilterbean {

  @override
  public void dofilter(servletrequest req, servletresponse res, filterchain chain)
      throws ioexception, servletexception {
    httpservletrequest request = (httpservletrequest) req;
    httpservletresponse response = (httpservletresponse) res;
    string authheader = request.getheader("authorization");
    if ("options".equals(request.getmethod())) {
      response.setstatus(httpservletresponse.sc_ok);
      chain.dofilter(req, res);
    } else {
      if (authheader == null || !authheader.startswith("bearer ")) {
        throw new servletexception("不合法的authorization header");
      }
      // 取得token
      string token = authheader.substring(7);
      try {
        claims claims = jwts.parser().setsigningkey("base64encodedsecretkey").parseclaimsjws(token).getbody();
        request.setattribute("claims", claims);
      } catch (exception e) {
        throw new servletexception("invalid token");
      }
      chain.dofilter(req, res);
    }
  }

}

要保护的url：/user下的：

@springbootapplication
public class authserverapplication {

  @bean
  public filterregistrationbean jwtfilter() {
    filterregistrationbean rbean = new filterregistrationbean();
    rbean.setfilter(new jwtfilter());
    rbean.addurlpatterns("/user/*");// 过滤user下的链接
    return rbean;
  }

  public static void main(string[] args) {
    springapplication.run(authserverapplication.class, args);
  }
}

usercontroller

这个是必须经过过滤才可以访问的：

@restcontroller
@requestmapping("/user")
public class usercontroller {

  @getmapping("/success")
  public string success() {
    return "恭喜您登录成功";
  }

  @getmapping("/getemail")
  public string getemail() {
    return "[e-mail]";
  }
}

关键测试

假设我们的authorization错了，肯定是通不过的：

当输入刚才服务器返回的正确token：

允许跨域请求

现在来说前端和后端是两个服务器了，所以需要允许跨域：

@configuration
public class corsconfig {

  @bean
  public filterregistrationbean corsfilter() {
    urlbasedcorsconfigurationsource source = new urlbasedcorsconfigurationsource();
    corsconfiguration config = new corsconfiguration();
    config.setallowcredentials(true);
    config.addallowedorigin("*");
    config.addallowedheader("*");
    config.addallowedmethod("option");
    config.addallowedmethod("get");
    config.addallowedmethod("post");
    config.addallowedmethod("put");
    config.addallowedmethod("head");
    config.addallowedmethod("delete");
    source.registercorsconfiguration("/**", config);
    filterregistrationbean bean = new filterregistrationbean(new corsfilter(source));
    bean.setorder(0);
    return bean;
  }

  @bean
  public webmvcconfigurer mvcconfigurer() {
    return new webmvcconfigureradapter() {
      @override
      public void addcorsmappings(corsregistry registry) {
        registry.addmapping("/**").allowedmethods("get", "put", "post", "get", "options");
      }
    };
  }
}

下次是采用vuejs写的前端如何请求。

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