【Android-Socket】Socket通信笔记（单例模式，线程管理,AsyncTask）

最新推荐文章于 2021-12-06 20:40:37 发布
最新推荐文章于 2021-12-06 20:40:37 发布
阅读量778 收藏 4
点赞数 2
分类专栏： 项目 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38304672/article/details/113244733
版权

扉:

  1. 本作学习视频来源:https://www.bilibili.com/video/BV1Nx411r7Pr?t=940&p=11
  2. 界面参考: https://blog.csdn.net/fszeng2011/article/details/42743323?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1
  3. Sock定义与方法详解参考
  4. Socket详解
  5. TCP与UDP区别
  6. 点击跳转百度网盘提取码：pgfj
  7. 连接时请注意端口号和查看本机IP
    1）cmd ipconfig
    2）点击网络查看属性
  8. TestMySocket为服务器端(Java开发) MySocketClient为安卓端(Kotlin开发)
  9. 定义:是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

一：首先在浏览器输入127.0.0.1

  1. 若无法访问 ping这个地址看能不能ping通 。若能通的话则看看IIS开了没有
  2. 开启互联网信息服务IIS
    在这里插入图片描述

二: 代码块

1. (创建本地服务器一)最简单的例子

  1. 建立Java项目
    在这里插入图片描述
  2. 核心：建立ServerSocket对象并使用accept()建立连接，建立后来个弹窗
    1）建立服务端的socket
    2）接收socket对象建立连接 搞定
