网络通信原理与实践-优快云博客

本文链接：https://blog.youkuaiyun.com/joshchen0805/article/details/41053649

本文详细介绍了网络通信的基本原理，包括IP地址、端口号、传输协议等关键概念，并通过实例展示了如何利用Java进行UDP和TCP通信的具体实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

概述

网络应用程序通信原理，如图，每台网络设备有一个IP地址，每个应用程序有一个端口

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

IP地址

网络中设备的标识

不易记忆，可用主机名

本地回环地址：127.0.0.1，主机名：localhost，可以ping它来测试网卡

子网掩码：划分小区公用一个公网IP地址，小区内使用局域网地址

端口

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

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

MySQL：3306、Tomcat：8080

一个网络应用程序有多个标识，一个被占用，启动另一个

传输协议

通讯的规则

常见协议：UDP、TCP

网络模型

OSI参考模型与TCP/IP参考模型

由上至下：数据封包，由下至上：数据拆包

应用层最常见协议是HTTP和FTP

传输层最常见协议是TCP和UDP

网际层最常见协议是IP

IP地址

InetAddress类

import java.net.*;//导入net包
class  IPDemo
{
	public static void main(String[] args) throws Exception
	{
		//InetAddress i = InetAddress.getLocalHost();//通过静态方法获取对象，会抛出未知主机异常

//		System.out.println(i.toString());//打印本机的主机名和地址
//		System.out.println("address:"+i.getHostAddress());
//		System.out.println("name:"+i.getHostName());

		InetAddress ia = InetAddress.getByName("thinkpad-sl400");//返回任意一台主机的IP对象，参数也可以是IP地址
		System.out.println("address:"+ia.getHostAddress());//以此为主，因为主机名还需要解析
		System.out.println("name:"+ia.getHostName());
	}
}

InetAddress ia = InetAddress.getByName("www.baidu.com");//可以获取百度主机IP对象，

有可能返回的IP对象不唯一，因为百度有多台主机服务器，此时用到下列方法

static InetAddress [ ] getAllByName(String host)

TCP和UDP特点介绍

UDP

将数据、源、目的封装在数据包中，不需要建立连接
每个数据包的大小限制在64k内
因无连接，是不可靠协议
不需要建立连接，速度快

类似对讲机

对方不在，包丢掉

应用：聊天、视频会议、桌面共享

TCP

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

类似电话

三次握手确认对方都知道对方的存在

应用：下载

Socket

Socket就是为网络服务提供的一种机制
通信的两端都先有Socket
网络通信其实就是Socket通信
数据在两个Socket间通过IO传输

UDP传输

UDP的socket服务该怎么去建立呢？

发送端

/*
需求：通过udp传输方式，将一段文字数据发送出去。，
定义一个udp发送端。
思路：
1，建立updsocket服务。
2，提供数据，并将数据封装到数据包中。
3，通过socket服务的发送功能，将数据包发出去。
4，关闭资源。
*/
class  UdpSend
{
	public static void main(String[] args) throws Exception
	{
		//1，创建udp服务。通过DatagramSocket对象。指定发送端端口号为8888，没有指定系统随机分配
		DatagramSocket ds = new DatagramSocket(8888);

		//2，确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port)参数列表为：数据包，长度，目的地址，端口号 

		byte[] buf = "udp ge men lai le ".getBytes();
		DatagramPacket dp = 
			new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),10000);//用主机测试时这里的IP地址会改变

		//3，通过socket服务，将已有的数据包发送出去。通过send方法。
		ds.send(dp);

		//4，关闭资源。
		ds.close();
	}
}

因为是面向无连接，如果单独运行该程序，接收端没有开，数据包会丢失

接收端

为了能够在一个控制台看到运行效果，将发送端程序和接收端程序都写在一个java文件中（注意此时class都没有public修饰），在dos命令行中输入start开启一个新的窗口

