黑马程序员——Java基础---网络编程

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

第一讲   概述

1、网络模型：OSI参考模型和TCP/IP参考模型。

网络参考模型：

一般来讲开发处于传输层和网际层，应用层为：FTTP和HTTP协议等。传输层：UDP和TCP等。网际层：IP。

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

图例：

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

1）IP地址：

a、网络中设备的标识。

b、不易记忆，可用主机名。

c、本地回环地址：127.0.0.1 主机名：localhost。

IP地址：java中对应InetAddress类，存在于java.net包中。

InetAddress类：

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

InetAddress i = InetAddress.getLocalHost();

（二）方法：

1）static InetAddress getByName(String host);//获取指定主机的IP和地址名。

2）static InetAddress[] getAllByName(String host);//在给定主机名的情况下，根据系统上配置的名称服务返回其IP地址所组成的数组。返回对象不唯一时，用此方法。

3）String getHostAddress();//返回IP地址字符串文本格式，以IP地址为主。

4）String getHostName();//返回IP地址主机名。

（三）如何获取一台主机的IP地址对象

1）功能：返回InetAddress对象。

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

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

示例：

class IPDemo 
{
	public static void main(String[] args) 
	{
		InetAdderss i = InetAddress.getLocalHost();
		System.out.println(i.toString());
		String address = i.getHostAddress();
		String name = i.getHostName();
		System.out.println("address:"+address+"name:"+name)
		//获取指定主机名的IP信息
		InetAddress ia = InetAddress.getByName("192.168.1.24");
		
		String a = ia.getHostAddress();
		String n = ia.getHostName();
		System.out.println("address:"+a+"name"+n);
		//获取指定主机名的IP信息
		InetAddress[] sina = InteAddress.getAllByName(www.sina.com.cn);
		for(InetAddress s : sina)
		{
			String sAddress = s.getHostAddress();
			String sName = s.getHostName();
			System.out.println("sinaIP:"+sAddress+"sinaName:"+sName);
		}
		
	}
}

2）端口号：

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

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

3）传输协议：

a、通讯的规则。

b、常见协议：TCP，UDP。

UDP

是面向无连接的，明确了对方的端口，无论对方在不在只管传输，不在就丢失数据，只求速度，应用于网络视频会议聊天等应用程序中。

协议特点：

a、将数据及源和目的封装成数据包中，不需要建立连接。

b、每个数据报的大小在限制在64k内。

c、因无连接，是不可靠协议。

d、不需要建立连接，速度快。

TCP

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

协议特点：

a、建立连接，形成传输数据的通道。

b、在连接中进行大数据量传输。

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

d、必须建立连接，效率会稍低。

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

3、通信的步骤：

1）找到IP地址

2）数据要发送到对象指定应用程序。为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识，这个数字标识就叫做端口，也称逻辑端口。

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

第二讲   传输协议

一、Socket

1、形象的可称之为插座，是为网络服务提供的一种机制。

2、通信的两端都有Socket，才能建立服务。

3、网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。

二、UDP传输

1、通过DatagramSocket,此类表示用来发送和接受数据包的套接字。

2、方法：

1）创建UdpSocket发送服务对象

DatagramSocket，不指定端口。DatagramSocket(int port)，指定端口。

2）发送：void send(DatagramPacket p)。

3）接受：void receive(DatagramPacket p)。

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

3、步骤：

1）发送数据：

a、建立udpsocket服务，

b、提供数据，并将数据封装到数据包中。

c、通过socket服务的发送功能，将数据包发出去。

d、关闭资源。

2）接收数据：

a、定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。方便于明确哪些数据过来该应用程序可以处理。

b、定义一个数据包，因为要存储接收到的字节数据。因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。

c、通过socket服务的receive方法将收到的数据存入已定义好的数据包中。

d、通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。

e、关闭资源。

注意：

1、发送端和接收端是两个独立的运行程序。

2、在发送端，要在数据包对象中明确目的地IP和端口。

c、在接收端，要指定监听的端口。

示例：

/*
需求：通过udp传输方式，将一段文字数据发送出去。

*/
import java.net.*;

//定义一个udp发送端。
class  UdpSend
{
	public static void main(String[] args) throws Exception
	{
		//1，创建udp服务。通过DatagramSocket对象。
		DatagramSocket ds = new DatagramSocket(8888);

		//2，确定数据，并封装成数据包。
		//DatagramPacket(byte[] buf, int length, InetAddress address, int port) 

		byte[] buf = "udp i come in ".getBytes();
		DatagramPacket dp = 
			new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),10000);

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

		//4，关闭资源。

		ds.close();

	}
}

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