public class MyServerSocket {
    public static void  main(String[] args){
        System.out.println("Hello, World!");
        //port 1-65535
        try{
            ServerSocket serverSocket=new ServerSocket(12345);
            //accept是个阻塞的方法 会阻塞当前线程 返回socket类型
            Socket socket=serverSocket.accept();
            //建立连接
            JOptionPane.showMessageDialog(null,"有客户机连接到了本机的12345端口");
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

Kotlin写法

object MyServerSocket {

    fun main(args: Array<String>) {
        println("Hello, World!")
        //port 1-65535
        try {
            val serverSocket = ServerSocket(12345)
            //accept是个阻塞的方法 会阻塞当前线程 返回socket类型
            val socket = serverSocket.accept()//接收客户端请求
            //建立连接
            JOptionPane.showMessageDialog(null, "有客户机连接到了本机的12345端口")
        } catch (e: IOException) {
            e.printStackTrace()
        }
    }
}
  1. 点击运行后，访问127.0.0.1:12345 是没有界面的，但可以看到。关闭窗体后 程序自动关闭
    在这里插入图片描述
    在这里插入图片描述

2. (创建本地服务器二) 解决线程阻塞问题，完成服务器向可客户端发送数据的功能

  1. 建立ServerListener类继承Thread
    1）复写run方法
    2）其中循环监听，循环返回新接入的socket对象
    3）每当有新的accept进入接起连接，就再次 new一个线程进行通话管理
public class ServerListener extends Thread {
    @Override
    public void run() {
        System.out.println("Hello, World!");
        //port 1-65535
        try{
            ServerSocket serverSocket=new ServerSocket(12345);
            //accept是个阻塞的方法 会阻塞当前线程 返回socket类型
            //每当有客户端连接 accept都会返回一个socket对象 循环接听客户端的连接
            while(true){
                Socket socket=serverSocket.accept();
                //建立连接
                JOptionPane.showMessageDialog(null,"有客户机连接到了本机的12345端口");
                //每个socket又要与每个独立的客户端进行通信 所以要将socket传递给新的线程
                new ChatSocket(socket).start();//循环监听客户端请求
            }

        }catch (
                IOException e){
            e.printStackTrace();
        }
    }
}
  1. 新建ChatSocker用于单独处理每个socket
    1）Linux 不区分套接字文件和普通文件，使用 write() 可以向套接字中写入数据，使用 read() 可以从套接字中读取数据。两台计算机之间的通信相当于两个套接字之间的通信，在服务器端用 write() 向套接字写入数据，客户端就能收到，然后再使用 read() 从套接字中读取出来，就完成了一次通信。

public class ChatSocket extends Thread {

    Socket socket;
    public ChatSocket(Socket s){
        this.socket=s;
    }
    //写回方法
    public void out(String out) throws IOException {
        socket.getOutputStream().write(out.getBytes("UTF-8"));
    }

    @Override
    public void run() {
        int count=0;
        while (true){
            count++;
            try {
                out("loop"+count);
                sleep(1000);
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

1）运行多个窗体访问
2）telnet localhost 12345
3）多个线程不同，每个分配独立的chatsocket线程，所以比如要管理线程
在这里插入图片描述
在这里插入图片描述

3. (创建本地服务器完成)让多个终端同步显示，建立管理线程类

  1. 测试发现 左上角有特化图标的输入不会显示出来字，但可以发送 类似保密
  2. 而非特化的输入可以看到也可以发送。
    1）private私有化构造方法
    2）建立单例返回cm对象
    3）使用Vector报错每个线程对象
    4）使用方法publish发送信息，for循环向每个发送(输出流，不存缓冲区直接显示的)
    代码一:建立管理类
    5）补充Kotlin的Vector写法
    在这里插入图片描述

public class ChatManager {
    //私有化构造方法 单例化
    private ChatManager() { }

    private static final ChatManager cm = new ChatManager();

    public static ChatManager getChatManaget() {
        return cm;
    }

    Vector<ChatSocket> vector = new Vector<ChatSocket>();

    public void add(ChatSocket cs) {
        vector.add(cs);
    }

    //某个线程向所有客户端发送信息
    public void publish(ChatSocket cs, String out) throws IOException {
        System.out.print(out);
        for (int i = 0; i < vector.size(); i++) {
            System.out.println("当前cs"+cs);
            ChatSocket csChatSoccket = vector.get(i);

            if (!cs.equals(csChatSoccket)){
                String msg = "";
                msg += out + "\n";//加个换行 不然安卓收不到 太坑了
                csChatSoccket.out(msg);
            }
        }
    }
}

代码二:建立了解后单独保存并且封入管理类

public class ServerListener extends Thread {
    @Override
    public void run() {
        System.out.println("Hello, World!");
        //port 1-65535
        try{
            ServerSocket serverSocket=new ServerSocket(12345);
            //accept是个阻塞的方法 会阻塞当前线程 返回socket类型
            //每当有客户端连接 accept都会返回一个socket对象 循环接听客户端的连接
            while(true){
                Socket socket=serverSocket.accept();
                //建立连接
                JOptionPane.showMessageDialog(null,"有客户机连接到了本机的12345端口");
                //每个socket又要与每个独立的客户端进行通信 所以要将socket传递给新的线程
                /*更新1.
                匿名方式直接创建 改为命名方式(赋个值 然后可以被调用)
                new ChatSocket(socket).start();//循环监听客户端请求*/
                ChatSocket cs=new ChatSocket(socket);
                cs.start();
                ChatManager.getChatManaget().add(cs);
            }

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

代码三：读入缓冲区的内容并发送消息给终端


public class ChatSocket extends Thread {

    Socket socket;
    public ChatSocket(Socket s){
        this.socket=s;
    }
    public void out(String out) throws IOException {
        socket.getOutputStream().write(out.getBytes("UTF-8"));
    }

    @Override
    public void run() {
//        int count=0;
/*
* 修改2. 服务器循环读取消息再发送给终端
* */
            try {
                BufferedReader br=new BufferedReader(
                        new InputStreamReader(
                                socket.getInputStream(),"UTF-8"));
                String line=null;
                while ((line=br.readLine())!=null) {
                    ChatManager.getChatManaget().publish(this,line);
                }
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            //count++;
            /*try {
                out("loop"+count);
                sleep(1000);
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }*/

    }
}

在这里插入图片描述
在这里插入图片描述
关闭一个窗口后后，若未remove数组中的东西 ，则会报错(1. socked
关闭报错 2.读写流关闭报错(安卓))。每次连接的这个弹窗提示要点掉，不然会阻塞线程。
在这里插入图片描述

在这里插入图片描述

4. 安卓代码

  1. 给权限
   <uses-permission android:name="android.permission.INTERNET" />
  1. AsyncTask防止弃用修改版本
    compileSdkVersion 29
    buildToolsVersion "29.0.2"


class MainActivity : AppCompatActivity(), View.OnClickListener {


    companion object {
        const val KEY = "key"
        const val TAG = "My Phone"
    }

    //创建一个socket
    private var socket: Socket? = null

    //创建输入输出流
    private var writer: BufferedWriter? = null
    private var reader: BufferedReader? = null

    private var socketAddress: SocketAddress? = null
    private var isConnected = false
    private var sp: SharedPreferences? = null
    private var currentName: String? = null
    private var connectFailed = false
    private var progressDialog: ProgressDialog? = null
    private var task: AsyncTask<Void?, String?, Void?>? = null

    val currentPosition by lazy { StringBuilder() }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        init()


    }

    private fun init() {

        btnConnect.setOnClickListener(this)
        btnSend.setOnClickListener(this)
        btnSetName.setOnClickListener(this)

        tvConnectState!!.text = "连接状态：未连接"
        //初始化sharepreference
        sp = getPreferences(MODE_PRIVATE)
        sp?.let {
            currentName = it.getString(MainActivity.Companion.KEY, null)
        }
        if (currentName != null) {
            tvCurrentName!!.text = "当前昵称：$currentName"
        }
    }

    override fun onClick(v: View) {
        when (v.id) {
            R.id.btnConnect ->
                if (currentName != null) {
                    connect()
                } else {
                    Toast.makeText(this, "请先设置昵称后重新连接", Toast.LENGTH_SHORT).show()
                }
            R.id.btnSend -> send()
            R.id.btnSetName -> {
                val tmp = etSetName!!.text.toString().trim { it <= ' ' }
                setName(tmp)
            }
        }
    }


    //    ==================================== 逻辑相关
    private fun setName(s: String) {
        if (s != "") {
            val editor = sp!!.edit()
            editor.putString(MainActivity.Companion.KEY, s)
            if (editor.commit()) {
                tvCurrentName!!.text = "当前昵称：$s"
                currentName = s
                etSetName!!.setText("")
                Toast.makeText(this, "昵称设置成功", Toast.LENGTH_SHORT).show()
            } else {
                Toast.makeText(this, "昵称设置失败，请重试", Toast.LENGTH_SHORT).show()
            }
        } else {
            Toast.makeText(this, "昵称不能为空", Toast.LENGTH_SHORT).show()
        }
    }


    private fun connect() {
        progressDialog = ProgressDialog.show(this," 连接状况", "正在连接...")
        var read: AsyncTask<Void, String, Void> = @SuppressLint("StaticFieldLeak")
        object : AsyncTask<Void, String, Void>() {

            @SuppressLint("WrongThread")
            override fun doInBackground(vararg params: Void?): Void? {


                //把这些放Asynctask中更好  不允许在主线程连接
                val ip = etIP!!.text.toString()
                val port = Integer.valueOf(etPort!!.text.toString())

                //socket = java.net.Socket(ip, port)//Socket(etIP!!.text,)
                //设置最长连接时间
                socket= Socket()
                socketAddress = InetSocketAddress(ip, port)

                socket?.let {
                    it.connect(socketAddress,3000)
                    //包装Buffererd
                    writer = BufferedWriter(OutputStreamWriter(it.getOutputStream()))
                    reader = BufferedReader(InputStreamReader(it.getInputStream()))
                    //连接成功就发送这个
                    publishProgress("@success")
                }


                var line: String? = null
                Log.e(TAG, "doInBackground: Start$line")

                //就是line不为null
                while (reader!!.readLine().also({ line = it }) != null) {
                    Log.e(TAG, "doInBackground: 进入循环$line" )
                    publishProgress(line)
                }
                Log.e(TAG, "doInBackground: 退出循环$line" )

                return null
            }

            override fun onProgressUpdate(vararg values: String?) {


                //这里没做连接失败的反馈  相加自己加个glag
                if (values[0].equals("@success")){
                    tvConnectState!!.text = "连接状态：已连接"
                    Toast.makeText(this@MainActivity, "连接成功", Toast.LENGTH_SHORT).show()
                    progressDialog!!.dismiss()
                }
                //发布values的第一个对象
                Log.e(TAG, "onProgressUpdate: Start$values[0]" )

                currentPosition.append("别人说:==${values[0]}"+"\n")
                tvChatRecord?.text=currentPosition
                super.onProgressUpdate(*values)

            }
        }

        read.execute()
    }



    //不涉及联网操作 放主线程应该没问题 有问题 flush
    private fun send() {
        Thread(Runnable {
            //一定要追加换行符
            currentPosition.append("我说:${etMassage.text}").append("\n")
            writer?.write(etMassage.text.toString() + "\n")
            writer?.flush()

            runOnUiThread {
                etMassage!!.setText("")
                tvChatRecord?.text = currentPosition
            }
//数据强制输出  安卓反复开启  服务器会有混淆 报closed错误

        }).start()

    }

    override fun onDestroy() {
        writer?.close()
        reader?.close()
        super.onDestroy()
    }
}

在这里插入图片描述

5.调试过程和同步更新机制

  1. 第一个阶段，完成连接发送更新UI消息，之后便进入了While循环，从断点我们知道一进入就不会退出循环了(哪怕刚开始取到空，只是单纯的 不执行代码 这种类似以起c++ ！=EOF输入CTRL+Z才退出循环，一直在循环中 发现输入流有东西(其他端实现)就直接通知UI更新)
    在这里插入图片描述

  2. 实现我发的就是我说，其他人发的就其他人说：这个比较简直自己发的直接获取为我说，AsyncTask中接到的所有消息都是他说

  3. 发送消息非常重要加换行符，估计是侦测借位换行符的，亲测结尾加上两个换行符也达不到换行效果。
    在这里插入图片描述
    在这里插入图片描述

  4. 打断点暂时测不出来关闭连接后的 情况
    在这里插入图片描述

6. 补充AsyncTask 30弃用之前

在这里插入图片描述
在这里插入图片描述

风聆Mia
关注
专栏目录
java socket 单例_Java 单例模式的几种实现方式
weixin_29471325的博客
02-16 490
单例模式的本质是在运行过程中，某个类只能实例化一个对象；下面是单例模式最基本的实现方式packagecom.fuck.singleton;publicclassSingleton{privateSingleton(){System.out.println("Thisisasingleobject");}privatestaticSingletonsingleton=ne...
android建立多个socket,Android--多个Activity共享Socket--单例模式
weixin_28851191的博客
05-27 692
本身跟同窗校能电院同窗一块儿作的创新训练项目：java树莓派端与app端创建Socket通讯，要求app端收发信息，树莓派端处理信息。设计模式问题：在多个Activity之间共享Socket通讯，使用设计模式单例模式：单例模式保证在程序中只有一个实例存在而且能全局的访问到。apppublic class MSocket extends Socket{//private static final S...
C#Socket利用单例来实现服务器与客户端交互
04-15
Socket利用单例来实现服务器与客户端交互
精读《设计模式 - Singleton 单例模式》
前端精读周刊
11-02 175
Singleton（单例模式）Singleton（单例模式）属于创建型模式，提供一种对象获取方式，保证在一定范围内是唯一的。意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。其...
java socket 单例_Java Socket应用---通信是这样练成的
weixin_39773158的博客
02-16 210
网络基础知识地址、端口号、协议java 提供的网络功能有四大类InetAddress ：用于标识网络上的硬件资源URL：统一资源定位符 通过URL可以直接读取或写入网络上的数据Sockets：使用TCP协议实现网络通信的Socket相关的类Datagram：使用UDP协议，将数据保存在数据报中，通过网络进行通信。查看全部0采集收起2021-01-11通信模型啊查看全部InetAddress.get...
Android Socket通信实验时线程问题
NightWatchers的博客
05-06 183
这几天在写Android实验使用Socket进行通信，一路坎坷啊，可能是太菜了吧，这里把最主要的线程坑写在这里(可能对大多数人来说不是坑)： 在客户端创建线程提交时由于用户信息和内容不在一个activity里所以使用不同的线程，但是每个线程在Socket中都会产生不同的Socket，我是在服务器端使用hashmap以<Socket,Object>形式保存的，所以一直出现保存的信息与发文...
Android笔记：Socket客户端收发数据
04-21
在Android开发中，Socket通信是实现设备间数据传输的重要手段，尤其在构建网络服务和进行设备间的实时交互时。本文将深入探讨如何在Android平台上创建一个Socket客户端，以及如何通过TCP协议进行数据的发送和接收。 ...
android开发笔记socket之tcp
09-05
2. 客户端连接：在Android应用中，我们可以在一个新开启的线程或者AsyncTask中执行Socket连接操作，以避免阻塞主线程。 ```java new Thread(new Runnable() { @Override public void run() { try { // 创建...
Android代码-局域网简易云端笔记系统源码.zip
08-02
通过深入研究这个项目的源码，开发者不仅可以学习到如何构建一个简单的云端笔记应用，还能掌握Android应用的局域网通信和数据同步策略，这对于进一步提升Android开发技能非常有帮助。同时，这也是一个很好的实践案例...
Android 局域网简易云端笔记系统源码.zip
12-04
Socket编程用于实现客户端与服务器间的网络通信，AsyncTask用于在后台线程执行耗时操作，避免阻塞主线程，BroadcastReceiver则可以监听系统或自定义广播，实现特定事件的响应。 此外，数据存储方面，可能采用了...
Socket简单实例Socket简单实例
08-16
Socket 简单实现tcp，udp数据传输。Socket 简单实现tcp，udp数据传输。
android也架构之单例模式
08-19
首先我们来看下单例模式的定义： 定义：在整个应用中，保证一个类只有一个实例，它提供了一个可以访问到它自己的全局访问点（静态方法）。 单例模式中有区分了懒汉式和饿汉式，懒汉式主要是用时间来换空间，饿汉式则是用空间来换时间。饿汉式是线程安全的，懒汉式是非线程安全的，如果要实现懒汉式的非线程安全，则可以再访问点添加synchronized关键字声明即可。在其他的一些项目中还使用了双重检测枷锁机制。 现在我们来看下代码，我会提供代码下载供大家参考。 文章详情：http://blog.csdn.net/michael_yy/article/details/7883621
Android--多个Activity共享Socket--单例模式
猪の成长日记
04-13 1833
自己跟同学校能电院同学一起做的创新训练项目： 树莓派端与app端建立Socket通信，要求app端收发信息，树莓派端处理信息。 问题：在多个Activity之间共享Socket通信，使用设计模式单例模式：单例模式保证在程序中只有一个实例存在并且能全局的访问到。 public class MSocket extends Socket{ //private static fin...
SocketIO 单例
erweimac的博客
05-22 838
前言普通单例_饿汉模式不管有没调用，一开始就创建单例1234567891011121314151617181920212212345678普通单例_饱汉模式调用时才创建单例对象1234567891011121314151617181920212223242526123456789单例组件1.新建一个 GameManager.js1234567891011121314151617182.调用地方 新...
android socket通信 创建线程接受 客户端
weixin_34059951的博客
02-16 90
//声明量 private String IPaddress="192.168.1.120"; private int port =50003; private Handler mhandler =null; private String cc =""; private TextView returnvalue;// ...
Android 单例模式
Venus 的博客
09-20 1197
文章目录1、单例模式介绍2、单例模式的简单例子3、懒汉模式实现单例模式4、Double Check Lock (DLC) 实现单例5、静态内部类单例模式6、枚举单例7、使用容器是实现单例模式 1、单例模式介绍 据说在一个app 中，单例对象的类必须保证只有一个实例存在，系统只有一个全局变量存在。 2、单例模式的简单例子 假设一个公司在 只能有一个CEO ,可以有多个经理，员工。那么我们就把C...
单例socket
qq1761310972
03-20 3281
public class GetSocket { private static Socket socket = new Socket();  private GetSocket() { super(); }   public synchronized static Socket getSocket() { Log.i("getSocket", "getSocke
C++ Socket编程实例解析
热门推荐
LiTong
10-21 3万+
Socket socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式;Socket是发动机，提供了网络通信的能力。 在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的
单实例（单例模式）
Forston的博客
12-06 1117
特点： 1、只能被初始化一次（不能提供public的构造函数和析构函数） 2、不能被拷贝（不能提供拷贝构造函数、赋值函数） 示例： Windows中进行socket开发时，要loadWs2_32.lib，同时还要调用WSAStartup和WSACleanup来初始化和释放资源，使用中只要初始化一次就可以，这时候就可以通过单实例来实现。 头文件 #pragma once class CWinSockInit { public: static CWinSockInit& GetIns.
Android AsyncTask深度解析：实现线程间通信
"Android多线程AsyncTask详解" 在Android应用开发中，多线程的使用是必不可少的，尤其是在处理耗时任务时，如网络请求、数据库操作等，以避免阻塞主线程（UI线程）导致用户体验下降。本文将深入探讨Android的多线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值