TCP网络编程

TCP网络编程
  与UDP不同的是TCP是通过客服端和服务端的方式来传输数据的。
客服端：
public class TCPClient {

    /**
     * @param args
     * @throws IOException
     * @throws UnknownHostException
     */
    public static void main(String[] args) throws UnknownHostException, IOException {

        /*
         * 需求：创建一个客户端，给服务器端发送一个字符串数据。
         * 思路：
         * 1，先有socket服务，为了创建连接。
         * 2，一旦连接建立说明有了数据传输的通道，这就是基于socket的io流。
         *         既然是发送一个数据到服务端，可以使用socket io流中的输出流。
         * 3，关闭资源。
         */
        System.out.println("客户端开启........");
        //1，创建客户端socket服务，通过Socket对象完成。在一创建就明确对方地址和端口。
        Socket s = new Socket("192.168.1.252",10002);
       
        //2，一旦连接建立，就有了socket流。既然是发送，需要使用socket的输出流。
        OutputStream out = s.getOutputStream();
       
        //3，通过输出流对象的write方法，将数据发送目标主机。
        out.write("tcp演示，哥们又来了！".getBytes());
       
        //4，关闭资源。
        s.close();
       
        System.out.println("客户端关闭........");
       
       
       
       
    }

}
服务器端：
public class TCPServer {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        /*
         * 需求：接收客户端的数据，打印到显示器上。
         * 服务端创建的思路：
         * 思路：
         * 1，必须有socket服务。
         * 2，接收客户端的数据。
         * 3，打印到显示器上，并关闭资源。
         *
         */
        System.out.println("服务端开启。。。。。。");
        //1，创建服务端的socket对象。使用ServerSocket。并明确一个监听的端口。这是必须的。
        ServerSocket ss = new ServerSocket(10002);
       
        //2，接收客户端的数据，怎么接收呢？首先获取到客户端对象，然后在通过客户端对象的socket流中的读取流读取数据。
        Socket s = ss.accept();
       
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip+"......connected");
       
        //3，通过客户端对象获取读取流。
        InputStream in = s.getInputStream();
       
        byte[] buf = new byte[1024];
        int len = in.read(buf);
       
        String str = new String(buf,0,len);
       
        System.out.println(str);
       
        //4，关闭资源。
        s.close();
        ss.close();
        System.out.println("服务端关闭。。。。。。");
       
       
       
       
       
    }

}

基于TCP协议的网络编程

TCP协议是一种可靠的通络协议，通信两端的Socket使得它们之间形成网络虚拟链路，两端的程序可以通过虚拟链路进行通讯。Java使用socket对象代表两端的通信端口，并通过socket产生的IO流来进行网络通信。

2.1 ServerSocket
    在两个通信端没有建立虚拟链路之前，必须有一个通信实体首先主动监听来自另一端的请求。ServerSocket对象使用accept()方法用于监听来自客户端的Socket连接，如果收到一个客户端Socket的连接请求，该方法将返回一个与客户端Socket对应的Socket对象。如果没有连接，它将一直处于等待状态。通常情况下，服务器不应只接受一个客户端请求，而应该通过循环调用accept()不断接受来自客户端的所有请求。
    这里需要注意的是，对于多次接收客户端数据的情况来说，一方面可以每次都在客户端建立一个新的Socket对象然后通过输入输出通讯，这样对于服务器端来说，每次循环所接收的内容也不一样,被认为是不同的客户端。另外，也可以只建立一次，然后在这个虚拟链路上通信，这样在服务器端一次循环的内容就是通信的全过程。
    服务器端的示例代码：

Java代码  ​

1. //创建一个ServerSocket，用于监听客户端Socket的连接请求  监听端口为30000  
2.         ServerSocket ss = new ServerSocket(30000);    
3.         //采用循环不断接受来自客户端的请求    
4.         while (true)    
5.         {    
6.             //每当接受到客户端Socket的请求，服务器端也对应产生一个Socket    
7.             Socket s = ss.accept();    
8.             //将Socket对应的输出流包装成PrintStream    
9.             PrintStream ps = new PrintStream(s.getOutputStream());    
10.             //进行普通IO操作    
11.             ps.println("您好，今天服务器的大姨夫来了！");    
12.             //关闭输出流，关闭Socket    
13.             ps.close();    
14.             s.close();    
15.         }   

 2.2 Socket

    使用Socket可以主动连接到服务器端，使用服务器的IP地址和端口号初始化之后，服务器端的accept便可以解除阻塞继续向下执行，这样就建立了一对互相连接的Socket。
    客户端示例代码：

Java代码  ​

1. Socket socket = new Socket("127.0.0.1" , 30000);    
2.  //将Socket对应的输入流包装成BufferedReader    
3.  BufferedReader br = new BufferedReader(    
4.      new InputStreamReader(socket.getInputStream()));    
5.  //进行普通IO操作    
6.  String line = br.readLine();    
7.  System.out.println("来自服务器的数据：" + line);    
8.  //关闭输入流、socket    
9.  br.close();    
10.  socket.close();   

 2.3 使用多线程

    在复杂的通讯中，使用多线程非常必要。对于服务器来说，它需要接收来自多个客户端的连接请求，处理多个客户端通讯需要并发执行，那么就需要对每一个传过来的Socket在不同的线程中进行处理，每条线程需要负责与一个客户端进行通信。以防止其中一个客户端的处理阻塞会影响到其他的线程。对于客户端来说，一方面要读取来自服务器端的数据，另一方面又要向服务器端输出数据，它们同样也需要在不同的线程中分别处理。
具体代码如下，服务器端：

Java代码  ​

1. public class MyServer    
2. {    
3.     //定义保存所有Socket的ArrayList    
4.     public static ArrayList<Socket> socketList = new ArrayList<Socket>();    
5.     public static void main(String[] args)     
6.         throws IOException    
7.     {    
8.         ServerSocket ss = new ServerSocket(30000);    
9.         while(true)    
10.         {    
11.             //此行代码会阻塞，将一直等待别人的连接    
12.             Socket s = ss.accept();    
13.             socketList.add(s);    
14.             //每当客户端连接后启动一条ServerThread线程为该客户端服务    
15.             new Thread(new ServerThread(s)).start();    
16.         }    
17.     }    
18. }   

 客户端：

Java代码  ​

1. public class MyClient    
2. {    
3.     public static void main(String[] args)    
4.         throws IOException     
5.     {    
6.         Socket s = s = new Socket("127.0.0.1" , 30000);    
7.         //客户端启动ClientThread线程不断读取来自服务器的数据    
8.         new Thread(new ClientThread(s)).start();    
9.         //获取该Socket对应的输出流    
10.         PrintStream ps = new PrintStream(s.getOutputStream());    
11.         String line = null;    
12.         //不断读取键盘输入    
13.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));    
14.         while ((line = br.readLine()) != null)    
15.         {    
16.             //将用户的键盘输入内容写入Socket对应的输出流    
17.             ps.println(line);    
18.         }    
19.     } }