朝花夕拾之socket的基本使用以及mina框架简单介绍

最新推荐文章于 2024-03-21 07:45:08 发布
最新推荐文章于 2024-03-21 07:45:08 发布
阅读量277 收藏
点赞数
文章标签： java 移动开发 网络
原文链接：https://juejin.im/post/5c9c6f95f265da60f30d5ccb
版权

工欲善其事，必先利其器，从互联网诞生到现在，基本上所有的程序都是网络程序，很少有单机版的程序了。 而网络编程的本质是两个设备之间的数据交换，当然，在计算机网络中，设备主要指计算机。我们现在进行网络编程，基本上都是使用已经封装好的框架，毕竟自己实现维护一套网络编程框架，费时费力不说，做出来之后还不一定好用，有那时间多保养保养头发。

Socket简介

记得大学学习java的时候，并没有接触网络编程相关的基础知识，一直都是单机版程序，没有见识到网络编程的美妙，所以对socket这个东西既熟悉又陌生。熟悉的原因是在MFC实验课中接触到socket知识的，没错，就是那门古老的开发语言，现在已经销声匿迹了，陌生的原因大概也就不言而喻了。好了，说了那么多，那socket到底是什么呢？

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口 。很多同学会把tcp、udp协议和socket搞混，其实Socket只是一种连接模式，不是协议。tcp、udp是两个最基本的协议，很多其它协议都是基于这两个协议。

用socket可以创建tcp连接，也可以创建udp连接，这意味着，用socket可以创建任何协议的连接。简单的来说，socket相当于一艘船，你把目的地（ip+端口）告诉它，把要运输的货物搬上去，然后它将货物送往目的地。这个货物具体需要怎么运输，运输完成之后是否还要通知你已经到达目的地，这就是实现协议的区别了。

Socket使用

首先来回顾一下socket的基本使用，创建一个服务端所需步骤

  1. 创建ServerSocket对象绑定监听端口。
  2. 通过accept()方法监听客户端的请求。
  3. 建立连接后，通过输入输出流读取客户端发送的请求信息。
  4. 通过输出流向客户端发送请求信息。
  5. 关闭相关资源。

嗯。。。Talk is cheap,Show me the code：

public class SocketServer {
    public static void main(String[] args) {
        //第一步
        SocketServer socketServer = new SocketServer();
        socketServer.startServer(2333);
    }
    private void startServer(int port) {
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.println("服务器已启动,等待客户连接...");
            //第二步 调用accept()方法开始监听，等待客户端的连接 这个方法会阻塞当前线程
            Socket socket = serverSocket.accept();
            System.out.println("客户端连接成功");
            //第三步 建立输入输出流读数据
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            String receivedMsg;
            while ((receivedMsg = bufferedReader.readLine()) != null && !("end").equals(receivedMsg)) {
                System.out.println("客户端：" + receivedMsg);
                //第四步 给客户端发送请求
                String response = "hello client";
                System.out.println("我(服务端)：" + response);
                bufferedWriter.write(response+ "\n");
                bufferedWriter.flush();
            }
            //关闭相关资源
            socket.close();
            serverSocket.close();
            bufferedWriter.close();
            bufferedReader.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
复制代码

创建一个客户端所需步骤，其实和服务端代码差不多：

  1. 创建Socket对象，指明需要连接的服务器的地址和端口。
  2. 建立连接后，通过输出流向服务器发送请求信息。
  3. 通过输入流获取服务器的响应信息。
  4. 关闭相关资源
public class SocketClient {
    public static void main(String[] args){
        SocketClient socketClient = new SocketClient();
        socketClient.startClient(2333);
    }
    void startClient(int port){
        try {
            Socket clientSocket = new Socket("localhost",port);
            System.out.println("客户端已启动");
            //给服务器发消息
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));
            //接收服务器传过来的消息
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            //键盘输入消息  发送给服务端
            BufferedReader inputReader = new BufferedReader(new InputStreamReader(System.in));
            String readLine = null;
            while (!(readLine = inputReader.readLine()).equals("bye")){
                System.out.println("我(客户端)：" + readLine);
                //将键盘输入的消息发送给服务器
                bufferedWriter.write(readLine+"\n");
                bufferedWriter.flush();
                String response = bufferedReader.readLine();
                System.out.println("服务端: " + response);
            }
            bufferedWriter.close();
            inputReader.close();
            clientSocket.close();
        }catch (IOException e){
            e.printStackTrace();
        }
        
    }
}
复制代码

