自定义注解API数据加密和签名校验

最新推荐文章于 2024-04-23 14:44:44 发布
最新推荐文章于 2024-04-23 14:44:44 发布
阅读量4.7w 收藏 5
点赞数 3
分类专栏： java SpringBoot 文章标签： API设计 数据签名 对称加密 MD5 SHA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beishangbuzailai/article/details/86575532
版权
  • api数据数据签名(MD5,SHA1)
    • 签名枚举类SginEnum.java
package com.jx.app.api.framework.annotation.enums;

/**  
* @ClassName: SginEnum  
* @Description: TODO(这是一个签名枚举类)  
* @author gangyu
* @date 2018年11月20日 下午4:30:44  
*/
public enum SginEnum {
	//0不需要签名，1使用MD5数据加密 2 使用SHA数据加密
	ANY(0), MD5(1), SHA1(2);
	private final int value;

	private SginEnum(int value) {
		this.value = value;
	}

	public int getValue() {
		return value;
	}
}
  • 签名注解类SginAnot.java
/**    
* @Title: SginAnot.java  
* @Package com.jxkj.app.api.framework  
* @Description: TODO(用一句话描述该文件做什么)  
* @author gangyu
* @date 2018年11月20日 下午4:07:58  
* @version V1.0    
*/
package com.jx.app.api.framework.annotation;

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

import com.jx.app.api.framework.annotation.enums.SginEnum;

/**  
* @ClassName: SginAnot  
* @Description: TODO(签名验证注解)  
* @author gangyu
* @date 2018年11月20日 下午4:07:58  
*    
*/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface SginAnot {
	SginEnum type() default SginEnum.ANY;//默认不需要签名
}
  • 加密工具类MD5.java
package com.jx.common.entrypt;

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jx.common.utils.BeanUtil;
import com.jx.common.utils.TestEntity;

/**
 * @ClassName: MD5
 * @Description: TODO(MD5加密工具)
 * @author gangyu
 * @date 2018年11月20日 下午2:12:14
 *
 */
public class MD5 {


	private static final Logger log = LoggerFactory.getLogger(MD5.class);

	public static String PRIVATE_KEY = "这是你的密钥";
	
    private static final String hexDigIts[] = {"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"};

	public static String encrypt(String plainText) {
		try {
			return encrypt(plainText,true);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			log.error("MD5加密异常:",e);
			return null;
		}
	}
	
	/**
	 * @Title: encrypt
	 * @Description: TODO(16位或32位密码)
	 * @param @param
	 *            plainText
	 * @param @param
	 *            flag true为32位,false为16位
	 * @throws UnsupportedEncodingException
	 */
	public static String encrypt(String plainText, boolean flag) throws UnsupportedEncodingException {
		try {
			if (StringUtils.isEmpty(plainText)) {
				return null;
			}
			MessageDigest md = MessageDigest.getInstance("MD5");
            String	encrStr = byteArrayToHexString(md.digest(plainText.getBytes("UTF-8")));
			if (flag)
				return encrStr;
			else
				return encrStr.substring(8, 24);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
			return null;
		}

	}

	@SuppressWarnings("unchecked")
	public static String encrypt(Object obj){
		if(obj==null){
			return null;
		}
		Map<String, Object> map = new HashMap<String,Object>();
		if(obj instanceof Map){
			map=(Map<String, Object>) obj;
		}else{
			map = BeanUtil.transBean2Map(obj);
		}
		return encrypt(map,true);
	}
	
	/**
	 * @Title: encrypt
	 * @Description: TODO(16位或32位密码)
	 * @param @param
	 *            plainText
	 * @param @param
	 *            flag true为32位,false为16位
	 * @throws UnsupportedEncodingException
	 */
	public static String encrypt(Map<String, Object> map, boolean flag) {
		String param = null;
		map.remove("sign");
		map.remove("encrypt");
		String result = BeanUtil.mapOrderStr(map);
		if (StringUtils.isEmpty(result)) {
			return null;
		}
		param = encrypt(encrypt(result)+PRIVATE_KEY);
		if (flag) {
			return param;
		} else {
			param = param.substring(8, 24);
		}
		return param;
	}

