Java网络编程实践（判断质数）

Java网络编程实践（判断质数）

该示例实现的功能是质数判断，程序实现的功能为客户端程序接收用户输入的数字，然后将用户输入的内容发送给服务器端，服务器端判断客户端发送的数字是否是质数，并将判断的结果反馈给客户端，客户端根据服务器端的反馈显示判断结果。

网络程序的功能都分为客户端程序和服务器端程序实现，下面先描述一下每个程序分别实现的功能：

1、 客户端程序功能：

a)  接收用户控制台输入
b)  判断输入内容是否合法
c)  按照协议格式生成发送数据
d)  发送数据
e)  接收服务器端反馈
f)  解析服务器端反馈信息，并输出

2、 服务器端程序功能：

a)  接收客户端发送数据
b)  按照协议格式解析数据
c)  判断数字是否是质数
d)  根据判断结果，生成协议数据
e)  将数据反馈给客户端

设计协议格式：

1、客户端发送“quit”字符串代表结束连接
2、反馈数据长度为1个字节。数字0代表是质数，1代表不是质数，2代表协议格式错误。

客户端程序：

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;

/*
 * 以TCP方式实现的质数判断客户端程序
 */
public class TCPPrimeClient {

    static BufferedReader br;
    static Socket socket;
    static InputStream is;
    static OutputStream os;
    final static String HOST="127.0.0.1";
    final static int PORT=10005;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        init();                            // 初始化
        while(true){
            System.out.println("请输入数字：");
            String input=readInput();          // 读取输入
            if(isQuit(input)){                 // 判断是否结束
                byte[] b="quit".getBytes();
                sent(b);
                break;                       // 结束程序
            }

            if(checkInput(input)){           // 校验合法
                // 发送数据
                sent(input.getBytes());

                // 接收数据
                byte[] data=receive();

                // 解析反馈数据
                parse(data);
            }else{
                System.out.println("输入不合法，请重新输入");
            }
        }
        close();                    // 关闭流和连接

    }

    private static void close() {

        try{
            br.close();
            is.close();
            os.close();
            socket.close();
        }catch(Exception e){
            e.printStackTrace();
        }

    }

    private static void parse(byte[] data) {

        if(data==null){
            System.out.println("服务器反馈数据不正确！");
            return;
        }
        byte value=data[0];
        switch (value) {
        case 0:
            System.out.println("质数");
            break;
        case 1:
            System.out.println("不是质数");
            break;
        case 2:
            System.out.println("协议格式错误");
            break;
        }
    }

    private static byte[] receive() {
        byte[] b=new byte[1024];
        try{
            int n=is.read(b);
            byte[] data=new byte[n];
            System.arraycopy(b, 0, data, 0, n);
            return data;
        }catch(Exception e){
            return null ;
        }
    }

    private static boolean checkInput(String input) {

        if(input==null){
            return false;
        }
        try{
            int n=Integer.parseInt(input);
            if(n>=2){
                return true;
            }else {
                return false;
            }
        }catch(Exception e){
            return false;
        }
    }

    private static void sent(byte[] data) {

        try{
            os.write(data);
        }catch(Exception e){
            e.printStackTrace();
        }

    }

    private static boolean isQuit(String input) {
        if(input==null){
            return false;
        }else {
            if("quit".equalsIgnoreCase(input)){
                return true;
            }else {
                return false;
            }
        }
    }

    private static String readInput() {
        try {
            return br.readLine();
        } catch (Exception e) {
            return null;
        }
    }

    private static void init() {
        try {
            br=new BufferedReader(new InputStreamReader(System.in));
            socket=new Socket(HOST, PORT);
            is=socket.getInputStream();
            os=socket.getOutputStream();
        } catch (Exception e) {

        }   
    }

}

服务器端程序：

import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/*
 * 以TCP方式实现的质数判别服务器端
 */
public class TCPPrimeServer {


    public static void main(String[] args) {
        final int PORT=10005;
        ServerSocket ss=null;
        try{
            ss=new ServerSocket(PORT);
            System.out.println("服务器端已启动：");
            while(true){
                Socket s=ss.accept();
                (new PrimeLogicThread(s)).start();
            }           
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                ss.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }       
    }
}

class PrimeLogicThread extends Thread{
    Socket socket;
    InputStream is;
    OutputStream os;

    public PrimeLogicThread(Socket socket){
        this.socket=socket;
        init();
//      start();
    }

    private void init() {
        try{
            is=socket.getInputStream();
            os=socket.getOutputStream();
        }catch(Exception e){
            e.printStackTrace();
        }

    }
    public void run(){
        while(true){
            // 接收客户端请求
            byte[] data=receive();
            // 判断是否退出
            if(isQuit(data)){
                break;
            }
            // 逻辑处理
            byte[] b=Logic(data);
            // 反馈数据
            send(b);
        }
        close();
    }

    private void close() {

        try{
            is.close();
            os.close();
            socket.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    private void send(byte[] data) {

        try {
            os.write(data);
        } catch (Exception e) {
        }
    }

    private byte[] Logic(byte[] data) {

        // 反馈数组
        byte[] b=new byte[1];
        // 校验参数
        if(data==null){
            b[0]=2;
            return b;
        }
        try{
            // 转换为数字
            String s=new String(data);
            int n=Integer.parseInt(s);
            // 判断是否是质数
            if(n>=2){
                boolean flag=isPrime(n);
                if(flag){
                    b[0]=0;
                }else {
                    b[0]=1;
                }
            }else {
                b[0]=2;
                System.out.println(n);
            }
        }catch(Exception e){
            e.printStackTrace();
            b[0]=2;
        }
        return b;
    }

    private boolean isPrime(int n) {
        boolean b=true;
        for( int i=2;i<=Math.sqrt(n);i++){
            if(n%i==0){
                b=false;
                break;
            }
        }
        return b;
    }

    private boolean isQuit(byte[] data) {

        if(data==null){
            return false;
        }else {
            String s=new String(data);
            if(s.equalsIgnoreCase("quit")){
                return true;
            }else {
                return false;
            }
        }
    }

    private byte[] receive() {

        byte[] b=new byte[1024];
        try{
            int n=is.read(b);
            byte[] data=new byte[n];
            System.arraycopy(b, 0, data, 0, n);
            return data;
        }catch(Exception e){
            return null;
        }
    }

}