基于redis的小程序登录实现方法流程分析

wx.login({
 success (res) {
 if (res.code) {
 //发起网络请求
 wx.request({
 url: 'https://test.com/onlogin',
 data: {
 code: res.code
 }
 })
 } else {
 console.log('登录失败！' + res.errmsg)
 }
 }
})

@authignore
 @requestmapping("/login")
 @responsebody
 public responsebean openid(@requestparam(value = "code", required = true) string code,
  @requestparam(value = "avatarurl") string avatarurl,
  @requestparam(value = "city") string city,
  @requestparam(value = "country") string country,
  @requestparam(value = "gender") string gender,
  @requestparam(value = "language") string language,
  @requestparam(value = "nickname") string nickname,
  @requestparam(value = "province") string province,
  httpservletrequest request) { // 小程序端获取的code
 responsebean responsebean = new responsebean();
 try {
 boolean check = (stringutils.isempty(code)) ? true : false;
 if (check) {
 responsebean = new responsebean(false, unicomresponseenums.no_code);
 return responsebean;
 }
 //将获取的用户数据存入数据库;
 map<string, object> msgs = new hashmap<>();
 msgs.put("appid", appid);
 msgs.put("secret", secret);
 msgs.put("js_code", code);
 msgs.put("grant_type", "authorization_code");
 // java的网络请求，返回字符串
 string data = httputils.get(msgs, constants.jscode2session);
 logger.info("======> " + data);
 string openid = jsonobject.parseobject(data).getstring("openid");
 string session_key = jsonobject.parseobject(data).getstring("session_key");
 string unionid = jsonobject.parseobject(data).getstring("unionid");
 string errcode = jsonobject.parseobject(data).getstring("errcode");
 string errmsg = jsonobject.parseobject(data).getstring("errmsg");

 jsonobject json = new jsonobject();
 int userid = -1;

 if (!stringutils.isblank(openid)) {
 users user = userservice.selectuserbyopenid(openid);
 if (user == null) {
  //新建一个用户信息
  users newuser = new users();
  newuser.setopenid(openid);
  newuser.setarea(city);
  newuser.setsex(integer.parseint(gender));
  newuser.setnickname(nickname);
  newuser.setcreatetime(new date());
  newuser.setstatus(0);//初始
  if (!stringutils.isblank(unionid)) {
  newuser.setunionid(unionid);
  }
  userservice.instert(newuser);
  userid = newuser.getid();
 } else {
  userid = user.getid();
 }
 json.put("userid", userid);
 }
 if (!stringutils.isblank(session_key) && !stringutils.isblank(openid)) {
 //这段可不用redis存,直接返回session_key也可以
 string useragent = request.getheader("user-agent");
 string sessionid = tokenservice.generatetoken(useragent, session_key);
 //将session_key存入redis
 redisutil.setex(sessionid, session_key + "###" + userid, constants.session_key_ex);
 json.put("token", sessionid);

 responsebean = new responsebean(true, json);
 } else {
 responsebean = new responsebean<>(false, null, errmsg);
 }
 return responsebean;
 } catch (exception e) {
 e.printstacktrace();
 responsebean = new responsebean(false, unicomresponseenums.jscode2session_erro);
 return responsebean;
 }
 }

/**
 * httputils工具类
 *
 * @author
 */
