大数据之路week04--day03（网络编程）

哎，怎么感觉自己变得懒了起来，更新博客的频率变得慢了起来，可能是因为最近得知识开始变得杂变得难了起来，之前在上课的时候，也没有好好听这一方面的知识，所以，现在可以说是在学的新的知识，要先去把新的知识思路屡了一遍，自己实现了代码，把整个过程以及规则搞懂了，我才会来总结博客。

说个有关这节知识的相关内容，

在学习网络编程之前，我们一定要先把I/O输入输出流给先学了，为什么这么说呢？仔细想想，我们学习网络编程，说到底还是数据之间的传输，文字，图片，音乐，视频等等也好，它们有的传输以及接收的方式不同，如果没有学习过I/O编程就来学习这个网络编程就略显困难，而我对I/O 流的学习还没有结束，因为有点多，我争取在本周把I/O流的章节的知识点和代码给总结出来。

好了，话不多说，如果你学过I/O输入输出流了，那么往下看（自学能力强的在学习网络编程的过程中就会慢慢总结到规律，。。），自己总结的，有啥不完整或者错误的欢迎私信补充和指出。

网络编程

1、计算机网络

　　什么是计算机网络？

　　是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

2、网络编程

　　就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交换。

图1　　网络参考模型图

图2　　网络应用程序是由网络编程，I/O流，多线程组成

3、网络编程的三要素

简单的故事开头方便理解：

　　我想和自己心爱的女孩说话了，怎么办？

　　第一步：我要找到这个女孩。　　　　　　　　　　　（IP地址）

　　第二步：对她说话，要对着耳朵说。　　　　　　　　　（端口）

　　第三步：我要说什么呢？“I Love You”,但是她听不懂英文，说汉语就可以了，我爱你。（协议）

　　 (1) IP地址

　　　　　　Ip地址是网络中计算机的唯一标识。端口是用来区分电脑上的应用程序。

　　　　　　计算机只能识别二进制的数据，所以我们的IP地址应该是一个二进制的数据。

　　　　　　但是，我们看电脑配置的IP地址却不是二进制的，这是为什么？

　　　　　　IP：192.168.1.103

　　　　　　换算：11000000 10101000 00000001 01100111

　　　　　　想想看，如果我们的Ip地址写成下面的二进制的话，不管是记忆还是书写都十分的麻烦，

　　　　　　所以，为了方便表示IP地址，我们就把IP地址的每一个字节上的数据换算成十进制，然后用 “点分十进制” 来表示。

　　　　　　IP地址的组成：网络号段+主机号段

　　　　　　　　A类：第一号段为网络号段+后三位的主机号段

　　　　　　　　　　　　一个网络号：256*256*256 = 16777216

　　　　　　　　B类：前二号段为网络号段+后两位的主机号段

　　　　　　　　　　　　一个网络号：256*256 = 65536

　　　　　　　　C类：前三号段为网络号段+后一位主机号段

　　　　　　　　　　　　一个网络号：256

拓展一下：

　　　　两个常用的DOS命令：

　　　　　　ipconfig：查看本机的IP地址

　　　　　　ping ip地址：测试本机与指定的IP地址间的通信是否有问题

　　　　特殊的IP地址：

　　　　　　127.0.0.1 回环地址（表示本机）

　　　　　　X.X.X.255 广播地址

　　　　　　X.X.X.0 网络地址

为了方便方便我们获取IP地址和操作，Java提供了一个类InetAddress供我们使用，它是没有构造方法的，类中有静态方法返回该类的对象，类名调用。

　　（2）端口

　　　　　　正在运行的程序的标识

　　　　　　有效端口：0~65535，其中0~1024系统使用或者保留端口，一般情况下，我们使用10000以上的。

　　（3）协议

