Go语言视频零基础入门到精通

javalearner

1.介绍：
      本文手把手的详解了jPortMap端口映射程序开发中的每一步，做为己运行在实际的企业项目中的应用， jPortMap程序较全面的展示了Thread、List、Vector、Socket、ServerSocket、Input/OutpuStream、File Read/Write、Properties等核心API的用法，是初学者快速进阶的一个优秀案例。

        在涉及内外网数据交换的网络应用系统开发中，我们经常需要做端口映射，比如放在外部网络主机上的程序要与内部网络上的某台机器建主TCP/IP连结，如下图（1）示：

     C机器可以与A机连通，但要与B机连通，由与不在同一网络，就无能为力了；这时，就需在A机器上做交换或是转发，来接通C与B之间的TCP/IP连结，即C机先与A机器建立Socket连结，A再与B机建立连结，然后由A在中间转发C与B通信的数据；B机器上可能运行着数据库，WebService等在Tcp/IP上通信的程序，而C机器必须访问这些服务。这里A机器就充当像现实生活中介绍人的角色，负责将C、B之间的通信数据流在Socket上转发；  
  
   
   
     
   

     
   
  
图1
       因此，A机需实现端口转发功能，在Liunx上，可以通过配置IPTable由OS实现，在本例中，我们将开发一个java实现的端口转发程序jPortMap,此程序将运行在A机器上，以实现转发C与B之间通信的转发。

2.源码下载及测试说明:

从www.NetJava.cn上下载源代码解压后，可看到如下目录结构：



     现在，你可以修改一下jPortMap.cfg中的配置，比如，想通过本机的127.0.0.1地址上的8899端口转发到10.10.3.156，则这样配置：
##本地IP
LocalIP.1 = 127.0.0.1
##本地端口
LocalPort.1 = 8899
##目标IP
DestHost.1 = 10.10.3.156
##目标端口
DestPort.1 = 80
##客户端IP过滤表,*表示许可模糊匹配
AllowClient.1 = *.*.*.*

,双击jPortMap.bat启动程序后，在你的IE里输入http://127.0.0.1:8899试试看：）
  3.jPortMap程序类的构成说明：
jPortMap由Main.java、Server.java、Transfer.java、Route.java、SysLog.java五个类构成。

类文件功能概要：
Main.java：程序启动主类，负责从配置文件读取转发的配置参数，启动转发服务器；

Server.java:其实是一个ServerSocket服务器，接受C机器进入的Socket连结请求，生成Transfer.对象，由Transfer负责在本机(A上)转发B和C之间的通信。

Route.java:转发对象的数据模板类，用来将转发配置映射为java对象，以由Server，ransfer对象使用。

Transfer.java:按字面意思，可理解为“传送者”，如在图示中，当C要通过A连结B时，是先连结到A机上，这里在C和A间生成一个socket对象，Transfer对象则使用这个生成的socket对象和这个传输任务的Route对象执行具体的转发任务。

SysLog.java:jPortMap是一个服务器端程序，在运行中可能会出现错误，因此需要一个日志工具,日志工具在jPortMap中只有一个对象存在，负责记录每天程序运行的信息，如错误，警行，一般信息等。

配置文件：
    cfgjPortMap.cfg:这是一个文本文件，其中存放jPortMap的配置数据，当程序启动时，主类会从中读取数据配置程序，以生成多个Route对象在内存中保持数据。

4.Route.java解析：
我们己经说明，Route类是转发对象配置数据的模板类，当jPortMap启运时，它需要知道如下配置：
1. 有多少处转发任务(意味着要监听哪几个ServerSocket)；
2. jPortMap程序对每个转发任务要启动的监听ServerSocket端口及所绑定的IP地址；
3. 每个转发任务的目标IP地址和端口;

    因此，jPortMap一但启动，可能会创建多个Route对象，而每个具体的Route对象则保布着一个转发任务的以上配置数据。
另外，从安全方面着想，我们的jPortMap程序还需要对请求进入的连结进行安全管理，这里我们简单的用IP过滤的方法，即jPortMap中ServerSocekt监听到的进入连结请求会认证IP地址，如发现IP地址没有在许可的列表中，则断开这个请求；所以Route类还要保存每个任务对应的许可IP表；
我们的Route.java源文件如下：