	public static Map<String, Object> resultMap = new HashMap<String, Object>();
	@SuppressWarnings("unchecked")
	public static Map<String, Object> mapFn(Map<String, Object> map) {
		for (String key : map.keySet()) {
			if (map.get(key) != null && map.get(key) != "" && (!key.equals("BTYPE") && !key.equals("SIGN"))) {
				if (key.equals("INPUT")) {
					if (map.get(key) != null) {
						mapFn((Map<String, Object>) map.get(key));
					}
				} else {
					resultMap.put(key, map.get(key));
				}
			}
		}
		return resultMap;
	}
	
	@SuppressWarnings("unchecked")
	public static boolean check(Object obj){
		Map<String,Object> map=new HashMap<String,Object>();
		if(obj==null){
			return false;
		}
		if(obj instanceof Map){
			map=(Map<String, Object>) obj;
		}else{
			map = BeanUtil.transBean2Map(obj);
		}
		String sign=(String)map.get("sign");
		if(sign==null){
			return false;
		}
		String str=encrypt(obj);
		return sign.equals(str)?true:false;
	}

    public static String byteArrayToHexString(byte b[]){
        StringBuffer resultSb = new StringBuffer();
        for(int i = 0; i < b.length; i++){
            resultSb.append(byteToHexString(b[i]));
        }
        return resultSb.toString();
    }

    public static String byteToHexString(byte b){
        int n = b;
        if(n < 0){
            n += 256;
        }
        int d1 = n / 16;
        int d2 = n % 16;
        return hexDigIts[d1] + hexDigIts[d2];
    }
    
	public static void main(String[] args) throws UnsupportedEncodingException {
		TestEntity test = new TestEntity();
		test.setId("1");
		test.setAge("20");
		test.setClaes("你好");
		test.setName("gyu");
		test.setCreateTime("2018-11-20");
		test.setSign("5189bd815c3850395f30779d0e59229e");
		System.out.println("MD5验签成功:"+check(test));
	}

}
  • SHA加密工具类SHA1.java
package com.jx.common.entrypt;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jx.common.utils.BeanUtil;

/**  
* @ClassName: Sha1Util  
* @Description: TODO(SHA加密)  
* @author gangyu
* @date 2018年11月20日 下午2:08:36  
*    
*/
public class Sha1 {
	private static final Logger log = LoggerFactory.getLogger(Sha1.class);
	public static String encrypt(String str){
	    if (null == str || 0 == str.length()){
	        return null;
	    }
	    char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
	            'a', 'b', 'c', 'd', 'e', 'f'};
	    try {
	        MessageDigest mdTemp = MessageDigest.getInstance("SHA1");
	        mdTemp.update(new String(str.getBytes("iso8859-1"), "utf-8").getBytes());
	        byte[] md = mdTemp.digest();
	        int j = md.length;
	        char[] buf = new char[j * 2];
	        int k = 0;
	        for (int i = 0; i < j; i++) {
	            byte byte0 = md[i];
	            buf[k++] = hexDigits[byte0 >>> 4 & 0xf];
	            buf[k++] = hexDigits[byte0 & 0xf];
	        }
	        return new String(buf);
	    } catch (NoSuchAlgorithmException e) {
	        e.printStackTrace();
			log.error("SHA1加密异常:",e);
	    } catch (UnsupportedEncodingException e) {
	        e.printStackTrace();
			log.error("SHA1加密异常:",e);
	    }
		return str;
	}
	
	@SuppressWarnings("unchecked")
	public static String encrypt(Object obj) {
		if(obj==null){
			return null;
		}
		Map<String, Object> map = new HashMap<String,Object>();
		if(obj instanceof Map){
			map=(Map<String, Object>) obj;
		}else{
			map = BeanUtil.transBean2Map(obj);
		}
		map.remove("sign");
		map.remove("encrypt");
		String result = BeanUtil.mapOrderStr(map);
		if (StringUtils.isEmpty(result)) {
			return null;
		}
		return encrypt(result);
	}
	
	@SuppressWarnings("unchecked")
	public static boolean check(Object obj){
		Map<String,Object> map=new HashMap<String,Object>();
		if(obj==null){
			return false;
		}
		if(obj instanceof Map){
			map=(Map<String, Object>) obj;
		}else{
			map = BeanUtil.transBean2Map(obj);
		}
		String sign=(String)map.get("sign");
		if(sign==null){
			return false;
		}
		String str=encrypt(obj);
		return sign.equals(str)?true:false;
		
		
	}
	

}
  • 返回数据对称加密DES.java