　　　　　　网络协议是网络上所有设备（网络服务器、计算机及交换机、路由器、防火墙等等）之间通信规则的集合，它规定了通信时信息必须采用的格式和这些格式的意义。尽管 TCP/IP 协议从名称看只包括 TCP 这个协议名，但是在 TCP/IP 协议的传输层同时存在 TCP（Transmission Control Protocol，传输控制协议）和 UDP（User Datagram Protocol，用户数据报协议）两个协议。在网络通信中 TCP 协议类似于使用手机打电话，可以保证把信息传递给别人；而 UDP 协议类似于发短信，接收人有可能接收不到传递的信息。（UDP存在丢包）在网络通信中使用 TCP 的方式需要建立专门的虚拟连接，然后进行可靠的数据连接，如果数据发送失败，客户端会自动重发该数据。而使用 UDP 方式不需要建立专门的虚拟连接，传输也不是很可靠，如果发送失败则客户端无法获得。TCP 协议是一种以固定连线为基础的协议，它提供两台计算机之间可靠的数据传送。而 UDP 无连接通信协议，它不保证可靠数据的传输，但能够向若干目标发送数据以及接收来自若干源的数据。对于一些重要的数据，一般使用 TCP 方式来进行数据传输，而大量的非核心数据则通过 UDP 方式进行传递。使用 TCP 方式传递的速度稍微慢一点，而且传输时产生的数据量会比 UDP 大一点。

4、协议UDP和TCP

　　（1）UDP

　　　　　　将数据源和目的封装成数据包中，不需要建立连接；每个数据报的大小限制在64k；因为它没有连接，是不可靠协议；不需要建立连接，速度快。

　　（2）TCP

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

　　　　　　分分钟了解什么是三次握手的视频网址　　https://www.bilibili.com/video/av41782699?from=search&seid=15360378958258479001

5、Socket

　　（1）Socket套接字

　　　　网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一标识的标识套接字。

　　（2）Socket原理机制：

　　　　通信的两端都有Socket

　　　　网络通信其实就是Socket间的通信

　　　　数据在两个Socket间通过I/O传输

图3　　Socket原理机制

6、UDP协议发送和接收数据

　　先看图解：

图4　　UDP协议发送和接收数据

　　发送：

　　　　创建UDP发送端和Socket对象

　　　　创建数据，并把数据打包

　　　　调用Socket对象的发送方法发送数据包

　　　　释放资源

　　接收：

　　　　创建UDP接收端的Socket对象

　　　　创建数据包用于接收数据

　　　　调用Socket对象的接收方法接收数据包

　　　　解析数据包

　　　　释放资源

案例：

1、最基本的UDP协议发送和接收数据

send端：

 1 package com.wyh.demo2;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.Inet4Address;
 7 import java.net.InetAddress;
 8 import java.net.SocketException;
 9 
10 /** 
11 * @author WYH
12 * @version 2019年11月25日 下午6:46:00
13 */
14 public class sendDemo1 {
15     public static void main(String[] args) throws IOException {
16         //创建Socket
17         DatagramSocket ds = new DatagramSocket();
18         //创建数据
19         byte[] buf = "你好，我是优化后的数据".getBytes();
20         int length = buf.length;
21         InetAddress address = InetAddress.getByName("192.168.1.103");
22         int port = 12345;
23         //打包数据
24         DatagramPacket dp = new DatagramPacket(buf, length, address, port);
25         //发送数据
26         ds.send(dp);
27         //释放资源
28         ds.close();
29         
30     }
31 
32 }

service端：

 1 package com.wyh.demo2;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.SocketException;
 7 
 8 /** 
 9 * @author WYH
10 * @version 2019年11月25日 下午6:40:16
11 */
12 public class reciveDemo1 {
13     public static void main(String[] args) throws IOException {
14         //创建Socket对象
15         DatagramSocket ds = new DatagramSocket(12345);
16         
17         
18         byte[] bt =new byte[1024];
19         //创建包裹
20         DatagramPacket dp = new DatagramPacket(bt, bt.length);
21         
22         //接收数据
23         ds.receive(dp);
24         
25         //解析数据
26         String ip = dp.getAddress().getHostAddress();
27         String s = new String(dp.getData(),0,dp.getLength());
28         System.out.println("主机名："+ip+",接收的数据是："+s);
29         
30         //释放资源
31         ds.close();
32         
33     }
34 
35 }

2、把发送数据改进为键盘录入

send端：

 1 package com.wyh.demo3;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.net.DatagramPacket;
 7 import java.net.DatagramSocket;
 8 import java.net.InetAddress;
 9 
