黑马程序员——Java语言基础——08.网络编程

------- android培训、java培训、期待与您交流！ ----------

本节考点：

一、 UDP和TCP的区别

二、TCP服务上传文件

1-1 网络编程概述

(1)网络模型
OSI参考模型：应用层、表示层、会话层、传输层、网络层、数据连接层、物理层
TCP/IP参考模型：应用层、传输层、网际层、主机至网络层
(2)网络通讯要素
IP地址、端口号、传输协议
(3)网络通讯前提
找到对方IP
数据要发送到指定端口。为了标示不同的应用程序，所以给这些网络应用程序都用数字进行标示。这个标示就叫端口。
定义通信规则。这个规则称为通信协议，国际组织定义了通用协议TCP/IP
(4)计算机网络：
是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
(5)IP地址：
IP地址 = 网络号码+主机地址
A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码
B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码
C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码
特殊地址:
127.0.0.1 回环地址,可用于测试本机的网络是否有问题. ping 127.0.0.1   
ipconfig:查看本机IP地址
xxx.xxx.xxx.0 网络地址
xxx.xxx.xxx.255 广播地址
A类 1.0.0.1---127.255.255.254 10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)。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
(6)各种网络分类方式
A:按网络覆盖范围划分
　　局域网(几米至10公里以内) 　　城域网(10~100公里) 　　广域网(几百公里到几千公里) 　　国际互联网
B:按网络拓扑结构划分
　　总线型网络 　　星形网络 　　环型网络 　　树状网络 　　混合型网络
C:按传输介质划分
　　有线网 　　无线网
D:按网络使用性质划分
　　公用网 　　专用网
(7)虚拟专用网络（Virtual Private Network ，简称VPN)指的是在公用网络上建立专用网络的技术。
其之所以称为虚拟网，主要是因为整个VPN网络的任意两个节点之间的连接并没有传统专网
所需的端到端的物理链路，而是架构在公用网络服务商所提供的网络平台，如Internet、
ATM(异步传输模式〉、Frame Relay （帧中继）等之上的逻辑网络，
用户数据在逻辑链路中传输。它涵盖了跨共享网络或公共网络的封装、
加密和身份验证链接的专用网络的扩展。VPN主要采用了隧道技术、加解密技术、
密钥管理技术和使用者与设备身份认证技术。

1-2 TCP和UDP

1-2-1 UDP和TCP的区别（考点）

UDP
将数据及源和目的封装成数据包中，不需要建立连接
每个数据报的大小在限制在64k内
因无连接，是不可靠协议
不需要建立连接，速度快
TCP
建立连接，形成传输数据的通道。
在连接中进行大数据量传输
通过三次握手完成连接，是可靠协议
必须建立连接，效率会稍低
注：三次握手：
第一次：我问你在么？
第二次：你回答在。
第三次：我反馈哦我知道你在。

1-2-2 Socket(UDP传输)

Socket就是为网络服务提供的一种机制。
通信的两端都有Socket。
网络通信其实就是Socket间的通信。
数据在两个Socket间通过IO传输。
玩Socket主要就是记住流程，代码查文档就行

1-2-3 UDP传输

DatagramSocket与DatagramPacket
发送端：
（1）建立DatagramSocket服务；
（2）提供数据，并将数据封装到字节数组中；
（3）创建DatagramPacket数据包，并把数据封装到包中，同时指定IP和接收端口
（4）通过Socket服务，利用send方法将数据包发送出去；
（5）关闭DatagramSocket和DatagramPacket服务。
接收端：
（1）建立DatagramSocket服务，并监听一个端口；
（2）定义一个字节数组和一个数据包，同时将数组封装进数据包；
（3）通过DatagramPacket的receive方法，将接收的数据存入定义好的数据包；
（4）通过DatagramPacke关闭t的方法，获取发送数据包中的信息；
（5）关闭DatagramSocket和DatagramPacket服务。
DatagramSocket与DatagramPacket方法摘要：
*****DatagramSocket
构造方法：
DatagramSocket() 
构造数据报套接字并将其绑定到本地主机上任何可用的端口。
DatagramSocket(int port) 
创建数据报套接字并将其绑定到本地主机上的指定端口。 
DatagramSocket(int port, InetAddress laddr) 
创建数据报套接字，将其绑定到指定的本地地址。 
方法摘要:
void close() 
关闭此数据报套接字。
InetAddress getInetAddress() 
返回此套接字连接的地址。 
InetAddress getLocalAddress() 
获取套接字绑定的本地地址。
int getPort() 
返回此套接字的端口。 
void receive(DatagramPacket p) 
从此套接字接收数据报包。 
void send(DatagramPacket p) 
从此套接字发送数据报包。
****DatagramPacket
构造方法：
DatagramPacket(byte[] buf, int length) 
构造 DatagramPacket，用来接收长度为 length 的数据包。
DatagramPacket(byte[] buf, int length, InetAddress address, int port) 
构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
InetAddress getAddress() 
返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。 
byte[] getData() 
返回数据缓冲区。 
int getLength() 
返回将要发送或接收到的数据的长度。
int getPort() 
返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。
代码示例：
发送端：

class UDPSend
{
	public static void main(String[] args) throws Exception
	{
		DatagramSocket ds = new DatagramSocket();
		byte[] buf = "这是UDP发送端".getBytes();
		DatagramPacket dp = new DatagramPacket(
			buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);
		ds.send(dp);
		ds.close();
	}
}

接收端

class UDPRece
{
	public static void main(String[] args) throws Exception
	{
		DatagramSocket ds = new DatagramSocket(10000);
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);
		ds.receive(dp);//将发送端发送的数据包接收到接收端的数据包中
		String ip = dp.getAddress().getHosyAddress();//获取发送端的ip
		String data = new String(dp.getData(),0,dp.getLength());//获取数据
		int port = dp.getPort();//获取发送端的端口号
		sop(ip+":"+data+":"+port);
		ds.close();
	}
}

