Java基础-网络编程（TCP/UDP编程、TCP/UDP通信实现聊天室功能）

Java基础-网络编程（TCP/UDP编程、TCP/UDP通信实现聊天室功能）

本章内容需要一定的计算机网络知识，以下做一下概念扫盲

• 计算机网络：不同位置的主机通过通信线路连接（可理解为宽带），在网络操作系统、网络管理软件、以及一堆网络协议（tcp/udp）的协作下进行信息传递
• 网络编程：实现网络互通的不同计算机的运行程序之间的通信
• 网络模型：我们的“hello”从本计算机到其他计算机，根据使用协议（TCP/UDP）的不同，都要经过n层模型，步步转化，直至被对方接收（hello）

• IP地址：网络通信三兄弟的老大
• 端口号：网络通信三兄弟的老二
• 协议：TCP/UDP-老三

扫盲结束，上代码，本章节内容偏底层，可以不用理解得那么到位

基础-InetAddress类

管理ip、无构造器

特点：

• 单例模式（设计模式）
• 根据静态方法返回该对象

通过InetAddress可以获得同一网络下任意主机的网络信息，看代码：

    /*获得本地主机信息*/
    InetAddress localHost = InetAddress.getLocalHost() ;
    System.out.println(localHost);


    /*获得本地ip*/
    String host = localHost.getHostAddress();
    System.out.println(host);

    /*获得本地主机名*/
    String hostName = localHost.getHostName() ;
    System.out.println(hostName);

结果：

DESKTOP-AS6LJ9L/127.0.0.1
127.0.0.1
DESKTOP-AS6LJ9L

UDP通信互联聊天功能

客户端代码逻辑

1. 创建socket服务对象（UDP中为DataGramSocket）
2. 接收数据包（UDP使用DatagramPacket）
3. 解析数据（使用上述InetAddress）
4. 关闭资源（与流一样）

客户端具体代码

import sun.security.util.Length;

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

public class UdpServer {


    public static void main(String[] args) {
        /*创建socket对象*/
        DatagramSocket  ds = null  ;
        
        try {
            /*参数：自定义服务端口*/
            ds = new DatagramSocket(10000) ;
            /*创建一个字节数组*/
            byte[] bs = new byte[1024];
            /*创建数据包->接收数据
            * 数据接收完以第二参数的长度存入指定数组，以二进制存储，我们无法读，在下面转化为字符串
            * */
            DatagramPacket dp  = new DatagramPacket(bs,bs.length) ;
            
            System.out.println("UDP服务端已启动...");

            /*接收数据*/
            
            while (true) {
                
                /*接收数据*/
                ds.receive(dp);
                /*获得客户端的ip*/
                InetAddress inetAddress = dp.getAddress();
                /*获得数据*/
                byte[] data = dp.getData() ;//获得数据
                int len = dp.getLength() ;//获得数据长度
                String str = new String(data,0, len) ;//数据转化为字符串
                System.out.println(inetAddress.getHostAddress()+"发送的数据是："+str);

            }

             } catch (Exception e) {
                    e.printStackTrace();
            /*关闭资源*/
             }finally {
                if (ds!=null)
                ds.close();
             }


    }
}

客户端代码逻辑

1. 创建socket服务对象（UDP中为DataGramSocke）
2. 创建（DatagramPacke）
3. 发送数据包（send方法）

客户端代码

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

public class UdpClient {