10 /** 
11 * @author WYH
12 * @version 2019年11月25日 下午6:46:00
13 */
14 public class sendDemo1 {
15     public static void main(String[] args) throws IOException {
16         //创建Socket
17         DatagramSocket ds = new DatagramSocket();
18         //创建数据
19         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
20         String line;
21         while((line = br.readLine())!=null) {
22             //当输入886的时候跳出
23             if("886".equals(line)) {
24                 break;
25             }
26             byte[] buf = line.getBytes();
27             int length = buf.length;
28             InetAddress address = InetAddress.getByName("192.168.1.255");
29             int port = 12345;
30             //打包数据
31             DatagramPacket dp = new DatagramPacket(buf, length, address, port);
32             //发送数据
33             ds.send(dp);
34         }
35         
36         
37         //释放资源
38         ds.close();
39         
40     }
41 
42 }

service端：

 1 package com.wyh.demo3;
 2 
 3 import java.io.IOException;
 4 
 5 import java.net.DatagramPacket;
 6 import java.net.DatagramSocket;
 7 import java.net.SocketException;
 8 
 9 /** 
10 * @author WYH
11 * @version 2019年11月25日 下午6:40:16
12 */
13 public class reciveDemo1 {
14     public static void main(String[] args) throws IOException {
15         //创建Socket对象
16         DatagramSocket ds = new DatagramSocket(12345);
17         
18         
19         byte[] bt =new byte[1024];
20         //创建包裹
21         DatagramPacket dp = new DatagramPacket(bt, bt.length);
22         //while(true) 保证它可以一直可以接收数据
23         while(true) {
24           //接收数据
25             ds.receive(dp);
26             
27             //解析数据
28             String ip = dp.getAddress().getHostAddress();
29             String s = new String(dp.getData(),0,dp.getLength());
30             System.out.println("主机名："+ip+",接收的数据是："+s);
31         }
32         
33         
34         //释放资源
35         //ds.close();
36         
37     }
38 
39 }

3、一个简易聊天小程序并用多线程改进（实现Runnable接口的run方法）

sendThread:

 1 package 多线程改进ChatRoom;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.net.DatagramPacket;
 7 import java.net.DatagramSocket;
 8 import java.net.InetAddress;
 9 
10 /** 
11 * @author WYH
12 * @version 2019年11月25日 下午7:55:50
13 */
14 public class SendThread implements Runnable{
15     private DatagramSocket ds;
16     
17     public SendThread(DatagramSocket ds) {
18         this.ds = ds;
19     }
20     
21     @Override
22     public void run() {
23         try {
24         //创建数据
25         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
26         String line = null;
27         while((line = br.readLine())!=null) {
28             if("886".equals(line)) {
29                 break;
30             }
31             DatagramPacket dp = new DatagramPacket(line.getBytes(), line.getBytes().length, InetAddress.getByName("192.168.1.103"), 12306);
32             ds.send(dp);
33             
34         }
35         //释放资源
36         ds.close();
37         }catch(IOException e){
38             e.printStackTrace();
39         }
40     }
41 }

serviceThread：

 1 package 多线程改进ChatRoom;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 
 7 /** 
 8 * @author WYH
 9 * @version 2019年11月25日 下午8:07:23
10 */
11 public class ReciveThread implements Runnable {
12     private DatagramSocket ds;
13     
14     public ReciveThread(DatagramSocket ds) {
15         this.ds = ds;
16     }
17 
18     @Override
19     public void run() {
20         try {
21             while (true) {
22                 byte[] b = new byte[1024];
23                 DatagramPacket dp = new DatagramPacket(b, b.length);
24                 ds.receive(dp);
25                 String ip = dp.getAddress().getHostAddress();
26                 String s = new String(dp.getData(), 0, dp.getData().length);
27 
28                 System.out.println("主机号:" + ip + "发来:" + s);
29             }
30         } catch (IOException e) {
31             e.printStackTrace();
32         }
33     }
34 
35 }

主函数：

 1 package 多线程改进ChatRoom;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramSocket;
 5 
 6 /** 
 7 * @author WYH
 8 * @version 2019年11月25日 下午7:52:39
 9 */
10 public class chatRoom {
11     public static void main(String[] args) throws IOException{
12         DatagramSocket dsSend = new DatagramSocket();
13         DatagramSocket dsRecive = new DatagramSocket(12306);
14         
15         SendThread st = new SendThread(dsSend);
16         ReciveThread rt = new ReciveThread(dsRecive);
17         
18         Thread t1 = new Thread(st);
19         Thread t2 = new Thread(rt);
20         
21         t1.start();
22         t2.start();
23     }
24 
25 }

