17.网络编程

最新推荐文章于 2021-02-12 21:26:23 发布

炳烛以期明

最新推荐文章于 2021-02-12 21:26:23 发布

阅读量898

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/u011374699/article/details/16112929

版权

Java 专栏收录该内容

29 篇文章 1 订阅

订阅专栏

网络编程

一、概述

1.服务器和客户端：

为了使两台计算机之间进行通信，必须为这两台计算机建立一个网络，将这两台计算机进行连接，

把一台作为客户端，一台作为服务器。

客户端：指发送请求信息的计算机或程序。

服务器：指能提供信息的计算机或程序。

2.协议的概念

有时候两台计算机都是相互发送信息，相互接收信息的，所以很难区分服务器和客户端。

为了保证能将两台或更多的计算机之间能相互通信，必须遵守某种约定，这就是协议。例如，互联网使用IP协议，这种协议使用4个字节来标识网络中的一台计算机。

3.网络参考模型：OSI参考模型和TCP/IP参考模型

一般来说，开发处于传输层和网际层；

应用层为FTP和HTTP协议等，

传输层为UDP和TCP协议等；

网际层为IP。

通常用户操作的是应用层，而编程人员需要做的是传输层和网际层，用户在应用层操作的数据，经过逐层封包，最后到物理层发送到另一个模型中，再进行逐层解包，如图所示：

二、网络通讯要素：IP地址、端口号、传输协议

1.IP地址：InetAddress

a)网络中设备的标识

b)不易记忆，可用主机名表示，两者存在映射关系

c)本机回环地址：127.0.0.1，主机名为：localhost。

IP地址在Java中对应的是InetAdress类，存在于java.net包中。

2.InetAdress类

1)无构造函数，可通过getLocalHost()方法获取InetAddress对象，此方法静态，返回本类对象。

2)方法：

static InetAddress getByName(String host)：获取指定主机的IP和主机名。（最好用ip地址去获取，主机名需要解

析）

static InetAddress[] getAllByName(String host)：在给定主机名的情况下，根据系统上配置的名称服务返回IP

地址所组成的数组。返回对象不唯一时，用此方法。

String getHostName()：返回IP地址主机名。

String getHostAddress()：返回IP地址字符串文本形式，以IP地址为主。

3)获取任意一台主机的IP地址对象

对于任意主机，需要指定传入主机名的参数。

如果IP地址和对应的主机名，这种映射关系没有在网络上，就不会解析成功，返回的还是指定的IP。

代码示例

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

public class IPDemo {

	public static void main(String[] args) throws UnknownHostException {

		// 获取本地主机ip地址对象
		InetAddress ip = InetAddress.getLocalHost();

		// 获取其他主机的IP地址对象
		ip = InetAddress.getByName("192.168.1.100");// 需要解析域名
		System.out.println(ip.getHostAddress());
		System.out.println(ip.getHostName());
		// 获取指定主机名的ip信息
		InetAddress[] baidu = InetAddress.getAllByName("www.baidu.com");
		for (InetAddress b : baidu) {
			String baddress = b.getHostAddress();
			String bname = b.getHostName();
			System.out.println("baiduIP=" + baddress + "\tbaiduname=" + bname);
		}
	}

}

3.端口号（Port）

a)用于标识进程的逻辑地址，不用进程的标识。

b)有效端口：0 ~65535，系统使用或保留的端口是：0~ 1024。使用时不要占用保留的端口。

4.传输协议：TCP和UDP

即通信规则，包含TCP和UDP协议。

5.UDP协议

面向无连接，明确对方的端口后，无论在不在网上，只管传输，没有网络时数据会丢失。一般用于网络视频会议和聊天等。

UDP协议的特点：

a)面向无连接，即将数据源和目的封装成数据包，不建立连接的发送

b)每个数据包的大小限制在64K之内

c)因无连接，所以是不可靠协议。

d)不建立连接，速度快。

6.TCP协议

是面向连接的，必须连接成功才能传输数据，应用于下载等程序上。

TCP协议的特点：

a)面向连接，在建立连接后，形成传输数据的通道

b)在连接中进行大数据量的传输

