devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Netty实现A服务信息到B服务信息转发_netty实现tcp转发

作者：盐析白兔 | 2024-07-17 03:48:49

赞

踩

netty实现tcp转发

1、本代码需要一定java基础

Netty原理

我们都知道 Netty 是一个高性能、异步事件驱动的 NIO 框架，基于 JAVA NIO 提供的 API 实现

2、代码文件目录

直接上代码

1、往BBWConfig.properties写入服务信息

  1. package com.com.test.bbw;
  2.  
  3. import org.apache.commons.logging.Log;
  4. import org.apache.commons.logging.LogFactory;
  5. import org.springframework.boot.context.properties.ConfigurationProperties;
  6. import org.springframework.context.annotation.PropertySource;
  7. import org.springframework.stereotype.Component;
  8.  
  9. import java.io.*;
  10. import java.util.Properties;
  11.  
  12. @Component
  13. @ConfigurationProperties
  14. @PropertySource("classpath:BBWConfig.properties")
  15. public class BBWConfig {
  16.  
  17.     private static final Log logger = LogFactory.getLog(BBWConfig.class);
  18.  
  19.  
  20.     private String config_path = "src/main/resources/";   //本地路径
  21.     private String config_filename = "BBWConfig.properties";
  22.     private static Properties properties;
  23.  
  24.     private static String bbwServerIp;   //BBW服务器地址
  25.     private static String bbwServerPort; //BBW服务器端口
  26.     private static String paySendPort;   //支付发出端口
  27.     private static String payRcvServerIp; //支付接收地址
  28.     private static String payTcpRcvPort; //tcp支付接收端口
  29.     private static String payHttpRcvPort; //http支付接收端口
  30.     private static String warningNum; //AGENt重连次数警告consumer
  31.     private static String encoding;      //报文编码格式
  32.     private static String reStartTime;   //AGNET异常重连间隔（单位：毫秒）
  33.  
  34.  
  35.     // Netty服务连接状态：连接中
  36.     public static final int CONNECT_STATE_CONNECTING = 0;
  37.     //  Netty服务连接状态：连接成功
  38.     public static final int CONNECT_STATE_SUCC = 1;
  39.     //  Netty服务连接状态：连接失败
  40.     public static final int CONNECT_STATE_FAIL = -1;
  41.  
  42.     public BBWConfig() {
  43.         String home =System.getProperty("user.dir");
  44.         // set config file path
  45.         if (null != home && !"".equals(home.trim())){
  46.             if (!home.endsWith("/")){
  47.                 home = home + "/";
  48.             }
  49.             config_filename = home + config_path + config_filename;
  50.         }
  51.         else{
  52.             config_filename = config_path + config_filename;
  53.         }
  54.         // check config file
  55.         creatConfigFile();
  56.         this.properties = getConfigFile();
  57.         init();
  58.     }
  59.  
  60.     private Properties getConfigFile() {
  61.         properties = new Properties();
  62.         try {
  63.             FileReader fileReader = new FileReader(config_filename);
  64.             properties.load(fileReader);
  65.             fileReader.close();
  66.         } catch (IOException e) {
  67.             e.printStackTrace();
  68.         }
  69.         return properties;
  70.     }
  71.  
  72.     public static Properties getProperties() {
  73.         return properties;
  74.     }
  75.  
  76.     public static void setProperties(Properties properties) {
  77.         BBWConfig.properties = properties;
  78.     }
  79.  
  80.     public static String getBbwServerIp() {
  81.         return bbwServerIp;
  82.     }
  83.  
  84.     public static void setBbwServerIp(String bbwServerIp) {
  85.         BBWConfig.bbwServerIp = bbwServerIp;
  86.     }
  87.  
  88.     public static String getBbwServerPort() {
  89.         return bbwServerPort;
  90.     }
  91.  
  92.     public static void setBbwServerPort(String bbwServerPort) {
  93.         BBWConfig.bbwServerPort = bbwServerPort;
  94.     }
  95.  
  96.     public static String getPaySendPort() {
  97.         return paySendPort;
  98.     }
  99.  
  100.     public static void setPaySendPort(String paySendPort) {
  101.         BBWConfig.paySendPort = paySendPort;
  102.     }
  103.  
  104.     public static String getPayRcvServerIp() {
  105.         return payRcvServerIp;
  106.     }
  107.  
  108.     public static void setPayRcvServerIp(String payRcvServerIp) {
  109.         BBWConfig.payRcvServerIp = payRcvServerIp;
  110.     }
  111.  
  112.     public static String getPayTcpRcvPort() {
  113.         return payTcpRcvPort;
  114.     }
  115.  
  116.     public static void setPayTcpRcvPort(String payTcpRcvPort) {
  117.         BBWConfig.payTcpRcvPort = payTcpRcvPort;
  118.     }
  119.  
  120.     public static String getPayHttpRcvPort() {
  121.         return payHttpRcvPort;
  122.     }
  123.  
  124.     public static void setPayHttpRcvPort(String payHttpRcvPort) {
  125.         BBWConfig.payHttpRcvPort = payHttpRcvPort;
  126.     }
  127.  
  128.     public static String getWarningNum() {
  129.         return warningNum;
  130.     }
  131.  
  132.     public static void setWarningNum(String warningNum) {
  133.         BBWConfig.warningNum = warningNum;
  134.     }
  135.  
  136.     public static String getEncoding() {
  137.         return encoding;
  138.     }
  139.  
  140.     public static void setEncoding(String encoding) {
  141.         BBWConfig.encoding = encoding;
  142.     }
  143.  
  144.     public static String getReStartTime() {
  145.         return reStartTime;
  146.     }
  147.  
  148.     public static void setReStartTime(String reStartTime) {
  149.         BBWConfig.reStartTime = reStartTime;
  150.     }
  151.  
  152.     /**
  153.      *
  154.      * @说明 创建默认的配置文件
  155.      */
  156.     private File creatConfigFile() {
  157.         File file = new File(config_filename);
  158.  
  159.         if (logger.isInfoEnabled()) {
  160.             logger.info("BBWConfig config_filename = " + config_filename);
  161.         }
  162.  
  163.         if (!file.exists()) {
  164.             if (logger.isInfoEnabled()) {
  165.                 logger.info("BBWConfig start creatConfigFile  ..............");
  166.             }
  167.             try {
  168.                 file.createNewFile();
  169.                 OutputStreamWriter osw = new OutputStreamWriter(
  170.                         new FileOutputStream(file));
  171.                 osw.write("#BBW服务器地址" + "\n");
  172.                 osw.write("bbwServerIp=127.0.0.1" + "\n");
  173.                 osw.write("#BBW服务器端口" + "\n");
  174.                 osw.write("bbwServerPort=4444" + "\n");
  175.                 osw.write("#支付接出端口Tcp" + "\n");
  176.                 osw.write("paySendPort=50039" + "\n");
  177.                 osw.write("#支付接入平台地址" + "\n");
  178.                 osw.write("payRcvServerIp=127.0.0.1" + "\n");
  179.                 osw.write("#支付平台接入端口tcp" + "\n");
  180.                 osw.write("payTcpRcvPort=50040" + "\n");
  181.                 osw.write("#支付平台接入http端口" + "\n");
  182.                 osw.write("payHttpRcvPort=9004" + "\n");
  183.                 osw.write("#AGENt重连次数警告consumer" + "\n");
  184.                 osw.write("warningNum=10" + "\n");
  185.                 osw.write("#报文编码格式" + "\n");
  186.                 osw.write("encoding=UTF8" + "\n");
  187.                 osw.write("#AGNET异常重连间隔（单位：毫秒）" + "\n");
  188.                 osw.write("reStartTime=10000" + "\n");
  189.                 osw.close();
  190.             } catch (IOException e) {
  191.                 e.printStackTrace();
  192.             }
  193.         }
  194.         return file;
  195.     }
  196.     private void init(){
  197.         BBWConfig.bbwServerIp=BBWConfig.properties.getProperty("bbwServerIp");
  198.         BBWConfig.bbwServerPort=BBWConfig.properties.getProperty("bbwServerPort");
  199.         BBWConfig.paySendPort=BBWConfig.properties.getProperty("paySendPort");
  200.         BBWConfig.payRcvServerIp=BBWConfig.properties.getProperty("payRcvServerIp");
  201.         BBWConfig.payTcpRcvPort=BBWConfig.properties.getProperty("payTcpRcvPort");
  202.         BBWConfig.payHttpRcvPort=BBWConfig.properties.getProperty("payHttpRcvPort");
  203.         BBWConfig.encoding=BBWConfig.properties.getProperty("encoding");
  204.         BBWConfig.warningNum=BBWConfig.properties.getProperty("warningNum");
  205.     }
  206.     public static void main(String[] args) {
  207.         BBWConfig nc = new BBWConfig();
  208.         if (logger.isDebugEnabled()) {
  209.             logger.debug("BBWConfig toString \n" + nc.getConfigFile().toString());
  210.         }
  211.     }
  212.  
  213. }

 2、读取数据工具类

  1. package com.com.test.bbw;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5.  
  6. import java.io.BufferedInputStream;
  7. import java.io.BufferedOutputStream;
  8. import java.io.ByteArrayOutputStream;
  9. import java.io.IOException;
  10.  
  11. public class ConverUtils {
  12.  
  13.     private static final Logger log = LoggerFactory.getLogger(ConverUtils.class);
  14.  
  15.     private static final Integer msgLeng = 5;
  16.  
  17.     /**
  18.      * 循环去写数据
  19.      *
  20.      * @param bos
  21.      * @param buff
  22.      * @param bufferCapacity
  23.      * @throws IOException
  24.      */
  25.     public static void cycleWriteMessage(BufferedOutputStream bos, byte[] buff, int bufferCapacity) throws IOException {
  26.         int len = buff.length;
  27.  
  28.         int count = 0;
  29.         int tmpLen = len;
  30.         while (true) {
  31.             if (tmpLen <= bufferCapacity) {
  32.                 bos.write(buff, count, tmpLen);
  33.                 bos.flush();
  34.                 count += tmpLen;
  35.                 tmpLen = 0;
  36.             } else {
  37.                 bos.write(buff, count, bufferCapacity);
  38.                 bos.flush();
  39.                 count += bufferCapacity;
  40.                 tmpLen -= bufferCapacity;
  41.             }
  42.             if (tmpLen == 0)
  43.                 break;
  44.         }
  45.     }
  46.  
  47.     /**
  48.      * 循环去读数据
  49.      *
  50.      * @param bis
  51.      * @param baos
  52.      * @param bufferCapacity
  53.      * @param len
  54.      * @param socketReaderCircleTimes
  55.      * @throws IOException
  56.      */
  57.     public static String cycleReadMessage(BufferedInputStream bis, StringBuffer msgInfo, int bufferCapacity, int len,
  58.                                           int socketReaderCircleTimes) throws IOException {
  59.         int index = 0;
  60.         // 读取的明文长度
  61.         int numberRead = 0;
  62.         // 读取的字节长度
  63.         int numberReadByte = 0;
  64.         // 明文的长度变量
  65.         int tmpLen = len;
  66.         byte[] buff = null;
  67.         // 定义可变字符串用于存储取到的明文数据
  68.         StringBuffer msgTemp = new StringBuffer();
  69.         for (int i = 0; i < socketReaderCircleTimes; i++) {
  70.             buff = new byte[tmpLen];
  71.             numberReadByte = bis.read(buff, 0, tmpLen);
  72.             if (numberReadByte <= 0) {
  73.                 break;
  74.             }
  75.             // 拿到的字节数据转为16进制数据
  76.             String asciiBytesToMsg = byteArr2HexStr(buff);
  77.             String msg = convertHexToString(asciiBytesToMsg);
  78.             msgTemp.append(msg);
  79.             // 判断长度
  80.             numberRead = asciiBytesToMsg.length();
  81.             // 如果明文长度小于剩余报文头长度
  82.             if (numberRead < tmpLen) {
  83.                 index += numberRead;
  84.                 tmpLen -= numberRead;
  85.             } else {
  86.                 if (numberRead != tmpLen)
  87.                     break;
  88.                 index += numberRead;
  89.                 tmpLen -= numberRead;
  90.             }
  91.  
  92.             if (tmpLen <= 0)
  93.                 break;
  94.         }
  95.         // 判断长度
  96.         if (msgTemp.length() == len) {
  97.             msgInfo.append(msgTemp);
  98.             return msgInfo.toString();
  99.         }
  100.         return null;
  101.     }
  102.  
  103.  
  104.  
  105.     /**
  106.      * 将两个字节数组合并
  107.      *
  108.      * @param data1
  109.      * @param data2
  110.      * @return
  111.      */
  112.     public static byte[] addBytes(byte[] headData, byte[] bodyData) {
  113.         byte[] data3 = null;
  114.         if(null != bodyData && 0 < bodyData.length){
  115.             data3 = new byte[headData.length + bodyData.length];
  116.             System.arraycopy(headData, 0, data3, 0, headData.length);
  117.             System.arraycopy(bodyData, 0, data3, headData.length, bodyData.length);
  118.         }else {
  119.             data3 = "00000".getBytes();
  120.         }
  121.         return data3;
  122.     }
  123.  
  124.     /**
  125.      * 循环去读报文的长度
  126.      *
  127.      * @param bis
  128.      * @param baos
  129.      * @param bufferCapacity
  130.      * @param len
  131.      * @param socketReaderCircleTimes
  132.      * @throws IOException
  133.      */
  134.     public static void cycleReadMessageHeadLeng(BufferedInputStream bis, ByteArrayOutputStream baos, int bufferCapacity,
  135.                                                 int len, int socketReaderCircleTimes) throws IOException {
  136.  
  137.         int numberRead = 0;
  138.         int tmpLen = len;
  139.         int index = 0;
  140.         byte[] buff = null;
  141.         for (int i = 0; i < socketReaderCircleTimes; i++) {
  142.             if (tmpLen < bufferCapacity) {
  143.                 buff = new byte[tmpLen];
  144.                 int available = bis.available();
  145.                 if(available >0){
  146.                     numberRead = bis.read(buff, 0, tmpLen);
  147.                 }else{
  148.                     continue;
  149.                 }
  150.             } else {
  151.                 buff = new byte[bufferCapacity];
  152.                 numberRead = bis.read(buff, 0, bufferCapacity);
  153.             }
  154.  
  155.             if (numberRead < 0) {
  156.                 return;
  157.             }
  158.             if (numberRead < tmpLen) {
  159.                 index += numberRead;
  160.                 tmpLen -= numberRead;
  161.  
  162.                 byte[] tmpByte = new byte[numberRead];
  163.                 System.arraycopy(buff, 0, tmpByte, 0, numberRead);
  164.                 baos.write(tmpByte);
  165.             } else {
  166.                 if (numberRead != tmpLen)
  167.                     break;
  168.                 index += numberRead;
  169.                 tmpLen -= numberRead;
  170.                 baos.write(buff);
  171.             }
  172.  
  173.             if (tmpLen <= 0)
  174.                 break;
  175.         }
  176.     }
  177.  
  178.     /**
  179.      * 将报文的2位ASCII码字符码转为10进制
  180.      *
  181.      * @param bytes
  182.      * @return
  183.      */
  184.     public static int decodeMsgLength(byte[] bytes) {
  185.         if (bytes != null && bytes.length == 2) {
  186.  
  187.             return bytes2Short(bytes, 0);
  188.         } else {
  189.             log.error("bytes of length cannot decode to int value.");
  190.         }
  191.         return 0;
  192.     }
  193.  
  194.     public static short bytes2Short(byte[] b, int offset) {
  195.         short n = (short) (((b[offset] < 0 ? b[offset] + 256 : b[offset]) << 8)
  196.                 + (b[offset + 1] < 0 ? b[offset + 1] + 256 : b[offset + 1]));
  197.         return n;
  198.     }
  199.  
  200.     public static byte[] encode(int lengthValue, int length) {
  201.         if (lengthValue > 0 && length > 0) {
  202.             byte[] bytes;
  203.             try {
  204.                 String hexStr = Integer.toHexString(lengthValue);
  205.                 if (hexStr.length() % 2 != 0) {
  206.                     hexStr = "0" + hexStr;
  207.                 }
  208.                 bytes = hexstr2ByteArr(hexStr);
  209.                 byte[] ret = new byte[length];
  210.                 for (int i = 0; i < length; i++) {
  211.                     ret[i] = 0x00;
  212.                 }
  213.                 System.arraycopy(bytes, 0, ret, length - bytes.length, bytes.length);
  214.                 return ret;
  215.             } catch (Exception e) {
  216.                 log.error("报文长度转化出错");
  217.             }
  218.         } else {
  219.             if(lengthValue == 0){
  220.                 return "00000".getBytes();
  221.             }
  222.             log.error("无效的报文长度:"+lengthValue);
  223.         }
  224.         return new byte[0];
  225.     }
  226.  
  227.     public static byte[] hexstr2ByteArr(String strIn) {
  228.         byte[] arrB = strIn.getBytes();
  229.         int iLen = arrB.length;
  230.         byte[] arrOut = new byte[iLen / 2];
  231.  
  232.         for (int i = 0; i < iLen; i += 2) {
  233.             String strTmp = new String(arrB, i, 2);
  234.             arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
  235.         }
  236.  
  237.         return arrOut;
  238.     }
  239.  
  240.     /**
  241.      * hex字符串转byte数组
  242.      *
  243.      * @param inHex
  244.      *            待转换的Hex字符串
  245.      * @return 转换后的byte数组结果
  246.      */
  247.     public static byte[] hexToByteArray(String inHex) {
  248.         if (inHex != null && !inHex.isEmpty()) {
  249.             int hexlen = inHex.trim().length();
  250.             byte[] result;
  251.             if (hexlen % 2 == 1) {
  252.                 // 奇数
  253.  
  254.             } else {
  255.                 // 偶数
  256.                 result = new byte[(hexlen / 2)];
  257.                 int j = 0;
  258.                 for (int i = 0; i < hexlen; i += 2) {
  259.                     result[j] = hexToByte(inHex.substring(i, i + 2));
  260.                     j++;
  261.                 }
  262.                 return result;
  263.             }
  264.         }
  265.         return new byte[0];
  266.  
  267.     }
  268.  
  269.     /**
  270.      * Hex字符串转byte
  271.      *
  272.      * @param inHex
  273.      *            待转换的Hex字符串
  274.      * @return 转换后的byte
  275.      */
  276.     public static byte hexToByte(String inHex) {
  277.         return (byte) Integer.parseInt(inHex, 16);
  278.     }
  279.  
  280.     /**
  281.      * ASCII码转换为16进制
  282.      *
  283.      * @param str
  284.      * @return
  285.      */
  286.     public static String convertStringToHex(String str) {
  287.  
  288.         char[] chars = str.toCharArray();
  289.  
  290.         StringBuffer hex = new StringBuffer();
  291.         for (int i = 0; i < chars.length; i++) {
  292.             hex.append(Integer.toHexString((int) chars[i]));
  293.         }
  294.  
  295.         return hex.toString();
  296.     }
  297.  
  298.     /**
  299.      * 将字节数组转为16进制数据
  300.      *
  301.      * @param arrB
  302.      * @return
  303.      * @throws IOException
  304.      */
  305.     public static String byteArr2HexStr(byte[] arrB) throws IOException {
  306.         int iLen = arrB.length;
  307.         StringBuffer sb = new StringBuffer(iLen * 2);
  308.  
  309.         for (int i = 0; i < iLen; ++i) {
  310.             int intTmp;
  311.             for (intTmp = arrB[i]; intTmp < 0; intTmp += 256) {
  312.             }
  313.  
  314.             if (intTmp < 16) {
  315.                 sb.append("0");
  316.             }
  317.  
  318.             sb.append(Integer.toString(intTmp, 16));
  319.         }
  320.  
  321.         return sb.toString();
  322.     }
  323.  
  324.     /**
  325.      *
  326.      * 16进制数据转为明文
  327.      * @param arrB
  328.      * @return
  329.      * @throws IOException
  330.      */
  331.     public static String convertHexToString(String hex) {
  332.  
  333.         StringBuilder sb = new StringBuilder();
  334.         StringBuilder temp = new StringBuilder();
  335.         for (int i = 0; i < hex.length() - 1; i += 2) {
  336.             String output = hex.substring(i, (i + 2));
  337.             int decimal = Integer.parseInt(output, 16);
  338.             sb.append((char) decimal);
  339.             temp.append(decimal);
  340.         }
  341.  
  342.         return sb.toString();
  343.     }
  344.     /**
  345.      * 左补齐
  346.      *
  347.      * @param 原字符串
  348.      * @param 左补字符
  349.      * @param 补齐长度
  350.      * @return 如果原字符串超长,返回原字符串
  351.      */
  352.     public static String lpad(String str, char ch, int len) {
  353.         if (str.length() >= len) {
  354.             return str;
  355.         }
  356.  
  357.         char[] origChs = str.toCharArray();
  358.         char[] chs = new char[len];
  359.         int pos = len - origChs.length;
  360.  
  361.         for (int i = 0; i < len; i++) {
  362.             if (i < pos) {
  363.                 chs[i] = ch;
  364.             } else {
  365.                 chs[i] = origChs[i - pos];
  366.             }
  367.         }
  368.         return new String(chs);
  369.     }
  370.  
  371. }

 3、解码

  1. package com.com.test.bbw;
  2.  
  3. import io.netty.buffer.ByteBuf;
  4. import io.netty.channel.ChannelHandlerContext;
  5. import io.netty.handler.codec.MessageToMessageDecoder;
  6.  
  7. import java.util.List;
  8.  
  9. public class MsgPckDecode extends MessageToMessageDecoder<ByteBuf> {
  10. 	//明文长度
  11. 	private static final Integer msgLeng = 5;
  12. 	@Override
  13. 	protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
  14.  
  15. 		final byte[] headMessage;
  16. 		final byte[] contentMessage;
  17. 		headMessage = new byte[2];
  18. 		// 定义可变字符串用于存储取到的明文数据
  19. 		StringBuffer msgTemp = new StringBuffer();
  20. 		//获取报文长度
  21. 		msg.getBytes(msg.readerIndex(), headMessage, 0, 2);
  22. 		// 将两位报文ASII码数据转为10进制长度
  23. 		int msgLength = ConverUtils.decodeMsgLength(headMessage);
  24. 		String msgLengthStr = msgLength+"";
  25. 		msgLengthStr = ConverUtils.lpad(msgLengthStr, '0', msgLeng);
  26. 		msgTemp.append(msgLengthStr);
  27.         //根据报文长度读取内容
  28. 		contentMessage = new byte[msgLength];
  29. 		msg.getBytes(2, contentMessage, 0, msgLength);
  30. 		// 拿到的字节数据转为16进制数据
  31. 		String asciiBytesToMsg = ConverUtils.byteArr2HexStr(contentMessage);
  32. 		String message = ConverUtils.convertHexToString(asciiBytesToMsg);
  33. 		msgTemp.append(message);
  34. 		out.add(msgTemp.toString());
  35.  
  36. 	}
  37.  
  38. }
  1. package com.com.test.bbw;
  2.  
  3. import io.netty.buffer.ByteBuf;
  4. import io.netty.channel.ChannelHandlerContext;
  5. import io.netty.handler.codec.MessageToByteEncoder;
  6. import org.msgpack.MessagePack;
  7.  
  8. public class MsgPckEncode extends MessageToByteEncoder<Object> {
  9.  
  10. 	private static final Integer msgLeng = 5;
  11. 	@Override
  12. 	protected void encode(ChannelHandlerContext ctx, Object msg, ByteBuf buf) throws Exception {
  13. 		MessagePack pack = new MessagePack();
  14. 		String dataStr = (String) msg;
  15. 		// 第一步:获取报文长度
  16. 		int msgLength = Integer.parseInt(dataStr.substring(0, msgLeng));
  17. 		String msgInfo = dataStr.substring(msgLeng);
  18. 		//将报文 长度转为16进制 ，内容转为ASCII码
  19. 		String convertStringToHex  = ConverUtils.convertStringToHex(msgInfo);
  20. 		byte[] message = ConverUtils.addBytes(ConverUtils.encode(msgLength, 2), ConverUtils.hexToByteArray(convertStringToHex));
  21. 		buf.writeBytes(message);
  22.  
  23. 	}
  24. }

