Android客戶端簡單的聊天程序實現

看看今天實現的Android聊天室的聊天功能吧，先說說服務器端的代碼及其功能吧

server.java : 負責服務器的界面，以及更服務器主線程ServerThread的啟動，產生了BroadCast廣播，產生ClientThread線程

ServerThread.java:服務器監聽的端口線程，負責創建ServerSocket及監聽是否有新的客戶端連接，並記錄客戶端連接及需要發送的信息，產生了BroadCast廣播

BroadCast.java: 服務器向客戶端廣播線程，負責向客戶端發送消息，產生ClientThread線程

ClientThread.java:維持服務器和單個客戶端的連接線程，負責接受客戶端發來是信息

好了接著就看看他們的代碼吧！！

1.server.java-------創建ServerThread對象啟動run方法

1. package com.wang;
3. import java.awt.BorderLayout;
4. import javax.swing.*;
5. import java.awt.event.*;
7. public class Server extends JFrame implements ActionListener {
9. /****
10. *服務器端主程序負責界面，以及服務段主線程ServerThread的啟動
11. * 服務端主線程ServerThread又產生BroadCast及ClientThread線程 建立服務器端主界面中所用到的布局方式
12. ***/
13. // 邊框容器
14. BorderLayout borderLayout1 = new BorderLayout();
15. BorderLayout borderLayout2 = new BorderLayout();
16. // 創建面板
17. JPanel jPanel1 = new JPanel();
18. JPanel jPanel2 = new JPanel();
19. // 創建按鈕
20. JButton jButton1 = new JButton();
21. JButton jButton2 = new JButton();
22. JScrollPane jScrollPane1 = new JScrollPane();
24. // 創建服務器端接收信息文本框
25. static JTextArea jTextArea1 = new JTextArea();
26. boolean bool = false, start = false;
28. // 聲明ServerThread線程類對象
29. ServerThread serverThread;
30. Thread thread;
32. // 構造函數，用於初始化
33. public Server() {
34. super("Server");
35. // 設置內容面板布局方式
36. getContentPane().setLayout(borderLayout1);
38. // 初始化按鈕組件
39. jButton1.setText("啟動服務器");
40. // 按鈕的動作設置監聽事件
41. jButton1.addActionListener(this);
42. jButton2.setText("關閉服務器");
43. // 按鈕的動作設置監聽事件
44. jButton2.addActionListener(this);
46. // 初始化jPanel1面板對象，並向其中加入組件，上北
47. this.getContentPane().add(jPanel1, java.awt.BorderLayout.NORTH);
48. jPanel1.add(jButton1);
49. jPanel1.add(jButton2);
51. // 初始化jPanel2面板對象，並向其中加入組件，
52. jTextArea1.setText("");
53. jPanel2.setLayout(borderLayout2);
54. jPanel2.add(jScrollPane1, java.awt.BorderLayout.CENTER);
55. jScrollPane1.getViewport().add(jTextArea1);
56. this.getContentPane().add(jPanel2, java.awt.BorderLayout.CENTER);
58. this.setSize(400, 400);
59. this.setVisible(true);
60. }
62. public static void main(String[] args) {
63. Server sever = new Server();
64. sever.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
65. }
67. // 服務器界面中按鈕事件處理
68. public void actionPerformed(ActionEvent e) {
69. if (e.getSource() == jButton1) {
70. // 聲明一個ServerThread對象
71. serverThread = new ServerThread();
72. serverThread.start();
73. } else if (e.getSource() == jButton2) {
74. bool = false;
75. start = false;
76. serverThread.finalize();
77. this.setVisible(false);
78. }
79. }
80. }

2.ServerThread.java -----創建Broadcast對象，啟動該線程，實現run方法後，不斷的向客戶端發送消息，ServerThread開啟後，不斷的獲取新的客戶端並監聽是否發送消息

