黑马程序员——网络编程

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

网络编程

一、网络的概述：

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

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

      3、网络非常重要：有人说，20世纪最伟大的发明不是计算机，而是计算机网络。还有人说，如果你买了计算机而没有联网，就等于买了电话机而没有接电话线一样。

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

           网络模型一般是指 OSI（Open System Interconnection开放系统互连）参考模型 和T CP/IP参考模型：如下图:

▪应用层：主要是一些终端的应用，比如说FTP（各种文件下载），WEB（IE浏览），QQ之类的

             【可以把它理解成我 们在电脑屏幕上可以看到的东西．就是终端应用 】

▪表示层：主要是进行对接收的数据进行解释、加密与解密、压缩与解压缩等（也就是把计算机能够识别的东西转换

              成人能够能识别的东西（如图片、声音等）

▪会话层：通过传输层（端口号：传输端口与接收端口）建立数据传输的通路。主要在你的系统之间发起会话或者接

              受会话请求（设备之间需要互相认识可以是IP也可以是MAC或者是主机名）

▪传输层：定义了一些传输数据的协议和端口号（WWW端口80等）主要是将从下层接收的数据进行分段和传输，到

              达目的地址后再进行重组。常常把这一层数据叫做段。

▪网络层：主要将从下层接收到的数据进行IP地址（例192.168.0.1)的封装与解封装。

              在这一层工作的设备是路由器， 常把这一层的数据叫做数据包。 

▪数据链路层：主要将从物理层接收的数据进行MAC地址（网卡的地址）的封装与解封装。

                     常把这一层的数据叫做帧。在这一层工作的设备是交换机，数据通过交换机来传输。

▪物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。

              它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就

              是我们常说的数模转换与模数转换）。这一层的数据叫做比特。

▪java是站在应用层开发程序的

二、网络编程三要素

  1、IP：网络中每一台计算机的唯一标识

        拓展知识：给出一个十进制的 ip 数值：192.168.3.100

        而它在网络中实际上是如下表示的：11000000 10101000 00000011 01100100

        为什么我们不是采用下面这种方式配置ip的呢?

        为了方便记忆，把这种表示形式做了改进："点分十进制"

      ▪ IP地址的分类：

        A类1.0.0.1---127.255.255.254 

        10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)

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

        C类 192.0.0.1---223.255.255.254192.168.X.X是私有地址

        D类 224.0.0.1---239.255.255.254

        E类 240.0.0.1---247.255.255.254

        ▪ IP地址的组成：

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

         A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码（256*256*256 -- 16777216）

         B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码（256*256 --- 65536）

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

         查看本机IP DOS命令：ipconfig

   2、端口：用于标识进程的逻辑地址

         拓展知识：

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

            A:每个网络程序都会至少有一个逻辑端口
            B:用于标识进程的逻辑地址，不同进程的标识不一样
            C:有效端口：0~65535，其中0~1024系统使用或保留端口。
           通过360可以查看端口号

   3、协议：定义通信规则

          TCP：

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

                   数据无限制（在连接中进行大数据量传输）

                   面向连接(三次握手)

                   可靠协议

                   速度慢（必须建立连接，效率会稍低）

                   举例：蓝牙，QQ单聊，打电话

         UDP

                   把数据打包（封装成数据包）

                   数据有限制（每个数据包的大小限制在64K）

                   不需要建立连接

                   不可靠（因为无连接，所以是不可靠协议）

                   速度快（不需要建立连接，速度快）

                   举例：QQ聊天室(群聊)