package com.jx.common.entrypt;

import java.security.Key;
import java.util.Map;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;

import com.google.gson.Gson;
import com.jx.common.utils.Base64;


/**
* @ClassName: Des  
* @Description: TODO(对称加密工具)  
* @author gangyu
* @date 2018年11月20日 下午1:18:49  
*/
public class DES {
	// 密钥
	private final static String secretKey = "123456789987654321";
	// 向量
	private final static String iv = "ggboy123";
	// 加解密统一使用的编码方式
	private final static String encoding = "utf-8";

	/**
	* @Title: encode
	* @Description: TODO(加密)
	* @param String
	* @author gangyu2
	* @date 2018年11月20日下午1:19:19
	 */
	public static String encode(String plainText){
		Key deskey = null;
		DESedeKeySpec spec;
		try {
			spec = new DESedeKeySpec(secretKey.getBytes());
			SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
			deskey = keyfactory.generateSecret(spec);

			Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
			IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
			cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);
			byte[] encryptData = cipher.doFinal(plainText.getBytes(encoding));
			return Base64.encode(encryptData);
		} catch (Exception e) {
			e.printStackTrace();
			return "";
		}
	}

	/**
	* @Title: decode
	* @Description: TODO(解密)
	* @param String
	* @author gangyu2
	* @date 2018年11月20日下午1:19:37
	 */
	public static String decode(String encryptText){
		try{

			Key deskey = null;
			DESedeKeySpec spec = new DESedeKeySpec(secretKey.getBytes());
			SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
			deskey = keyfactory.generateSecret(spec);
			Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
			IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
			cipher.init(Cipher.DECRYPT_MODE, deskey, ips);

			byte[] decryptData = cipher.doFinal(Base64.decode(encryptText));

			return new String(decryptData, encoding);
		}catch(Exception e){
			e.printStackTrace();
			return "";
		}
	}


}
  • RequestUtil.java
public class RequestUtil {

