BlogJava-方枪枪的java世界-文章分类-Jdk

ChatServer

秋天的山谷 — Mon, 09 Dec 2013 14:04:00 GMT

package com.tianhe.frm.chat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Scanner;

/**
*
*

* 服务器的实现效果：

*

* 1.输入-help得到所有有关服务器操作的命令

*

* 2.输入-run进入服务器各项内容初始化

*

* 3.输入-stop断开服务器

*

* 4.输入-quit断开服务器，并退出操作

*

* 5.服务器创建成功后，会通过单独的线程运行监听客户端信息(listenLink)

*

* 6.服务器接收到数据后，会将数据移交至数据分析器(analyseMes)处理

*

* 7.当用户确定连接并确定昵称后，服务器将该用户的地址及姓名存储在infoMemory中。

*

*

*

*

* 服务器的类与方法：

*

* 1.测试服务器创建：testServer(String ip,int port)

*

* 2.初始化服务器：initServer(String ip,int port)

*

* 3.确定IP与Port ：fixServerLink(String ip,int port)

*

* 4.信息监听器：listenLink()

*

* 5.数据分析器：analyseMes(String mes)

*

* 6.获取地址用户名：getConsumerName(SocketAddress sa)

*

* 7.数据转发器：transforMes(String mes)

*

* 8.数据单项转发器：transforMesSingle(SocketAddress adr,String mes)

*

* 9.停止服务器：cutServer()

*

* 10.获得帮助列表：helpList()

*

* 11.错误提示方法：errorTip(String str)

*

* 12.在主函数中进行相应操作

*

*

* 重点注意的地方：

*

* 与客户端相仿，为了顺利监听信息，需要另一个线程运行信息监听器
*
*/
public class ChatServer implements Runnable
{
    private DatagramSocket server = null;

    private DatagramPacket getDatas = null;

    private InetAddress serverAddress = null;

    private int port = 0;

    // 开始运行监听的变量
    private boolean beStart = false;

    // 用来测试服务器的变量
    private boolean test = true;

    // 信息存储器
    private Hashtable infoMemory = new Hashtable();

    /**
     * 测试服务器连接
     *
     * @param ip
     * @param port
     * @return
     */
    public boolean testServer(String ip, int port)
    {
        this.initServer(ip, port);
        return test;
    }

    /**
     * 服务器初始化
     *
     * @param ip
     * @param port
     */
    public void initServer(String ip, int port)
    {
        // 确定IP与port输入正确
        this.fixServerLink(ip, port);
        try
        {
            server = new DatagramSocket(this.port, serverAddress);
            System.out.println("!-The Server Initialization Success！");
            // 可以开始运行变量
            beStart = true;
        }
        catch (SocketException s)
        {
            // 如果出现异常，则服务器测试不通过
            test = false;
            errorTip("!-The Server Initialization Fail!");
        }
        finally
        {

        }
    }

    /**
     * 确定服务器IP和端口信息
     *
     * @param ip
     * @param port
     */
    private void fixServerLink(String ip, int port)
    {
        // 判断连接服务器的端口号
        // 如果输入命令为0，则为默认端口号9999
        // 否则端口号为新端口号
        if (port == 0)
            this.port = 9999;
        else
            this.port = port;
        // 判断连接服务器的IP地址
        // 如果输入命令为0，则为默认的本地IP地址
        // 否则为输入的IP地址
        try
        {
            if (ip.equalsIgnoreCase("0"))
                this.serverAddress = InetAddress.getLocalHost();
            else
                this.serverAddress = InetAddress.getByName(ip);
        }
        catch (UnknownHostException u)
        {
            errorTip("!-Sorry, IP address you put is not currect!");
        }
    }