1. /*
   
2. * Route.java
   
3. *
   
4. * Created on 2006年12月28日, 下午12:36
   
5. *
   
6. * To change this template, choose Tools | Template Manager
   
7. * and open the template in the editor.
   
8. */
   
9. package org.netjava.jportmap;
   
10. /**
    
11. *转发任务的配置数据对象模板
    
12. *

复制代码

Company: www.NetJava.org * @author javafound */ public class Route { public Route() {} //jPortMap绑定的IP String LocalIP=""; //监听的端口 int LocalPort=0; //转发数据的目标机器IP String DestHost=""; //转发的目标端口 int DestPort=0; //这个转发上许可进入的IP列表 String AllowClient="";
//重写的toString方法，输出具体Route对象的信息以便debug public String toString() { StringBuffer stb = new StringBuffer(); stb.append(" LocalADD " + LocalIP); stb.append(" :" + LocalPort); stb.append(" --->DestHost " + DestHost); stb.append(" :" + DestPort); stb.append(" (AllowClient) " + AllowClient); return stb.toString(); } }  
      可以比对cfgjPortMap.cfg(可用notepad打开)中的内容，Route类只需要据文本件中的配配生成多个Route对象或者说转发任务，再由其它对象来使用，因此，Route类的功能和结构很简单，就像映射表结构的javaBean一样，只是负责保存数据在内存中。

5. SysLog.java解析：
SysLog保存每天的日志信息到指定的目录下，简单的说就是提供方法供别的对象来调用，写内容到文件中:

1. 
   
2. package org.netjava.jportmap;
   
3. import java.io.*;
   
4. import java.util.Calendar;
5. 
   
6. /**
   
7. * Title: 端口转发器
8. * Description:日志工具类
   
9. * Copyright: Copyright (c) 2005
   
10. * Company: www.NetJava.org
    
11. * @author javafound
    
12. * @version 1.0
    
13. */
14. 
    
15. public class SysLog {
    
16.     //记录输出一般信息
    
17.   public  static void info(String s) {
    
18.         writeToTodayLog("INFO  :", s);
    
19.     }
    
20.    ////记录警告信息
    
21. public   static void warning(String s) {
    
22.         writeToTodayLog("WARN:", s);
    
23.     }
    
24.    //记录错误信息
    
25. public   static void severe(String s) {
    
26.         writeToTodayLog("ERROR:", s);
    
27.     }
    
28. //输出到当天日志文件的具体实现
    
29.     private static void writeToTodayLog(String flag, String msg) {
    
30.         RandomAccessFile raf = null;
    
31.         try {
    
32.             Calendar now = Calendar.getInstance();
    
33.             String yyyy = String.valueOf(now.get(java.util.Calendar.YEAR));
    
34.             String mm = String.valueOf(now.get(Calendar.MONTH) + 1);
    
35.             String dd = String.valueOf(now.get(Calendar.DAY_OF_MONTH));
    
36.             String hh = String.valueOf(now.get(Calendar.HOUR_OF_DAY));
    
37.             String ff = String.valueOf(now.get(Calendar.MINUTE));
    
38.             String ss = String.valueOf(now.get(Calendar.SECOND));
    
39.             mm = (1 == mm.length()) ? ("0" + mm) : mm;
    
40.             dd = (1 == dd.length()) ? ("0" + dd) : dd;
    
41.             hh = (1 == hh.length()) ? ("0" + hh) : hh;
    
42.             ff = (1 == ff.length()) ? ("0" + ff) : ff;
    
43.             ss = (1 == ss.length()) ? ("0" + ss) : ss;
    
44.             String yyyymmdd = yyyy + mm + dd;
    
45.             String hhffss=hh+ff+ss;
    
46.             String path = System.getProperties().getProperty("user.dir")
    
47.                           + File.separator + "log";
    
48.             File p = new File(path);
    
49.             if (!p.exists()) {
    
50.                 p.mkdirs();
    
51.             }
    
52.             path += File.separator + "jPortMap_" + yyyymmdd + ".log";
    
53.             File f = new File(path);
    
54.             if (f.isDirectory()) {
    
55.                 f.delete();
    
56.             }
    
57.             raf = new RandomAccessFile(f, "rw");
    
58.             raf.seek(raf.length());
    
59.             raf.writeBytes(hhffss+"  "+flag + " : " + msg + "
    
60. ");
    
61.             raf.close();
    
62.         } catch (Exception ex) {
    
63.             System.out.println("write file has error=" + ex);
    
64.         }
    
65.     }
    
66.      /** Creates a new instance of SysLog
    
67.       *做为一个工具类，一般不需要实例化，所以此处private
    
68.       */
    
69.     private SysLog() {}
    
70. }

复制代码

说明：
首先我们看到提供的三个公用静态方法：
//记录一般信息
public static void info(String s)

////记录警告信息
public static void warning(String s)

//记录错误信息
public static void severe(String s)

      SysLog做为系统中的工具类，一般是不需要实例化的，所以只提供调用功能即可，这三个调用方法为其它对象提供了调用接口，分别输出不同类型的信息到目志中，而调用对象并不需要去关心具体日志的格式，日志文件命令，文件读写等问题----只需传入要记录的消息即可。

     System.getProperties()返回一个Properties对象，其实是一个Map接口的实现,其中存入格式为 名字:值 一一对应的表，系统的许多环境变量，如程序运行的当前目录user.dir,操作系统类型，java当前版本等都在其中存放。

     RandomAccessFile:在写日志时使用了这个类向日志文件中写入内容，其中seek(int length)可以指定跳过文件中内容的长度后再开始写入；这样我们的日志就不会丢失。

6.Server.java解析：
      如其名，Server是一个转发服务器的实现类，我们的jPortMap可同时执行多个转发服务，所以每个Server对象都将做为一个独立的线程运行，在jPortMap.cfg中配置了几个转发任务，系统就会实例几个Route对象，并生成对应个数的的Server对象，每个Server对象使用自己的一个Route对象的数据在指定的端口启动监听服务，等待客户端(如前面图示则是C机器)发起的连结，接收到连结请求并通过IP验证后，这个Server对象则将具体的转发任务交给自己的一个Transfer对象去独立处理，而Server对象则继续运行，等待到来的连结请求。

      我们可以将这个Server理解为一个看门人的角色---使用ServerSocket监听指定端口，等待到来的连结，它只负责接待来客，并核查来客的身份，如核查通过，至于来客进的门怎么办，它不管-----由它所持有的另外一个对象Transfer类的一个实例去处理。解析代码如下：

1. package org.netjava.jportmap;
   
2. import java.net.*;
   
3. import java.util.*;
   
4. /**
   
5. * Title: 端口转发器
   
6. * Description:启动监听服务
   
7. * Copyright: Copyright (c) 2005
   
8. * Company: www.NetJava.org
   
9. * @author javafound
   
10. * @version 1.0
    
11. */
12. 
    
13. public class Server extends Thread {
    
14.     //创建一个转发服务器
    
15.     public Server(Route route, int id) {
    
16.         this.route = route;
    
17.         connectionQueue = new Vector();
    
18.         myID = id;
    
19.         start();
    
20.     }
    
21.     //关闭这个服务器：
    
22.     public void closeServer() {
    
23.         isStop = true;
    
24.         if (null != myServer) {
    
25.             closeServerSocket();
    
26.         } while (this.connectionQueue.size() > 0) {
    
27.             Transfer tc = (Transfer) connectionQueue.remove(0);
    
28.             tc.closeSocket(tc.socket);
    
29.             tc = null;
    
30.         }
    
31.     }
    
32. //启动转发服务器的执行线程
    
33.     public void run() {
    
34.         SysLog.info(" start Transfer......:" + route.toString());
    
35.         ServerSocket myServer = null;
    
36.         try {
    
37.             InetAddress myAD = Inet4Address.getByName(route.LocalIP);
    
38.             myServer = new ServerSocket(route.LocalPort, 4, myAD);
    
39.         } catch (Exception ef) {
    
40.             SysLog.severe("Create Server " + route.toString() + " error:" + ef);
    
41.             closeServerSocket();
    
42.             return;
    
43.         }
    
44.         SysLog.info("Transfer Server : " + route.toString() + " created OK");
    
45.         while (!isStop) {
    
46.             String clientIP = "";
    
47.             try {
    
48.                 Socket sock = myServer.accept();
    
49.                 clientIP = sock.getInetAddress().getHostAddress();
    
50.                 if (checkIP(route, clientIP)) {
    
51.                     SysLog.warning(" ransfer Server : " + route.toString() +
    
52.                                    "  Incoming:" + sock.getInetAddress());
    
53.                     sock.setSoTimeout(0);
    
54.                     connCounter++;
    
55.                     Transfer myt = new Transfer(sock, route);
    
56.                     connectionQueue.add(myt);
    
57.                 } else {
    
58.                     SysLog.warning(" ransfer Server : " + route.toString() +
    
59.                                    "  Refuse :" + sock.getInetAddress());
    
60.                     closeSocket(sock);
    
61.                 }
    
62.             } catch (Exception ef) {
    
63.                 SysLog.severe(" Transfer Server : " + route.toString() +
    
64.                               " accept error" + ef);
    
65.             }
    
66.         }
    
67.     }
    
68.     //检测进入的IP是否己许可
    
69.     private static boolean checkIP(Route route, String inIP) {
    
70.         String[] inI = string2StringArray(inIP, ".");
    
71.         String[] list = string2StringArray(route.AllowClient, ".");
    
72.         if (inI.length != list.length) {
    
73.             SysLog.severe(" Transfer Server Error Cfg AllowClient : " +
    
74.                           route.toString());
    
75.             return false;
    
76.         }
    
77.         for (int i = 0; i < inI.length; i++) {
    
78.             if ((!inI[i].equals(list[i])) && !(list[i].equals("*"))) {
    
79.                 System.out.println(": " + inI[i] + " :" + list[i]);
    
80.                 return false;
    
81.             }
    
82.         }
    
83.         return true;
    
84.     }
    
85.     /*
    
86.      * @param srcString 原字符串
    
87.      * @param separator 分隔符
    
88.      * @return 目的数组
    
89.      */
    
90.     private static final String[] string2StringArray(String srcString,
    
91.             String separator) {
    
92.         int index = 0;
    
93.         String[] temp;
    
94.         StringTokenizer st = new StringTokenizer(srcString, separator);
    
95.         temp = new String[st.countTokens()];
    
96.         while (st.hasMoreTokens()) {
    
97.             temp[index] = st.nextToken().trim();
    
98.             index++;
    
99.         }
    
100.         return temp;
     
101.     }
     
102. 
     
103.   //关闭ServerSocket
     
104.     private void closeServerSocket() {
     
105.         try {
     
106.             this.myServer.close();
     
107.           } catch (Exception ef) {
     
108.         }
     
109.     }
     
110. private void closeSocket(Socket s) {
     
111.         try {
     
112.             s.close();
     
113.         } catch (Exception ef) {
     
114.         }
     
115.     }
     
116.    
     
117.     //服务器
     
118.   private ServerSocket myServer = null;
     
119.     //连结队列控制
     
120.     private boolean isStop = false;
     
121.             //
     
122.     private Vector connectionQueue = null;
     
123.     private int connCounter = 0;
     
124.     // 路由对象
     
125.     private Route route = null;
     
126.     //连结的ID号，暂未用
     
127.     private static int  myID = 0;
     
128. }
     

复制代码

  Server类关键功能是在一个独立的线程中执行监听任务，当我们实例化一个ServerSocket时，即绑定了本机的一个IP和端口，这个ServerSocket对象就在这个地址(由IP和端口组成)上通过调用accept()方法等待客户端连结，默认情况下，这个等待会一直持续，直到有一个连结进入----生成一个socket对象；
而我们的ServerSocket.accept()是在一个wilhe循环中，这保证了监听服务器不会中途退出。

7. Transfer.java解析
      在分析Server.java中我们看到，Server做为一个服务器，在与客户端建立连结后使用生成的Socket对象和自己的Routc对象来实例化一个Transfer,具体的传输工作就交给了Transfer对象完成。

    Server生成的Socket对象是机器C与A之间连结的一个代码，通过这个Socekt对象上的Input/OutPut Stream，可以让C与A之间通信----工作还只完成了一半，这里我们还需要建立A与B之间的Socket连结，这里就出现了两个Socket连结，分别是C与A间，我们叫SocketCA；A与B间我们假设叫做SocketAB； Transfer对象的任务就是行建立SocketAB,然后，将SocketCA的输入写入到SocketAB的输出流，将SocketAB的输出流写到SocketCA的输出流中，这样，就完成了C,B机器之间的数据转发。

1. package org.netjava.jportmap;
   
2. import java.net.*;
   
3. import java.io.*;
4. 
   
5. /**
   
6. * Title: 端口转发器
   
7. * Description: 对连结进行转发处理
   
8. * Copyright: Copyright (c) 2005
   
9. * Company: www.NetJava.org
   
10. * @author javafound
    
11. * @version 1.0
    
12. */
13. 
    
14. public class Transfer extends Thread {
    
15.      /**
    
16.      * 创建传输对象
    
17.      * @param s Socket   :进入的socket
    
18.      * @param route Route:转发配置
    
19.      */
    
20.     public Transfer(Socket s, Route route) {
    
21.         this.route = route;
    
22.         this.socket = s;
    
23.         this.start();
    
24.     }
    
25.     // 执行操作的线程
    
26.     public void run() {
    
27.         Socket outbound = null;
    
28.         try {
    
29.             outbound = new Socket(route.DestHost, route.DestPort);
    
30.             socket.setSoTimeout(TIMEOUT);
    
31.             InputStream is = socket.getInputStream();
    
32.             outbound.setSoTimeout(TIMEOUT);
    
33.             OutputStream os = outbound.getOutputStream();
    
34.             pipe(is, outbound.getInputStream(), os, socket.getOutputStream());
    
35.         } catch (Exception e) {
    
36.             SysLog.severe(" transfer error:" +route.toString()+ " :" + e);
    
37.         } finally {
    
38.             SysLog.warning("Disconnect :"+ route.toString());
    
39.             closeSocket(outbound);
    
40.             closeSocket(socket);
    
41.         }
    
42.     }
    
43.    
    
44. /**
    
45. *传输的实现方法
    
46. */
    
47. private   void pipe(InputStream is0, InputStream is1,
    
48.               OutputStream os0, OutputStream os1) {
    
49.         try {
    
50.             int ir;
    
51.             byte bytes[] = new byte[BUFSIZ];
    
52.             while (true) {
    
53.                 try {
    
54.                     if ((ir = is0.read(bytes)) > 0) {
    
55.                         os0.write(bytes, 0, ir);
    
56.                     } else if (ir < 0) {
    
57.                         break;
    
58.                     }
    
59.                 } catch (InterruptedIOException e) {}
    
60.                 try {
    
61.                     if ((ir = is1.read(bytes)) > 0) {
    
62.                         os1.write(bytes, 0, ir);
    
63.                         // if (logging) writeLog(bytes,0,ir,false);
    
64.                     } else if (ir < 0) {
    
65.                         break;
    
66.                     }
    
67.                 } catch (InterruptedIOException e) {}
    
68.             }
    
69.         } catch (Exception e0) {
    
70.             SysLog.warning(" Method pipe" + this.route.toString() + " error:" +
    
71.                            e0);
    
72.         }
    
73.     }
    
74.     //关闭socket
    
75.      void closeSocket(Socket s) {
    
76.         try {
    
77.             s.close();
    
78.         } catch (Exception ef) {
    
79.         }
    
80.     }
    
81.    //传输任务的Route对象
    
82. Route route = null;
    
83.      // 传入数据用的Socket
    
84. Socket socket;
    
85.    //超时
    
86.    static private int TIMEOUT = 1000;
    
87.    //缓存
    
88.    static private int BUFSIZ = 1024;
    
89. }
    

复制代码

8.Main.java解析
OK,至此己万事具备！我们需要一个启动主类，根据读入的配置文件数据来启动转发服务器，执行转发工作：

1. package org.netjava.jportmap;
   
2. import java.io.*;
   
3. import java.util.*;
   
4. import java.net.*;
   
5. /**
   
6. * Title: 端口转发器
   
7. * Description:启动主类：读取配置，启动监听服务
   
8. * Copyright: Copyright (c) 2005
   
9. * Company: www.NetJava.org
   
10. * @author javafound
    
11. * @version 1.0
    
12. */
13. 
    
14. public class Main {
    
15.   //start......
    
16.     public static void main(String args[]) {
    
17.         startService();
    
18.     }
    
19. //start
    
20.     public static void startService() {
    
21.         if (!loadCfgFile()) {
    
22.             System.exit(1);
    
23.         } while (serverList.size() > 0) {
    
24.             Server ts =   serverList.remove(0);
    
25.             ts.closeServer();
    
26.         }
    
27.         for (int i = 0; i < routeList.size(); i++) {
    
28.             Route r = routeList.get(i);
    
29.             Server server = new Server(r, i);
    
30.             serverList.add(server);
    
31.         }
    
32.     }
    
33. // 停止服务接口,备用其它模块调用
    
34.     public static void stop() {
    
35.         while (serverList.size() > 0) {
    
36.             Server ts = serverList.remove(0);
    
37.             ts.closeServer();
    
38.         }
    
39.     }
    
40.     /**
    
41.      *从配置文件读取数据，生成Route对象
    
42.      * read cfg parameter
    
43.      * @return boolean
    
44.      */
    
45.     private static boolean loadCfgFile() {
    
46.         try {
    
47.             String userHome = System.getProperties().getProperty("user.dir");
    
48.             if (userHome == null) {
    
49.                 userHome = "";
    
50.             } else {
    
51.                 userHome = userHome + File.separator;
    
52.             }
    
53.             userHome += "cfg" + File.separator + "jPortMap.cfg";
    
54.             InputStream is = new FileInputStream(userHome);
    
55.             Properties pt = new Properties();
    
56.             pt.load(is);
    
57.             //共有几个业务模块
    
58.             int ServiceCount = Integer.parseInt(pt.getProperty("TransferCount"));
    
59.             for (; ServiceCount > 0; ServiceCount--) {
    
60.                 Route r = new Route();
    
61.                 r.LocalIP = pt.getProperty("LocalIP." + ServiceCount).trim();
    
62.                 r.LocalPort = Integer.parseInt(pt.getProperty("LocalPort." +
    
63.                         ServiceCount).trim());
    
64.                 r.DestHost = pt.getProperty("DestHost." + ServiceCount).trim();
    
65.                 r.DestPort = Integer.parseInt(pt.getProperty("DestPort." +
    
66.                         ServiceCount).trim());
    
67.                 r.AllowClient = pt.getProperty("AllowClient." + ServiceCount).
    
68.                                 trim();
    
69.                 routeList.add(r);
    
70.             }
    
71.             is.close();
    
72.             SysLog.info("ystem Read cfg file OK");
    
73.         } catch (Exception e) {
    
74.             System.out.println("找不到配置文件:"+e);
    
75.             SysLog.severe("loadCfgFile false :" + e);
    
76.             return false;
    
77.         }
    
78.         return true;
    
79.     }
    
80.     //Server服务器集合
    
81.     private static List< Server> serverList = new ArrayList();
    
82.     //Route集合
    
83.     private static List< Route> routeList = new ArrayList();
    
84. }
    

复制代码

     Main类中需要注意的是loadCfgFile（）方法，它用来读取当前目录下面cfg/jPortMap.cfg文件中的配置数据，如读取成功，返加ture值，如读取失败，程序测会退出。
另外：
//Server服务器集合
private static List<Server> serverList = new ArrayList();

//Route集合
private static List<Route> routeList = new ArrayList();

这两行代码，生成两个列表，来保存己启动的Server对象和Route对象。

     现在，我们只要启动Main类，jPortMap就开始运行了,同时会在log目录下行成每天的运行日志；当然，千万不要忘了cfg/目录下面jPortMap.cfg中配置转发的参数,配置的具体说明在该文件中有注解。
源码目录结构图(NetBean中)：

   9.改进设想：
       无论如何，这还是个比较简陋的程序！假如我们把配置改成XML格式、假如我们使用Thread Pool来执行任务、假如我们使用NIO、假如我们再做一套PL的UI界面….,您的任何建议，都会是对jPortMap走向完美的支持,请登陆www.NetJava.cn发表您的看法，发布您的创新！当然，www.NetJava.cn现在己增加了许多新东东让您欣赏！


源码下载：http://file.javaxxz.com/2014/10/28/235839203.zip