Socket编程一实现简易的聊天功能以及文件传输

最新推荐文章于 2020-12-18 12:53:37 发布
最新推荐文章于 2020-12-18 12:53:37 发布
阅读量2.8k 收藏 20
点赞数
分类专栏： Java

Socket编程一实现简易的聊天功能以及文件传输

标签： androidsocket通讯协议聊天socket传输文件
2017-02-21 21:26 174人阅读 评论(6) 收藏 举报


干程序是一件枯燥重复的事，每当感到内心浮躁的时候，我就会找小说来看。我从小就喜爱看武侠小说，一直有着武侠梦。从金庸，古龙，梁羽生系列到凤歌（昆仑），孙晓（英雄志）以及萧鼎的（诛仙）让我领略着不一样的江湖。

如果你有好看的武侠系列小说，给我留言哦。题外话就扯这么多了，接着还是上技术。

看看今天实现的功能效果图：

soc.gif

可以这里使用多台手机进行通讯，【凤歌】我采用的服务器发送消息。

是不是只有发送消息，有些显得太单调了。好，在发送消息的基础上增加文件传输。后期会增加视频，音频的传输，增加表情包。那一起来看看图文消息的效果图，带领大家一起来实现通讯的简易聊天功能。

soc.gif

需要解决的难点：

  • 如何判断socket接收的数据是字符串还是流？

如果你已是一名老司机，还请留言给出宝贵意见。带着这个疑问我们接着往下看。

Socket概述

Socket我们称之为”套接字”，用于消息通知系统（如：激光推送），时事通讯系统（如：环信）等等。用于描述IP地址和端口，是一个通信链的句柄。网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket，一个Socket由一个IP地址和一个端口号唯一确定（如：ServerSocket）。应用程序通常通过”套接字”向网络发出请求或者应答网络请求。Socket是TCP/IP协议的一个十分流行的编程界面，但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。

java.NET包下有两个类：Socket和ServerSocket，基于TCP协议。

本文针对Socket和ServerSocket作主要讲解。

socket连接

建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket ，另一个运行于服务器端，称为ServerSocket。

客户端Socket

Socket的构造方法：

Socket(InetAddress address,int port); //创建一个流套接字并将其连接到指定 IP 地址的指定端口号
Socket(String host,int port); //创建一个流套接字并将其连接到指定主机上的指定端口号
Socket(InetAddress address,int port, InetAddress localAddr,int localPort); //创建一个套接字并将其连接到指定远程地址上的指定远程端口
Socket(String host,int port, InetAddress localAddr,int localPort); //创建一个套接字并将其连接到指定远程主机上的指定远程端口
Socket(SocketImpl impl); //使用用户指定的 SocketImpl 创建一个未连接 Socket

参数含义：

  • address 双向连接中另一方的IP地址

  • port 端口号

  • localPort 本地主机端口号

  • localAddr 本地机器地址

  • impl 是socket的父类，既可以用来创建serverSocket又可以用来创建Socket

注意：我们在选取端口号的时候需要特别注意，每一个端口提供一种特定的服务，只有给出正确的端口，才能获得相应的服务。0~1023的端口号为系统所保留，例如http服务的端口号为80,telnet服务的端口号为21,ftp服务的端口号为23。本文选取的端口号为30003

Socket的几个重要方法：

public InputStream getInputStream(); //方法获得网络连接输入，同时返回一个IutputStream对象实例
public OutputStream getOutputStream(); //方法连接的另一端将得到输入，同时返回一个OutputStream对象实例
public Socket accept(); //用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。

注意对流异常的处理。

服务端ServerSocket

ServerSocket的构造方法：

ServerSocket(int port); //创建绑定到特定端口的服务器套接字
ServerSocket(int port,int backlog); //利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号
ServerSocket(int port,int backlog, InetAddress bindAddr); //使用指定的端口、侦听 backlog 和要绑定到的本地 IP地址创建服务器

消息与文件的接收和发送

基础常量

Constants常量类：

    //连接ip地址 可以通过以下代码查看当前 IP 地址，记住在网络适配里关掉其他的连接，只保留当前连接
    //注意关掉防火墙，关闭杀毒软件
    /**
     * InetAddress ia = null;
     * try {
     * ia = ia.getLocalHost();
     * <p>
     * String localname = ia.getHostName();
     * String localip = ia.getHostAddress();
     * System.out.println("本机名称是：" + localname);
     * System.out.println("本机的ip是 ：" + localip);
     * } catch (Exception e) {
     * // TODO Auto-generated catch block
     * e.printStackTrace();
     * }
     */
    public static final String HOST = "192.168.199.164";
    //端口号  避免端口冲突 我这里取30003
    public static final int PORT = 30003;

    //收到消息
    public static final int RECEIVE_MSG = 0;

    //发送消息
    public static final int SEND_MSG = 1;

    //发送文件
    public static final int SEND_FILE = 2;

    //传输文件
    public static final int TRANSFER_FILE = 3;

    //传输字符串
    public static final int TRANSFER_STR = 4;

    //聊天列表 发送消息
    public static final int CHAT_SEND = 1;

    //聊天列表 接收消息
    public static final int CHAT_FROM = 2;

    //更新进度
    public static final int PROGRESS = 5;

