ServerThread

package com.server;

import java.io.DataInputStream;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.*;

import org.apache.log4j.Logger;

/**
 * 服务器线程类
 * @author 翱翔团队
 * @version 1.0.0
 */
public class ServerThread implements Runnable
{
    //定义套接字
    Socket socket = null;
    
    List list = null, playList = null;//定义list集合
            
    DataInputStream dis = null;//定义数据输入流
    
    static DataOutputStream dos = null;//定义数据输出流
    
    static File file = null;//定义文件对象
    
    static FileInputStream fis2 = null;//定义文件输入流
    
    static ObjectInputStream ois2 = null;//定义文件输出流
    
    public User user = null;//定义文件对象
    
    public String[] data = null;//定义数据数组
    
    static FileOutputStream fos = null;//文件输出流
    
    static ObjectOutputStream oos = null;//对象输出流
    
    ServerThread thread;
    
    // 定义一个logger  
    static Logger logger = Logger.getLogger(com.server.ServerFrame.class.getName());
    
    /**
     * 服务器线程的入口方法
     * @param socket 套接字
     * @param txtMess 文本域
     * @param list list集合
     */
    public ServerThread(Socket socket, List list, List playerList)
    {
        this.socket = socket;
        this.list = list;
        this.playList = playerList;
    }
    
