java接口加密解密

这里写目录标题

controller
加解密工具类
加密（本质是对@ResponseBody加密）
解密（本质是对@RequestBody传参解密）
注解

controller

@Controller
public class PathVariableController {

    @GetMapping(value = "/test")
    @ResponseBody
    public HashMap<String, Object> test() {
        HashMap<String, Object> map = new HashMap<>();
        map.put("data","successqqqqqq");
        map.put("code",200);
        map.put("msg","成功");
        return map ;
    }

    @PostMapping(value = "/us")
    @ResponseBody
    public HashMap<String, Object> us(@RequestBody User user) {
        System.out.println(user.getAge()+user.getName());
        HashMap<String, Object> map = new HashMap<>();
        map.put("data",user.getName());
        map.put("code",200);
        map.put("msg",user.getAge());

//        map.put("name","lidapao里大炮");
//        map.put("age",18);
        return map ;
    }
}

加解密工具类

package org.example.demo.demos.web;

import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.io.*;
import java.security.Key;
import java.util.Base64;

public class DESUtil {

    /**
     * 偏移变量，固定占8位字节
     */
    private final static String IV_PARAMETER = "12345678";
    /**
     * 密钥算法
     */
    private static final String ALGORITHM = "DES";
    /**
     * 加密/解密算法-工作模式-填充模式
     */
    private static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";
    /**
     * 默认编码
     */
    private static final String CHARSET = "utf-8";

    /**
     * 生成key
     *
     * @param password
     * @return
     * @throws Exception
     */
    private static Key generateKey(String password) throws Exception {
        DESKeySpec dks = new DESKeySpec(password.getBytes(CHARSET));
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
        return keyFactory.generateSecret(dks);
    }


    /**
     * DES加密字符串
     *
     * @param password 加密密码，长度不能够小于8位
     * @param data 待加密字符串
     * @return 加密后内容
     */
    public static String encrypt(String password, String data) {
        if (password== null || password.length() < 8) {
            throw new RuntimeException("加密失败，key不能小于8位");
        }
        if (data == null)
            return null;
        try {
            Key secretKey = generateKey(password);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
            byte[] bytes = cipher.doFinal(data.getBytes(CHARSET));

            //JDK1.8及以上可直接使用Base64，JDK1.7及以下可以使用BASE64Encoder
            //Android平台可以使用android.util.Base64
            return new String(Base64.getEncoder().encode(bytes));

        } catch (Exception e) {
            e.printStackTrace();
            return data;
        }
    }

