Android Studio的笔记--socket通信-Toy模板网

这篇具有很好参考价值的文章主要介绍了Android Studio的笔记--socket通信。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

Socket

Socket 作为一种通用的技术规范，首次是由 Berkeley 大学在 1983 为 4.2BSD Unix 提供的，后来逐渐演化为 POSIX 标准。Socket API 是由操作系统提供的一个编程接口，让应用程序可以控制使用 socket 技术。
Socket API 不属于 TCP/IP协议簇，只是操作系统提供的一个是一个对 TCP / IP协议进行封装的编程调用接口，工作在应用层与传输层之间：
一个 Socket 包含两个必要组成部分：
1地址：IP 和端口号组成一队套接字
2协议：Socket 所用的是传输层协议，目前有 TCP、UDP、raw IP

协议

根据传输方式不同（即使用的协议不同）可分为三种：
1.Stream Sockets（流套接字）
基于 TCP协议，采用流的方式提供可靠的字节流服务。TCP 协议有以下特点：
·面向连接：指的是要使用TCP传输数据，必须先建立TCP连接，传输完成后释放连接，就像打电话一样必须先拨号建立一条连接，打完后挂机释放连接。
·全双工通信：即一旦建立了TCP连接，通信双方可以在任何时候都能发送数据。
·可靠的：指的是通过TCP连接传送的数据，无差错，不丢失，不重复，并且按序到达。
·面向字节流：流，指的是流入到进程或从进程流出的字符序列。简单来说，虽然有时候要传输的数据流太大，TCP报文长度有限制，不能一次传输完，要把它分为好几个数据块，但是由于可靠性保证，接收方可以按顺序接收数据块然后重新组成分块之前的数据流，所以TCP看起来就像直接互相传输字节流一样，面向字节流。
2.Datagram Sockets（数据报套接字）
基于 UDP协议，采用数据报文提供数据打包发送的服务。UDP 协议有以下特点：
·无连接的：和TCP要建立连接不同，UDP传输数据不需要建立连接，就像写信，在信封写上收信人名称、地址就可以交给邮局发送了，至于能不能送到，就要看邮局的送信能力和送信过程的困难程度了。
·不可靠的：因为UDP发出去的数据包发出去就不管了，不管它会不会到达，所以很可能会出现丢包现象，使传输的数据出错。
·面向报文：数据报文，就相当于一个数据包，应用层交给UDP多大的数据包，UDP就照样发送，不会像TCP那样拆分。
·没有拥塞控制：拥塞，是指到达通信子网中某一部分的分组数量过多，使得该部分网络来不及处理，以致引起这部分乃至整个网络性能下降的现象，严重时甚至会导致网络通信业务陷入停顿，即出现死锁现象，就像交通堵塞一样。TCP建立连接后如果发送的数据因为信道质量的原因不能到达目的地，它会不断重发，有可能导致越来越塞，所以需要一个复杂的原理来控制拥塞。而UDP就没有这个烦恼，发出去就不管了。
3.Row Sockets
通常用在路由器或其他网络设备中，这种 socket 不经过TCP/IP协议簇中的传输层（transport layer），直接由网络层（Internet layer）通向应用层（Application layer），所以这时的数据包就不会包含 tcp 或 udp 头信息。

android socket 代码

清单文件

得添加权限 < uses-permission android:name=“android.permission.INTERNET” />

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.lxh.biji"
    android:installLocation="internalOnly">
    <uses-permission android:name="android.permission.INTERNET" />
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.Shuiji">
        <activity
            android:name=".MainActivity"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service
            android:name=".TCPServerService"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="com.newland.management.TCPServerService.and" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </service>
        <service
            android:name=".TCPClientService"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="com.newland.management.TCPClientService.and" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </service>
    </application>
</manifest>

开启服务

Intent intentx = new Intent("com.newland.management.TCPServerService.and");
intentx.setPackage("com.lxh.biji");
context.startService(intentx);
Intent intentx_ = new Intent("com.newland.management.TCPClientService.and");
intentx_.setPackage("com.lxh.biji");
context.startService(intentx_);

服务端：TCPServerService

package com.lxh.biji;
import android.app.IntentService;
import android.content.Intent;
import android.os.SystemClock;
import android.text.TextUtils;
import android.util.Log;
import androidx.annotation.Nullable;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * create by lxh on 2023/2/20 Time：16:33
 * tip:socket服务端 端口号55019，用来发送值
 */
