Android Socket通信

浅浅的花香味﹌ 2022-09-23 11:53 180阅读 0赞

Socket是基于Tcp的链接，适用于长链接  
Socke通讯需要客户端和服务器，客户端我们在android上编写，而服务器则选择在eclipse上编写

上效果图;  
![20160718165139730][]

eclipse：  
我们一共需要4个类，分别是  
Server类，继承自Thread，用于建立服务器，并监听Socket的链接  
MySocket类，继承自Thread,用于对Socket进行读写操作  
SocketManager类，单态模式，管理Socket，不过主要的用途其实还是可以将信息发送给所有人  
Start类，开启Server类

Start：

package wkk.server.socket;
    
    public class Start {
    
        public static void main(String[] args) {
            new Server().start();
        }
    
    }

Server：

package wkk.server.socket;
    
    import java.io.IOException;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Server extends Thread {
        
        private SocketManager manager;
    
        @Override
        public void run() {
            try {
                // 1-65535
                ServerSocket ss = new ServerSocket(1234);
                manager=SocketManager.getInstance();
                while (true) {
                    // 此方法会阻塞线程 直至有人链接
                    Socket socket = ss.accept();
                    System.out.println("有客户端连接上服务器了");
                    MySocket socket1=new MySocket(socket);
                    socket1.start();
                    manager.add(socket1);
                }
    
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

new ServerSocket(1234);  
这个方法的参数为int型端口号数值在1-65535之间，一般选择较大值避免冲突  
accept()，这个方法会阻塞线程，所以适合在主线程中进行操作，我们循环监听Socket的链接，为每一个Socket开启一个独立的线程，并将Socket添加到SocketManager的list集合中

MySocket :

package wkk.server.socket;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.Socket;
    
    public class MySocket extends Thread {
        
    
        private Socket socket;
        private SocketManager manager;
    
        public MySocket(Socket socket) {
            this.socket = socket;
        }
    
        @Override
        public void run() {
            manager=SocketManager.getInstance();
            try {
                //读取并发送
                BufferedReader reader = new BufferedReader(new InputStreamReader(
                        socket.getInputStream()));
                String messageString = null;
                while ((messageString = reader.readLine()) != null) {
                    System.out.println(messageString);
                    manager.sendAll(this, messageString);
                }
                reader.close();
                manager.remove(this);
            } catch (Exception e) {
            }
        }
        //写
        public void out(String out) {
            try {
                socket.getOutputStream().write((out + "\r\n").getBytes("utf-8"));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }

在构造方法中传入所需的Socket,继承自Thread,在run方法中监听客户端发送来的消息，并将消息发送给所有人

SocketManager：

package wkk.server.socket;
    
    import java.util.ArrayList;
    
    public class SocketManager {
    
        private static SocketManager manager;
    
        private ArrayList<MySocket> list;
    
        private SocketManager() {
            list = new ArrayList<MySocket>();
        }
    
        public static SocketManager getInstance() {
            if (manager == null) {
                manager = new SocketManager();
            }
            return manager;
        }
    
        public void add(MySocket soc){
            list.add(soc);
        }
    
        public void remove(MySocket soc){
            list.remove(soc);
        }
        //发送给所有人
        public void sendAll(MySocket soc,String out){
            for (MySocket soc1 : list) {
                if(!soc.equals(soc1)){
                    soc1.out(out);
                }
            }
        }
    
    }

这个类就很简单了，只有一个list并提过对外部的方法，增加，删除，以及发送给除自己之外的所有人

好eclipse上就这些东西

**接下来开始编写Android的代码：**  
activity\_main:

<?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context="wkk.app4.MainActivity">
    
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content">
    
            <EditText
                android:id="@+id/ip"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:hint="输入ip地址"
                android:text="192.168.1.110" />
            <EditText
                android:id="@+id/code"
                android:layout_width="100dp"
                android:layout_height="wrap_content"
                android:hint="输入端口号"
                android:text="1234" />
            <Button
                android:id="@+id/link"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="链接" />
        </LinearLayout>
    
    
        <ListView
            android:id="@+id/listview"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1"></ListView>
    
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content">
    
            <EditText
                android:id="@+id/message"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:hint="输入聊天信息" />
    
            <Button
                android:id="@+id/send"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="发送" />
        </LinearLayout>
    
    
    </LinearLayout>

整个布局很简单，在上面已经看过效果图了

listview的item也很简单，之后一个TextView我就不贴了  
适配器什么的无关紧要，就不占用篇幅了，实体类就一个String和一个boolean，一个是用于显示内容，一个是用于判断是自己发出去的信息，还是其他人发出去的信息，来设置TextView的Gravity，实在不懂的等下可以下源码

MainActivity：

package wkk.app4;
    
    import android.os.AsyncTask;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Message;
    import android.support.v7.app.AppCompatActivity;
    import android.text.TextUtils;
    import android.util.Log;
    import android.view.View;
    import android.widget.Button;
    import android.widget.EditText;
    import android.widget.ListView;
    import android.widget.Toast;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.net.Socket;
    import java.util.List;
    
    public class MainActivity extends AppCompatActivity implements View.OnClickListener,Handler.Callback {
        
    
        private EditText ip, code, message;
        private Button link, send;
        private ListView listview;
        private Socket socket;
        private InputStream inputStream;
        private OutputStream outputStream;
        private MyAdapter adapter;
        private List<Bean> list;
        private String[] ipandcode;//里面的内容分别是ip地址和端口号
        private Handler handler;
        private BufferedWriter writer;//对outputStream包装用于发送信息
        private static final int MESSAGE=0;
        private static final int SUCCEED=1;
        private static final int FAILURE=2;
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            //初始化相应数据
            findview();
            adapter = new MyAdapter(this);
            listview.setAdapter(adapter);
            list = adapter.getList();
            handler=new Handler(this);
        }
    
        private void findview() {
            ip = (EditText) findViewById(R.id.ip);
            code = (EditText) findViewById(R.id.code);
            message = (EditText) findViewById(R.id.message);
            link = (Button) findViewById(R.id.link);
            send = (Button) findViewById(R.id.send);
            listview = (ListView) findViewById(R.id.listview);
    
            link.setOnClickListener(this);
            send.setOnClickListener(this);
        }
    
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.link:
                    String ipt = ip.getText().toString().trim();
                    String codet = code.getText().toString().trim();
                    if (TextUtils.isEmpty(ipt) || TextUtils.isEmpty(codet)) {
                        return;
                    }
                    if (socket != null) {
                        Toast.makeText(this,"已连接",Toast.LENGTH_SHORT).show();
                        return;
                    }
                    ipandcode = new String[2];
                    ipandcode[0] = ipt;
                    ipandcode[1] = codet;
                    //使用异步任务来进行网络操作
                    new MyAsyncTask().execute();
                    break;
                case R.id.send:
                    if(writer==null){
                        Toast.makeText(this,"请先链接",Toast.LENGTH_SHORT).show();
                        return;
                    }
                    try {
                        //发送数据
                        writer.write(message.getText().toString().trim() + "\n");
                        writer.flush();
                        Bean bean=new Bean();
                        bean.setMessage( message.getText().toString().trim());
                        bean.setIsmy(true);
                        list.add(bean);
                        message.setText("");
                        adapter.notifyDataSetChanged();
                    } catch (IOException e) {
                        Log.d("测试",e.toString());
                    }
                    break;
            }
        }
    
        @Override
        public boolean handleMessage(Message msg) {
            switch(msg.what){
                case MESSAGE:
                    //获取信息刷新界面
                    String message= (String) msg.obj;
                    Bean bean=new Bean();
                    bean.setMessage(message);
                    bean.setIsmy(false);
                    list.add(bean);
                    adapter.notifyDataSetChanged();
                    break;
                case SUCCEED:
                    Toast.makeText(this,"链接成功",Toast.LENGTH_SHORT).show();
                    break;
                case FAILURE:
                    Toast.makeText(this,"链接失败",Toast.LENGTH_SHORT).show();
                    break;
            }
    
            return true;
        }
    
        private class MyAsyncTask extends AsyncTask<Void, Void, String> {
        
    
            @Override
            protected String doInBackground(Void... params) {
                try {
                    //参数 ip地址 端口号
                    socket=new Socket(ipandcode[0],Integer.parseInt(ipandcode[1]));
                    Message msg= handler.obtainMessage();
                    msg.what=SUCCEED;
                    handler.sendMessage(msg);
                } catch (IOException e) {
                    Message msg= handler.obtainMessage();
                    msg.what=FAILURE;
                    handler.sendMessage(msg);
                    return null;
                }
    
                try {
                    outputStream = socket.getOutputStream();
                    inputStream = socket.getInputStream();
    
                    writer=new BufferedWriter(new OutputStreamWriter(outputStream));
                    //监听服务器传递过来的信息
                    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
                    String message = null;
                    while ((message = reader.readLine()) != null) {
                        Message msg= handler.obtainMessage();
                        msg.what=MESSAGE;
                        msg.obj=message;
                        handler.sendMessage(msg);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }
    
            @Override
            protected void onProgressUpdate(Void... values) {
    
            }
        }
    
    }

整个Activity代码看起来有点复杂，但是逻辑并不多，无非就是连接服务器，向服务器发送数据，监听服务器传递过来的数据并且刷新界面这些而已，核心代码就那么多，和服务器上的代码几乎一样，无非就是接收和发送数据罢了：

//发送数据
          writer.write(message.getText().toString().trim() + "\n");
          writer.flush();

接收：

BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
                    String message = null;
                    while ((message = reader.readLine()) != null) {
                        Message msg= handler.obtainMessage();
                        msg.what=MESSAGE;
                        msg.obj=message;
                        handler.sendMessage(msg);
                    }

好了，接下来，你只要将eclipse的服务开启，然后就可以聊天了，当然界面很简介，有兴趣可以给它拓展下…

整个代码就这么多，看清楚了真的不难，但是这个demo只能在局域网下进行通讯，如果想放到外网上这些代码肯定不行，会很麻烦，如果有兴趣可以自己去尝试下,  
额…………

我是看着极客学院的视频学习的，如果博客看的不是很明白，可以去看看视频：  
[http://www.jikexueyuan.com/course/226\_1.html?ss=1][http_www.jikexueyuan.com_course_226_1.html_ss_1]

源码下载地址：  
[http://download.csdn.net/detail/w18756901575/9579354][http_download.csdn.net_detail_w18756901575_9579354]

--------------------

2016/10/09 16:33  
放在外网上只需要将ip改成外网ip就可以了，是我以前不知道sb了

[20160718165139730]: /images/20220720/8be785a371ee49858b088bbdb974ba4e.png
[http_www.jikexueyuan.com_course_226_1.html_ss_1]: http://www.jikexueyuan.com/course/226_1.html?ss=1
[http_download.csdn.net_detail_w18756901575_9579354]: http://download.csdn.net/detail/w18756901575/9579354