一篇文章带你入门java网络编程

更新时间：2021年08月04日 14:39:16 作者：正函数-

网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。本文介绍了一些网络编程基础的概念，并用Java来实现TCP和UDP的Socket的编程，来让读者更好的了解其原理

基于TCP/IP协议的通信

TCP/IP协议
- TCP/IP协议.会在通信两端建立连接（虚拟连接），用于发送和接收数据
- TCP/IP协议是一种可靠的网络协议，它通过重发机制来保证这种可靠性

通信的实现

ServerSocket用来监听来自客户端的连接，当没有连接时，它处于阻塞状态

客户端使用Socket连接到指定的服务器

基于UDP协议的通信

UDP协议
- UDP协议不会在通信两端建立连接（虚拟链路），而是直接发送连接
- UDP协议是一种不可靠的网络协议，但是这种协议的通信效率非常高
通信的实现
- DatagramSocket用于两端的通信，它不负责维护状态，不产生io流，仅仅是发送或接受数据包
- DatagramPacket代表数据包

在这里插入图片描述

InetAddress

/**
 *
 * InetAddressDemo
 *
 *
 */

public class InetAddressDemo {

    public static void main(String[] args) throws IOException {
        InetAddress baidu = InetAddress.getByName("www.baidu.com");
        System.out.println(baidu);
        System.out.println(baidu.getHostAddress());//获取主机地址
        System.out.println(baidu.isReachable(1000));//是否可达
        System.out.println("====================================================================================");
        InetAddress local = InetAddress.getByAddress(new byte[]{127, 0, 0, 1});
        System.out.println(local.getHostName());//获取主机名
        System.out.println(local.isReachable(1000));//是否可达
    }
}

在这里插入图片描述

案例演示（简易聊天室）

