急急急~~~帮忙呀~~socket问题~~~~~~~

Question

利用socket的tcp协议~~开发
是服务器端对多个客户端
当每个客户端登录后服务器端都会给客户端发送信息，客户端与服务器端永久保持链接状态，而且对每个客户端所发的信息都是指定的
例如当客户端01链接服务器后服务器就会给其编个号01，然后服务器段的数据经过处理后如果有01的信息就给01发送信息，如果没有就不给其发。帮忙给打个框架就好，

Answer 1

客户端
===========================================
import java.net.InetAddress;
import java.net.UnknownHostException;/**
 * 客户端Demo,创建三个子线程访问服务器
 *
 * @author Lv 
 */
public class ClientDemo
{
    /**
     * 程序入口
     * @param args
     */
    public static void main(String[] args)
    {
        try
        {
            InetAddress inetAddress1 = InetAddress.getByName("192.168.0.14");            new ConnectThread(inetAddress1, 4665, "12345\t67890");
            new ConnectThread(inetAddress1, 4665, "abcde\tfghij");
            new ConnectThread(inetAddress1, 4665, "我你他");        } catch (UnknownHostException e)
        {
            e.printStackTrace();
            System.out.println("unknow host,can't connect to server!");
        }
    }
}////////////////////////////////////////////import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;/**
 * 建立与服务器连接的子线程
 *
 * @author Lv Lihua
 */
public class ConnectThread implements Runnable
{
    /**
     * 建立与服务器连接的Socket对象
     */
    private Socket sckConnectObj;    /**
     * 连接的服务器端口
     */
    private int port;    /**
     * 向服务器发送的字串
     */
    private String strSend;    /**
     * 创建一个同步对象
     */
    private static Object synObj = new Object();    /**
     * 构造函数 创建与服务器连接的新线程
     * 
     * @param serverInetAddress 包含服务器地址信息的InetAddress对象
     * @param port 服务器端口
     * @param str 向服务器发送的字符串
     */
    public ConnectThread(InetAddress serverInetAddress, int port, String str)
    {
        strSend = str;
        this.port = port;
        boolean sockError = false;        try
        {
            this.sckConnectObj = new Socket(serverInetAddress, port);
        }
        catch (IOException e)
        {
            System.err.println(
                "Thread connect server:"
                    + serverInetAddress.getHostAddress()
                    + " port:"
                    + port
                    + " error!");
            sockError = true;
        }
        if (!sockError)
        {
            new Thread(this, serverInetAddress.getHostAddress()).start();
        }
    }    /**
     * 线程启动入口
     */
    public void run()
    {
        InputStream inStr; //与服务器连接Socket对象的输入流
        OutputStream outStr; //与服务器连接Socket对象的输出流
        byte[] bDataRece = new byte[256]; //接收数据的缓冲区，256 bytes
        int dataLen; //接收的数据长度        for (int i = 3; i > 0; i--) //向服务器发送三次数据
        {
            try
            {
                inStr = sckConnectObj.getInputStream();
                outStr = sckConnectObj.getOutputStream();
                outStr.write(strSend.getBytes()); //发送数据
                dataLen = inStr.read(bDataRece); //接收数据
                if (dataLen == -1)
                {
                    System.out.println("the server close connect");
                    break;
                }
                else
                {
                    synchronized (synObj) //接收，发送数据显示处于同步语句内，避免显示混乱
                    {
                        System.out.println(
                            Thread.currentThread().getName()
                                + ":"
                                + sckConnectObj.getLocalPort()
                                + ">>>send data:"
                                + strSend);                        System.out.println(
                            Thread.currentThread().getName()
                                + ":"
                                + sckConnectObj.getLocalPort()
                                + "<<<receive data from server:"
                                + "\n\t"
                                + new String(bDataRece, 0, dataLen)
                                + "\n");
                    }
                }
                Thread.sleep(500);
            }
            catch (IOException e)
            {
             System.out.println(">>>>conntecting to server error! maybe been closed");
            } catch (InterruptedException e)
            {
             System.out.println("sleep connect thread been interupted!");
                e.printStackTrace();
            }
        } //for语句end
        System.out.println(
            "=====Thread\""
                + Thread.currentThread().getName()
                + ":"
                + sckConnectObj.getLocalPort()
                + "\"exit!");
    }
}