public class httputils {
 /**
 * 请求方式：post
 */
 public static string post = "post";
 /**
 * 编码格式：utf-8
 */
 private static final string charset_utf_8 = "utf-8";
 /**
 * 报文头部json
 */
 private static final string application_json = "application/json";
 /**
 * 请求超时时间
 */
 private static final int connect_timeout = 60 * 1000;
 /**
 * 传输超时时间
 */
 private static final int so_timeout = 60 * 1000;
 /**
 * 日志
 */
 private static final logger logger = loggerfactory.getlogger(httputils.class);
 /**
 * @param protocol
 * @param url
 * @param paramap
 * @return
 * @throws exception
 */
 public static string dopost(string protocol, string url,
  map<string, object> paramap) throws exception {
 closeablehttpclient httpclient = null;
 closeablehttpresponse resp = null;
 string rtnvalue = null;
 try {
 if (protocol.equals("http")) {
 httpclient = httpclients.createdefault();
 } else {
 // 获取https安全客户端
 httpclient = httputils.gethttpsclient();
 }
 httppost httppost = new httppost(url);
 list<namevaluepair> list = msgs2valuepairs(paramap);
// list<namevaluepair> list = new arraylist<namevaluepair>();
// if (null != paramap &&paramap.size() > 0) {
// for (entry<string, object> entry : paramap.entryset()) {
//  list.add(new basicnamevaluepair(entry.getkey(), entry
//  .getvalue().tostring()));
// }
// }
 requestconfig requestconfig = requestconfig.custom()
  .setsockettimeout(so_timeout)
  .setconnecttimeout(connect_timeout).build();// 设置请求和传输超时时间
 httppost.setconfig(requestconfig);
 httppost.setentity(new urlencodedformentity(list, charset_utf_8));
 resp = httpclient.execute(httppost);
 rtnvalue = entityutils.tostring(resp.getentity(), charset_utf_8);
 } catch (exception e) {
 logger.error(e.getmessage());
 throw e;
 } finally {
 if (null != resp) {
 resp.close();
 }
 if (null != httpclient) {
 httpclient.close();
 }
 }
 return rtnvalue;
 }
 /**
 * 获取https，单向验证
 *
 * @return
 * @throws exception
 */
 public static closeablehttpclient gethttpsclient() throws exception {
 try {
 trustmanager[] trustmanagers = new trustmanager[]{new x509trustmanager() {
 public void checkclienttrusted(
  x509certificate[] paramarrayofx509certificate,
  string paramstring) throws certificateexception {
 }
 public void checkservertrusted(
  x509certificate[] paramarrayofx509certificate,
  string paramstring) throws certificateexception {
 }
 public x509certificate[] getacceptedissuers() {
  return null;
 }
 }};
 sslcontext sslcontext = sslcontext
  .getinstance(sslconnectionsocketfactory.tls);
 sslcontext.init(new keymanager[0], trustmanagers,
  new securerandom());
 sslcontext.setdefault(sslcontext);
 sslcontext.init(null, trustmanagers, null);
 sslconnectionsocketfactory connectionsocketfactory = new sslconnectionsocketfactory(
  sslcontext,
  sslconnectionsocketfactory.allow_all_hostname_verifier);
 httpclientbuilder clientbuilder = httpclients.custom()
  .setsslsocketfactory(connectionsocketfactory);
 clientbuilder.setredirectstrategy(new laxredirectstrategy());
 closeablehttpclient httpclient = clientbuilder.build();
 return httpclient;
 } catch (exception e) {
 throw new exception("http client 远程连接失败", e);
 }
 }
 /**
 * post请求
 *
 * @param msgs
 * @param url
 * @return
 * @throws clientprotocolexception
 * @throws unknownhostexception
 * @throws ioexception
 */
 public static string post(map<string, object> msgs, string url)
 throws clientprotocolexception, unknownhostexception, ioexception {
 closeablehttpclient httpclient = httpclients.createdefault();
 try {
 httppost request = new httppost(url);
 list<namevaluepair> valuepairs = msgs2valuepairs(msgs);
// list<namevaluepair> valuepairs = new arraylist<namevaluepair>();
// if (null != msgs) {
// for (entry<string, object> entry : msgs.entryset()) {
//  if (entry.getvalue() != null) {
//  valuepairs.add(new basicnamevaluepair(entry.getkey(),
//  entry.getvalue().tostring()));
//  }
// }
// }
 request.setentity(new urlencodedformentity(valuepairs, charset_utf_8));
 closeablehttpresponse resp = httpclient.execute(request);
 return entityutils.tostring(resp.getentity(), charset_utf_8);
 } finally {
 httpclient.close();
 }
 }
 /**
 * post请求
 *
 * @param msgs
 * @param url
 * @return
 * @throws clientprotocolexception
 * @throws unknownhostexception
 * @throws ioexception
 */
 public static byte[] postgetbyte(map<string, object> msgs, string url)
 throws clientprotocolexception, unknownhostexception, ioexception {
 closeablehttpclient httpclient = httpclients.createdefault();
 inputstream inputstream = null;
 byte[] data = null;
 try {
 httppost request = new httppost(url);
 list<namevaluepair> valuepairs = msgs2valuepairs(msgs);
// list<namevaluepair> valuepairs = new arraylist<namevaluepair>();
// if (null != msgs) {
// for (entry<string, object> entry : msgs.entryset()) {
//  if (entry.getvalue() != null) {
//  valuepairs.add(new basicnamevaluepair(entry.getkey(),
//  entry.getvalue().tostring()));
//  }
// }
// }
 request.setentity(new urlencodedformentity(valuepairs, charset_utf_8));
 closeablehttpresponse response = httpclient.execute(request);
 try {
 // 获取相应实体
 httpentity entity = response.getentity();
 if (entity != null) {
  inputstream = entity.getcontent();
  data = readinputstream(inputstream);
 }
 return data;
 } catch (exception e) {
 e.printstacktrace();
 } finally {
 httpclient.close();
 return null;
 }
 } finally {
 httpclient.close();
 }
 }
 /** 将流 保存为数据数组
 * @param instream
 * @return
 * @throws exception
 */
 public static byte[] readinputstream(inputstream instream) throws exception {
 bytearrayoutputstream outstream = new bytearrayoutputstream();
 // 创建一个buffer字符串
 byte[] buffer = new byte[1024];
 // 每次读取的字符串长度，如果为-1，代表全部读取完毕
 int len = 0;
 // 使用一个输入流从buffer里把数据读取出来
 while ((len = instream.read(buffer)) != -1) {
 // 用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
 outstream.write(buffer, 0, len);
 }
 // 关闭输入流
 instream.close();
 // 把outstream里的数据写入内存
 return outstream.tobytearray();
 }
 /**
 * get请求
 *
 * @param msgs
 * @param url
 * @return
 * @throws clientprotocolexception
 * @throws unknownhostexception
 * @throws ioexception
 */
 public static string get(map<string, object> msgs, string url)
 throws clientprotocolexception, unknownhostexception, ioexception {
 closeablehttpclient httpclient = httpclients.createdefault();
 try {
 list<namevaluepair> valuepairs = msgs2valuepairs(msgs);
// list<namevaluepair> valuepairs = new arraylist<namevaluepair>();
// if (null != msgs) {
// for (entry<string, object> entry : msgs.entryset()) {
//  if (entry.getvalue() != null) {
//  valuepairs.add(new basicnamevaluepair(entry.getkey(),
//  entry.getvalue().tostring()));
//  }
// }
// }
 // entityutils.tostring(new urlencodedformentity(valuepairs),
 // charset);
 url = url + "?" + urlencodedutils.format(valuepairs, charset_utf_8);
 httpget request = new httpget(url);
 closeablehttpresponse resp = httpclient.execute(request);
 return entityutils.tostring(resp.getentity(), charset_utf_8);
 } finally {
 httpclient.close();
 }
 }
 public static <t> t post(map<string, object> msgs, string url,
  class<t> clazz) throws clientprotocolexception,
 unknownhostexception, ioexception {
 string json = httputils.post(msgs, url);
 t t = json.parseobject(json, clazz);
 return t;
 }
 public static <t> t get(map<string, object> msgs, string url, class<t> clazz)
 throws clientprotocolexception, unknownhostexception, ioexception {
 string json = httputils.get(msgs, url);
 t t = json.parseobject(json, clazz);
 return t;
 }
 public static string postwithjson(map<string, object> msgs, string url)
 throws clientprotocolexception, ioexception {
 closeablehttpclient httpclient = httpclients.createdefault();
 try {
 string jsonparam = json.tojsonstring(msgs);
 httppost post = new httppost(url);
 post.setheader("content-type", application_json);
 post.setentity(new stringentity(jsonparam, charset_utf_8));
 closeablehttpresponse response = httpclient.execute(post);
 return new string(entityutils.tostring(response.getentity()).getbytes("iso8859-1"), charset_utf_8);
 } finally {
 httpclient.close();
 }
 }
 public static <t> t postwithjson(map<string, object> msgs, string url, class<t> clazz) throws clientprotocolexception,
 unknownhostexception, ioexception {
 string json = httputils.postwithjson(msgs, url);
 t t = json.parseobject(json, clazz);
 return t;
 }
 public static list<namevaluepair> msgs2valuepairs(map<string, object> msgs) {
 list<namevaluepair> valuepairs = new arraylist<namevaluepair>();
 if (null != msgs) {
 for (entry<string, object> entry : msgs.entryset()) {
 if (entry.getvalue() != null) {
  valuepairs.add(new basicnamevaluepair(entry.getkey(),
  entry.getvalue().tostring()));
 }
 }
 }
 return valuepairs;
 }
}

