Android网络应用学习笔记（二）引入多线程实现简单C/S聊天室应用

于 2019-03-29 20:58:41 发布
阅读量424 收藏 2
点赞数
分类专栏： Android 文章标签： Android

参考自《疯狂Android讲义》。

在实际情况下，客户端通常不止一个，不能让一个客户端一直占用服务器，所以服务器应该为每个客户端单独启动一条线程负责通信。而在Android客户端，为了避免让通信阻塞UI界面，应该为通信单独启动一条线程。事实上，Android平台早已不允许在UI线程中直接建立网络连接了。

事先说明，本项目只能用于局域网通信。

下面看代码。

 

1.服务器端实现代码

思路：该程序需要两个类，一个是创建ServerSocket监听器的主类Myserver，一个是负责处理每个Socket通信的线程类ServerThread。

1）Myserver类

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class MyServer {

	//定义保存所有Socket的ArrayList
	public static ArrayList<Socket> socketList = new ArrayList<Socket>();
	
	public static void main(String[] args) throws IOException
	{
		// TODO Auto-generated method stub
		ServerSocket ss = new ServerSocket(30000);
		while(true)
		{
			//此行代码会阻塞，将一直等待别人的连接
			Socket s = ss.accept();
			socketList.add(s);
			//每当客户端连接后启动一条ServerThread线程为该客户端服务
			new Thread(new ServerThread(s)).start();
		}
	}

}

上面的代码很简单，先建立一个socketlist用于保存所有的socket，接着建立一个serversocket，然后循环监听socket的连接，当有新的socket连接的时候就将其加入socketlist，立即为它启动一条新的ServerThread线程为它服务。

2）ServerThread类

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketException;
import java.util.Iterator;


public class ServerThread implements Runnable
{
	//定义当前线程所处理的Socket
	Socket s = null;
	//该线程所处理的Socket所对应的输入流
	BufferedReader br = null;
	public ServerThread(Socket s) throws IOException
	{
		this.s = s;
		//初始化该Socket对应的输入流
		br = new BufferedReader(new InputStreamReader(s.getInputStream(),"utf-8"));
	}
	public void run()
	{
		try
		{
			String content = null;
			//采用循环不断从Socket中读取客户端发送过来的数据
			while((content = readFromClient()) != null)
			{
				//遍历socketList中的每个Socket
				//将读到的内容向每个Socket发送一次
				for(Iterator<Socket> it=MyServer.socketList.iterator();it.hasNext(); )
				{
					Socket s = it.next();
					try {
						OutputStream os = s.getOutputStream();
						os.write((content + "\n").getBytes("utf-8"));
					}
					catch(SocketException e)
					{
						e.printStackTrace();
						//删除该Socket
						it.remove();
						System.out.println(MyServer.socketList);
					}
				}
			}
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
	}
	//定义读取客户端数据的方法
	private String readFromClient()
	{
		try {
			return br.readLine();
		}
		//如果捕获到异常，表明该Socket对应的客户端已经关闭
		catch(IOException e)
		{
			e.printStackTrace();
			//删除该Socket
			MyServer.socketList.remove(s);
		}
		return null;
	}
	
}

首先该线程需要实现从目前socket中读取数据，再将数据转发给socketlist中的socket。此程序使用readFromClient()方法来读取客户端数据，若是在此过程中捕获到IOException异常，则表明该Socket对应的客户端已经关闭，程序就将该Socket从socketList中删除。

当服务器线程读取到客户端数据之后，程序遍历socketList集合，并将该数据向其中每个Socket发送一次。在发送过程中捕获到SocketException也说明该Socket出现问题，用同样方式将该Socket从socketList中移除。

 

2.客户端实现代码

先建立一个Android项目。

首先是界面布局的代码。布局大致是上面一行是发送框，剩下都是对话框。

<?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:id="@+id/activity_main"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.multithreadclient.MainActivity">
    <LinearLayout
        android:orientation="horizontal"
        android:layout_height="wrap_content"
        android:layout_width="match_parent">
        <!--定义一个文本框，用于接收用户的输入-->
        <EditText
            android:id="@+id/input"
            android:layout_width="280dp"
            android:layout_height="wrap_content" />
        <Button
            android:id="@+id/send"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:paddingLeft="8dp"
            android:text="@string/send"/>
        </LinearLayout>>
    <!--定义一个文本框，用于显示服务器的信息-->
    <TextView
        android:id="@+id/show"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="top"
        android:background="#ffff"
        android:textSize="14dp"
        android:textColor="#f000"/>
</LinearLayout>

具体实现部分包含两条线程，一条负责生成主界面，相应用户动作，并将用户输入的数据写入Socket对应的输出流中；另一条负责读取Socket输入流的数据，并负责将这些数据在程序界面上显示出来。

1）MainActivity.java文件

import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    //定义界面上的UI
    EditText input;
    TextView show;
    Button send;
    Handler handler;
    //定义与服务器通信的子线程
    ClientThread clientThread;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        input = (EditText) findViewById(R.id.input);
        send = (Button) findViewById(R.id.send);
        show = (TextView) findViewById(R.id.show);
        handler = new Handler()
        {
            @Override
            public void handleMessage(Message msg)
            {
                //如果消息来自于子线程
                if(msg.what == 0x123)
                {
                    //将读取的内容追加显示在文本框中
                    show.append("\n" + msg.obj.toString());
                }
            }
        };
        clientThread = new ClientThread(handler);
        //客户端启动ClientThread线程创建网络连接，读取来自服务器的数据
        new Thread(clientThread).start();
        send.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try{
                    //当用户单击“发送”按钮后，将用户输入的数据封装成Message
                    //然后发送给子线程的Handler
                    Message msg = new Message();
                    msg.what = 0x345;
                    msg.obj = input.getText().toString();
                    clientThread.revHandler.sendMessage(msg);
                    //清空input文本框
                    input.setText("");
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            }
        });
    }
}