7、TCP协议发送和接收数据

先看图解：

图5　　TCP协议发送和接收数据

发送：

　　创建TCP客户端的Socket对象

　　获取输出露，写数据

　　释放数据

接收：

　　创建TCP服务端的Socket对象

　　监听客户端连接

　　获取输入流，读取数据

　　释放资源（注意，所有有关文件的操作，都要进行关闭操作（.close()）!!!!!!!）

案例：

1、最基本的TCP协议发送和接收数据

Client：

 1 package TCP协议;
 2 
 3 import java.io.IOException;
 4 import java.io.OutputStream;
 5 import java.net.Socket;
 6 import java.net.UnknownHostException;
 7 
 8 /** 
 9 * @author WYH
10 * @version 2019年11月26日 下午7:17:58
11 * 
12 * 
13 * TCP一定要先开启服务端
14 * java.net.ConnectException: Connection refused: connect
15 * 
16 */
17 public class Clint {
18     public static void main(String[] args) throws IOException {
19         //创建TCP协议的Socket对象
20         Socket s = new Socket("192.168.1.103",9998);
21         
22         //获取输出流
23         OutputStream os = s.getOutputStream();
24         os.write("hello,TCP来了。。".getBytes());
25         
26         //释放资源
27         s.close();
28         
29     }
30 
31 }

Server：

 1 package TCP协议;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.net.ServerSocket;
 6 import java.net.Socket;
 7 
 8 /**
 9  * @author WYH
10  * @version 2019年11月26日 下午7:28:59
11  */
12 public class Server {
13     public static void main(String[] args) throws IOException {
14         // 获取服务器端的Socket
15         ServerSocket ss = new ServerSocket(9998);
16         // 进行监听返回一个Socket对象
17         Socket s = ss.accept();
18         InputStream is = s.getInputStream();
19         //获取客户端IP地址
20         String s2 = s.getInetAddress().getHostAddress();
21         
22         //进行获取字节流并输出到控制台
23         byte[] b = new byte[1024];
24         int len;
25         while ((len = is.read(b)) != -1) {
26             String s1 = new String(b, 0, len);
27             System.out.println(s2+":"+s1);
28         }
29 
30         // 释放资源
31         s.close();
32         ss.close();
33 
34     }
35 
36 }

2、服务器给出反馈：

client：

 1 package TCP协议_1;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.io.OutputStream;
 6 import java.net.Socket;
 7 
 8 /** 
 9 * @author WYH
10 * @version 2019年11月26日 下午7:17:58
11 * 
12 * 
13 * TCP一定要先开启服务端
14 * java.net.ConnectException: Connection refused: connect
15 * 
16 */
17 public class Clint {
18     public static void main(String[] args) throws IOException {
19         //创建TCP协议的Socket对象
20         Socket s = new Socket("192.168.1.103",9997);
21         
22         //获取输出流
23         OutputStream os = s.getOutputStream();
24         os.write("hello,TCP来了。。".getBytes());
25         
26         //接收服务器端的反馈
27         InputStream is = s.getInputStream();
28         byte[] b = new byte[1024];
29         int len;
30         while((len = is.read(b))!=-1) {
31             String s1 = new String(b,0,len);
32             System.out.println(s1);
33         }
34         
35         //释放资源
36         s.close();
37         
38     }
39 
40 }

Server：

 1 package TCP协议_1;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.io.OutputStream;
 6 import java.net.ServerSocket;
 7 import java.net.Socket;
 8 
 9 /**
10  * @author WYH
11  * @version 2019年11月26日 下午7:28:59
12  */
13 public class Server {
14     public static void main(String[] args) throws IOException {
15         ServerSocket ss = new ServerSocket(9997);
16         Socket s = ss.accept();
17         
18         String ip = s.getInetAddress().getHostAddress();
19         
20         InputStream is = s.getInputStream();
21         byte[] bys = new byte[1024];
22         int len = is.read(bys);
23         String s1 = new String(bys,0,len);
24         System.out.println(ip+":"+s1);
25         
26         //发送反馈
27         OutputStream os = s.getOutputStream();
28         os.write("数据我已经收到了".getBytes());
29         
30         
31         s.close();
32         ss.close();
33         
34     }
35 
36 }

3、客户端键盘录入，服务器端控制台输出

