网络编程 IP地址 DNS 服务器 协议 socket套接字 通信模型 客户端/服务端

网络编程

IP地址的组成

四个8位的二进制数由三个“.”分割开来
为了好记，改写为十进制的;
IP地址= 网络地址+主机地址
1、网络地址：标识计算机或网络设备所在的网段
2、主机地址：标识特定主机或网络设备
分为:每个【】占8位
A类：【网络】 【主机】【主机】【主机】1~126
B类：【网络】【网络】 【主机】 【主机】128~191 
C类：【网络】【网络】【网络】  【主机】192~223
D类：用于组播通信			224~239
E类用于科研			240~255

cmd命令

使用ipconfig在cmd中查看的网络配置
使用ping+ip地址查看本机一次地址的主机网络是否通畅

DNS

Domain Name System,域名系统

服务器

通常指在网络环境下，具有较高的计算能力，能够提供用户服务功能的计算机
1、邮件服务器
2、web服务器

模式介绍

B/S: Browser/Server，浏览器/服务器模式
C/S: Client/Server，客户端/服务器模式

协议

为了在网络中不同的计算机之间进行通信而建立的规则、标准或约定的集合
TCP/IP五层
1、物理层
2、数据链路层
3、网络层		ICMP	IGMP     IP       ARP     RARP
4、传输层		TCP     UDP
5、应用层		HTTP   FTP  TFTP   SMTP     SNMP    DNS

Socket

 通信链路的端点就被称为“套接字”
1、流式套接字（SOCK_STREAM）【基于TCP】
面向连接、可靠的数据传输服务
2、数据报式套接字（SOCK_DGRAM）【基于UDP】
无连接服务
3、原始式套接字（SOCK_RAW）

常用API

java.net包：
1、Socket
2、ServerSocket
3、DatagramPacket
4、DatagramSocket
5、InetAddress
.......

两种网络通信模型

基于TCP协议的Socket网络通信

	用来实现双向安全连接网络通信

Socket通信模型

进行网络通信时，Socket需要借助数据流来完成数据的传递工作

Socket网络编程的步骤：客户端/服务端（C/S）

1、建立连接
2、打开Socket关联的输入输出流
3、数据流中读写信息
4、关闭所有的数据流和Socket

详细步骤

1、user类：需要实现Serializable接口
2、服务器端：通过Socket.getInetAddress()获取InetAddress对象，再用getHostAddress()获取客户端IP
	创建ServerSocket对象
	ServerSocket serverSocket = new ServerSocket(设置端口号);
	//声明Socket获取ServerSocket的accept()方法
	Socket socket = serverSocket.accept();
	//获取Socket字节输入流方法
	InputStream is = socket.getInputStream();
	//创建对象输入流
	ObjectInputStream ois = new ObjectInputStream(参数是字节输入流);
	//创建要接受地对象，并调用readObject()方法
	User user = （User）ois. readObject();
	//打印输出
	System.out.print(user.toString());
3、客户端：
	//创建Socket对象，调用它的两个参数的构造方法
	Socket socket = new Socket(主机地址 , 端口号);//本机使用localhost,端口根据服务端所设置的端口进行输入
	//获取Socket的输出流
	OutputStream os = socket.getOutputStream();
	//创建对象输出流
	ObjectOutputStream oos = new ObjectOutputStream(字节输出流);
	//创建要传的对象
	User user = new User("admin","123456");
	//使用对象输出流写出对象
	oos.writeObject(user);