	public static <T> T parseRequset(HttpServletRequest request, Class<T> c) {

		T t = null;
		try {
			t = c.newInstance();// 根据反射生成实例对象
			Method[] ms = c.getMethods();

			Map<String, String[]> map = request.getParameterMap();

			// map.entrySet（）是将map里的每一个键值对//取出来封装成一个Entry对象在存到一个Set集合里面
			// //Map.Entry<String[],
			// String>的意思是一个泛型，表//示Entry里装的String[]数组和string的字符串，分别是//key和value

			for (Map.Entry<String, String[]> entry : map.entrySet()) {
				String key = entry.getKey();
				String[] values = entry.getValue();
				if (values != null && values.length > 1) {
					continue;
				}
				String v = values[0];
				key = "set" + key;

				for (Method m : ms) {
					if (key.equalsIgnoreCase(m.getName())) {
						String parameterTypeName = m.getParameterTypes()[0].getName();
						if ("int".equals(parameterTypeName) || "java.lang.Integer".equals(parameterTypeName)) {
							m.invoke(t, Integer.parseInt(v));

						} else if ("float".equals(parameterTypeName) || "java.lang.Float".equals(parameterTypeName)) {
							m.invoke(t, Float.parseFloat(v));
						} else if ("double".equals(parameterTypeName) || "java.lang.Double".equals(parameterTypeName)) {
							m.invoke(t, Double.parseDouble(v));
						} else if ("long".equals(parameterTypeName) || "java.lang.Long".equals(parameterTypeName)) {
							m.invoke(t, Long.parseLong(v));
						} else if ("short".equals(parameterTypeName) || "java.lang.Short".equals(parameterTypeName)) {
							m.invoke(t, Short.parseShort(v));
						} else if ("java.lang.String".equals(parameterTypeName)) {
							m.invoke(t, v);
						}
						break;
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}

		return t;

	}
	
	public static Map<String,Object> parseRequset(HttpServletRequest request) {

		Map<String,Object> resultMap = new HashMap<String,Object>();
		try {

			Map<String, String[]> map = request.getParameterMap();

			// map.entrySet（）是将map里的每一个键值对//取出来封装成一个Entry对象在存到一个Set集合里面
			// //Map.Entry<String[],
			// String>的意思是一个泛型，表//示Entry里装的String[]数组和string的字符串，分别是//key和value

			for (Map.Entry<String, String[]> entry : map.entrySet()) {
				String key = entry.getKey();
				String[] values = entry.getValue();
				if (StringUtils.isEmpty(values[0])) {
					continue;
				}
				String v = values[0];
				resultMap.put(key, v);
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}

		return resultMap;

	}
}
  • BeanUtil.java
package com.jx.common.utils;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtilsBean;
import org.apache.commons.lang3.StringUtils;

public class BeanUtil {

	// Map --> Bean 2: 利用org.apache.commons.beanutils 工具类实现 Map --> Bean
	public static void transMap2Bean2(Map<String, Object> map, Object obj) {
		if (map == null || obj == null) {
			return;
		}
		try {
			BeanUtils.populate(obj, map);
		} catch (Exception e) {
			System.out.println("transMap2Bean2 Error " + e);
		}
	}

	// Map --> Bean 1: 利用Introspector,PropertyDescriptor实现 Map --> Bean
	public static void transMap2Bean(Map<String, Object> map, Object obj) {
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
			PropertyDescriptor[] propertyDescriptors = beanInfo
					.getPropertyDescriptors();

			for (PropertyDescriptor property : propertyDescriptors) {
				String key = property.getName();

				if (map.containsKey(key)) {
					Object value = map.get(key);
					// 得到property对应的setter方法
					Method setter = property.getWriteMethod();
					setter.invoke(obj, value);
				}

			}

		} catch (Exception e) {
			System.out.println("transMap2Bean Error " + e);
		}

		return;

	}

	// Bean --> Map 1: 利用Introspector和PropertyDescriptor 将Bean --> Map
	public static Map<String, Object> transBean2Map(Object obj) {
		if (obj == null) {
			return null;
		}
		Map<String, Object> map = new HashMap<String, Object>();
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			for (PropertyDescriptor property : propertyDescriptors) {
				String key = property.getName();

				// 过滤class属性
				if (!key.equals("class")) {
					// 得到property对应的getter方法
					Method getter = property.getReadMethod();
					Object value = getter.invoke(obj);
					if(null !=value && !"".equals(value))
						map.put(key, value);
				}

			}
		} catch (Exception e) {
			System.out.println("transBean2Map Error " + e);
		}
		return map;

	}
	
	public static String mapOrderStr(Map<String, Object> map) {
		List<Map.Entry<String, Object>> list = new ArrayList<Map.Entry<String, Object>>(map.entrySet());
		Collections.sort(list, new Comparator<Map.Entry<String, Object>>() {
			public int compare(Entry<String, Object> o1, Entry<String, Object> o2) {
				return o1.getKey().compareTo(o2.getKey());
			}
		});

		StringBuilder sb = new StringBuilder();
		for (Map.Entry<String, Object> mapping : list) {
			sb.append(mapping.getKey() + "=" + mapping.getValue() + "&");
		}
		return sb.substring(0, sb.length() - 1);
	}
	
	

	/**
	 * 
	 * 将源的属性复制到目标属性上去
	 * @param src
	 * @param dest
	 * @lastModified
	 * @history
	 */
	public static void copyProperties(Object dest,Object src) {
		if (src == null || dest == null) {
			return;
		}
		// 获取所有的get/set 方法对应的属性
		PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
		PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(src);

		for (int i = 0; i < descriptors.length; i++) {
			PropertyDescriptor propItem = descriptors[i];
			// 过滤setclass/getclass属性
			if ("class".equals(propItem.getName())) {
				continue;
			}

			try {
				Method method = propItem.getReadMethod();
				// 通过get方法获取对应的值
				Object val = method.invoke(src);
				// 如果是空，不做处理
				if (null == val) {
					continue;
				}
				if(val instanceof String) {
					if(StringUtils.isBlank(val.toString())) {
						continue;
					}
				}
				// 值复制
				PropertyDescriptor prop = propertyUtilsBean.getPropertyDescriptor(dest, propItem.getName());
				// 调用写方法，设置值
				if (null != prop && prop.getWriteMethod() != null) {
					prop.getWriteMethod().invoke(dest, val);
				}
			} catch (Exception e) {
			}

		}

	}
	
	public static <T> T mapToEntity(Map<String, Object> map, Class<T> entity) {
		T t = null;
		try {
			t = entity.newInstance();
			for(Field field : entity.getDeclaredFields()) {
				if (map.containsKey(field.getName())) {
					boolean flag = field.isAccessible();
		            field.setAccessible(true);
		            Object object = map.get(field.getName());
		            if (object!= null && field.getType().isAssignableFrom(object.getClass())) {
		            	 field.set(t, object);
					}
		            field.setAccessible(flag);
				}
			}
			return t;
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return t;

	}	

}
  • 拦截器AppInterceptor.java
package com.jx.app.api.framework.interceptor;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import com.google.gson.Gson;
import com.jx.app.api.framework.annotation.LoginAnot;
import com.jx.app.api.framework.annotation.SginAnot;
import com.jx.app.api.framework.annotation.enums.Auth;
import com.jx.app.api.framework.annotation.enums.SginEnum;
import com.jx.common.entrypt.MD5;
import com.jx.common.entrypt.Sha1;
import com.jx.common.token.ServiceException;
import com.jx.common.token.TokenException;
import com.jx.common.token.TokenUtil;
import com.jx.common.utils.Constants;
import com.jx.common.utils.RequestUtil;
import com.jx.common.utils.Result;
import com.jx.common.utils.enums.CodeEnum;
import com.jx.core.api.model.BaseModel;

/**  
* @ClassName: AppInterceptor  
* @Description: TODO(拦截器)  
* @author gangyu
* @date 2018年11月20日 下午4:10:55  
*    
*/
public class AppInterceptor implements HandlerInterceptor{
    private final static Logger LOGGER = LoggerFactory.getLogger(AppInterceptor.class);
	
	private static final String CONTENT_TYPE="text/json;charset=UTF-8";
	
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		  if (handler.getClass().isAssignableFrom(HandlerMethod.class)) {
			  	//签名验证注解
	        	SginAnot signAnot = ((HandlerMethod) handler).getMethodAnnotation(SginAnot.class);
	        	
	        	//验签
	        	if(signAnot!=null && !signCheck(request,signAnot.type())){
            		response.setContentType(CONTENT_TYPE);
                	response.getWriter().print(new Gson().toJson(new Result(CodeEnum.SIGN_FAIL)));
                	return false;
	        	}
				return true;
		  }else{
				return true;
		  }
	}

	private boolean signCheck(HttpServletRequest request,SginEnum enumm){
		Map<String,Object> map=RequestUtil.parseRequset(request);
		if(enumm==SginEnum.MD5){
			return MD5.check(map);
		}else if(enumm==SginEnum.SHA1){
			return Sha1.check(map);
		}
		return false;
	}
	}
	}
}
  • 统一返回对象Result.java