需求1：UDP键盘录入数据，并发送给接收端
发送端：

class UDPSend
{
	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.253"),10000);
			ds.send(dp);
		}
		ds.close();
	}
		
}

接收端：

class UDPRece
{
	public static void main(String[] args) throws Exception
	{
		DatagramSocket ds = new DatagramSocket(10000);
		while(true)
		{
			byte[] buf = new byte[1024];
			DatagramPacket dp = new DatagramPacket(buf,buf.length);
			ds.receive(dp);//将发送端发送的数据包接收到接收端的数据包中
			String ip = dp.getAddress().getHosyAddress();//获取发送端的ip
			String data = new String(dp.getData(),0,dp.getLength());//获取数据
			int port = dp.getPort();//获取发送端的端口号
			sop(ip+":"+data+":"+port);
			ds.close();
		}
	}
	
}

需求2：编写简单的聊天工具
思路：
使用多线程技术
发送端：

class UDPSend implements Runnable
{
	private DatagramSocket ds;
	public UDPSend(){}
	public UDPSend(DatagramSocket ds)
	{
		this.ds=ds;
	}
	public void run()
	{
		try
		{
			BufferedReader bufr = new BufferedReader(
						new InputStreamReader(System.in));
			String line = null;
			while((line = bufr.readLine())!=null)
			{
				if("886".equals(line))
					break;
				byte[] buff = line.getBytes();
				DatagramPacket dp = new DatagramPacket(
				buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);
				ds.send(dp);
			}
		}
		catch(Exception e)
		{
			throw new RuntimeException("发送失败");
		}
	}
}

接收端：

class UDPRece implements Runnable
{
	private DatagramSocket ds;
	public UDPSend(){}
	public UDPSend(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().getHosyAddress();//获取发送端的ip
				String data = new String(dp.getData(),0,dp.getLength());//获取数据
				int port = dp.getPort();//获取发送端的端口号
				sop(ip+":"+data+":"+port);		
			}
		}
		catch(Exception e)
		{
			throw new RuntimeException("接收失败");
		}
	}
}

测试类：

class UDPTest
{
	public static void main(String[] args)
	{
		DatagramSocket sendSocket = new DatagramSocket();
		DatagramSocket receSocket = new DatagramSocket(10000);


		new Thread(new UDPSend(sendSocket)).start();
		new Thread(new UDPRece(receSocket)).start();
	}
}

1-2-4 TCP传输