    /**
     * 监听信息
     *
     */
    public void listenLink()
    {
        byte[] buf = new byte[1024];
        String mes = null;
        try
        {
            getDatas = new DatagramPacket(buf, buf.length);
            System.out.println("!-The Server starts listenning to message.");
            while (beStart)
            {
                server.receive(getDatas);
                mes = new String(buf, 0, getDatas.getLength());
                // 将获取的数据传递至数据分析器
                this.analyseMes(mes);
            }
        }
        catch (IOException e)
        {
            errorTip("!-The Server Can not receive message");
        }
    }

    /**
     * 数据分析器，给予相应处理
     *
     * @param mes
     */
    private void analyseMes(String mes)
    {
        // 获取当前客户端的地址：
        SocketAddress adr = getDatas.getSocketAddress();

        // -test:进行服务器与客户端的连接测试
        // 若成功，则将该客户端发送成功消息
        if (mes.trim().equalsIgnoreCase("-test"))
        {
            transforMesSingle(adr, "-test: !-From Server:Succeed in Testing.");
        }

        // -quit：接受客户端退出信息
        // 将该用户的退出信息转发至所有在线成员
        else if (mes.trim().equalsIgnoreCase("-quit"))
        {
            String name = this.getConsumerName(adr);
            System.out.println(name + "//" + adr + " quit! ");
            transforMes("* " + name + "退出聊天室");
            infoMemory.remove(name);
        }

        // -getList:接受客户端获取列表的请求
        // 将所有用户连接为字符串的形式，如："-getList,用户1,用户2...用户n"
        else if (mes.trim().equals("-getList"))
        {
            StringBuffer list = new StringBuffer();
            list.append("-getList,");
            Enumeration names = infoMemory.keys();
            while (names.hasMoreElements())
            {
                list.append(names.nextElement() + ",");
            }
            transforMesSingle(getDatas.getSocketAddress(), list.toString());
        }

        // -to：接受客户端请求，将信息转发给相应客户
        // 如果目标客户不存在，则向请求客户发送相应消息
        else if (mes.indexOf("-to ") != -1 && mes.startsWith("-to "))
        {
            String main = mes.substring("-to ".length(), mes.length());
            String toName = main.substring(0, main.indexOf(" "));
            String name = this.getConsumerName(adr);
            String con = name + " say to you :" + main.substring(toName.length() + 1, main.length());
            if (!infoMemory.containsKey(toName))
                transforMesSingle(adr, "!-The message can not be recevie by whom you send for,please check out.");
            else
                transforMesSingle(infoMemory.get(toName), con);
        }

        // -nick:接受客户端登录请求
        // 如果输入的匿名不存在，则登记该用户与infoMemory
        // 如果存在则返回相应提示
        else if (mes.indexOf("-nick ") != -1 && mes.startsWith("-nick "))
        {
            String nickName = mes.substring("-nick ".length(), mes.length());
            if (infoMemory.containsKey(nickName))
                transforMesSingle(adr, "-nick: !-The nickname you post is already exist,please try others.");
            else
            {
                infoMemory.put(nickName, adr);
                transforMes("Welcome " + nickName + " to Sunspot Chat!");
                System.out.println(nickName + "//" + adr.toString() + " succeed in lanuching.");
            }
        }

        // 一般消息将会转发至所有用户
        else
        {
            String name = this.getConsumerName(adr);
            transforMes(name + ": " + mes);
        }
    }

    /**
     * 通过地址得到用户的昵称由于Hashtable无法通过Value获取Key，所有专门写该方法
     *
     * @param sa
     * @return
     */
    private String getConsumerName(SocketAddress sa)
    {
        Enumeration names = infoMemory.keys();
        String name = null;
        while (names.hasMoreElements())
        {
            String temp = names.nextElement();
            SocketAddress adrs = infoMemory.get(temp);
            // 进行比较
            if (sa.equals(adrs))
            {
                name = temp;
                break;
            }
        }
        return name;
    }

