一个手机上的网络聊天游戏(J2ME)

这是一个Client基于J2ME以及TCP/IP协议的简单的聊天程序，在本人模拟器上测试没问题，但并不保证真机上会出现问题。

代码以及整个游戏框架你可以拿来自由使用，但请注明出处。

(一)

这部分是程序Cilent端和Server端共用的一些类，之所以把它们拿出来单独写，是为了让整个程序的框架更清晰。

其实也就一个类、一个接口，但思想是一样的，或许你需要更多的类来让Client和Server共用，举个例子来说：如果你采用了“脏矩形技术”，那么可以把每个Item、每个Frame做个共享类放在这里。

Server接口：

public interface Server {
    public static final int PORT = 8042;
}

这个接口里很简单，之定义了一个端口号，以便于以后的程序修改和维护。

Message类：

听其名字就知道了，这个是消息类，因为无论是Client端还是Server端，其消息是能抽象出很多相似的东西的。

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

public class Message {
    public static final int NO_VALUE = -1;
    public static final int SIGNUP = 0;
    public static final int SIGNUP_ACK = 1;
    public static final int CLIENT_STATUS = 2;
    public static final int SERVER_STATUS = 3;
    public static final int ERROR = 4;
    public static final int SIGNOFF = 5;
    private int type;
    private String str;
    public static int player_id;

    public Message(int type,int player_id,String str) {
         this.type = type;
         Message.player_id = player_id;
         this.str = str;
    }
   
    public int getType() {
        return type;
    }

   public String getStr(){
     return str;
   }
   
    public void archive(DataOutputStream out) throws IOException {
        out.writeInt(type);
        out.writeInt(player_id);
        out.writeUTF(str);
        out.flush();
        System.out.println("***Client has send :"+type);
    }

   public static Message createFromStream(DataInputStream in) throws IOException {
        Message msg = new Message(in.readInt(), in.readInt(),in.readUTF());
        return msg;
    }

   public String toString() {
        return "Message: type # = " + type + ", player_id = "
               + player_id+", content = "+str;
    }

}

因为我们只是实现了简单的聊天功能，只是发送简单的字符给Server端，然后让其传送到各个Client端，因此功能比较简单，目的也仅仅用于学习，但你可以在此功能上增加更多的功能。

 

服务器端类

服务器端也很简单，就是开一个ServerSocket监听Client端的连接，如果有连接，就把此连接加入到一个List中。之所以这样处理， 是为了管理用户连接，比如将来你可能需要增加给特定的用户发送私人消息的功能，那么就可以从这个用户列表中寻找特定的用户进行发送。

连接建立以后利用一个单独的线程来进行通讯。

MultiPlayerServer类：

import java.io.IOException;
import java.net.ServerSocket;
import java.util.List;
import java.util.Vector;

public class MultiPlayerServer implements Server,Runnable{
    private List list;

    public MultiPlayerServer() {
        list = new Vector();
        Thread t2 = new Thread(this);
        t2.start();
    }
   
    public void distributeUpdate(int type,int player_id,String content) {
        ServerConnection conn;
        Message msg = new Message(type,player_id,content);
        for (int i = 0; i < list.size(); i++) {
            conn = (ServerConnection) list.get(i);
            conn.sendMessage(msg);
        }
    }

 

    public synchronized void removeConnection(ServerConnection conn) {
        list.remove(conn);
        System.out.println("removed connection for player " + conn.getPlayerID());
        System.out.println("connection list size is now " + list.size());
    }

 

    public void run() {
        ServerSocket socket;

        try {
            socket = new ServerSocket(PORT);
            System.out.println("multiplayer server listening @ " + PORT);

            for (; ; ) {
                    synchronized (this) {
                        list.add(new ServerConnection(socket.accept(),this));
                    }
                }
        } catch (IOException ioe) {
            System.out.println("*** MultiPlayerServer.run(): " + ioe);
        }
    }

}

ServerConnection类:

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.*;

public class ServerConnection implements Runnable {
    private MultiPlayerServer server;
    private Socket socket;
    private DataInputStream in;
    private DataOutputStream out;
    private int player_id;
    private Message err;
    private boolean done;
   
    public static Hashtable userList = new Hashtable();
    public static int player_count;