/*
需求：
定义一个应用程序，用于接收udp协议传输的数据并处理的。

定义udp的接收端。
思路：
1，定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。
	方便于明确哪些数据过来该应用程序可以处理。
2，定义一个数据包，因为要存储接收到的字节数据。
因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
3，通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
4，通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
5，关闭资源。
*/
class  UdpRece
{
	public static void main(String[] args) throws Exception
	{
		//1,创建udp socket，建立端点。定义了一个10000端口
		DatagramSocket ds = new DatagramSocket(10000);
		while(true)//接收端一直开启，放在这里避免BindException，将上面的语句包括进来会重复使用同一个端口，因为端口服务建立一次就好，不要循环建立
		{
		//2,定义数据包。用于存储数据。参数列表有固定格式
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);

		//3，通过服务的receive方法将收到数据存入数据包中。
		ds.receive(dp);//阻塞式方法。		

		//4，通过数据包的方法获取其中的数据。
		String ip = dp.getAddress().getHostAddress();

		String data = new String(dp.getData(),0,dp.getLength());

		int port = dp.getPort();//获取发送端应用程序的端口号

		System.out.println(ip+"::"+data+"::"+port);

		}
		//5，关闭资源
		//ds.close();
	}
}

键盘录入方式发送数据

与IO技术结合

192.168.1.0：代表一个网络地址段

192.168.1.255：代表该网络段的广播地址，当找一个主机地址没找到时就发广播给所有地址

import java.net.*;
import java.io.*;//只要用到net包，通常都会用到io包
class  UdpSend2
{
	public static void main(String[] args) throws Exception
	{
		DatagramSocket ds = new DatagramSocket();

		BufferedReader bufr = 
			new BufferedReader(new InputStreamReader(System.in));//读取键盘录入的标准语句

		String line = null;

		while((line=bufr.readLine())!=null)//因为数据量大，所以用到循环
		{
			if("886".equals(line))
				break;

			byte[] buf = line.getBytes();//定义一个刚好装下读到的一行数据的缓冲区

			DatagramPacket dp = 
				new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10001);//采用了广播地址

			ds.send(dp);
		}
		ds.close();
	}
}

class  UdpRece2
{
	public static void main(String[] args) throws Exception
	{
		DatagramSocket ds = new DatagramSocket(10001);

		while(true)
		{
			byte[] buf = new byte[1024];
			DatagramPacket dp = new DatagramPacket(buf,buf.length);

			ds.receive(dp);

			String ip = dp.getAddress().getHostAddress();
			String data = new String(dp.getData(),0,dp.getLength());//获取数据，定义好数据的长度

			System.out.println(ip+"::"+data);
		}
	}
}

聊天

与多线程技术结合使用，不开两个dos窗口

/*
编写一个聊天程序。
有收数据的部分，和发数据的部分。
这两部分需要同时执行。
那就需要用到多线程技术。
一个线程控制收，一个线程控制发。

因为收和发动作是不一致的，所以要定义两个run方法。
而且这两个方法要封装到不同的类中。
*/
import java.io.*;
import java.net.*;
class Send implements Runnable
{
	private DatagramSocket ds;
	public Send(DatagramSocket ds)//发送的时候要用哪一个socket不确定，所以在发送端在构造时就传一个指定的socket进来
	{
		this.ds = ds;
	}

	public void run()
	{
		try
		{
			BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

			String line = null;

			while((line=bufr.readLine())!=null)
			{
				byte[] buf = line.getBytes();

				DatagramPacket dp = 
					new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10002);

				ds.send(dp);

				if("886".equals(line))
					break;
			}
		}
		catch (Exception e)
		{
			throw new RuntimeException("发送端失败");
		}
	}
}

class Rece implements Runnable
{

	private DatagramSocket ds;
	public Rece(DatagramSocket ds)
	{
		this.ds = ds;
	}
	public void run()
	{
		try
		{
			while(true)
			{
				byte[] buf = new byte[1024];
				DatagramPacket dp = new DatagramPacket(buf,buf.length);
				ds.receive(dp);
				String ip = dp.getAddress().getHostAddress();
				String data = new String(dp.getData(),0,dp.getLength());
				if("886".equals(data))
				{
					System.out.println(ip+"....离开聊天室");
					break;
				}
				System.out.println(ip+":"+data);
			}
		}
		catch (Exception e)
		{
			throw new RuntimeException("接收端失败");
		}
	}
}