以上对于socket的示例比较简单，只实现了客户端给服务器发送消息，服务器收到消息并回复客户端。现实的情况其实很复杂，如服务器高并发的处理，客户端怎么监听服务器随时发来的消息，客户端断线重连机制，心跳包的处理，还有在对消息的拆包、粘包的处理等等。而引入mina框架，我们不必关注复杂的网络通信的实现，只需专注于具体的业务逻辑。

Mina框架简介

MINA框架是对java的NIO包的一个封装，简化了NIO程序开发的难度，封装了很多底层的细节，让开发者把精力集中到业务逻辑上来。可能有一些同学不知道NIO是什么，这里简单介绍一下，NIO就是new IO，是jdk1.4引入的，它是同步非阻塞的，比如一个服务器多个客户端，客户端发送的请求都会注册到服务器的多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。它适用于连接数目多且连接比较短的架构，比如聊天服务器。

mina简单使用

Mina 的API 将真正的网络通信与我们的应用程序隔离开来，你只需要关心你要发送、接收的数据以及你的业务逻辑即可。如果想要使用mina，需要先去apache下载mina的jar包：mina下载地址，我使用的是2.0.16版本，下载解压之后，只需要使用mina-core-2.0.16.jar和slf4j-android.jar这两个包即可.

先看看我们实现的效果图(由于是视频转gif，可能不太好看出来，就是一个简单的文本通讯)：

创建服务端

前面说mina将网络通信与我们的应用程序隔离开来，那我们看看怎么样实现一个TCP的服务端，最近在学习kotlin，以后的代码应该都用kotlin展示了：

//创建一个非阻塞的service端的socket
val acceptor = NioSocketAcceptor()
//设置编解码器  ProtocolCodecFilter拦截器 网络传输需要将对象转换为字节流
acceptor.filterChain.addLast("codec",ProtocolCodecFilter(TextLineCodecFactory()))
//设置读取数据的缓冲区大小
acceptor.sessionConfig.readBufferSize = 2048
//读写通道10秒内无操作进入空闲状态 
acceptor.sessionConfig.setIdleTime(IdleStatus.BOTH_IDLE, 10)
//绑定端口
acceptor.bind(InetSocketAddress(8080))
复制代码

这段代码我们就初始化了一个TCP服务端，其中，编解码器使用的是mina自带的换行符编解码器工厂，设置编解码器是因为在网络上传输数据时，发送端发送数据需要将对象转换为字节流进行传输，接收端收到数据后再将字节流转换回来。相当于双方约定一套规则，具体规则可以自己定，也可以用现成的。我这里只需要发送文本，就用内置的啦。

网络通信已经实现，那发送、接收数据呢？我们具体的业务逻辑都在IoHandler这个类中进行处理，编写一个类继承IoHandlerAdapter ，并重写它的几个方法，记得在bind端口之前调用acceptor.setHandler(MyIoHandlerAdapter())，不然无法监听到具体事件 ：