Client：

 1 package TCP协议_2;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.IOException;
 6 import java.io.InputStream;
 7 import java.io.InputStreamReader;
 8 import java.io.OutputStreamWriter;
 9 import java.net.Socket;
10 
11 /**
12  * @author WYH
13  * @version 2019年11月26日 下午7:17:58
14  * 客户端键盘录入，服务器端控制台输出
15  * 
16  * 
17  *          TCP一定要先开启服务端 java.net.ConnectException: Connection refused: connect
18  * 
19  */
20 public class Clint {
21     public static void main(String[] args) throws IOException {
22         // 创建TCP协议的Socket对象
23         Socket s = new Socket("192.168.1.103", 9997);
24 
25         /*
26          * Scanner sc =new Scanner(System.in); System.out.print("请输入想要发送的数据:"); String
27          * info = sc.next();
28          */
29         System.out.print("请输入想要发送的数据:");
30         //键盘录入
31         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
32         //包装通道流
33         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
34 
35         String line;
36         while ((line = br.readLine()) != null) {
37             //键盘录入的一定要自定义结束
38             if ("886".equals(line)) {
39                 break;
40             }
41             bw.write(line);
42             bw.newLine();
43             bw.flush();
44         }
45         // 释放资源
46         s.close();
47 
48     }
49 
50 }

Server：

 1 package TCP协议_2;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStream;
 6 import java.io.InputStreamReader;
 7 import java.io.OutputStream;
 8 import java.net.ServerSocket;
 9 import java.net.Socket;
10 
11 /**
12  * @author WYH
13  * @version 2019年11月26日 下午7:28:59
14  */
15 public class Server {
16     public static void main(String[] args) throws IOException {
17         ServerSocket ss = new ServerSocket(9997);
18         Socket s = ss.accept();
19 
20         String ip = s.getInetAddress().getHostAddress();
21         
22         //包装通道里的流
23         BufferedReader br = new BufferedReader(new InputStreamReader(
24                 s.getInputStream()));
25         String line;
26         while ((line = br.readLine()) != null) {
27             System.out.println(ip + ":" + line);
28         }
29 
30         s.close();
31 
32     }
33 
34 }

4、客户端键盘录入，服务器写到文件里

Client：

 1 package TCP协议_3;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.IOException;
 6 import java.io.InputStream;
 7 import java.io.InputStreamReader;
 8 import java.io.OutputStreamWriter;
 9 import java.net.Socket;
10 
11 /**
12  * @author WYH
13  * @version 2019年11月26日 下午7:17:58
14  * 客户端键盘录入，服务器端输出到文本文件
15  * 
16  * 
17  *          TCP一定要先开启服务端 java.net.ConnectException: Connection refused: connect
18  * 
19  */
20 public class Clint {
21     public static void main(String[] args) throws IOException {
22         Socket s = new Socket("192.168.1.103",2222);
23         
24         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
25         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
26         
27         String line = null;
28         while((line = br.readLine())!=null) {
29             if("886".equals(line)) {
30                 break;
31             }
32             bw.write(line);
33             bw.newLine();
34             bw.flush();
35         }
36                 
37         
38         s.close();
39         
40     }
41 }

Server：

 1 package TCP协议_3;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileWriter;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 import java.io.InputStreamReader;
 9 import java.io.OutputStream;
10 import java.net.ServerSocket;
11 import java.net.Socket;
12 
13 /**
14  * @author WYH
15  * @version 2019年11月26日 下午7:28:59
16  */
17 public class Server {
18     public static void main(String[] args) throws IOException {
19         ServerSocket ss = new ServerSocket(2222);
20         
21         Socket s = ss.accept();
22         String ip = s.getInetAddress().getHostAddress();
23         
24         BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
25         
26         String line = null;
27         while((line = br.readLine())!=null) {
28             System.out.println(ip+":"+line);
29             //封装要写入的文件
30             BufferedWriter br1 = new BufferedWriter(new FileWriter("D://TCP测试.txt",true));
31             br1.write(line);
32             br1.newLine();
33             br1.close();
34             
35         }
36         
37         s.close();
38         
39         
40     }
41 
42 }

5、客户端读取文本文件，服务器端控制台输出

Client：

 1 package TCP协议_4;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileReader;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 import java.io.InputStreamReader;
 9 import java.io.OutputStream;
