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

最新推荐文章于 2024-05-31 11:17:46 发布
最新推荐文章于 2024-05-31 11:17:46 发布
阅读量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
关注
专栏目录
SpirngBoot设置自定义注解@NoToken去除部分接口的token验证
洛阳泰山的博客
10-30 4653
项目开发中，有部分对外提供的接口需要无token调用，毕竟每次都需要先调用登录接口获取token,再去调用功能接口，还要不停的更新token,防止token过期，别的项目调用实在有点麻烦，于是开发一个notoken 的注解在不需要传token的接口controller里加上@NoToken注解，即可实现，非常方便，下面就附上代码教程，仅供参考。
实战：用Spring Boot构建电商系统中的API接口
AI天才研究院
08-06 868
1998年，在经历了无数的创新革命之后，互联网成为科技界最重要的分支之一。随着时间的推移，互联网已经成为人类信息化革命的源头。如今的电子商务网站数量达到数百亿，这些网站都具有大规模的用户群体、丰富的内容、高频的交易、海量数据等特征。电商行业近几年有了很多变革，比如大数据分析、物流管理、供应链管理、订单评价、信用卡支付等等。其中API接口开发对于电商系统而言尤其重要。
后端外部接口验签
qq_43513370的博客
02-19 349
通过接口与外协系统对接时需要验签，本文章实现的是验签。
利用Spring AOP自定义注解解决日志和签名校验
weixin_33755649的博客
10-09 564
一、需解决的问题 部分API有签名参数（signature），Passport首先对签名进行校验，校验通过才会执行实现方法。 　　　　第一种实现方式(Origin)：在需要签名校验的接口里写校验的代码，例如： boolean isValid = accountService.validSignature(appid, signature, client_signature...
自定义注解校验
AntHub的博客
10-30 118
文章目录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 855
1、创建注解 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface EncryptionSM4 { //可以给个默认值，然后根据不同的值采用不同加密方式 //String type() default "SM4"; } 2、在属性上加入注解 需要加密的字段 //三个实例类注意 //请求报文 @Data public class FallbackRequestModel implements Seri
java自定义注解实现加密，解密，脱敏
zzqtty的博客
07-17 1811
ApiModelProperty(value = "加密",example = "xxx000XX")//返回给前端时候使用，去掉多层级@Component/*** 设置参数*/@Overridereturn;/*** 获取值*/@Override/*** 获取值*/@Override/*** 获取值*/@Override/** 脱敏类型*//*使用占位符*//*脱敏开始位置，从0开始计数，默认为0*//*
安全优雅的RESTful API签名实现方案
胡峻峥的博客
06-20 2576
安全优雅的RESTful API签名实现方案 1、接口签名的必要性 在为第三方系统提供接口的时候，肯定要考虑接口数据的安全问题，比如数据是否被篡改，数据是否已经过时，数据是否可以重复提交等问题。其中我认为最终要的还是数据是否被篡改。在此分享一下我的关于接口签名的实践方案。 2、项目中签名方案痛点 每个接口有各自的签名方案，不统一，维护成本较高。 没有对消息实体进行签名，无法避免数据被篡改。 无法...
API 接口应该如何设计？如何保证安全？如何签名？如何防重？
caixiangting的博客
07-17 1172
Token访问令牌accesstoken,用于接口中,用于标识接口调用者的身份、凭证，减少用户名和密码的传输次数。一般情况下客户端(接口调用方)需要先向服务器端申请一个接口调用的账号，服务器会给出一个appId和一个key,key用于参数签名使用，注意key保存到客户端，需要做一些安全处理，防止泄露。timestamp时间戳，是客户端调用接口时对应的当前时间戳，时间戳用于防止DoS攻击。nonce随机值，是客户端随机生成的值，作为参数传递过来，随机值的目的是增加sign签名的多变性。...
签名安全规范：解决【请求对象json序列化时，时间字段被强制转换成时间戳的问题】
最新发布
iOS逆向与安全
05-31 576
API接口协议中包含字段nonce_str，主要保证签名不可预测。我们推荐生成随机数算法如下：调用随机数函数生成，将得到的值转换为字符串。接口协议中包含字段nonce_str，主要保证签名不可预测。我们推荐生成随机数算法如下：调用随机数函数生成，将得到的值转换为字符串。尤其是涉及敏感词操作的接口：支付、密码、登陆、验证码等接口。允许的请求头字段： 添加sign。
java 自定义解码_[求助],java如何使用自定义注解对入参进行解密？
weixin_35676877的博客
02-16 230
正好之前做过自定义ArgumentResolver相关的开发。先指出你的一个问题，ArgumentResolver是对你Controller方法上的单个参数进行解析，也就是说，你的参数是什么类型，就要return什么类型，直接返回一个String除非你的参数就是String，否则肯定type mismatch。可选择一种解决方式，继承org.springframework.web.method.a...
api 请求 fail_基于Spring Boot以及Redis使用Aop来实现Api接口签名验证
weixin_39664560的博客
01-31 288
由于项目需要开发第三方接口给多个供应商，为保证Api接口的安全性，遂采用Api接口签名验证。Api接口签名验证主要防御措施为以下几个：请求发起时间得在限制范围内请求的用户是否真实存在是否存在重复请求请求参数是否被篡改实现思路：我们按照主要防御措施先后顺序来实现，首先已知我们得到以下四个参数：// 供应商的id，验证用户的真实性 String appid = request.getHeader("a...
【JavaWeb】基于SpringBoot的Aop+自定义注解的方式实现接口签名源码
墩墩分墩
02-12 1485
文章目录0.相关依赖1.切面类2.异常处理3.自定义签名注解4.映射请求头签名字段类5.签名工具类6.hibernate-validator校验工具类7.redisTemplate配置类8.测试接口 0.相关依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data
基于注解的 java 加签验签框架 checksum
weixin_33946605的博客
05-29 212
checksum 基于 java 注解生成加签验签 checksum。 开源地址：github checksum 创作缘由 原来的代码中，checksum 的生成是用的工具类方法。 后来发现如下的问题： 有些字段太大，不想参与验签，但是无法方便的调整。 不同系统的 checksum 字段不同，只好把工具方法 copy 过去，改来改去。 感觉这样有很大的弊端，完全失去了灵活性。 特性...
aop java 接口_Spring AOP实现接口验签
weixin_29159711的博客
02-26 564
因项目需要与外部对接，为保证接口的安全性需要使用aop进行方法的验签;在调用方法的时候，校验外部传入的参数进行验证，验证通过就执行被调用的方法，验证失败返回错误信息；不是所有的方法都需要进行验签，所有使用了注解，只对注解的方法才进行验签；创建ApiAuth注解(Annotation)@Documented@Target(ElementType.METHOD)@Retention(Retention...
三方开放接口，Springboot通过AOP实现API接口的签名验证
qq_32430463的博客
06-21 2963
对外开放的接口，需要验证请求方发送过来的数据确实是由发送方发起的，并且中途不能被篡改和伪造，所以才会对接口的访问进行签名验证，以保证双方获取到的原来的信息是没有经过篡改的。@Aspect //定义一个切面@Slf4j//接口签名验证超时时间//接口签名唯一密钥// 定义切点Pointcutlog.info("开始验证签名");try {//获取timestamp参数//获取sign参数return RestResult.failed("timestamp和sign参数不能为空");
Spring Boot实现接口签名验证
涛哥是个大帅比
04-23 4229
一个用于生成签名，另一个用于验证签名。生成签名的方法通常将请求参数按照特定规则计算出一个签名值。常见的签名算法有HMAC-SHA1、HMAC-SHA256等。验证签名的方法则是对接收到的请求参数进行同样的处理，并计算出一个签名值，然后与请求中携带的签名值进行比对。/*** 获取签名* @param secretKey 密钥* @param data 需要签名的数据* @return 签名*/try {/*** 验证签名* @param secretKey 密钥。
最详细的SpringBoot实现接口校验签名调用
passerbyYSQ
07-04 7617
验签是指第三方系统在调用接口之前，需要按照原系统的规则根据所有请求参数生成一个签名（字符串），在调用接口时携带该签名。原系统会验证签名的有效性，只有签名验证有效才能正常调用接口，否则请求会被驳回。
自定义注解-验验证接口权限
普通人一枚
08-06 392
有如下需求：在没有权限管理的情况下阻挡普通用户的接口请求，可以做自定义验证来验证接口权限。
Java JSR303数据校验与自定义注解实战教程
"Java使用JSR303进行数据校验和自定义校验注解的教程" 在Java开发中，数据校验是一项关键任务，它确保了输入数据的准确性和完整性。JSR303（Java Bean Validation）提供了一种标准的方法来处理这些验证，而...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值