    /**
     * 向所有的用户发送数据
     *
     * @param mes
     */
    public void transforMes(String mes)
    {
        byte[] buf = mes.getBytes();
        DatagramPacket sendDatas = null;
        Enumeration all = infoMemory.elements();
        try
        {
            while (all.hasMoreElements())
            {
                sendDatas = new DatagramPacket(buf, buf.length, all.nextElement());
                server.send(sendDatas);
            }
        }
        catch (SocketException s)
        {
            errorTip("!-The feedback address is error!");
        }
        catch (IOException i)
        {
            errorTip("!-Can not send message!");
        }
    }

    /**
     * 向单个用户发送数据
     *
     * @param adr
     * @param mes
     */
    public void transforMesSingle(SocketAddress adr, String mes)
    {
        byte[] buf = mes.getBytes();
        try
        {
            DatagramPacket sendDatas = new DatagramPacket(buf, buf.length, adr);
            server.send(sendDatas);
        }
        catch (SocketException s)
        {
            errorTip("!-The feedback address is error!");
        }
        catch (IOException i)
        {
            errorTip("!-Can not send message!");
        }
    }

    /**
     * 断开连接
     *
     */
    public void cutServer()
    {
        beStart = false;
        if (server != null)
            server.close();
        System.out.println("!-The server is done.");
    }

    public void helpList()
    {
        System.out.println("-help" + "    获取服务器相应操作的帮助" + "\n" + "-run " + "    运行服务器，并同时建立信息监听" + "\n" + "-stop"
                + "    停止服务器" + "\n" + "-quit" + "    停止服务器，并退出命令" + "\n");
    }

    /**
     * 线程
     */
    public void run()
    {
        listenLink();
    }

    /**
     * 主要操作
     *
     * @param args
     */
    public static void main(String[] args)
    {
        ChatServer ser = new ChatServer();
        String getIp = null;
        int getPort = 0;

        // 建立输入
        Scanner input = new Scanner(System.in);
        System.out.println("!-Please input server command:");

        // 开始输入
        String command = null;
        // 如果输入quit将断开连接，并退出操作
        while (!(command = input.next()).equalsIgnoreCase("-quit"))
        {
            // 获取帮助
            if (command.equalsIgnoreCase("-help"))
            {
                ser.helpList();
            }

            // 初始化服务器
            if (command.equalsIgnoreCase("-run"))
            {
                boolean goon = true;
                while (goon)
                {
                    System.out.println("1.输入服务器的IP地址，默认输入数字0：");
                    getIp = input.next();
                    System.out.println("2.输入服务器的端口号，默认输入数字0：");
                    try
                    {
                        getPort = input.nextInt();
                    }
                    catch (Exception e)
                    {
                        System.out.println("!-The port style is not currect!");
                    }
                    // 测试服务器创建，如果成功则同时为信息监听器建立线程
                    System.out.println("!-创建服务器并运行...");
                    if (ser.testServer(getIp, getPort))
                    {
                        new Thread(ser).start();
                        goon = false;
                    }
                    else
                        System.out.println("!-服务器创建失败，请检查！");
                }
            }

            // 关闭服务器
            if (command.equalsIgnoreCase("-stop"))
            {
                ser.cutServer();
            }
        }
        input.close();
        ser.cutServer();
    }

    /**
     * 错误提示
     *
     * @param str
     */
    public static void errorTip(String str)
    {
        System.out.println("-----------------\n" + str + "\n-----------------");
    }
}

秋天的山谷 2013-12-09 22:04 发表评论

ChatClient

秋天的山谷 — Mon, 09 Dec 2013 14:04:00 GMT

package com.tianhe.frm.chat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.InputMismatchException;
import java.util.NoSuchElementException;
import java.util.Scanner;