public class TCPServerService extends IntentService {
    private static final String TAG = "TCPServerService";
    public TCPServerService() {
        super("TCP");
    }
    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "lxh "+TAG+"  onCreate: ");
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
        isover = true;
        Log.d(TAG, "lxh "+TAG+"  onDestroy: ");
    }
    private boolean isover = false;
    private String sendMag="";
    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        try {
            Log.i(TAG,"lxh onHandleIntent");
            ServerSocket serverSocket = new ServerSocket(55019);//监听本地端口号
            Socket socket = serverSocket.accept();
            InputStream inputStream = socket.getInputStream();//获取输入流，接受用户发来的消息
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            OutputStream outputStream = socket.getOutputStream();//获取输出流，向客户端回复消息
            PrintWriter writer = new PrintWriter(new OutputStreamWriter(outputStream));
            while (!isover) {//通过循环不断读取客户端发来的消息,并回复
                //Log.i(TAG,"lxh on while");
                String readLine = reader.readLine();
                if (!TextUtils.isEmpty(readLine)) {
                    String readMag =readLine.toString();Log.i(TAG,"lxh 客户端发送的消息："+readMag);
                    if(readMag.equals("Client_send")){
                        String need_String="Server_back";
                        sendMag =need_String;
                    }else if (readMag.equals("get")){ }
                    //SystemClock.sleep(500);//延迟发送
                    writer.println(sendMag+"\r");
                    writer.flush();//刷新流
                }else { }
            }
            inputStream.close();//关闭流
            reader.close();
            outputStream.close();
            writer.close();
            socket.close();
            //需关闭，否则再次连接时，会报端口号已被使用
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端：TCPClientService

package com.lxh.biji;
import android.annotation.SuppressLint;
import android.app.IntentService;
import android.content.Intent;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.text.TextUtils;
import android.util.Log;
import androidx.annotation.Nullable;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
/**
 * create by lxh on 2023/2/20 Time：20:02
 * tip:socket客户端 端口号55019
 */
public class TCPClientService extends IntentService {
    private static final String TAG = "TCPClientService";
    public TCPClientService() {
        super("TCP");
    }
    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "lxh "+TAG+" onCreate: ");
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
//        isover_client = true;
//        //关闭输入流和连接
//        if (mSocket != null) {
//            try {
//                mSocket.shutdownInput();
//                mSocket.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
        Log.d(TAG, "lxh "+TAG+" onDestroy: ");
    }
    private boolean isover_client = false;
    private String sendMag_client="";
    private static final int CONNECT_SERVER_SUCCESS = 0;
    private static final int MESSAGE_RECEIVE_SUCCESS = 1;
    private static final int MESSAGE_SEND_SUCCESS = 2;
    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                connectTCPServer();//连接服务端，实现通信交互//IO操作必须放在子线程执行
            }
        }).start();

    }
    Handler handler=new Handler();
    int handler_id=0;
    //handler.postDelayed(runnable, 2000);
    //handler.removeCallbacks(runnable);
    Runnable runnable=new Runnable() {
        @Override
        public void run() {
            run_send();
            handler_id++;
            handler.postDelayed(this, 2000);
            if (handler_id>3){
                handler.removeCallbacks(runnable);
                //关闭输入流和连接
                if (mSocket != null) {
                    try {
                        mSocket.shutdownInput();
                        mSocket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };
    private void run_send(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                String msg = "Client_send";
                if (mPrintWriter != null && !TextUtils.isEmpty(msg)) {
                    mPrintWriter.println(msg + "\n");
                    //mPrintWriter.flush();//此处可以不用刷新流的方法，因为在创建mPrintWriter对象时，在其构造方法中设置了自动刷新缓存
                    mHandler.obtainMessage(MESSAGE_SEND_SUCCESS, msg).sendToTarget();
                }
            }
        }).start();
    }
    private Socket mSocket = null;
    private void connectTCPServer() {
        while (mSocket == null) {//通过循环来判断Socket是否有被创建，若没有则会每隔1s尝试创建，目的是保证客户端与服务端能够连接
            try {
                mSocket = new Socket("localhost", 55019);//创建Socket对象，指定IP地址和端口号
                mPrintWriter = new PrintWriter(new OutputStreamWriter(mSocket.getOutputStream()), true);
                if (mSocket.isConnected()) //判断是否连接成功
                    mHandler.sendEmptyMessage(CONNECT_SERVER_SUCCESS);
            } catch (IOException e) {
                e.printStackTrace();
                SystemClock.sleep(1000);//设计休眠机制，每次重试的间隔时间为1s
            }
        }
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(mSocket.getInputStream()));
            while (!isover_client) {//通过循环来，不断的接受服务端发来的消息
                String msg = reader.readLine();
                if (!TextUtils.isEmpty(msg)) {
                    mHandler.obtainMessage(MESSAGE_RECEIVE_SUCCESS, msg).sendToTarget();
                }
            }
            mPrintWriter.close();//关闭流
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @SuppressLint("all")
    private Handler mHandler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            switch (msg.what) {
                case CONNECT_SERVER_SUCCESS:
                    Log.i(TAG,"lxh 与服务端连接成功");
                    //run_send();
                    handler.postDelayed(runnable, 2000);
                    break;
                case MESSAGE_RECEIVE_SUCCESS:
                    Log.i(TAG,"lxh 服务端发来的消息："+msg.obj.toString());
                    break;
                case MESSAGE_SEND_SUCCESS:
                    //Log.i(TAG,"lxh 客户端发送的消息："+msg.obj.toString());
                    break;
            }
            return false;
        }
    });
    private PrintWriter mPrintWriter;
}

log

/com.lxh.biji D/TCPServerService: lxh TCPServerService  onCreate: 
/com.lxh.biji I/TCPServerService: lxh onHandleIntent
/com.lxh.biji D/TCPClientService: lxh TCPClientService onCreate: 
/com.lxh.biji D/TCPClientService: lxh TCPClientService onDestroy: 
/com.lxh.biji I/TCPClientService: lxh 与服务端连接成功
/com.lxh.biji I/TCPServerService: lxh 客户端发送的消息：Client_send
/com.lxh.biji I/TCPClientService: lxh 服务端发来的消息：Server_back
/com.lxh.biji I/TCPServerService: lxh 客户端发送的消息：Client_send
/com.lxh.biji I/TCPClientService: lxh 服务端发来的消息：Server_back
/com.lxh.biji I/TCPServerService: lxh 客户端发送的消息：Client_send
/com.lxh.biji I/TCPClientService: lxh 服务端发来的消息：Server_back

感谢互联网
引用内容来自Android Socket 通信
服务端部分代码参考Android进程间通信 - Socket使用（TCP、UDP）
适合阅读文章分享
Android 基于TCP的 Socket 编程实现（结合 okio）
Android实现socket网络通信
基于android的Socket通信

与君共勉！待续
欢迎指错，一起学习文章来源地址https://www.toymoban.com/news/detail-438512.html

到了这里，关于Android Studio的笔记--socket通信的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！