JavaSe——网络编程

网络编程概述

l  计算机网络

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

l  网络编程

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

l  计算机网络之间以何种规则进行通信，就是网络模型研究问题。

l  网络模型一般是指

                                      OSI（Open SystemInterconnection开放系统互连）参考模型

                                      TCP/IP参考模型

网络模型7层概述：

1.物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就是我们常说的数模转换与模数转换）。这一层的数据叫做比特。

2. 数据链路层：主要将从物理层接收的数据进行MAC地址（网卡的地址）的封装与解封装。常把这一层的数据叫做帧。在这一层工作的设备是交换机，数据通过交换机来传输。

3. 网络层：主要将从下层接收到的数据进行IP地址（例192.168.0.1)的封装与解封装。在这一层工作的设备是路由器，常把这一层的数据叫做数据包。

4. 传输层：定义了一些传输数据的协议和端口号（WWW端口80等），如：TCP（传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据），UDP（用户数据报协议，与TCP特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如QQ聊天数据就是通过这种方式传输的）。主要是将从下层接收的数据进行分段和传输，到达目的地址后再进行重组。常常把这一层数据叫做段。

5.会话层：通过传输层（端口号：传输端口与接收端口）建立数据传输的通路。主要在你的系统之间发起会话或者接受会话请求（设备之间需要互相认识可以是IP也可以是MAC或者是主机名）

6.表示层：主要是进行对接收的数据进行解释、加密与解密、压缩与解压缩等（也就是把计算机能够识别的东西转换成人能够能识别的东西（如图片、声音等）。

7.应用层： 主要是一些终端的应用，比如说FTP（各种文件下载），WEB（IE浏览），QQ之类的（可以把它理解成我们在电脑屏幕上可以看到的东西．就是终端应用）。

网络编程三要素：

         A:IP地址

         B:端口

         C:协议

IP

l  要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接受数据的计算机和识别发送的计算机，在TCP/IP协议中，这个标识号就是IP地址。

l  那么，我们如果获取和操作IP地址呢？

                   为了方便我们对IP地址的获取和操作，java提供了一个类InetAddress供我们使用。

IP地址:

         网络中计算机的唯一标识。

        

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

         但是呢，我们配置的IP地址确不是二进制的，为什么呢?

                   IP：192.168.1.100

                   换算：1100000010101000 00000001 01100100

         假如真是：1100000010101000 00000001 01100100的话。

         我们如果每次再上课的时候要配置该IP地址，记忆起来就比较的麻烦。

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

                   "点分十进制"

                  

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

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

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

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

                            一个网络号：256*256= 65536

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

                            一个网络号：256

        

         IP地址的分类：

                   A类 1.0.0.1---127.255.255.254       (1)10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)                                                           (2)127.X.X.X是保留地址，用做循环测试用的。

                   B类 128.0.0.1---191.255.255.254  172.16.0.0---172.31.255.255是私有地址。169.254.X.X是保留地址。

                   C类 192.0.0.1---223.255.255.254  192.168.X.X是私有地址

                   D类 224.0.0.1---239.255.255.254         

                   E类 240.0.0.1---247.255.255.254

A:所谓IP地址就是给每个连接在Internet上的主机分配的一个32bit地址。按照TCP/IP规定，IP地址用二进制来表示，每个IP地址长32bit，比特换算成字节，就是4个字节。例如一个采用二进制形式的IP地址是“00001010000000000000000000000001”，这么长的地址，人们处理起来也太费劲了。为了方便人们的使用，IP地址经常被写成十进制的形式，中间使用符号“.”分开不同的字节。于是，上面的IP地址可以表示为“10.0.0.1”。IP地址的这种表示法叫做“点分十进制表示法”，这显然比1和0容易记忆得多。

B:IP地址的组成

IP地址 = 网络号码+主机地址

A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码

B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码

C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码

特殊地址:

127.0.0.1 回环地址,可用于测试本机的网络是否有问题. ping 127.0.0.1  

DOS命令 ipconfig:查看本机IP地址

xxx.xxx.xxx.0 网络地址

xxx.xxx.xxx.255 广播地址

A类 1.0.0.1---127.255.255.254       (1)10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)                                                            (2)127.X.X.X是保留地址，用做循环测试用的。

B类 128.0.0.1---191.255.255.254  172.16.0.0---172.31.255.255是私有地址。169.254.X.X是保留地址。