4、前置与服务B之间长链接，支持断线重连机制 

  1. package com.com.test.bbw;
  2.  
  3. import io.netty.bootstrap.Bootstrap;
  4. import io.netty.channel.*;
  5. import io.netty.channel.nio.NioEventLoopGroup;
  6. import io.netty.channel.socket.SocketChannel;
  7. import io.netty.channel.socket.nio.NioSocketChannel;
  8. import io.netty.handler.timeout.IdleStateHandler;
  9. import org.slf4j.Logger;
  10. import org.slf4j.LoggerFactory;
  11.  
  12. import java.util.concurrent.TimeUnit;
  13.  
  14. public class TCPBBWAdaptor {
  15.     private static final Logger log = LoggerFactory.getLogger(TCPBBWAdaptor.class);
  16.     private String bbwServerIp;
  17.     private int bbwServerPort;/* 端口 */
  18.     private String encoding;/* 编码方式 */
  19.     private int timeout=10000;/* 超时时间：秒 */
  20.     private EventLoopGroup group;
  21.     private Bootstrap client;
  22.     private Channel channel;
  23.  
  24.     public static Logger getLog() {
  25.         return log;
  26.     }
  27.  
  28.     private ChannelFuture future;
  29.  
  30.     public TCPBBWAdaptor() {
  31.         init();
  32.         group = new NioEventLoopGroup();
  33.         client = new Bootstrap();
  34.         client.group(group);
  35.         client.channel(NioSocketChannel.class);
  36.         client.option(ChannelOption.SO_KEEPALIVE, true);
  37.         client.handler(new ChannelInitializer<SocketChannel>() {
  38.  
  39.             @Override
  40.             protected void initChannel(SocketChannel ch) throws Exception {
  41.                 // 按照\r\n进行解码
  42.                 //ch.pipeline().addLast(new DelimiterBasedFrameDecoder(Integer.MAX_VALUE, Delimiters.lineDelimiter()[0]));
  43.                 ch.pipeline().addLast(new IdleStateHandler(0, 0, 5))
  44.                         .addLast(new MsgPckDecode())
  45.                         .addLast(new MsgPckEncode())
  46.                         .addLast(new TcpBBWClientHandler(TCPBBWAdaptor.this));
  47.             }
  48.  
  49.         });
  50.     }
  51.  
  52.     public Object send(Object msg) {
  53.         try {
  54.             if (channel != null && channel.isActive()) {
  55.                 doSend(msg);
  56.             } else {
  57.                 restConnOrConn();
  58.                 send(msg);
  59.             }
  60.         } catch (Exception e) {
  61.             log.info("连接异常!");
  62.             group.shutdownGracefully();
  63.         }
  64.  
  65.         return msg;
  66.     }
  67.  
  68.     private void doSend(Object msg) {
  69.         group.execute(new Runnable() {
  70.             @Override
  71.             public void run() {
  72.                 channel.writeAndFlush(msg);
  73.             }
  74.         });
  75.     }
  76.  
  77.     public void restConnOrConn() throws InterruptedException {
  78.         future = client.connect(bbwServerIp, bbwServerPort).sync();
  79.         future.addListener(new ChannelFutureListener() {
  80.             @Override
  81.             public void operationComplete(ChannelFuture future) throws Exception {
  82.                 if (future.isSuccess()) {
  83.                     channel = future.channel();
  84.                 } else {
  85.                     future.channel().eventLoop().schedule(new Runnable() {
  86.  
  87.                         @Override
  88.                         public void run() {
  89.                             try {
  90.                                 restConnOrConn();
  91.                             } catch (InterruptedException e) {
  92.                                 // TODO Auto-generated catch block
  93.                                 e.printStackTrace();
  94.                             }
  95.  
  96.                         }
  97.                     }, 2, TimeUnit.SECONDS);
  98.                 }
  99.             }
  100.         });
  101.  
  102.     }
  103.     public void init(){
  104.         this.bbwServerIp=BBWConfig.getBbwServerIp();
  105.         this.bbwServerPort= Integer.parseInt(BBWConfig.getBbwServerPort());
  106.         this.encoding=BBWConfig.getEncoding();
  107.     }
  108. }
  1. package com.com.test.bbw;
  2.  
  3. import com.com.test.client.TCPPayAdaptor;
  4. import io.netty.channel.ChannelHandlerContext;
  5. import io.netty.channel.ChannelInboundHandlerAdapter;
  6. import io.netty.handler.timeout.IdleStateEvent;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import org.springframework.util.StringUtils;
  10.  
  11. public class TcpBBWClientHandler extends ChannelInboundHandlerAdapter {
  12. 	private static final Logger log = LoggerFactory.getLogger(TcpBBWClientHandler.class);
  13. 	// 明文报文长度
  14. 	private static final Integer msgLeng = 5;
  15. 	private TCPBBWAdaptor clinet;
  16. 	public TcpBBWClientHandler(TCPBBWAdaptor clinet) {
  17.         this.clinet = clinet;
  18. 	}
  19. 	/**
  20. 	 * 客户端与服务端创建连接的时候调用
  21. 	 */
  22. 	@Override
  23. 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
  24. 		   ctx.fireChannelActive();
  25. 	}
  26.  
  27. 	/**
  28. 	 * 客户端与服务端断开连接时调用
  29. 	 */
  30. 	@Override
  31. 	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
  32. 		clinet.restConnOrConn();
  33. 	}
  34.  
  35. 	/**
  36. 	 * 服务端接收客户端发送过来的数据结束之后调用
  37. 	 */
  38. 	@Override
  39. 	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
  40. 		ctx.flush();
  41. 	}
  42.  
  43. 	/**
  44. 	 * 工程出现异常的时候调用
  45. 	 */
  46. 	@Override
  47. 	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  48. 		cause.printStackTrace();
  49. 		ctx.close();
  50. 		//重新连接
  51. 		clinet.restConnOrConn();
  52. 	}
  53. 	/**
  54. 	 * 心跳处理方法
  55. 	 */
  56. 	@Override
  57. 	public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
  58. 		// 如果属于心跳处理
  59. 		if (evt instanceof IdleStateEvent) {
  60. 			IdleStateEvent event = (IdleStateEvent) evt;
  61. 			switch (event.state()) {
  62. 			case READER_IDLE:
  63. 				break;
  64. 			case WRITER_IDLE:
  65. 				break;
  66. 			case ALL_IDLE:
  67. 				//发送心跳
  68. 				sendMsg(ctx);
  69. 				break;
  70. 			}
  71. 		}
  72. 		super.userEventTriggered(ctx, evt);
  73. 	}
  74. 	private void sendMsg(ChannelHandlerContext ctx) {
  75. 		ctx.channel().writeAndFlush("");
  76. 	}
  77. 	@Override
  78. 	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  79. 		ctx.channel().eventLoop().execute(new Runnable() {
  80. 			@Override
  81. 			public void run() {
  82. 				final String msgL=(String)msg;
  83. 				if (!StringUtils.isEmpty(msgL)) {
  84. 					log.debug("接收到报文为：" +msg);
  85. 					TCPPayAdaptor payAdaptor=new TCPPayAdaptor();
  86. 					payAdaptor.send(msg);
  87. 				}
  88. 			}
  89. 		});
  90. 	}
  91.  
  92. }

 5、前置与服务A之间短连接，异步调用

  1. package com.com.test.client;
  2.  
  3. import com.com.test.bbw.BBWConfig;
  4. import io.netty.bootstrap.Bootstrap;
  5. import io.netty.buffer.ByteBuf;
  6. import io.netty.buffer.Unpooled;
  7. import io.netty.channel.*;
  8. import io.netty.channel.nio.NioEventLoopGroup;
  9. import io.netty.channel.socket.SocketChannel;
  10. import io.netty.channel.socket.nio.NioSocketChannel;
  11. import io.netty.handler.codec.string.StringDecoder;
  12. import io.netty.handler.codec.string.StringEncoder;
  13. import io.netty.handler.timeout.IdleStateHandler;
  14. import org.slf4j.Logger;
  15. import org.slf4j.LoggerFactory;
  16. import org.springframework.util.StringUtils;
  17.  
  18. import java.io.UnsupportedEncodingException;
  19.  
  20. public class TCPPayAdaptor {
  21. 	private static final Logger log = LoggerFactory.getLogger(TCPPayAdaptor.class);
  22. 	private String payRcvServerIp;
  23. 	private int payTcpRcvPort;/* 端口 */
  24. 	private String encoding;/* 编码方式 */
  25. 	private int timeout=20000;/* 超时时间：秒 */
  26. 	private EventLoopGroup group;
  27. 	private Bootstrap client;
  28. 	private Channel channel;
  29.  
  30. 	public static Logger getLog() {
  31. 		return log;
  32. 	}
  33.  
  34. 	private ChannelFuture future;
  35.  
  36. 	public TCPPayAdaptor() {
  37. 		init();
  38. 		group = new NioEventLoopGroup();
  39. 		client = new Bootstrap();
  40. 		client.group(group);
  41. 		client.channel(NioSocketChannel.class);
  42. 		client.option(ChannelOption.SO_KEEPALIVE, true);
  43. 		client.handler(new ChannelInitializer<SocketChannel>() {
  44.  
  45. 			@Override
  46. 			protected void initChannel(SocketChannel ch) throws Exception {
  47. 				// 按照\r\n进行解码
  48. 				//ch.pipeline().addLast(new DelimiterBasedFrameDecoder(Integer.MAX_VALUE, Delimiters.lineDelimiter()[0]));
  49. 				ch.pipeline().addLast(new IdleStateHandler(0, 0, 5))
  50. 						.addLast(new StringDecoder())
  51. 						.addLast(new StringEncoder())
  52. 						.addLast(new TcpPayClientHandler());
  53. 			}
  54.  
  55. 		});
  56. 		try {
  57. 			future = client.connect(payRcvServerIp, payTcpRcvPort).sync();
  58. 			if(future!=null&&future.isSuccess()){
  59. 				channel=future.channel();
  60. 			}
  61. 		} catch (InterruptedException e) {
  62. 			e.printStackTrace();
  63. 		}
  64. 	}
  65.  
  66. 	public Object send(Object msg) {
  67. 		try {
  68. 			if (channel != null && channel.isActive()) {
  69. 				doSend(msg);
  70. 			}
  71. 		} catch (Exception e) {
  72. 			log.info("连接异常!");
  73. 			group.shutdownGracefully();
  74. 		}
  75.  
  76. 		return msg;
  77. 	}
  78.  
  79. 	private void doSend(Object msg) {
  80. 		try {
  81. 			final String msgL=(String)msg;
  82. 			byte[] bytes = msgL.getBytes(encoding);
  83. 			ByteBuf buf = Unpooled.wrappedBuffer(bytes);
  84. 			byte[] req = new byte[buf.readableBytes()];
  85. 			buf.readBytes(req);
  86. 			String smsg = new String(req, encoding);
  87. 			if (!StringUtils.isEmpty(smsg)) {
  88. 				log.debug("接收到报文为：" + smsg);
  89. 				channel.writeAndFlush(smsg);
  90. 			}
  91. 			ByteBuf buffer = Unpooled.buffer();
  92. 			buffer.writeBytes(req);
  93. 		} catch (UnsupportedEncodingException e) {
  94. 			log.info("bbw返回发送异常");
  95. 		}
  96. 	}
  97.  
  98. 	public void init(){
  99. 		this.payTcpRcvPort= Integer.parseInt(BBWConfig.getPayTcpRcvPort());
  100. 		this.payRcvServerIp= BBWConfig.getPayRcvServerIp();
  101. 		this.encoding= BBWConfig.getEncoding();
  102. 	}
  103. }
  1. package com.com.test.client;
  2. import io.netty.channel.ChannelHandlerContext;
  3. import io.netty.channel.ChannelInboundHandlerAdapter;
  4. import io.netty.handler.timeout.IdleStateEvent;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7.  
  8. import java.lang.reflect.Method;
  9.  
  10. public class TcpPayClientHandler extends ChannelInboundHandlerAdapter {
  11. 	private static final Logger log = LoggerFactory.getLogger(TcpPayClientHandler.class);
  12. 	// 明文报文长度
  13. 	private static final Integer msgLeng = 5;
  14. 	/**
  15. 	 * 客户端与服务端创建连接的时候调用
  16. 	 */
  17. 	@Override
  18. 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
  19. 		ctx.fireChannelActive();
  20. 	}
  21.  
  22. 	/**
  23. 	 * 客户端与服务端断开连接时调用
  24. 	 */
  25. 	@Override
  26. 	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
  27. 		ctx.channel().writeAndFlush("");
  28. 	}
  29.  
  30. 	/**
  31. 	 * 服务端接收客户端发送过来的数据结束之后调用
  32. 	 */
  33. 	@Override
  34. 	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
  35. 		ctx.flush();
  36. 	}
  37.  
  38. 	/**
  39. 	 * 工程出现异常的时候调用
  40. 	 */
  41. 	@Override
  42. 	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  43. 		cause.printStackTrace();
  44. 		ctx.close();
  45. 	}
  46. }