c)通过三次握手完成连接，是可靠的协议

三次握手：第一次本方发送请求，第二次对方确认连接，第三次本方再次确认连接成功。

d)必须建立连接，效率稍慢

7.通信的步骤

1）找到IP地址

2）数据要发送到对象指定应用程序，为标识这些应用程序，所以给这些网络应用程序都用数字标识，为方便称呼这

个数字，叫做端口，即逻辑端口。

3）定义通信规则，称之为协议。国际组织定义了通用协议，即TCP/IP。

注意：必须要有数字标识才能将数据发送到应用程序上。

三、传输协议

1.Socket（套接字）

Socket就是为网络服务提供的一种机制，通信两端都有Socket，是两台机器间通信的端点。网络通信其实就是Socket之间的通信。数据在两个Socket之间通过io传输。套接字的实际工作由SocketImpl类的实例执行。

2.UDP传输

通过类DatagramSocket与DatagramPacket来实现传输。DatagramPacket：数据报包用来实现无连接包投递服务的，每条报文仅根据该包中包含的信息从一台机器路由到另一台机器中。凡是带地址（InetAddress）的都是用于发送包的。

使用UDP传输的方法：

a)建立发送端、接收端

b)建立数据包，封装发送的数据和接收的数据:DatagramPacket dp =new DatagramPacket(要发送的数据，目的地IP地

址，目的地端口);

c)调用Socket的send(dp)和receive(dp)。

d)关闭Socket流。

3.UDP传输发送数据和接收数据的思路

1）发送数据的思路

a)建立UDP的Socket服务。可以指定端口，也可以不指定。不指定端口时，系统会随机分配端口，如果端口被占用，则

会顺延。

b)将要发送的数据封装到数据包中。

c)通过UDP的Socket服务将数据包发送出去。

d)关闭Socket服务。

2）接收数据的思路

a)建立UDP的Socket服务。因为要接收数据，必须要明确端口号。否则它是随机接收任何可用的端口号的数据包。

b)创建数据包，用于存储接收到的数据，方便用数据包对象的方法解析数据。

c)使用Socket服务的receive方法将接收的数据存储到数据包中。

d)通过数据包中的方法解析数据包中的数据。

e)关闭资源。

注意事项：

第一．发送端与接收端是两个独立的运行程序。

第二．在发送端，要在数据包对象中明确目的地IP及端口。

第三．在接收端，要明确接收哪个端口的数据。

代码实现：

发送端

<span style="font-size:18px;">import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
/*
 * UDP发送端。
 */
public class UDPSendDemo {

	public static void main(String[] args) throws IOException {

		System.out.println("发送端启动......");
		//1.创建Socket服务。使用DatagramSocket对象。
		DatagramSocket ds = new DatagramSocket();
		
		//2.将要发送的数据封装到数据包中，
		String str = "send演示：hah 我喜欢你！";
		byte[] buf = str.getBytes();
		
		//使用DatagramPacket对象封装数据。
		DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10000);
		
		//3.通过UDP的Socket服务将数据包发送出去。
		ds.send(dp);
		
		ds.close();
	}

}
</span>

接收端

<span style="font-size:18px;">import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/*
 *UDP接收端
 */
public class UDPReceiveDemo {

	public static void main(String[] args) throws IOException {

		System.out.println("接收端启动......");
		
		//1。建立UDP的Socket服务
		DatagramSocket ds = new DatagramSocket(10000);
		
		//2.创建数据包，
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);
		
		//3.使用接收方法将数据存储到数据包中。
		ds.receive(dp);//阻塞式的。没有数据，则一直等待。
		
		//4.通过数据包对象的方法，解析其中的数据。比如：地址，端口，数据内容。
		String ip = dp.getAddress().getHostAddress();
		int port = dp.getPort();
		//获取数据长度的字符串
		String text = new String(dp.getData(),0,dp.getLength());
		
		System.out.println(ip+":"+port+":"+text);
		
		ds.close();
	}

}
</span>

练习：编写一个聊天程序