三、Socket

   1.Socket机制概述：
        ▪ Socket是Internet主机上（计算机）提供的服务，包装了端口和IP地址

           通信两端独有Socket

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

           数据在两个Socket

         网络编程又称Socket编程、或套接字编程  

   2.InetAddress类的概述和使用：

        （1）InetAddress类是一个IP地址类的包装类

         （2）InetAddress它是一个实体类

         （3）InetAddress没有提供构造方法那我们如何使用这个类呢？

                  方式一：找类下的静态方法直接类名调用

                  方式二：如果发现有非静态的方法，遇到这种情况就要找下静态方法中有没有返回值类型是InetAddress类型的静态方法我们可以通过这个静态方法获取到该类的对象

         （4）方法：public static InetAddressgetByName(String host)：根据主机名取的IP地址 host位置可以穿主机名也可以传IP地址

                             public String getHostAddress()：返回IP地址字符串（以文本表现形式）

                             public String getHostName()： 根据IP获取主机名

   3.Socket概述图:

   4.UDP协议发送、接收数据

      ▪ UDP发送步骤：

            A: 创建发送端Socket服务对象

                 DatagramSocket ds = new DatagramSocket();

            B: 创建数据，并把数据打包 

                 byte[] bys = "黄牛破解12306网站,刷票。说明黄牛也是IT出身".getBytes();

                 DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.3.100"), 12306);

            C: 发送数据：ds.send(dp);

            D: 释放资源：ds.close();

      ▪ UDP接收步骤：

            A: 创建接收端Socket服务对象
                DatagramSocket ds = new DatagramSocket(12306);
            B: 创建数据包(接收容器) 
            byte[] bys = new byte[1024];
                DatagramPacket dp = new DatagramPacket(bys, bys.length);
            C: 调用接收方法
                ds.receive(dp);
            D: 解析数据包,把数据显示在控制台
                 String ip = dp.getAddress().getHostAddress();
                 String s = new String(dp.getData(), 0, dp.getLength());
                 System.out.println(ip + "---" + s);
            E: 释放资源

                 ds.close();

       ▪ 接收端和发送端示例：

          接收端代码：

package Test1;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/*
 *  UDP协议接收数据步骤：
 *  A:创建接收端Socket服务对象
 *  B:创建数据包(接收容器) 
 *  C:调用接收方法
 *  D:解析数据包,把数据显示在控制台
 *  E:释放资源
 *  
 *  注意：
 *  	A:端口一定要一致。
 *  	B:Exception in thread "main" java.net.BindException: 
 *  	  Address already in use: Cannot bind
 */
public class ReceiveDemo {
	public static void main(String[] args) throws IOException {
		// 创建接收端Socket服务对象
		// DatagramSocket(int port)
		DatagramSocket ds = new DatagramSocket(12306);

		// 创建数据包(接收容器)
		// public DatagramPacket(byte[] buf,int length)
		byte[] bys = new byte[1024];
		DatagramPacket dp = new DatagramPacket(bys, bys.length);

		// 调用接收方法
		// public void receive(DatagramPacket p)
		ds.receive(dp);

		// 解析数据包,把数据显示在控制台
		// public InetAddress getAddress()
		InetAddress address = dp.getAddress();
		String ip = address.getHostAddress();

		// public byte[] getData()
		byte[] bys2 = dp.getData();
		// public int getLength()
		int length = dp.getLength();

		String s = new String(bys2, 0, length);
		System.out.println(ip + "***" + s);

		// 释放资源
		ds.close();
	}
}

          发送端代码：

package Test1;

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

/*
 * UDP协议发送数据步骤：
 * A:创建发送端Socket服务对象
 * B:创建数据，并把数据打包 
 * C:发送数据
 * D:释放资源
 */
public class SendDemo {
	public static void main(String[] args) throws IOException {
		// 创建发送端Socket服务对象
		DatagramSocket ds = new DatagramSocket();

		// 创建数据，并把数据打包
		String str = "hello,udp,我来了";
		// public DatagramPacket(byte[] buf,int length,InetAddress address,int
		// port)
		byte[] bys = str.getBytes();
		int length = bys.length;
		InetAddress address = InetAddress.getByName("192.168.1.113");
		int port = 12306;
		DatagramPacket dp = new DatagramPacket(bys, length, address, port);

		// 发送数据
		// public void send(DatagramPacket p)
		ds.send(dp);

		// 释放资源
		ds.close();
	}
}