import java.lang.annotation.*;
@target({elementtype.method,elementtype.type})
@retention(retentionpolicy.runtime)
@documented
public @interface authignore {
}

 @override
 public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) throws exception {
 authignore annotation;
 if(handler instanceof handlermethod) {
 annotation = ((handlermethod) handler).getmethodannotation(authignore.class);
 }else{
 return true;
 }
 //如果有@authignore注解，则不验证token
 if(annotation != null){
 return true;
 }
// //获取微信access_token;
// if(!redisutil.exists(constants.access_token)){
// map<string, object> msgs = new hashmap<>();
// msgs.put("appid",appid);
// msgs.put("secret",secret);
// msgs.put("grant_type","client_credential");
// string data = httputils.get(msgs,constants.getaccesstoken); // java的网络请求，返回字符串
// string errcode= jsonobject.parseobject(data).getstring("errcode");
// string errmsg= jsonobject.parseobject(data).getstring("errmsg");
// if(stringutils.isblank(errcode)){
// //存储access_token
// string access_token= jsonobject.parseobject(data).getstring("access_token");
// long expires_in=long.parselong(jsonobject.parseobject(data).getstring("expires_in"));
// redisutil.setex("access_token",access_token, expires_in);
// }else{
// //异常返回数据拦截，返回json数据
// response.setcharacterencoding("utf-8");
// response.setcontenttype("application/json; charset=utf-8");
// printwriter out = response.getwriter();
// responsebean<object> responsebean=new responsebean<>(false,null, errmsg);
// out = response.getwriter();
// out.append(json.tojson(responsebean).tostring());
// return false;
// }
// }
 //获取用户凭证
 string token = request.getheader(constants.user_token);
// if(stringutils.isblank(token)){
// token = request.getparameter(constants.user_token);
// }
// if(stringutils.isblank(token)){
// object obj = request.getattribute(constants.user_token);
// if(null!=obj){
// token=obj.tostring();
// }
// }
// //token凭证为空
// if(stringutils.isblank(token)){
// //token不存在拦截，返回json数据
// response.setcharacterencoding("utf-8");
// response.setcontenttype("application/json; charset=utf-8");
// printwriter out = response.getwriter();
// try{
// responsebean<object> responsebean=new responsebean<>(false,null, unicomresponseenums.token_empty);
// out = response.getwriter();
// out.append(json.tojson(responsebean).tostring());
// return false;
// }
// catch (exception e) {
// e.printstacktrace();
// response.senderror(500);
// return false;
// }
// }
 if(token==null||!redisutil.exists(token)){
 //用户未登录，返回json数据
 response.setcharacterencoding("utf-8");
 response.setcontenttype("application/json; charset=utf-8");
 printwriter out = response.getwriter();
 try{
 responsebean<object> responsebean=new responsebean<>(false,null, unicomresponseenums.dis_login);
 out = response.getwriter();
 out.append(json.tojson(responsebean).tostring());
 return false;
 }
 catch (exception e) {
 e.printstacktrace();
 response.senderror(500);
 return false;
 }
 }
 tokenmanager.refreshusertoken(token);
 return true;
 }
}