class  ChatDemo
{
	public static void main(String[] args) throws Exception
	{
		DatagramSocket sendSocket = new DatagramSocket();
		DatagramSocket receSocket = new DatagramSocket(10002);

		new Thread(new Send(sendSocket)).start();
		new Thread(new Rece(receSocket)).start();
	}
}

TCP传输

Socket和ServerSocket
建立客户端和服务器端（UDP是发送端和接收端）
建立连接后，通过Socket中的IO流进行数据的传输
关闭Socket
同样，客户端和服务器端是两个独立的应用程序

客户端一建立就要连接服务端

空参数的Socket客户端构造函数通过connect来连接到指定的服务端

/*
演示tcp传输。
1,tcp分客户端和服务端。
2，客户端对应的对象是Socket。
	服务端对应的对象是ServerSocket
*/
/*
客户端，
通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机。
因为tcp是面向连接的。所以在建立socket服务时，
就要有服务端存在，并连接成功。形成通路后，在该通道进行数据的传输。

需求：给服务端发送给一个文本数据。

步骤：
1，创建Socket服务。并指定要连接的主机和端口。

*/
import java.io.*;
import java.net.*;
class  TcpClient
{
	public static void main(String[] args) throws Exception 
	{
		//创建客户端的socket服务。指定目的主机和端口，一旦创建，就会有输入和输出的流对象
		Socket s = new Socket("192.168.1.254",10003);
		
		//为了发送数据，应该获取socket流中的输出流。
		OutputStream out = s.getOutputStream();

		out.write("tcp ge men lai le ".getBytes());

		s.close();//流封装在Socket中，所以只需要关闭Socket
	}
}
/*
需求：定义端点接收数据并打印在控制台上。
服务端:
1，建立服务端的socket服务。ServerSocket();
	并监听一个端口。
2，获取连接过来的客户端对象。
	通过ServerSokcet的 accept方法。没有连接就会等，所以这个方法阻塞式的。
3，客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。
	并打印在控制台。因为服务端需要连接端个客户端
4，关闭服务端。（可选）
*/
class  TcpServer//先运行服务端监听客户端
{
	public static void main(String[] args) throws Exception
	{
		//建立服务端socket服务。并监听一个端口。
		ServerSocket ss = new ServerSocket(10003);

		//通过accept方法获取连接过来的客户端对象。当需要被多个客户端访问时，就使用无线循环，不断获取客户端对象
		while(true)
		{
		Socket s = ss.accept();//拿到客户端对象

		String ip = s.getInetAddress().getHostAddress();//获取客户端的IP地址对象并获取IP字符串
		System.out.println(ip+".....connected");

		//获取客户端发送过来的数据，那么要使用客户端对象的输入流来读取数据。
		InputStream in = s.getInputStream();//该源是网络流
		
		byte[] buf = new byte[1024];
		int len = in.read(buf);

		System.out.println(new String(buf,0,len));

		s.close();//关闭客户端.
		}
		//ss.close();关闭服务端，可选
	}
}

/*
演示tcp的传输的客户端和服务端的互访。
需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。
*/
/*
客户端：
1，建立socket服务。指定要连接主机和端口。
2，获取socket流中的输出流。将数据写到该流中。通过网络发送给服务端。
3，获取socket流中的输入流，将服务端反馈的数据获取到，并打印。
4，关闭客户端资源。
*/
class TcpClient2 
{
	public static void main(String[] args)throws Exception 
	{
		Socket s = new Socket("192.168.1.254",10004);
		
		OutputStream out = s.getOutputStream();

		out.write("服务端，你好".getBytes());
		
		InputStream in = s.getInputStream();

		byte[] buf = new byte[1024];

		int len = in.read(buf);//read方法阻塞式方法，如果服务端数据还没发送，read方法会等在这里

		System.out.println(new String(buf,0,len));

		s.close();
	}
}

