/**
 * 参见文档: <a href="https://zh.wikipedia.org/wiki/%E6%B1%89%E5%AD%97%E5%86%85%E7%A0%81%E6%89%A9%E5%B1%95%E8%A7%84%E8%8C%83">汉字内码扩展规范</a>
 * <p>
 * GBK/1:GB2312非汉字符号: A1~A9, A1~FE
 * GBK/2:GB2312汉字: B0~F7, A1~FE
 * GBK/3:扩充汉字: 81~A0, 40~FE (7F除外)
 * GBK/4:扩充汉字: AA~FE, 40~A0 (7F除外)
 * GBK/5:扩充非汉字: A8~A9, 40~A0 (7F除外)
 *
 * @author Gao Youbo
 * @since 2022-08-23 16:34
 */
public class GBK {
    private static final Charset CHARSET = Charset.forName("GBK");

    /**
     * 获取所有GBK编码字符
     */
    public static List<String> getGBK() {
        List<String> words = new ArrayList<>();
        byte[] bytes = new byte[2];

        // GBK/1:GB2312非汉字符号
        for (int b1 = 0xA1; b1 <= 0xA9; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0xA1; b2 <= 0xFE; b2++) {
                bytes[1] = (byte) b2;
                words.add(new String(bytes, CHARSET));
            }
        }

        // GBK/2:GB2312汉字
        for (int b1 = 0xB0; b1 <= 0xF7; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0xA1; b2 <= 0xFE; b2++) {
                bytes[1] = (byte) b2;
                words.add(new String(bytes, CHARSET));
            }
        }

        // GBK/3:扩充汉字
        for (int b1 = 0x81; b1 <= 0xA0; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0x40; b2 <= 0xFE; b2++) {
                bytes[1] = (byte) b2;
                if (b2 != 0x7F) {
                    words.add(new String(bytes, CHARSET));
                }
            }
        }

        // GBK/4:扩充汉字
        for (int b1 = 0xAA; b1 <= 0xFE; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0x40; b2 <= 0xA0; b2++) {
                bytes[1] = (byte) b2;
                if (b2 != 0x7F) {
                    words.add(new String(bytes, CHARSET));
                }
            }
        }

        // GBK/5:扩充非汉字
        for (int b1 = 0xA8; b1 <= 0xA9; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0x40; b2 <= 0xA0; b2++) {
                bytes[1] = (byte) b2;
                if (b2 != 0x7F) {
                    words.add(new String(bytes, CHARSET));
                }
            }
        }

        return words;
    }

    public static boolean isGBK(String str) {
        boolean isGBK = false;
        char[] chars = str.toCharArray();
        for (char c : chars) {
            byte[] bytes = String.valueOf(c).getBytes(CHARSET);
            if (bytes.length == 2) { // GBK 编码为两个字节
                int b1 = bytes[0] & 0xff;
                int b2 = bytes[1] & 0xff;
                if (b1 >= 0xA1 && b1 <= 0xA9 && b2 >= 0xA1 & b2 <= 0xFE) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0xB0 && b1 <= 0xF7 && b2 >= 0xA1 & b2 <= 0xFE) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0x81 && b1 <= 0xA0 && b2 >= 0x40 & b2 <= 0xFE && b2 != 0x7F) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0xAA && b1 <= 0xFE && b2 >= 0x40 & b2 <= 0xA0 && b2 != 0x7F) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0xA8 && b1 <= 0xA9 && b2 >= 0x40 & b2 <= 0xA0 && b2 != 0x7F) {
                    isGBK = true;
                    break;
                }
            }
        }
        return isGBK;
    }
}

/**
 * @author Gao Youbo
 * @since 2022-08-19 10:28
 */
public class Base128 {
    private static final char[] DEFAULT_CHAR_TABLE = {
            '0', '1', '2', '3', '4', '5', '6', '7',
            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
            'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
            'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
            'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
            'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
            'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
            'u', 'v', 'w', 'x', 'y', 'z', '-', '_',

            'α', 'β', 'γ', 'δ', 'ε', 'ζ', 'η', 'θ',
            'ι', 'κ', 'λ', 'μ', 'ν', 'ξ', 'ο', 'π',
            'ρ', 'ς', 'σ', 'τ', 'υ', 'φ', 'χ', 'ψ',
            'ω', 'à', 'á', 'â', 'ã', 'ä', 'å', 'æ',
            'ç', 'è', 'é', 'ê', 'ë', 'ì', 'í', 'î',
            'ï', 'ð', 'ñ', 'ò', 'ó', 'ô', 'õ', 'ö',
            '÷', 'ø', 'ù', 'ú', 'û', 'ü', 'ý', 'þ',
            'ÿ', 'Ā', 'ā', 'Ă', 'ă', 'Ą', 'ą', 'Ć',
    };

    private final char[] charTable;
    private final HashMap<Character, Integer> indexTable;

    public Base128() {
        this(DEFAULT_CHAR_TABLE);
    }

    public Base128(char[] charTable) {
        this.charTable = charTable;
        this.indexTable = new HashMap<>(charTable.length);
        for (int j = 0; j < charTable.length; j++) {
            indexTable.put(charTable[j], j);
        }
    }