/**
*
*

* 客户端的实现效果

*

* 1.登录服务器，如果服务器端口号和IP号输入的字符都是"0"则，客户端连接到默认的服务器

*

* 2.输入聊天昵称

*

* 3.输入"-quit"会自动退出聊天

*

* 4.输入"-getList"会得到在线用户的名称

*

* 5.输入"-to <用户名称> <聊天信息>"会把信息发送到指定的用户处，他人看不到

*

* 6.输入"-help"会得到客户端相应操作帮助

*

* 6.直接输入内容则会将内容发送到所有在线的用户处

*

*

*

*

* 客户端的类与方法

*

* 1.建立连接方法：connectServer(String ip,int port)

*

* 2.断开连接方法：disconnectServer()

*

* 2.发送消息方法：sendMes(String mes)

*

* 3.接受消息方法：getMes()

*

* 4.接受一次消息：getMesOnce()

*

* 5.获得用户列表：getList(String mes)

*

* 6.测试连接方法：testConnect(String ip,int port)

*

* 7.检查用户名：checkNickName(String nickName)

*

* 8.获得帮助列表：helpList()；

*

* 9.各项内容的输入在main方法中进行

*

*

*

*

* 重点注意的地方

*

* 由于客户端无法知道服务器何时转发数据，所以客户端需要一直不停地监听消息，为了不影响其他的方法，如发送数据，这里用到多线程，即为接受数据单独建立一个线程，以防止影响其他方法的正常工作。
*
*/
public class ChatClient implements Runnable
{
    // 发送数据的服务器Net地址，在fixServerLink
    // 和sendMes方法中会用到
    private InetAddress sendAddress = null;

    private int port = 0;

    // 客户端
    private DatagramSocket client = null;

    // 发送的数据报
    private DatagramPacket sendDatas = null;

    // 用来测试是否能够连接成功或者用户名是否正确
    // 在testConnect和checkNickName中会用到.
    // 并穿插在sendMes方法中
    private boolean test = true;

    /**
     * 建立连接
     *
     * @param ip 服务器IP号
     * @param port 服务器Port
     */
    public void connectServer(String ip, int port)
    {
        // 先确定输入的IP与端口号是否符合规则
        this.fixServerLink(ip, port);

        try
        {
            client = new DatagramSocket();
        }
        catch (SocketException s)
        {
            System.out.println("The Connection of server is error.");
        }
    }

    /**
     * 确定IP与Port输入是否正确
     *
     * @param ip
     * @param port
     */
    private void fixServerLink(String ip, int port)
    {
        // 判断连接服务器的端口号
        // 如果输入命令为0，则为默认端口号9999
        // 否则端口号为新端口号
        if (port == 0)
            this.port = 9999;
        else
            this.port = port;
        // 判断连接服务器的IP地址
        // 如果输入命令为0，则为默认的本地IP地址
        // 否则为输入的IP地址
        try
        {
            if (ip.equalsIgnoreCase("0"))
                this.sendAddress = InetAddress.getLocalHost();
            else
                this.sendAddress = InetAddress.getByName(ip);
        }
        catch (UnknownHostException u)
        {
            System.out.println("Sorry, IP address you put is not currect!");
        }
    }

    /**
     * 断开连接
     */
    public void disconnectServer()
    {
        // 当客户端断开连接之前，客户端会向服务器端发送一个信息，
        // 以便告诉服务器该客户下线
        this.sendMes("-quit");
        if (client != null)
            client.close();

    }

    /**
     * 发送消息
     *
     * @param mes
     */
    public void sendMes(String mes)
    {
        byte[] buf = mes.getBytes();
        sendDatas = new DatagramPacket(buf, buf.length, sendAddress, port);
        // 当建立发送时，测试正常
        test = true;
        try
        {
            client.send(sendDatas);
        }
        catch (NullPointerException n)
        {
            // 如果无法得到要发送的消息，测试终止
            test = false;
            System.out.println("The nullity of the address of connection");
        }
        catch (IOException s)
        {
            // 如果无法发送消息至服务器，测试终止
            test = false;
            System.out.println("There is a problem to send message.");
        }
        finally
        {
        }
    }