6、 服务B监听器，用来监听B系统发送给前置消息，用来转发到服务A

  1. package com.com.test.listener;
  2.  
  3. import com.com.test.server.Server;
  4. import org.apache.commons.logging.Log;
  5. import org.apache.commons.logging.LogFactory;
  6. import org.springframework.boot.ApplicationArguments;
  7. import org.springframework.boot.ApplicationRunner;
  8. import org.springframework.stereotype.Component;
  9.  
  10.  
  11.  
  12. @Component
  13. public class BBWListener implements ApplicationRunner{
  14. 	private static final Log logger = LogFactory.getLog(BBWListener.class);
  15.  
  16. 	@Override
  17. 	public void run(ApplicationArguments args) throws Exception {
  18.  
  19. 		if (logger.isInfoEnabled()) {
  20. 			logger.info("Starting booting core banking services platform...");
  21. 		}
  22. 		// Start
  23. 		try {
  24. 			Server server = new Server();
  25. 			server.start();
  26. 		} catch (Exception e) {
  27. 			e.printStackTrace();
  28. 			logger.error(e);
  29. 		}
  30. 		if (logger.isInfoEnabled()) {
  31. 			logger.info("Started booted bbw banking services platform...");
  32. 		}
  33. 	}
  34.  
  35. }