    public static void main(String[] args) {

        /*创建客户端udp-socket*/
        DatagramSocket ds = null ;

        /*创建高效输入流*/
        BufferedReader reader = null ;

        try {
            ds = new DatagramSocket() ; //客户端socket
            reader = new BufferedReader(new InputStreamReader(System.in)) ;//从系统输入读取

            
            String line = null ;/*使用buffer读必备*/
            
            /*聊天->循环实现*/
            while ((line=reader.readLine())!=null){
                /*退出标志：控制台输入exit即退出服务*/
                if ("exit".equals(line))
                    break;

                byte[] bs = line.getBytes() ;//以字节byte形式打包发出
                /*创建数据包
                * 参数一：字节数组
                * 参数二：数组长度
                * 参数三:客户端网络信息（根据ip）
                * 参数四：端口号
                * */
                DatagramPacket dp  = new DatagramPacket(bs,bs.length, InetAddress.getByName("127.0.0.1"),10000) ;
                /*发送数据包*/
                ds.send(dp);
            }
            System.out.println("服务关闭，服务端24小时监听");

        } catch (Exception e) {
            e.printStackTrace();
            /*关闭所有流*/
        }finally {
            if (ds!=null)
                ds.close();
            if (reader!=null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }





}

TCP通信实现聊天功能

TCP服务端代码逻辑

1. 创建socket服务对象，指定端口（TCP中为ServerSocket）

2. 监听并获得客户端对象socket

3. 获得输入流（IO流不清楚的查我博客，讲得很清楚）

4. 读取数据

5. 释放资源

   TCP服务端代码

   import java.io.BufferedReader;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.InputStreamReader;
   import java.net.InetAddress;
   import java.net.ServerSocket;
   import java.net.Socket;
   
   public class TcpServer {
       public static void main(String[] args) {
           /*创建服务端socket*/
           ServerSocket ss = null ;
           /*获得客户端socket*/
           Socket s = null  ;
           /*高效输入流*/
           BufferedReader reader =null ;
           try {
               /*创建服务端socket对象，绑定端口号*/
               ss = new ServerSocket(10000) ;
               /*接收客户端的请求*/
               System.out.println("TCP服务端已开始监听");
               s = ss.accept() ;
   
               /*获得输入流对象*/
               InputStream in = s.getInputStream() ;
   
               /*聊天功能->循环接收-*/
               while (true) {
                   reader = new BufferedReader(new InputStreamReader(in));
                   /*读取数据*/
                   String line = reader.readLine();
                   /*结束标志*/
                   if ("exit".equals(line)){
                       System.out.println("服务关闭");
                       break;}
                   /*获得客户端网络信息*/    
                   InetAddress address = s.getInetAddress();
                   /*获得客户端的ip地址*/
                   String ip = address.getHostAddress();
                   System.out.println(ip + "发送了:" + line);
               }
   
   
   
   
           } catch (IOException e) {
               e.printStackTrace();
               
           /*关闭流*/
           }finally {
               try {
                   if (ss!=null)
                       ss.close();
                   if (s!=null)
                       s.close();
                   if (reader!=null)
                       reader.close();
               } catch (Exception e) {
                   e.printStackTrace();
               }
   
           }
           }
       }
   
   
   

TCP客户端代码逻辑

1. 创建客户端socket对象
2. 获得输出流
3. 写数据
4. 释放资源

TCP客户端代码

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

public class TcpClient {
    public static void main(String[] args) {
        /*创建socket对象*/
        Socket s = null ;
        /*输出流*/
        BufferedWriter writer = null ;
        /*用于读取控制台数据的输入流*/
        BufferedReader reader = null ;

        try {
            /*socket创建对象->指定ip和端口*/
            s = new Socket("127.0.0.1",10000) ;
            /*获得输出流*/
            OutputStream out = s.getOutputStream()  ;
            /*输入输出流*/
            writer = new BufferedWriter(new OutputStreamWriter(out)) ;
            reader = new BufferedReader(new InputStreamReader(System.in)) ;//从控制台读取

            /*高效bufferd读必备*/
            String line = null ;
            /*聊天功能->循环发送*/
            while (true) {
                /*读取控制台数据*/
                line = reader.readLine() ;
                /*写数据*/
                writer.write(line);
                writer.newLine();
                writer.flush();
                /*结束标志->读到exit结束客户端服务
                * TCP的服务端也需要同时关闭
                * */
                if ("exit".equals(line)){
                    System.out.println("服务关闭");
                    break;
            }}
        } catch (Exception e) {
            e.printStackTrace();
            /*关闭流*/
        }finally {
            try {
                if (s!=null)
                    s.close();
                if (writer!=null)
                    writer.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}