Ankündigung

Einklappen
Keine Ankündigung bisher.

PHP Server und Java Applet als Client

Einklappen

Unconfigured Ad Widget

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • papalangi_44
    hat ein Thema erstellt PHP Server und Java Applet als Client.

    PHP Server und Java Applet als Client

    Hallo,

    ich habe ein Java-Applet, das Textenachrichten und kleine Sounddateien
    erzeugt, diese möchte ich an den Webserver schicken , der sie wiederum
    sofort an aktuell registrierte Clients ( <= 12) verteilen soll.

    Da ich nur einen "normalen" Webspace mit PHP habe kann ich da natürlich nicht einen Javaserver programmieren und starten der einen Port abfragt.

    Die Textdateien und die Soundfiles (Sprachaufzeichnung) sind nicht umfangreich (evtl jeweils ca 1 MB).

    Wie könnte ich so etwas lösen. Mir fehlt da im Moment etwas die Idee.

    Hochladen per AJAX oder upload? Clientseitig kann ich zwar ein Socket aufmachen aber auf der Serverseite?

    Die Clients alle Sekunde per AJAX nachfragen lassen, ob etwas vorliegt
    ( wäre sicher übertriebn, da evtl nur alle 10 Minuten etwas kommt, muß aber sofort weitergeleitet werden).

    Hat jemand evtl einen Denkanstoß für mich?

    Danke papalangi_44

  • Hans_James
    antwortet
    ermal danke, habe es zum laufen bekommen. Eine frage habe ich noch, kann man auf ein xxamp server ein Socket server und gleichzeitig mehere client laufen lassen???

    Einen Kommentar schreiben:


  • notyyy
    antwortet
    google mal nach jsocket. ist sehr einfach ...

    Einen Kommentar schreiben:


  • Hans_James
    antwortet
    Hallo,

    erstmal danke, genau das habe ich gesucht. Kannst du mir auch ein Bespiel für den Client geben ???

    Gruß

    Hans

    Einen Kommentar schreiben:


  • Deltachaos
    antwortet
    Problem ist die Browserunterstützung.


    Jedoch kann man die Socket Funktonalität von Flash nach Javascript brigen.
    Dann hat man aber auch nur einen Client.

    An diesem Punkt kann ich ja mal meine kleine Socket Classe anbringen:

    redServerSocket.class.php
    PHP-Code:
    <?php

        
    class redServerClient
        
    {
        
            private 
    $redServerSocket;
            private 
    $commandcache '';
            public 
    $get_history = array();
            public 
    $send_history = array();
            public 
    $handle;
            public 
    $id;
            public 
    $lastused;
            public 
    $connected;
            public 
    $data = array();
            
            public function 
    __construct($redServerSocket$handle)
            {
                
    $this->redServerSocket $redServerSocket;
                
    $this->handle $handle;
                
    $this->id $redServerSocket->getIdFromHandle($handle);
                
                
    $this->connected time();
                
    $this->lastused time();
                
            }
            
            public function 
    addCache($string)
            {
                
    $this->lastused time();
                
    $this->commandcache .= $string;
            }
            
            public function 
    getCache()
            {
                return 
    $this->commandcache;
            }
            
            public function 
    clearCache()
            {
                if(
    is_array($this->get_history))
                    
    $this->get_history[] = substr($this->commandcache0, (strlen($this->redServerSocket->end) * -1));
                
    $this->commandcache '';
            }
            
            public function 
    disconnect($code 3000)
            {
                @
    socket_shutdown($this->handle);
                @
    socket_close($this->handle);
                
    $this->redServerSocket->callClientDisconnect($this->id$code);
                
    $this->redServerSocket->unsetClient($this->id);
                return 
    TRUE;
            }
            
            public function 
    write($data)
            {
                
    $this->redServerSocket->callDataSend($this->id$data);
                if(
    is_array($this->send_history))
                    
    $this->send_history[] = $data;
                return 
    socket_write($this->handle$data);
            }
            
            public function 
    send($data)
            {
                return 
    $this->write($data);
            }
            
            public function 
    lastErrorCode()
            {
                return 
    socket_last_error($this->handle);
            }
            
            public function 
    lastErrorString()
            {
                return 
    socket_strerror($this->lastErrorCode());
            }
            
        }
        
        abstract class 
    redServerSocket
        
    {
        
        
            private 
    $code = array(
                
    'from_api'            => 3000
                
    'timeout'            => 3001
                
    'connection_closed'        => 3002,
                
    'connection_refused'        => 3003
            
    );
            private 
    $mainsocket NULL;
            private 
    $clients = array();
            
            protected 
    $host 0;
            protected 
    $port 0;
            protected 
    $timeout NULL;
            
            public 
    $end NULL;
            
            protected function 
    onDataRecieve($clientObj$data)
            {
                return 
    TRUE;
            }

            protected function 
    onDataSend($clientObj$data)
            {
                return 
    TRUE;
            }        
            
            protected function 
    onClientConnect($clientObj)
            {
                return 
    TRUE;
            }
            
            protected function 
    onClientDisconnect($clientObj$code)
            {
                return 
    TRUE;
            }
            
            protected function 
    onSocketReady($host$port)
            {
            }
            
            protected function 
    onSocketError($error$client false)
            {
            }
            
            public function 
    __construct($port NULL$host NULL)
            {
                if(
    $this->end === NULL)
                    
    $this->end chr(4);
                if(
    false == ($this->mainsocket = @socket_create(AF_INETSOCK_STREAMSOL_TCP)))
                {
                    
    $this->onSocketError($this->lastErrorCode());
                }
                else
                {
                    @
    socket_set_option($this->mainsocketSOL_SOCKETSO_REUSEADDR1);
                    if(
    $port !== NULL)
                        
    $this->port $port;
                    if(
    $host !== NULL)
                        
    $this->host $host;
                    if(
    false == ($ret =@socket_bind($this->mainsocket$this->host$this->port)))
                    {
                        
    $this->onSocketError($this->lastErrorCode());
                    }
                    else
                    {
                        
    $ret socket_listen($this->mainsocket);
                        
    $this->onSocketReady($this->host$this->port);
                    }
                }
            }
            
            public function 
    callDataSend($id$data)
            {
                if(!
    is_object($id))
                    
    $id $this->clients[$id];
                
    $this->onDataSend($id$data);
            }
            
            public function 
    callClientDisconnect($id$code)
            {
                if(!
    is_object($id))
                    
    $id $this->clients[$id];
                
    $this->onClientDisconnect($id$code);
            }
            
            public function 
    getIdFromHandle($handle)
            {
                
    $str = (string)$handle;
                
    $str substr($str13);
                return (int)
    $str;
            }
            
            public function 
    getClients()
            {
                return 
    $this->clients;
            }
            
            public function 
    unsetClient($client)
            {
                unset(
    $this->clients[$client]);
            }
            
            public function 
    clientCheck()
            {
                
    $localClients = array();
                foreach(
    $this->clients as $num => $clientObj)
                {
                
                    if(
    $this->timeout !== NULL && $clientObj->lastused time() - $this->timeout && $this->onClientDisconnect($clientObj$this->code['timeout']))
                        
    $clientObj->disconnect($this->code['timeout']);
                    else
                        
    $localClients[$clientObj->id] = $clientObj->handle;
                }
                
                
    $set_r array_merge((array)$this->mainsocket$localClients);
                
    $set_w NULL;
                
    $set_e $localClients;
                
                
    //    Check for new Data.
                //    If the mainsocket in the array $set_r
                //    then is there a new Client!
                //    If not then is there new Data from the Socket in the Array
                
                
    if( ( $ret =@socket_select($set_r$set_w $set_e 1) ) > )
                {
                    foreach(
    $set_r as $data)
                    {
                        if(
    $data == $this->mainsocket//Is it the mainsocket there are new clients in it!
                        
    {
                            
    $newclient = @socket_accept($this->mainsocket);
                            if(
    $newclient)
                            {
                                
    $id $this->getIdFromHandle($newclient);
                                
    $clientObj = new redServerClient($this$newclient);
                                
    $this->clients[$id] = $clientObj;
                                if(
    $this->onClientConnect($clientObj) === FALSE)
                                    
    $clientObj->disconnect($this->code['connection_refused']);
                            }
                            else
                                
    $this->onSocketError($this->lastErrorCode());
                        }
                        else
                        {
                            
    $data_read socket_read($data1024);
                            
    $id $this->getIdFromHandle($data);
                            if(
    $data_read === false)
                            {
                                
    $ret $this->onSocketError($this->lastErrorCode(), $this->clients[$id]);
                                if(!
    $ret)
                                    
    $this->clients[$id]->disconnect($this->code['from_api']);
                            }
                            else
                            {
                                if(
    strlen($data_read) > && isset($this->clients[$id]))
                                {
                                    
    $this->clients[$id]->lastaction time();
                                    
    $this->clients[$id]->addCache($data_read);
                                    
    $endstr_len strlen($this->end);
                                    if(
    substr($this->clients[$id]->getCache(), ($endstr_len * -1), $endstr_len) === $this->end)
                                    {
                                        
    $this->onDataRecieve($this->clients[$id], substr($this->clients[$id]->getCache(), 0, ($endstr_len * -1)));
                                        
    $this->clients[$id]->clearCache();
                                    }
                                }
                                else
                                    
    $this->clients[$id]->disconnect($this->code['connection_closed']);
                            }
                        }
                    }
                    foreach(
    $set_e as $handle//Oh, these Clients have an ugly Error. I kick them from my List!
                    
    {
                        
    $id $this->getIdFromHandle($handle);
                        
    $this->clients[$id]->disconnect($this->code['connection_closed']);
                    }
                }
            }
            
            public function 
    lastErrorCode()
            {
                return 
    socket_last_error($this->mainsocket);
            }
            
            public function 
    lastErrorString()
            {
                return 
    socket_strerror($this->lastErrorCode());
            }
        }
        

        
    ?>
    redServerSocket.example.class.php
    PHP-Code:
    <?php
        $port 
    1338;
               
        include(
    'redServerSocket.class.php');
        
        
    /*
            Metoden der Clients Objekte:
            
            public $get_history = array();
            //echo "Dein letztes Komando war: $get_history[0]"
            public $send_history = array();
            //echo "Ich habe dir zuletzt gesendet: $send_history[0]"
            public $handle; //Client Socket Handle. Siehe: http://php.net/manual/de/function.socket-accept.php
            public $id; //Client ID
            public $lastused; //Unix Timestamp der letzten Client Reaktion.
            public $connected; //Unix Timestamp des Verbindungszeitpunktes
            public $data = array(); //Ein Array zum Speichern von Session Variablen
            
            
            public function addCache($string) //Fügt $string zum commandcache hinzu
            public function getCache() //Gibt den aktuellen commandcache zurück
            public function clearCache() //Löscht den aktuellen commandcache
            
            public function disconnect($code = 3000) //Schliest Verbindung mit Fehlercode
            public function write($data) //Sendet Daten an Client. Rückgabe von function: http://de3.php.net/manual/en/function.socket-write.php
            public function send($data) //Alias für write($data)
            
            public function lastErrorCode() //Alias für: socket_last_error($this->handle)
            public function lastErrorString() //Alias für: socket_strerror(socket_last_error($this->handle))
        
        */
        
        
    class Server extends redServerSocket
        
    {
            
            
    //$this->end = '\n' //Begrenzer der einzelnen Komandos. Standart ist: chr(4) (EOT)
            //$this->timeout = 3600; //Zeit in der Client Nachrichten senden muss bevor er aus der Liste geworfen wird.
                         //NULL deaktiviert das Timeout. Standart ist: NULL
            
            //public function lastErrorCode() //Alias für: socket_last_error($this->mainsocket)
            //public function lastErrorString() //Alias für: socket_strerror(socket_last_error($this->mainsocket))
            //public function getClients() //return $this->clients.
            
            
    protected function onDataRecieve($clientObj$data)
            {
                if(
    $data == 'Hallo')
                    
    $clientObj->data['GREET'] = true;
                echo 
    "onDataRecieve [" $clientObj->id "]: " $data "\n";
                
    $clients $this->getClients();
                foreach(
    $clients as $id => $clientObj)
                    
    $clientObj->write('[' $clientObj->id ']: ' $data);
                
            }

            protected function 
    onDataSend($clientObj$data)
            {
                echo 
    "onDataSend [" $clientObj->id "]: " $data "\n";
            }        
            
            protected function 
    onClientConnect($clientObj)
            {
                echo 
    "onClientConnect [" $clientObj->id "]\n";
                
    //$clientObj->get_history = NULL; //Deaktiviert die get_history
                //$clientObj->send_history = NULL; //Deaktiviert die send_history
                //return FALSE; //Wenn return false wird der client abgelehnt
            
    }
            
            protected function 
    onClientDisconnect($clientObj)
            {
                echo 
    "onClientDisconnect [" $clientObj->id "]\n";
            }
            
            protected function 
    onSocketReady($host$port)
            {
                echo 
    "Socket ready!!\n";
            }
            
            protected function 
    onSocketError($errorcode$clientObj false)
            {
                if(
    $clientObj !== false)
                    echo 
    "Error [" $clientObj->id "]" $this->lastErrorString(); //Fehler von Client
                
    else
                    echo 
    "Error" $this->lastErrorString(); //Fehler von Mainsocket
                //return true; //läst den Client, sollte es ein Fehler sein bei dem er normalerweise disconnectet wird, in der Liste;
            
    }
        
        }
        
        echo    
    "Server startet on Port: ".$port."\n" .
            
    "On Liux and Windows Systems you can connect to the server with:\n" .
            
    "telnet <IP> ".$port."\n" .
            
    "You can disconnect by close the Terminal\n" .
            
    "You can shutdown the Server by press CTRL + C in the Server Terminal\n" .
            
    "GL & HF!\n" .
            
    "#######################################################################\n";
        
        
    $host NULL;
        
    $socket = new Server($port$host); //Port und Host. Wenn Host === NULL dann hört der Server auf alle IP Adressen des Hosts
        
        
    while(true)
        {
            
    $socket->clientCheck(); //Prüft auf neue Nachrichten. 
        
    }

    ?>

    Einen Kommentar schreiben:


  • BlackScorp
    antwortet
    eventuell Websockets, habe es aber nie verwendet aber anscheinend ist es eine alternative zu Server-Push

    WebSockets – Wikipedia

    Einen Kommentar schreiben:


  • papalangi_44
    antwortet
    Auf so eine Lösung mit AJAX-Requests wird es wohl hinauslaufen.

    Jetzt aber erst mal allen schöne Osterfeiertage.

    Einen Kommentar schreiben:


  • xm22
    antwortet
    Du könntest immer einen Ajax-Request an den Server absenden, der dann 10 - 20 sec. läuft und währenddessen abfragt, ob etwas neues kommt.

    Einen Kommentar schreiben:


  • Tiberius
    antwortet
    Du könntest mit PHP einen SocketServer aufsetzen

    // Ups, übersehen das es lediglich ein Webspace ist

    Einen Kommentar schreiben:


  • nikosch
    antwortet
    Ausser pull request wird Dir wohl nicht viel übrig bleiben.

    Einen Kommentar schreiben:

Lädt...
X