class TcpServer2
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10004);

		Socket s = ss.accept();

		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....connected");
		InputStream in = s.getInputStream();

		byte[] buf = new byte[1024];

		int len = in.read(buf);

		System.out.println(new String(buf,0,len));

		OutputStream out = s.getOutputStream();

		Thread.sleep(10000);//让线程等待，延迟向客户端发送数据，客户端的read方法会等待
		out.write("哥们收到,你也好".getBytes());

		s.close();

		ss.close();
	}
}

应用1：文本转换服务器

/*
需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。
而且客户度可以不断的进行文本转换。当客户端输入over时，转换结束。

分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入。
目的：网络设备，网络输出流。
而且操作的是文本数据。可以选择字符流。

步骤
1，建立服务。
2，获取键盘录入。
3，将数据发给服务端。
4，后去服务端返回的大写数据。
5，结束，关资源。

都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。
*/
import java.io.*;
import java.net.*;

class  TransClient
{
	public static void main(String[] args) throws Exception
	{
		Socket s = new Socket("192.168.1.254",10005);

		//定义读取键盘数据的流对象。
		BufferedReader bufr = 
			new BufferedReader(new InputStreamReader(System.in));

		//定义目的，将数据写入到socket输出流。发给服务端。
		//BufferedWriter bufOut = 
			//new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);//简化：PrintWriter既能接受字节流又能接受字符流，还能自动刷新

		//定义一个socket读取流，读取服务端返回的大写信息。
		BufferedReader bufIn = 
			new BufferedReader(new InputStreamReader(s.getInputStream()));

		String line = null;
		
		while((line=bufr.readLine())!=null)//这里的readLine读取的是键盘的数据
		{
			if("over".equals(line))
				break;
			
			out.println(line);//打印流使用println方法将数据写入流中，并带换行
//			bufOut.write(line);
//			bufOut.newLine();//结束标记，用于读键盘用，和读取文件数据不同，读取文件要自定义结束标记
//			bufOut.flush();

			String str =bufIn.readLine();//这里的ReadLine读取的是Socket输入流的数据，和上面的都在循环体内
			System.out.println("server:"+str);
			
		}
		bufr.close();//bufr需要单独关闭，因为它与Socket无关
		s.close();//输入“over”，循环结束，Socket关闭，客户端关闭，还会在Socket流里面加入-1结束标记，告诉服务端，退出循环，导致服务端也会关闭
	}
}
/*
服务端：
源：socket读取流。
目的：socket输出流。
都是文本，装饰。
*/
class  TransServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10005);

		Socket s = ss.accept();//服务端一旦与客户端连接就会一直进行下去，所以不能放进循环体中
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....connected");

		//读取socket读取流中的数据。
		BufferedReader bufIn =
			new BufferedReader(new InputStreamReader(s.getInputStream()));

		//目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。
		//BufferedWriter bufOut = 
			//new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

		PrintWriter out = new PrintWriter(s.getOutputStream(),true);

		String line = null;
		while((line=bufIn.readLine())!=null)
		{

			System.out.println(line);

			out.println(line.toUpperCase());
//			bufOut.write(line.toUpperCase());
//			bufOut.newLine();//加入回车符
//			bufOut.flush();//因为数据写到了缓冲区里，所以要刷新才能发出去
		}

		s.close();
		ss.close();
	}
}
/*
该例子出现的问题。
现象：客户端和服务端都在莫名的等待。
为什么呢？
因为客户端和服务端都有阻塞式方法。这些方法没有读到结束标记，即回车符。也就是说客户端发出的数据里面没有写入回车符，而readLine方法判断的是回车标记，那么就一直等
而导致两端，都在等待。就查阻塞时方法
*/

技巧：如果程序没有正常运行，可以通过在代码之间加入打印语句来debug，看程序运行到哪里停止了