7、接收到系统B消息服务端

  1. package com.com.test.server;
  2.  
  3. import com.com.test.bbw.BBWConfig;
  4. import io.netty.bootstrap.ServerBootstrap;
  5. import io.netty.channel.ChannelFuture;
  6. import io.netty.channel.ChannelInitializer;
  7. import io.netty.channel.ChannelOption;
  8. import io.netty.channel.ChannelPipeline;
  9. import io.netty.channel.EventLoopGroup;
  10. import io.netty.channel.nio.NioEventLoopGroup;
  11. import io.netty.channel.socket.ServerSocketChannel;
  12. import io.netty.channel.socket.SocketChannel;
  13. import io.netty.channel.socket.nio.NioServerSocketChannel;
  14. import io.netty.handler.codec.string.StringDecoder;
  15. import io.netty.handler.codec.string.StringEncoder;
  16. import org.apache.commons.logging.Log;
  17. import org.apache.commons.logging.LogFactory;
  18.  
  19.  
  20. public class Server {
  21.     private static final Log logger = LogFactory.getLog(Server.class);
  22.     private int paySendPort;
  23.     private String encoding;/* 编码方式 */
  24.     private int timeout = 10000;/* 超时时间：秒 */
  25.     private int conNum = 1;/* 保持连接数 */
  26.     private ServerSocketChannel serverSocketChannel;
  27.  
  28.     private void bind() {
  29.         //服务端要建立两个group，一个负责接收客户端的连接，一个负责处理数据传输
  30.         //连接处理group
  31.         EventLoopGroup boss = new NioEventLoopGroup();
  32.         //事件处理group
  33.         EventLoopGroup worker = new NioEventLoopGroup();
  34.         ServerBootstrap bootstrap = new ServerBootstrap();
  35.         // 绑定处理group
  36.         bootstrap.group(boss, worker).channel(NioServerSocketChannel.class)
  37.                 //保持连接数
  38.                // .option(ChannelOption.SO_BACKLOG, conNum)
  39.                 //有数据立即发送
  40.                 .option(ChannelOption.TCP_NODELAY, true)
  41.                 //保持连接
  42.                 .childOption(ChannelOption.SO_KEEPALIVE, false)
  43.                 //处理新连接
  44.                 .childHandler(new ChannelInitializer<SocketChannel>() {
  45.                     @Override
  46.                     protected void initChannel(SocketChannel sc) throws Exception {
  47.                         // 增加任务处理
  48.                         ChannelPipeline p = sc.pipeline();
  49.                         p.addLast(
  50.                                 //使用了netty自带的编码器和解码器
  51.                                 new StringDecoder(),
  52.                                 new StringEncoder(),
  53.                                 //心跳检测，读超时，写超时，读写超时
  54.                                 //new IdleStateHandler(5, 0, 0, TimeUnit.SECONDS),
  55.                                 //自定义的处理器
  56.                                 new ServerHandler());
  57.                     }
  58.                 });
  59.  
  60.         //绑定端口，同步等待成功
  61.         ChannelFuture future;
  62.         try {
  63.             future = bootstrap.bind(paySendPort).sync();
  64.             if (future.isSuccess()) {
  65.                 serverSocketChannel = (ServerSocketChannel) future.channel();
  66.                 logger.info("服务端启动成功，端口：" + paySendPort);
  67.             } else {
  68.                 logger.info("服务端启动失败！");
  69.             }
  70.             //等待服务监听端口关闭,就是由于这里会将线程阻塞，导致无法发送信息，所以我这里开了线程
  71.             future.channel().closeFuture().sync();
  72.         } catch (Exception e) {
  73.             e.printStackTrace();
  74.         } finally {
  75.             //优雅地退出，释放线程池资源
  76.             boss.shutdownGracefully();
  77.             worker.shutdownGracefully();
  78.         }
  79.     }
  80.  
  81.     public void init() {
  82.         this.paySendPort = Integer.parseInt(BBWConfig.getPaySendPort());
  83.         this.encoding = BBWConfig.getEncoding();
  84.     }
  85.  
  86.     public void start() {
  87.         init();
  88.         bind();
  89.     }
  90. }

 7、接收到系统B消息客户端，调用