<span style="font-size:18px;">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;
/*
 * 编写一个聊天程序
 * 
 * 分析：程序有接收数据，有发送数据，这部分要同时执行。这时需要用多线程控制技术。
 * 		一个线程控制接收，一个线程控制发送。因为收发两个动作不一致，所以要定义两个run方法，
 * 		而且要封装到不同的类中。
 */
public class ChatDemo {

	public static void main(String[] args) throws IOException {

		DatagramSocket send = new DatagramSocket();
		DatagramSocket receive = new DatagramSocket(10001);//指向发送端的端口号
		
		new Thread(new Send(send)).start();
		new Thread(new Receive(receive)).start();
	}

}

//接收端
class Receive implements Runnable {

	private DatagramSocket ds;
	Receive(DatagramSocket ds){
		this.ds = ds;
	}
	@Override
	public void run() {
		
		try{
			while(true){//加while循环，不断接收数据。
				
				//2.创建数据包，
				byte[] buf = new byte[1024];
				DatagramPacket dp = new DatagramPacket(buf,buf.length);
				
				//3.使用接收方法将数据存储到数据包中。
				ds.receive(dp);//阻塞式的。没有数据，则一直等待。
				
				//4.通过数据包对象的方法，解析其中的数据。比如：地址，端口，数据内容。
				String ip = dp.getAddress().getHostAddress();
				int port = dp.getPort();
				//获取数据长度的字符串
				String text = new String(dp.getData(),0,dp.getLength());
				
				System.out.println(ip+":"+port+":"+text);
				if(text.equals("886")){
					System.out.println(ip+"退出聊天室");
				}
				}
		}catch(Exception e){
			
		}
	}

}

//发送端
class Send implements Runnable{

	private DatagramSocket ds;
	
	Send(DatagramSocket ds){
		this.ds = ds;
	}
	@Override
	public void run() {
		
		try{
			BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
			String line = null;
			
			while((line=bufr.readLine())!=null){
				byte[] buf = line.getBytes();
			
				//有效IP地址：192.168.1.1~254，0是网络位。255是广播地址，既能接收，又能发送，群聊。局域网内的都能看到。
				DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10001);
				ds.send(dp);
				if("886".equals(line))
					break;
			}
			
			ds.close();
		}catch(Exception e){
			
		}
	}

}
</span>

4.TCP传输
TCP传输分为客户端和服务端。客户端对应的对象为Socket，服务端对应的对象为ServerSocket。

1）TCP传输常用的方法：
    Socket（）：创建空参数的客户端对象，一般用于服务器端接收数据。
    Socket（String host，int port）：创建客户端对象时明确目的地的IP地址和端口号。
    ServerSocket（int port）：指定接收的客户端的端口。
    Socket accept（）：服务端监听并获取客户端的流对象。
    void shutdownInput（）：此套接字的流置于末尾。调用此方法后从套接字输入流读取内容，则返回EOF（文件结束符）。
    void shutdownOutput（）：禁用此套接字的输出流。调用此方法后写入套接字输出流会出现异常。
    InputStream getInputStream（）：返回此套接字的输入流，Socket对象调用。
    OutputStream getOutputStream（）：返回此套接字的输出流，Socket对象调用。

2）TCP传输的基本思路
客户端：
a)客户端要明确服务端的IP地址和端口，才能尝试连接，如果连接失败，会出现异常。
b)连接成功后，客户端和服务端建立了数据通道，就可以通过IO流进行数据传输，而Socket已经提供了输入流和输出流，只需要调用getInputStream()和getOutputStream()方法获取即可。
c)通讯结束后，关闭Socket流。

服务端：
a)创建服务端对象时需要明确要处理的数据是从哪个端口传入的。
b)当有客户端访问时，要明确是哪个客户端，可调用服务端流对象的方法accept（）来获取已连接的客户端对象，然后通过该对象的方法处理数据。
c)当客户端访问结束后，关闭该客户端对象。

3）TCP传输的步骤
客户端：
a)创建Socket服务对象，并指定主机地址和端口。
b)完成连接后，产生Socket数据通道，可通过方法互殴IO流进行数据传输。
c)使用Socket中的输出流，将数据写出。
d)关闭Socket流资源。

