首页 > > 程序设计 > Java技术 >

网络编程

2019-05-13 07:18:26来源：博客园阅读 ()

1 网络概念

1.1 网络通信三要素

IP地址:唯一标识网络上的每一台计算机。两台计算机之间通信的必备有素
端口号:计算机中应用的标号(代表一个应用程序)

0-1024 为系统使用或保留端口；
常见端口：http：80，stmp：25，ftp：21；
有效端口0-65536,开发者可以的端口是1025-65536之间。一些第三方引用如 mysql：3306，Oracle：1251。

通信协议:通信的规则 TCP，UDP

1.2 网络通信模型

2 InetAddress

public class Test01 {
   public static void main(String[] args) {
       // 获取本机IP地址
       InetAddress ip1;
       try {
           ip1 = InetAddress.getLocalHost();
           // 将打印计算机名以及IP地址
           System.out.println(ip1.toString());
           
           // 获取主机名称
           System.out.println(ip1.getHostName());
           System.out.println(ip1.getHostAddress());
           
       } catch (UnknownHostException e) {
           e.printStackTrace();
       }
   }
}

3 TCP 编程

TCP编程中，如果要完成通信，通信双方必须要创建 socket，通过 socket 完成通信。

TCP通信步骤：

服务器启动 ServerSocket 作为通信的 Server 端，等待客户端链入。
客户端创建 Socket 作为通信的 Client 端
Client 端链入 Server 端后建立可靠的、双向的、持续性的、点对点的通讯连接，即可通信。

案例一：完成一次单向通信

服务器端：