package com.jx.common.utils;


import java.io.Serializable;

import com.google.gson.Gson;
import com.jx.common.entrypt.DES;
import com.jx.common.utils.enums.CodeEnum;

/**
 * 结果DTO
 * @lastModified
 * @history
 */

public class Result implements Serializable{
	private static final long serialVersionUID = 1L;

	/**
	 * 结果详细
	 */
	private String msg;

	/**
	 * 需要传回页面的数据
	 */
	private Object data;
	
	/**
	 * 状态码
	 */
	private String code;
	
	/**
	 * 加密
	 */
	private boolean encrypt;
	
	/**
	 * 图标
	 */
	private Integer icon;

	public boolean isEncrypt() {
		return encrypt;
	}

	public void setEncrypt(boolean encrypt) {
		this.encrypt = encrypt;
	}

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}

	public Result() {

	}

	public Result(CodeEnum enums) {
		this.msg = enums.getMsg();
		this.encrypt = enums.getEncrypt();
		this.code = enums.getCode();
		this.icon = enums.getIcon();
	}

	public Result(CodeEnum enums,Object data) {
		this.msg = enums.getMsg();
		this.encrypt = enums.getEncrypt();
		this.code = enums.getCode();
		this.icon=enums.getIcon();
		if(enums.getEncrypt()){
			this.data=DES.encode(new Gson().toJson(data));
		}else{
			this.data=data;
		}
	}

	public Object getData() {
		return data;
	}

	public void setData(Object data) {
		this.data = data;
	}


	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	public Integer getIcon() {
		return icon;
	}

	public void setIcon(Integer icon) {
		this.icon = icon;
	}

	public static Result success(CodeEnum enums) {
		Result dto = new Result();
		dto.setMsg(enums.getMsg());
		dto.setEncrypt(enums.getEncrypt());
		dto.setCode(enums.getCode());
		dto.setIcon(enums.getIcon());
		return dto;
	}
	
	public static Result success(CodeEnum enums,Object data) {
		Result dto = new Result();
		dto.setData(data);
		dto.setEncrypt(enums.getEncrypt());
		dto.setCode(enums.getCode());
		dto.setIcon(enums.getIcon());
		if(enums.getEncrypt()){
			dto.setData(DES.encode(new Gson().toJson(data)));
		}else{
			dto.setData(data);
		}
		return dto;
	}
	
	public static Result fail(String msg) {
		Result dto = new Result();
		dto.setMsg(msg);
		dto.setEncrypt(false);
		dto.setCode("1");
		dto.setIcon(SysCode.ICON.ICON_FAIL);
		return dto;
	}
	

}
  • 状态码枚举类CodeEnum.java