Answer 2

服务端
===========================
import java.io.*;
import java.net.*;/**
 * 服务器端Demo，建立侦听，将接受客户端连接的对象传递给新创建的线程
 *
 * @author Lv 
 */
public class ServerDemo
{
    public static void main(String[] args)
    {
        int port = 4665; //侦听端口，4665
        try
        {
            ServerSocket sObj = new ServerSocket(port);
            while (true)
            {
                System.out.println("====the server listening in the port 4665====");
                Socket acptSckObj = sObj.accept(); //创建接受连接对象
                System.out.println(
                    "client\""
                        + acptSckObj.getInetAddress().getHostName()
                        + "\"Requesting connect");
                new ListenThread(acptSckObj); //将接受连接的对象传给新线程
            }
        } catch (BindException e)
        {
            System.out.println("Bind port error!(Address already in use)");
            System.exit(-1);
        } catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}/////////////////////////////////////////////
import java.net.*;
import java.io.*;/**
 * 创建服务器接受连接线程
 *
 * @author Lv 
 */
public class ListenThread implements Runnable
{
    /**
     * 接受连接的Socket对象
     */
    private Socket acptSckObj;    /**
     * 服务器接收到的数据
     */
    private byte[] bDataRece;    /**
     * 创建一个用于同步语句的对象
     */
    private static Object synObj = new Object();    /**
     * 构造函数，创建连接后的数据处理线程
     * 
     * @param serverObj 服务器接收连接请求的Socket对象
     */
    public ListenThread(Socket serverObj)
    {
        bDataRece = new byte[256];
        this.acptSckObj = serverObj;
        new Thread(this, this.acptSckObj.getInetAddress().getHostName()).start();
    }    /**
     * 将字符串反向后返回
     * 
     * @param str 待处理字符串
     * @return 反转后的字符串
     */
    public String ReverseStr(String str)
    {
        int strLen = str.length();
        byte[] strByte = str.getBytes();
        for (int i = 0; i < strLen / 2; i++)
        {
            byte bTemp = strByte[i];
            strByte[i] = strByte[strLen - 1 - i];
            strByte[strLen - 1 - i] = bTemp;
        }
        return new String(strByte);
    }    /**
     * 线程入口
     */
    public void run()
    {
        InputStream inStr;
        OutputStream outStr;
        int dataLen;        try
        {
            inStr = acptSckObj.getInputStream();
            outStr = acptSckObj.getOutputStream();            while (true)
            {
                try //捕获回客户端断开连接引起的SocketException
                    {
                    dataLen = inStr.read(bDataRece);
                }
                catch (SocketException e)
                {
                    System.out.println(
                        "client\""
                            + acptSckObj.getInetAddress().getHostName()
                            + "\"-port\""
                            + acptSckObj.getPort()
                            + "\"connect closed");
                    break;
                }
                String strGet = new String(bDataRece, 0, dataLen);
                outStr.write(ReverseStr(strGet).getBytes());
                outStr.flush();
                synchronized (synObj) //避免显示混乱，用同步语句保证两显示信息在一起
                {
                    System.out.println(
                        "\n>>>receive client\""
                            + acptSckObj.getInetAddress().getHostName()
                            + "\"_port\""
                            + acptSckObj.getPort()
                            + "\"'s data("
                            + dataLen
                            + "bytes):\n"
                            + strGet);
                    System.out.println("<<<the sever reply string:\n" + ReverseStr(strGet));
                }
                strGet = "";
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

Answer 3

唉，偶学JAVA那会写的例子
你凑合着看吧，自己再慢慢改，呵呵

Answer 4

不难的, 用一个数组保存每一个与服务器连接客户端的Socket  再用一个保存客户端的信息(如登陆的时候给个名字,或者是id) 然后就行了 
最近才写了个,如果需要可以加我 442143212

Answer 5

用NIO来写吧，性能与速度会提升一些，如果用户多的话