在java中，服务器套接字从一个客户端读取对象，并在另一个套接字上写入

我想开发一个服务器，它可以完成以下任务。 1） 接受来自client1的请求，读取objet并写入另一个对象 2） 接受来自client2的请求，读取objet并写入另一个对象 3） Client1输入client2的信息，服务器必须根据信息获取client2并在client2上写入对象

服务器java

public class Server{
ServerSocket serverSocket ;
Socket socket;
@SuppressWarnings("rawtypes")
public static List<Map> clientList = new ArrayList<Map>();//creating list to store map objects of all clients


// Server socket instantiating
Server(int port) {
    try{
        serverSocket = new ServerSocket(port);
    }catch(Exception e){
        e.printStackTrace();
    }
}

//server is waiting on listen mode for accepting clients
void serverConnect() {
    while (true) {
        try {
            System.out.println("Server is Waiting for client to connect ");
            socket = serverSocket.accept();
            socket.setKeepAlive(true);
            System.out.println("connected to: "+ socket.getRemoteSocketAddress());
            new Thread(new ClientSession(socket)).start();//creating a new thread for every client
        } catch (Exception e) {
            e.printStackTrace();
            break;
        }
    }
}


public static void main(String args[]) throws IOException {
    Server server = new Server(5050);
    try {
        server.serverConnect();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

公共类服务器{
服务器套接字服务器套接字；
插座；
@抑制警告（“原始类型”）
public static List clientList=new ArrayList（）；//创建列表以存储所有客户端的映射对象
//服务器套接字实例化
服务器（int端口）{
试一试{
serverSocket=新的serverSocket（端口）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
//服务器正在等待侦听模式以接受客户端
void serverConnect（）{
while（true）{
试一试{
System.out.println（“服务器正在等待客户端连接”）；
socket=serverSocket.accept（）；
socket.setKeepAlive（true）；
System.out.println（“连接到：”+socket.getRemoteSocketAddress（））；
新线程（新客户端会话（套接字））.start（）；//为每个客户端创建新线程
}捕获（例外e）{
e、 printStackTrace（）；
打破
}
}
}
公共静态void main（字符串args[]）引发IOException{
服务器=新服务器（5050）；
试一试{
serverConnect（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}

}

ClientSession.java

`public class ClientSession implements Runnable {

Socket clientsocket;
String emailId;
String msg;
String ipaddress;
String phoneNumber;
String sessionId;
String socketAddress;
String calleeInfo;
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost/Server";
ObjectOutputStream oos;
  @SuppressWarnings("rawtypes")
  Map globalmap = new HashMap();//creating a hashmap object to store sockets,objectoutputstreamobjects of clients

ClientSession(Socket socket) {
    // TODO Auto-generated constructor stub
    globalmap.put("clientsockets", socket);
    this.clientsocket = socket;
    System.out.println("socket--"+socket);
     try {
        oos = new ObjectOutputStream(clientsocket.getOutputStream());
        globalmap.put("oos", oos);
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

@SuppressWarnings("unchecked")
public void run() {
    // TODO Auto-generated method stub
    System.out.println("A new Thread started");
    try {
        System.out.println("IN SERVER READ METHOD");
        ObjectInputStream ois = new ObjectInputStream(clientsocket.getInputStream());
        Map<String, String> map = (Map<String, String>) ois.readObject();
        System.out.println("map in servereread"+map);
        System.out.println("IN SERVER DECODE METHOD");
        msg =  map.get("msg");
        System.out.println(msg);
        emailId =  map.get("email");
        phoneNumber =  map.get("phoneno");
        globalmap.put("phoneno", phoneNumber);
        globalmap.put("email",emailId);
        Server.clientList.add(globalmap);
        if (msg.equals("REGISTER")) {
            System.out.println("IN DECODE REGISTER");
            ipaddress =  map.get("ipaddr");
        } else if (msg.equals("INVITE")) {
            System.out.println("IN DECODE INVITE");
            sessionId =  map.get("sessionId");
            calleeInfo =  map.get("calleeInfo");
        }
        analyze(map);
    } catch (Exception e) {
        e.printStackTrace();
    }

}



private void analyze(Map<String, String> map) {
    // TODO Auto-generated method stub
    try {
        String SQL = null;
        System.out.println(msg);
        Class.forName("com.mysql.jdbc.Driver");
        System.out.println("Connecting to database...");
        Connection conn = DriverManager.getConnection(DB_URL,"username","pwd");
        Statement st = conn.createStatement();
        SocketAddress socketAddr = clientsocket.getRemoteSocketAddress();
        socketAddress = socketAddr.toString();
        if (msg.equals("REGISTER")) {
            SQL = "INSERT INTO Register (email,phoneNumber,ipaddress,socketaddress) VALUES ('"+ emailId+ "','"+ phoneNumber+ "','"+ ipaddress+ "','" + socketAddress + "')";
            System.out.println("SQL statement..." + SQL);
            serverWrite();
        } else if (msg.equals("INVITE")) {
            System.out.println("Connecting to database for invite...");
            SQL = "INSERT INTO Invite (sessionid,calleremail,callerphoneNo,calleeInfo) VALUES ('"+ sessionId+ "','"+ emailId+ "','"+ phoneNumber+ "','" + calleeInfo + "')";
            System.out.println("SQL statement--" + SQL);
            System.out.println("CalleeInfo--" + calleeInfo);
            // Retrieve the socket of the destination
            String query = "SELECT * FROM Register WHERE email='"+ calleeInfo + "' OR phoneNumber = '" + calleeInfo+ "'";
            ResultSet rs = st.executeQuery(query);
            System.out.println("ResultSet--" + rs);
            if (rs.next()) {
                String socketaddr = rs.getString("socketaddress");
                String email= rs.getString("email");
                String phoneNo= rs.getString("phoneNumber");
                String ipadd= rs.getString("ipaddress");
            }
                for(int i=0;i<Server.clientList.size();i++){
                    String emailid= (String) Server.clientList.get(i).get("email");
                    String phone = (String) Server.clientList.get(i).get("phoneno");
                    if(calleeInfo.equals(emailid) || calleeInfo.equals(phone)){
                        ObjectOutputStream out1= (ObjectOutputStream) Server.clientList.get(i).get("oos");
                        System.out.println("ObjectOutputStream----"+out1);
                        System.out.println("writing on"+Server.clientList.get(i).get("clientsockets"));
                        System.out.println("map before writing on to client2--"+map);
                        out1.reset();
                        out1.writeObject(map);
                        out1.flush();
                        break;
                    }

                }
            // retrieve socket info from register table based on calleeInfo
            // as primary key
        }
        st.executeUpdate(SQL);

    } catch (Exception e) {
        e.printStackTrace();
    }
}


private void serverWrite() {
    // TODO Auto-generated method stub
    try {
        // Using ObjectOutputStream class to write object
          HashMap<String, String> map = new HashMap<String, String>();// Creating an object for HashMap class
          if (msg.equals("REGISTER")) {
            System.out.println("ObjectOutputStream storing--"+oos);
            map.put("msg", "REGISTERED"); // setting a message in HashMap object
            System.out.println("sending registered");
            oos.writeObject(map);// writing an object on socket
        } 
    /*  else if (msg.equals("INVITE")) {
            map.put("msg", "CALLING");
            System.out.println("sending calling");
        }*/

    } catch (Exception e) {
        e.printStackTrace();
    }
}

`public类ClientSession实现可运行{
插座客户端插座；
字符串emailId；
串味精；
字符串地址；
字符串电话号码；
字符串sessionId；
字符串套接字地址；
字符串calleeInfo；
静态最终字符串JDBC_DRIVER=“com.mysql.JDBC.DRIVER”；
静态最终字符串DB_URL=“jdbc:mysql://localhost/Server";
对象输出流oos；
@抑制警告（“原始类型”）
Map globalmap=new HashMap（）；//创建HashMap对象以存储客户端的套接字、objectoutputstreamobjects
客户端会话（套接字）{
//TODO自动生成的构造函数存根
globalmap.put（“客户端套接字”，套接字）；
this.clientsocket=socket；
System.out.println（“套接字--”+socket）；
试一试{
oos=newObjectOutputStream（clientsocket.getOutputStream（））；
全球地图放置（“oos”，oos）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
@抑制警告（“未选中”）
公开募捐{
//TODO自动生成的方法存根
System.out.println（“新线程启动”）；
试一试{
System.out.println（“服务器内读取方法”）；
ObjectInputStream ois=新的ObjectInputStream（clientsocket.getInputStream（））；
Map Map=（Map）ois.readObject（）；
System.out.println（“服务器端映射”+map）；
System.out.println（“服务器内解码方法”）；
msg=map.get（“msg”）；
System.out.println（msg）；
emailId=map.get（“电子邮件”）；
phoneNumber=map.get（“phoneno”）；
全球地图输入（“电话号码”，电话号码）；
globalmap.put（“电子邮件”，emailId）；
Server.clientList.add（globalmap）；
如果（消息等于（“寄存器”））{
System.out.println（“解码寄存器中”）；
ipaddress=map.get（“ipaddr”）；
}else if（msg.equals（“INVITE”））{
System.out.println（“解码邀请”）；
sessionId=map.get（“sessionId”）；
calleeInfo=map.get（“calleeInfo”）；
}
分析（地图）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
私有void分析（映射）{
//TODO自动生成的方法存根
试一试{
字符串SQL=null；
System.out.println（msg）；
Class.forName（“com.mysql.jdbc.Driver”）；
System.out.println（“连接到数据库…”）；
Connection conn=DriverManager.getConnection（DB_URL，“username”，“pwd”）；
语句st=conn.createStatement（）；
SocketAddress SocketAddress=clientsocket.getRemoteSocketAddress（）；
socketAddress=socketAddress.toString（）；
如果（消息等于（“寄存器”））{
SQL=“将值（“+emailId+”、“+phoneNumber+”、“+ipaddress+”、“+ipaddress+”、“+socketaddress+”）插入寄存器（电子邮件、电话号码、ipaddress、socketaddress）；
System.out.println（“SQL语句…”+SQL）；
serverWrite（）；
}else if（msg.equals（“INVITE”））{
System.out.println（“连接到数据库以获取邀请…”）；
SQL=“插入Invite（sessionid、calleremail、callerphoneNo、calleeInfo）值（“+sessionid+”、“+emailId+”、“+phoneNumber+”、“+calleeInfo+”）”）；
System.out.println（“SQL语句--”+SQL）；
System.out.println（“CalleeInfo--”+CalleeInfo）；
//检索目标的套接字
String query=“从注册表中选择*，其中email='”+calleeInfo+“'或phoneNumber='”+calleeInfo+“'”；
结果集rs=st.executeQuery（查询）；
System.out.println（“结果集--”+rs）；
如果（rs.next（））{
字符串socketaddr=rs.getString（“socketaddress”）；
String email=rs.getString（“电子邮件”）；
字符串phoneNo=rs.getString（“phoneNumber”）；
字符串ipadd=rs.getString（“ipaddress”）；
}
对于（int i=0；i在本例中，问题在于客户端不在服务器中..但有一个建议是不要将map对象创建为map map=new map；。它将只使用字符串。只需创建为map map=new map（）；它将使用字符串、数组和所有数据类型