服务端：
a)创建服务端对象ServerSocket，并监听指定端口。
b)调用accept方法获取与服务端连接的客户端对象，此方法是阻塞式方法，如果没有客户端连接就一直等待。
c)使用获取到的客户端对象读取数据并处理。
d)关闭服务端（可选）。一般服务器要保持运行状态，在实际应用中，随时都有客户端访问服务器。

代码示例：

<span style="font-size:18px;">import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

//服务端接收客户端发过来的数据，并打印在控制台上。

public class ServerDemo2 {

	public static void main(String[] args) throws IOException {

		//1.创建服务端对象，
		ServerSocket ss = new ServerSocket(8888);
	
		//2。获取连接过来的客户端对象，
		Socket s = ss.accept();//阻塞式
		
		//获取客户端的IP地址
		String ip = s.getInetAddress().getHostAddress();
		
		//3.通过Socket对象获取输入流，要读取客户端发来的数据。
		InputStream in = s.getInputStream();
		
		byte[] buf = new byte[1024];
		
		int len = in.read(buf);
		
		String text = new String(buf,0,len);
		System.out.println(ip+":"+text);
		
		//服务端向客户端返回数据，使用socket输出流
		OutputStream out = s.getOutputStream();
						
		out.write("收到！".getBytes());
		
		
		s.close();
		ss.close();

	}

}


//客户端将数据发送到服务端

public class ClientDemo2 {

	public static void main(String[] args) throws UnknownHostException, IOException {

		
		Socket socket = new Socket("127.0.0.1",8888);
	
		OutputStream out = socket.getOutputStream();
		
		out.write("tcp演示：哥们又来了！".getBytes());

		//读取服务端返回的数据。使用Socket读取流
		InputStream in = socket.getInputStream();
		
		byte[] buf = new byte[1024];
		int len = in.read(buf);
		String text = new String(buf,0,len);
		
		System.out.println(text);
		
		
		socket.close();
		
	
	}

}</span>

练习一：创建一个英文大写转换服务器。
客户端输入字母数据，发送给服务端，服务端收到后显示在控制台上，并将数据转成大写返回给客户端。
直到客户端输入over，转换结束。

练习一代码实现：

客户端：

<span style="font-size:18px;">/*
 * 思路：
 * 客户端
 * 1.需要先有socket端点。
 * 2.客户端的数据源：键盘
 * 3.将数据给Socket输出流
 * 4.接收服务端的数据。源：Socket输入流。
 *	5.将数据显示在控制台上，都是文本数据
 *
 *转换客户端：
 *1.创建Socket客户端对象，
 *2。获取键盘录入
 *3.将录入的信息发送给Socket输出流。
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class TransClient {

	public static void main(String[] args) throws UnknownHostException, IOException{
	
		//1.创建Socket流
		Socket socket = new Socket("127.0.0.1",8888);
		
		BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
		 
		//3.Socket输出流
//		new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
		//数据原封不动的输出
		PrintWriter out = new PrintWriter(socket.getOutputStream(),true);
		
		//4.Socket输入流，读取服务端返回的大写数据。
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		
		String line = null;
		
		while((line=bufr.readLine())!=null){
			if("over".equals(line)){
				break;
			}
			
//			out.print(line+"\r\n");
//			out.flush();
			out.println(line);
			
			//读取服务端返回的一行大写数据。
			String upperStr = bufIn.readLine();
			System.out.println(upperStr);
		}
		
		socket.close();

	}
}</span>

服务端：

<span style="font-size:18px;">import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

/*
 * 转换服务端
 * 分析：
 * 1，serversocket服务
 * 2.获取Socket对象。
 * 3.源：Socket，读取客户端发过来的需要转换的数据，
 * 4.目的：将数据显示在控制台上
 * 5.将数据转换成大写发给客户端。
 */
public class TransServer {

	public static void main(String[] args) throws IOException{
		
		//创建serverSocket服务端。
		ServerSocket ss = new ServerSocket(8888);
		
		//2.获取Socket对象。
		Socket s = ss.accept();
		
		//获取IP
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"......connected");
		