TCPPayAdaptor转发到系统A
  1. package com.com.test.server;
  2.  
  3. import com.com.test.bbw.TCPBBWAdaptor;
  4. import io.netty.buffer.ByteBuf;
  5. import io.netty.buffer.Unpooled;
  6. import io.netty.channel.ChannelHandlerContext;
  7. import io.netty.channel.ChannelInboundHandlerAdapter;
  8. import io.netty.util.CharsetUtil;
  9. import org.apache.commons.logging.Log;
  10. import org.apache.commons.logging.LogFactory;
  11. import org.springframework.util.StringUtils;
  12.  
  13. import java.io.UnsupportedEncodingException;
  14.  
  15. public class ServerHandler extends ChannelInboundHandlerAdapter {
  16. 	private static final Log logger = LogFactory.getLog(ServerHandler.class);
  17. 	/**
  18. 	 * 客户端与服务端创建连接的时候调用
  19. 	 */
  20. 	@Override
  21. 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
  22. 		ctx.fireChannelActive();
  23. 	}
  24.  
  25. 	/**
  26. 	 * 一旦建立连接第一个被执行
  27. 	 */
  28. 	@Override
  29. 	public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
  30. 	}
  31.  
  32. 	/**
  33. 	 * 客户端与服务端断开连接时调用
  34. 	 */
  35. 	@Override
  36. 	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
  37. 		ctx.close();
  38. 	}
  39. 	/**
  40. 	 * 服务端接收客户端发送过来的数据结束之后调用
  41. 	 */
  42. 	@Override
  43. 	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
  44. 		ctx.flush();
  45. 	}
  46.  
  47. 	/**
  48. 	 * 工程出现异常的时候调用
  49. 	 */
  50. 	@Override
  51. 	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  52. 		cause.printStackTrace();
  53. 		ctx.close();
  54. 	}
  55.  
  56. 	/**
  57. 	 * 服务端处理客户端websocket请求的核心方法，这里接收了客户端发来的信息
  58. 	 */
  59. 	@Override
  60. 	public void channelRead(ChannelHandlerContext channelHandlerContext, Object info) throws Exception {
  61. 		logger.info("接收到了：" + info);
  62. 		try {
  63. 			final String msgL=(String)info;
  64. 			byte[] bytes = msgL.getBytes(CharsetUtil.UTF_8);
  65. 			ByteBuf buf = Unpooled.wrappedBuffer(bytes);
  66. 			byte[] req = new byte[buf.readableBytes()];
  67. 			buf.readBytes(req);
  68. 			String smsg = new String(req, CharsetUtil.UTF_8);
  69. 			if (!StringUtils.isEmpty(smsg)) {
  70. 				logger.debug("接收到报文为：" + smsg);
  71. 				new TCPBBWAdaptor().send(info);
  72. 			}
  73. 			ByteBuf buffer = Unpooled.buffer();
  74. 			buffer.writeBytes(req);
  75. 		} catch (Exception e) {
  76. 			logger.info("bbw返回发送异常");
  77. 		}
  78. 	}
  79.  
  80. }