Socket和ServerSocket
（1）建立客户端和服务器端
（2）建立连接后，通过Socket中的IO流进行数据的传输
（3）关闭socket
同样，客户端与服务器端是两个独立的应用程序。
Socket
构造方法：
Socket() 
通过系统默认类型的 SocketImpl 创建未连接套接字
Socket(InetAddress address, int port) 
创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
Socket(String host, int port) 
创建一个流套接字并将其连接到指定主机上的指定端口号。
方法摘要：
void close() 
关闭此套接字。
InetAddress getInetAddress() 
返回套接字连接的地址。
InputStream getInputStream() 
返回此套接字的输入流。
OutputStream getOutputStream() 
返回此套接字的输出流。 
int getPort() 
返回此套接字连接到的远程端口。
void shutdownInput() 
此套接字的输入流置于“流的末尾”。 
void shutdownOutput() 
禁用此套接字的输出流。 
String toString() 
将此套接字转换为 String。
ServerSocket
构造方法：
ServerSocket() 
创建非绑定服务器套接字。 
ServerSocket(int port) 
创建绑定到特定端口的服务器套接字。
方法摘要：
Socket accept() 
侦听并接受到此套接字的连接。
void close() 
关闭此套接字。 
InetAddress getInetAddress() 
返回此服务器套接字的本地地址。
TCP传输流程：
客户端：
（1）建立Socket服务，并制定要连接的主机和端口；
（2）获取Socket流中的输出流OutputStream，将数据写入流中，通过网络发送给服务端；
（3）获取Socket流中的输出流InputStream，获取服务端的反馈信息；
（4）关闭资源。
服务端：
（1）建立ServerSocket服务，并监听一个端口；
（2）通过ServerSocket服务的accept方法，获取Socket服务对象；
（3）使用客户端对象的读取流获取客户端发送过来的数据；
（4）通过客户端对象的写入流反馈信息给客户端；
（5）关闭资源；
代码示例：
客户端：

class TCPClient
{
	public static void main(String[] args)
	{
		Socket s = new Socket("192.168.1.253",10000);
		OutputStream os = s.getOutputStream();
		out.write("这是TCP发送的数据".getBytes());
		s.close();
	}
}

服务端：

class TCPServer
{
	public static void main(String[] args)
	{
		ServerSocket ss = new ServerSocket(10000);
		Socket s = ss.accept();


		String ip = s.getInetAddress().getHostAddress();
		sop(ip);


		InputStream is = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = is.read(buf);
		sop(new String(buf,0,len));
		s.close();
		ss.close();
	}
}

TCP需求1：客户端给服务端发送数据，服务端接收到后反馈信息给客户端
客户端：

class TCPClient
{
	public static void main(String[] args)
	{
		Socket s = new Socket("192.168.1.253",10000);
		OutputStream os = s.getOutputStream();
		out.write("这是TCP发送的数据".getBytes());
		
		InputStream is = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = is.read(buf);
		sop(new String(buf,0,len));
		s.close();
	}
}

服务端：

class TCPServer
{
	public static void main(String[] args)
	{
		ServerSocket ss = new ServerSocket(10000);
		Socket s = ss.accept();


		String ip = s.getInetAddress().getHostAddress();
		sop(ip);


		InputStream is = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = is.read(buf);
		sop(new String(buf,0,len));


		OutputStream os = s.getOutputStream();
		out.write("这是TCP发送的数据".getBytes());


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

TCP需求2：建立一个文本转换服务端，客户给服务端发送文本，服务端将数据转换成大写后返回给客户端
 当客户端输入over时，转换结束
客户端：

class TCPClient
{
	public static void main(String[] args)
	{
		Socket s = new Socket("192.168.1.253",10000);
		BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(
								s.getOutputStream()));
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(
								s.getInputStream()));
		String line = null;
		while((line = bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			bufOut.write(line);
			bufOut.newLine();
			bufOut.flush();
			String retVal = bufIn.readLine();
			sop("server:"+retVal);
		}
		bufr.close();
		s.close();
	}
}

服务端：

class TCPServer
{
	public static void main(String[] args)
	{
		ServerSocket ss = new ServerSocket(10000);
		Socket s = ss.accept();


		String ip = s.getInetAddress().getHostAddress();
		sop(ip);
		
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(
								s.getInputStream()));
		BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(
								s.getOutputStream()));


		while((line = bufIn.readLine())!=null)
		{
			bufOut.write(line.toUpperCase());
			bufOut.newLine();
			bufOut.flush();
		}
		s.close();
		ss.close();
	}
}

需求3：拷贝文件
客户端：