		//3.获取Socket读取流，并装饰
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		//4.获取Socket输出流，并装饰
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);
		
		String line = null;
		
		while((line=bufIn.readLine())!=null){
			
//			System.out.print(line+"\r\n");
//			out.print(line.toUpperCase()+"\r\n");
//			out.flush();
			
			System.out.println(line);
			out.println(line.toUpperCase());
			
		}
		
		s.close();	
		ss.close();	
	
	}
}</span>

练习一常见问题：
1.服务端没有“over”停止运行的标记，客户端停止运行，服务端怎么也跟着运行了呢？
首先readline方法是阻塞式方法，客户端停止了，他也会一直等待数据。按理来说服务端不会停止运行。
其实，是由于客户端中的最后一句：socket。close();相当于在socket流植入了结束标记。
socket流关闭后，服务端中readline()封装的read方法就会返回-1，readline()跟着返回null;所以读取停止。

2.若客户端和服务端都不带着自动刷新true，以及去掉自动换行(println-->print)，有什么现象呢？
现象：客户端按下空格后，不能再次输入，而且也没返回大写。
分析：
(1)客户端写入数据后，没有刷新，所以数据没有写入服务端，可以加out.flush();
(2)即使刷新，服务端还是没有显示数据。因为readLine()方法以换行符(即回车)为结束标记。
   去掉自动刷新，用flush()来替换，输入数据后flush刷新，没有将换行符写入数据，那么服务端的
   readLine()方法会一直等待输入。
   解决方法是，在客户端和服务端的数据后+"\r\n".

因为阻塞式方法，导致客户端和服务端都在等待。
所以，为了不这么麻烦，直接用println(line.toUpper());
同时，加上自动刷新。

练习二：向服务器上传一个文件，服务返回一条信息。

代码实现：

<span style="font-size:18px;">/*
需求：向服务器上传一个文件，服务返回一条信息
1、客户端：
源：硬盘上的文件；目的：网络设备，即网络输出流。
若操作的是文本数据，可选字符流，并加入高效缓冲区。若是媒体文件，用字节流。

2、服务端：
源：socket读取流；目的：socket输出流。

3、出现的问题： 
现象：
a、文件已经上传成功了，但是没有得到服务端的反馈信息。
b、即使得到反馈信息，但得到的是null，而不是“上传成功”的信息

原因：
a、因为客户端将数据发送完毕后，服务端仍然在等待这读取数据，并没有收到结束标记，就会一直等待读取。
b、上个问题解决后，收到的不是指定信息而是null，是因为服务端写入数据后，需要刷新，才能将信息反馈给客服端。

解决：
方法一：定义结束标记，先将结束标记发送给服务端，让服务端接收到结束标记，然后再发送上传的数据。但是这样定义可能会发生定义的标记和文件中的数据重复，而导致提前结束。
   方法二：定义时间戳，由于时间是唯一的，在发送数据前，先获取时间，发送完后在结尾处写上相同的时间戳，在服务端，接收数据前先接收一个时间戳，然后在循环中判断时间戳以结束标记。
  方法三：通过socket方法中的shutdownOutput()，关闭输入流资源，从而结束传输流，以给定结束标记。通常用这个方法。
*/

import java.io.*;
import java.net.*;


//客户端
class  TcpClient
{
	public static void main(String[] args) throws Exception
	{
		//创建Socket服务
		Socket s=new Socket("127.0.0.1",10000);
		
		//定义读取流读取文件数据
		BufferedReader br=new BufferedReader(new FileReader("TcpDemo.java"));

		//定义目的，将数据写入到Socket输出流。发给服务端
		//BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		PrintWriter pw=new PrintWriter(s.getOutputStream(),true);

		//定义一个Socket读取流，读取服务端返回信息。
		BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));

		String line=null;
		while ((line=br.readLine())!=null)
		{
			pw.println(line);
		}
		
		s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1.

		System.out.println(brin.readLine());//接收返回信息
		
		br.close();
		s.close();
	}
}