10 import java.io.OutputStreamWriter;
11 import java.net.Socket;
12 
13 import javax.annotation.processing.Filer;
14 import javax.lang.model.element.Element;
15 import javax.tools.FileObject;
16 import javax.tools.JavaFileObject;
17 import javax.tools.JavaFileManager.Location;
18 
19 /**
20  * @author WYH
21  * @version 2019年11月26日 下午7:17:58
22  * 客户端文本文件，服务器端输出到控制台
23  * 
24  * 
25  *          TCP一定要先开启服务端 java.net.ConnectException: Connection refused: connect
26  * 
27  */
28 public class Clint {
29     public static void main(String[] args) throws IOException {
30         Socket s = new Socket("192.168.1.103",2222);
31         //封装文本文件
32         BufferedReader br = new BufferedReader(new FileReader("D://TCP测试.txt"));
33         
34         //封装通道流
35         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
36         String line = null;
37         while((line = br.readLine())!= null) {
38             bw.write(line);
39             bw.newLine();
40             bw.flush();
41         }
42         
43         bw.close();
44         s.close();
45     }
46 }

Server：

 1 package TCP协议_4;
 2 
 3 import java.io.BufferedReader;
 4 
 5 import java.io.BufferedWriter;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 import java.io.InputStream;
 9 import java.io.InputStreamReader;
10 import java.io.OutputStream;
11 import java.net.ServerSocket;
12 import java.net.Socket;
13 
14 /**
15  * @author WYH
16  * @version 2019年11月26日 下午7:28:59
17  */
18 public class Server {
19     public static void main(String[] args) throws IOException {
20         ServerSocket ss = new ServerSocket(2222);
21         
22         Socket s = ss.accept();
23         String ip = s.getInetAddress().getHostAddress();
24         
25         //封装通道流
26         BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
27         
28         String line = null;
29         
30         while ((line = br.readLine()) != null) {
31             System.out.println(ip+":"+line);
32         }
33         br.close();
34         s.close();
35         
36         
37         
38     }
39 
40 }

6、客户端读取文本文件，服务器端写入到新的文本文件，模拟文件上传

Client:

 1 package TCP协议_5;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileReader;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 import java.io.InputStreamReader;
 9 import java.io.OutputStream;
10 import java.io.OutputStreamWriter;
11 import java.net.Socket;
12 
13 import javax.annotation.processing.Filer;
14 import javax.lang.model.element.Element;
15 import javax.tools.FileObject;
16 import javax.tools.JavaFileObject;
17 import javax.tools.JavaFileManager.Location;
18 
19 /**
20  * @author WYH
21  * @version 2019年11月26日 下午7:17:58
22  * 客户端文本文件，服务器端输出到文本,并接收到来自服务器的反馈
23  * 
24  * 
25  * 
26  * 
27  *          TCP一定要先开启服务端 java.net.ConnectException: Connection refused: connect
28  * 
29  */
30 public class Clint {
31     public static void main(String[] args) throws IOException {
32         Socket s = new Socket("192.168.1.103",2222);
33         //封装文本文件
34         BufferedReader br = new BufferedReader(new FileReader("D://TCP测试.txt"));
35         
36         //封装通道流
37         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
38         String line = null;
39         while((line = br.readLine())!= null) {
40             bw.write(line);
41             bw.newLine();
42             bw.flush();
43         }
44         
45         //方法1 自定义通知服务器我读取文件结束，但是不好
46         //如果我要读取的文本文件过程中有该自定义，那么就被中止了，所以我们采用第二种方式
47         /*bw.write("over");
48         bw.newLine();
49         bw.flush();*/
50         
51         //方式2 采用Socket提供的方法
52         s.shutdownOutput();
53         
54         
55         BufferedReader br1 = new BufferedReader(new InputStreamReader(s.getInputStream()));
56         String line1 = br1.readLine();
57         System.out.println(line1);
58         
59         
60         bw.close();
61         s.close();
62     }
63 }

Server:

 1 package TCP协议_5;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileWriter;
 6 import java.io.IOException;
 7 import java.io.InputStreamReader;
 8 import java.io.OutputStreamWriter;
 9 import java.net.ServerSocket;