    /**
     * DES解密字符串
     *
     * @param password 解密密码，长度不能够小于8位
     * @param data 待解密字符串
     * @return 解密后内容
     */
    public static String decrypt(String password, String data) {
        if (password== null || password.length() < 8) {
            throw new RuntimeException("加密失败，key不能小于8位");
        }
        if (data == null)
            return null;
        try {
            Key secretKey = generateKey(password);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
            cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
            return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes(CHARSET))), CHARSET);
        } catch (Exception e) {
            e.printStackTrace();
            return data;
        }
    }

    /**
     * DES加密文件
     *
     * @param srcFile  待加密的文件
     * @param destFile 加密后存放的文件路径
     * @return 加密后的文件路径
     */
    public static String encryptFile(String password, String srcFile, String destFile) {

        if (password== null || password.length() < 8) {
            throw new RuntimeException("加密失败，key不能小于8位");
        }
        try {
            IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, generateKey(password), iv);
            InputStream is = new FileInputStream(srcFile);
            OutputStream out = new FileOutputStream(destFile);
            CipherInputStream cis = new CipherInputStream(is, cipher);
            byte[] buffer = new byte[1024];
            int r;
            while ((r = cis.read(buffer)) > 0) {
                out.write(buffer, 0, r);
            }
            cis.close();
            is.close();
            out.close();
            return destFile;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * DES解密文件
     *
     * @param srcFile  已加密的文件
     * @param destFile 解密后存放的文件路径
     * @return 解密后的文件路径
     */
    public static String decryptFile(String password, String srcFile, String destFile) {
        if (password== null || password.length() < 8) {
            throw new RuntimeException("加密失败，key不能小于8位");
        }
        try {
            File file = new File(destFile);
            if (!file.exists()) {
                file.getParentFile().mkdirs();
                file.createNewFile();
            }
            IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, generateKey(password), iv);
            InputStream is = new FileInputStream(srcFile);
            OutputStream out = new FileOutputStream(destFile);
            CipherOutputStream cos = new CipherOutputStream(out, cipher);
            byte[] buffer = new byte[1024];
            int r;
            while ((r = is.read(buffer)) >= 0) {
                cos.write(buffer, 0, r);
            }
            cos.close();
            is.close();
            out.close();
            return destFile;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }


    public static void main(String[] args) {
        String key = "98fbffd1064a4355b8abaacb6fa96f94";
        String data="bDyb3N+87Imt+LmOEklv+ttCM2Z/5pHnYbJKbQ41bvozUKMMSrScP/xhHCYUJBrKI/aIDaDs7BE=";
    //String data="Khrcd+W7L/+PkWYPB/2qrgL7G8agzQXJ2xWdU8q67sfpjBd+C9nwEFdqDiBpbtTGP8jjcUJnOYILEMPtbKH+6YiqhMcluTRlkoXrPePhfQFOa/69mrwXn42jZsx1g1mR7AqOwdoGoz2rIQRh5RAn3uFuaN9nonQ2sFhxb9f+YA/5umlWVc8v37t4RmrFv4PO0xlqNV4lkXgdj2AnvUqxfBIizKXRgxFdvyqwydiXEL2+sMMc1B/mJY1C8N1pK92St/rF9Bj94fZdewHL3pQklxfl3c1bVqXexIY/CjCrSwmhkTdKMWWC4+81Z9kPlNUDnas3b2Wi/OgoHJVuQIhXShu+KSqBSxWPkECNo6OX/L5zUUa45NOIUOqXVduZhxlvm1/CvzgqLUPlEaAWfIZWzw==";
//        System.out.println("加密前key：" + key);
//        System.out.println("加密前data：" + key);
//        String rc="{\"corpKey\":\"913205080884374764\"}";
//        String en = encrypt(key,rc);
//        System.out.println("加密后：" + en);
        String de = decrypt(key,data);
        System.out.println("解密后：" + de);
    }
}

加密（本质是对@ResponseBody加密）

package com.ruoyi.framework.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruoyi.common.annotation.Encrypt;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.utils.DESUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.lang.Nullable;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

import java.util.HashMap;
import java.util.Map;

/**
 * 加解密接口处理
 */
@RestControllerAdvice
public class EncodeAdvice implements ResponseBodyAdvice {

    private Logger log = LoggerFactory.getLogger(EncodeAdvice.class);


    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        return true;
    }

    @Nullable
    @Override
    public Object beforeBodyWrite(@Nullable Object body, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        boolean encode = true;
        // 出参 配置文件控制 默认打开
        String isEncrypt = RuoYiConfig.getIsEncrypt();
        if ("true".equals(isEncrypt)) {
            if (methodParameter.getMethod().isAnnotationPresent(Encrypt.class)) {
                Encrypt serializedField = methodParameter.getMethodAnnotation(Encrypt.class);
                encode = serializedField.encode();
            }
            if (encode) {
                log.info("对方法method :【" + methodParameter.getMethod().getName() + "】返回数据进行加密");
                String secretPrivateKey = RuoYiConfig.getPrivateKey();
                ObjectMapper objectMapper = new ObjectMapper();
                try {
                    String result = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(body);
                    Map<String, String> data = new HashMap<>();
                    String enData = DESUtil.encrypt("98fbffd1064a4355b8abaacb6fa96f94", result);
                    // String enData2 = RsaUtils.encryptByPublicKey(RuoYiConfig.getPublicKey(), result);
                    data.put("data", enData);
                    // String s3 = RsaUtils.decrypt(RuoYiConfig.getPrivateKey(), enData);
                    return data;
                } catch (Exception e) {
                    e.printStackTrace();
                    log.error("对方法method :【" + methodParameter.getMethod().getName() + "】返回数据进行加密出现异常：" + e.getMessage());
                }
            }
        }
        return body;
    }
}