@configuration
public class interceptorconfig extends webmvcconfigureradapter {
 @override
 public void addinterceptors(interceptorregistry registry) {
 registry.addinterceptor(authorizationinterceptor())
 .addpathpatterns("/**")// 拦截所有请求，通过判断是否有 @authignore注解 决定是否需要登录
 .excludepathpatterns("/user/login");//排除登录
 }
 @bean
 public authorizationinterceptor authorizationinterceptor() {
 return new authorizationinterceptor();
 }
}

@service
public class tokenmanager {
 @resource
 private redisutil redisutil;
 //生成token(格式为token:设备-加密的用户名-时间-六位随机数)
 public string generatetoken(string useragentstr, string username) {
 stringbuilder token = new stringbuilder("token:");
 //设备
 useragent useragent = useragent.parseuseragentstring(useragentstr);
 if (useragent.getoperatingsystem().ismobiledevice()) {
 token.append("mobile-");
 } else {
 token.append("pc-");
 }
 //加密的用户名
 token.append(md5utils.md5encode(username) + "-");
 //时间
 token.append(new simpledateformat("yyyymmddhhmmsssss").format(new date()) + "-");
 //六位随机字符串
 token.append(uuid.randomuuid().tostring());
 system.out.println("token-->" + token.tostring());
 return token.tostring();
 }
 /**
 * 登录用户，创建token
 *
 * @param token
 */
 //把token存到redis中
 public void save(string token, users user) {
 if (token.startswith("token:pc")) {
 redisutil.setex(token,json.tojsonstring(user), constants.token_ex);
 } else {
 redisutil.setex(token,json.tojsonstring(user), constants.token_ex);
 }
 }
 /**
 * 刷新用户
 *
 * @param token
 */
 public void refreshusertoken(string token) {
 if (redisutil.exists(token)) {
 string value=redisutil.get(token);
 redisutil.setex(token, value, constants.token_ex);
 }
 }
 /**
 * 用户退出登陆
 *
 * @param token
 */
 public void loginout(string token) {
 redisutil.remove(token);
 }
 /**
 * 获取用户信息
 *
 * @param token
 * @return
 */
 public users getuserinfobytoken(string token) {
 if (redisutil.exists(token)) {
 string jsonstring = redisutil.get(token);
 users user =jsonobject.parseobject(jsonstring, users.class);
 return user;
 }
 return null;
 }
}