10 import java.net.Socket;
11 import java.util.Scanner;
12 
13 /**
14  * @author WYH
15  * @version 2019年11月26日 下午7:28:59
16  */
17 public class Server {
18     public static void main(String[] args) throws IOException, InterruptedException {
19         ServerSocket ss = new ServerSocket(2222);
20         
21         Socket s = ss.accept();
22         String ip = s.getInetAddress().getHostAddress();
23         
24         //封装通道流
25         BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
26         BufferedWriter bw = new BufferedWriter(new FileWriter("TCP_5.txt",true));
27         String line1 = null;
28         while((line1 = br.readLine())!=null) {
29             /*if("over".equals(line1)) {
30                 break;
31             }*/
32             bw.write(line1);
33             bw.newLine();
34             bw.flush();
35             Thread.sleep(2000);//这里我添加了一个线程睡眠，为了更逼真的模拟
36             System.out.println("文件复制中。。");
37         }
38         
39         
40         BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
41         Scanner sc = new Scanner(System.in);
42         String s1 = sc.next();
43         bwServer.write(s1);
44         bwServer.newLine();
45         bwServer.flush();
46         System.out.println("文件复制成功");
47         
48         
49         
50         bw.close();
51         br.close();
52         s.close();
53         
54         
55         
56     }
57 
58 }

7、上传图片（字节流进行传输）

Client：

 1 package TCP协议_6图片;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.BufferedReader;
 6 import java.io.BufferedWriter;
 7 import java.io.FileInputStream;
 8 import java.io.FileReader;
 9 import java.io.IOException;
10 import java.io.InputStream;
11 import java.io.InputStreamReader;
12 import java.io.OutputStream;
13 import java.io.OutputStreamWriter;
14 import java.net.Socket;
15 
16 import javax.annotation.processing.Filer;
17 import javax.lang.model.element.Element;
18 import javax.tools.FileObject;
19 import javax.tools.JavaFileObject;
20 import javax.tools.JavaFileManager.Location;
21 
22 /**
23  * @author WYH
24  * @version 2019年11月26日 下午7:17:58
25  * 客户端发送图片，服务器端接收图片
26  * 
27  * 
28  * 
29  * 
30  *          TCP一定要先开启服务端 java.net.ConnectException: Connection refused: connect
31  * 
32  */
33 public class Clint {
34     public static void main(String[] args) throws IOException {
35        //获取Socket对象
36         Socket s = new Socket("192.168.1.103", 19191);
37         
38         //封装图片
39         BufferedInputStream bi = new BufferedInputStream(new FileInputStream("timg.jpg"));
40         //封装通道流
41         BufferedOutputStream bo = new BufferedOutputStream(s.getOutputStream());
42         
43         byte[] bys = new byte[1024];
44         int len;
45         while((len = bi.read(bys))!=-1){
46             bo.write(bys,0,len);
47             bo.flush();//为了保证没有精度丢失
48         }
49         s.shutdownOutput();
50         
51         //接收反馈
52         InputStream is = s.getInputStream();
53         byte[] bys2 = new byte[1024];
54         int len1 = is.read(bys2);
55         String s1 = new String(bys2,0,len1);
56         System.out.println(s1);
57         
58         bi.close();
59         s.close();
60         
61         
62         
63     }
64 }

Server：

 1 package TCP协议_6图片;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.BufferedReader;
 6 import java.io.BufferedWriter;
 7 import java.io.FileOutputStream;
 8 import java.io.FileWriter;
 9 import java.io.IOException;
10 import java.io.InputStreamReader;
11 import java.io.OutputStream;
12 import java.io.OutputStreamWriter;
13 import java.net.ServerSocket;
14 import java.net.Socket;
15 import java.util.Scanner;
16 
17 /**
18  * @author WYH
19  * @version 2019年11月26日 下午7:28:59
20  */
21 public class Server {
22     public static void main(String[] args) throws IOException, InterruptedException {
23         ServerSocket ss = new ServerSocket(19191);
24         
25         Socket s = ss.accept();
26         
27         BufferedInputStream bi = new BufferedInputStream(s.getInputStream());
28         
29         BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("copy.jpg"));
30         byte[] bys = new byte[1024];
31         int len;
32         while((len = bi.read(bys))!= -1){
33             bo.write(bys,0,len);
34             bo.flush();//为了保证没有精度丢失
35         }
36         
37                 
38         OutputStream ow = s.getOutputStream();
39         ow.write("图片上传成功".getBytes());
40         
41         bo.close();
42         s.close();
43         
44         
45     }
46 
47 }