8、启动类 

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
  4. import org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration;
  5. import org.springframework.context.annotation.ComponentScan;
  6.  
  7. @ComponentScan(basePackages = {"com"})
  8. @SuppressWarnings("all")
  9. @SpringBootApplication(exclude= {DataSourceAutoConfiguration.class, MongoAutoConfiguration.class})
  10. public class TestApplication {
  11.  
  12. 	public static void main(String[] args) {
  13. 		SpringApplication.run(TestApplication.class, args);
  14. 	}
  15.  
  16. }
日志
logging.config=classpath:logback-boot.xml

BBWConfig.properties

#BBW服务器地址
bbwServerIp=127.0.0.1
#BBW服务器端口
bbwServerPort=4444
#支付接出端口Tcp
paySendPort=50039
#支付接入平台地址
payRcvServerIp=127.0.0.1
#支付平台接入端口tcp
payTcpRcvPort=50040
#支付平台接入http端口
payHttpRcvPort=9004
#AGENt重连次数警告consumer
warningNum=10
#报文编码格式
encoding=UTF8
#AGNET异常重连间隔（单位：毫秒）
reStartTime=10000
test=003090800C220000080000000040000000000000003535122313335102421203535301

logback-boot.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
  3. <!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
  4. <!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
  5. <!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
  6. <configuration  scan="true" scanPeriod="10 seconds">
  7.  
  8.     <!--<include resource="org/springframework/boot/logging/logback/base.xml" />-->
  9.  
  10.     <contextName>logback</contextName>
  11.     <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。 -->
  12.     <property name="log.path" value="D:/nmyslog/nmys" />
  13.  
  14.     <!-- 彩色日志 -->
  15.     <!-- 彩色日志依赖的渲染类 -->
  16.     <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
  17.     <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
  18.     <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
  19.     <!-- 彩色日志格式 -->
  20.     <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
  21.  
  22.  
  23.     <!--输出到控制台-->
  24.     <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
  25.         <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
  26.         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
  27.             <level>info</level>
  28.         </filter>
  29.         <encoder>
  30.             <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
  31.             <!-- 设置字符集 -->
  32.             <charset>UTF-8</charset>
  33.         </encoder>
  34.     </appender>
  35.  
  36.  
  37.     <!--输出到文件-->
  38.  
  39.     <!-- 时间滚动输出 level为 DEBUG 日志 -->
  40.     <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  41.         <!-- 正在记录的日志文件的路径及文件名 -->
  42.         <file>${log.path}/log_debug.log</file>
  43.         <!--日志文件输出格式-->
  44.         <encoder>
  45.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  46.             <charset>UTF-8</charset> <!-- 设置字符集 -->
  47.         </encoder>
  48.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  49.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  50.             <!-- 日志归档 -->
  51.             <fileNamePattern>${log.path}/debug/log-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  52.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  53.                 <maxFileSize>100MB</maxFileSize>
  54.             </timeBasedFileNamingAndTriggeringPolicy>
  55.             <!--日志文件保留天数-->
  56.             <maxHistory>15</maxHistory>
  57.         </rollingPolicy>
  58.         <!-- 此日志文件只记录debug级别的 -->
  59.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  60.             <level>debug</level>
  61.             <onMatch>ACCEPT</onMatch>
  62.             <onMismatch>DENY</onMismatch>
  63.         </filter>
  64.     </appender>
  65.  
  66.     <!-- 时间滚动输出 level为 INFO 日志 -->
  67.     <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  68.         <!-- 正在记录的日志文件的路径及文件名 -->
  69.         <file>${log.path}/log_info.log</file>
  70.         <!--日志文件输出格式-->
  71.         <encoder>
  72.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  73.             <charset>UTF-8</charset>
  74.         </encoder>
  75.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  76.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  77.             <!-- 每天日志归档路径以及格式 -->
  78.             <fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  79.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  80.                 <maxFileSize>100MB</maxFileSize>
  81.             </timeBasedFileNamingAndTriggeringPolicy>
  82.             <!--日志文件保留天数-->
  83.             <maxHistory>15</maxHistory>
  84.         </rollingPolicy>
  85.         <!-- 此日志文件只记录info级别的 -->
  86.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  87.             <level>info</level>
  88.             <onMatch>ACCEPT</onMatch>
  89.             <onMismatch>DENY</onMismatch>
  90.         </filter>
  91.     </appender>
  92.  
  93.     <!-- 时间滚动输出 level为 WARN 日志 -->
  94.     <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  95.         <!-- 正在记录的日志文件的路径及文件名 -->
  96.         <file>${log.path}/log_warn.log</file>
  97.         <!--日志文件输出格式-->
  98.         <encoder>
  99.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  100.             <charset>UTF-8</charset> <!-- 此处设置字符集 -->
  101.         </encoder>
  102.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  103.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  104.             <fileNamePattern>${log.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  105.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  106.                 <maxFileSize>100MB</maxFileSize>
  107.             </timeBasedFileNamingAndTriggeringPolicy>
  108.             <!--日志文件保留天数-->
  109.             <maxHistory>15</maxHistory>
  110.         </rollingPolicy>
  111.         <!-- 此日志文件只记录warn级别的 -->
  112.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  113.             <level>warn</level>
  114.             <onMatch>ACCEPT</onMatch>
  115.             <onMismatch>DENY</onMismatch>
  116.         </filter>
  117.     </appender>
  118.  
  119.  
  120.     <!-- 时间滚动输出 level为 ERROR 日志 -->
  121.     <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  122.         <!-- 正在记录的日志文件的路径及文件名 -->
  123.         <file>${log.path}/log_error.log</file>
  124.         <!--日志文件输出格式-->
  125.         <encoder>
  126.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  127.             <charset>UTF-8</charset> <!-- 此处设置字符集 -->
  128.         </encoder>
  129.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  130.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  131.             <fileNamePattern>${log.path}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  132.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  133.                 <maxFileSize>100MB</maxFileSize>
  134.             </timeBasedFileNamingAndTriggeringPolicy>
  135.             <!--日志文件保留天数-->
  136.             <maxHistory>15</maxHistory>
  137.         </rollingPolicy>
  138.         <!-- 此日志文件只记录ERROR级别的 -->
  139.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  140.             <level>ERROR</level>
  141.             <onMatch>ACCEPT</onMatch>
  142.             <onMismatch>DENY</onMismatch>
  143.         </filter>
  144.     </appender>
  145.  
  146.     <!--
  147.         <logger>用来设置某一个包或者具体的某一个类的日志打印级别、
  148.         以及指定<appender>。<logger>仅有一个name属性，
  149.         一个可选的level和一个可选的addtivity属性。
  150.         name:用来指定受此logger约束的某一个包或者具体的某一个类。
  151.         level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
  152.               还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。
  153.               如果未设置此属性，那么当前logger将会继承上级的级别。
  154.         addtivity:是否向上级logger传递打印信息。默认是true。
  155.     -->
  156.     <!--<logger name="org.springframework.web" level="info"/>-->
  157.     <!--<logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>-->
  158.     <!--
  159.         使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：
  160.         第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
  161.         第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别：
  162.      -->
  163.  
  164.  
  165.     <!--
  166.         root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
  167.         level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
  168.         不能设置为INHERITED或者同义词NULL。默认是DEBUG
  169.         可以包含零个或多个元素，标识这个appender将会添加到这个logger。
  170.     -->
  171.  
  172.     <!--开发环境:打印控制台-->
  173.     <springProfile name="dev">
  174.         <logger name="com.com.test.bbw" level="debug"/>
  175.     </springProfile>
  176.  
  177.     <root level="info">
  178.         <appender-ref ref="CONSOLE" />
  179.         <appender-ref ref="DEBUG_FILE" />
  180.         <appender-ref ref="INFO_FILE" />
  181.         <appender-ref ref="WARN_FILE" />
  182.         <appender-ref ref="ERROR_FILE" />
  183.     </root>
  184.  
  185.     <!--生产环境:输出到文件-->
  186.     <!--<springProfile name="pro">-->
  187.         <!--<root level="info">-->
  188.             <!--<appender-ref ref="CONSOLE" />-->
  189.             <!--<appender-ref ref="DEBUG_FILE" />-->
  190.             <!--<appender-ref ref="INFO_FILE" />-->
  191.             <!--<appender-ref ref="ERROR_FILE" />-->
  192.             <!--<appender-ref ref="WARN_FILE" />-->
  193.         <!--</root>-->
  194.     <!--</springProfile>-->
  195.  
  196. </configuration>

pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4. 	<modelVersion>4.0.0</modelVersion>
  5. 	<parent>
  6. 		<groupId>org.springframework.boot</groupId>
  7. 		<artifactId>spring-boot-starter-parent</artifactId>
  8. 		<version>2.4.1</version>
  9. 		<relativePath/> <!-- lookup parent from repository -->
  10. 	</parent>
  11. 	<groupId>com.test</groupId>
  12. 	<artifactId>test</artifactId>
  13. 	<version>0.0.1-SNAPSHOT</version>
  14. 	<name>test</name>
  15. 	<description>Demo project for Spring Boot</description>
  16.  
  17. 	<properties>
  18. 		<java.version>1.8</java.version>
  19. 	</properties>
  20.  
  21. 	<dependencies>
  22. 		<dependency>
  23. 			<groupId>org.springframework.boot</groupId>
  24. 			<artifactId>spring-boot-starter-data-mongodb</artifactId>
  25. 		</dependency>
  26. 		<dependency>
  27. 			<groupId>org.springframework.boot</groupId>
  28. 			<artifactId>spring-boot-starter-jdbc</artifactId>
  29. 		</dependency>
  30. 		<dependency>
  31. 			<groupId>org.springframework.boot</groupId>
  32. 			<artifactId>spring-boot-starter-web</artifactId>
  33. 		</dependency>
  34. 		<dependency>
  35. 			<groupId>org.springframework.kafka</groupId>
  36. 			<artifactId>spring-kafka</artifactId>
  37. 		</dependency>
  38. 		<dependency>
  39. 			<groupId>io.netty</groupId>
  40. 			<artifactId>netty-all</artifactId>
  41. 		</dependency>
  42. 		<dependency>
  43. 			<groupId>org.msgpack</groupId>
  44. 			<artifactId>msgpack</artifactId>
  45. 			<version>0.6.12</version>
  46. 		</dependency>
  47. 		 <dependency>
  48.               <groupId>ch.qos.logback</groupId>
  49.               <artifactId>logback-classic</artifactId>
  50.               <version>1.2.3</version>
  51.               <scope>compile</scope>
  52.             </dependency>
  53.             <dependency>
  54.               <groupId>org.apache.logging.log4j</groupId>
  55.               <artifactId>log4j-to-slf4j</artifactId>
  56.               <version>2.10.0</version>
  57.               <scope>compile</scope>
  58.             </dependency>
  59.             <dependency>
  60.               <groupId>org.slf4j</groupId>
  61.               <artifactId>jul-to-slf4j</artifactId>
  62.               <version>1.7.25</version>
  63.               <scope>compile</scope>
  64.             </dependency>
  65. 		<dependency>
  66. 			<groupId>org.springframework.boot</groupId>
  67. 			<artifactId>spring-boot-starter-test</artifactId>
  68. 			<scope>test</scope>
  69. 		</dependency>
  70. 		<dependency>
  71. 			<groupId>org.springframework.kafka</groupId>
  72. 			<artifactId>spring-kafka-test</artifactId>
  73. 			<scope>test</scope>
  74. 		</dependency>
  75. 	</dependencies>
  76.  
  77. 	<build>
  78. 		<plugins>
  79. 			<plugin>
  80. 				<groupId>org.springframework.boot</groupId>
  81. 				<artifactId>spring-boot-maven-plugin</artifactId>
  82. 			</plugin>
  83. 		</plugins>
  84. 	</build>
  85.  
  86. </project>

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号