java网络编程之TCP通讯

java中的网络编程之TCP协议的详细介绍，以及如何使用，同时我在下面举2例说明如何搭配IO流进行操作，

 /*
  *TCP
  *建立连接，形成传输数据的通道；
  *在连接中进行大数据量传输；
  *通过三次握手完成连接，是可靠协议；
  *必须建立连接，效率会稍低
  */

 /*
  * TCP传输
  * Socket和ServerSocket建立客户端和服务器端建立连接后，
  * 通过Socket中的IO流进行数据的传输关闭socket同样，
  * 客户端与服务器端是两个独立的应用程序。
  */

 //-------------------------------
 //下面的是TCP协议的服务器端代码

 import java.io.IOException;
 import java.io.InputStream;
 import java.net.ServerSocket;
 import java.net.Socket;

 /*
  * TCP协议接收数据
  *     1.创建接收端的socket对象
  *     2.监听客户端，返回一个对应的socket对象
  *     3.获取输入流，读取数据，显示在控制台
  *     4.释放资源
  */
 public class ServerDemo {
     public static void main(String[] args) throws IOException {
         // 创建接收端socket对象
         ServerSocket ss = new ServerSocket(10086);

         // 监听客户端，返回一个对应的socket对象
         // public Socket accept() 侦听并接受到此套接字的连接。
         Socket s = ss.accept(); // 阻塞式方法，直到通道建立

         // 获取输入流，读取数据
         InputStream is = s.getInputStream();
         byte[] bys = new byte[1024];
         int len = is.read(bys); // 阻塞式方法，直到数据发过来。
         String ip = s.getInetAddress().getHostAddress();

         String str = new String(bys, 0, len);
         System.out.println(str);

         // 释放资源
         s.close();
         ss.close(); // 这个不应该关闭
     }
 }

 //-------------------------------
 //下面是客户端TCP协议的代码
 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.Socket;

 /*
  *TCP协议发送数据：
  *    1.创建发送端socket对象
  *        这一步如果成功，就说明链接已经成功了。
  *    2.获取输出流，写数据
  *    3.释放资源
  *
  *TCP一些服务器必须先开启，保证通道简历，否则直接报错。
  *java.net.ConnectException: Connection refused: connect
  */
 public class ClientDemo {
     public static void main(String[] args) throws IOException {
         // 创建发送端socket对象
         // Socket(String host, int port) 创建一个流套接字并将其连接到指定主机上的指定端口号。
         Socket socket = new Socket("lpp-PC", 10086);
 //“lpp-PC”里面的字符串一般使用服务器端的IP地址代替。

         // 获取输出流，写数据
         OutputStream os = socket.getOutputStream();
         os.write("TCP coming~~~".getBytes());

         // 关闭资源
         os.close();
     }
 }

 //==================================
 //---------------------------------------------------------------
 //下面给出一个案例：客户端从指定文本文件读取数据，发送到服务器端，
 //服务器将接收到的数据，再次写入到一个新的文本文件。数据的写/出是字节
 //流

 //首先给出的是客户端的代码：
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.Socket;

 /*
  * 客户端从文本文件中读取数据，服务器得到数据写入到文本文件，
  * 为了在服务器写完数据后，给客户端一个反馈，但是直接在通道内额外的添加数据是不行，会导致双方一直保持等待状态
  *     方案
  *       1：  在客户端里面额外增加一条语句告诉服务器结束的标志。
  *       2: 直接使用JDK给出的方法：shutdownOutput();socket提供了一个中止功能，它会通知服务器别等了，我没有数据过来了。
  */

 public class ClientDemo {
     public static void main(String[] args) throws IOException {
         // 客户端socket对象
         Socket s = new Socket("lpp-PC", 12345);

         // 封装数据源
         BufferedReader br = new BufferedReader(new FileReader("a.txt"));

         // 封装通道内流
         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                 s.getOutputStream()));

         // 写入数据
         String line = null;
         while ((line = br.readLine()) != null) {
             bw.write(line);
             bw.newLine();
             bw.flush();
         }

         // // 为了告诉服务器写到这里就可以停止了，额外增加一个标记，自定义一个结束标记
         // bw.write("over");
         // bw.newLine();
         // bw.flush();

         //socket提供了一个中止功能，它会通知服务器别等了，我没有数据过来了。
         s.shutdownOutput();

         // 接受服务器的反馈
         BufferedReader brClient = new BufferedReader(new InputStreamReader(
                 s.getInputStream()));
         String str = brClient.readLine();
         System.out.println(str);

         // 释放资源
         br.close();
         s.close();
     }
 }

 //------------------------------------------
 //下面是服务器端的代码

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.ServerSocket;
 import java.net.Socket;

 public class ServerDemo {
     public static void main(String[] args) throws IOException {
         // 服务端socke对象
         ServerSocket ss = new ServerSocket(12345);

         // 监听客户端，获取socke对象
         Socket s = ss.accept();

         // 封装目标文件
         BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

         // 封装通道中的输入流
         BufferedReader br = new BufferedReader(new InputStreamReader(
                 s.getInputStream()));

         // 读取数据,并将数据写入文件
         String line = null;
         while ((line = br.readLine()) != null) {
             // if ("over".equals(line)) {
             // break;
             // }
             bw.write(line);
             bw.newLine();
             bw.flush();
         }

         // 在文件写出完毕后，给客户端一个反馈，
         BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(
                 s.getOutputStream()));
         bwServer.write("数据写入完毕");
         bwServer.newLine();
         bwServer.flush();

         // 释放资源
         bw.close();
         s.close();

     }
 }