    /**
     * 得到数据
     */
    public void getMes()
    {
        byte[] buf = new byte[1024];
        DatagramPacket getDatas = new DatagramPacket(buf, buf.length);
        String mes = null;
        try
        {
            while (true)
            {
                client.receive(getDatas);
                mes = new String(buf, 0, getDatas.getLength());
                // 如果服务器发送的消息中的头片段有-getList
                // 表明客户端获得在线用户列表，调用getList方法解析
                if (mes.indexOf("-getList") == 0)
                    this.getList(mes);
                else
                    System.out.println(mes);
            }
        }
        catch (IOException i)
        {
            System.out.println("Fail in receving message");
        }
    }

    /**
     * 得到一次数据
     *
     */
    public String getMesOnce()
    {
        byte[] buf = new byte[1024];
        DatagramPacket getDatas = new DatagramPacket(buf, buf.length);
        String mes = null;
        try
        {
            client.receive(getDatas);
            mes = new String(buf, 0, getDatas.getLength());
        }
        catch (Exception e)
        {
            System.out.println("!-Can not receive the message!");
        }
        finally
        {
        }
        return mes;
    }

    /**
     * 显示在线用户列表
     *
     * @param mes
     */
    private void getList(String mes)
    {
        String[] list = mes.split(",");
        System.out.println("在线用户：\n-------------");
        for (int i = 1; i < list.length; i++)
        {
            System.out.println("    * " + list[i]);
        }
        System.out.println("-------------");
    }

    /**
     * 测试连接
     *
     * @param ip
     * @param port
     * @return
     */
    public boolean testConnect(String ip, int port)
    {
        // 创建连接，测试连接是否正确
        this.connectServer(ip, port);
        // 如果连接正确，试图发送测试标识"-test"
        // 在发送数据过程中测试连接是否正确
        this.sendMes("-test");
        // 如果连接发送测试通过
        // 则开始测试是否能够正确
        if (test)
        {
            String mes = this.getMesOnce();
            // 如果服务器返回相应的标识，测试通过
            if (mes.startsWith("-test"))
            {
                test = true;
            }
        }

        if (client != null)
        {
            client.close();
        }
        return test;
    }

    /**
     * 判断用户名输入是否正确
     */
    private boolean checkNickName(String nickName)
    {
        test = true;
        String mes = null;
        // 判断昵称是否符合约定
        for (int i = 0; i < nickName.length(); i++)
        {
            char temp = nickName.charAt(i);
            // 如果不符合，则终止测试
            if (!Character.isLetterOrDigit(temp))
            {
                test = false;
                break;
            }
        }
        // 如果通过约定，则试图向服务器发送昵称，进行判断
        if (test)
        {
            this.sendMes("-nick " + nickName);
            mes = this.getMesOnce();
            // 如果服务器返回"-nick"标识
            // 说明测试昵称失败，终止测试
            if (mes.startsWith("-nick"))
            {
                test = false;
            }
        }

        System.out.println(mes);
        return test;
    }

    /**
     * 得到帮助列表
     *
     */
    public void helpList()
    {
        System.out.println("重要说明：如果已经成功连接，只要输入内容，所有在线用户都能看到您的发言。" + "\n" + "-help" + "         获取客户端相应操作的帮助" + "\n"
                + "-test" + "         测试与服务器的连接，如果已经服务器连接，请不要选用此项" + "\n" + "-getList" + "    得到在线用户的列表" + "\n"
                + "-to " + "\n" + "                    将消息发送到特定的在线用户处" + "\n" + "-quit"
                + "         断开连接，退出聊天室" + "\n");
    }

    /**
     * 线程部分
     */
    public void run()
    {
        getMes();
    }