/**
     * 向客户端发送消息后会调用此方法
     * @param session
     * @param message
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun messageSent(session: IoSession?, message: Any?) {
        super.messageSent(session, message)
        LogUtils.i("服务器发送消息成功")
    }

    /**
     * 从端口接受消息，会响应此方法来对消息进行处理
     * @param session
     * @param message
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun messageReceived(session: IoSession?, message: Any?) {
        super.messageReceived(session, message)
        val msg = message!!.toString()
        LogUtils.i("服务器接收消息成功：$msg")
    }

    /**
     * 服务器与客户端创建连接
     * @param session
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionCreated(session: IoSession?) {
        super.sessionCreated(session)
        LogUtils.i("服务器与客户端创建连接")
    }

    /**
     * 服务器与客户端连接打开
     * @param session
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionOpened(session: IoSession?) {
        super.sessionOpened(session)
        LogUtils.i("服务器与客户端连接打开")
    }

    /**
     * 关闭与客户端的连接时会调用此方法
     * @param session
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionClosed(session: IoSession?) {
        super.sessionClosed(session)
        LogUtils.i("关闭与客户端的连接时会调用此方法")
    }

    /**
     * 服务器进入空闲状态
     * @param session
     * @param status
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionIdle(session: IoSession?, status: IdleStatus?) {
        super.sessionIdle(session, status)
        LogUtils.i("服务器进入空闲状态")
    }

    /**
     * 异常
     * @param session
     * @param cause
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun exceptionCaught(session: IoSession?, cause: Throwable) {
        super.exceptionCaught(session, cause)
        LogUtils.i("服务器异常$cause")
    }
复制代码

大家应该注意到IoSession这个东西了，每一个方法参数里都有它，那它具体是干什么的呢？

IoSession是一个接口，这个接口用于表示Server 端与Client 端的连接，IoAcceptor.accept()的时候返回实例。这个接口有如下常用的方法：

  1. WriteFuture write(Object message)：这个方法用于写数据，该操作是异步的。
  2. CloseFuture close(boolean immediately)：这个方法用于关闭IoSession，该操作也是异步的，参数指定true 表示立即关闭，否则就在所有的写操作都flush 之后再关闭。
  3. Object setAttribute(Object key,Object value)：这个方法用于给我们向会话中添加一些属性，这样可以在会话过程中都可以使用，类似于HttpSession 的setAttrbute()方法。IoSession 内部使用同步的HashMap 存储你添加的自定义属性。
  4. SocketAddress getRemoteAddress()：这个方法获取远端连接的套接字地址。
  5. void suspendWrite()：这个方法用于挂起写操作，那么有void resumeWrite()方法与之配对。对于read()方法同样适用。
  6. ReadFuture read()：这个方法用于读取数据， 但默认是不能使用的， 你需要调用IoSessionConfig 的setUseReadOperation(true)才可以使用这个异步读取的方法。一般我们不会用到这个方法，因为这个方法的内部实现是将数据保存到一个BlockingQueue，假如是Server 端，因为大量的Client 端发送的数据在Server 端都这么读取，那么可能会导致内存泄漏，但对于Client，可能有的时候会比较便利。
  7. IoService getService()：这个方法返回与当前会话对象关联的IoService 实例。

换言之，拿到IoSession就能够进行两端打call了，什么？你问我怎么打call？

fun sendText(message: String,client IoSession){
    var ioBuffer = IoBuffer.allocate(message.toByteArray().size)
    ioBuffer.put(message.toByteArray())
    ioBuffer.flip()
    client.write(ioBuffer)
}
复制代码
创建客户端

无论是Server 端还是Client 端，在Mina中的执行流程都是一样的。唯一不同的就是IoService 的Client 端实现是IoConnector。

val connector = NioSocketConnector()
// 设置链接超时时间
connector.connectTimeoutMillis = 15000
// 添加过滤器
connector.filterChain.addLast("codec",ProtocolCodecFilter(TextLineCodecFactory()))
connector.setDefaultRemoteAddress(InetSocketAddress(ip, port))
val future = connector.connect()
future.awaitUninterruptibly()// 等待连接创建完成
var session = future.session// 获得IoSession
复制代码

IoHandlerAdapter 和服务端一样，这里不做过多介绍。

最后贴上服务端代码：

class MinaServer : IoHandlerAdapter(){
    private val acceptor: NioSocketAcceptor
    private var isConnected = false
    private var handler: Handler by Delegates.notNull()
    init {
        //创建一个非阻塞的service端的socket
        acceptor = NioSocketAcceptor()
        //设置编解码器  ProtocolCodecFilter拦截器 网络传输需要将对象转换为字节流
        acceptor.filterChain.addLast("codec",
                ProtocolCodecFilter(TextLineCodecFactory()))
        //设置读取数据的缓冲区大小
        acceptor.sessionConfig.readBufferSize = 2048
        //读写通道10秒内无操作进入空闲状态
        acceptor.sessionConfig.setIdleTime(IdleStatus.BOTH_IDLE, 10)
        handler = Handler()

    }

    fun connect(port: Int): MinaServer {
        if (isConnected)
            return this
        thread {
            try {
                //注册回调 监听和客户端之间的消息
                acceptor.handler = this
                acceptor.isReuseAddress = true
                //绑定端口
                acceptor.bind(InetSocketAddress(port))
                isConnected = true
                handler.post {
                    connectCallback?.onOpened()
                }
            } catch (e: Exception) {
                e.printStackTrace()
                handler.post {
                    connectCallback?.onError(e)
                }
                LogUtils.i("服务器连接异常")
                isConnected = false
            }
        }
        return this
    }

    fun sendText(message: String){
        for (client in acceptor.managedSessions.values){
            var ioBuffer = IoBuffer.allocate(message.toByteArray().size)
            ioBuffer.put(message.toByteArray())
            ioBuffer.flip()
            client.write(ioBuffer)
        }
    }

    /**
     * 向客户端发送消息后会调用此方法
     * @param session
     * @param message
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun messageSent(session: IoSession?, message: Any?) {
        super.messageSent(session, message)
        LogUtils.i("服务器发送消息成功")
        connectCallback?.onSendSuccess()
    }

    /**
     * 从端口接受消息，会响应此方法来对消息进行处理
     * @param session
     * @param message
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun messageReceived(session: IoSession?, message: Any?) {
        super.messageReceived(session, message)
        handler.post {
            connectCallback?.onGetMessage(message)
        }
        val msg = message!!.toString()
        LogUtils.i("服务器接收消息成功：$msg")
    }

    /**
     * 服务器与客户端创建连接
     * @param session
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionCreated(session: IoSession?) {
        super.sessionCreated(session)
        handler.post {
            connectCallback?.onConnected()
        }
        LogUtils.i("服务器与客户端创建连接")
    }

    /**
     * 服务器与客户端连接打开
     * @param session
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionOpened(session: IoSession?) {
        super.sessionOpened(session)
        LogUtils.i("服务器与客户端连接打开")
    }

    /**
     * 关闭与客户端的连接时会调用此方法
     * @param session
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionClosed(session: IoSession?) {
        super.sessionClosed(session)
        handler.post {
            connectCallback?.onDisConnected()
        }
        LogUtils.i("关闭与客户端的连接时会调用此方法")
    }

    /**
     * 服务器进入空闲状态
     * @param session
     * @param status
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionIdle(session: IoSession?, status: IdleStatus?) {
        super.sessionIdle(session, status)
        LogUtils.i("服务器进入空闲状态")
    }

    /**
     * 异常
     * @param session
     * @param cause
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun exceptionCaught(session: IoSession?, cause: Throwable) {
        super.exceptionCaught(session, cause)
        handler.post {
            connectCallback?.onError(cause)
        }
        LogUtils.i("服务器异常$cause")
    }

    private var connectCallback:ConnectCallback? = null
    fun setConnectCallback(callback:ConnectCallback){
        this.connectCallback = callback
    }
    interface ConnectCallback{
        fun onSendSuccess()
        fun onGetMessage(message: Any?)
        fun onOpened()
        fun onConnected()
        fun onDisConnected()
        fun onError(cause: Throwable)
    }

}
复制代码

​

在服务端中的activity中使用：

 			var mServer = MinaServer()
            mServer
                    .connect(2333)
                    .setConnectCallback(object : MinaServer.ConnectCallback {
                        override fun onSendSuccess() {
                            //发送消息成功
                        }

                        override fun onGetMessage(message: Any?) {
                            //接收消息成功
                            val msg = message.toString()
                        }

                        override fun onOpened() {
                            
                        }
                        override fun onConnected() {

                        }

                        override fun onDisConnected() {

                        }

                        override fun onError(cause: Throwable) {
                            Toast.makeText(applicationContext, "服务器异常" + cause.toString(), Toast.LENGTH_SHORT).show()
                        }

                    })
复制代码

再看客户端代码：

lass MinaClient : IoHandlerAdapter(){
    private val connector: NioSocketConnector
    private var session: IoSession? = null

    var isConnected = false
    private var handler:Handler by Delegates.notNull()
    init {
        connector = NioSocketConnector()
        // 设置链接超时时间
        connector.connectTimeoutMillis = 15000
        // 添加过滤器
        connector.filterChain.addLast("codec",
                ProtocolCodecFilter(TextLineCodecFactory()))
        handler = Handler()
    }

    fun connect(ip: String, port: Int): MinaClient {
        if (isConnected)
            return this
        thread {
            connector.handler = this
            connector.setDefaultRemoteAddress(InetSocketAddress(ip, port))
            //开始连接
            try {
                val future = connector.connect()
                future.awaitUninterruptibly()// 等待连接创建完成
                session = future.session// 获得session
                isConnected = session != null && session!!.isConnected
            } catch (e: Exception) {
                e.printStackTrace()
                handler.post {
                    connectCallback?.onError(e)
                }
                println("客户端链接异常...")
            }
        }
        return this
    }
    fun disConnect(){
        if (isConnected){
            session?.closeOnFlush()
            connector.dispose()
        }else{
            connectCallback?.onDisConnected()
        }
    }

    fun sendText(message: String){
        var ioBuffer = IoBuffer.allocate(message.toByteArray().size)
        ioBuffer.put(message.toByteArray())
        ioBuffer.flip()
        session?.write(ioBuffer)
    }
    /**
     * 向服务端端发送消息后会调用此方法
     * @param session
     * @param message
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun messageSent(session: IoSession?, message: Any?) {
        super.messageSent(session, message)
        LogUtils.i("客户端发送消息成功")
        handler.post {
            connectCallback?.onSendSuccess()
        }
    }

    /**
     * 从端口接受消息，会响应此方法来对消息进行处理
     * @param session
     * @param message
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun messageReceived(session: IoSession?, message: Any?) {
        super.messageReceived(session, message)
        LogUtils.i("客户端接收消息成功：")
        handler.post {
            connectCallback?.onGetMessage(message)
        }
    }

    /**
     * 服务器与客户端创建连接
     * @param session
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionCreated(session: IoSession?) {
        super.sessionCreated(session)
        LogUtils.i("服务器与客户端创建连接")
        handler.post {
            connectCallback?.onConnected()
        }
    }

    /**
     * 服务器与客户端连接打开
     * @param session
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionOpened(session: IoSession?) {
        super.sessionOpened(session)
        LogUtils.i("服务器与客户端连接打开")
    }

    /**
     * 关闭与客户端的连接时会调用此方法
     * @param session
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionClosed(session: IoSession?) {
        super.sessionClosed(session)
        LogUtils.i("关闭与客户端的连接时会调用此方法")
        isConnected = false
        handler.post {
            connectCallback?.onDisConnected()
        }
    }

    /**
     * 客户端进入空闲状态
     * @param session
     * @param status
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun sessionIdle(session: IoSession?, status: IdleStatus?) {
        super.sessionIdle(session, status)
        LogUtils.i("客户端进入空闲状态")
    }

    /**
     * 异常
     * @param session
     * @param cause
     * @throws Exception
     */
    @Throws(Exception::class)
    override fun exceptionCaught(session: IoSession?, cause: Throwable) {
        super.exceptionCaught(session, cause)
        LogUtils.i("客户端异常$cause")
        handler.post {
            connectCallback?.onError(cause)
        }
    }
    private var connectCallback:ConnectCallback? = null
    fun setConnectCallback(callback:ConnectCallback){
        this.connectCallback = callback
    }
    interface ConnectCallback{
        fun onSendSuccess()
        fun onGetMessage(message: Any?)
        fun onConnected()
        fun onDisConnected()
        fun onError(cause: Throwable)
    }
}
复制代码