    /**
     * 线程的运行方法
     */
    public void run()
    {
        try
        {
            while (true)
            {
                //当前socket的输入流
                dis = new DataInputStream(this.socket.getInputStream());
                //当前socket的输出流
                dos = new DataOutputStream(this.socket.getOutputStream());
                //实例化消息对象
                String mess = dis.readUTF();
                System.out.println("server receive  mess:" + mess);
                logger.info("server receive  mess:" + mess);
                
                // 字符串已#号分隔
                data = mess.split("#");
                
                for (Iterator iterator = list.iterator(); iterator.hasNext();)
                {
                    Socket socket = (Socket) iterator.next();
                    logger.info("Server list socket:" + socket.toString());
                }
                
                for (Iterator iterator = playList.iterator(); iterator.hasNext();)
                {
                    User user = (User) iterator.next();
                    logger.info("Server playList user:" + user.getUserName());
                }
                //字符串已#号分隔
                data = mess.split("#");
                
                if (data.length > 1)
                {
                    //获取数据的分隔
                    int flag = Integer.parseInt(data[0]);
                    System.out.println("server flag:" + flag);
                    switch (flag)
                    {
                        //网络聊天
                        case TypeListInfo.NET_CHAT:
                            for (Iterator iterator = list.iterator(); iterator.hasNext();)
                            {
                                Socket sk = (Socket) iterator.next();
                                dos = new DataOutputStream(sk.getOutputStream());
                                dos.writeUTF(mess);
                            }
                            break;
                        // 玩家连接
                        case TypeListInfo.PLAYER_CONTECT:
                            ServerFrame.setCount(ServerFrame.getCount() + 1);
                            // count控制是否是玩家
                            if (ServerFrame.getCount() <= 2)
                            {
                                // 下棋者连接后 进行玩家分配 先连接的为红方
                                dos = new DataOutputStream(
                                        socket.getOutputStream());
                                dos.writeUTF("" + ServerFrame.getMap());
                                if (ServerFrame.getMap() == 2)
                                {
                                    playList.add(0, socket);
                                    ServerFrame.setMap(1);
                                }
                                else if (ServerFrame.getMap() == 1)
                                {
                                    playList.add(1, socket);
                                    ServerFrame.setMap(2);
                                }
                            }
                            break;
                        // 头像 名字
                        case TypeListInfo.IMAGE_NAME:
                            for (Iterator iterator = list.iterator(); iterator.hasNext();)
                            {
                                Socket sk = (Socket) iterator.next();
                                if (sk != this.socket)
                                {
                                    dos = new DataOutputStream(
                                            sk.getOutputStream());
                                    dos.writeUTF(mess);
                                }
                            }
                            break;
                        //注册
                        case TypeListInfo.REGISTER_YES:
                            try
                            {
                                //注册信息反序列化
                                fileReverse(TypeListInfo.REGISTER_YES);
                                //登录信息序列化
                                fileRank(data[1], data[2], data[3]);
                            }
                            catch (Exception e)
                            {
                                e.printStackTrace();
                            }
                            //向客户端发送信息
                            dos.writeUTF(TypeListInfo.REGISTER_NO + "#-1");
                            break;
                        //登录
                        case TypeListInfo.LOGIN_OK:
                            try
                            {
                                //登录信息反序列化
                                fileReverse(TypeListInfo.LOGIN_OK);
                            }
                            catch (Exception e)
                            {
                                e.printStackTrace();
                            }
                            dos.writeUTF(TypeListInfo.LOGIN_NO + "#-1");
                            break;
                        //退出
                        case TypeListInfo.IS_EXIT:
                            list.remove(this.socket);
                            playList.remove(this.socket);
                            ServerFrame.setCount(ServerFrame.getCount() - 1);
                            if (playList.size() == 0)
                            {
                                ServerFrame.setMap(2);
                            }
                            else
                            {
                                System.out.println("data[2]:" + data[2]);
                                ServerFrame.setMap(Integer.parseInt(data[2].trim()));
                            }
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                //如果遍历的socket不等于当前的socket
                                if (this.socket == socket)
                                {
                                    //集合的迭代
                                    list.remove(socket);
                                    //写入OK
                                    dos.writeUTF(TypeListInfo.IS_EXIT + "");
                                    break;
                                }
                            }//for
                            break;
                        case TypeListInfo.NET_CHESS:
                            //服务器处理网络同步走棋
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket s = (Socket) it.next();
                                if (this.socket != s)
                                {
                                    dos = new DataOutputStream(
                                            s.getOutputStream());
                                    //转发信息
                                    dos.writeUTF(mess);
                                }
                            }
                            break;
                        //网络同步悔棋
                        case TypeListInfo.NET_REGRET:
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                if (this.socket != socket)
                                {
                                    dos = new DataOutputStream(
                                            socket.getOutputStream());
                                    //转发同意信息
                                    dos.writeUTF(mess);
                                }
                            }
                            break;
                        //同意悔棋
                        case TypeListInfo.NET_REGRET_YES:
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                if (this.socket != socket)
                                {
                                    dos = new DataOutputStream(
                                            socket.getOutputStream());
                                    dos.writeUTF(TypeListInfo.NET_REGRET_YES
                                            + "#yes");
                                }
                            }
                            break;
                        //不同意悔棋
                        case TypeListInfo.NET_REGRET_NO:
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                if (this.socket != socket)
                                {
                                    dos = new DataOutputStream(
                                            socket.getOutputStream());
                                    dos.writeUTF(mess + "#no");
                                }
                            }
                            break;
                        //网络转发消息
                        case TypeListInfo.NET_MESS:
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                if (this.socket != socket)
                                {
                                    dos = new DataOutputStream(
                                            socket.getOutputStream());
                                    dos.writeUTF(mess + "#ok");
                                }
                            }
                            break;
                        //开始
                        case TypeListInfo.NET_START:
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                if (this.socket != socket)
                                {
                                    dos = new DataOutputStream(
                                            socket.getOutputStream());
                                    logger.info("Server forward  start mess:"+mess+"#");
                                    dos.writeUTF(mess + "#");                                  
                                }
                            }
                            break;
                        // 确定开始
                        case TypeListInfo.NET_START_YES:
                            // 调用集合的遍历
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                try
                                {
                                    // 数据输出流
                                    dos = new DataOutputStream(
                                            socket.getOutputStream());
                                    logger.info("Server forward confirm start mess:"+mess+"#");
                                    // 转发消息
                                    dos.writeUTF(mess + "#");
                                }
                                catch (Exception e)
                                {
                                    e.printStackTrace();
                                }
                            }
                            
                            System.out.println("服务器成功转发消息");
                            break;
                        case TypeListInfo.NET_GAME_OVER:
                            //调用集合的遍历
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                if (this.socket != socket)
                                {
                                    try
                                    {
                                        //数据输出流
                                        dos = new DataOutputStream(
                                                socket.getOutputStream());
                                        //转发消息
                                        dos.writeUTF(mess + "#");
                                    }
                                    catch (Exception e)
                                    {
                                        e.printStackTrace();
                                    }
                                }
                            }
                            break;
                        //网络求和
                        case TypeListInfo.NET_PEACE:
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                if (this.socket != socket)
                                {
                                    try
                                    {
                                        //数据输出流
                                        dos = new DataOutputStream(
                                                socket.getOutputStream());
                                        //转发消息
                                        dos.writeUTF(mess + "#");
                                    }
                                    catch (Exception e)
                                    {
                                        e.printStackTrace();
                                    }
                                }
                            }
                            break;
                        case TypeListInfo.NET_PEACE_YES:
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                if (this.socket != socket)
                                {
                                    try
                                    {
                                        //数据输出流
                                        dos = new DataOutputStream(
                                                socket.getOutputStream());
                                        //转发消息
                                        dos.writeUTF(mess + "#");
                                    }
                                    catch (Exception e)
                                    {
                                        e.printStackTrace();
                                    }
                                }
                            }
                            break;
                        case TypeListInfo.NET_PEACE_NO:
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                if (this.socket != socket)
                                {
                                    try
                                    {
                                        //数据输出流
                                        dos = new DataOutputStream(
                                                socket.getOutputStream());
                                        //转发消息
                                        dos.writeUTF(mess + "#");
                                    }
                                    catch (Exception e)
                                    {
                                        e.printStackTrace();
                                    }
                                }
                            }
                            break;
                        case TypeListInfo.NET_PEACE_MESS:
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                try
                                {
                                    //数据输出流
                                    dos = new DataOutputStream(
                                            socket.getOutputStream());
                                    //转发消息
                                    dos.writeUTF(mess + "#");
                                }
                                catch (Exception e)
                                {
                                    e.printStackTrace();
                                }
                            }
                            break;
                        case TypeListInfo.NET_WIN:
                            for (Iterator it = list.iterator(); it.hasNext();)
                            {
                                Socket socket = (Socket) it.next();
                                try
                                {
                                    //数据输出流
                                    dos = new DataOutputStream(
                                            socket.getOutputStream());
                                    //转发消息
                                    dos.writeUTF(mess + "#");
                                }
                                catch (Exception e)
                                {
                                    e.printStackTrace();
                                }
                            }
                            break;
                        case TypeListInfo.CLOSE:
                            logger.info("server remove socket:"+socket);
                            list.remove(socket);
                            break;
                        default://                            
                            break;
                    }//switch
                }//if
            }//while
        }//try
        catch (IOException e)
        {
            //System.out.println("服务器成功处理客户端的退出。");
        }
    }
    
    /**
     * 文件的反序列化
     * @param info 文件信息
     * @throws Exception 抛出异常
     */
    public void fileReverse(int info) throws Exception
    {
        //实例化一个文件对象
        file = new File("user.txt");
        if (file.exists() == true)
        {
            //实例化文件输入流
            fis2 = new FileInputStream("user.txt");
            //实例化对象输入流
            ois2 = new ObjectInputStream(fis2);
            //将原来文件反序列化到list中
            playList = (List) ois2.readObject();
            //流的关闭
            ois2.close();
            fis2.close();
            //集合的迭代
            Iterator iterator = playList.iterator();
            while (iterator.hasNext())
            {
                //实例化对象
                user = (User) iterator.next();
                //实例化用户名
                String name = user.getUserName();
                //实例化密码
                String pwd = new String(user.getPwd());
                switch (info)
                {
                    //注册信息
                    case TypeListInfo.REGISTER_YES:
                        if (name.equals(data[1]))
                        {
                            //向客户端发送的注册信息
                            dos.writeUTF(TypeListInfo.REGISTER_YES + "#0");
                            return;
                        }
                        break;
                    //登录信息
                    case TypeListInfo.LOGIN_OK:
                        if (name.equals(data[1]) && pwd.equals(data[2]))
                        {
                            //向客户端发送的登录信息
                            dos.writeUTF("#" + TypeListInfo.LOGIN_OK + "#");
                            return;
                        }
                        break;
                    default:
                        break;
                }//switch
            }//while
        }//if        
    }//fileReverse()
    
    /**
     * 文件的序列化
     * @param name 用户名
     * @param pwd 密码
     * @param sex 性别
     * @throws Exception 抛出异常
     */
    public void fileRank(String name, String pwd, String sex) throws Exception
    {
        // 新建一个用户对象
        user = new User();
        //设置用户对象的属性值
        user.setUserName(name);
        //设置用户对象的密码
        user.setPwd(pwd);
        //设置对象的性别
        user.setSex(sex);
        System.out.println(user.getUserName() + user.getPwd());
        //将对象添加到集合中
        playList.add(user);
        //实例化文件输出流
        fos = new FileOutputStream("user.txt");
        //        实例化对象输出流
        oos = new ObjectOutputStream(fos);
        //将集合中的数据写入到文件中
        oos.writeObject(playList);
        oos.flush();
        fos.flush();
        oos.close();
        fos.close();
        dos.writeUTF(TypeListInfo.REGISTER_YES + "#1");
    }
}