//服务器
public class LoginServer {
	public static void main(String[] args) {
		//建立服务器的socket，指定服务器的端口，开始监听
		ServerSocket serverSocket = null;
		//声明socket
		Socket socket = null;
		InputStream is = null;
		BufferedReader br = null;
		OutputStream os = null;
		BufferedWriter bw = null;
		try {
			//指定服务器的端口，开始监听
			serverSocket = new ServerSocket(8807);
			//创建socket对象
			socket = serverSocket.accept();
			//创建输入流，接收内容
			is = socket.getInputStream();
			//创建bufferedReader对象，并设置encoding
			br = new BufferedReader(new InputStreamReader(is));
			String str = null;
			//读取客户端的信息
			while((str = br.readLine())!=null){
				System.out.println("我是服务器，接受到的客户端信息为："+str);
			}			
				os = socket.getOutputStream();
				//bw = new BufferedWriter(new OutputStreamWriter(os, "UTF-8"));
				String replay = "登陆成功";
				os.write(replay.getBytes());
			
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				//关闭资源
				//bw.close();
				os.close();
				br.close();
				is.close();
				socket.close();
				serverSocket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}			
		}
	}
}
//客户端
public class LoginClient {
	public static void main(String[] args) {
		OutputStream os = null;
		Socket socket = null;
		BufferedWriter bw = null;
		InputStream is = null;
		BufferedReader br = null;
		try {
			//建立客户端的socket连接，指定服务器的位置及端口
			socket = new Socket("localhost",8807);
			//打开输入输出流，创建输出流，写内容
			os = socket.getOutputStream();
			//bw = new BufferedWriter(new OutputStreamWriter(os, "UTF-8"));
			String string = "用户名：liwang,密码：123456";
			//发送客户端登录信息，向输出流写入信息
			os.write(string.getBytes());
			
			socket.shutdownOutput();
						
			is = socket.getInputStream();
			br = new BufferedReader(new InputStreamReader(is));
			String str = null;
			while((str=br.readLine())!=null){
				System.out.println("我是客户端，服务器说："+str);
			}
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				//关闭资源
				br.close();
				is.close();
				//bw.close();
				os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

多客户端

多客户端与服务器网络通信，可以借助多线程
客户端：发送请求，接收响应
服务器：循环监听用户请求，一旦监听到请求，创建并开启线程
线程：接收并处理客户请求

//线程
public class MyThread extends Thread{
	Socket socket = null;
	public MyThread(Socket socket){
		this.socket = socket;
	}
	public void run(){
		InputStream is = null;
		ObjectInputStream ois = null;
		OutputStream os =null;
		OutputStreamWriter osw = null;
		try {
			is = socket.getInputStream();
			ois = new ObjectInputStream(is);
			User user = (User)ois.readObject();
			System.out.println(user.toString());
			
			//获取主机IP地址
			InetAddress address = socket.getInetAddress();
			String ip = address.getHostAddress();
			System.out.println(ip);
			
			os = socket.getOutputStream();
			osw = new OutputStreamWriter(os);
			osw.write("欢迎登录");
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}finally{
			try {
				osw.close();
				os.close();
				ois.close();
				is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}			
		}
	}
}
//客户端
public class Server {
	public static void main(String[] args) {
		ServerSocket serverSocket = null;
		Socket socket = null;
		try {
			serverSocket = new ServerSocket(5000);
			while(true){
				socket = serverSocket.accept();
				MyThread myThread = new MyThread(socket);
				myThread.start();
			}
			
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				socket.close();
				serverSocket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}
//客户端1
public class Client_01 {
	public static void main(String[] args) {
		Socket socket =null;
		OutputStream os = null;
		ObjectOutputStream oos = null;
		InputStream is = null;
		InputStreamReader isr = null;
		BufferedReader br = null;
		try {
			socket = new Socket("localhost",5000);
			os = socket.getOutputStream();
			oos = new ObjectOutputStream(os);
			User user = new User("张三","123456");
			oos.writeObject(user);
			
			is = socket.getInputStream();
			isr = new InputStreamReader(is);
			br = new BufferedReader(isr);
			System.out.println(br.readLine());
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				br.close();
				isr.close();
				is.close();
				oos.close();
				os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}		
	}
}
//客户端2
public class Client_02 {
	public static void main(String[] args) {
		Socket socket =null;
		OutputStream os = null;
		ObjectOutputStream oos = null;
		InputStream is = null;
		InputStreamReader isr = null;
		BufferedReader br = null;
		try {
			socket = new Socket("localhost",5000);
			os = socket.getOutputStream();
			oos = new ObjectOutputStream(os);
			User user = new User("李四","123456");
			oos.writeObject(user);
			
			is = socket.getInputStream();
			isr = new InputStreamReader(is);
			br = new BufferedReader(isr);
			System.out.println(br.readLine());
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				br.close();
				isr.close();
				is.close();
				oos.close();
				os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}	
	}
}
//用户类
public class User implements Serializable {
	private String userName;
	private String password;	
	public User(){}
	public User(String userName, String password) {
		super();
		this.userName = userName;
		this.password = password;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String toString() {
		return "User [userName=" + userName + ", password=" + password + "]";
	}	
}

基于DUP协议的Socket网络通信

了解

//服务器端
public class UDPServer {
	public static void main(String[] args) {
		DatagramSocket ds = null;
		byte[] buf = new byte[1024];
		DatagramPacket dp = new  DatagramPacket(buf,1024);
		try {
			ds = new DatagramSocket(8880);
			ds.receive(dp);		
			String mess = new String(dp.getData());
			System.out.println(mess);
			
			InetAddress ia = InetAddress.getByName("localhost");
			String reply = "你好，我在，请咨询！";
			DatagramPacket p = new DatagramPacket(reply.getBytes(), reply.getBytes().length,ia,8881);
			ds.send(p);
		} catch (SocketException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			ds.close();
		}
	}
}
//客户端
public class UDPClient {
	public static void main(String[] args) {
		String message = "你好，我想咨询一个问题！";		
		DatagramSocket ds = null;		
		DatagramSocket socket = null; 
		try {
			InetAddress ia = InetAddress.getByName("localhost");
			DatagramPacket dp = new DatagramPacket(message.getBytes(), 0, message.getBytes().length, ia, 8880);
			ds = new DatagramSocket();
			ds.send(dp);		
			byte[] buf = new byte[1024];
			DatagramPacket p = new DatagramPacket(buf, 1024);
			socket = new DatagramSocket(8881);
			socket.receive(p);
			String s = new String(p.getData());
			System.out.println(s);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (SocketException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			socket.close();
			ds.close();
		}
	}
}