应用2：复制文件至服务端

客户端发完数据应该告诉服务端一个结束标记

三种结束标记

自定义结束标记。比如客户端在发数据之前向服务端发送字符串“over”，然后在服务端获取自定义标记后进行判断。局限性：所传送的文本可能与自定义结束标记重复
时间戳。时间是唯一的。考虑到时间的数据类型是long，考虑使用DataOutputStream 和DataInputStream类操作。但是使用的流对象过多。
Socket对象的shutdownOutput()方法。关闭客户端的输出流。相当于给流中加入一个结束标记-1.这样服务端readLine方法就能结束循环了

import java.io.*;
import java.net.*;
class  TextClient
{
	public static void main(String[] args) throws Exception
	{
		Socket s = new Socket("192.168.1.254",10006);//可以单独捕获异常

		BufferedReader bufr = new BufferedReader(new FileReader("IPDemo.java"));

		PrintWriter out = new PrintWriter(s.getOutputStream(),true);

		//第二种结束标记：使用DataInputStream和DataOutputStream来操作时间的Long类型数据
		//DataOutputStream dos = new DataOutputStream(s.getOutputStream());
		//long time = System.currentTimeMillis();
		//dos.writeLong(time);

		String line = null;
		while((line=bufr.readLine())!=null){
			out.println(line);
		} 
		//out.println("over");//第一种标记结束方式（否则服务端会一直等待）：自定义结束标记，然后服务端判断标记“over”，可是万一文件里面有over数据就会在那里结束，可以改用定义时间戳，因为时间戳唯一。
		//out.writeLong(time);//数据传输结束，再向服务端写入原时间戳
		s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1.这样服务端readLine方法就能结束循环了
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
		String str = bufIn.readLine();
		System.out.println(str);
		bufr.close();
		s.close();
	}
}

class TextServer{
	public static void main(String[] args) throws Exception{
		ServerSocket ss = new ServerSocket(10006);
		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....connected");

		//第二种结束标记：服务端读取客户端传来的时间戳
		//DataInputStream dis = new DataInputStream(s.getInputStream());
		//long time = dis.readLong();

		BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
		PrintWriter out = new PrintWriter(new FileWriter("server.txt"),true);//一执行，文件就产生了。实际中应该先获取文件名，如果有重名文件则加数字标记
		String line = null;
		while((line=bufIn.readLine())!=null)//如果不加结束标记，服务端会一直等在这里接收数据
		{
			//if("over".equals(line))//或者对时间戳进行判断：if(time.equals(line))
			//break;
			out.println(line);
		}
		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		pw.println("上传成功");
		out.close();
		s.close();
		ss.close();
	}
}

应用3：上传图片

注意判断结束标记

并发上传图片

/*
需求：并发上传图片。
*/
/*
客户端。
1，服务端点。
2，读取客户端已有的图片数据。
3，通过socket 输出流将数据发给服务端。
4，读取服务端反馈信息。
5，关闭。
*/
import java.io.*;
import java.net.*;
class  PicClient
{
	public static void main(String[] args)throws Exception 
	{
		if(args.length!=1)//只能传入一个参数
		{
			System.out.println("请选择一个jpg格式的图片");
			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)//超过5M的图片拒绝
		{
			System.out.println("文件过大，没安好心");
			return ;
		}
		
		Socket s = new Socket("192.168.1.254",10007);//与该主机的10007端口建立连接

		FileInputStream fis = new FileInputStream(file);

		OutputStream out = s.getOutputStream();

		byte[] buf = new byte[1024];

		int len = 0;

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

		//告诉服务端数据已写完
		s.shutdownOutput();

		InputStream in = s.getInputStream();

		byte[] bufIn = new byte[1024];

		int num = in.read(bufIn);
		System.out.println(new String(bufIn,0,num));

		fis.close();
		s.close();
	}
}
/*
服务端
适应单线程的服务端有个局限性。当A客户端连接上以后。被服务端获取到。服务端执行具体流程。
这时B客户端连接，只有等待。
因为服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法。所以
暂时获取不到B客户端对象。

那么为了可以让多个客户端同时并发访问服务端。
那么服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。

如何定义线程呢？
只要明确了每一个客户端要在服务端执行的代码即可。将该代码存入run方法中。
*/
class PicThread implements Runnable
{
	private Socket s;
	PicThread(Socket s)
	{
		this.s = s;
	}
	public void run()
	{

		int count = 1;//计数器不能定义为成员变量，因为多个线程就会共享该数据了
		String ip  = s.getInetAddress().getHostAddress();
		try
		{
			System.out.println(ip+"....connected");

			InputStream in = s.getInputStream();

			File dir =  new File("d:\\pic");

			File file = new File(dir,ip+"("+(count)+")"+".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+"上传失败");
		}
	}
}
class  PicServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10007);//这里监听的是自己的10007端口

		while(true)//接受一个客户端就创建一个线程，accept方法是阻塞方法，所以要使用循环
		{
			Socket s = ss.accept();

			new Thread(new PicThread(s)).start();
		}

		//ss.close();
	}
}