C类 192.0.0.1---223.255.255.254  192.168.X.X是私有地址

D类 224.0.0.1---239.255.255.254         

E类 240.0.0.1---247.255.255.254  

InetAddress类的概述和使用

l  那么，我们如果获取和操作IP地址呢？

                   为了方便我们对IP地址的获取和操作，java提供了一个类InetAddress供我们使用。

package com.core.net.demo;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class Test {

	public static void main(String[] args) throws UnknownHostException {
		// 根据主机名或IP地址获得ip对象
//		InetAddress address = InetAddress.getByName("192.168.1.22");
		InetAddress address = InetAddress.getByName("Admin-PC");
		System.out.println(address.getHostName()+"---"+address.getHostAddress());
		//Admin-PC---192.168.1.22
	}

}

端口

l  物理端口 网卡口

l  逻辑端口 我们指的就是逻辑端口

         A:每个网络程序都会至少有一个逻辑端口

         B:用于标识进程的逻辑地址，不同进程的标识

         C:有效端口：0~65535，其中0~1024系统使用或保留端口。

         通过360可以查看端口号

 

端口号：

         正在运行的程序的标识。

         有效端口：0~65535，其中0~1024系统使用或保留端口。

协议

协议：

         通信的规则

        

         UDP：

                   把数据打包

                   数据有限制

                   不建立连接

                   速度快

                   不可靠

        

         TCP：

                   建立连接通道

                   数据无限制

                   速度慢

                   可靠

        

         举例：

                   UDP：发短信

                   TCP：打电话     

l  Socket套接字：

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

l  Socket原理机制：

•    通信的两端都有Socket。

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

•    数据在两个Socket间通过IO传输。

UDP协议发送数据&接收数据

发送端：

package com.core.net.demo;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class SendDemo {

	public static void main(String[] args) throws IOException {
		// UDP协议发送数据&接收数据
		// 1.创建发送端Socket对象
		// 2.创建数据，打包数据
		// 3.调用Socket对象的发送数据包
		// 4.释放资源

		DatagramSocket ds = new DatagramSocket();
		byte[] bys = "Hello,Java,世界".getBytes();
		InetAddress address = InetAddress.getByName("192.168.1.22");
		int port = 10086;
		DatagramPacket dp = new DatagramPacket(bys, bys.length, address, port);
		ds.send(dp);
		ds.close();
	}

}

接收端：

package com.core.net.demo;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class ReceiveDemo {

	public static void main(String[] args) throws IOException {
		// 创建Socket接收对象
		// 创建数据包，用于接收数据
		// 调用Socket对象的接收方法接收数据
		// 解析数据，并显示在控制台上
		// 释放资源

		DatagramSocket ds = new DatagramSocket(10086);
		byte[] bys = new byte[1024];
		DatagramPacket dp = new DatagramPacket(bys, bys.length);
		ds.receive(dp);
		// 解析数据
		InetAddress address = dp.getAddress();
		String ip = address.getHostAddress();
		String hostName = address.getHostName();
		System.out.println(hostName + "---" + ip);
		byte[] data = dp.getData();
		int length = dp.getLength();
		String s = new String(data, 0, length);
		System.out.println("内容是：" + s);
		ds.close();
	}

}

控制台：

Admin-PC---192.168.1.22
内容是：Hello,Java,世界

UDP协议发送和接收数据代码优化

发送端：

package com.core.net.demo1;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class SendDemo {

	public static void main(String[] args) throws IOException {
		// UDP协议发送数据&接收数据
		// 1.创建发送端Socket对象
		// 2.创建数据，打包数据
		// 3.调用Socket对象的发送数据包
		// 4.释放资源

		DatagramSocket ds = new DatagramSocket();
		byte[] bys = "UDP协议传送数据优化".getBytes();
		DatagramPacket dp = new DatagramPacket(bys, bys.length,
				InetAddress.getByName("192.168.1.22"), 12345);
		ds.send(dp);
		ds.close();
	}

}

接收端：

package com.core.net.demo1;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class ReceiveDemo {

	public static void main(String[] args) throws IOException {
		// 创建Socket接收对象
		// 创建数据包，用于接收数据
		// 调用Socket对象的接收方法接收数据
		// 解析数据，并显示在控制台上
		// 释放资源
		DatagramSocket ds = new DatagramSocket(12345);
		byte [] bys  = new byte[1024];
		DatagramPacket dp = new DatagramPacket(bys, bys.length);
		ds.receive(dp);
		String str = new String(dp.getData(), 0, dp.getLength());
		System.out.println("内容："+str+"来自："+dp.getAddress().getHostAddress());
		ds.close();
	}

}

