一个简单的socket聊天程序

一个简单的Socket聊天程序, 当然是多客户的(客户代码差不多一样)，可以添加一些东西，但大概主体是这样的＜．．．＞

难点：１．客户端什么时候去读取信息.

　　　2.　服务器应该怎么存储客户端的每个连接.

对于第一个问题:

　　有这样三个回答:

　　　　1.每隔一段时间查看服务器一次

　　　　　　优点:　　可行

　　　　　　缺点:　　有点复杂，这样以来服务器就必须知道客户端哪些已经读取，而哪些内容还没有读取，所以服务器就需要存储信息；

　　　　　　　　　　再者，间隔时间也不好取,太大，延迟高，太小，效率太低.

　　　　2.在用户发送消息时，读取

　　　　　　有点：　　简单

　　　　　　缺点：　　如果有多个客户，这个客户又有点懒，没发送，这样他就接受不到其他用户发送的消息了．

　　　　3.在消息被发送到服务器时，读取

　　　　　　优点：　　效率高

　　　　　　缺点：　　这样必须做一个循环单独来接收消息，但是要放哪里呢(为了防止影响用户与GUI的交互，我们创建一个线程专门监听), GUI启动后，

　　　　　　　　　　　　除非有事件被触发，否则没有一处是在运转的

第二个问题嘛，我们存储每个客户和服务器连接后的流，因为客户个数未知，故采用自动增长的线性表即可.

下面是代码实现.

 1 package jffx.blogs.net;
 2 
 3 import java.io.*;
 4 import java.net.ServerSocket;
 5 import java.net.Socket;
 6 import java.util.ArrayList;
 7 import java.util.Date;
 8 
 9 //服务器并没有用GUI
10 //当然也可以，不过没有必要,
11 //一般是写入服务器的配置文件.
12 //当然,一切看你
13 public class Exercise2_Server {
14     /**
15      * 保存和服务器连接的每个客户端流
16      */
17     ArrayList<DataOutputStream> clientOutputStream = null ;
18 
19 
20     public static void main(String[] args) {
21         new Exercise2_Server().start() ;
22     }
23 
24     /**
25      * 程序主要处理阶段
26      */
27     private void start() {
28         //为存储客户流分配空间
29         clientOutputStream = new ArrayList<>() ;
30 
31         try {
32             ServerSocket server = new ServerSocket(4242) ;
33 
34             //使服务器一直处于监听状态
35             while(true) {
36                 Socket sock = server.accept() ;
37                 DataOutputStream out = new DataOutputStream(
38                         new BufferedOutputStream(sock.getOutputStream())
39                 ) ;
40                 clientOutputStream.add(out) ;
41 
42                 //处理每个客户
43                 new Thread(new ClientHandler(sock)).start() ;
44                 //显示消息
45                 System.out.println(new Date()) ;
46                 System.out.println("	建立一个连接") ;
47             }
48         } catch (Exception ex) {
49             ex.printStackTrace() ;
50         }
51     }
52 
53     /**
54      * 单独处理每个客户的任务
55      */
56     private class ClientHandler implements Runnable {
57         Socket socket = null ;
58         DataInputStream read = null ;
59         public ClientHandler(Socket socket) {
60             try {
61                 this.socket = socket ;
62                 read = new DataInputStream(
63                         new BufferedInputStream(socket.getInputStream())
64                 ) ;
65             } catch (Exception ex) {
66                 ex.printStackTrace() ;
67             }
68         }
69         @Override
70         public void run() {
71             String msg ;
72             try {
73                 //从客户端读取所有消息
74                 while((msg = read.readUTF()) != null) {
75                     System.out.println("read : " + msg) ;
76                     sendToEveryOne(msg) ;　　　
77                 }
78             } catch (Exception ex) {
79                 ex.printStackTrace() ;
80             }
81         }
82     }
83     //发送消息给所有客户
84     private void sendToEveryOne(String msg) {
85         try {
86             for (DataOutputStream writer : clientOutputStream) {
87                 writer.writeUTF(msg);
88                 writer.flush() ;　　　//立刻发送输出流
89             }
90         } catch (Exception ex) {
91             ex.printStackTrace() ;
92         }
93     }
94 
95 }

package jffx.blogs.net;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.ScrollPane;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.Date;

/**
 * 聊天程序的客户端
 */
public class Exercise2_Client1 extends Application
{
    TextArea ta = new TextArea() ;
    TextField tf = new TextField() ;
    DataInputStream in = null ;
    DataOutputStream out = null ;
    Socket socket ;

    @Override
    public void start(Stage primaryStage) {
        //画图
        BorderPane mainPane = new BorderPane() ;

        mainPane.setCenter(new ScrollPane(ta)) ;
        ta.setPrefColumnCount(60);
        ta.setPrefRowCount(80);
        ta.setEditable(false) ;

        Button bt = new Button("Send") ;
        HBox hbox = new HBox(10) ;
        hbox.getChildren().addAll(tf, bt) ;
        tf.setPrefColumnCount(50);
        mainPane.setBottom(hbox);

        //初始化流
        setUpNetWorking();

        //设置GUI事件 -- lambda()
        bt.setOnAction(event -> {
            try {
                out.writeUTF(tf.getText()) ;
                out.flush() ;
            } catch (Exception ex) {
                ex.printStackTrace() ;
            }
            //清空文本域
            tf.setText("");
        }) ;

        //创建线程单独处理接收消息
        //和用户与GUI交互分开
        Thread readThread = new Thread(() -> {
            String message ;
            //反复读取服务器发送的内容
            try {
                while((message = in.readUTF()) != null) {
                    System.out.println("read : " + ta.getText()) ;
                    ta.appendText(new Date() + "
");
                    ta.appendText("	" + message + "
") ;
                }
            } catch (Exception ex) {
                ex.printStackTrace() ;
            }
        });
        readThread.start() ;

        //显示
        Scene scene = new Scene(mainPane, 400, 600) ;
        primaryStage.setScene(scene) ;
        primaryStage.setTitle("Client") ;
        primaryStage.show() ;
    }
    //初始化流
    private void setUpNetWorking() {
        try {
            socket = new Socket("127.0.0.1", 4242) ;
            in = new DataInputStream(new BufferedInputStream(socket.getInputStream())) ;
            out = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream())) ;
            System.out.println("时间:" + new Date()) ;
            System.out.println("	连接建立!") ;
        } catch (Exception ex) {
            ex.printStackTrace() ;
        }
    }

}