//服务端
class TcpServer
{
	public static void main(String[] args)throws Exception
	{
		//创建服务端的ServerSocket服务,并指定监听端口
		ServerSocket ss =new ServerSocket(10000);
		
		//获取客户端连接
		Socket s=ss.accept();

		//获取客户端ip
		System.out.println(s.getInetAddress().getHostName()+" connected.......");

		//读取Socket读取流中的数据
		BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));

		//将接收到的数据写入文件中
		PrintWriter out=new PrintWriter(new FileWriter("TcpDemo.txt"),true);
		
		//将返回信息写入Socket流的写入流中
		BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

		String line=null;
		while ((line=brin.readLine())!=null)
		{
			out.println(line);
		}

		//PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		//pw.println("上传成功");
		
		bwout.write("上传成功!");
		bwout.newLine();//换行
		bwout.flush();//刷新

		out.close();//关流
		s.close();
		ss.close();
	}
}</span>

四、应用

1.并发上传图片

   在讲并发上传图片前，先讲解下单线程上传图片，即每次只能有一个客户端上传图片到服务器。
         ①客户端：创建客户端套接字；读取客户端待上传的图片数据；通过Socket输出流将数据发送给服务端；读取服务器端反馈的信息；关闭。
         ②服务端：创建服务器服务对象，并指定端口；获取客户端对象，获取客户端对象，从而获取信息；读取客户端输入流数据；写入文件；用客户端输出流反馈信息；关闭。
       单线程的服务端有局限性。当一个客户端连接服务端以后，跟服务器端的监听器绑定，然后顺序执行后续流程。这时如果有其他客户端请求连接到服务端，只能等待，因为服务端没有处理完前一个客户端的请求，不能循环回来执行accept方法，所以获取不到其他客户端。
       为了实现多个客户端能同时并发访问服务端，服务端可以将连接的每个客户端封装到一个单独的线程中，这样就可以同时处理多个客户端请求。
       只要明确了每个客户端在服务端执行的代码，将这些代码封装到run方法中即可。
代码实现：

<span style="font-size:18px;">/*
需求：并发上传图片
*/

import java.io.*;
import java.net.*;
//客户端
class  PicClient
{
	public static void main(String[] args) throws Exception
	{
		//对传入的值进行判断
		if (args.length!=1)
		{
			System.out.println("请指定一个图片文件！");
			return;
		}

		File file=new File(args[0]);

		//对文件路径进行判断
		if (!(file.exists()&&file.isFile()))
		{
			System.out.println("你上传的文件有问题，非文件或者不存在！");
			return;
		}

		//判断是否是图片文件
		if (!file.getName().endsWith(".jpg"))
		{
			System.out.println("图片格式错误，请重新选择！");
			return;
		}

		//对文件大小进行判断
		if (file.length()>1024*1024*5)
		{
			System.out.println("你上传的文件过大,居心叵测！");
			return;
		}

		//创建服务
		Socket s=new Socket("localhost",10000);
		//读取图片数据
		FileInputStream fis=new FileInputStream(file);
		
		//用Socket服务输出流写入数据
		OutputStream out =s.getOutputStream();

		BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));

		byte[] buf=new byte[1024];

		int len=0;

		while ((len=fis.read(buf))!=-1)
		{
			out.write(buf,0,len);
		}

		//结束标记，表示文件数据已经上传完了
		s.shutdownOutput();

		String info=in.readLine();//读取返回信息
		System.out.println(info);

		fis.close();//关流
		s.close();

	}
}

//服务端
class PicServer
{
	public static void main(String[] args)throws Exception
	{
		//创建服务，监听端口
		ServerSocket ss=new ServerSocket(10000);
		
		while (true)
		{
			//获取客户端对象
			Socket s=ss.accept();
			//客户端执行线程
			new Thread(new PicThread(s)).start();
		}
		
		//ss.close();
	}
}

