`

简单Client与Server的单向通信和双向通信

javasocket 
阅读更多

        从Console中读取内容：

BufferedReader inputReader;  
// Alt + Shift + z    try...catch等快捷键  
// 从Console读取内容  
try {  
    inputReader = new BufferedReader(new InputStreamReader(System.in));  
    String inputContent;  
    while (!(inputContent = inputReader.readLine()).equals("bye")) {  
        System.out.println(inputContent);  
    }  
} catch (Exception e) {  
    e.printStackTrace();  
}

一.单向通信

        Client -> Server

SocketClient.java

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class SocketClient {

    public static void main(String[] args) {
        SocketClient client = new SocketClient();
        client.start();
    }

    public void start() {
        BufferedReader inputReader = null;
        BufferedWriter writer = null;
        Socket socket = null;
        // 从Console读取内容  
        try {
            socket = new Socket("127.0.0.1", 9898);
            // 从socket进行写入  
            writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            inputReader = new BufferedReader(new InputStreamReader(System.in));
            String inputContent;
            while (!(inputContent = inputReader.readLine()).equals("bye")) {
                writer.write(inputContent + "\n");
                writer.flush(); 
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                writer.close();
                inputReader.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

SocketServer.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketServer {

    public static void main(String[] args) {
        SocketServer socketServer = new SocketServer();
        socketServer.startServer();
    }

    public void startServer() {
        ServerSocket serverSocket = null;
        BufferedReader reader = null;
        Socket socket = null;
        try {
            // 端口号只要不冲突就行  
            serverSocket = new ServerSocket(9898);
            System.out.println("server started..");
            // 进入阻塞状态，等待客户端接入  
            socket = serverSocket.accept();
            System.out.println("client " + socket.hashCode() + " connected");
            // 从socket中读取数据  
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String receiveMsg;
            while ((receiveMsg = reader.readLine()) != null) { // 以"\n"结束  
                System.out.println(receiveMsg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                reader.close();
                socket.close();
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 

二.Client Server双向通信

        即时接受消息，也就是所谓的长连接，记得要先启动Server。

SocketClient2.java

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class SocketClient2 {

    public static void main(String[] args) {
        SocketClient2 client = new SocketClient2();
        client.start();
    }

    public void start() {
        BufferedReader inputReader = null;
        // 从socket读取  
        BufferedReader reader = null;
        BufferedWriter writer = null;
        Socket socket = null;
        // Alt + Shift + z    try...catch等快捷键  
        // 从Console读取内容  
        try {
            socket = new Socket("127.0.0.1", 9898);
            // 用于读取服务器返回的数据  
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 从socket进行写入  
            writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            inputReader = new BufferedReader(new InputStreamReader(System.in));
            String inputContent;
            while (!(inputContent = inputReader.readLine()).equals("bye")) {
                writer.write(inputContent + "\n");
                writer.flush();
                //              System.out.println(inputContent);  
                // 服务器返回的数据  
                String response = reader.readLine();
                System.out.println(response);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                reader.close();
                writer.close();
                inputReader.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

SocketServer2.java

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketServer2 {

    public static void main(String[] args) {
        SocketServer2 socketServer = new SocketServer2();
        socketServer.startServer();
    }

    public void startServer() {
        ServerSocket serverSocket = null;
        BufferedReader reader = null;
        BufferedWriter writer = null;
        Socket socket = null;
        try {
            // 端口号只要不冲突就行  
            serverSocket = new ServerSocket(9898);
            System.out.println("server started..");
            // 进入阻塞状态，等待客户端接入  
            socket = serverSocket.accept();
            System.out.println("client " + socket.hashCode() + " connected");
            // 从socket中读取数据  
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            String receiveMsg;
            while ((receiveMsg = reader.readLine()) != null) { // 以"\n"结束  
                System.out.println(receiveMsg);
                writer.write("server reply:" + receiveMsg + "\n");
                writer.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                reader.close();
                writer.close();
                socket.close();
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 

三.Socket模拟http请求响应（仅模拟）

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.Random;

public class SimpleServer {
    private ServerSocket ss;
    private Socket socket;
    private BufferedReader in;
    private PrintWriter out;
    private Random random = new Random();

    public SimpleServer() {
        try {
            this.ss = new ServerSocket(9898);

            System.out.println("The server is waiting your input...");
            for (;;) {
                this.socket = this.ss.accept();

                this.in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
                this.out = new PrintWriter(this.socket.getOutputStream(), true);
                String line = this.in.readLine();

                System.out.println("you input is : " + line);

                String echo = randomEcho();
                System.out.println("echo : " + echo);
                StringBuilder sb = new StringBuilder();
                sb.append("HTTP/1.1 200 OK").append("\n")
                        .append("Content-Type:application/x-www-form-urlencoded;charset=UTF-8").append("\n")
                        .append("Date:").append(new Date().toString()).append("\n").append("Content-Length:")
                        .append(echo.getBytes().length).append("\n").append("\n").append(echo);

                this.out.println(sb.toString());
                this.out.flush();

                this.out.close();
                this.in.close();
                this.socket.close();
                if (line.equalsIgnoreCase("quit") || line.equalsIgnoreCase("exit") || line.equalsIgnoreCase("bye")) {
                    break;
                }
            }
            this.ss.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private String randomEcho() throws Exception {
        int num = this.random.nextInt();
        StringBuilder sb = new StringBuilder();
        sb.append("respCode=").append("0000").append("&").append("respMsg=").append("随机消息:" + num);
        //    String signature = SignUtil.sign(ResourcesUtils.getInstance().tppPriKey().trim().getBytes("UTF-8"), sb.toString());
        //    sb.append("&").append("signature=").append(signature);
        return sb.toString();
    }

    public static void main(String[] args) {
        new SimpleServer();
    }
}

 

参考文章：http://blog.csdn.net/DuanLiuchang/article/details/70148894?locationNum=13&fps=1

分享到：
| GRPC基础入门
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Remoting双向通信V3.0.rar

    这个"Remoting双向通信V3.0.rar"压缩包可能包含了一个演示或实现.NET Remoting V3.0版本中双向通信的示例项目，分为Client（客户端）和Server（服务器端）两个部分。 .NET Remoting允许不同进程甚至不同计算机上的...

    tomcat ssl单向/双向

    总结来说，"Tomcat SSL 单向/双向"涉及到网络通信的安全性，涵盖SSL证书的配置、服务器和客户端的认证，以及源码层面的理解。对于开发和运维人员，掌握这些知识对于构建安全的Web服务至关重要。

    使用Fleck和WebSocketSharp实现WebStock通信

    本主题聚焦于使用Fleck和WebSocketSharp两个库来实现WebSocket通信，这主要用于创建一个实时、双向的通信渠道，常见于股票交易系统、在线游戏等场景。在Windows桌面应用程序（Winform）开发中，C#语言提供了丰富的库...

    OpenSSL-s-client 和 s-server

    它提供了s_client和s_server两个命令行工具，用于测试和调试SSL/TLS连接。这两个工具在理解和分析SSL/TLS通信时非常有用。 1. **s_client**: s_client是OpenSSL提供的客户端模拟器，它可以用来与任何支持SSL或TLS的...

    socket通信实现单聊和多聊以及传文件

    2. **接收Client Connection**：当客户端尝试连接时，服务器调用`accept()`接收连接请求，返回一个新的Socket对象用于与客户端通信。 3. **发送与接收消息**：客户端和服务器端都可以使用`send()`和`recv()`方法来...

    Server-(1).zip_client server_数据传输_数据同步 c#

    在IT行业中，客户端-服务器（Client-Server）架构是一种常见的通信模式，广泛应用于数据传输和同步。本项目“Server-(1).zip”显然是一个与C#编程语言相关的客户端服务器应用程序，旨在实现数据的同步传输。以下是对...

    管道通信命名管道通信

    任务2中，展示了如何设计一个简单的命名管道通信系统，包括client和server端。client端（`fifo_clt.c`）通过调用`mkfifo()`创建FIFO文件，然后向管道发送请求，而server端（`fifo_svr.c`）监听并响应这些请求。当有...

    命名管道用于进程间双向通信

    本文将深入探讨命名管道的工作原理、API的使用方法以及如何通过编程实现匿名管道的双向通信。 首先，我们了解下命名管道的基本概念。命名管道是由一个进程创建，并为其他进程提供一个命名的访问点，通过这个名称，...

    IHS单双向SSL配置

    IHS（IBM HTTP Server）是IBM提供的一款强大的Web服务器，支持SSL（Secure Sockets Layer）和TLS（Transport Layer Security）协议，用于实现网络通信的安全加密。SSL配置分为单向认证和双向认证两种模式，分别适用...

    车载通信架构 - SOMEIP 协议概述

    该协议采用 C/S（Client/Server）的通信架构，采用远程服务调用（Remote Procedure Call）机制，实现服务的动态配置和数据传输。 SOME/IP 协议功能介绍： 1. 数据序列化与反序列化（Serialization/Deserialization...

    S7-1200 与 S7-300 CP343-1 S7 通信例程.zip

    S7通信主要有两种类型：S7通信伙伴（S7 Partner）和S7通信服务器/客户端（Server/Client）。在这个例子中，S7-1200可以作为客户端，S7-300通过CP343-1模块作为服务器，或者反之亦然。通信过程包括建立连接、数据交换...

    C# 管道通信 服务器

    2. 创建一个新的命名管道服务器实例，通过调用`NamedPipeServerStream`类的构造函数，指定管道名称、方向（双向或单向）、安全设置等参数。 3. 使用`WaitForConnection`方法等待客户端连接。当客户端连接时，此方法...

    QtTcp实现简单C/S消息发送与单向文件传输

    QTcpSocket是QtNetwork模块的一部分，它提供了一种方便的方式来处理TCP套接字，允许我们创建双向通信链路。在C/S模型中，服务器监听特定端口上的连接请求，而客户端则尝试连接到该端口。 **二、C/S消息发送与接收**...

    进程通信（套接字、内存映射、命名管道）范例

    命名管道是另一种进程间通信机制，它允许单向或双向数据流。与普通管道不同，命名管道可以在没有亲缘关系的进程之间建立连接。命名管道在 Windows 上称为命名管道，在 Unix-like 系统上则称为 FIFO。 #### 示例代码...

    匿名管道通信例子

    在Windows操作系统中，匿名管道是通过内核对象实现的，主要用于简单的单向通信。在这个例子中，我们将探讨如何使用Microsoft Foundation Classes（MFC）库来创建和使用匿名管道。 在MFC中，匿名管道可以通过`CFile`...

    命名管道服务端，客户端通信实例

    1. **单向或双向通信**：命名管道可以实现单向（数据只能从服务器流向客户端或反之）或双向（数据可以在两个方向上流动）通信。 2. **异步和同步**：服务端和客户端可以通过异步或同步方式交互，异步模式下，一个...

    C# 进程间通信 命名通道

    2. **单向与双向通信**：命名管道可以是单向或双向的。单向管道只能在一个方向上传输数据，而双向管道则允许数据在两个方向上同时传输。 3. **服务器与客户端**：在命名管道通信中，通常有一个创建并监听管道的进程...

    基于MFC网络通信设计.doc

    在这个模型中，客户机（Client）发起请求，服务器（Server）提供服务。在这个设计中，我们的目标是创建一个简单的对话框应用，使得两台运行Windows 7 64位系统的PC能够通过网络进行通信，一台作为客户机，另一台作为...

    minimal-grpc-client-server

    标题 "minimal-grpc-client-server" 暗示我们关注的是一个使用 gRPC 构建的简单客户端-服务器示例，该示例可能是用 Java 语言编写的。gRPC 是一个高性能、开源和通用的 RPC（远程过程调用）框架，它基于 HTTP/2 协议...

    进程将通信

    命名管道在进程间提供了一条单向或双向的数据流通道，可以实现半双工或全双工通信。每个管道都有一个唯一的名称，允许客户端通过这个名称找到并连接到服务端，从而进行通信。 在C#中，命名管道主要通过`System.IO....

Magicbox
Global site tag (gtag.js) - Google Analytics