注意：关闭多余的网络适配，关闭防火墙。

定义协议

为了保证接收到的数据类型统一（数据是字符串还是流），需要定义协议。定义协议的方式有很多种：

  • 发送一个握手信号。 根据握手信号来确定发送的是字符串还是流

  • 定义了Header（头）和Body（实体），头是固定大小的，用来告诉接收者数据的格式、用途、长度等信息，接收者根据Header来接受Body。

  • 自定义协议

我这里采用的自定义协议，原理跟前面两种类似。我传输的是JSON数据，根据字段标识传输的是字符串还是流，接收者根据标识去解析数据即可。

协议的实体类（Transmission）：

    //文件名称
    public String fileName;

    //文件长度
    public long fileLength;

    //传输类型
    public int transmissionType;

    //传输内容
    public String content;

    //传输的长度
    public long transLength;

    //发送还是接受类型    1发送  2接收
    public int itemType = 1;

    //0 文本  1  图片
    public int showType;

根据字段transmissionType去标识传输（序列化）或接收（反序列化）的类型。传输的过程中始终都是以JSON的格式存在的。传输文件时需要把流转换成字符串（方式很多种我用的是Base64加密与解密）。

客户端（ClientThread）
public class ClientThread extends Thread {

    PrintWriter mPrintWriter;
    BufferedReader mBufferedReader;
    Socket mSocket;

    Handler mSendHandler;
    Handler mWriteHandler;

    Gson mGson;

    public ClientThread(Handler handler) {
        mSendHandler = handler;
        mGson = new Gson();
    }