package javaserver.TcpServer;
import JAVAClient.TcpClient;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class tcpServer {
    public static ExecutorService threadPool= Executors.newFixedThreadPool(10);
    public static List<Socket> socketList= Collections.synchronizedList(new ArrayList<>());
    public static void main(String[] args) {
//
//        try {
//
//            //接受客户端的请求
//            ServerSocket serverSocket=new ServerSocket(9000);
//            while (true){
//                Socket socket = serverSocket.accept();//封装了一些客户端的信息
//                System.out.println("请求;" + socket.toString());
//
//                PrintStream ps=new PrintStream(socket.getOutputStream());
//                ps.println("welcome "+ socket.getInetAddress().getHostAddress());
//                socket.close();
//            }
//
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
        try {
            ServerSocket serverSocket = new ServerSocket(9000);
            while (true){
                Socket socket = serverSocket.accept();
                socketList.add(socket);
                threadPool.submit(new ThreadTask(socket));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}
class  ThreadTask implements  Runnable{
    private Socket  socket;
    private BufferedReader reader;
    public ThreadTask(Socket socket) {
        this.socket = socket;
        try {
            this.reader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        try {
            String line;
            while ((line=reader.readLine())!=null){
                for (Socket client: tcpServer.socketList){
                    String from=socket.getInetAddress().getHostAddress()+":::"+socket.getPort();
                    String content= from+"说"+line;
                    new PrintStream(client.getOutputStream()).println(content);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package JAVAClient;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TcpClient {
    public static ExecutorService threadPool= Executors.newFixedThreadPool(3);
    public static void main(String[] args) throws IOException {
//        Socket socket=new Socket("127.0.0.1",9000);
//        BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//        String s = br.readLine();
//        System.out.println(s);
        Socket socket=new Socket("127.0.0.1",9000);
        threadPool.submit(new ReadTask(socket));
        threadPool.submit(new WriteTask(socket));


    }
}

class ReadTask implements Runnable{
   private Socket socket;
   private BufferedReader reader;
    public ReadTask(Socket socket) {
        this.socket = socket;
        try {
            this.reader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        try {
            String line;
            while ((line=reader.readLine())!=null){
                System.out.println(line);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class WriteTask implements Runnable{
    private Socket socket;
    private PrintStream writer;
    public WriteTask(Socket socket) {
        this.socket = socket;
        try {
            writer=new PrintStream(socket.getOutputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        Scanner scanner = new Scanner(System.in);
        String line;
        while ((line=scanner.nextLine())!=null){
            writer.println(line);
        }
    }
}

在这里插入图片描述

UDP 演示

服务端

package javaserver.TcpServer;
import java.net.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class UdpServer {

    public static ExecutorService threadPool= Executors.newFixedThreadPool(10);
    public static List<InetSocketAddress> addressesList=new ArrayList<>();

    public static void main(String[] args) {
        try {
            DatagramSocket socket=new DatagramSocket(9001);
            // 随时通知
            threadPool.submit(new SendTask(socket));
            //接受访问 并且记录
            byte[] buffer=new byte[1024];
            DatagramPacket packet=new DatagramPacket(buffer,buffer.length);
            while (true){
                socket.receive(packet);
                addressesList.add((InetSocketAddress) packet.getSocketAddress());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class SendTask implements Runnable{
    private DatagramSocket socket;
    public SendTask(DatagramSocket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            Scanner scanner = new Scanner(System.in);
            String line;
            while ((line= scanner.nextLine())!=null){
                for (InetSocketAddress isa:UdpServer.addressesList){
                    byte[] buffer=line.getBytes();
                    DatagramPacket packet=new DatagramPacket(buffer,buffer.length,isa.getAddress(),isa.getPort());
                    socket.send(packet);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

客户端

package JAVAClient;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class UdpClient {
    public static ExecutorService threadPool= Executors.newFixedThreadPool(3);
    public static void main(String[] args) {
        try {
            DatagramSocket socket=new DatagramSocket();
//            注册
             DatagramPacket packet=new DatagramPacket(new byte[]{1},1, InetAddress.getByName("127.0.0.1"),9001);
             socket.send(packet);
//             接收
            threadPool.submit(new ReceiveTask(socket));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
class ReceiveTask implements Runnable{
    private DatagramSocket socket;
    public ReceiveTask(DatagramSocket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
   try {
       byte[] buffer=new  byte[1024];
       DatagramPacket packet=new DatagramPacket(buffer,buffer.length);
       while (true){
           socket.receive(packet);
           String line =new String(packet.getData(),0, packet.getLength());
           System.out.println(line);
       }
   } catch (Exception e) {
       e.printStackTrace();
   }
    }
}

在这里插入图片描述

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注脚本之家的更多内容！

您可能感兴趣的文章:

Sentinel热点规则示例详解分析
这篇文章主要介绍了何为热点？热点即经常访问的数据。很多时候我们希望统计某个热点数据中访问频次最高的 Top K 数据，并对其访问进行限制
2021-09-09
Java处理InterruptedException异常的理论与实践
在使用Java的过程中，有个情景或许很多人见过，您在编写一个测试程序，程序需要暂停一段时间，于是调用 Thread.sleep()。但是编译器或 IDE 报错说没有处理检查到的 InterruptedException。InterruptedException 是什么呢，为什么必须处理它？下面跟着小编一起来看看。
2016-08-08
MyBatis的SQL执行结果和客户端执行结果不一致问题排查
本文主要介绍了MyBatis的SQL执行结果和客户端执行结果不一致问题排查，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-04-04
java删除文件夹下所有文件示例分享
这篇文章主要介绍了java删除文件夹下所有文件示例,需要的朋友可以参考下
2014-02-02
深度剖析Java成员变量、局部变量和静态变量的创建和回收时机
这篇文章主要介绍了深度剖析Java成员变量、局部变量和静态变量的创建和回收时机,成员变量是定义在类中的变量，每个类的实例都会拥有自己的成员变量。它们的生命周期与对象的创建和销毁相对应,下面我将详细介绍它们的特点和生命周期,需要的朋友可以参考下
2023-07-07
浅谈Springmvc中的页面跳转问题
这篇文章主要介绍了浅谈Springmvc中的页面跳转问题，具有一定参考价值，需要的朋友可以了解下。
2017-12-12
TransmittableThreadLocal线程间传递逻辑示例解析
这篇文章主要介绍了TransmittableThreadLocal线程间传递逻辑示例解析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-06-06
Java实现计算器的代码
这篇文章主要为大家介绍了Java实现计算器的详细代码，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2018-06-06
Servlet实现多文件上传功能
这篇文章主要为大家详细介绍了Servlet实现文件上传功能，还可以实现Servlet多文件上传功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-03-03
深入了解Java对象的克隆
这篇文章主要介绍了Java对象的克隆的相关资料，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下
2020-08-08