应用4：客户端并发登录

/*
客户端通过键盘录入用户名。
服务端对这个用户名进行校验。

如果该用户存在，在服务端显示xxx，已登陆。
并在客户端显示 xxx，欢迎光临。

如果该用户不存在，在服务端显示xxx，尝试登陆。
并在客户端显示 xxx，该用户不存在。

最多就登录三次。
*/
import java.io.*;
import java.net.*;


class  LoginClient
{
	public static void main(String[] args) throws Exception
	{
		Socket s = new Socket("192.168.1.254",10008);

		BufferedReader bufr = 
			new BufferedReader(new InputStreamReader(System.in));

		PrintWriter out = new PrintWriter(s.getOutputStream(),true);

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


		for(int x=0; x<3; x++)
		{
			String line = bufr.readLine();
			if(line==null)//如果用户输入ctrl+c，则退出
				break;
			out.println(line);

			String info = bufIn.readLine();
			System.out.println("info:"+info);
			if(info.contains("欢迎"))//如果返回的字符串包含该字样，结束登陆
				break;

		}

		bufr.close();
		s.close();
	}
}


class UserThread implements Runnable
{
	private Socket s;
	UserThread(Socket s)
	{
		this.s = s;
	}
	public void run()
	{
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....connected");
		try
		{
			for(int x=0; x<3; x++)
			{
				BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));

				String name = bufIn.readLine();
				if(name==null)//当客户端输入ctrl+c后，name会为null，所以此时要跳出循环
					break;

				BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));//该文件记录了登陆的用户名

				PrintWriter out = new PrintWriter(s.getOutputStream(),true);

				String line = null;

				boolean flag = false;//技巧：要把循环后的结果记录，所以要定义一个标记
				while((line=bufr.readLine())!=null)
				{
					if(line.equals(name))
					{
						flag = true;
						break;
					}				
				}
				
				if(flag)
				{
					System.out.println(name+",已登录");
					out.println(name+",欢迎光临");
					break;
				}
				else
				{
					System.out.println(name+",尝试登录");
					out.println(name+",用户名不存在");
				}
			}
			s.close();
		}
		catch (Exception e)
		{
			throw new RuntimeException(ip+"校验失败");
		}
	}
}
class  LoginServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10008);

		while(true)
		{
			Socket s = ss.accept();

			new Thread(new UserThread(s)).start();
		}
	}
}

自定义服务端和客户端

自定义服务端

客户端：浏览器或 telnet
服务端：自定义。

import java.net.*;
import java.io.*;
class ServerDemo 
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(11000);

		Socket s = ss.accept();
		System.out.println(s.getInetAddress().getHostAddress());

		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);

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

		s.close();

		ss.close();
	}
}

通过浏览器访问自定义的服务器或Tomcat服务器，输入IP : 端口号
通过telnet访问自定义服务器或者Tomcat服务器