import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server01 {
   public static void main(String[] args) {
       
       System.out.println("服务器启动...");
       
       // 【1】创建server socket
       ServerSocket serverSocket = null;
       Socket clientSocket = null;
       try {
       
           serverSocket = new ServerSocket(8000);
           // 【2】等待客户端的链入->阻塞式函数->监听8000端口，看是否有client链入
           clientSocket = serverSocket.accept();
           
           System.out.println(clientSocket.getInetAddress().getHostAddress()+"链入!");
       
           // 【3】给客户端主动发信息
           OutputStream out = clientSocket.getOutputStream();
           
           String msg = "hello 兄弟";
           byte[] buf = msg.getBytes("UTF-8");
           out.write(buf);
                       //输出结束后，要记得socket.shudownOutput()
           clientSocket.shutdownOutput();
           
           out.close();
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

客户端：

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

public class Client01 {
   public static void main(String[] args) {
       System.out.println("客户端运行...");
       
       // 【1】创建客户端socket
       Socket socket = null;
       try {
           socket = new Socket("192.168.2.56", 8000);
           
           // 【2】接收来自服务器的消息
           InputStream in = socket.getInputStream();
           byte[] buf = new byte[1024];
           int len = in.read(buf);
           
           String msg = new String(buf, 0, len, "UTF-8");
           System.out.println(msg);
           // 读取结束后，socket.shutdownInput()
                       socket.shutdownInput();
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

案例二：双向通信，模拟登录验证，采用传输对象的方式

服务器：

package objectTCP.server;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

import objectTCP.User;

public class Server {
   public static void main(String[] args) throws InterruptedException {
       System.out.println("Server started");
       try {
                       //创建服务器端
           ServerSocket server = new ServerSocket(8000);
           Socket client = server.accept();
           System.out.println(client.getInetAddress().getHostName() + " connected");
                       //接收
           InputStream in = client.getInputStream();
           ObjectInputStream ois = new ObjectInputStream(in);
           User user = (User)ois.readObject();
           client.shutdownInput();
           
           System.out.println(user.toString());
                       //发送
           if(user.getUsr().equals("admin") && user.getPsw().equals("12345")) {
               OutputStream out = client.getOutputStream();
               DataOutputStream dos = new DataOutputStream(out);
               dos.writeUTF("验证成功！");
               client.shutdownOutput();
           }else {
               OutputStream out = client.getOutputStream();
               DataOutputStream dos = new DataOutputStream(out);
               dos.writeUTF("密码、或用户名错误，验证失败！");
               client.shutdownOutput();
           }
           client.close();
           server.close();
       } catch (IOException e) {
           e.printStackTrace();
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }
   }
}

客户端：

package objectTCP.client;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

import objectTCP.User;

public class Client {
   public static void main(String[] args) {
       User user = new User();
       Scanner input = new Scanner(System.in);
       System.out.print("usrName: ");
       user.setUsr(input.nextLine());
       System.out.print("psw: ");
       user.setPsw(input.nextLine());
       try {
           Socket server = new Socket("192.168.3.2", 8000);
           OutputStream out = server.getOutputStream();
           ObjectOutputStream oos = new ObjectOutputStream(out);
           oos.writeObject(user);
           server.shutdownOutput();
           
           InputStream in = server.getInputStream();
           DataInputStream dis = new DataInputStream(in);
           System.out.println(dis.readUTF());
           server.shutdownInput();
           server.close();
           input.close();
       }catch (IOException e) {
           e.printStackTrace();
       }
   }
}

这里要注意，服务器端的 User 类和客户端的 User 类要处于一样的包路径下，且拥有一样的序列化 ID，不然会出现类型转换异常。

配合线程，可以实现多用户验证，效果如图：

4 UDP 编程

UDP 编程中，如果要完成通信，通信双方必须要创建 DatagramSocket，通过 DatagramSo-cket 完成通信。

DatagramPacket 数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息(字节数组，长度，目标ip，端口)从一台机器自动路由到另一台机器。TCP 类似于打电话，需要双方确认，而 UDP 类似于发短信，只要知道目的地即可发送。

UDP步骤:

创建一个DatagramSocket用于表示发送端，通过send方法发送数据报
创建一个DatagramSocket用于表示接收端，通过receive方法接收数据报

需求：两个客户端相互聊天

用户1：先接收消息再发送消息

package UDPClient2;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Test {
   public static void main(String[] args) {
       Scanner input = new Scanner(System.in);
       try {
           // 指定此程序的端口
           DatagramSocket socket = new DatagramSocket(4000);
           // 指定接受端的ip
           InetAddress desIp = InetAddress.getByName("192.168.2.138");
           while(true) {
               //接收消息
               byte[] rcvBuf = new byte[1024];
               DatagramPacket rcvPack = new DatagramPacket(rcvBuf, rcvBuf.length);
               socket.receive(rcvPack);
               System.out.println(rcvPack.getAddress().getHostName() + " --> " + new String(rcvBuf, 0, rcvPack.getLength(), "utf8"));
               
               
               //发送消息
               System.out.print("Your msg --> ");
               String msg = input.nextLine();
               byte[] sndBuf = msg.getBytes("utf8");
               // 创建发送出的包,指定了内容、目的地ip、目的地端口
               DatagramPacket sndPack = new DatagramPacket(sndBuf, sndBuf.length, desIp, 3000);
               //发送
               socket.send(sndPack);
           }
       } catch (SocketException e) {
           e.printStackTrace();
       } catch (UnsupportedEncodingException e) {
           e.printStackTrace();
       } catch (UnknownHostException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

用户2：先发送消息，再接收消息

package UDPClient1;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Test {
   public static void main(String[] args) {
       Scanner input = new Scanner(System.in);
       try {
           // 指定此程序的端口
           DatagramSocket socket = new DatagramSocket(3000);
           // 指定接受端的ip
           InetAddress desIp = InetAddress.getByName("192.168.2.138");
           while(true) {
               //发送消息
               System.out.print("Your msg --> ");
               String msg = input.nextLine();
               byte[] sndBuf = msg.getBytes("utf8");
               // 创建发送出的包,指定了内容、目的地ip、目的地端口
               DatagramPacket sndPack = new DatagramPacket(sndBuf, sndBuf.length, desIp, 4000);
               //发送
               socket.send(sndPack);
               
               
               //接收消息
               byte[] rcvBuf = new byte[1024];
               DatagramPacket rcvPack = new DatagramPacket(rcvBuf, rcvBuf.length);
               socket.receive(rcvPack);
               System.out.println(rcvPack.getAddress().getHostName() + " --> " + new String(rcvBuf, 0, rcvPack.getLength(), "utf8"));
           }
       } catch (SocketException e) {
           e.printStackTrace();
       } catch (UnsupportedEncodingException e) {
           e.printStackTrace();
       } catch (UnknownHostException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}