Java Socket 通信 （四）

最新推荐文章于 2024-08-24 22:01:16 发布
最新推荐文章于 2024-08-24 22:01:16 发布
阅读量367 收藏 2
点赞数 1
分类专栏： Java 文章标签： socket 性能 java android server
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012209506/article/details/52840586
版权

前言：经过前三次的学习，今天又深入了一步。组长说，你尝试下传byte数组，你会遇到坑的。前几次，为了方便，我读流和写流都是用的readUTF()和writeUTF().直接写的String类型。于是我尝试了一下，直接传byte数组。代码如下：

Server端：

package mysocket.versiontwo;

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


/**
 * Created by demi on 16/10/12.
 */

public class JsonServer {

    public static void main(String args[]) {
        ServerSocket ss = null;
        Socket s = null;
        Thread thread = null;
        try {
            ss = new ServerSocket(3320);
            while (true) {
                s = ss.accept();
                System.out.println("Client :" + s.getInetAddress() + " : " + s.getPort() + " 已连接》》》》》》");
                thread = new Thread(new ServerThread(s));
                thread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

ServerThread.java 

package mysocket.versiontwo;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

/**
 * Created by demi on 16/10/14.
 */
public class ServerThread implements Runnable {
    private Socket s = null;
    DataInputStream dis = null;
    DataOutputStream dos = null;

    public ServerThread(Socket s) {
        this.s = s;
    }

    @Override
    public void run() {
        try {
            dos = new DataOutputStream(s.getOutputStream());
            dis = new DataInputStream(s.getInputStream());
            while (true) {
                byte[] bytes = new byte[1024];
                dis.read(bytes);
               String data= new String( bytes ,"UTF-8");
                System.out.println(new String( bytes ,"UTF-8"));
                if (null != data) {
                    if (!data.contains("data")) {
                        JSONObject jo = new JSONObject(data);
                        int a = jo.getInt("numA");
                        int b = jo.getInt("numB");
                        dos.write(creatSumJson(a, b).getBytes("UTF-8"));//写入数据到客户端
                        dos.flush();
                    } else {
                        JSONObject jo = new JSONObject(data);
                        int a = jo.getInt("data");
                        for (int i = 0; i < 100; i++) {
                            a++;
                            dos.write(createRandomJson(a).getBytes("UTF-8"));//写入数据到客户端
                            dos.flush();
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            try {
                dis.close();
                dos.close();
                s.close();
                System.out.print("链接已断开");
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }

    /**
     * 模拟现实项目中的接口,在做了自加运算后创建一个json。
     */

    public static String createRandomJson(int a) {
        JSONObject s = new JSONObject();
        try {
            s.put("data", a);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return s.toString();
    }

    /**
     * 模拟现实项目中的接口,获取客户端的两个加数，做完加法后返回给客户端。
     */
    //
    public static String creatSumJson(int a, int b) {
        JSONObject s = new JSONObject();
        try {
            s.put("sum", a + b);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return s.toString();
    }
}


Client端：

package mysocket.versiontwo;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Random;

/**
 * Created by demi on 16/10/12.
 */

public class JsonClient {

    public static void main(String args[]){
        DataOutputStream dos =null;
        Thread chat = null;
        Socket socket = null;
        DataInputStream dis =null;
        try {
            socket =new Socket("127.0.0.1",3320);
            dos =new DataOutputStream(socket.getOutputStream());
            dos.write(createRandomJson().getBytes("UTF-8")); //写入数据到服务器端
            chat = new Thread(new ChatThread(socket));
            chat.start();
            socket.setKeepAlive(true);
            int i = 0;
            while(i<=100){
                Thread.sleep(1000);
                dos.write(creatSumJson().getBytes("UTF-8"));//写入数据到服务器端
                i++;
            }
        } catch (IOException e) {
            e.printStackTrace();
            try {
                dos.close();
                socket.close();
                chat.stop();
                System.out.print("链接已断开");
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    /**
     * 模拟现实项目中的接口,创建一个20以内的随机数的json,发送到服务器,让服务器做++运算,加一次向客户端推送一次结果。
     */

    public static String createRandomJson(){
        JSONObject s = new JSONObject();
        try {
            s.put("data", new Random().nextInt(20));
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return s.toString() ;
    }

    /**
     * 模拟现实项目中的接口,创建两个100以内的随机数的json,发送到服务器,让服务器做完加法后返回给客户端。
     */
    //
    public static String creatSumJson(){
        JSONObject s =new JSONObject();
        try {
            s.put("numA", new Random().nextInt(100));
            s.put("numB", new Random().nextInt(100));
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return s.toString() ;
    }
}

ChatThread.Java 

package mysocket.versiontwo;

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

/**
 * Created by demi on 16/10/13.
 */

public class ChatThread implements Runnable {
    private Socket s = null;
    DataInputStream dis =null;
    public ChatThread(Socket s){
        this.s = s;
    }

    @Override
    public void run() {
        try {
            dis =new DataInputStream(s.getInputStream());
            while(true){
                byte[] bytes = new byte[1024];
                dis.read(bytes);

                System.out.println(new String( bytes ,"UTF-8")); //打印来自服务器的数据
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

正高高兴兴的run并和组长说，没坑啊。结果程序一运行起来，坑就来了！请看截图

我发现客户端读数据的时候，读的长度是不确定的，有时候一次性读的多，有时候就读一个。所以这就需要一个分隔机制，来限制读的长度。那首先想到的就是，在读流之前告诉对方，我的流的byte数组的长度。这样就可以避免这个问题了。还有一个问题就是，之前我还能通过json字段来判断是哪个接口，现在咋判断呢？这就需要cmd(命令号了)。那就在传json前,先把cmd，byte数组的长度传过去，再传json。但听前辈们说还谣传一个标识符，来标记是哪一次请求，防止多次请求过后，返回回来的结果对应不上。这个值传到服务器，服务器也会把这个值再传回来，客户端判断这个值与传过去的值是否一致。来对应请求。修改后的代码如下：

ServerThread.java

package mysocket.versionfour;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

/**
 * Created by demi on 16/10/14.
 */
public class ServerThread extends Thread {

    private Socket s = null;
    DataInputStream dis = null;
    DataOutputStream dos = null;

    public ServerThread(Socket s) {
        this.s = s;
    }

    @Override
    public void run() {
        try {
            dos = new DataOutputStream(s.getOutputStream());
            dis = new DataInputStream(s.getInputStream());
            while (true) {
                readFromClient();
            }
        } catch (Exception e) {
            e.printStackTrace();
            try {
                dis.close();
                dos.close();
                s.close();
                System.out.print("链接已断开");
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }

    /**
     * 模拟现实项目中的接口,在做了自加运算后创建一个json。
     */

    public static String createRandomJson(int a) {
        JSONObject s = new JSONObject();
        try {
            s.put("data", a);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return s.toString();
    }

    /**
     * 模拟现实项目中的接口,获取客户端的两个加数，做完加法后返回给客户端。
     */
    //
    public static String creatSumJson(int a, int b) {
        JSONObject s = new JSONObject();
        try {
            s.put("sum", a + b);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return s.toString();
    }

    public void write2Client(byte[] bytes,int tag) throws  Exception{
        dos.writeInt(bytes.length);//传过去的byte数组的长度
        dos.writeInt(tag);
        dos.write(bytes);
        dos.flush();
    }

    public void readFromClient(){

        try {
            int length=dis.readInt();
            byte[] bytes = new byte[length];
            int cmd = dis.readInt();
            int tag = dis.readInt();
            dis.read(bytes,0,length);
            String data= new String( bytes ,"UTF-8");
            System.out.println(tag + ":" +new String( bytes ,"UTF-8"));
            JSONObject jo = new JSONObject(data);
            switch (cmd){
                case CMD.SUM :
                    int a = jo.getInt("numA");
                    int b = jo.getInt("numB");
                    write2Client(creatSumJson(a, b).getBytes("UTF-8"),tag);
                    break;
                case CMD.RANDOMADD :
                    int random = jo.getInt("data");
                    for (int i = 0; i < 100; i++) {
                        random++;
                        write2Client(createRandomJson(random).getBytes("UTF-8"),tag);
                    }
                    break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}
ClientReadTHread.java 

package mysocket.versionfour;

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

/**
 * Created by demi on 16/10/13.
 */

public class ClientReadThread extends Thread {
    private Socket s = null;
    DataInputStream dis =null;
    public ClientReadThread(Socket s){
        this.s = s;
    }

    @Override
    public void run() {
        try {
            dis =new DataInputStream(s.getInputStream());
            while(true){
                readFromServer();
            }
        } catch (Exception e) {
            e.printStackTrace();
            try {
                dis.close();
                s.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
    public void readFromServer() throws Exception{
        int length=dis.readInt();
        byte[] bytes = new byte[length];
        int tag =dis.readInt();
        dis.read(bytes,0,length);
        System.out.println(tag+":"+new String( bytes ,"UTF-8")); //打印来自服务器的数据
    }
}


ClientWriteThread.java

package mysocket.versionfour;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Random;

/**
 * Created by demi on 16/10/13.
 */

public class ClientWriteThread extends Thread {
    private static int tag;
    private Socket s = null;
    DataOutputStream dos =null;

    public ClientWriteThread(Socket s){
        this.s = s;
    }

    @Override
    public void run() {
        try {
            dos = new DataOutputStream(s.getOutputStream());
            byte[] bytes = createRandomJson().getBytes("UTF-8");
            write2Server( bytes, CMD.RANDOMADD);
            int i = 0;
            while (i <= 100) {
                Thread.sleep(1000);
                byte[] sumBytes = creatSumJson().getBytes("UTF-8");
                write2Server( sumBytes, CMD.SUM);
                i++;
            }
        } catch (Exception e) {
            e.printStackTrace();
            try {
                dos.close();
                s.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
    /**
     * 模拟现实项目中的接口,创建一个20以内的随机数的json,发送到服务器,让服务器做++运算,加一次向客户端推送一次结果。
     */

    public static String createRandomJson() {
        JSONObject s = new JSONObject();
        try {
            s.put("data", new Random().nextInt(20));
            tag = new Random().nextInt(1000)+1000;
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return s.toString();
    }

    /**
     * 模拟现实项目中的接口,创建两个100以内的随机数的json,发送到服务器,让服务器做完加法后返回给客户端。
     */

    public static String creatSumJson() {
        JSONObject s = new JSONObject();
        try {
            s.put("numA", new Random().nextInt(100));
            s.put("numB", new Random().nextInt(100));
            tag = new Random().nextInt(1000)+1000;
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return s.toString();
    }

    public void write2Server( byte[] bytes, int cmd) throws Exception {
        dos.writeInt(bytes.length);//传过去的byte数组的长度
        dos.writeInt(cmd);//命令号，通过命令号来辨别是哪个接口！
        dos.writeInt(tag);//标志位，标记是那哪一次请求。
        dos.write(bytes);
        //dos.writeUTF(createRandomJson());
        dos.flush();
    }
}

CMD.java 

package mysocket.versionfour;

/**
 * Created by demi on 16/10/14.
 */
public class CMD {
    //两加数求和
    public static final int SUM = 1001;
    //随机数自加一
    public static final int RANDOMADD = 1002;
}

运行结果就正常了。


这就是进步！下一步就开始封装Socket了！期待吧！


DX_Demi
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java之Socket通信
小男孩儿的博客
03-03 1927
一、TCP/IP协议 TCP/IP是目前世界上应用最为广泛的协议，是以TCP和IP为基础的不同层次上多个协议的集合 也称：TCP/IP协议族 或 TCP/IP协议栈 TCP：Transmission Control Protocol 传输控制协议 IP：Internet Protocol 互联网协议 TCP/IP模型 应用层的协议： HTTP 超文文传输协议 FTP 文件传输协议 SMTP 简单邮件传输协议 Telnet 远程登录服务 IP地址 ...
Java实现Socket通信
热门推荐
gao_zhennan的博客
06-04 1万+
前言：花了一个多星期的时间，重新学习了计算机网络中可靠数据传输的知识和TCP、UDP协议。在掌握了基本的理论后，想通过编程实践，来巩固和加深下对Socket通信的理解。 一 项目简介 1. 开发环境 操作系统：win10 Java版本：1.8 开发工具：IDEA 2021 2. 项目描述 本项目基于TCP协议，实现了客户端和服务器的Socket通信。项目主要实现了查字的功能，客户端输入要查询的一个汉字，然后回车发送到服务器端，服务器把汉字的查询结果在返回给客户端。另外，在使用服务器提供的字典服务前，客户
使用Java完成Socket通信
m0_57099067的博客
04-18 9162
用Java实现一个最基本的Socket_TCP编程 可以放在一个项目中，创建两个Java文件 注意：先运行服务器端（SocketTCP_Server类） 再运行客户端（SocketTCP_Client类） import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; /** 服务器端 */ public class SocketTCP_Server { pu...
Java Socket通信之UDP协议
可能是一只知更鸟
03-18 4664
什么是网络编程？ Socket套接字 流套接字 数据报套接字 面试题：TCP协议和UDP协议的区别？ java数据报套接字通讯模型（Socket UDP以及常见的API） UDP数据报套接字编程 回显服务器 查字典服务器
Java中的Socket通信
qq_46291038的博客
07-24 1073
1.TCP 是传输控制协议的缩写，它保障了两个应用程序之间的可靠通信。 通常用于互联网协议，被称 TCP/IP。 2.Socket套接字使用TCP提供了两台计算机之间的通信机制。 客户端程序创建一个套接字，并尝试连接服务器的套接字。 3.当连接建立时，服务器会创建一个 Socket 对象。客户端和服务器现在可以通过对 Socket 对象的写入和读取来进行通信。 4.java.net.Socket 类代表一个套接字，并且 java.net.ServerSocket 类为服务...
基于 Java 简单实现 Socket 通信
技术分享、唠嗑水文、如有不周、还望海涵
12-05 5637
J3 - 白起 技术（TCP/IP # UDP # Socket） 最近开了个项目：https://gitee.com/j3_baiqi/communication 欢迎大家指点一下项目结构、编码问题、业务方向????????????????????????。 一、什么是 Socket 百科： 白话就是，基于网络通信协议所制定的交互接口（接口就是规范）。 既然是接口，那必然就有实现，所以本次所有讲述的就是用 Java 来实现的一种 Socket 通信。但实现之前还是要铺垫一下两个网络通信中的重要协议：
java实现简单的Socket通信
weixin_46028606的博客
09-26 1930
先上一个简单的示意图，图中ServerSocket准确的说应该是Server。 Socket翻译成“套接字”比较难以理解，我觉得翻译称为插座比较合适， 两个程序可以通过插座之间通信，插进去就能联系上，至于Socket具体怎么实现的可以不用管，反正就是可以像电线一样传输数据就行！ 首先是客户端，要先指定IP地址和port（端口）连接才能联系得上对应的服务器，因此，要想成功的联系上，就必须先把服务器启动了，再运行客户端，如果先启动了Client，就会爆“Exception, in ,thread “main”
socket通信（java实现）
Estrus5的博客
11-15 2950
socket通信
java socket 加密,Java socket通信实现DES加密与解密
weixin_39653764的博客
03-13 1640
DES是对称加密算法的其中一个，用一个密钥进行加密解密数据，安全性能比较低，效率较高，一些不太重要的数据可以使用DES加密算法进行加密解密传输，其他的3DES与AES用法类似。流程图首先认真看一下流程图，在脑海里过一遍，然后其实也就是分为以下两个过程，传输完密钥后，就可以使用这个密钥加密数据发送给服务器，服务器拿密钥解密数据，完事。OK，直接贴代码吧，注意下Base64转码传输以及密钥的传输就行了...
Java Socket 通信
02-27
Java Socket通信是网络编程中的重要一环，它提供了在两台计算机之间建立低级连接的能力，使得数据可以在两个应用程序之间双向传输。在这个过程中，一台计算机作为服务器（Server），等待客户端（Client）的连接请求...
java Socket通信实现.zip
08-27
Java Socket通信是网络编程中的基础概念，主要用于两台计算机之间的数据传输。Socket在Java中被封装为类，提供了客户端和服务器端进行双向通信的能力。在这个"java Socket通信实现.zip"的压缩包中，可能包含了关于...
深入理解Java Socket通信
08-31
本文将深入探讨Java Socket通信的核心概念，包括ServerSocket和Socket的使用，以及TCP/IP协议在其中的角色。 首先，Java中的Socket可以分为普通Socket和NioSocket两种类型。普通Socket基于传统的I/O模型，而Nio...
java Socket通信实现
06-06
Java Socket通信实现是Java网络编程中的重要组成部分，它允许两台计算机通过TCP/IP协议进行双向通信。在Java中，Socket提供了低级别的、基于连接的、面向数据流的通信API，可以用于实现客户端-服务器架构的应用程序...
Java Socket 聊天通信演示代码
05-31
首先，Java Socket通信基于TCP（传输控制协议），它确保了数据的可靠传输，包括数据的顺序和无丢失。在聊天应用中，服务器端创建一个Socket监听特定的端口，等待客户端的连接请求。一旦客户端连接到服务器，它们之间...
阿里云服务器 篇七：服务器热备份/定时备份
最新发布
生活在别处
08-24 61
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 500
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1039
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 687
linux上datax 安装以及使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值