telnet为windows里面的远程登陆工具，可以连接网络中的任意一台主机，对主机进行命令式的配置，是一个客户端软件，在cmd下输入telnet IP 端口号。

Tomcat服务端

客户端：浏览器。
服务端：Tomcat服务器。

Tomcat默认端口是8080

自定义浏览器客户端

自定义浏览器客户端程序，并向自定义的服务端发送请求

import java.io.*;
import java.net.*;
class MyIE 
{
	public static void main(String[] args)throws Exception 
	{
		Socket s = new Socket("192.168.1.254",8080);
		
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);

		out.println("GET /myweb/demo.html HTTP/1.1");//将请求写死（一般浏览器有地址栏）
		out.println("Accept: */*");//*/*代表除了前面的格式剩下的都支持
		out.println("Accept-Language: zh-cn");
		out.println("Host: 192.168.1.254:11000");
		out.println("Connection: closed");
		out.println();//一定要写空行，将请求头和请求体分开
		out.println();
                //获取HTTP相应消息头 其中响应状态码200代表请求成功
		BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));

		String line = null;

		while((line=bufr.readLine())!=null)
		{
			System.out.println(line);
		}

		s.close();
	}
}
/*此为非自定义浏览器发送的请求数据
http://192.168.1.254:11000/myweb/demo.html
//此为请求头信息
GET /myweb/demo.html HTTP/1.1 ()
Accept: application/x-shockwave-flash, image/gif, image/x-xbitmap, image/jpeg, i
mage/pjpeg, application/vnd.ms-excel, application/vnd.ms-powerpoint, application
/msword, application/QVOD, application/QVOD,
Accept-Language: zh-cn
Accept-Encoding: gzip, deflate(支持的压缩格式)
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0
.50727)
Host: 192.168.1.254:11000
Connection: Keep-Alive
                            (这里是区分请求头和请求体的空行，必须要！)

*/

服务端还会给客户端发送响应头信息

自定义图形界面浏览器

客户端：自定义。(图形界面)
服务端：Tomcat服务器。

官方浏览器里面挂了很多解析引擎（html，javascript，css等），自定义没有，无法对数据进行解析

不使用URL

获取传输层传送的数据，获取服务器返回的所有数据并把数据展示在文本区，包括响应头，使用URLConnection可以不包括响应头：

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
class  MyIEByGUI
{
	private Frame f;
	private TextField tf;
	private Button but;
	private TextArea ta;
	
	private Dialog d;
	private Label lab;
	private Button okBut;

	MyIEByGUI()
	{
		init();
	}
	public void init()
	{
		f = new Frame("my window");
		f.setBounds(300,100,600,500);
		f.setLayout(new FlowLayout());

		tf = new TextField(60);

		but = new Button("转到");

		ta = new TextArea(25,70);

		d = new Dialog(f,"提示信息-self",true);
		d.setBounds(400,200,240,150);
		d.setLayout(new FlowLayout());
		lab = new Label();
		okBut = new Button("确定");

		d.add(lab);
		d.add(okBut);

		f.add(tf);
		f.add(but);
		f.add(ta);

		myEvent();
		f.setVisible(true);
	}
	private void  myEvent()
	{

		okBut.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				d.setVisible(false);
			}
		});
		d.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
				d.setVisible(false);
			}
		});

		tf.addKeyListener(new KeyAdapter()
		{
			public void keyPressed(KeyEvent e)
			{
				try
				{
						if(e.getKeyCode()==KeyEvent.VK_ENTER)
					showDir();
				}
				catch (Exception ex)
				{
				}
			
			}
		});


		but.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				try
				{
					showDir();
				}
				catch (Exception ex)
				{
				}
			}
		});

		f.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
				System.exit(0);	
			}
		});
	}

	private void showDir()throws Exception
	{

		ta.setText("");//每调用一次就清空一次text area
		String url = tf.getText();//http://192.168.1.254:8080/myweb/demo.html
		//对获取的url字符串进行切割获取数据
		int index1 = url.indexOf("//")+2;

		int index2 = url.indexOf("/",index1);

		String str = url.substring(index1,index2);
		String[] arr = str.split(":");
		String host = arr[0];
		int port = Integer.parseInt(arr[1]);

		String path = url.substring(index2);
		//ta.setText(str+"...."+path);

		Socket s = new Socket(host,port);
		
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);

		out.println("GET "+path+" HTTP/1.1");
		out.println("Accept: */*");
		out.println("Accept-Language: zh-cn");
		out.println("Host: 192.168.1.254:11000");
		out.println("Connection: closed");

		out.println();
		out.println();

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

		String line = null;

		while((line=bufr.readLine())!=null)
		{
			ta.append(line+"\r\n");
		}

		s.close();

	}

	public static void main(String[] args) 
	{
		new MyIEByGUI();
	}
}

