webservice-自定义注解处理参数加解密问题

webservice-自定义注解处理参数加解密问题

前一段项目中用到了webservice,正好自己之前也了解过一点apache的cxf框架,所以就采用了cxf来实现webservice服务端,本身实现并没技术难点,但是项目为了保证安全性,采用了传输加密的过程,所以大部分请求参数需要加密,返回参数也需要加密,大致流程是:

请求参数对称加密+对称秘钥非对称加密,
返回参数堆成加密+对称秘钥非对称加密

参数加密本身并不复杂,但是有些服务并不需要加密,有些则需要,加密工具类并不通用
string,datahandler等不能重用,虽然本质都是对字节数据加密,但是要写许多方法,还要方法参数,检查需要加解密处理的参数,然后寻找对应的类型处理方法调用.
逻辑很清晰,但是过程实现很恶心,最终这样实现了一版,但是并不合我的意.

如果能在拦截器中获取到参数列表,然后寻找对应的解码器解码,这样就比较简单了.但是难点是,如果标记参数,并指定被标记参数的解码器尼?
我想到了注解,注解就可以标记,参数,然后通过反射获取到注解,解析出内容.
本来想标记到参数上,但是一个个标记太麻烦,而且获取也不太方便,索性就放在方法上,用数组来接收.
问题解决.

代码实现

自定义注解:

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


/** * @author webservice请求参数自定义注解 * */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestHanleAnnotation {
    Class[] handler() default {};
    int[] index() default {};

}

参数解码器接口

import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * @author taoyuan *参数处理器 * @param <T> */ public abstract class ParamHandler<T> { //解码器实例缓存 public static final Map<Class,ParamHandler> hanlers=new ConcurrentHashMap<>(); //处理方法 abstract T handle(T t); } 

解码器实现,这里并没有真正解码,只是在参数后面加了123

public class StringHandler extends ParamHandler<String> { @Override public String handle(String t) { return t+"123"; } } 

服务方法注解使用

//表示第一个参数需要StringHandler处理
    @RequestHanleAnnotation(index=0,handler=StringHandler.class)
    public String test(String test,String test2) throws Exception {
        System.out.println(test);
        System.out.println(test2);
        return "cesshi";


    }

拦截器实现

  import java.io.File; import java.lang.reflect.Method; import java.util.Map; import org.apache.commons.io.FileUtils; import org.apache.cxf.binding.soap.SoapMessage; import org.apache.cxf.interceptor.Fault; import org.apache.cxf.message.MessageContentsList; import org.apache.cxf.phase.AbstractPhaseInterceptor; import org.apache.cxf.phase.Phase; import org.apache.log4j.Logger; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; /** * @author 都市桃源 */ public class EcrInInterceptor extends AbstractPhaseInterceptor<SoapMessage>{ private Logger log = Logger.getLogger(ContractLogicImpl.class); public EcrInInterceptor(){ // 在调用方法之前调用拦截器 super(Phase.PRE_INVOKE); } @Override public void handleMessage(SoapMessage msg) throws Fault { /*获取请求ip,拦截器中可以做下统一日志处理 HttpServletRequest httprequest = (HttpServletRequest)msg.get(AbstractHTTPDestination.HTTP_REQUEST); * */ //获取正在执行的方法 Method method = MsgUtil.getSoapMethod(msg); //解析注解,并处理参数 MessageContentsList contentsList = MessageContentsList.getContentsList(msg); MsgUtil.handle(method,contentsList); } @Override public void handleFault(SoapMessage message) { super.handleFault(message); } 

注解解析工具类实现

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import org.apache.cxf.binding.soap.SoapMessage;
import org.apache.cxf.message.Exchange;
import org.apache.cxf.message.MessageContentsList;
import org.apache.cxf.service.Service;
import org.apache.cxf.service.invoker.MethodDispatcher;
import org.apache.cxf.service.model.BindingOperationInfo;




/** * @author ll * 获取方法名称 * */
public class MsgUtil {
    /**根据消息获取调用方法 * @param msg * @return */
    public static Method getSoapMethod(SoapMessage msg){
         Exchange exchange = msg.getExchange();  
            BindingOperationInfo bop = exchange.get(BindingOperationInfo.class);  
            MethodDispatcher md = (MethodDispatcher) exchange.get(Service.class)  
                    .get(MethodDispatcher.class.getName());  
            Method method = md.getMethod(bop);
            return method; 
    }
    public static void handle(Method method,MessageContentsList contentsList) {
        if(method==null)return;
        RequestHanleAnnotation reqAnno= method.getAnnotation(RequestHanleAnnotation.class);
        int[] indexs = reqAnno.index();
        if(indexs==null||indexs.length==0)return;
        Class[] handlers = reqAnno.handler();
        try {
            //处理器实例
            ParamHandler handler=null;
        for(int i=0,len=indexs.length;i<len;i++){
                //获取需要处理的参数
                Object obj = contentsList.get(indexs[i]);
                //从缓存中获取处理器实例
                handler=ParamHandler.hanlers.get(handlers[i]);
                if(handler==null){
                    //创建处理器实例
                    handler=(ParamHandler) handlers[i].newInstance();
                    //缓存处理器实例
                    ParamHandler.hanlers.put(handlers[i],handler);
                }
                 contentsList.set(indexs[i],handler.handle(obj));
        }
        }catch (Exception e) {
            e.printStackTrace();
        }

    }

}

返回参数同样也可以注解实现,这里就不在赘述了,实现也比较简单.

**需要注意的是,拦截器拦截顺序不一样 拦截器统一继承 AbstractPhaseInterceptor类,请求拦截 :super(Phase.PRE_INVOKE); 返回拦截: super(Phase.PRE_STREAM);**