class TCPClient
{
	public static void main(String[] args)
	{
		Socket s = new Socket("192.168.1.253",10000);
		BufferedReader bufr = new BufferedReader(new FileReader("g:\\demo.txt"));
		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		String line = null;
		while((line = bufr.readLine())!=null)
		{
			pw.println();
		}
		s.shutDownOutput();
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(
								s.getInputStream()));
		String retVal = bufIn.readLine();
		sop(retVal);
		bufr.close();
		s.close();
	}
}

服务端：

class TCPServer
{
	public static void main(String[] args)
	{
		ServerSocket ss = new ServerSocket(10000);
		Socket s = ss.accept();


		String ip = s.getInetAddress().getHostAddress();
		sop(ip);
		
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(
								s.getInputStream()));
		PrintWriter out = new PrintWriter(new FileWriter"copy.txt",true);
		String line =null;
		while((line = bufIn.readLine())!=null)
		{
			out.write(line);
		}
		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		pw.println("上传成功");
		out.close();
		s.close();
		ss.close();
	}
}

需求4：上传图片
客户端：

class TCPClient
{
	public static void main(String[] args)
	{
		Socket s = new Socket("192.168.1.253",10000);
		FileInputStream fis = new FileInputStream("g:\\1.bmp");
		OutputStream out = s.getOutputStream();
		byte[] buf = new byte[1024];
		int len = 0;
		while((len = bufr.read())!=-1)
		{
			out.write(buf,0,len);
		}
		s.shutDownOutput();


		InputStream in = s.getInputStream();
		byte[] bufIn = new byte[1024];
		int lenIn = in.read(bufIn);
		sop(new String(bufIn,0,lenIn);
		fis.close();
		s.close();
	}
}

服务端：

class TCPServer
{
	public static void main(String[] args)
	{
		ServerSocket ss = new ServerSocket(10000);
		Socket s = ss.accept();


		String ip = s.getInetAddress().getHostAddress();
		sop(ip);
		FileOutputStream fos = new FileOutputStream("g:\\copy.bmp");
		InputStream in = s.getInputStream();
		byte[] bufIn = new byte[1024];
		int lenIn = 0;
		while((lenIn=bufIn.read())!=-1)
		{
			fos.write(bufIn,0,lenIn)
		}


		OutputStream outIn = s.getOutputStream();
		outIn.write("上传成功".getBytes());
		fos.close();
		s.close();
		ss.close();
	}
}

需求5：客户端并发登陆
客户端通过键盘录入用户名，服务端对这个用户名进行校验
如果用户存在，在服务端现实xxx已登录，并在客户端现实欢迎xxx
如果用户不存在，在服务端现实xxx正在尝试登陆，并在客户端现实xxx用户不存在
最多登陆三次。
校验端：

class User implements Runnable
(
	private Socket s;
	public User(){}
	public User(Socket s)
	{
		this.s=s;
	}
	public void run()
	{
		try
		{
			BufferedReader bufrIn = new BufferedReader(
					new InputStream(s.getInputStream()))
			String name = bufrIn.readLine();
			if(name==null)
			{
				sop("用户名为空");
				break;
			}
			BufferedReader bufr = new BufferedReader(
					new FileReader("user.txt"));
			PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
			String line = null;
			boolean flag = false;
			while((line = bufr.reanLine())!=null)
			{
				if(line.equals(name))
				{
					flag = true;
					break;
				}
				if(flag)
				{
					sop(name+"已登陆");
					pw.println("欢迎"+name);
					break;
				}
				else
				{
					sop(name+"正尝试登陆");
					pw.println(name+"用户不存在");
				}


			}
			s.close();
		}
		catch(Exception e)
		{
			throw new RuntimeException("用户校验失败");
		}
	}
)

客户端：

class LoginClient
{
	public static void main(String[] args)
	{
		Socket s = new Socket("192.168.1.253",10000);
		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 i=0;i<3;i++)
		{
			String line = bufr.readLine();
			if(line == null)
			{
				sop("用户名不能为空！");
				break;
			}
			out.write(line);
			String retVal = bufIn.readLine();
			sop(retVal);	
		}
		bufr.close();
		s.close();
	}
}

服务端：

class LoginServer
{
	public static void main(String[] args)
	{
		ServerSocket ss = new ServerSocket(10000);
		while(true)
		{
			Socket s = ss.accept();
			new Thread(new User()).start();
		}
	}
}

------- android培训、java培训、期待与您交流！ ----------