class  UdpRece
{
	public static void main(String[] args) throws Exception
	{
		//1,创建udp socket，建立端点。
		DatagramSocket ds = new DatagramSocket(10000);
		while(true)
		{
		//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();

	}
}

练习一

/*用键盘录入的方式来发送数据*/

import java.net.*;
import java.io.*;
//发送端
class  UdpSend
{
	public static void main(String[] args) throws Exception
	{	
		//创建udp服务。通过DatagramSocket对象。
		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);
			//通过socket服务，将已有的数据包发送出去。
			ds.send(dp);
		}
		//关闭资源
		ds.close();
	}
}


//接收端
class  UdpRece
{
	public static void main(String[] args) throws Exception
	{	
		//创建udp socket，建立端点
		DatagramSocket ds = new DatagramSocket(10001);
		//一直处于接收状态
		while(true)
		{	
			//定义数据包。用于存储数据
			byte[] buf = new byte[1024];
			DatagramPacket dp = new DatagramPacket(buf,buf.length);
			
			//通过服务的receive方法将收到数据存入数据包中
			ds.receive(dp);

			String ip = dp.getAddress().getHostAddress();
			
			//通过数据包的方法获取其中的数据
			String data = new String(dp.getData(),0,dp.getLength());
			
			System.out.println(ip+"::"+data);
		}
	}
}

练习二

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

因为收和发动作是不一致的，所以要定义两个run方法。
而且这两个方法要封装到不同的类中。

*/
import java.io.*;
import java.net.*;
//udp发送线程
class Send implements Runnable
{
	//定义socket服务引用
	private DatagramSocket ds;
	public Send(DatagramSocket ds)
	{
		this.ds = ds;
	}

	//复写run方法
	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);
				//通过socket服务，将已有的数据包发送出去
				ds.send(dp);

				if("886".equals(line))
					break;
			}
			//关闭资源
			ds.close();
		}
		catch (Exception e)
		{
			throw new RuntimeException("发送端失败");
		}
	}
}
//udp接收端线程
class Rece implements Runnable
{
	//定义socket服务引用
	private DatagramSocket ds;
	public Rece(DatagramSocket ds)
	{
		this.ds = ds;
	}
	//复写run方法
	public void run()
	{
		try
		{	//一直处于接收状态
			while(true)
			{
				//定义数据包。用于存储数据
				byte[] buf = new byte[1024];
				DatagramPacket dp = new DatagramPacket(buf,buf.length);
				//通过服务的receive方法将收到数据存入数据包中
				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);
			}
			//ds.close();关闭资源
		}
		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传输

1、TCP分为客户端和服务端。客户端对应Socket对象，服务端对应ServerSocket对象

2、方法：

1）创建客户端对象

Socket()：创建空参数的客户端对象，一般用于服务端接收数据

Socket(String host,int port )：指定要接受的IP地址和端口号

2）创建服务端对象

ServerSocket(int port)：指定接收的客户端的端口

3）Socket accept()：监听并接受到此套接字的连接。

4）void shutdownInput()：此套接字的输入流置于“流的末尾”。

5）void shutdownOutput()：禁用此套接字的输出流。

6）InputStream getInputStream()：返回此套接字的输入流。

7）OutputStream getOutputStream()：返回此套接字的输出流。

3、基本思路

客户端：

1）客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常。

2）连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，而Socket对象已经提供了输入流和输出流对象，通过getInputStream()和getOutputStream()获取即可。

3）与服务端通讯结束后，关闭Socket。

服务端：

1）服务端需要明确它要处理的数据是从哪个端口进入的。

2）当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象与客户端通过IO流进行数据传输。

3）当该客户端访问结束，关闭该客户端。

4、步骤

客户端：

通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机。因为tcp是面向连接的。所以在建立socket服务时，就要有服务端存在，并连接成功。形成通路后，在该通道进行数据的传输。

1）创建Socket服务。并指定要连接的主机和端口。通路一建立，就会产生Socket流（包括输入流和输出流），通过方法获取

2）为了发送数据，应该获取socket流中的输出流。如果要接收服务端的反馈信息，还需要获取Socket的输入流

3）通过输出流的write()方法将要发送的数据写入到流中

4）关闭Socket流资源

服务端：