运行结果：

       ▪ 用多线程改进聊天室：
         测试类代码：

package Test1;
/*
 * 应用程序：网络编程，IO,多线程。
 */
public class ChatRoom {
	public static void main(String[] args) {
		SendThread st = new SendThread();
		ReceiveThread rt = new ReceiveThread();

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(rt); 

		t1.start();
		t2.start();
	}
}

         接收端类代码：

package Test1;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class ReceiveThread implements Runnable {

	public void run() { 
		try {
			// 创建接收端Socket对象
			DatagramSocket ds = new DatagramSocket(10086);

			// 创建数据包
			while (true) {
				byte[] bys = new byte[1024];
				DatagramPacket dp = new DatagramPacket(bys, bys.length);
				// //接收数据
				ds.receive(dp);
				// 解析数据
				String ip = dp.getAddress().getHostAddress();
				String s = new String(dp.getData(), 0, dp.getLength());
			    //String hostName = dp.getAddress().getHostName();
				System.out.println("from " + ip + " data is " + s);
			}

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

         发送端类代码：

package Test1;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class SendThread implements Runnable {

	@Override
	public void run() {
		try { 
			// 创建发送端Socket对象
			DatagramSocket ds = new DatagramSocket();

			// 封装键盘录入
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			// 创建数据，并打包
			String line = null;
			while ((line = br.readLine()) != null) {
				if ("886".equals(line)) {
					break;
				}

				byte[] bys = line.getBytes();
				DatagramPacket dp = new DatagramPacket(bys, bys.length,InetAddress.getByName("192.168.1.100"), 10086);
				ds.send(dp);
			}

			// 释放资源
			ds.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

   5.TCP协议发送、接收数据
     1）TCP协议客户端的步骤:
         A:创建客户端的Socket对象 
         B:建立连接
             Socket s = new Socket("192.168.3.100", 10010);//创建了对象也建立了连接，端口号要和服务端一致

         C:获取输出流，写数据即可
            OutputStream os = s.getOutputStream();
            os.write("hello,tcp,我来了".getBytes());
         D:释放资源
           s.close();
     2）TCP协议服务器端的步骤：
         A:创建服务器端Socket对象
            ServerSocket ss = new ServerSocket(10010);//端口号要和客户端写的一致
         B:监听连接 
            Socket s = ss.accept();//阻塞式方法
         C:获取输入流，读取数据，并显示
            InputStream is = s.getInputStream();
            byte[] bys = new byte[1024];
            int len = is.read(bys);//阻塞阻塞式方法
            String client = new String(bys, 0, len);
            System.out.println(client);
         D:释放资源
            s.close();

     3）CP协议发送和接收数据图解

      4）TCP协议服务器端、客户端 代码示例：

           TCP 服务端：

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

/*
 * TCP协议服务器端的步骤：
 * A:创建服务器端Socket对象
 * B:监听连接 
 * C:获取输入流，读取数据，并显示
 * D:释放资源
 */
public class ServerDemo {
	public static void main(String[] args) throws IOException {
		// 创建服务器端Socket对象
		// ServerSocket(int port)
		ServerSocket ss = new ServerSocket(10010);
		// 监听连接
		// public Socket accept()
		Socket s = ss.accept();//阻塞
		// 获取输入流，读取数据，并显示
		// public InputStream getInputStream()
		InputStream is = s.getInputStream();
		byte[] bys = new byte[1024];
		int len = is.read(bys);//阻塞
		String client = new String(bys, 0, len);
		System.out.println(client);

		// 释放资源
		s.close();
		// ss.close();
	}
}

           TCP客户 端：

package Test1;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

/*  
 * TCP协议客户端的步骤:
 * A:创建客户端的Socket对象 
 * B:建立连接
 * C:获取输出流，写数据即可
 * D:释放资源
 * 
 * 注意：
 * Exception in thread "main" java.net.ConnectException: Connection refused: connect
 * TCP程序，必须先开服务器端。
 */
public class ClientDemo {
	public static void main(String[] args) throws IOException {
		// 创建客户端的Socket对象,建立连接
		// public Socket(InetAddress address,int port)
		// Socket s = new Socket(InetAddress.getByName("192.168.3.100"), 10010);
		// Socket(String host, int port)
		Socket s = new Socket("192.168.1.113", 10010);
		// 获取输出流，写数据即可
		// public OutputStream getOutputStream()
		OutputStream os = s.getOutputStream();
		os.write("hello,tcp,我来了".getBytes());
		// 释放资源
		s.close();
	}
}

运行结果：

     5）数据来源于键盘录入与，通过服务器转成大写，然后反馈给客户端显示。示例：

         服务器端代码：

package Test1;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo {  
	public static void main(String[] args) throws IOException {
		// 创建服务器Socket对象
		ServerSocket ss = new ServerSocket(22222);

		// 监听客户端
		Socket s = ss.accept();

		// 获取输入流
		BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

		String line = null;
		while ((line = br.readLine()) != null) {
			bw.write(line.toUpperCase());
			bw.newLine();
			bw.flush();
		}

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

         客服端代码：

package Test1;
import java.io.*;
import java.net.Socket;
/*
 * 需求：数据来源于键盘录入与，通过服务器转成大写，然后反馈给客户端显示。
 */
public class ClientDemo {
	public static void main(String[] args) throws IOException {
		// 创建客户端Socket对象
		Socket s = new Socket("192.168.1.113", 22222);

		// 封装键盘录入
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// 获取输出流
		// OutputStream os = s.getOutputStream();
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
				s.getOutputStream()));

		String line = null;
		while ((line = br.readLine()) != null) {
			if ("over".equals(line)) {
				break;
			}

			bw.write(line);
			bw.newLine();
			bw.flush();

			// 获取服务器的反馈
			BufferedReader brServer = new BufferedReader(new InputStreamReader(
					s.getInputStream()));
			String server = brServer.readLine();
			System.out.println("server:" + server);
		}

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

运行结果：

 

    6）客服端键盘录入数据，服务器端写入文本文件 输入over完毕，并给与客服端提示：

          服务器端：

package Test1;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo {
	public static void main(String[] args) throws IOException {
		// 创建服务器Socket对象
		ServerSocket ss = new ServerSocket(22222);

		// 监听客户端
		Socket s = ss.accept();//阻塞

		// 获取输入流
		BufferedReader br = new BufferedReader(new InputStreamReader(
				s.getInputStream()));
		// 封装输出流
		PrintWriter out = new PrintWriter(new FileWriter("out.txt"), true);
		String line = null;
		while ((line = br.readLine()) != null) {//阻塞
//			if("886".equals(line)){
//				break;
//			}
			out.println(line);
		} 

		PrintWriter pw = new PrintWriter(s.getOutputStream(), true);
		pw.println("数据成功接收");

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

         客户端：

package Test1;
import java.io.*;
import java.net.Socket;

public class ClientDemo {
	public static void main(String[] args) throws IOException {
		// 创建客户端Socket对象
		Socket s = new Socket("192.168.1.113", 22222);

		// 封装键盘录入
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// 获取输出流
		// OutputStream os = s.getOutputStream();
		PrintWriter pw = new PrintWriter(s.getOutputStream(), true);

		String line = null;
		while ((line = br.readLine()) != null) {
			if ("over".equals(line)) {
				break;
			}
			pw.println(line);
		}
//		pw.println("886");
		s.shutdownOutput(); 

		// 获取服务器的反馈
		BufferedReader brServer = new BufferedReader(new InputStreamReader(
				s.getInputStream()));
		String server = brServer.readLine();//阻塞
		System.out.println("server:" + server);

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

运行结果：