package com.jx.common.utils.enums;
/**  
* @ClassName: ExceptionEnum  
* @Description: TODO(系统编码)  
* @author gangyu
* @date 2018年11月21日 下午5:22:32  
*/
public enum CodeEnum {
	//系统编码
    SYS_EXCEPTION("999",false,"系统异常",'fail'),
    SUCCESS("0",false,"成功",'success'),
    ENCRYPT("0",true,"成功",'success'),
    FAIL("1",false,"失败",'fail'),
    SIGN_FAIL("1",false,"签名不正确",'fail'),
    DATA_EMPTY("0",false,"暂无数据",'success'),
    ;

    private String code;
    
    private String msg;
    
    private Boolean encrypt;
    
    private Integer icon;

    CodeEnum(String code,Boolean encrypt, String msg,Integer icon) {
        this.code = code;
        this.encrypt = encrypt;
        this.msg = msg;
        this.icon = icon;
    }

    public Integer getIcon() {
		return icon;
	}

	public String getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

	public Boolean getEncrypt() {
		return encrypt;
	}
    
}
  • Controller层使用签名注解
	@RequestMapping(value="encryptEntity",produces = "application/json;charset=UTF-8",method=RequestMethod.POST)
    @SginAnot(type = SginEnum.MD5)
    public  Object encryptEntity(TestEntity test){
        return businessService.encryptEntity(test);
    }
  • 验签加密排序根据ASII表进行排序在BeanUtil.java类里已经实现
  • url?a=1&c=2&b=3。。。->排序后 a=1&b=3&c=2 然后进行数据加密 俩边排序方式要一致当然为了安全可以排完序加入自己的密钥在进行一次加密
  • Result.java提供了返回数据加密方法CodeEnum.ENCRYPT这里使用的是DES对称加密