发送端的数据来自于键盘录入案例

l  从键盘录入数据进行发送，如果输入的是886那么客户端就结束输入数据。

接收端：

package com.core.net.demo2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class ReceiveDemo {

	public static void main(String[] args) throws IOException {
		// 创建Socket接收对象
		// 创建数据包，用于接收数据
		// 调用Socket对象的接收方法接收数据
		// 解析数据，并显示在控制台上
		// 释放资源
		DatagramSocket ds = new DatagramSocket(12345);
		while(true){
			byte [] bys  = new byte[1024];
			DatagramPacket dp = new DatagramPacket(bys, bys.length);
			ds.receive(dp);
			String str = new String(dp.getData(), 0, dp.getLength());
			if(str.equals("886")){
				break;
			}
			System.out.println("内容："+str+"来自："+dp.getAddress().getHostAddress());
		}
		ds.close();
		System.out.println("接收端结束");
	}

}

发送端：

package com.core.net.demo2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;

public class SendDemo {

	public static void main(String[] args) throws IOException {
		// UDP协议发送数据&接收数据
		// 1.创建发送端Socket对象
		// 2.创建数据，打包数据
		// 3.调用Socket对象的发送数据包
		// 4.释放资源
		String next = "";
		DatagramSocket ds = new DatagramSocket();
		do {
			Scanner sc = new Scanner(System.in);
			next = sc.next();
			// System.out.println("你输入的内容：" + next);

			byte[] bys = next.getBytes();
			DatagramPacket dp = new DatagramPacket(bys, bys.length,
					InetAddress.getByName("192.168.1.22"), 12345);
			ds.send(dp);

		} while (!next.equals("886"));
		System.out.println("发送端结束");
		// DatagramSocket ds = new DatagramSocket();
		// byte[] bys = "UDP协议传送数据优化".getBytes();
		// DatagramPacket dp = new DatagramPacket(bys, bys.length,
		// InetAddress.getByName("192.168.1.22"), 12345);
		// ds.send(dp);
		ds.close();
	}

}

多线程实现聊天室程序

这样就可以在同一个窗口演示发送和接收数据了

方法1：

发送端：

package com.core.net.demo3;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;

public class SendThread extends Thread {
	@Override
	public void run() {
		while (true) {
			try {
				DatagramSocket ds = new DatagramSocket();
				System.out.println("发送端发送内容：");
				Scanner sc = new Scanner(System.in);
				String next = sc.next();
				byte[] bys = next.getBytes();
				DatagramPacket dp = new DatagramPacket(bys, bys.length,
						InetAddress.getByName("192.168.1.22"), 12345);
				ds.send(dp);
				
				ds.close();
//				sc.close();
			} catch (IOException e) {
				e.printStackTrace();
			}

		}
	}
}

接收端：