8、多线程改进上传文件（思路：服务器端实现Runnable接口，重写run方法）

Client:

 1 package TCP协议_7Thread;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileReader;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 import java.io.InputStreamReader;
 9 import java.io.OutputStream;
10 import java.io.OutputStreamWriter;
11 import java.net.Socket;
12 
13 import javax.annotation.processing.Filer;
14 import javax.lang.model.element.Element;
15 import javax.tools.FileObject;
16 import javax.tools.JavaFileObject;
17 import javax.tools.JavaFileManager.Location;
18 
19 /**
20  * @author WYH
21  * @version 2019年11月26日 下午7:17:58
22  * 客户端文本文件，服务器端输出到文本,并接收到来自服务器的反馈
23  * 
24  * 
25  * 
26  * 
27  *          TCP一定要先开启服务端 java.net.ConnectException: Connection refused: connect
28  * 
29  */
30 public class Clint {
31     public static void main(String[] args) throws IOException {
32         Socket s = new Socket("192.168.1.103",2222);
33         //封装文本文件
34         BufferedReader br = new BufferedReader(new FileReader("D://TCP测试.txt"));
35         
36         //封装通道流
37         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
38         String line = null;
39         while((line = br.readLine())!= null) {
40             bw.write(line);
41             bw.newLine();
42             bw.flush();
43         }
44         s.shutdownOutput();
45         
46         
47         BufferedReader br1 = new BufferedReader(new InputStreamReader(s.getInputStream()));
48         String line1 = br1.readLine();
49         System.out.println(line1);
50         
51         
52         bw.close();
53         s.close();
54     }
55 }

Serve实现Runnable接口，重写run方法类:

 1 package TCP协议_7Thread;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileWriter;
 6 import java.io.IOException;
 7 import java.io.InputStreamReader;
 8 import java.io.OutputStreamWriter;
 9 import java.net.Socket;
10 import java.util.Scanner;
11 
12 public class StudentThread implements Runnable {
13     
14     private Socket s;
15     public StudentThread(Socket s){
16         this.s = s;
17     }
18 
19     @Override
20     public void run(){
21         try{
22         String ip = s.getInetAddress().getHostAddress();
23         //封装通道流
24         BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
25         String newFile = System.currentTimeMillis()+".txt";
26         
27         BufferedWriter bw = new BufferedWriter(new FileWriter(newFile,true));
28         String line1 = null;
29         while((line1 = br.readLine())!=null) {
30             /*if("over".equals(line1)) {
31                 break;
32             }*/
33             bw.write(line1);
34             bw.newLine();
35             bw.flush();
36             try {
37                 Thread.sleep(2000);
38             } catch (InterruptedException e) {
39                 // TODO Auto-generated catch block
40                 e.printStackTrace();
41             }
42             System.out.println("文件上传中。。");
43         }
44         
45         
46         BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
47 //        Scanner sc = new Scanner(System.in);
48 //        String s1 = sc.next();
49         bwServer.write("文件上传成功");
50         bwServer.newLine();
51         bwServer.flush();
52         System.out.println("文件上传成功");
53         
54         
55         
56         bw.close();
57         br.close();
58         s.close();
59         
60         }catch(IOException e){
61             e.printStackTrace();
62         }
63     }
64 
65 }

Server：

 1 package TCP协议_7Thread;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileWriter;
 6 import java.io.IOException;
 7 import java.io.InputStreamReader;
 8 import java.io.OutputStreamWriter;
 9 import java.net.ServerSocket;
10 import java.net.Socket;
11 import java.util.Scanner;
12 
13 /**
14  * @author WYH
15  * @version 2019年11月26日 下午7:28:59
16  */
17 public class Server {
18     public static void main(String[] args) throws IOException, InterruptedException {
19         ServerSocket ss = new ServerSocket(2222);
20         while(true){
21             Socket s = ss.accept();
22             new Thread(new StudentThread(s)).start();
23         } 
24     }
25 
26 }

（后面整理发现，我的Client的类名写错了，英文不好，请见谅，嘿嘿，自行修改一下类名即可）

再次提醒：（注意，所有有关文件的操作，都要进行关闭操作（.close()）!!!!!!!）