//利用多线程实现并发上传
class PicThread implements Runnable
{
	private Socket s;
	PicThread(Socket s)
	{
		this.s=s;
	}
	public void run()
	{
		int count=1;
		//获取客户端ip
		String ip=s.getInetAddress().getHostAddress();
		try
		{		
			System.out.println(ip+"  connected.....");

			//通过客户端的读取流读取数据
			InputStream in=s.getInputStream();
			//文件保存路径
			File dir =new File("C:\\Users\\asus\\Desktop");
			//文件名
			File file=new File(dir,ip+".jpg");
			//判断文件是否存在
			while(file.exists())
			{
				file=new File(dir,ip+"("+(count++)+").jpg");
			}

			//将数据写入到指定文件中
			FileOutputStream fos=new FileOutputStream(file);

			byte[] buf=new byte[1024];
			int len=0;
			while ((len=in.read(buf))!=-1)
			{
				fos.write(buf,0,len);
			}

			//将收到图片数据的信息返回给客户端
			OutputStream out=s.getOutputStream();
			
			out.write("上传成功！".getBytes());

			fos.close();//关流
			s.close();
		}
		catch (Exception e)
		{
			throw new RuntimeException(ip+"图片上传失败");
		}
	}
}</span>

2.客户端并发登录

需求：客户端通过键盘录入用户名，服务端对用户名进行校验。如果用户存在，在服务端“显示xxx，已登录”，并在客户端显示“xxx，欢迎光临”；如果用户不存在，在服务端显示“xxx尝试登录”，在客户端显示“xxx，该用户不存在”。
代码实现：

import java.io.*;
import java.net.*;
//客户端
class  LoginClient
{
	public static void main(String[] args) throws Exception
	{
		//创建服务
		Socket s=new Socket("localhost",10000);
		//键盘录入
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

		
		//用Socket服务输出流写入数据
		PrintWriter out =new PrintWriter(s.getOutputStream(),true );

		//接收服务器返回的信息
		BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));

		String line=null;

		for(int x=0;x<3;x++)
		{
			line=br.readLine();//读取键盘录入
			if (line==null)
			{
				break;//如果键盘没有输入，则直接结束
			}

			out.println(line);//将数据写入流中

			String info=in.readLine();//读取返回信息

			System.out.println(info);

			if (info.contains("欢迎"))//---------------
			{
				break;//如果登录成功，就跳出循环
			}
		}

		br.close();//关流
		s.close();
	}
}

//服务端
class LoginServer
{
	public static void main(String [] args)throws Exception
	{
		//创建服务，监听端口
		ServerSocket ss=new ServerSocket(10000);
		
		while (true)
		{
			//获取客户端对象
			Socket s=ss.accept();
		
			//客户端执行线程
			new Thread(new LoginThread(s)).start();
		}
		
		//ss.close();
	}
}

//利用多线程实现并发登录
class LoginThread implements Runnable
{
	private Socket s;
	LoginThread(Socket s)
	{
		this.s=s;
	}
	public void run()
	{
		//获取客户端ip
		String ip=s.getInetAddress().getHostAddress();
		System.out.println(ip+"  connected.....");
		try
		{		
			for (int x=0;x<3 ;x++ )
			{	
				//通过客户端的读取流读取数据
				BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));
				
				//读取数据库中的数据，这里用文件来表示数据库
				BufferedReader br=new BufferedReader(new FileReader("users.txt"));

				String line=in.readLine();//读取客户端数据
				if (line==null)//--------------
				{
					break;//如果客户端没有发送数据，则跳出循环
				}
				String data=null;
				boolean flag=false;//设置标记
				//读取数据库中的用户数据
				while ((data=br.readLine())!=null)
				{
					if (line.equals(data))
					{
						flag=true;//如果用户存在，则将标记设为true
						break;
					}
				}

				//将数据写入到指定文件中
				PrintWriter out=new PrintWriter(s.getOutputStream(),true);

				if (flag)
				{
					System.out.println(line+",已登陆！");
					
					out.println(line+"，欢迎光临！");

					break;//-----------
				}
				else
				{
					System.out.println(line+",尝试登陆！");
					out.println(line+"，用户名不存在！");
				}	
			}
			s.close();//关流
		}
		catch (Exception e)
		{
			throw new RuntimeException("用户登陆失败");
		}	
	}
}

3.客户端和服务端的浏览器演示

浏览器是一个客户端，它可以对服务端发送过来的数据进行解析，把符合应用层协议的消息解析后，将头信息拆包，传送到应用层，只保留了正确的正文主题部分显示在浏览器上。
浏览器输入网址后，内部应答如下图：

