13、网络编程

目录

• 网络编程
  • 网络底层
    • 网络模型一
    • 网络模型二
  • IP ,端口号，通信协议
    • TCP
    • 线程和网络编程
    • 服务器和客户端
    • UDP

网络编程

网络底层

网络模型一

网络模型二

IP ,端口号，通信协议

IP: 识别一台计算机的，只要是为了找到某一台，所有IP地址不能够重复。

​ 由4个8位二进制的组成，也就是32位的二进制，分成4部分。

​ 比如说 192.168.3.42 ------》 在计算机显示的是十进制，计算机运行的是二进制。

IP 地址：32位，由4个8位二进制数组成

IP表示方法：点分十进制

IP地址 = 网络ID +主机ID
网络ID：标识计算机或网络设备所在的网段
主机ID：标识特定主机或网络设备

序号	方法	描述
1	public static InetAddress getLocalHost()	获得主机名和IP地址
2	public String getHostAddress()	获取IP地址
3	public String getHostName()	获取主机名
4	public static InetAddress getByName(String host)	根据主机名获得IP地址

获得百度的IP地址：

InetAddress ia2=InetAddress.getByName("www.baidu.com");
System.out.println("其它主机名称:"+ia2.getHostAddress());

端口号：当你识别了一台计算机，但你却不能识别到每一个应用程序在执行什么。所以端口号就是识别应用程序在 电脑的运行，这样就可以找到指定的应用了。

通信协议：当有了IP,端口号，这样就可以找到指定的软件了，但是我们还不知道通过什么东西来传输数据。所以就有了通信协议，这样就可以通过通信协议来传输数据了。通信协议有两种 TCP 和 UDP 。

TCP

先要建立连接然后才能传输数据。

重要的代码。

ServerSocket server = new ServerSocket(8080);//创建服务器，8080是指定接收客户端端口号

//连接到客户端
Socket client = server.accept();

//接收客户端的信息
InputStream is = client.getInputStream();

//创建客户端并指定ip地址，还有服务端端口号
Socket client = new Socket("192.168.3.40",8080);

//从客户端写出信息
OutputStream os = client.getOutputStream();

//提交信息，切断输出流。 client
client.shutdownOutput();

package socket;
 
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
 
public class Server {
	public static void main(String[] args) throws IOException {
		//创建服务器，并指定接收的端口号
		ServerSocket server = new ServerSocket(8080);
		//连接到客户端
		Socket client = server.accept();
		//接收客户端的信息
		InputStream is = client.getInputStream();
		byte[] bs = new byte[1024];
		int len = is.read(bs);
		System.out.println(new String(bs,0,len));
		is.close();
		server.close();
	}
}

package socket;
 
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
 
public class Client {
	public static void main(String[] args) throws IOException {
		//创建客户端并指定ip地址，还有服务端端口号
		Socket client = new Socket("192.168.3.40",8080);
		//从客户端写出信息
		OutputStream os = client.getOutputStream();
		os.write("System.out.println('HolleWorld');".getBytes());
		//提交信息，切断输出流。 client
		client.shutdownOutput();
		os.close();
		client.close();
	}
}
 

线程和网络编程

当我们耗时比较就的操作时，比如查询数据库。我们不可能等一个用户查询完再给下一个用户去用，如果是这样的话，我们就执行一个简单的操作，如果用户多，用户就在那里等了好久。这样的体验就极差，所以，我们还是创建一个线程让线程替我们去工作，所以等待的时间就大大的减少了。

package tcpthread02;
 
import java.io.IOException;
 
import java.net.ServerSocket;
import java.net.Socket;
 
public class ServerDemo02 {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		ServerSocket server = new ServerSocket(9898);
		while(true) {
			Socket client = server.accept();
			new MyThread(client).start();
		}
	}
}

package tcpthread02;
 
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
 
public class ClientDemo02 {
	public static void main(String[] args) throws UnknownHostException, IOException {
		for (int i = 0; i < 10; i++) {
			Socket client = new Socket("Localhost",9898);
			OutputStream os = client.getOutputStream();
			ObjectOutputStream oos = new ObjectOutputStream(os);
			oos.writeObject(new User("张三","123"));
			client.shutdownOutput();
			oos.close();
			os.close();
			client.close();
		}
	}
}
 

package tcpthread02;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.Socket;
 
public class MyThread extends Thread{
	private Socket client;
	
	public MyThread(Socket client) {
		super();
		this.client = client;
	}
 
	@Override
	public void run() {
		InputStream is;
		try {
			Thread.sleep(5000);
			is = client.getInputStream();
			ObjectInputStream ois = new ObjectInputStream(is);
			Object obj = ois.readObject();
			System.out.println(obj.getClass().getName());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
	}
}
 

package tcpthread02;
 
import java.io.Serializable;
 
public class User implements Serializable{
	private String name;
	private String psw;
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
	public User(String name, String psw) {
		super();
		this.name = name;
		this.psw = psw;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPsw() {
		return psw;
	}
	public void setPsw(String psw) {
		this.psw = psw;
	}	
}

服务器和客户端

数据的传输都是相对而言的，输入和输出都是相对于当前的应用程序。

UDP

udp传输协议，是发一段一段数据包这样子，类是于发短信，每次最多只能发这么大的数据，60K的数据。

也能会存在丢包的情况，导致数据的不完整。如果在接收端还没运行，就先运行了发送端。发送端也可以接收数据。

package udp;
/**
*发送端
*/
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
 
public class Send {
	public static void main(String[] args) throws IOException {
		//创建发送端,建立自己的端口，
		DatagramSocket ds = new DatagramSocket(8000);
		//创建发送的内容
		String str = "在吗";
		byte[] bs = str.getBytes();
		//创建发送包
		DatagramPacket dp = new DatagramPacket(bs,bs.length,InetAddress.getLocalHost(),9999);
		//发送
		ds.send(dp);
		//关闭
		ds.close();
	}
 
}
package udp;
/**
*接收端
*/
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
 
public class Receive {
	public static void main(String[] args) throws IOException {
		//创建接收端，建立接收端口号
		DatagramSocket ds = new DatagramSocket(9999);
		//创建接收包
		byte[] bs = new byte[1024];
		DatagramPacket dp = new DatagramPacket(bs,bs.length);
		//接收包
		ds.receive(dp);
		//解析包
		System.out.println(new String (dp.getData()));
		System.out.println(dp.getAddress());
		ds.close();
	}
}