求教

lipu1022

blind.setLabelProvider(new ISlatLabelProvider() {
  public String getText(Control slatControl) {
    for(Group g : viewers.keySet()) {
      QTreeViewer<Model> viewer = viewers.get(g);
      if(viewer.getQTree() == slatControl)
          return getGroupText(g);
      }
    return "";
}

for(Group g : viewers.keySet())这里，for(  :  )是个什么用法？我看不懂，能讲下吗？
照葫芦画瓢,我把 Group 换成其他类型，就进不了这个for，为什么呢？

linfans

严重地支持你！！！
可是俺不会啊 +_+

如斯

支持你！但是我没有研究过lumaQQ的源代码，所以帮不了你！抱歉

jx1984520

严重地支持你！！！
可是俺不会啊 +_+

lipu1022

框架搭建完成了，一些基础的功能，窗口什么的都搞定了
我现在想完成通讯功能了，高人能否给我点提示或者一些思路流程呢？我想要实现的是内网的多人
通讯，请教要怎么完成比较好呢？

谢谢luma的开源，给了我一个很好的学习机会，学了很多，会了很多，不会的更多：（

lipu1022

如何解决同一台机器打开2个客户端发送消息的问题呢？如何判断是那个客户端来接收或发送消息？
请指点指点

luma

client.getUser().getQQ()

lipu1022

哦，这个方法我也想过，用户号是不是也应该封到包里，上传给服务器，然后再建立个
Hashmap<userQQ,userSocket>来建立用户的连接注册，这样可以区分同一用户
在不同机器上的登陆吗？又或者怎么解决个问提呢？还请指点指点

lipu1022

可以加我的QQ号:33816404吗？我还有很多东西不理解，想请教你

lipu1022

我写了个服务器，然后用QQ和服务器进行消息传递，发现运行速度十分慢，尤其是打开QQ的时候
而且一旦开了QQ的线程后，CPU使用率一直是100%，这个是什么问题导致的？我搞不明白，希望帮我看一下。
服务器代码：
/**
         * 启动服务器
         */
        public void openServer() {
                try {
                        onlineUsers = 0;
                        InetSocketAddress address = new InetSocketAddress(InetAddress
                                        .getLocalHost(), port);
                        serverSocket = new ServerSocket();
                        serverSocket.bind(address);
                        str = totaljTextArea.getText() + "已经启动服务器!"
                                        + serverSocket.getInetAddress() + "\n";
                        totaljTextArea.setText(str);
                        handlers = new Vector<Object>();
                        listenForClients(serverSocket);
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }

        /**
         * 监听来自客户端的连接请求
         */
        protected void listenForClients(ServerSocket server) {
                int clientID = 0;
                while (true) {
                        try {
                                Socket client = server.accept();
                                ChatHandler handler = new ChatHandler(++clientID, client);
                                handler.start();
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }
        }

        /**
         * 每一个用户
         */
        public class ChatHandler implements Runnable {

                protected ClientInfo clientInfo = new ClientInfo();

                // 套接字
                protected Socket socket;

                // 对象输入流
                protected ObjectInputStream in;

                // 对象输出流
                protected ObjectOutputStream out;

                // 指定的用来处理用户的线程
                protected Thread listener;

                public ChatHandler(int clientID, Socket socket) {

                        clientInfo.clientId = clientID;
                        this.socket = socket;
                }

                /**
                 * 连接检测 检测客户端发送的登陆消息和密码校验
                 */
                protected boolean handShake() {
                        try {
                                // 读入对象
                                        Object logMsg = in.readObject();
                                        if (logMsg instanceof Message) {
                                                try {
                                                        switch (((Message)logMsg).msgType) {
                                                        case LOGIN_CHECK:
                                                                empNum = ((Message) logMsg).name;
                                                                psw = ((Message) logMsg).psw;
                                                                if (!checkPsw()) {
                                                                        Message message = new Message();
                                                                        message.logIn = false;
                                                                        message.loginCheckMessage(empNum,"密码校验错误!");
                                                                        out.writeObject(message);
                                                                        out.flush();
                                                                        message.clear();
                                                                        onlineUsers--;
                                                                        in.close();
                                                                        out.close();
                                                                        return false;
                                                                }
                                                                // clientList.addElement(empNum);
                                                                onlineUsers++;
                                                                Message message = new Message();
                                                                message.logIn = true;
                                                                message.loginCheckMessage(empNum,"登陆成功!");
                                                                out.writeObject(message);
                                                                out.flush();
                                                                message.clear();
                                                                break;
                                                        default:
                                                                break;
                                                        }
                                                } catch (Exception e) {
                                                        // e.printStackTrace();
                                                }
                                        } else {
                                                System.out.println(logMsg);
                                        }
                        } catch (Exception e) {
                                // e.printStackTrace();
                        }
                        return true;
                }

                public synchronized void start() {
                        if (listener == null) {
                                try {
                                        out = new ObjectOutputStream(socket.getOutputStream());
                                        in = new ObjectInputStream(socket.getInputStream());
                                        if (!handShake())
                                                return;
                                        listener = new Thread(this);
                                        listener.start();
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                }

                public synchronized void stop() {
                        if (listener != null) {
                                if (listener != Thread.currentThread()) {
                                        try {
                                                listener.interrupt();
                                                listener = null;
                                                handlers.removeElement(this);
                                                // clientList.removeElement(clientInfo.clientName);
                                                UpdateList newClient = new UpdateList();
                                                newClient.requestType = false;
                                                newClient.newClient = clientInfo.clientName;
                                                broadcast(newClient);
                                                out.close();
                                                socket.close();
                                        } catch (Exception e) {
                                                e.printStackTrace();
                                        }
                                }
                        }
                }

                public void run() {
                        try {
                                handlers.addElement(this);
                                while (true) {
                                        try {
                                                Object clientMsg = in.readObject();
                                                if (clientMsg instanceof Message) {
                                                        // 是公共信息
                                                        if (((Message) clientMsg).audience == true) {
                                                                broadcast(clientMsg);
                                                        }
                                                        // 私有信息
                                                        else {
                                                                ((ChatHandler) (handlers
                                                                                .elementAt(((Message) clientMsg).recieverId))).out
                                                                                .writeObject(clientMsg);
                                                        }
                                                } else if (clientMsg instanceof ChatRequest) {
                                                        ((ChatHandler) (handlers
                                                                        .elementAt(((Message) clientMsg).recieverId))).out
                                                                        .writeObject(clientMsg);
                                                } else if (clientMsg instanceof LogOut) {
                                                        onlineUsers--;
                                                        break;
                                                } else {
                                                        System.out.println(clientMsg);
                                                }
                                        } catch (Exception e) {
                                                // e.printStackTrace();
                                        }
                                }
                        } catch (Exception e) {
                                // e.printStackTrace();
                        } finally {
                                stop();
                        }
                }
        /**
         * 关闭服务器
         */
        protected void shutDown() {
                try{
                        serverSocket.close();
                }catch (Exception e) {
                       
                }
                System.exit(0);
        }