跨进程之Socket

本文详细介绍了一种在Android中实现跨进程通信的方法——Socket通信。通过创建服务端与客户端,实现了不同进程间的实时数据传输。文章提供了完整的代码示例,包括清单文件配置、MainActivity、SocketUtil类、ServerService类及子进程Activity的实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Socket通讯对于Android跨进程来说有些杀鸡用牛刀的感觉。这也是一种办法,主要用于两个进程间进行数据互通 实时刷新

先上清单文件

        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <service
            android:name=".ServerService"
            android:process=":remote" />

        <activity
            android:name=".ArActivity"
            android:process=":remote" />

MainActivity代码实列

package com.example.mysocket;

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;

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

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "DEBUG-WCL: " + MainActivity.class.getSimpleName();

    private Socket socket = null;  //客戶端Socket


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        Intent intent = new Intent(this, ServerService.class);
        startService(intent);

        SocketUtils.getInstance().startSocket();


        findViewById(R.id.tiao).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(MainActivity.this,ArActivity.class));
            }
        });

    }

    @Override
    protected void onDestroy() {

        if (socket != null) {
            try {
                socket.shutdownInput();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        super.onDestroy();

    }



}

SocketUtil类

package com.example.mysocket;

import android.os.SystemClock;
import android.util.Log;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Timer;
import java.util.TimerTask;

public class SocketUtils {

    private Socket socket;
    private PrintWriter mPrintWriter;

    private int i=0;

    // 私有构造
    private SocketUtils() {

    }

    private static SocketUtils single = null;

    // 双重检查
    public static SocketUtils getInstance() {
        if (single == null) {
            synchronized (SocketUtils.class) {
                if (single == null) {
                    single = new SocketUtils();
                }
            }
        }
        return single;
    }

    public void  startSocket(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                connectTCPServer();
            }
        }).start();

        setTimer();
    }



    /**
     * 连接TCP服务器
     */
    private void connectTCPServer() {

        // 不停重试直到连接成功为止
        while (socket == null) {
            try {
                socket = new Socket("localhost", ServerService.PORT);

                mPrintWriter = new PrintWriter(new BufferedWriter(
                        new OutputStreamWriter(socket.getOutputStream())), true);

                Log.e("TAG", "服务器连接成功");

            } catch (IOException e) {
                SystemClock.sleep(300);
                Log.e("TAG", "连接TCP服务失败, 重试...");
            }

        }

        try {
            BufferedReader br = new BufferedReader(
                    new InputStreamReader(socket.getInputStream()));
            while (true) {
                String msg = br.readLine();
                if (msg != null) {
                    Log.e("TAG","数据:"+msg);
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

        ServerService.close(mPrintWriter);
        try {
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    private void setTimer(){
        Timer timer=new Timer();

        TimerTask task=new TimerTask() {
            @Override
            public void run() {

                i++;

                if(mPrintWriter!=null){
                    mPrintWriter.println("韩开"+i);
                }


            }
        };
        timer.schedule(task,1000,2000);
    }

}

Service类

package com.example.mysocket;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.util.Log;

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

/**
 * TCP的服务端
 * <p/>
 * Created by wangchenlong on 16/6/16.
 *
 * 提供单列  如果断开 自行做操作保活重新链接
 */
public class ServerService extends Service {

    private static final String TAG = "DEBUG-WCL: " + ServerService.class.getSimpleName();

    private boolean mIsServiceDestroyed = false;

    public static final int PORT = 1709;
    private Socket client;

    @Override
    public void onCreate() {
        new Thread(new TcpServer()).start();
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        mIsServiceDestroyed = true;
        super.onDestroy();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new MsgBinder();
    }

    private MessageInterface messageInterface;

    public void setMessageInterface(MessageInterface messageInterface) {
        this.messageInterface = messageInterface;
    }


    public void sendMessage(final int i) {
        new Thread() {
            @Override
            public void run() {
                try {
                    // 向客户端发送消息
                    PrintWriter out = new PrintWriter(new BufferedWriter(
                            new OutputStreamWriter(client.getOutputStream())), true);
                    out.println(i);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }


    public class MsgBinder extends Binder {
        /**
         * 获取当前Service的实例
         * @return
         */
        public ServerService getService(){
            return ServerService.this;
        }

    }

    private class TcpServer implements Runnable {

        @Override
        public void run() {
             final ServerSocket serverSocket;
            try {
                serverSocket = new ServerSocket(PORT);
            } catch (IOException e) {
                Log.e(TAG, "建立链接失败, 端口:" + PORT);
                e.printStackTrace();
                return; // 链接建立失败直接返回
            }

            while (!mIsServiceDestroyed) {
                try {
                    client = serverSocket.accept();
                    Log.e(TAG, "接收数据");
                    new Thread() {
                        @Override
                        public void run() {
                            try {
                                responseClient(client);
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }.start();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 接收客户端的消息
     *
     * @param client 客户端
     * @throws IOException
     */
    private void responseClient(Socket client) throws IOException {


        // 接收客户端消息
        BufferedReader in = new BufferedReader(
                new InputStreamReader(client.getInputStream()));

//        // 向客户端发送消息
//        PrintWriter out = new PrintWriter(new BufferedWriter(
//                new OutputStreamWriter(client.getOutputStream())), true);
//
//        out.println(0);

        while (!mIsServiceDestroyed) {
            String str = in.readLine();
            Log.e("TAG","----"+str);

            if(messageInterface!=null){
                messageInterface.getString(str);
            }

            if (str == null) {
                break;
            }

        }

        Log.e(TAG, "客户端退出: ");


        // 关闭通信
//        close(out);
        close(in);
        client.close();

    }


    /**
     * 关闭
     * @param closeable 关闭
     */
    public static void close(Closeable closeable) {
        try {
            if (closeable != null) {
                closeable.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

数据传输接口

package com.example.mysocket;

/**
 * 数据更新接口
 */
public interface MessageInterface {

    void getString(String msg);

}

子进程Activity类

package com.example.mysocket;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

/**
 * 接收端
 * 子进程
 */

public class ArActivity extends AppCompatActivity implements MessageInterface{

    private TextView ar_tv;
    private ServerService service1;
    private ServiceConnection serviceConnection;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_ar);

        ar_tv = findViewById(R.id.ar_tv);

        //下载的Service绑定
        Intent intent = new Intent(ArActivity.this, ServerService.class);
        serviceConnection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                service1 = ((ServerService.MsgBinder) service).getService();
                service1.setMessageInterface(ArActivity.this);
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {

            }
        };
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);


    }

    /**
     * 接口回调数据
     * @param msg
     */
    @Override
    public void getString(final String msg) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                ar_tv.setText(msg);
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(serviceConnection);
    }

}

原文链接  https://www.jianshu.com/p/c9342eada3dd

在 Linux 系统中,Socket 是一种常用的跨进程通信(IPC)机制,它允许不同进程之间通过网络或本地文件系统进行数据交换。Socket 在 Linux 中被视为一种虚拟文件,其数据结构包含了通信所需的信息,例如 IP 地址、端口号等,通过读写该虚拟文件实现通信[^2]。 ### 方法 #### 1. 创建 Socket 使用 `socket()` 函数创建一个 Socket,其原型如下: ```c #include <sys/types.h> #include <sys/socket.h> int socket(int domain, int type, int protocol); ``` - `domain`:指定通信域,如 `AF_UNIX`(本地通信)或 `AF_INET`(网络通信)。 - `type`:指定 Socket 类型,如 `SOCK_STREAM`(流式 SocketTCP)或 `SOCK_DGRAM`(数据报 Socket,UDP)。 - `protocol`:通常设置为 0,表示使用默认协议。 #### 2. 绑定地址 使用 `bind()` 函数将 Socket 绑定到一个特定的地址上。对于本地通信,通常使用 `struct sockaddr_un` 结构体来表示地址。 ```c #include <sys/socket.h> #include <sys/un.h> struct sockaddr_un addr; memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; strcpy(addr.sun_path, "/tmp/mysocket"); bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)); ``` #### 3. 监听连接(适用于 TCP) 对于流式 Socket,服务器端需要调用 `listen()` 来监听连接请求。 ```c listen(sockfd, 5); ``` #### 4. 接受连接(适用于 TCP) 服务器端使用 `accept()` 接受客户端的连接请求。 ```c int clientfd = accept(sockfd, NULL, NULL); ``` #### 5. 连接服务器(适用于 TCP) 客户端使用 `connect()` 连接到服务器。 ```c connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)); ``` #### 6. 数据传输 使用 `send()` 和 `recv()` 函数进行数据的发送和接收。 ```c send(sockfd, "Hello Server", 12, 0); recv(sockfd, buffer, sizeof(buffer), 0); ``` #### 7. 关闭 Socket 使用 `close()` 函数关闭 Socket。 ```c close(sockfd); ``` ### 示例 #### 服务器端代码 ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <sys/un.h> #define SOCKET_PATH "/tmp/mysocket" #define BUFFER_SIZE 1024 int main() { int server_fd, client_fd; struct sockaddr_un addr; char buffer[BUFFER_SIZE]; // 创建 Socket server_fd = socket(AF_UNIX, SOCK_STREAM, 0); if (server_fd == -1) { perror("socket"); exit(EXIT_FAILURE); } // 绑定地址 memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; strcpy(addr.sun_path, SOCKET_PATH); unlink(SOCKET_PATH); // 删除旧的 Socket 文件 if (bind(server_fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) { perror("bind"); close(server_fd); exit(EXIT_FAILURE); } // 监听连接 if (listen(server_fd, 5) == -1) { perror("listen"); close(server_fd); exit(EXIT_FAILURE); } printf("Server is listening...\n"); // 接受连接 client_fd = accept(server_fd, NULL, NULL); if (client_fd == -1) { perror("accept"); close(server_fd); exit(EXIT_FAILURE); } // 接收数据 while (1) { int bytes_received = recv(client_fd, buffer, BUFFER_SIZE, 0); if (bytes_received <= 0) { break; } buffer[bytes_received] = '\0'; printf("Received: %s\n", buffer); } // 关闭连接 close(client_fd); close(server_fd); unlink(SOCKET_PATH); // 删除 Socket 文件 return 0; } ``` #### 客户端代码 ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <sys/un.h> #define SOCKET_PATH "/tmp/mysocket" #define BUFFER_SIZE 1024 int main() { int sockfd; struct sockaddr_un addr; char buffer[BUFFER_SIZE]; // 创建 Socket sockfd = socket(AF_UNIX, SOCK_STREAM, 0); if (sockfd == -1) { perror("socket"); exit(EXIT_FAILURE); } // 连接服务器 memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; strcpy(addr.sun_path, SOCKET_PATH); if (connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) { perror("connect"); close(sockfd); exit(EXIT_FAILURE); } // 发送数据 const char *message = "Hello Server"; send(sockfd, message, strlen(message), 0); // 接收响应 int bytes_received = recv(sockfd, buffer, BUFFER_SIZE, 0); if (bytes_received > 0) { buffer[bytes_received] = '\0'; printf("Response: %s\n", buffer); } // 关闭连接 close(sockfd); return 0; } ``` ### 编译与运行 1. 编译服务器端代码: ```bash gcc server.c -o server ``` 2. 编译客户端代码: ```bash gcc client.c -o client ``` 3. 运行服务器端: ```bash ./server ``` 4. 运行客户端: ```bash ./client ``` 服务器端会接收到客户端发送的消息,并打印到控制台。 ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值