package com.core.net.demo3;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class ReceiveThread extends Thread {
	@Override
	public void run() {
		DatagramSocket ds;
		try {
			ds = new DatagramSocket(12345);
			byte[] bys = new byte[1024];
			DatagramPacket dp = new DatagramPacket(bys, bys.length);
			ds.receive(dp);

<pre name="code" class="java"><span style="white-space:pre">			</span>// 解析数据，在控制台输出
				System.out.println("接收端接收数据："
						+ new String(dp.getData(), 0, dp.getLength())
						+ "---ip是："+dp.getAddress());

		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}

测试类：

package com.core.net.demo3;

public class ChatRoom {

	public static void main(String[] args) {
		SendThread st = new SendThread();
		ReceiveThread rt = new ReceiveThread();
		rt.start();
		st.start();
	}

}

方法2：

发送端：

package com.core.net.demo4;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;

public class SendThread implements Runnable {
	private DatagramSocket ds;

	public SendThread(DatagramSocket ds) {
		this.ds = ds;
	}

	@Override
	public void run() {
		// 封装键盘录入对象
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = null;
		try {
			while ((line = br.readLine()) != null) {
				if (line.equals("886")) {
					break;
				}
				byte[] bys = line.getBytes();
				DatagramPacket dp;
				dp = new DatagramPacket(bys, bys.length,
						InetAddress.getByName("192.168.1.22"), 12345);
				ds.send(dp);

			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		ds.close();
	}
}

接收端：

package com.core.net.demo4;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class ReceiveThread implements Runnable {
	private DatagramSocket ds;

	public ReceiveThread(DatagramSocket ds) {
		this.ds = ds;
	}

	@Override
	public void run() {
		while (true) {
			try {
				byte[] bys = new byte[1024];
				DatagramPacket dp = new DatagramPacket(bys, bys.length);
				ds.receive(dp);

				// 解析数据，在控制台输出
				System.out.println("接收端接收数据："
						+ new String(dp.getData(), 0, dp.getLength())
						+ "---ip是：" + dp.getAddress());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

测试类：

package com.core.net.demo4;

import java.net.DatagramSocket;
import java.net.SocketException;

public class ChatRoom {

	public static void main(String[] args) throws SocketException {
		DatagramSocket	dsReceive = new DatagramSocket(12345);
		DatagramSocket	dsSend = new DatagramSocket();
		ReceiveThread rt = new ReceiveThread(dsReceive);
		SendThread st = new SendThread(dsSend);
		Thread sendThread = new Thread(st);
		Thread receiveThread = new Thread(rt);
		receiveThread.start();
		sendThread.start();
	}
}

TCP协议发送数据 & TCP协议接收数据

服务器：

package com.core.net.demo5;

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

public class ServiceDemo {

	/*
	 * TCP接收数据 A.创建Socket对象 B.监听客户端，返回一个对应的Socket对象 C.获取输出流，读取数据，写在控制台 D.释放资源
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		ServerSocket ss = new ServerSocket(8888);

		Socket s = ss.accept();
		InputStream is = s.getInputStream();
		
		byte[] bys = new byte[1024];
		int len = is.read(bys);
		String ip = s.getInetAddress().getHostAddress();
		System.out.println("接收端："+ip+new String(bys, 0, len));
		
		ss.close();
	}

}

客户端：

package com.core.net.demo5;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClienDemo {
	/*
	 * TCP 发送端数据
	 * A.创建Socket对象
	 * B.获取输出流
	 * C.释放资源
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket s = new Socket("192.168.1.22", 8888);
		
		//获得输出流，写数据
		OutputStream os = s.getOutputStream();
		os.write("Hello,Tcp,我来了".getBytes());
		
		//释放资源
		s.close();
	}

}

服务器给客户端一个反馈案例

客户端：

package com.core.net.demo6;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClienDemo {
	/*
	 * TCP 发送端数据
	 * A.创建Socket对象
	 * B.获取输出流
	 * C.释放资源
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket s = new Socket("192.168.1.22", 8888);
		
		//获得输出流，写数据
		OutputStream os = s.getOutputStream();
		os.write("Hello,Tcp,我来了".getBytes());
		
		InputStream is = s.getInputStream();
		byte [] bys = new byte[1024];
		int len = is.read(bys);
		System.out.println(new String(bys, 0, len));
		//释放资源
		s.close();
	}

}

服务端：

package com.core.net.demo6;

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

public class ServiceDemo {

	/*
	 * TCP接收数据 A.创建Socket对象 
	 * B.监听客户端，返回一个对应的Socket对象
	 *  C.获取输出流，读取数据，写在控制台 
	 *  D.释放资源
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		ServerSocket ss = new ServerSocket(8888);

		Socket s = ss.accept();
		InputStream is = s.getInputStream();
		
		byte[] bys = new byte[1024];
		int len = is.read(bys);
		String ip = s.getInetAddress().getHostAddress();
		System.out.println("接收端："+ip+new String(bys, 0, len));
		
		OutputStream os = s.getOutputStream();
		os.write("我是服务器，我收到你传来的数据".getBytes());
		ss.close();
	}

}

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

客户端：

package com.core.net.demo7;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClienDemo {
	public static void main(String[] args) throws UnknownHostException,
			IOException {
		Socket s = new Socket("192.168.1.22", 22222);
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
				s.getOutputStream()));

		String line = null;
		while ((line = br.readLine()) != null) {
			if(line.equals("886")){
				break;
			}
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		s.close();
	}

}

服务端：

package com.core.net.demo7;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServiceDemo {

	public static void main(String[] args) throws IOException {
		ServerSocket ss = new ServerSocket(22222);
		Socket s = ss.accept();
		InputStream is = s.getInputStream();
		
		BufferedReader br = new BufferedReader(new InputStreamReader(is));
		String line = null;
		while((line = br.readLine())!=null){
			System.out.println(line);
		}
		
		s.close();
	}

}

客户端键盘录入服务器写到文本文件

客户端不变；

服务器：

package com.core.net.demo8;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServiceDemo {
	// 客户端键盘录入服务器写到文本文件
	public static void main(String[] args) throws IOException {
		ServerSocket ss = new ServerSocket(22222);
		Socket s = ss.accept();
		InputStream is = s.getInputStream();

		BufferedReader br = new BufferedReader(new InputStreamReader(is));
		BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
		String line = null;
		while ((line = br.readLine()) != null) {
			System.out.println(line);
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		bw.close();
		s.close();
	}

}

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

服务器端和上上个一样；

package com.core.net.demo9;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClienDemo {
	public static void main(String[] args) throws UnknownHostException,
			IOException {
		Socket s = new Socket("192.168.1.22", 22222);
		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
				s.getOutputStream()));

		String line = null;
		while ((line = br.readLine()) != null) {
//			if(line.equals("886")){
//				break;
//			}
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		s.close();
	}

}

TCP协议上传文本文件

客户端：

package com.core.net.demo;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClientDemo {

	public static void main(String[] args) throws IOException {
		Socket s = new Socket("192.168.1.22", 8888);
		BufferedReader br = new BufferedReader(new FileReader("a.java"));
		OutputStream os = s.getOutputStream();
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
		String line = null;
		while((line = br.readLine())!=null){
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		
		br.close();
		s.close();
	}

}

服务端：

package com.core.net.demo;

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

public class ServerDemo {

	public static void main(String[] args) throws IOException {
		ServerSocket ss = new ServerSocket(8888);
		Socket s = ss.accept();
		InputStream is = s.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(is));
		BufferedWriter bw = new BufferedWriter(new FileWriter("b.java"));
		String line = null;
		while ((line = br.readLine()) != null) {
			System.out.println(line);
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		s.close();
		ss.close();
	}

}

TCP上传文本文件并给出反馈

方法一：写一个标记

客户端：

package com.core.net.demo1;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClientDemo {

	public static void main(String[] args) throws IOException {
		Socket s = new Socket("192.168.1.22", 8888);
		BufferedReader br = new BufferedReader(new FileReader("a.java"));
		OutputStream os = s.getOutputStream();
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
		String line = null;
		while ((line = br.readLine()) != null) {
			
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		// 自定义一个标签
		bw.write("over");
		bw.newLine();
		bw.flush();
		InputStream is = s.getInputStream();
		BufferedReader brReader = new BufferedReader(new InputStreamReader(is));
		String client = brReader.readLine();
		System.out.println(client);

		br.close();
		s.close();
	}

}

服务器：

package com.core.net.demo1;

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

public class ServerDemo {

	public static void main(String[] args) throws IOException {
		ServerSocket ss = new ServerSocket(8888);
		Socket s = ss.accept();
		InputStream is = s.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(is));
		BufferedWriter bw = new BufferedWriter(new FileWriter("b.java"));
		String line = null;
		while ((line = br.readLine()) != null) {
			if (line.equals("over")) {
				break;
			}
			System.out.println(line);
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		// 给出反馈
		OutputStream os = s.getOutputStream();
		BufferedWriter bwWriter = new BufferedWriter(new OutputStreamWriter(os));
		bwWriter.write("上传成功");
		bwWriter.newLine();
		bwWriter.flush();

		bw.close();
		s.close();
		ss.close();
	}

}

方法二：s.shutdownOutput();

客户端：

package com.core.net.demo2;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClientDemo {

	public static void main(String[] args) throws IOException {
		Socket s = new Socket("192.168.1.22", 8888);
		BufferedReader br = new BufferedReader(new FileReader("a.java"));
		OutputStream os = s.getOutputStream();
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
		String line = null;
		while ((line = br.readLine()) != null) {
			
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
//		// 自定义一个标签
//		bw.write("over");
//		bw.newLine();
//		bw.flush();
		
		s.shutdownOutput();
		
		InputStream is = s.getInputStream();
		BufferedReader brReader = new BufferedReader(new InputStreamReader(is));
		String client = brReader.readLine();
		System.out.println(client);

		br.close();
		s.close();
	}

}

服务端：

package com.core.net.demo2;

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

public class ServerDemo {

	public static void main(String[] args) throws IOException {
		ServerSocket ss = new ServerSocket(8888);
		Socket s = ss.accept();
		InputStream is = s.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(is));
		BufferedWriter bw = new BufferedWriter(new FileWriter("b.java"));
		String line = null;
		while ((line = br.readLine()) != null) {
//			if (line.equals("over")) {
//				break;
//			}
			System.out.println(line);
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		// 给出反馈
		OutputStream os = s.getOutputStream();
		BufferedWriter bwWriter = new BufferedWriter(new OutputStreamWriter(os));
		bwWriter.write("方法2：上传成功");
		bwWriter.newLine();
		bwWriter.flush();

		bw.close();
		s.close();
		ss.close();
	}

}

TCP协议上传图片并给出反馈

客户端：

package com.core.net.demo3;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;

public class UploadClient {

	public static void main(String[] args) throws IOException {
		// 创建socke对象 192.168.1.22
		Socket s = new Socket("192.168.1.22", 12345);

		// 封装文件读取流
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				"E:\\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();//这一步很关键：刷新此输出流并强制写出所有缓冲的输出字节流
		}

		//结束是否上传成功
		s.shutdownOutput();
		InputStream is = s.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(is));
		String line = null;
		len = 0;
		while((line = br.readLine())!=null){
			System.out.println(line);
		}
		// 关闭资源
		s.close();
		bis.close();

	}

}

服务器：

package com.core.net.demo3;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

public class UploadServer {

	public static void main(String[] args) throws IOException {
		ServerSocket ss = new ServerSocket(12345);
		Socket s = ss.accept();
		// 封装通道内流
		InputStream is = s.getInputStream();
		BufferedInputStream bis = new BufferedInputStream(is);
		// 封装文件
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("E:\\temp\\b.jpg"));

		int len = 0;
		byte[] bys = new byte[1024];
		while ((len = bis.read(bys)) != -1) {
			bos.write(bys, 0, len);
			bos.flush();//这一步很关键：刷新此输出流并强制写出所有缓冲的输出字节流
		}

		
		//给一个反馈
		BufferedWriter bwWriter = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		bwWriter.write("图片上传成功");
		bwWriter.newLine();
		bwWriter.flush();
		
		bos.close();
		s.close();
		ss.close();
	}

}

多线程改进多个客户端上传文件案例

客户端：

package com.core.net.demo4;

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

public class UploadServer {

	public static void main(String[] args) throws IOException {
		//创建服务器Socket对象
		ServerSocket ss = new ServerSocket(12345);
		while(true){
			Socket s = ss.accept();
			Thread t = new Thread(new UserThread(s));
			t.start();
		}
	}

}

上传线程：

package com.core.net.demo4;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class UserThread implements Runnable {
	private Socket s;
	public UserThread(Socket s) {
		this.s = s;
	}

	@Override
	public void run() {
		try {
			InputStream is = s.getInputStream();
			BufferedInputStream bis = new BufferedInputStream(is);
			String fileName = System.currentTimeMillis()+".avi";
			BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(fileName ));
			int len = 0;
			byte[] bys = new byte[1024];
			while((len = bis.read(bys))!=-1){
				bos.write(bys, 0, len);
				bos.flush();
			}
			bos.close();
			BufferedWriter bwWriter = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
			bwWriter.write("文件"+fileName+".avi上传成功");
			bwWriter.newLine();
			bwWriter.flush();
			s.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

}

客户端：

package com.core.net.demo4;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;

public class UploadClient {

	public static void main(String[] args) throws IOException {
		// 创建socke对象 192.168.1.22
		Socket s = new Socket("192.168.1.22", 12345);

		// 封装文件读取流
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				"E:\\1.avi"));
		// 封装通道流
		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();//这一步很关键：刷新此输出流并强制写出所有缓冲的输出字节流
		}

		//结束是否上传成功
		s.shutdownOutput();
		InputStream is = s.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(is));
		String line = null;
		len = 0;
		while((line = br.readLine())!=null){
			System.out.println(line);
		}
		// 关闭资源
		s.close();
		bis.close();

	}

}