    @Override
    public void run() {
        super.run();

        try {
            //创建socket
            mSocket = new Socket(Constants.HOST, Constants.PORT);
            //获取到读写对象
            mPrintWriter = new PrintWriter(mSocket.getOutputStream());
            mBufferedReader = new BufferedReader(new InputStreamReader(mSocket.getInputStream()));

            //新开线程读取消息 并发送消息
            new Thread() {
                @Override
                public void run() {
                    super.run();
                    String content = null;
                    try {
                        while ((content = mBufferedReader.readLine()) != null) {
                            Transmission trans = mGson.fromJson(content, Transmission.class);
                            if (trans.transmissionType == Constants.TRANSFER_STR) {
                                Message msg = new Message();
                                msg.what = Constants.RECEIVE_MSG;
                                msg.obj = content;
                                mSendHandler.sendMessage(msg);
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }.start();

            //当前线程创建 handler
            Looper.prepare();
            mWriteHandler = new Handler() {
                @Override
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    if (msg.what == Constants.SEND_MSG) {
                        mPrintWriter.write(msg.obj.toString() + "\r\n");
                        mPrintWriter.flush();
                    } else if (msg.what == Constants.SEND_FILE) {//传输文件
                        //定义标记判定是字符串还是文件
                        sendFile(msg.obj.toString());
                    }
                }
            };
            Looper.loop();

        } catch (IOException e) {
            e.printStackTrace();
            //出现异常关闭资源
            try {
                if (mPrintWriter != null) {
                    mPrintWriter.close();
                }
                if (mBufferedReader != null) {
                    mBufferedReader.close();
                }
                if (mSocket != null) {
                    mSocket.close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }

    }

    /**
     * 文件路径
     *
     * @param filePath
     */
    private void sendFile(String filePath) {
        FileInputStream fis = null;
        File file = new File(filePath);

        try {
            mSendHandler.sendEmptyMessage(Constants.PROGRESS);

            fis = new FileInputStream(file);

            Transmission trans = new Transmission();
            trans.transmissionType = Constants.TRANSFER_FILE;
            trans.fileName = file.getName();
            trans.fileLength = file.length();
            trans.transLength = 0;

            byte[] bytes = new byte[1024];
            int length = 0;
            while ((length = fis.read(bytes, 0, bytes.length)) != -1) {
                trans.transLength += length;
                trans.content = Base64Utils.encode(bytes);
                mPrintWriter.write(mGson.toJson(trans) + "\r\n");
                mPrintWriter.flush();

                Message message = new Message();
                message.what = Constants.PROGRESS;
                message.obj = 100 * trans.transLength / trans.fileLength;
                mSendHandler.sendMessage(message);
            }
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            mPrintWriter.close();
        }
    }

在MainActivity中开启客户端线程：

    mClientThread = new ClientThread(mHandler);
    mClientThread.start();
服务端（MyServer）
public class MyServer {

    //多客户端
    public static ArrayList<Socket> sSockets = new ArrayList<Socket>();

    public static void main(String[] args) {
        //DatagramSocket 基于UDP协议的
        ServerSocket serverSocket = null;

        try {
            //创建服务器的socket对象
            serverSocket = new ServerSocket(Constants.PORT);

            while (true) {
                Socket socket = serverSocket.accept();
                sSockets.add(socket);
                //开启线程
                new Thread(new ServerThread(socket)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
   
   
  • 25

ServerThread 类：

public class ServerThread implements Runnable {

    Socket mSocket;
    BufferedReader mBufferedReader;
    Gson mGson;

    boolean mCreateFile = true;

    public ServerThread(Socket socket) throws IOException {

        mGson = new Gson();
        mSocket = socket;
        mBufferedReader = new BufferedReader(new InputStreamReader(mSocket.getInputStream(), "utf-8"));
        //新开线程给客服端发送消息
        new Thread() {
            @Override
            public void run() {
                super.run();
                sendMessage();
            }
        }.start();
    }

    @Override
    public void run() {
        readMessage();
    }

    //读取的数据发送给客户端
    private void readMessage() {
        String content = null;
        FileOutputStream fos = null;
        try {
            while ((content = mBufferedReader.readLine()) != null) {
                Transmission trans = mGson.fromJson(content, Transmission.class);
                if (trans.transmissionType == Constants.TRANSFER_STR) {
                    System.out.println("" + content);
                    for (Iterator<Socket> it = MyServer.sSockets.iterator();
                         it.hasNext(); ) {
                        if (it == null) {
                            break;
                        }
                        Socket s = it.next();
                        try {

                            PrintWriter printWriter = new PrintWriter(s.getOutputStream());
                            printWriter.write(content + "\r\n");
                            printWriter.flush();

                        } catch (SocketException e) {
                            e.printStackTrace();
                            it.remove();
                        }
                    }
                } else {
                    long fileLength = trans.fileLength;
                    long transLength = trans.transLength;
                    if (mCreateFile) {
                        mCreateFile = false;
                        fos = new FileOutputStream(new File("d:/" + trans.fileName));
                    }
                    byte[] b = Base64Utils.decode(trans.content.getBytes());
                    fos.write(b, 0, b.length);
                    System.out.println("接收文件进度" + 100 * transLength / fileLength + "%...");
                    if (transLength == fileLength) {
                        mCreateFile = true;

                        fos.flush();
                        fos.close();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            try {
                if (fos != null) {
                    fos.close();
                }
                if (mBufferedReader != null) {
                    mBufferedReader.close();
                }
                if (mSocket != null) {
                    mSocket.close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            MyServer.sSockets.remove(mSocket);
        }
    }

    //发送消息给连接的客服端
    private void sendMessage() {
        BufferedReader bufferedReader = null;
        try {
            while (true) {
                bufferedReader = new BufferedReader(new InputStreamReader(System.in));
                System.out.print("请输入发送的字符串：");
                String str = bufferedReader.readLine();
                for (Iterator<Socket> it = MyServer.sSockets.iterator();
                     it.hasNext(); ) {
                    if (it == null) {
                        break;
                    }
                    Socket s = it.next();
                    try {
                        Transmission trans = new Transmission();
                        trans.itemType = Constants.CHAT_FROM;
                        trans.transmissionType = Constants.TRANSFER_STR;
                        trans.content = str;

                        PrintWriter printWriter = new PrintWriter(s.getOutputStream());
                        printWriter.write(mGson.toJson(trans) + "\r\n");
                        printWriter.flush();

                    } catch (SocketException e) {
                        e.printStackTrace();
                        s.close();
                        it.remove();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }
                MyServer.sSockets.remove(mSocket);
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
}

首先运行MyServer的main函数，把服务启动起来，然后运行MainActivity把客户端启动起来。这样就实现了两端通讯。

源码地址


 
 
我的同类文章
Aurora Polaris
关注
专栏目录
网络编程--socket的一个简单的小案例--文件的复制
geek_xiong的博客
09-23 800
socket的一个简单的小案例–文件的复制 实现将一个文件（包括图片等）复制一份 考虑二进制文件，如音频，视频等，所以直接以二进制的形式进行拷贝 服务端用来接收文件 客户端用来发送文件 服务端： 创建套接字 绑定地址 等待客户端连接 打开新的一个文件用来保存数据 接收客户端发送到数据 将数据写到新的文件中 关闭文件，关闭套接字 客户端： 创建套接字 连接服务端 打开文件 读取文件 向服务端发...
socket编程实例，客户端和服务器端一对一信息传输
10-08
在vc下使用socket实现的一个程序，完成客户端和服务器端一对一信息传输。
循序渐进Socket网络编程（多客户端、信息共享、文件传输）
weixin_30410119的博客
01-25 202
循序渐进Socket网络编程（多客户端、信息共享、文件传输） 　　前言：在最近一个即将结束的项目中使用到了Socket编程，用于调用另一系统进行处理并返回数据。故把Socket的基础知识总结梳理一遍。 1、TCP/IP协议 　　既然是网络编程，涉及几个系统之间的交互，那么首先要考虑的是如何准确的定位到网络上的一台或几台主机，另一个是如何进行可靠高效的数据传输。这里就要使用到TCP...
网络编程-Socket客户端和服务器之间聊天与文件传输（GUI）
纸上得来终觉浅，绝知此事要躬行
05-12 3763
课程实验需要，在此记录 1.客户端与服务器局域网聊天室 package 网络编程; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import...
Socket编程一实现简易的聊天功能以及文件传输.docx
最新发布
10-25
为了实现文件传输，需要将文件读取为字节流，然后通过Socket的输出流写入到网络，服务器端则通过输入流接收并保存到本地。为了区分文本消息和文件传输，可以约定特定的协议头，比如文件传输前发送一个特殊的标识符。...
android Socket实现简单聊天功能以及文件传输
08-31
在本文中，我们将探讨如何使用Socket来构建简单的聊天应用以及实现文件传输。 首先，Socket是网络编程中的基础组件，它提供了一种在不同设备间建立可靠连接的方式。在Java中，Socket和ServerSocket是进行TCP/IP通信...
MFC　socket编程　简易聊天工具及文件传输（vs2010）
12-27
在本文中，我们将深入探讨如何使用Microsoft Foundation Class (MFC) 库进行Socket编程，以创建一个简单的聊天工具并实现文件传输功能。该程序在Visual Studio 2010环境下开发，通过`client`和`server`两个核心组件...
基于java socket网络编程实现的简单模拟qq聊天的程序，可实现并发聊天
06-10
Java Socket网络编程是Java语言中实现网络通信的基础，它提供了低级别的、面向连接的、可靠的字节流服务。在这个基于Java Socket实现的简单模拟QQ聊天程序中，我们主要探讨以下几个核心知识点： 1. **Socket原理**...
Java基于socket实现简易聊天室实例
09-03
【Java基于socket实现简易聊天室】的实例是一个基础的网络通信应用，用于演示如何通过Java的Socket编程在服务器端和客户端之间实现简单的文本聊天功能。在这个实例中，我们使用了两个核心类：`SendDemo` 和 `...
使用Socket实现聊天，传输文件（无需服务器）
03-01
c# 使用Socket进行文件传输，聊天。程序大小22kb
文件传输和聊天程序(c语言实现)
10-18
使用scoket套接字文件传输和对话的c语言程序！有服务器端和客户端！需同时打开两个文件在运行结果窗口中操作!(c语言写的)
java实现的TCP聊天及文件传输功能
10-27
java实现的TCP聊天及文件传输功能，欢迎大家使用
C++写的多对多聊天，实现了大文件数据的传送，用了包机制
12-29
C++写的多对多聊天，实现了大文件数据的传送，用了包机制
java简单聊天室的例子，带传文件功能
08-18
以前培训时写的java简单聊天室小例子，带有文件传输功能
Socket编程 ——文件传输
4ct10n
11-30 2499
一.实验内容 1 利用流式套接字实现文件传输 内容： 客户端向服务端发起socket连接，并建立数据传输通道； 2 客户端向服务端发送要传输的文件名称，以‘#’字符结尾，服务端逐字符接收，直到接收到#； 3 （变长数据）客户端向服务端发送文件长度，4字节； 4（定长数据）客户端向服务端发送文件内容； 5（变长数据）服务端接收完文件后，向客户端发送‚OK，以示成功接收。
Socket 聊天室收发文件
weixin_44724691的博客
12-18 537
TcpServer import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.security.Provider; import java.util.*; public class TcpServ
网络编程（socket）文件图片等传送
09-09
网络编程（socket）文件图片等传送
c++实现局域网文件传送基于socket
12-07
c++实现局域网文件传送基于socket含客户端和服务端
C++ Socket编程入门：简易服务器实现详解
"C++ Socket网络编程大全是一本深入介绍在C++环境下进行网络编程的详细指南，主要关注于使用Windows Sockets API（Winsock2）进行通信。本书涵盖了从基础到进阶的概念，包括但不限于：安装和配置Winsock库、套接字...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值