浅谈Java 三种方式实现接口校验

2023-09-22 23:45:04 279

本文介绍了Java三种方式实现接口校验，主要包括AOP，MVC拦截器，分享给大家，具体如下：

方法一：AOP

代码如下定义一个权限注解

packagecom.thinkgem.jeesite.common.annotation;

importjava.lang.annotation.ElementType;
importjava.lang.annotation.Retention;
importjava.lang.annotation.RetentionPolicy;
importjava.lang.annotation.Target;

/**
*权限注解
*CreatedbyHammingon2016/12/
*/
@Target(ElementType.METHOD)//这个注解是应用在方法上
@Retention(RetentionPolicy.RUNTIME)
public@interfaceAccessToken{
/*StringuserId();
Stringtoken();*/
}

获取页面请求中的IDtoken

@Aspect
@Component
publicclassAccessTokenAspect{

@Autowired
privateApiServiceapiService;

@Around("@annotation(com.thinkgem.jeesite.common.annotation.AccessToken)")
publicObjectdoAccessCheck(ProceedingJoinPointpjp)throwsThrowable{
HttpServletRequestrequest=((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
Stringid=request.getParameter("id");
Stringtoken=request.getParameter("token");
booleanverify=apiService.verifyToken(id,token);
if(verify){
Objectobject=pjp.proceed();//执行连接点方法
//获取执行方法的参数

returnobject;
}else{
returnResultApp.error(3,"token失效");
}
}
}

token验证类存储用到redis

packagecom.thinkgem.jeesite.common.service;

importcom.thinkgem.jeesite.common.utils.JedisUtils;
importio.jsonwebtoken.Jwts;
importio.jsonwebtoken.SignatureAlgorithm;
importio.jsonwebtoken.impl.crypto.MacProvider;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Service;
importorg.springframework.transaction.annotation.Transactional;
importredis.clients.jedis.Jedis;

importjava.io.*;
importjava.security.Key;
importjava.util.Date;

/**
*token登陆验证
*CreatedbyHammingon2016/12/
*/
@Service
publicclassApiService{
privatestaticfinalStringat="accessToken";

publicstaticKeykey;

//privateLoggerlogger=LoggerFactorygetLogger(getClass());
/**
*生成token
*Key以字节流形式存入redis
*
*@paramdate失效时间
*@paramappIdAppId
*@return
*/
publicStringgenerateToken(Datedate,StringappId){
Jedisjedis=null;
try{
jedis=JedisUtils.getResource();
byte[]buf=jedis.get("api:key".getBytes());
if(buf==null){//建新的key
key=MacProvider.generateKey();
ByteArrayOutputStreambao=newByteArrayOutputStream();
ObjectOutputStreamoos=newObjectOutputStream(bao);
oos.writeObject(key);
buf=bao.toByteArray();
jedis.set("api:key".getBytes(),buf);
}else{//重用老key
key=(Key)newObjectInputStream(newByteArrayInputStream(buf)).readObject();
}

}catch(IOExceptionio){
//System.out.println(io);
}catch(ClassNotFoundExceptionc){
//System.out.println(c);
}catch(Exceptione){
//logger.error("ApiService","generateToken",key,e);
}finally{
JedisUtils.returnResource(jedis);
}

Stringtoken=Jwts.builder()
.setSubject(appId)
.signWith(SignatureAlgorithm.HS512,key)
.setExpiration(date)
.compact();
//计算失效秒,7889400秒三个月
Datetemp=newDate();
longinterval=(date.getTime()-temp.getTime())/1000;
JedisUtils.set(at+appId,token,(int)interval);
returntoken;
}

/**
*验证token
*@paramappIdAppId
*@paramtokentoken
*@return
*/
publicbooleanverifyToken(StringappId,Stringtoken){
if(appId==null||token==null){
returnfalse;
}
Jedisjedis=null;
try{
jedis=JedisUtils.getResource();
if(key==null){
byte[]buf=jedis.get("api:key".getBytes());
if(buf==null){
returnfalse;
}
key=(Key)newObjectInputStream(newByteArrayInputStream(buf))readObject();
}
Jwts.parser().setSigningKey(key).parseClaimsJws(token).getBody().getSubject().equals(appId);
returntrue;
}catch(Exceptione){
//logger.error("ApiService","verifyToken",key,e);
returnfalse;
}finally{
JedisUtils.returnResource(jedis);
}
}

/**
*获取token
*@paramappId
*@return
*/
publicStringgetToken(StringappId){
Jedisjedis=null;
try{
jedis=JedisUtils.getResource();
returnjedis.get(at+appId);
}catch(Exceptione){
//logger.error("ApiService","getToken",e);
return"";
}finally{
JedisUtils.returnResource(jedis);
}
}
}

springaop配置

验证权限方法使用直接用注解就可以了AccessToken

例如

packagecom.thinkgem.jeesite.modules.app.web.pay;

importcom.alibaba.fastjson.JSON;
importcom.thinkgem.jeesite.common.annotation.AccessToken;
importcom.thinkgem.jeesite.common.base.ResultApp;
importcom.thinkgem.jeesite.modules.app.service.pay.AppAlipayConfService;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Controller;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RequestMethod;
importorg.springframework.web.bind.annotation.ResponseBody;

importjava.util.HashMap;
importjava.util.Map;

/**
*支付接口
*CreatedbyHammingon2016/12/
*/
@Controller
@RequestMapping(value="/app/pay")
publicclassAppPayModule{

@Autowired
privateAppAlipayConfServiceappAlipayConfService;

@RequestMapping(value="/alipay",method=RequestMethodPOST,produces="application/json")
@AccessToken
@ResponseBody
publicObjectalipay(StringorderId){
if(orderId==null){
Mapre=newHashMap<>();
re.put("result",3);
re.put("msg","参数错误");
Stringjson=JSONtoJSONString(re);
returnjson;
}else{
returnnull;
}
}
}

方法二：AOP方法2

1.定义一个查询父类，里面包含到authToken跟usedId两个属性，所有需要校验用户的请求的查询参数都继承这个查询父类，之所以会有这个userId，是因为我们校验得到用户之后，需要根据用户Id获取一些用户数据的，所以在AOP层我们就回填了这个参数了，这样也不会影响之前的代码逻辑(这个可能跟我的业务需求有关了)

publicclassAuthSearchVO{

publicStringauthToken;//校验字符串

publicIntegeruserId;//APP用户Id

publicfinalStringgetAuthToken(){
returnauthToken;
}

publicfinalvoidsetAuthToken(StringauthToken){
this.authToken=authToken;
}

publicfinalIntegergetUserId(){
returnuserId;
}

publicfinalvoidsetUserId(IntegeruserId){
this.userId=userId;
}

@Override
publicStringtoString(){
return"SearchVO[authToken="+authToken+",userId="+userId+"]";
}

}

2.定义一个方法级的注解，所有需要校验的请求都加上这个注解，用于AOP的拦截(当然你也可以拦截所有控制器的请求)

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public@interfaceAuthToken{
Stringtype();
}

3.AOP处理，之所以会将注解作为参数传进来，是因为考虑到可能会有多个APP的校验，可以利用注解的type属性加以区分

publicclassAuthTokenAOPInterceptor{

@Resource
privateAppUserServiceappUserService;

privatestaticfinalStringauthFieldName="authToken";
privatestaticfinalStringuserIdFieldName="userId";

publicvoidbefore(JoinPointjoinPoint,AuthTokenauthToken)throwsThrowable{

Object[]args=joinPoint.getArgs();//获取拦截方法的参数
booleanisFound=false;
for(Objectarg:args){
if(arg!=null){
Classclazz=arg.getClass();//利用反射获取属性值
Field[]fields=clazz.getDeclaredFields();
intauthIndex=-1;
intuserIdIndex=-1;
for(inti=0;i=0&userIdIndex>=0){
isFound=true;
authTokenCheck(fields[authIndex],fields[userIdIndex],arg,authToken);//校验用户
break;
}
}
}
if(!isFound){
thrownewBizException(ErrorMessage.CHECK_AUTHTOKEN_FAIL);
}

}

privatevoidauthTokenCheck(FieldauthField,FielduserIdField,Objectarg,AuthTokenauthToken)throwsException{
if(String.class==authField.getType()){
StringauthTokenStr=(String)authField.get(arg);//获取到校验Token
AppUseruser=appUserService.getUserByAuthToken(authTokenStr);
if(user!=null){
userIdField.set(arg,user.getId());
}else{
thrownewBizException(ErrorMessage.CHECK_AUTHTOKEN_FAIL);
}
}

}
}

4.最后就是在配置文件中配置这个AOP了(因为我们的spring版本跟aspect版本有点出入，导致用不了基于注解的方式)

最后给出测试代码，这样的代码就优雅很多了

@RequestMapping(value="/appointments",method={RequestMethod.GET})
@ResponseBody
@AuthToken(type="disticntApp")
publicListgetAppointments(AppointmentSearchVoappointmentSearchVo){
Listappointments=appointmentService.getAppointment(appointmentSearchVo.getUserId(),appointmentSearchVo);
returnappointments;
}

方法三：MVC拦截器

服务器：

拼接token之外所有参数，最后拼接token_key，做MD5，与token参数比对

如果token比对失败返回状态码500

publicclassAPIInterceptorextendsHandlerInterceptorAdapter{

@Override
publicbooleanpreHandle(HttpServletRequestrequest,
HttpServletResponseresponse,Objecthandler)throwsException{
Log.info(request);

Stringtoken=request.getParameter("token");

//tokenisnotneededwhendebug
if(token==null)returntrue;//!!remembertocommentthiswhendeployonserver!!

EnumerationparaKeys=request.getParameterNames();
StringencodeStr="";
while(paraKeys.hasMoreElements()){
StringparaKey=(String)paraKeys.nextElement();
if(paraKey.equals("token"))
break;
StringparaValue=request.getParameter(paraKey);
encodeStr+=paraValue;
}
encodeStr+=Default.TOKEN_KEY;
Log.out(encodeStr);

if(!token.equals(DigestUtils.md5Hex(encodeStr))){
response.setStatus(500);
returnfalse;
}

returntrue;
}

@Override
publicvoidpostHandle(HttpServletRequestrequest,
HttpServletResponseresponse,Objecthandler,
ModelAndViewmodelAndView)throwsException{
Log.info(request);
}

@Override
publicvoidafterCompletion(HttpServletRequestrequest,
HttpServletResponseresponse,Objecthandler,Exceptionex)
throwsException{

}
}

spring-config.xml配置中加入

客户端：

拼接请求接口的所有参数，最后拼接token_key，做MD5，作为token参数

请求样例：http://127.0.0.1:8080/interface/api?key0=param0&key1=param1&token=md5(concat(param0,param1))

api测试页面，用到了Bootstrap和AngularJS，还有一个js的hex_md5函数





APItest








Search:
token_key
md5{{md5(str)}}





{{api.request(api.params,value0,value1,value2,value3,value4,value5,value6,value7,value8,value9)}}



{{concat(value0,value1,value2,value3,value4,value5,value6,value7,value8,value9)}}


{{api.params[0]}}
{{api.params[1]}}
{{api.params[2]}}
{{api.params[3]}}
{{api.params[4]}}
{{api.params[5]}}
{{api.params[6]}}
{{api.params[7]}}
{{api.params[8]}}
{{api.params[9]}}
token

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

浅谈Java 三种方式实现接口校验

热门推荐

随机推荐