//======================================

//下面的这个例子是客户端读取的是图片文件/视频文件。而服务器会对象通过TCP协议读取到的数据写到对应格式的文中去。

 //先是服务器端的class文件

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;

 public class ServerDemo {
     public static void main(String[] args) throws IOException {
         // 服务端socke对象
         ServerSocket ss = new ServerSocket(23456);

         // 监听客户端，获取socket
         Socket s = ss.accept();

         // 封装通道内流数据
         BufferedInputStream bis = new BufferedInputStream(s.getInputStream());

         // 封装图标目的地
         BufferedOutputStream bos = new BufferedOutputStream(
                 new FileOutputStream("lpp.jpg"));

         byte[] bys = new byte[1024];
         int len = 0;
         while ((len = bis.read(bys)) != -1) {
             bos.write(bys, 0, len);
             bos.flush(); // 尤其是在通道内部使用时，必须使用flush否则丢包
         }

         // 给一个反馈
         OutputStream os = s.getOutputStream();
         os.write("图片上传成功".getBytes());

         // 释放资源
         bos.close();
         s.close();

     }
 }

 //------------------------------------------------
 //下面的是客户端的class文件

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.Socket;

 /*
  * 客户端读取一个数据，通过TCP协议发送到服务器
  */
 public class ClientDemo {
     public static void main(String[] args) throws IOException {
         // 客户端socke对象
         Socket s = new Socket("lll-PC", 23456);

         // 封装数据源
         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                 "a.jpg"));

         // 封装通道数据流
         BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());

         byte[] bys = new byte[1024];
         int len = 0;
         while ((len = bis.read(bys)) != -1) {
             bos.write(bys, 0, len);
             bos.flush();  //尤其是在通道内部使用时，必须使用flush否则丢包
         }

         // 读取反馈，关闭写入流，并告知服务器端，服务器端的阻塞不再等待向下执行
         s.shutdownOutput();

         InputStream is = s.getInputStream();
         byte[] buf = new byte[1024];
         int len2 = is.read(buf);
         String clientStr = new String(buf, 0, len2);
         System.out.println(clientStr);

         // 释放资源
         bis.close();
         s.close();

     }
 }