CSI Consultores

 
  • Aumentar fuente
  • Fuente predeterminada
  • Disminuir fuente
Home Seccion de blogs admin Corriendo un programa Java como demonio en Linux
21.08.2009 10:02:48
admin
Corriendo un programa Java como demonio en Linux

 

Por: Guido J. Granobles.

En ocasiones necesitamos que un programa Java actue como un servicio que se inicia bien sea de manera manual o cada vez que nuestro OS arranca. Estos servicios se ejecutan en background y estan constantemente a la espera de eventos o ejecutando tareas especificas en intervalos de periodos definidos, a estos servicios se les conoce tambien como demonios o daemons en la lengua inglesa. A diferencia de una aplicacion normal los demonios son controlados por el OS en su arranque y en su finalizacion, permitiendo completar tareas de liberacion de recusros en cada finalizacion del servicio o cuando la maquina ha recibido una orden de apagado.
 

Para crear una aplicacion que se ejecute como un demonio debemos implementar la interface Daemon usando el paquete que nos provee Apache, la cual pueden encontrar en http://commons.apache.org/daemon.com La interface contiene los siguientes metodos que debemos implementar:

 


public interface Daemon {
    
     	  public void init(DaemonContext context) throws Exception;
    
    	  public void start() throws Exception;

    	  public void stop()  throws Exception;

     	  public void destroy();
}


El metodo init se ejecuta una sola vez cuando se instancia la clase que implementa la interface Daemon, en este metodo se pueden inicializar atributos de instancia que necesitemos, inicializar sockets mas no iniciar hilos como los que escuchan puertos y ningun otro hilo.

El metodo start es el punto de entrada para el demonio como lo seria el metodo main para una aplicacion convecional, es aqui en este metodo donde podemos inicializar los hilos que van a llevar a cabo las tareas para las cuales se ha destinado el demonio.

El metodo Stop es llamado cuando sea necesario detener el demonio aqui se llevan a cabo operaciones tales como desconexiones de bases de datos mas no se liberan los recursos, esto se debeb conservar ya que al demonio se le podria requerir su reinicio.

El metodo Destroy se ejecuta una vez se desea el demonio termine todas sus tareas y libere todos los recursos que esta utilizando, es aqui donde se puden liberar cualquier recurso que usemos como sockets, objetos de base de datos etc.

Podriamos por ejemplo tener dos hilos, uno de los cuales funciona como un servidor que escucha constatemente por el puerto 6000 a la espera de un paquete.

El otro hilo podria tratarse de una aplicacion cliente que monitorea una tabla en una base de datos, cada vez que en cuentra un nuevo registro, lo lee, lo empaqueta y lo envia a un servidor remoto. Estos dos hilos deberian ser iniciados en el metodo start o dentro de algun otro metodo que sea llamado desde start. Veamos un ejemplo sencillo:

Primero definamos una clase servidor.

public class Servidor {

         	  private static Servidor ctrlComm;

         	  public static int PTO_SERVIDOR = 6000;

         	  boolean activeServer = true;

        	  Vector vDemonios = new Vector();

        	  private Servidor() { }

       	          public static Servidor getInstance() {
            	        if (ctrlComm == null) {         
                 	      ctrlComm = new Servidor();
                        }
           	       return ctrlComm;
                  }

       	         public void iniciarServicio() throws Exception {      
          	            new HiloServidor().start();
                  }

      	         public void pararServicio() {    

         	         activeServer = false;

        	        for (Iterator iter = vDemonios.iterator(); iter.hasNext();) {
             	                  HiloProcessInfo item = (HiloProcessInfo ) iter.next();
              	                 item.continuar = false;
                        }

                 } 

    	        private void servidorTCP() throws Exception {
                           ServerSocket serverSocket = new ServerSocket(PTO_SERVIDOR);
   
   	                    /*HiloProcessInfo es una clase que extiende Thread y lleva a cabo las tareas necesaria con el paquete recibid*/

    	                    HiloProcessInfo procesar = null; 

            	            while (activeServer) {
               	            try {

                         	         Socket socket = serverSocket.accept();

          	                         procesar= new HiloProcessInfo(socket); 

        	                  }  catch (Exception ex) {
                             	             ex.printStackTrace();
                             	             throw new Exception("Error Creando instancia de servidor");
                                  }             

                                 procesar.start(); 
          	                  vDemonios.add(procesar);

                   }
}

Ahora el Hilo que inicia el servidor

  	  private class HiloServidor extends Thread {
          	  int tipo = 0;

          	  public HiloServidor() {}         

                  public void run() {
             	          try {               
                  	        servidorTCP();                             
          	          } catch (Exception ex) {
                    	        ex.printStackTrace();
                   	        pararServicio();
               	          }
                  }
        }

ahora el hilo cliente

 	  public class Cliente extends Thread {

         	  private boolean servicioActivo = true;

         	  public Cliente() {}     

         	  public void pararServicio() {
                 	  this.servicioActivo = false;
                  }

          	  public void procesar() throws Exception {

              	           /*Aqui se coloca todo el codigo que se encarga de chequear la disponibilidad de registros en la base
            	            de datos, armar el paquete de datos, conectarse al servidor segun una IP y puerto especificado
            	            y por ultimo enviar el paquete y esperar la respuesta*/

                  }

     

      	          public void run() {       
          

             	           while (servicioActivo) {

                	              try {
              
                    	                     procesar();

               	                       } catch (Exception e) {
                   	                        try {
                                         	            /*cerrar conexion y sockets*/
                   	                              } catch (Exception e2) {}                       
             	                                      
                                       }           

                           }

         	  }

    }

ahora la clase principal que implementa Daemon

 	  public class MainDaemons implements Daemon {

         	  private static Servidor servComm;
         	  private static DaemonCliente cliComm;

             	  public static void iniciarServicio() {

         	             try {
            	                       servComm = Servidor.getInstance();
             	                       servComm.iniciarServicio();
             	                       cliComm = new Cliente();
            	                       cliComm.start();
        	             } catch (Exception ex) {
                   	              System.out.println("Servicio abortado: " + ex.getMessage());
                   	              System.exit(0);
                             }

         	             public static void finalizarServicio() {
            	                           if (servComm != null) {
                   	                            servComm.pararServicio();
                 	                            servComm = null;
                    	                           System.out.println("Servicio detenido " + new Date());
             	                            }
                             }

       	                    public void init(DaemonContext context) throws Exception {  }

                            public void start() throws Exception {
                                        iniciarServicio();
                            }

                   	    public void stop() throws Exception {
                                         finalizarServicio();
     	                     }

         
                       	     public void destroy() { }

    	  }

    }

Bien eso es todo. Para iniciar el demonio utilizamos el jsvc pero la explicacion de su uso queda para una posterior entrada en el blog. Aunque faltan mas controles y otras cositas en el ejemplo, ustedes ya pueden figurarse como se implementa y se usa la interfaz Daemon. Espero que esta informacion les sea util.

  interfaz Daemon | hilos | demonios java | Daemon
 

aidemar
23.08.2009 02:45:19

Esta pagina me parece muy interesante, me gustaria saber como se corre el demonio desde la linea de comandos utilizando el JSVC
 
 
Comentario
Inicio de sesión:

E-mail:




Menu principal

Encuentranos en FaceBook

Blog

« <July - 2010> »
SunMonTueWedThu FriSat
    123
45678910
11121314151617
18192021222324
25262728293031
Today

Enlazes de interes