 服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。需监听一个端口。

1）建立服务端socket服务。并监听一个端口。

2）获取连接过来的客户端对象。通过ServerSokcet的 accept方法。没有连接就会等，所以这个方法阻塞式的。

3）客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。并打印在控制台。

4）关闭服务端。（可选）

示例：

/*
客户端给服务端发送数据，服务端收到后，给客户端反馈信息


*/
//客户端
class TcpClient 
{
	public static void main(String[] args)throws Exception 
	{	
		//创建客户端的socket服务。指定目的主机和端口
		Socket s = new Socket("192.168.1.24",10000);
		//获取socket流中的输出流
		OutputStream out = s.getOutputStream();

		out.write("服务端，你好".getBytes());

		//获取Socket流中的输入流，用来接收服务端的反馈信息并打印 
		InputStream in = s.getInputStream();

		byte[] buf = new byte[1024];

		int len = in.read(buf);//读取反馈信息

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

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

//服务端
class TcpServer
{
	public static void main(String[] args) throws Exception
	{
		//建立服务端socket服务。并监听一个端口
		ServerSocket ss = new ServerSocket(10004);
		//通过accept方法获取连接过来的客户端对象
		Socket s = ss.accept();
		//获取客户端ip
		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();

		out.write("哥们收到,你也好".getBytes());
		//关闭资源
		s.close();

		ss.close();//可选
	}
}

练习一

/*

需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务端会将文本转成大写在返回给客户端。
而且客户端可以不断的进行文本转换。当客户端输入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);



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

		String line = null;
		
		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			
			out.println(line);
//			bufOut.write(line);
//			bufOut.newLine();
//			bufOut.flush();

			String str =bufIn.readLine();//读取返回的信息
			System.out.println("server:"+str);
			
		}

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


	}
}
/*

服务端：
源：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();

	}
}
/*
该例子出现的问题。
现象：客户端和服务端都在莫名的等待。
原因：
因为客户端和服务端都有阻塞式方法。这些方法么没有读到结束标记。那么就一直等
而导致两端，都在等待。
解决：需要用到刷新和换行的方式将写入和读取的数据从流中刷到内存中
	一、可用高效缓冲区类中的newLine()换行作为结束标记，用flush()刷新
	二、可用PrintOutputStream(s.getOutputStream(),true)创建输出流对象，true的作用是刷新。
*/

练习二

/*需求：向服务器上传一个文件，并返回上传成功信息
1、客户端：
源：硬盘上的文件
目的：网络设备，即网络输出流
2、服务端：
源：socket读取流
目的：socket输出流
*/

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

class  TextClient
{
	public static void main(String[] args) throws Exception
	{	//创建socket服务
		Socket s = new Socket("192.168.1.254",10006);
		//定义读取流读取文件数据
		BufferedReader bufr = 
			new BufferedReader(new FileReader("TcpDemo.java"));


		//定义目的，将数据写入到socket输出流，发给服务端
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);


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

		s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1.

		//定义一个socket读取流，读取服务端返回信息
		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
	{
		//建立服务端socket服务。并监听一个端口
		ServerSocket ss = new ServerSocket(10006);
		//通过accept方法获取连接过来的客户端对象
		Socket s = ss.accept();
		//获取客户端ip
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....connected");

		//读取socket读取流中的数据
		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))
				//break;
			out.println(line);
		}

		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		pw.println("上传成功");

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

	}
}

第三讲   应用

一、TCP客户端并发上传图片

1、单线程上传思路

客户端：

a、服务端点。

b、读取客户端已有的图片数据。

c、通过socket 输出流将数据发给服务端。

d、读取服务端反馈信息。

e、关闭。

服务端：

a、服务端服务，并监听窗口。

b、获取客户端对象，并获取客户ip。

c、读取客户端输入流数据。

d、写入文件。

e、用客户端输出流反馈信息。

f、关流。

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

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

如何定义线程呢？只要明确了每一个客户端要在服务端执行的代码即可。将该代码存入run方法中。

代码：

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)
		{
			System.out.println("文件过大，没安好心");
			return ;
		}
		


		//创建服务
		Socket s = new Socket("192.168.1.24",10007);
		//读取图片数据
		FileInputStream fis = new FileInputStream(file);
		//用socket服务输出流写入数据
		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();
	}
}
class  PicServer
{
	public static void main(String[] args) throws Exception
	{	//创建服务，监听端口
		ServerSocket ss = new ServerSocket(10007);
		while(true)
		{	
			//获取客户端对象
			Socket s = ss.accept();
		}
		new Thread(new PicThread(s)).start();
		
	}
}