    private String encodeToString(byte[] data) {
        if (data == null || data.length == 0) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        int tail = 0;
        for (int i = 0; i < data.length; i++) {
            int mov = (i % 7 + 1);
            int curr = 0xFF & data[i];
            int code = tail + (curr >> mov);
            sb.append(charTable[code]);
            tail = (0xFF & (curr << (8 - mov))) >> 1;
            if (mov == 7) {
                sb.append(charTable[tail]);
                tail = 0;
            }
        }
        sb.append(charTable[tail]);
        return sb.toString();
    }

    private byte[] decode(String str) {
        if (StringUtils.isBlank(str)) {
            return new byte[]{};
        }
        int length = (int) Math.floor(str.length() * 0.875);
        byte[] result = new byte[length];
        int idx = 0;
        int head = indexTable.get(str.charAt(0)) << 1;
        for (int i = 1; i < str.length(); ) {
            int mod = i % 8;
            int code = indexTable.get(str.charAt(i++));
            result[idx++] = (byte) (0xFF & (head + (code >> (7 - mod))));
            if (mod == 7) {
                head = 0xFF & (indexTable.get(str.charAt(i++)) << 1);
            } else {
                head = 0xFF & (code << (mod + 1));
            }
        }
        return result;
    }
}

private static final Charset CHARSET = Charset.forName("GB2312");

    /**
     * 获取GB2312所有汉字
     * “高位字节”的范围是0xB0-0xF7，“低位字节”的范围是0xA0-0xFE
     */
    private static List<String> getGB2312() {
        List<String> words = new ArrayList<>();
        byte[] bytes = new byte[2];
        for (int b1 = 176; b1 < 248; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 161; b2 < 255; b2++) {
                bytes[1] = (byte) b2;
                words.add(new String(bytes, CHARSET));
            }
        }
        return words;
    }

    /**
     * 对于gb2312来讲,首字节码位从0×81至0×FE，尾字节码位分别是0×40至0×FE
     */
    public static boolean isGB2312(String str) {
        boolean isGB2312 = false;
        char[] chars = str.toCharArray();
        for (char c : chars) {
            byte[] bytes = ("" + c).getBytes(CHARSET);
            if (bytes.length == 2) {
                int[] ints = new int[2];
                ints[0] = bytes[0] & 0xff;
                ints[1] = bytes[1] & 0xff;
                if (ints[0] >= 0x81 && ints[0] <= 0xFE && ints[1] >= 0x40 && ints[1] <= 0xFE) {
                    isGB2312 = true;
                    break;
                }
            }
        }
        return isGB2312;
    }

public class IpMatcher {
    public static boolean matchIPV4(String ip, String cidr) {
        String[] ips = ip.split("\\.");
        if (ips.length != 4) {
            return false;
        }
        int ipAddr = (Integer.parseInt(ips[0]) << 24)
                | (Integer.parseInt(ips[1]) << 16)
                | (Integer.parseInt(ips[2]) << 8) | Integer.parseInt(ips[3]);
        int type = Integer.parseInt(cidr.replaceAll(".*/", ""));
        int mask = 0xFFFFFFFF << (32 - type);
        String cidrIp = cidr.replaceAll("/.*", "");
        String[] cidrIps = cidrIp.split("\\.");
        int cidrIpAddr = (Integer.parseInt(cidrIps[0]) << 24)
                | (Integer.parseInt(cidrIps[1]) << 16)
                | (Integer.parseInt(cidrIps[2]) << 8)
                | Integer.parseInt(cidrIps[3]);
        return (ipAddr & mask) == (cidrIpAddr & mask);
    }

    public static void main(String[] args) {
        System.out.println(matchIPV4("172.16.0.1", "172.16.0.0/20"));
    }
}

import com.example.demo.common.exception.base.ErrorCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
import org.springframework.http.HttpStatus;

@Getter
@AllArgsConstructor
public class Response<T> {

    private int code = HttpStatus.OK.value();

    private String msg = "success";

    private T data;

    public Response(T data) {
        this.data = data;
    }

    public Response(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public Response(int code, T data) {
        this.code = code;
        this.data = data;
    }

    public Response(ErrorCode errorCode) {
        this.code = errorCode.getCode();
        this.msg = errorCode.getMessage();
    }

    public Response(ErrorCode errorCode, T data) {
        this.code = errorCode.getCode();
        this.msg = errorCode.getMessage();
        this.data = data;
    }
}

import com.example.demo.common.RequestContextHolder;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.core.annotation.Order;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

@ControllerAdvice
public class FormatResponseBodyAdvice implements ResponseBodyAdvice {
    private static Logger logger = LoggerFactory.getLogger(FormatResponseBodyAdvice.class);

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {

        Object wrapperBody = body;
        try {
            if (!(body instanceof Response)) {
                if (body instanceof String) {
                    wrapperBody = objectMapper.writeValueAsString(new Response<>(body));
                } else {
                    wrapperBody = new Response<>(body);
                }
            }
        } catch (Exception e) {
            logger.error("request uri path: {}, format response body error", request.getURI().getPath(), e);
        }
        return wrapperBody;
    }

}

import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.List;

@Configuration
public class WebConfiguration implements WebMvcConfigurer {

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(0, new MappingJackson2HttpMessageConverter());
    }
}

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.http.server.ServletServerHttpRequest;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;


@ControllerAdvice
public class FormatResponseBodyAdvice implements ResponseBodyAdvice {

    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
                                  Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {

        if (!(body instanceof Response)) {
            return new Response<>(body);
        }

        return body;

    }
}

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "hello world!";
    }

}