Jump to content

Aplicação Server/Client em Windows/Linux


s4l4s

Recommended Posts

Boas pessoal. Vim aqui tentar resolver um problema para o qual ainda não encontrei solução e espero que voces me possam ajudar. Queria fazer um pequeno programita no qual eu tenho um servidor e um cliente na qual o cliente envia um pedido (comando) a ser executado no servidor. Ok, eu sei que é simples. Isto funciona muito bem quando o servidor se encontra numa maquina com SO windows e o cliente em windows ou linux. Quando o servidor se encontra numa maquina com SO Linux entao ai' e' que se da' o problema. Da-me um nullpointer exception que me está a partir a cabeça  :wallbash: Bom, chega de palavreado, aqui vai o codigo:

Cliente

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Client extends Message {

    /**
     *Construtor da class Client 
     */
    public Client() {
        clientException = null;
    }

    /**
     * Metodo responsável pela conexão do user ao servidor
     * @param host ip onde se vai ligar
     * @param port porta onde se vai ligar
     * @return caso não consiga ligar, retorna a excepção
     */
    public String connect(String host, int port) {
        try {

            //ligação ao socket do servidor localhost e porta 10000

            socket = new Socket(host, port);

            //Abertura da stream de entrada

            in = new Scanner(socket.getInputStream());

            //Abertura da stream de saida

            out = new PrintStream(socket.getOutputStream());
        } catch (Exception ex) {
            clientException = "Impossivel ligar => Servidor offline? || " + ex.toString() + "\n";
//            JOptionPane.showMessageDialog(null, clientException);
        }
        return clientException;
    }

    /**
     * Metodo responsavel pelo fecho da ligação do user com o servidor
     * @return caso não consiga disconectar, retorna a excepção
     */
    public String disconnect() {
        if (socket == null) {
            clientException = "Nao existe nenhuma ligaçao.\n";
//            JOptionPane.showMessageDialog(null, clientException);
        }
        try {
            socket.close();
            in.close();
            out.close();
        } catch (Exception ex) {
            clientException = "Impossivel terminar a sessao => Existe sessao? || " + ex.toString() + "1n";
//            JOptionPane.showMessageDialog(null, clientException);
            System.out.println("Impossivel terminar a sessao => " + ex.toString());
        }
        return clientException;
    }

    /**
     * Metodo responsavel pelo envio do comando "ping" ao servidor
     * @param host ip do servidor a ser "pingado"
     * @param port porta do servidor a ser "pingado"
     * @return resposta do server
     */
    public String ping(String host, String port) throws IOException {
        connect(host, Integer.parseInt(port));
        send("ping");
        String msg = receive();
        disconnect();
        return msg;
    }

    public String executeCommand(String cmd) throws IOException {
        String[] str = cmd.split(" ");

        if (str[0].equalsIgnoreCase("ping")) {
            return ping(str[1], str[2]);
        } else {
            return "Unknown command\n";
        }
    }

    public static void main(String[] args) throws IOException {
        Client c = new Client();
        System.out.println(c.executeCommand("ping 192.168.10.140 10000"));
    }
}

Servidor


import java.io.IOException;
import java.io.PrintStream;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.UnknownHostException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Server extends Message {

    ServerSocket server;

    public Server() {
    }

    public void startServer(int Port) {
        try {
            String tmp1 = Inet4Address.getLocalHost().toString();
            String[] tmp = tmp1.split("/");
            String ip = "";
            for (String s1 : tmp) {
                ip = s1;
            }
            server = new ServerSocket(Port, 0, InetAddress.getByName(ip));
            System.out.println("Device is ready");
        } catch (Exception ex) {
            System.out.println("Device isnt ready => " + ex.toString());
        }
    }

    public void listen() {
        try {
            while (true) {
                socket = server.accept();
                connect();
                executeCommand(receive());
            }
        } catch (Exception ex) {
            Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void connect() {
        try {
            in = new Scanner(socket.getInputStream());
            out = new PrintStream(socket.getOutputStream());
        } catch (Exception ex) {
            Logger.getLogger(Message.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void ping() {
        try {
            in = new Scanner(socket.getInputStream());
            out = new PrintStream(socket.getOutputStream());
            Inet4Address ip = (Inet4Address) Inet4Address.getLocalHost();
            String msg = "Device is online. IP: " + ip.getHostAddress() + "\n";
            out.println(msg);
        } catch (Exception ex) {
            Logger.getLogger(Message.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * 
     * @return mensagem a dizer que o server se encontra online
     * @throws java.net.UnknownHostException
     */
//    public String ping() throws UnknownHostException, IOException {
//        Inet4Address ip = (Inet4Address) Inet4Address.getLocalHost();
////        String msg = "Device " + ip.getHostName() + " is online. IP: " + ip.getHostAddress() + "\n";
//        String msg = "Device is online. IP: " + ip.getHostAddress() + "\n";
////        Process p1 = Runtime.getRuntime().exec("ssh wireless@localhost ls -l");
////        BufferedReader stdInput = new BufferedReader(new InputStreamReader(p1.getInputStream()));
////        String msg = stdInput.readLine();
//        send(msg);
//        return msg;
//    }

    /**
     * Metodo responsavel pela execução dos comandos
     * @param command comando a ser executado pelo server
     * @throws java.net.UnknownHostException caso o host seja inválido
     */
    public void executeCommand(String command) throws UnknownHostException{
        String[] str = command.split(" ");
        if (str[0].equalsIgnoreCase("ping")) {
            ping();
        } else {
            System.out.println("Unknown command");
        }
    }

    public static void main(String[] args) {
        Server s = new Server();
        s.startServer(10000);
        s.listen();
    }
}

Message - Responsavel pela envio/recepção dos comandos


import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Message {
    
    Socket socket;
    public PrintStream out;
    public Scanner in;
    
    public boolean flag;
    
    public String clientException;
    public String serverException;

    /**
     * Metodo responsavel pelo envio dos comandos
     * @param msg mensagem a ser enviada
     */
    
    public void send(String msg) {
        out.println(msg);
    }
    
/**
* Metodo responsavel pela recepção dos comandos
* @return proxima linha
*/
    
    public String receive() {
        flag = true;
        return in.nextLine();
    }
}

Bom, fico à espera de respostas. Obrigado desde ja'  

EDIT: Adicionado código GeShi

Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.