//用多线程实现并发上传
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("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);

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

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

		
		}

		//ss.close();
	}
}

二、客户端并发登录

客户端通过键盘录入用户名。

服务端对这个用户名进行校验。

如果该用户存在，在服务端显示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));
		//用socket服务输出流写入数据
		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)
				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()
	{
		//获取客户端ip
		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)
					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();
		}
	}
}

三、客户端和服务端的浏览器演示

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

 而由于使用java编译是在传输层和网际层处理的，所以，会接受到全部的消息，包含了头消息。而浏览器处于应用层，已将发送来的头消息去除，只留下了主体信息。

1，
客户端：浏览器 (telnet)
服务端：自定义。
2，
客户端：浏览器。
服务端：Tomcat服务器。
3，
客户端：自定义。(图形界面)
服务端：Tomcat服务器。

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

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

四、URL和URLConnection

1、URL
URI：范围更大，条形码也包含于此范围
URL：范围较小，即域名

方法：

1）构造函数：URL(String protocol,String host,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;
2、URLConnection
方法：
        1）URLConnection openConnection();//用URL调用此方法，返回一个 URLConnection 对象，它表示到 URL 所引用的远程对象的连接。
        2）InputStream getInputStream();//获取输入流
        3）OutputStream getOutputStream();//获取输出流
示例：

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

class MyIEByGUIDemo 
{
	//定义所需组件引用
	private Frame f;
	private TextField tf;
	private Button but;
	private TextArea ta;
	
	//构造函数
	MyIEByGUIDemo()
	{
		init();
	}
	//窗体基本设置及功能实现
	public void init()
	{
		//组件实例化
		f = new Frame("my window");
		but = new Button("转到");
		tf = new TextField(30);
		ta = new TextArea(15,35);
		
		//基本设置
		f.setBounds(300,100,500,400);
		f.setLayout(new FlowLayout());

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

		myEvent();
		f.setVisible(true);
	}
	//注册事件
	private void myEvent()
	{	
		//窗体关闭功能
		f.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
			System.exit(0);
			}
		});
		//"转到"按钮事件
		but.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				try
				{
					showDir();//显示网页内容在文本区内
				}
				catch (Exception ex)
				{
					throw new RuntimeException("显示失败");
				}
				
			}
		});
		//文本框键盘事件
		tf.addKeyListener(new KeyAdapter()
		{	
			public void keyPressed(KeyEvent e)
			{
				try
				{
					if(e.getKeyCode()==KeyEvent.VK_ENTER)
					showDir();
				}
				catch (Exception ex)
				{
					throw new RuntimeException("显示失败");
				}
				
			}
		});
		
	}
	//显示网页内容
	private void showDir() throws Exception
	{
		ta.setText("");
		String path = tf.getText();//获取输入的路径
		
		//封装地址对象
		URL url = new URL(path);
		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));
	}
	
	public static void main(String[] args) 
	{
		new MyIEByGUIDemo();
	}
}

小知识点

1、Socket类的构造函数中，有一个空参数的构造函数：
        Socket()//通过系统默认类型的 SocketImpl创建未连接套接字对象
       可以通过connect(SocketAddress endpoint)方法来连接服务器。而SocketAddress是一个抽象类，它的子类InetSocketAddress实现了IP套接字地址（IP地址+端口号）。所以就可以连接到服务器了。
2、ServerSocket对象中的构造函数：
        ServerSocket(int port,int backlog)，其中的backlog表示队列的最大长度，即最多连入客户端的个数，即最大连接数。
3、在浏览器输入网址访问一台主机所做的操作：
       如输入http://61.135.169.125，可以直接连接此ip的主机，而我们一般是输入主机名：http:/www.baidu.ocm（百度主机对应的ip地址就是：61.135.169.125），那么此时浏览器做了什么操作呢？
       也就是说如何通过主机名获取IP地址，从而连接到这台主机呢？这就需要将主机名翻译成IP地址，即域名解析：DNS
       在进行访问的时候，会先在本地的hosts文件（c:\windows\system32\drivers\ext\host）中找对应的映射。若有，则直接返回请求；若无，则到公网的映射列表即DNS中找对应的映射，找到后，将主机名对应的IP地址返回给本机，本机通过这个IP地址找到对应的服务器。
示意图：

host应用：可屏蔽一些恶意网址，即将对应的映射关系写入hosts中，将IP地址改为本机的回环地址，那么会直接找到hosts，就不会将请求发送出去了。

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------