    /**
     * 各项内容的操作器
     */
    public static void main(String[] args)
    {
        ChatClient consumer = new ChatClient();
        String getIp = null;
        int getPort = 0;
        System.out.println("欢迎登录Sunspot聊天室！");
        Scanner input = new Scanner(System.in);

        // 输入IP与Port
        boolean goahead = true;
        while (goahead)
        {
            System.out.println("1.请输入服务器IP地址，默认请输入数字0 ：");
            // 第一步：输入服务器的IP地址
            getIp = input.next();
            // 第二步：输入服务器的端口号
            System.out.println("2.请输入服务器端口号，默认请输入数字0 ：");
            try
            {
                getPort = input.nextInt();
            }
            catch (InputMismatchException i)
            {
                errorTip("!-The port style is not currect!");
            }
            catch (NoSuchElementException n)
            {
                errorTip("!-The port style is not currect!");
            }

            // 测试服务器
            System.out.println("!-正在测试连接服务器，请稍候...");
            if (consumer.testConnect(getIp, getPort))
            {
                System.out.println("!-连接成功！");
                goahead = false;
            }
            else
                System.out.println("!-连接失败，您输入的IP及端口号错误。");
        }

        // 连接服务器
        consumer.connectServer(getIp, getPort);

        // 输入昵称
        boolean goon = true;
        while (goon)
        {
            // 第三步：输入昵称
            System.out.println("3.请输入您登录后显示的昵称(只能输入中文、英文字母及数字)：");
            String nick = input.next();
            boolean judge = consumer.checkNickName(nick);
            // 判断昵称是否输入正确
            if (judge)
                goon = false;
            else
                System.out.println("!-您输入的用户名不符合条件，请重新输入！");
        }

        // 开始运行接收数据
        new Thread(consumer).start();
        // 聊天
        String mes = null;
        System.out.println("!-您成功进入聊天室！");

        while (!(mes = input.nextLine()).equalsIgnoreCase("-quit"))
        {
            // 如果输入"-test"命令，开始测试
            if (mes.trim().equalsIgnoreCase("-test"))
            {
                consumer.testConnect(getIp, getPort);
                // -getList：获得在线用户列表
            }
            else if (mes.trim().equalsIgnoreCase("-getList"))
            {
                consumer.sendMes(mes);
                // -nick 设置昵称
            }
            else if (mes.startsWith("-nick "))
            {
                System.out.println("!-You have named, Can not allowed to rename!");
                // -help 获得帮助列表
            }
            else if (mes.equalsIgnoreCase("-help"))
            {
                consumer.helpList();
                // 如果输入的是空字符，则不发送
            }
            else if (mes.equals(""))
            {
            }
            else
            {
                consumer.sendMes(mes);
            }
        }

        // 退出
        input.close();
        consumer.disconnectServer();

    }

    /**
     * 错误提示标记
     *
     * @param str
     */
    public static void errorTip(String str)
    {
        System.out.println("-----------------\n" + str + "\n-----------------");
    }
}

秋天的山谷 2013-12-09 22:04 发表评论

如何指定JAVA的运行参数？

秋天的山谷 — Sat, 14 Jul 2012 04:31:00 GMT

rem ss.bat

set APP_DIR=D:\tools\tomcat6.0\wtpwebapps\com.tianhe.jxc
set APP_LIB_PATH=%APP_DIR%\WEB-INF\lib
set APP_CLASS_PATH=%APP_DIR%\WEB-INF\classes

java -Djava.ext.dirs=%APP_LIB_PATH% -cp %APP_CLASS_PATH%;. com.tianhe.frm.http.server.SimpleHttpServer -port 8080 -charset gbk

rem sc.bat
set APP_DIR=D:\tools\tomcat6.0\wtpwebapps\com.tianhe.jxc
set APP_LIB_PATH=%APP_DIR%\WEB-INF\lib
set APP_CLASS_PATH=%APP_DIR%\WEB-INF\classes

java -Djava.ext.dirs=%APP_LIB_PATH% -classpath -cp %APP_CLASS_PATH%;. com.tianhe.frm.http.client.SimpleHttpClient -url http://www.blogjava.net/Images/adminlogo.gif -dir d:/wallpaper

秋天的山谷 2012-07-14 12:31 发表评论