示例：自定义服务器，用浏览器访问。

代码：

import java.io.*;
import java.net.*;

//服务器
class  ServerDemo
{
	public static void main(String[] args)throws Exception 
	{
		//创建服务，监听端口
		ServerSocket ss=new ServerSocket(10000);
		//获取客户端
		Socket s=ss.accept();
		//显示ip
		String ip=s.getInetAddress().getHostAddress();

		System.out.println(ip);
		//读取客户端读取流数据
		InputStream in=s.getInputStream();

		byte[] buf=new byte[1024];
		int len=in.read(buf);
		//显示数据
		System.out.println(new String(buf,0,len));
		//返回信息写入客户端输出流
		PrintWriter out=new PrintWriter(s.getOutputStream(),true);///true一定要记得写

		out.println("<font color='red' size='7'>客户端你好!</font>");

		s.close();//关流
		ss.close();
	}
}

4.URL和URLConnection

•   URL
      URI：范围更大，条形码也包含在这个范围。
      URL：范围较小，即域名

方法：
      1）构造函数：URL(String protocol,Stringhost,int port,String file);//根据指定protocol、host、port号和file创建
                             URL对象。
      2）String getProtocol();//获取协议名称
      3）String getHost();//获取主机名
      4）int getPort();//获取端口号
      5）String getFile();//获取URL文件名
      6）String getPath();//获取此URL的路径部分
      7）String getQuery();//获取此URL的查询部，客户端传输的特定信息
   注：一般输入网址，是不带端口号的，此时可进行获取，通过获取网址返回的port，若port为-1，则分配一个默认
       的80端口，如
int port =getPort();
if(port == -1)
port = 80;
• URLConnection
   方法：
       1）URLConnection openConnection();//用URL调用此方法，返回一个URLConnection对象，它表示到URL 所引
       用的远程对象的连接。
      2）InputStream getInputStream();//获取输入流
      3）OutputStream getOutputStream();//获取输出流

/*
自定义浏览器，显示网页信息
*/

import java.io.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;

class MyIEGUIDemo
{
	//定义所需组件引用
	private Frame f;
	private Button but,bok;
	private TextField tf;
	private TextArea ta;

	//构造函数
	MyIEGUIDemo()
	{
		init();
	}

	//窗体基本设置于功能实现
	public void init()
	{
		//组件实例化
		f=new Frame("我的Window");
		but=new Button("跳转");
		tf=new TextField(50);
		ta=new TextArea(25,60);

		//基本设置
		f.setBounds(300,150,500,500);
		f.setLayout(new FlowLayout());

		//添加组件
		f.add(tf);
		f.add(but);
		f.add(ta);

		//窗体事件
		myEvent();

		//窗体显示
		f.setVisible(true);
	}

	//注册事件
	public void myEvent()
	{
		//窗体关闭功能
		f.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
				System.exit(0);
			}
		});

		//“跳转”按钮事件
		but.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				showFile();//显示网页内容在文本区中
			}
		});

		

		//文本框键盘事件
		tf.addKeyListener(new KeyAdapter()
		{
			public void keyPressed(KeyEvent e)
			{
				//如果键盘按下Enter键，就将网页内容显示在文本区中
				if(e.getKeyCode()==KeyEvent.VK_ENTER)
					showFile();
			}
		});
	}

	//显示网页内容
		private void showFile()
		{
			ta.setText("");
			String path=tf.getText();//获取输入的路径
			try
			{
				//封装地址对象
URL url =new URL(path);
连接网页服务器
				URLConnection conn=url.openConnection();
				//读取流，用于读取服务器返回数据
				InputStream in=conn.getInputStream();

				byte[] buf=new byte[1024*1024];

				int len=in.read(buf);
				//将数据显示在文本区中
				ta.append(new String(buf,0,len));
			}
			catch (Exception e)
			{
				throw new RuntimeException("连接"+path+"网站失败");
			}
		}

	public static void main(String[] args) 
	{
		//运行窗体
		new MyIEGUIDemo();
	}
}