BeiShangBuZaiLai
关注
专栏目录
Spring基于AspectJ实现验签切点
iOS逆向与安全
04-29 131
Aspect@Component@Order(0)/*** 验签切点(完整的找到设置的文件地址)* execution：用于匹配方法执行的连接点*其中带?号的 modifiers-pattern?是可选项* ret-type-pattern,name-pattern, parameters-pattern是必选项修饰符匹配，如public 表示匹配公有方法* ret-type-pattern 返回值匹配，* 表示任何返回值，全路径的类名等类路径匹配。
【JavaWeb】基于SpringBoot的Aop+自定义注解的方式实现接口签名源码
墩墩分墩
02-12 1458
文章目录0.相关依赖1.切面类2.异常处理3.自定义签名注解4.映射请求头签名字段类5.签名工具类6.hibernate-validator校验工具类7.redisTemplate配置类8.测试接口 0.相关依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data
利用Spring AOP自定义注解解决日志和签名校验
weixin_33755649的博客
10-09 554
一、需解决的问题 部分API有签名参数（signature），Passport首先对签名进行校验，校验通过才会执行实现方法。 　　　　第一种实现方式(Origin)：在需要签名校验的接口里写校验的代码，例如： boolean isValid = accountService.validSignature(appid, signature, client_signature...
自定义注解校验
AntHub的博客
10-30 112
文章目录FieldValidReflectUtil使用 FieldValid import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ ElementType.METHOD, ElementType.TYPE ,Elemen
自定义注解给属性加密
Pluto372的博客
08-02 838
1、创建注解 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface EncryptionSM4 { //可以给个默认值，然后根据不同的值采用不同加密方式 //String type() default "SM4"; } 2、在属性上加入注解 需要加密的字段 //三个实例类注意 //请求报文 @Data public class FallbackRequestModel implements Seri
java 自定义解码_[求助],java如何使用自定义注解对入参进行解密？
weixin_35676877的博客
02-16 226
正好之前做过自定义ArgumentResolver相关的开发。先指出你的一个问题，ArgumentResolver是对你Controller方法上的单个参数进行解析，也就是说，你的参数是什么类型，就要return什么类型，直接返回一个String除非你的参数就是String，否则肯定type mismatch。可选择一种解决方式，继承org.springframework.web.method.a...
api 请求 fail_基于Spring Boot以及Redis使用Aop来实现Api接口签名验证
weixin_39664560的博客
01-31 266
由于项目需要开发第三方接口给多个供应商，为保证Api接口的安全性，遂采用Api接口签名验证。Api接口签名验证主要防御措施为以下几个：请求发起时间得在限制范围内请求的用户是否真实存在是否存在重复请求请求参数是否被篡改实现思路：我们按照主要防御措施先后顺序来实现，首先已知我们得到以下四个参数：// 供应商的id，验证用户的真实性 String appid = request.getHeader("a...
基于注解的 java 加签验签框架 checksum
weixin_33946605的博客
05-29 206
checksum 基于 java 注解生成加签验签 checksum。 开源地址：github checksum 创作缘由 原来的代码中，checksum 的生成是用的工具类方法。 后来发现如下的问题： 有些字段太大，不想参与验签，但是无法方便的调整。 不同系统的 checksum 字段不同，只好把工具方法 copy 过去，改来改去。 感觉这样有很大的弊端，完全失去了灵活性。 特性...
aop java 接口_Spring AOP实现接口验签
weixin_29159711的博客
02-26 552
因项目需要与外部对接，为保证接口的安全性需要使用aop进行方法的验签;在调用方法的时候，校验外部传入的参数进行验证，验证通过就执行被调用的方法，验证失败返回错误信息；不是所有的方法都需要进行验签，所有使用了注解，只对注解的方法才进行验签；创建ApiAuth注解(Annotation)@Documented@Target(ElementType.METHOD)@Retention(Retention...
三方开放接口，Springboot通过AOP实现API接口的签名验证
qq_32430463的博客
06-21 2900
对外开放的接口，需要验证请求方发送过来的数据确实是由发送方发起的，并且中途不能被篡改和伪造，所以才会对接口的访问进行签名验证，以保证双方获取到的原来的信息是没有经过篡改的。@Aspect //定义一个切面@Slf4j//接口签名验证超时时间//接口签名唯一密钥// 定义切点Pointcutlog.info("开始验证签名");try {//获取timestamp参数//获取sign参数return RestResult.failed("timestamp和sign参数不能为空");
Spring Boot实现接口签名验证
最新发布
涛哥是个大帅比
04-23 3642
一个用于生成签名，另一个用于验证签名。生成签名的方法通常将请求参数按照特定规则计算出一个签名值。常见的签名算法有HMAC-SHA1、HMAC-SHA256等。验证签名的方法则是对接收到的请求参数进行同样的处理，并计算出一个签名值，然后与请求中携带的签名值进行比对。/*** 获取签名* @param secretKey 密钥* @param data 需要签名的数据* @return 签名*/try {/*** 验证签名* @param secretKey 密钥。
后端外部接口验签
qq_43513370的博客
02-19 319
通过接口与外协系统对接时需要验签，本文章实现的是验签。
最详细的SpringBoot实现接口校验签名调用
passerbyYSQ
07-04 7291
验签是指第三方系统在调用接口之前，需要按照原系统的规则根据所有请求参数生成一个签名（字符串），在调用接口时携带该签名。原系统会验证签名的有效性，只有签名验证有效才能正常调用接口，否则请求会被驳回。
自定义注解-验验证接口权限
普通人一枚
08-06 379
有如下需求：在没有权限管理的情况下阻挡普通用户的接口请求，可以做自定义验证来验证接口权限。
Java实战指南｜玩转接口验签-你和高手只差俩个自定义注解
xxsiyao的博客
07-12 455
前言： 一些个很朴素的功能【 登陆功能+接口验签+登陆用户信息共享 】这三个功能想必是大家在日常开发中基本上大都碰到过的吧，如果你还在使用拦截器给接口加白名单来进行过滤那些接口需要验签，如果你还在每次需要拿用户信息的时候都得去查一遍db，那么你就值得看下去，小编教你如何花式玩转接口登陆验签功能????????????【参考资料】 正文 技术设计流程【参考资料】 我们先看一下实现流程图哈，我们主要使用的技术包括： HandlerMethodArgumentResolver （参数解析器）， Handler
自定义注解的方式的使用场景：解决签名校验
小小坚的博客
06-10 820
实际项目中我们可以用自定义注解解决很多事情！ 解决签名校验 创建自定义注解类,注解到我们需要校验才能进入的方法上面 package com.jx.fly.common.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.anno...
接口加解密验签公共包编写
smilelims的博客
01-18 137
请求入参返回值验签加解密公共包编写
博客摘录「 【springboot系列】自定义注解实现加解密」2023年4月7日
m0_50272029的博客
04-07 119
因为我们这个工具是为 Web 项目开发的，以后必然使用在 Web 环境中，所以这里添加依赖时 scope 设置为 provided。
SpringBoot 系列教程(八十五)：Spring Boot使用MD5加盐验签Api接口之前后端分离架构设计
Thinkingcao的专栏
12-18 8501
一、前言 在当下的Web开发，或者涉及到H5、APP、小程序等移动端开发时，务必需要后端提供Api接口供前端调用，无论H5程序、App还是小程序，都是如此，那么接口安全问题就被大家重视起来了，现在也越来越多人关注接口安全问题，尤其是一些架构师，传统的接口在传输的过程中，容易被抓包然后更改里面的参数值达到某些目的。传统的做法是用安全框架或者在代码里面做验证，但是有些系统是不需要登录的，随时可以调AP...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值