    /**
     * Create a new instance for use with game engine 'engine',
     * socket 'socket', and server 'server'.
     */
    public ServerConnection(Socket socket,MultiPlayerServer server) {
        this.server = server;
        this.socket = socket;
        done = false;
        Thread thread = new Thread(this);
        thread.start();
    }

    private synchronized void handleSignup(String str) {
        player_id = player_count++;
        if (player_id < 0) {
            System.out.println("ServerConnection.handleSignup(): engine refused player sign-up");
            return;
        }
        userList.put(new Integer(player_id),str);
        System.out.println("signed up player " + player_id);
        Message msg = new Message(Message.SIGNUP_ACK,player_id,"-1");

        try {
            msg.archive(out);
        } catch (IOException e) {
            System.out.println("***: could not send msg " + err);
        }
    }

    private void handleClientStatus(Message msg) {
        server.distributeUpdate(Message.SERVER_STATUS,player_id,userList.get(new Integer(player_id))+" 说 :"+msg.getStr());
    }

    public int getPlayerID() {
        return player_id;
    }

    /**
     * Send a message to the client connected to this instance
     */
    public synchronized void sendMessage(Message msg) {
        try {
            msg.archive(out);
        } catch (IOException e) {
            System.out.println("***: could not send msg " + msg);
        }
    }

    /**
     * main loop
     */
    public void run() {
        Message msg;

        try {
            in = new DataInputStream(socket.getInputStream());
            out = new DataOutputStream(socket.getOutputStream());

            while (!done) {
                msg = Message.createFromStream(in);
                switch (msg.getType()) {
                case Message.SIGNUP:
                 System.out.println("Server is handling : SIGNUP");
                    handleSignup(msg.getStr());
                    System.out.println("Server After : SIGNUP");
                    break;
                case Message.CLIENT_STATUS:
                 System.out.println("Server receive : CIENT_STATUS");
                    handleClientStatus(msg);
                    break;
                case Message.SIGNOFF:
                    break;
                default:
                    break;
                }
            }

            in.close();
            out.close();
            socket.close();
        } catch (Exception ioe) {
            System.out.println("*** ServerConnection.run(): " + ioe);
            server.removeConnection(this);
        }
        server.removeConnection(this);
        System.out.println("player " + player_id + " disconnected.");
    }

}

 

 

 

客户端类

客户端很简单，就是开一个线程处理用户的数据发送和接收，并做出相应的界面处理。

由于其简单，我就不再罗嗦，看代码：

MIDlet类：

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;

/**
 * @author 孙东风
 *
 **/

public class ChatMIDlet extends MIDlet implements Runnable,CommandListener{
 
    private static final String SERVER_IP = "127.0.0.1";
    private Command exit = new Command("exit",Command.EXIT,1);
    private GameScreen screen;
    private DataInputStream in;
    private DataOutputStream out;
    private StreamConnection conn;
    private boolean done;
    private int player_id;
   
    public static Display display;

    Form login_form = new Form("登陆界面");
    TextField name_textfield = new TextField("请输入呢称 ：","",10,TextField.ANY);
    Command loginCommand = new Command("登陆",Command.SCREEN,1);
    static String name;
   
 public ChatMIDlet() {
  super();
  login_form.append(name_textfield);
  login_form.addCommand(loginCommand);
  login_form.setCommandListener(this);
  display = Display.getDisplay(this);
 }

 protected void startApp(){
        try {
            conn = (StreamConnection) Connector.open("socket://"+SERVER_IP+":"+Server.PORT);
            in = new DataInputStream(conn.openInputStream());
            out = new DataOutputStream(conn.openOutputStream());
        } catch (IOException e) {
            closeConnection();
            System.out.println("*** could not connect to server: " + e);
            destroyApp(true);
        }
  Display.getDisplay(this).setCurrent(login_form);
 }
 
 public DataInputStream getInput(){
  return in;
 }
 
 public DataOutputStream getOutput(){
  return out;
 }

//关闭所有资源 
    private void closeConnection() {
        try {
            if (in != null) {
                in.close();
            }

            if (out != null) {
                out.close();
            }

            if (conn != null) {
                conn.close();
            }
        } catch (IOException e) {
            System.out.println(e);
        }
    }

 protected void pauseApp() {

 }