客户端的activity中使用：

		var mClient = MinaClient()
        mClient
                .connect("192.168.0.108", 2333)
                .setConnectCallback(object : MinaClient.ConnectCallback {
                    override fun onGetMessage(message: Any?) {
                        val msg = message.toString()
                    }
                    override fun onConnected() {
                        
                    }

                    override fun onDisConnected() {
                        Toast.makeText(applicationContext, "断开连接成功", Toast.LENGTH_SHORT).show()
                    }
                    override fun onError(cause: Throwable) {
                        Toast.makeText(applicationContext, "服务器异常" + cause.toString(), Toast.LENGTH_SHORT).show()
                    }

                    override fun onSendSuccess() {

                    }

                })
复制代码

界面布局比较简单，就是一个recyclerview+几个button，如果觉得我讲得不够清楚T^T，可以到github上查看源码：minaSimple

weixin_34198762
关注
socket
ThreeAspects的博客
04-16 386
建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket ，另一个运行于服务器端，称为ServerSocket 。套接字之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。 服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求 客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器...
Socket编程及mina框架简单示例
洽洽老大的专栏
02-12 9581
要实现客户端与服务器的长连接，可以使用socket的方式连接服务器与客户端。在这篇文章中，将用原生的方式实现socket的服务器端和客户端，然后用Mina框架再实现一次。 原生方式上： 客户端可实现如下： SocketClient:package socketClient;import java.io.BufferedReader; import java.io.IOException; im
高并发MINA框架，网络编程（SOCKET）实现，简单的网络聊天DEMO
三也_攻城狮
12-11 6061
服务端 和http://blog.csdn.net/simonchi/article/details/40613923   文章类似 Apache MINA是一个网络应用程序框架，用来帮助用户简单地开发高性能和高可扩展性的网络应用程序。它提供了一个通过Java NIO在不同的传输例如TCP/IP和UDP/IP上抽象的事件驱动的异步API 对JAVA的SOCKET做了一层包装 Apach
socket编程基本框架
生亦何欢，死亦何苦？
04-19 1260
TCP编程的服务器端一般步骤是：1、创建一个socket，用函数socket()；2、设置socket属性，用函数setsockopt(); /* 可选 */3、绑定IP地址、端口等信息到socket上，用函数bind();4、开启监听，用函数listen()；5、接收客户端上来的连接，用函数accept()；6、收发数据，用函数send()和recv()，或者read()和wri
socket编程学习1----socket编程框架
qingkongyeyue的博客
08-04 1361
1.    基于TCP（面向连接）的socket编程 (1.1)服务器端程序  创建套接字socket  将套接字绑定到一个本地地址和端口上bind 将套接字设为监听模式，准备接收客户请求listen 等待客户请求到了；当请求到来后，接收连接请求，返回一个新的对应于此次连接的套接字accept  用返回的套接字和客户端进行通信rend/ recv 关闭套接字 (1.2)客户端程序
Socket简介
LU1196700392的专栏
07-02 637
目录 引子： 为何学习socket一定要先学习互联网协议呢？ 客户端/服务器架构 1.硬件C/S架构(打印机) 2.软件C/S架构(互联网中处处是C/S架构)：B/S架构也是C/S架构的一种，B/S是浏览器/服务器 C/S架构与socket的关系:我们用socket就是为了完成C/S架构的开发 OSI七层协议(*******) 互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层 每层运行常见物理设备 引子： 须知一个完整的计算机系统是由硬件，操作系统，应用.
Java springboot 整合mina 框架，nio通讯基础教程，mina框架基础教程.zip
08-15
总结来说，本教程将引导你从理论到实践，掌握Java NIO的基本原理，理解Mina框架的使用，以及如何在SpringBoot环境中整合Mina实现高效的网络通信。通过这些知识的学习，你将具备开发高并发、高性能网络应用的能力。
mina框架中socket使用，有服务端和客户端。
03-18
2. **Socket编程**：Socket是网络通信的基本组件，它在MINA框架中被用来建立和管理网络连接。Socket提供了一种进程间通信（IPC）的方式，允许两个远程系统之间交换数据。MINA框架中的Socket服务端和客户端通过Socket...
mina框架使用总结.doc
09-19
mina 框架使用总结 mina 框架是对 Java 的 NIO 包的一个封装，简化了 NIO 程序开发的难度，封装了很多底层的细节，使开发者把精力集中到业务逻辑上来。下面是对 mina 框架使用的总结。 1. MINA 框架概述 MINA ...
Mina+Socket通信
07-17
文件"MinaSocket"可能包含了实现上述功能的详细代码，包括服务端的Acceptor配置、过滤器设置、事件处理器编写，以及客户端的Socket连接、数据发送和接收等。通过阅读和理解这些代码，你可以更好地掌握Mina与Socket...
目前.NET最强SOCKET框架组“北风之神”（ZYSOCKET） 3.1 源代码
04-09
感谢大家对北风之神SOCKET框架的支持。鼓励。下面是北风之神 3.1的更新内容： 修正BUG: 1.ZYSocketSuper 读取 配置文件的最大连接数 读错问题。 2.ZYSocketSuper 无法断开客户端的问题。 3.BuffList 数据包解析丢失问题。 4.例1，例2.客户端断开忘记释放调用SOCKET.CLOSE（）的问题 新增功能 1.添加了一个ReadBytes 构造函数，此函数实现了在数据包在读取前需要回调的方法传入。（可以用来解密，解压缩 等功能） 2.添加了一个BufferFormat 类的构造，此函数实现了在数据包在生成前需要回调的方法传入。（可以用来加密，压缩 等功能） 3.添加了BufferFormat.FormatFCA(object o,FDataExtraHandle dataExtra)静态方法。可以用来在类格式化成数据包的时候进行加密压缩等功能 4.添加了ZYSocket.Security 命名空间，里面有传统的AES,DES算法的加解密类 5.添加了ZYSocket.Compression命名空间，里面有通过Deflate算法压缩类 6.开发了ReadBytes.Data属性，为ReadBytes里面的BYTE[]对象。值得注意的是 ReadBytes.Length为数据包原始长度，如果要得到解压缩后的数据包长度，请访问ReadByte.Data.length 新增代码 加解密实例测试 项目:演示了 AES DES 以及Deflate 的使用方法。 例3 - 例2的加密版 项目：就是讲例2通过DES 加密进行通讯的例子 连接测试工具 项目:很多朋友问我要连接数量测试工具。我一起的真的丢了。找不到了。所以重新写了一个 例4 项目：好多人让我写一个发送文件的例子，现在能如愿以偿了 by luyikk@126.com BLOG:http://blog.csdn.net/luyikk QQ:547386448
简述基本TCP套接字编程(一）
u013644957的博客
04-26 814
最近在看UNP的基本TCP套接字编程这一章，现总结如下： 首先用一张图阐述一下基本TCP socket的C/S框架 （1）socket函数 #include int socket(int family,int type,int protocol) 函数说明： 用于创建一个套接字 参数说明： family制定协议族，该参数也被称作协议域。具体常值如下表： fa
我们到底选择哪一款开源的Socket框架？
跟着阿笨一起玩NET
02-28 4512
一、摘要 FastSocket（简称:FS）突出:简单灵活、上手容易。 SuperSocket（简称:SS）突出:功能丰富、扩展强大。 二、FS和SS摆在我们的面前，那么我们应该选择哪一个玩呀？ 2.1、什么是FastSocket？ 1）、FS是一个轻量级易扩展的c#异步socket通信库，项目开始于2011年，经过近3年不断调整与改进，目前在功能和性能上均有不错的表现。 2）、FS...
EasySocket一款轻量级的Android端Socket框架
热门推荐
相忘于江湖
06-12 2万+
源码地址：https://github.com/jiusetian/EasySocket EasySocket的初衷是希望使Socket编程变得更加简单、快捷，因此项目在实现了Socket基本功能的基础上，还实现了TCP层面的请求回调功能。传统的Socket框架客户端发出一个请求信息，然后服务器返回一个应答信息，但是我们无法识别这个应答信息是对应哪个请求的，而EasySocket实现了将每个请求...
简洁实用Socket框架DotNettySocket
最新发布
weixin_68436326的博客
03-21 375
转自：寒空飞箭cnblogs.com/coldairarrow/p/11336771.html简介DotNettySocket是一个.NET跨平台Socket框架（支持.NET4.5+及.NET Standard2.0+），同时支持TcpSocket、WebSocket和UdpSocket，其基于微软强大的DotNetty框架，力求为Socket通讯提供简单、高效、优雅的操作方式。安装方式：Nug...
Socket通信封装MIna框架--含羞代放
chun1927506的博客
08-21 160
[TOC] Mina异步IO使用的Java底层JNI框架,Mina提供服务端和客户端,将我们的业务解耦开发.真正做到高内聚低耦合的思想 核心类 <font color="red">IoService</font> :Mina中将服务端和客户端都看成是服务,这里提供统...
高性能 TCP & UDP 通信框架 HP-Socket v3.4.1
qq897558368的博客
05-13 915
HP-Socket 是一套通用的高性能 TCP/UDP 通信框架，包含服务端组件、客户端组件和 Agent 组件，广泛适用于各种不同应用场景的 TCP/UDP 通信系统，提供 C/C++、C#、Delphi、E（易语言）、Java、Python 等编程语言接口。HP-Socket 对通信层实现完全封装，应用程序不必关注通信层的任何细节；HP-Socket 提供基于事件通知模型的 API 接口，能非
SuperSocket 一个轻量级可扩展 Socket 开发框架
rjcql的专栏
01-27 634
不用多说这是迄今为止用过最好用的.Net领域Socket开发框架，从Photon 脱坑之后，一直用它来搭建游戏服务器，相伴多年经历了多个游戏和工控项目的检验，简单易上手，功能应有尽有，强烈推荐。可以通过NuGet进行安装。
C++游戏服务器框架笔记(二)_封装Socket类
木可的博客
03-30 6988
C++封装Socket类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值