解密（本质是对@RequestBody传参解密）

package com.ruoyi.framework.config;

import cn.hutool.core.exceptions.ExceptionUtil;
import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.common.annotation.Encrypt;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.utils.DESUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.util.StreamUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;

import java.io.InputStream;
import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets;
import java.util.Map;

@Slf4j
@RestControllerAdvice
public class DecodeAdvice implements RequestBodyAdvice {


    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter,
                                           Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        try {
            // 入参默认加密
            boolean isDecode = true;
            if (parameter.getMethod().isAnnotationPresent(Encrypt.class)) {
                Encrypt encrypt = parameter.getMethodAnnotation(Encrypt.class);
                isDecode = encrypt.decode();
            }
            if (isDecode) {
                log.info("对方法method :【" + parameter.getMethod().getName() + "】入参进行解密");
                if (inputMessage.getHeaders().containsKey("requestType")) {
                    String requestType = inputMessage.getHeaders().get("requestType").get(0);
                    if (requestType.equals("post")) {
                        return new MyHttpInputMessage(inputMessage, requestType);
                    } else if (requestType.equals("put")) {
                        return new MyHttpInputMessage(inputMessage, requestType);
                        // return inputMessage;
                    } else {
                        return inputMessage;
                    }
                } else {
                    return inputMessage;
                }
            } else {
                return inputMessage;
            }
        } catch (Exception e) {
            log.error("对方法method :【" + parameter.getMethod().getName() + "】入参解密失败");
            log.error(ExceptionUtil.getMessage(e));
            return inputMessage;
        }
    }

    @Override
    public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter,
                                Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return body;
    }

    @Override
    public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter,
                                  Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return body;
    }

    class MyHttpInputMessage implements HttpInputMessage {
        private HttpHeaders headers;

        private InputStream body;

        /**
         * inputMessage 解密后重新赋值
         *
         * @param inputMessage
         * @param requestType
         * @throws Exception
         */
        public MyHttpInputMessage(HttpInputMessage inputMessage, String requestType) throws Exception {
            this.headers = inputMessage.getHeaders();
            if (requestType.equals("put")) {
                InputStream inputStream = inputMessage.getBody();
                String body = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
                this.body = IOUtils.toInputStream(easpString(body), "utf-8");
            } else {
                this.body = IOUtils.toInputStream(easpString(IOUtils.toString(inputMessage.getBody(), "utf-8")), "utf-8");
            }
        }

        @Override
        public InputStream getBody() {
            return body;
        }

        @Override
        public HttpHeaders getHeaders() {
            return headers;
        }

        /**
         * @param requestData
         * @return
         */
        public String easpString(String requestData) {
            if (requestData != null && !"".equals(requestData)) {
                Map<String, String> map = JSONObject.parseObject(requestData, Map.class);
                // 密文
                String isEncrypt = RuoYiConfig.getIsEncrypt();
                if (isEncrypt.equals("false")) {
                    return requestData;
                }
                String data = map.get("dataBody");
                if (StringUtils.isEmpty(data)) {
                    throw new RuntimeException("参数【requestData】缺失异常！");
                } else {
                    String content;
                    try {
                        content = DESUtil.decrypt("98fbffd1064a4355b8abaacb6fa96f94", data);
                    } catch (Exception e) {
                        throw new RuntimeException("参数解析异常！");
                    }
                    return content;
                }
            }
            throw new RuntimeException("参数【requestData】不合法异常！");
        }
    }
}

注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Encrypt {


    /**
     * 接收参数是否解密 默认true
     * @param
     */
    boolean decode() default true;

    /**
     * 返回体是否加密 默认true
     * @return
     */
    boolean encode() default true;

}