 protected void destroyApp(boolean bool){
  System.out.println("MidpTestClient.destroyApp()");
  Message msg = new Message(Message.SIGNOFF, Message.NO_VALUE,null);
  try {
            msg.archive(out);
        } catch (IOException e) {
        }

        closeConnection();
        Display.getDisplay(this).setCurrent(null);
 }

 public void handleStatus(Message msg){
  GameScreen.revStr = msg.getStr();
  screen.repaint();
 }
 
 public void handleError(){
     Message msg = new Message(Message.SIGNOFF, Message.NO_VALUE,null);

        try {
            msg.archive(out);
        } catch (IOException e) {
         e.printStackTrace();
        }
 }
 
 public void handleUnknown(Message msg){
  System.out.println("received unknown message: " + msg);
 }

 public void run() {

      Message msg;

         while (!done) {
             try {
                 msg = Message.createFromStream(in);
             } catch (IOException e) {
                 System.out.println("cant read message from stream");

                 continue;
             }

             switch (msg.getType()) {
             case Message.SERVER_STATUS:
              System.out.println("Client receive SERVER_STATUS");
                 handleStatus(msg);
              break;
             case Message.ERROR:
                 handleError();
                 break;
             default:
                 handleUnknown(msg);
                 break;
             }
         }
  
 }

 public void commandAction(Command cmd, Displayable g) {
        if (cmd == exit) {
            done = true;
            destroyApp(true);
            notifyDestroyed();
        }else if(cmd == loginCommand){
         if(name_textfield.getString().length() != 0){
          name = name_textfield.getString();
          Message msg = new Message(Message.SIGNUP,Message.NO_VALUE,name_textfield.getString());
          try{
           msg.archive(out);
           msg = Message.createFromStream(in);
           if (msg.getType() != Message.SIGNUP_ACK) {
                        System.out.println("*** could not sign up: " + msg);
                        destroyApp(true);
                    }
           
                    player_id = Message.player_id;
                    System.out.println("received sign-up ack, id = " + player_id);  
                    System.out.println("--------------1");
                    screen = new GameScreen();
                    screen.initialize(this, player_id);
                    done = false;
                    Thread thread = new Thread(this);
                    thread.start();
                    Display.getDisplay(this).setCurrent(screen);
          }catch(Exception e){
           System.out.println("*** could not sign up with server: " + e);
                    destroyApp(true);
          }
         }else{
          Alert alert = new Alert("警告","用户名和密码不能为空",null,AlertType.ERROR);
       alert.setTimeout(Alert.FOREVER);
       Display.getDisplay(this).setCurrent(alert);
               }
          }
    }

}
GameScreen类:

import javax.microedition.lcdui.*;

public class GameScreen extends Canvas implements CommandListener{

 public Form message_form = new Form("Send Message Form");
 public Command sendCommand = new Command("Send",Command.OK,1);
 public Command sendCommand2 = new Command("Send",Command.OK,1);
 public TextField content_textfield = new TextField("Content :","",10,TextField.ANY);
 public String content;
 
 public static String revStr = "null";
 
 public int player_id;
 ChatMIDlet chatmidlet;

 public GameScreen(){
  message_form.append(content_textfield);
  message_form.addCommand(sendCommand2);
  message_form.setCommandListener(this);
  this.addCommand(sendCommand);
  this.setCommandListener(this);
 }

 public void initialize(ChatMIDlet midlet,int player_id){
  this.chatmidlet = midlet;
  this.player_id = player_id;
 }
 
 protected void paint(Graphics g) {
   g.setColor(0x000000);
   g.fillRect(0,0,getWidth(),getHeight());
   g.setColor(0xffffff);
   g.drawString(revStr,0,0,Graphics.LEFT|Graphics.TOP);
 }

 public void commandAction(Command cmd, Displayable g) {
  if(cmd == sendCommand){
   System.out.println("CommandListenning this");
   ChatMIDlet.display.setCurrent(message_form);
  }else if(cmd == sendCommand2){
   content = content_textfield.getString();
   Message msg = new Message(Message.CLIENT_STATUS,player_id,content);
   try{
    msg.archive(chatmidlet.getOutput());
   }catch(Exception e){
    e.printStackTrace();
    System.out.println("Send Message Failed!");
   }
   ChatMIDlet.display.setCurrent(this);
  }
 }

}

后话：希望此文能为3G到来之前吹点热风，催化催化。

效果图如下：

输入呢称并传送到Server端

输入聊天内容

显示呢称和说话内容