使用URL对象的代码

private void showDir()throws Exception
	{
		ta.setText("");
		String urlPath = tf.getText();//http://192.168.1.254:8080/myweb/demo.html
		
		URL url = new URL(urlPath);

		URLConnection conn = url.openConnection();
		
		InputStream in = conn.getInputStream();

		byte[] buf = new byte[1024];

		int len = in.read(buf);

		ta.setText(new String(buf,0,len));

	}

使用URL对象

URL：统一资源定位符

URI的范围比URL大，比如包括条形码

如果没有找到已有的可以用来解析URL地址的对象就应该自己写一个

net包中有一个URL对象

/*
 String getFile() 
          获取此 URL 的文件名。 
 String getHost() 
          获取此 URL 的主机名（如果适用）。 
 String getPath() 
          获取此 URL 的路径部分。 
 int getPort() 
          获取此 URL 的端口号。 
 String getProtocol() 
          获取此 URL 的协议名称。 
 String getQuery() 
          获取此 URL 的查询部 
*/
import java.net.*;
class URLDemo 
{
	public static void main(String[] args) throws MalformedURLException//该异常因为传入的字符串不符合URL规则
	{
		URL url = new URL("http://192.168.1.254/myweb/demo.html?name=haha&age=30");//加入了请求参数，用问号分隔，用&传多个参数


		System.out.println("getProtocol() :"+url.getProtocol());
		System.out.println("getHost() :"+url.getHost());
		System.out.println("getPort() :"+url.getPort());
		System.out.println("getPath() :"+url.getPath());
		System.out.println("getFile() :"+url.getFile());//会带着后面的请求参数
		System.out.println("getQuery() :"+url.getQuery());//取得请求参数

		/*int port = url.getPort();//如果没有传端口号，则该方法会返回-1，此时为port指定默认端口80
		if(port==-1)
			port = 80;
		*/
	}
}

URLConnection对象

该对象代表一个远程连接，有HTTP和JAR两种协议

Socket的编程在传输层，使用URLConnection是在应用层，因为带着协议，可以给传输层的数据拆包，因此使用它获取的数据没有响应头

import java.net.*;
import java.io.*;
class  URLConnectionDemo
{
	public static void main(String[] args) throws Exception
	{
		URL url = new URL("http://192.168.1.254:8080/myweb/demo.html");

		URLConnection conn = url.openConnection();//使用URL对象的openConnection方法连接到该URL而不用写Socket了
		System.out.println(conn);
		
		InputStream in = conn.getInputStream();//openStream是其简写形式

		byte[] buf = new byte[1024];

		int len = in.read(buf);

		System.out.println(new String(buf,0,len));
	}
}

小知识点

空参构造函数Socket ( )会使用void connect(SocketAddress endpoint)方法连接到服务器，抽象类SocketAddress类下的InetSocketAddress封装的是IP地址+端口号，而InetAddress封装的是IP地址，所以分开写Socket(InetAddress address, int port)
构造函数ServerSocket (int port, int backlog)，backlog是队列的最大长度，也就是能同时连接到服务器的客户端的最大个数。因为同时在线太多会死机