1. package com.wang;
3. import java.util.*;
4. import java.io.*;
5. import java.net.*;
7. public class ServerThread extends Thread
8. // 服務器監聽端口線程
9. {
10. // 聲明ServerSocket類對象
11. ServerSocket serverSocket;
12. // 指定服務器監聽端口常量
13. public static final int PORT = 80;
15. /**
16. * 創建一個Vector對象，用於存儲客戶端連接的ClientThread對象 , ClientThread類維持服務器與單個客戶端的連接線程
17. * 負責接收客戶端發來的信息，clients負責存儲所有與服務器建立連接的客戶端
18. **/
20. Vector<ClientThread> clients;
21. // 創建一個Vector對象，用於存儲客戶端發送過來的信息
22. Vector<Object> messages;
23. // BroadCast類負責服務器向客戶端廣播消息
24. BroadCast broadcast;
26. String ip;
27. InetAddress myIPaddress = null;
29. public ServerThread() {
30. /***
31. * 創建兩個Vector數組非常重要 ， clients負責存儲所有與服務器建立連接的客戶端，
32. * messages負責存儲服務器接收到的未發送出去的全部客戶端的信息
33. *
34. **/
35. clients = new Vector<ClientThread>();
36. messages = new Vector<Object>();
38. try {
39. // 創建ServerSocket類對象
40. serverSocket = new ServerSocket(PORT);
41. } catch (IOException E) {
42. }
43. // 獲取本地服務器地址信息
44. try {
45. myIPaddress = InetAddress.getLocalHost();
46. } catch (UnknownHostException e) {
47. System.out.println(e.toString());
48. }
49. ip = myIPaddress.getHostAddress();
50. Server.jTextArea1.append("服務器地址：" + ip + "端口號:"
51. + String.valueOf(serverSocket.getLocalPort()) + "\n");
53. // 創建廣播信息線程並啟動
54. broadcast = new BroadCast(this);
55. broadcast.start();
56. }
58. /**
59. * 注意：一旦監聽到有新的客戶端創建即new Socket(ip, PORT)被執行,
60. * 就創建一個ClientThread來維持服務器與這個客戶端的連接
61. **/
62. public void run() {
63. while (true) {
64. try {
65. // 獲取客戶端連接，並返回一個新的Socket對象
66. Socket socket = serverSocket.accept();
68. System.out.println(socket.getInetAddress().getHostAddress());
69. // 創建ClientThread線程並啟動,可以監聽該連接對應的客戶端是否發送來消息， 並獲取消息
70. ClientThread clientThread = new ClientThread(socket, this);
71. clientThread.start();
72. if (socket != null) {
73. synchronized (clients) {
74. // 將客戶端連接加入到Vector數組中保存
75. clients.addElement(clientThread);
76. }
77. }
78. } catch (IOException E) {
79. System.out.println("發生異常：" + E);
80. System.out.println("建立客戶端聯機失敗！");
81. System.exit(2);
82. }
83. }
84. }
86. public void finalize() {
87. try {
88. // 關閉serverSocket方法
89. serverSocket.close();
90. } catch (IOException E) {
91. }
92. serverSocket = null;
93. }
94. }

3.BroadCast.java------

1. package com.wang;
3. import java.io.*;
5. public class BroadCast extends Thread { // 服務器向客戶端廣播線程
6. ClientThread clientThread;
7. // 聲明ServerThread對象
8. ServerThread serverThread;
9. String str;
11. public BroadCast(ServerThread serverThread) {
12. this.serverThread = serverThread;
13. }
15. // 該方法的作用是不停地向所有客戶端發送新消息
16. public void run() {
17. while (true) {
18. try {
19. // 線程休眠200 ms
20. Thread.sleep(200);
21. } catch (InterruptedException E) {
22. }
24. // 同步化serverThread.messages
25. synchronized (serverThread.messages) {
26. // 判斷是否有未發的消息
27. if (serverThread.messages.isEmpty()) {
28. continue;
29. }
30. // 獲取服務器端存儲的需要發送的第一條數據信息
31. str = (String) this.serverThread.messages.firstElement();
32. }
33. // 同步化serverThread.clients
34. synchronized (serverThread.clients) {
35. // 利用循環獲取服務器中存儲的所有建立的與客戶端的連接
36. for (int i = 0; i < serverThread.clients.size(); i++) {
37. clientThread = (ClientThread) serverThread.clients
38. .elementAt(i);
39. try {
40. // 向記錄的每一個客戶端發送數據信息
41. clientThread.out.writeUTF(str);
42. } catch (IOException E) {
43. }
44. }
45. // 從Vector數組中刪除已經發送過的那條數據信息
46. this.serverThread.messages.removeElement(str);
47. }
48. }
49. }
50. }