此Activity负责生成程序界面，并为程序的按钮单击事件绑定事件监听器，当用户单击按钮时向服务器发送信息。当用户单击该程序界面中的“发送”按钮后，程序会把input输入框中的内容发送给clientThread的Handler对象revHandler，clientThread负责将用户输入的内容发送给服务器。

2）ClientThread.java

import android.os.Handler;
import android.os.Looper;
import android.os.Message;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketTimeoutException;

/**
 * Created by huang yaoqiu on 2019/3/26.
 */

public class ClientThread implements Runnable
{
    private Socket s;
    //定义向UI线程发送消息的Handler对象
    private Handler handler;
    //定义接收UI线程的消息的Handler对象
    public Handler revHandler;
    //该线程所处理的Socket所对应的输入流
    BufferedReader br = null;
    OutputStream os = null;
    public  ClientThread(Handler handler)
    {
        this.handler = handler;
    }
    public void run()
    {
        try{
            s = new Socket("192.168.42.124",30000);
            br = new BufferedReader(new InputStreamReader(s.getInputStream()));
            os = s.getOutputStream();
            //启动一条子线程来读取服务器响应的数据
            new Thread()
            {
                @Override
                public void run()
                {
                    String content = null;
                    //不断读取Socket输入流中的内容
                    try {
                        while((content = br.readLine()) != null)
                        {
                            //每当读到来自服务器的数据之后，发送消息通知
                            //程序界面显示该数据
                            Message msg = new Message();
                            msg.what = 0x123;
                            msg.obj = content;
                            handler.sendMessage(msg);
                        }
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                }
            }.start();
            //为当前线程初始化Looper
            Looper.prepare();
            //创建revHandler对象
            revHandler = new Handler()
            {
                @Override
                public void handleMessage(Message msg)
                {
                    //接收到UI线程中用户输入的数据
                    if(msg.what == 0x345)
                    {
                        //将用户在文本框内输入的内容写入网络
                        try{
                            os.write((msg.obj.toString() + "\r\n").getBytes("utf-8"));
                        }
                        catch (Exception e)
                        {
                            e.printStackTrace();
                        }
                    }
                }
            };
            //启动Looper
            Looper.loop();
        }
        catch (SocketTimeoutException e1)
        {
            System.out.println("网络连接超时！");
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

ClientThread子线程负责建立与远程服务器的连接，并负责与远程服务器通信，读到数据之后便通过Handler对象发送一条消息。当ClientThread子线程收到UI线程发送过来的消息后，还负责将用户输入的内容发送给远程服务器。

 

示例图片：

多线程的TCP客户端

 

乐清_hyq
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值