@component
public class redisutil {
 @resource
 private redistemplate<string, string> redistemplate;
 public void set(string key, string value) {
 valueoperations<string, string> valueoperations = redistemplate.opsforvalue();
 valueoperations.set(key, value);
 }
 public void setex(string key, string value, long seconds) {
 valueoperations<string, string> valueoperations = redistemplate.opsforvalue();
 valueoperations.set(key, value, seconds,timeunit.seconds);
 }
 public boolean exists(string key) {
 return redistemplate.haskey(key);
 }
 public void remove(string key) {
 redistemplate.delete(key);
 }
 public string get(string key) {
 valueoperations<string, string> valueoperations = redistemplate.opsforvalue();
 return valueoperations.get(key);
 }
}

@configuration
@conditionalonclass(redisoperations.class)
@enableconfigurationproperties(redisproperties.class)
public class redisconfig {
 @bean
 @conditionalonmissingbean(name = "redistemplate")
 public redistemplate<object, object> redistemplate(
 redisconnectionfactory redisconnectionfactory) {
 redistemplate<object, object> template = new redistemplate<>();
 //使用fastjson序列化
 fastjsonredisserializer fastjsonredisserializer = new fastjsonredisserializer(object.class);
 // value值的序列化采用fastjsonredisserializer
 template.setvalueserializer(fastjsonredisserializer);
 template.sethashvalueserializer(fastjsonredisserializer);
 // key的序列化采用stringredisserializer
 template.setkeyserializer(new stringredisserializer());
 template.sethashkeyserializer(new stringredisserializer());
 template.setconnectionfactory(redisconnectionfactory);
 return template;
 }
 @bean
 @conditionalonmissingbean(stringredistemplate.class)
 public stringredistemplate stringredistemplate(
 redisconnectionfactory redisconnectionfactory) {
 stringredistemplate template = new stringredistemplate();
 template.setconnectionfactory(redisconnectionfactory);
 return template;
 }
}