4.ClientThread.java----獲得Socket的輸入輸出流，向客戶端接收或者發送數據

1. package com.wang;
3. import java.net.*;
4. import java.io.*;
5. public class ClientThread extends Thread
6. {
7. /**
8. * 維持服務器與單個客戶端的連接線程，負責接收客戶端發來的信息,
9. * 聲明一個新的Socket對象，
10. * 用於保存服務器端用accept方法得到的客戶端的連接
11. **/
12. Socket clientSocket;
14. //聲明服務器端中存儲的Socket對象的數據輸入／輸出流
15. DataInputStream in = null;
16. DataOutputStream out = null;
18. //聲明ServerThread對象
19. ServerThread serverThread;
21. public ClientThread(Socket socket,ServerThread serverThread)
22. {
23. clientSocket=socket;
24. this.serverThread=serverThread;
25. try
26. {
27. //創建服務器端數據輸入／輸出流
28. in = new DataInputStream(clientSocket.getInputStream());
29. out = new DataOutputStream(clientSocket.getOutputStream());
30. }
31. catch (IOException e2)
32. {
33. System.out.println("發生異常"+e2);
34. System.out.println("建立I/O通道失敗！");
35. System.exit(3);
36. }
37. }
38. //該方法監聽該連接對應得客戶端是否有消息發送
39. public void run()
40. {
41. while(true)
42. {
43. try
44. {
45. //讀入客戶端發送來的信息
46. String message=in.readUTF();
47. synchronized(serverThread.messages)
48. {
49. if(message!=null)
50. {
51. //將客戶端發送來得信息存於serverThread的messages數組中
52. serverThread.messages.addElement(message);
53. //在服務器端的文本框中顯示新消息
54. Server.jTextArea1.append(message+'\n');
55. }
56. }
57. }
58. catch(IOException E){break;}
59. }
60. }
61. }

5.接著看看手機客戶端的布局main.xml

1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:layout_width="fill_parent"
4. android:layout_height="fill_parent"
5. android:orientation="vertical" >
7. <LinearLayout
8. android:layout_width="fill_parent"
9. android:layout_height="wrap_content"
10. android:orientation="horizontal" >
12. <EditText
13. android:id="@+id/username"
14. android:layout_width="270dp"
15. android:layout_height="wrap_content"
16. android:hint="請輸入用戶名："
17. android:maxLength="10" >
18. </EditText>
20. <Button
21. android:id="@+id/LoginButton"
22. android:layout_width="wrap_content"
23. android:layout_height="wrap_content"
24. android:text="登陸" />
25. </LinearLayout>
27. <LinearLayout
28. android:layout_width="fill_parent"
29. android:layout_height="wrap_content"
30. android:orientation="horizontal" >
32. <EditText
33. android:id="@+id/ip"
34. android:layout_width="270dp"
35. android:layout_height="wrap_content"
36. android:digits=".1234567890"
37. android:hint="10.254.1.62" >
38. </EditText>
40. <Button
41. android:id="@+id/LeaveButton"
42. android:layout_width="wrap_content"
43. android:layout_height="wrap_content"
44. android:text="退出" />
45. </LinearLayout>
47. <EditText
48. android:id="@+id/history"
49. android:layout_width="fill_parent"
50. android:layout_height="280dp" >
51. </EditText>
53. <LinearLayout
54. android:layout_width="fill_parent"
55. android:layout_height="wrap_content"
56. android:orientation="horizontal" >
58. <EditText
59. android:id="@+id/message"
60. android:layout_width="270dp"
61. android:layout_height="wrap_content" >
62. </EditText>
64. <Button
65. android:id="@+id/SendButton"
66. android:layout_width="wrap_content"
67. android:layout_height="wrap_content"
68. android:text="發送" />
69. </LinearLayout>
71. </LinearLayout>