En esta entrada abordaremos un tema bastante interesante: cómo correr un programa en Java como servicio en Windows o demonio en UNIX/Linux. Puesto que el API de Java no proporciona nada para estos casos, utiliza

remos una librería llamada Java Service Wrapper. Dicha librería nos ofrece una serie de scripts y binarios preparados para diferentes sistemas operativos y arquitecturas, que nos permitirán correr nuestros programas como un servicio; además ofrece diferentes versiones: Profesional, Estándar y Comunity. En este caso usaremos la versión Comunity que es libre y gratuita.

La mejor manera de aprender a usar dicha librería es con un pequeño laboratorio, así que he preparado uno en donde explico la integración más simple que existe con Java Service Wrapper (existen 4 métodos; unos más avanzados que otros). La integración sencilla que he escogido nos permitirá ejecutar como servicio una aplicación que ya esté creada (probablemente ya empaquetada en un .jar) y a la que no podemos o es difícil hacerle modificaciones. Esta es la manera más sencilla de hacerlo, sin embargo tiene una desventaja: al detener el servicio se envía directamente un System.exit() a la JVM por lo que la aplicación no se cerrará limpiamente.

Si quieres integrar tu aplicación de una manera más segura y estás en la capacidad de prepararla para ello, podrías intentar la integración avanzada en la que utilizas el API de Java Service Wrapper para implementar métodos de inicio, pausa y detención del servicio [Para este caso utilizaremos una aplicación de ejemplo que recibe un archivo como parámetro y escribe en él información sobre la memoria del sistema, cada 60 segundos. He escogido este ejemplo porque posee varios aspectos interesantes: requiere de librerías externas (tanto JARs como librerías nativas [.so, dll, etc.]) y recibe parámetros.

Puedes descargar la aplicación de ejemplo de haciendo clic aquí. Si la ejecutáramos de manera convencional veríamos algo de este tipo:

Como puedes ver se trata de una aplicación de consola común y corriente. La aplicación consta básicamente de:

• El ejecutable servicio.jar ubicado en el directorio bin/
• La librería sigar.jar en el directorio lib/
• Las librerías específicas de cada arquitectura de sigar en lib/

Pasos para la integración

Lo primero es descargar el paquete de Java Service Wrapper y descomprimirlo. Supondremos que el directorio donde se encuentra Java Service Wrapper es $RUTA_JSW y que el directorio de la aplicación que  vamos a convertir en servicio es $RUTA_APP.

1. Copiamos los siguentes archivos al directorio bin de nuestra aplicación de ejemplo…

UNIX/Linux

El archivo $RUTA_JSW/bin/wrapper podría no existir; por lo tanto lo que debes copiar es el archivo wrapper-xxx específico para tu plataforma. Por ejemplo, en este caso estoy usando Gentoo Linux de 64bits por lo tanto copiaré el archivo $RUTA_JSW/bin/wrapper-linux-x86-64.

Windows

2. Renombramos algunos archivos…

UNIX/Linux…

Ahora debes renombrar el script sh.script.in con el nombre de la aplicación con la que haremos la integración y darle privilegios de ejecución. En este casó se llama simplemente “servicio”:

Windows

Ahora debes renombrar los archivos .bat  para que concuerden con el nombre de la aplicación con la que haremos la integración. En este casó se llama simplemente “servicio” (lo puedes hacer usando el explorador si no te gusta usar la consola, pero a mi me daría pena):

3. editar archivo de configuración

Editamos el archivo wrapper.conf y lo dejamos en el directorio $RUTA_APP/conf/. El archivo para este ejemplo tendrá el siguiente contenido (importante! lee la explicación si usas Windows):

# Comando de Java
wrapper.java.command=java
# Clase que ejecutara el Wrapper
wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp
# Librerias necesarias para ejecutar el programa
wrapper.java.classpath.1=../lib/wrapper.jar
wrapper.java.classpath.2=servicio.jar
# Java Library Path (ubicacion de las librerias wrapper.dll o wrapper.so)
wrapper.java.library.path.1=../lib
# Java Bits.  On applicable platforms, tells the JVM to run in 32 or 64-bit mode.
wrapper.java.additional.auto_bits=TRUE
# Parametros del programa
wrapper.app.parameter.1=net.casidiablo.servicio.Servicio
wrapper.app.parameter.2=/tmp/log
#********************************************************************
# Wrapper General Properties
#********************************************************************
# Allow for the use of non-contiguous numbered properties
wrapper.ignore_sequence_gaps=TRUE
# Title to use when running as a console
wrapper.console.title=servicio
#********************************************************************
# Wrapper Windows NT/2000/XP Service Properties
#********************************************************************
# Name of the service
wrapper.name=jgossip
# Display name of the service
wrapper.displayname=Servicio
# Description of the service
wrapper.description=Monitor de memoria
# Mode in which the service is installed. AUTO_START or DEMAND_START
wrapper.ntservice.starttype=AUTO_START
# Allow the service to interact with the desktop.
wrapper.ntservice.interactive=false

Explicación del archivo de configuración:

• wrapper.java.command=java es el comando para ejecutar java. En este caso es simplemente java porque estoy en Linux y además tengo configurado correctamente el path. En Windows podría ser algo como: c:\archivos de programa\java\jdk1.6\bin\java.exe
• wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp indica el archivo a ejecutar es la clase WrapperSimpleApp que se usa en la integración sencilla. Esta clase envoltorio es la que permite ejecutar la aplicación como servicio.
• wrapper.java.classpath.1=../lib/wrapper.jar
wrapper.java.classpath.2=servicio.jar indican las rutas o archivos del classpath.
• wrapper.java.library.path.1=../lib indica el directorio donde se encuentran las librerías a usar.
• wrapper.app.parameter.1=net.casidiablo.servicio.Servicio
wrapper.app.parameter.2=/tmp/log estos son los parámetros que se pasarán al programa. Importante: como estamos haciendo la integración simple, el primer parámetro debe ser la clase que contiene el método main de nuestra aplicación.
• wrapper.name=jgossip esta opción es para Windows y define el nombre del servicio en el sistema.
• wrapper.ntservice.starttype=AUTO_START si estás en windows, define si el servicio quedará configurado para iniciar automáticamente.

4. Probar/Instalar el servicio…

Ahora veremos cómo podemos probar la aplicación para asegurarnos que ha quedado bien configurada antes de proceder con la instalación.

UNIX/Linux

Ejecutamos el script ‘servicio’ que configuramos en el paso 1 y 2 con el parámetro console:

Deberías ver algo como:

Lo detienes presionando Ctrl+C. Ahora, si queremos probarlo como demonio basta con ejecutar los comandos típicos de un demonio en UNIX/Linux:

Para instalarlo basta con crear un enlace simbólico del script en el directorio /etc/init.d y añadirlo al listado de servicios a iniciar; por ejemplo:

Windows

Para instalarlo en Windows basta con ejecutar el archivo InstallServicio-NT.bat. Puedes verificar que fue instalado correctamente accediendo a la consola de administración de servicios de NT (ejecutas el comando services.msc):

Fuentes y descargas

Aunque en esta entrada no explico cómo hacer la integración avanzada, he preparado un ejemplo completo que puedes descargar en el listado de abajo.

• Puedes encontrar más documentación en la página oficial del proyecto
• Descargar el laboratorio de esta entrada
• Descargar el código fuente del laboratorio
• Descargar código fuente y laboratorio de la integración avanzada

Este es un pequeño ejemplo de cómo enviar correos desde Java usando el API de Java Mail. Lo único que necesitaremos es descargar la librería mail.jar de la página de Java Mail y crear un programa de este estilo:

import javax.mail.*;
import javax.mail.internet.*;
import java.util.*;

public class EnviarMail {
  public static void main(String[] args) {
    try {
      // Se debe crear un archivo de propiedades que
      // contenga el nombre del servidor SMTP
      Properties props = new Properties();
      props.put("mail.host", "mail.servidorcorreo.com");

      // se crea un objeto de sesion
      Session conexionCorreo = Session.getInstance(props, null);
      // este objeto representa el mensaje a enviar
      Message mensaje = new MimeMessage(conexionCorreo);

      // los objetos Adress contienen informacion de recipientes de correo
      Address desde = new InternetAddress("tucorreo@servidorcorreo.biz",
          "Pepito Perez");
      Address para = new InternetAddress("destinatario@otroservidor.com");

      // asignamos el contenido. En este caso usamos 'text/plain' pero
      // es posible usar 'text/html' para enviar correos con contenido
      // HTML
      mensaje.setContent("Este es un mensaje de texto plano!",
          "text/plain");
      // asignar el origen del correo
      mensaje.setFrom(desde);
      // asignar un destinatario
      mensaje.setRecipient(Message.RecipientType.TO, para);
      // asignar el asunto del correo
      mensaje.setSubject("Hola, Java Mail!");

      Transport.send(mensaje);

    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }
}

Para compilarlo y ejecutarlo desde la consola:

Si estás usando Eclipse, debes añadir la librería mail.jar al classpath. En este artículo explico cómo hacerlo.

Descargar

En esta guía aprenderemos a obtener información de los recursos sistema en Java, usando la librería Sigar. Los datos que podremos extraer son los siguientes:

• Información de la CPU.
• Espacio en disco disponible.
• Cantidad de espacio que consume un directorio en específico.
• Cantidad de memoria RAM disponible y en uso.
• Información de red (dirección IP, nombre de la NIC, puertos abiertos, tablas de enrutamiento, etc.)
• Información de los procesos que se están ejecutando en el sistema.
• Asignación de variables de entorno.
• Uptime, o cantidad de tiempo que el equipo ha estado encendido.
• Nombre y versión del sistema operativo.
• Usuarios logueados actualmente.

Resaltadas en negrita está la información en la que nos concentraremos en el ejemplo. Pero antes aclaremos un poco que es Sigar: el API de Sigar nos proporciona una serie de métodos que nos permiten obtener información del sistema operativo; consta de una librería de Java (.jar) y otras librerías nativas específicas para cada sistema operativo soportado (libsigar-amd64-linux.so, para Linux de 64 bits o sigar-x86-winnt.dll para Windows de 32 bits, por poner un ejemplo).

Teniendo esto en cuenta, para hacer funcionar dicha API en una de nuestras aplicaciones, bastaría con tener el archivo .jar y la librería específica de nuestro sistema operativo. En el desarrollo del ejemplo se usará Eclipse y, aunque se explicará cómo añadir las librerías en el proyecto, se da por conocido el funcionamiento del flag --classpath de los comandos javac y java (obligatorio si no se usa ningún IDE).

El resultado…

Siempre pongo primero el resultado ya que nos aclara la visión de hacia donde vamos, y de paso saber si lo que está aquí es lo que buscamos. Esta es la salida del programa en mi Gentoo Linux:

====Informacion del sistema====
Descripcion del SO	Gentoo 2.1.6
Nombre del SO		Linux
Arquitectura del SO	x86_64
Version del SO		2.6.31-gentoo
Nivel de parches	unknown
Fabricante		Gentoo
Version SO		2.1.6
Encendido durante:	6:15

==== Informacion de la CPU ====
Fabricante:		Intel
Modelo			Core(TM)2 Duo CPU     T5750  @ 2.00GHz
Mhz			1994
Total CPUs		2
CPUs fisiscas		1
Nucleos por CPU		2
Tamanio cache		2048

Consumo de CPU 0	22.0%
Consumo de CPU 1	2.0%
Consumo total de CPU	6.0%

====Informacion del sistema de archivos====

dispos.|total|usado|disponible|%uso|dir|tipo

/dev/root|24042944|10698228|12123376|47%|/|ext4
/dev/sda1|175457764|155825380|10719932|94%|/home|ext3

====Informacion de la memoria====
Cantidad de memoria RAM: 3968MB
Total: 4056984
Usada: 2307076
Disponible: 1749908
Memoria SWAP total: 1052248
Memoria SWAP usada: 0
Memoria SWAP libre: 1052248

Descargar Sigar

Puedes descargar Sigar de la página oficial: http://support.hyperic.com/display/SIGAR/Home que incluye además ejemplos para Java, Perl, C, Python, Ruby, y más. Puedes además descargar el código fuente que se encuentra licenciado bajo la GPL2.

Creación del proyecto en Eclipse

Voy a usar este ejemplo para además enseñar a manipular librerías externas en Eclipse; si lo que te interesa es conocer el código, puedes saltarte a dicha sección directamente.

Creamos un proyecto en Eclipse llamado InfoSistema:

Ahora creamos una carpeta dentro del proyecto llamada lib, en donde guardaremos las librerías de Sigar (.jar, .so, .dll, etc.):

Ahora descomprimimos el archivo que descargamos de Sigar, y copiamos los archivos que se encuentran en la carpeta sigar-bin/lib a la carpeta lib de nuestro proyecto. En mi caso la copia la hice con este comando:

Cabe resaltar que bastaría con copiar el archivo llamado sigar.jar y la librería del sistema donde vamos a correr nuestro programa (libsigar-amd64-linux.so en mi caso).

Una vez hecha la copia, hacemos clic en la raiz del proyecto en Eclipse y presionamos F5 para actualizar el árbol de ficheros; de esta manera Eclipse sabrá de los nuevos archivos que hemos copiado. Y lo que haremos a continuación será enlazar la librería sigar.jar a nuestro proyecto, para lo cual hacemos clic derecho en el mismo, Build Path -> Configure Build Path…

En la ventana que aparece, seleccionaremos la pestaña Libraries y hacemos clic en el botón Add JARs… Seleccionamos el archivo sigar.jar y hacemos clic en OK:

Ahora que la librería se encuentra añadida, podemos utilizar el API que Sigar nos ofrece. ¡Pasemos entonces al código!

Información del sistema…

La siguiente clase nos permite obtener información del sistema operativo, como el nombre, la versión, la arquitectura, etc. Creamos una nueva clase llamada InfoSO con el siguiente código:

import org.hyperic.sigar.OperatingSystem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;

public class InfoSO {
	private Sigar sigar = new Sigar();
	public void imprimirInfo() {
		OperatingSystem sys = OperatingSystem.getInstance();
		System.out.println("Descripcion del SO\t" + sys.getDescription());
		System.out.println("Nombre del SO\t\t" + sys.getName());
		System.out.println("Arquitectura del SO\t" + sys.getArch());
		System.out.println("Version del SO\t\t" + sys.getVersion());
		System.out.println("Nivel de parches\t" + sys.getPatchLevel());
		System.out.println("Fabricante\t\t" + sys.getVendor());
		System.out.println("Version SO\t\t" + sys.getVendorVersion());
		try {
			imprimirUptime();
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
	public void imprimirUptime() throws SigarException {
		double uptime = sigar.getUptime().getUptime();
		String resultado = "";
		int dias = (int) uptime / (60 * 60 * 24);
		int minutos, horas;
		if (dias != 0)
			resultado += dias + " " + ((dias > 1) ? "dias" : "dia") + ", ";
		minutos = (int) uptime / 60;
		horas = minutos / 60;
		horas %= 24;
		minutos %= 60;
		if (horas != 0)
			resultado += horas + ":" + (minutos < 10 ? "0" + minutos : minutos);
		else
			resultado += minutos + " min";
		System.out.println("Encendido durante:\t" + resultado);
	}
}

Aspectos importantes:

• La clase que nos proporciona los métodos para recuperar información del sistema operativo es OperatingSystem.
• Con los métodos getName y getDescription obtenemos el nombre del sistema operativo y descripción (por ejemplo: nombre = Linux; descripción = Gentoo 2.1.6).
• El método getUptime de la clase Sigar nos permite conocer cuanto tiempo ha estado prendido el equipo analizado.

Información de la CPU…

La siguiente clase nos permitirá conocer el modelo del procesador, sus capacidades, la cantidad de núcleos y el uso de los mismos, etc. Creamos una nueva clase llamada InfoCPU con el siguiente código:

import org.hyperic.sigar.CpuInfo;
import org.hyperic.sigar.CpuPerc;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;

public class InfoCPU {
	private Sigar sigar;

	public void imprimirInfoCPU() {
		sigar = new Sigar();
		CpuInfo[] infos = null;
		CpuPerc[] cpus = null;
		try {
			infos = sigar.getCpuInfoList();
			cpus = sigar.getCpuPercList();
		} catch (SigarException e) {
			e.printStackTrace();
		}

		CpuInfo info = infos[0];
		long tamanioCache = info.getCacheSize();
		System.out.println("Fabricante:\t\t" + info.getVendor());
		System.out.println("Modelo\t\t\t" + info.getModel());
		System.out.println("Mhz\t\t\t" + info.getMhz());
		System.out.println("Total CPUs\t\t" + info.getTotalCores());
		if ((info.getTotalCores() != info.getTotalSockets())
				|| (info.getCoresPerSocket() > info.getTotalCores())) {
			System.out.println("CPUs fisiscas\t\t" + info.getTotalSockets());
			System.out
					.println("Nucleos por CPU\t\t" + info.getCoresPerSocket());
		}

		if (tamanioCache != Sigar.FIELD_NOTIMPL)
			System.out.println("Tamanio cache\t\t" + tamanioCache);
		System.out.println("");

		for (int i = 0; i < cpus.length; i++)
			System.out.println("Consumo de CPU " + i + "\t"
					+ CpuPerc.format(cpus[i].getUser()));

		try {
			System.out.println("Consumo total de CPU\t"
					+ CpuPerc.format(sigar.getCpuPerc().getUser()));
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
}

Aspectos importantes:

• Se deben usar objetos de CpuInfo y CpuPerc que proporcionan los métodos para recuperar información del procesador. Dichos objetos se crean a partir de un objeto principal de tipo Sigar.
• Para extraer información acerca del procesador usamos los métodos de la clase CpuInfo (por ejemplo getVendor o getModel).
• Los datos específicos de cada núcleo de nuestro procesador se extraen con los métodos de la clase CpuPerc (getUser para obtener el uso de un núcleo, por ejemplo).

Información del sistema de archivos…

La siguiente clase nos permite obtener información del sistema de archivos: unidades montadas, espacio en disco, tipo de sistema de archivos, etc. Creamos una nueva clase llamada InfoSistemaArchivos con el siguiente código:

import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;
import org.hyperic.sigar.FileSystem;
import org.hyperic.sigar.FileSystemUsage;
import org.hyperic.sigar.NfsFileSystem;
import org.hyperic.sigar.SigarProxy;
import org.hyperic.sigar.SigarProxyCache;

public class InfoSistemaArchivos {
	private SigarProxy proxy;
	private Sigar sigar;

	public InfoSistemaArchivos() {
		sigar = new Sigar();
		proxy = SigarProxyCache.newInstance(sigar);
	}

	public void imprimirInfo() throws SigarException {
		FileSystem[] listaSistemaArchivos = proxy.getFileSystemList();
		System.out.println("\ndispos.|total|usado|disponible|%uso|dir|tipo\n");
		for (int i = 0; i < listaSistemaArchivos.length; i++)
			imprimirSistemaArchivos(listaSistemaArchivos[i]);
	}

	public void imprimirSistemaArchivos(FileSystem sistemaArchivos)
			throws SigarException {
		long usado, disponible, total, porcentaje;

		try {
			FileSystemUsage uso;
			if (sistemaArchivos instanceof NfsFileSystem) {
				NfsFileSystem nfs = (NfsFileSystem) sistemaArchivos;
				if (!nfs.ping()) {
					System.out.println(nfs.getUnreachableMessage());
					return;
				}
			}
			uso = sigar.getFileSystemUsage(sistemaArchivos.getDirName());

			usado = uso.getTotal() - uso.getFree();
			disponible = uso.getAvail();
			total = uso.getTotal();

			porcentaje = (long) (uso.getUsePercent() * 100);
		} catch (SigarException e) {
			// por ejemplo, si en al procesar D:\ en windows falla
			// con "Device not ready"
			usado = disponible = total = porcentaje = 0;
		}

		String porcentajeUso;
		if (porcentaje == 0)
			porcentajeUso = "-";
		else
			porcentajeUso = porcentaje + "%";

		System.out.print(sistemaArchivos.getDevName());
		System.out.print("|" + total);
		System.out.print("|" + usado);
		System.out.print("|" + disponible);
		System.out.print("|" + porcentajeUso);
		System.out.print("|" + sistemaArchivos.getDirName());
		System.out.println("|" + sistemaArchivos.getSysTypeName());
	}
}

Aspectos importantes:

• La clase que nos proporciona los métodos para obtener información de una unidad en específico es FileSystem.
• El método getDevName nos devuelve el nombre del dispositivo referenciado por el objeto de la clase FileSystem.
• Los métodos getTotal y getAvail devuelven un long que representa el espacio total del dispositivo y espacio disponible, respectivamente.
• Para conocer el tipo de sistema de archivos (ext4, ntfs, fat, btrfs, etc.) utilizamos el método getSysTypeName.

Información de la memoria…

La siguiente clase nos permite conocer la cantidad de memoria RAM que tiene el equipo, así como la que se está usando actualmente (tanto memoria física como virtual, aka, swap). Creamos una nueva clase llamada InfoMemoria con el siguiente código:

import org.hyperic.sigar.Mem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.Swap;
import org.hyperic.sigar.SigarException;

public class InfoMemoria {
	private Sigar sigar = new Sigar();
	public void imprimirInfo() throws SigarException {
		Mem memoria = sigar.getMem();
		Swap intercambio = sigar.getSwap();

		System.out.println("Cantidad de memoria RAM: "+ memoria.getRam() + "MB");

		System.out.println("Total: "+enBytes(memoria.getTotal()));
		System.out.println("Usada: "+enBytes(memoria.getUsed()));
		System.out.println("Disponible: "+enBytes(memoria.getFree()));

		System.out.println("Memoria SWAP total: "+enBytes(intercambio.getTotal()));
		System.out.println("Memoria SWAP usada: "+enBytes(intercambio.getUsed()));
		System.out.println("Memoria SWAP libre: "+enBytes(intercambio.getFree()));

	}
	private Long enBytes(long valor) {
		return new Long(valor / 1024);
	}
}

Aspectos importantes:

• La clase Mem nos proporciona métodos para obtener información de la memoria del sistema.
• La clase Swap hace lo mismo que Mem, pero para la memoria virtual.
• Los métodos getTotal y getUsed nos devuelven un long que representa (en bits) la cantidad de memoria del equipo y lo que está usando, respectivamente.

La clase main…

El main de nuestro proyecto estará contenido en la clase InfoSistema:

import org.hyperic.sigar.SigarException;
public class InfoSistema {
	public static void main(String[] args) {
		try {
			System.out.println("====Informacion del sistema====");
			new InfoSO().imprimirInfo();
			System.out.println("\n==== Informacion de la CPU ====");
			new InfoCPU().imprimirInfoCPU();
			System.out.println("\n====Informacion del sistema de archivos====");
			new InfoSistemaArchivos().imprimirInfo();
			System.out.println("\n====Informacion de la memoria====");
			new InfoMemoria().imprimirInfo();
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
}

Eso es todo, solo nos queda ejecutar el proyecto y, opcionalmente, crear un archivo .jar para ejecutar en cualquier lado.

Descargas…

• Descarga del código fuente usado en esta entrada
• Descargar librerías de Sigar de SourceForge

Puesto que estaré haciendo un proyecto en Python, iré colocando aquellos tips útiles que he aprendido usando este maravilloso lenguaje de programación. En este caso, se trata de obtener la información del sistema que ejecuta el script; cosas como el PID del script, el directorio donde se está ejecutando, el nombre y versión del sistema operativo, etc.:

#!/usr/bin/python

import os
import time

numUsuario = os.getuid()
pidProceso = os.getpid()
donde = os.getcwd()
sistemaOperativo = os.uname()
tiempos = os.times()
horaRaw = time.time()
horaFormato = time.ctime(horaRaw)

print "Numero de usuario",numUsuario
print "PID",pidProceso
print "Directorio actual",donde
print "Informacion del sistema",sistemaOperativo
print "Informacion de tiempos del sistema",tiempos

print "\nLa hora/fecha actual es",horaRaw
print "Lo cual significa",horaFormato

Información extra: http://docs.python.org/library/os.html

Este es un tip bastante útil que nos permitirá poner las ventanas de nuestras aplicaciones en Fullscreen (pantalla completa), y de paso aprenderemos a crear ventanas sin bordes (lo cual es útil si queremos hacer algún splash de inicio para nuestra aplicación).

En el siguiente ejemplo usaremos básicamente los siguientes métodos y clases:

• Método setUndecorated de la clase JFrame, el cual recibe un parámetro boolean. Si le enviamos true, quitará los bordes de la ventana.
• La clase GraphicsDevice nos permite manejar objetos que representan dispositivos gráficos, como la pantalla del computador. En este caso creamos el  objeto con la instrucción GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); que nos devuelve un objeto que representa la pantalla en donde se está mostrando nuestro programa.
• El método setFullScreenWindow, de la clase GraphicsDevice, nos permite poner nuestro programa en pantalla completa. Además, aunque no lo usemos en el ejemplo, contamos con el método isFullScreenSupported que nos permite saber si es posible poner la ventana en modo fullscreen o no.

Código fuente del ejemplo…

import javax.swing.*;
import java.awt.GraphicsEnvironment;
import java.awt.GraphicsDevice;
import java.awt.event.*;

public class EjemploFullscreen extends JFrame implements ActionListener{
        private JButton boton;
        private boolean estaFull = false;
        static GraphicsDevice grafica=
                GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
        public EjemploFullscreen() {
                super("Ejemplo pantalla completa en Java");

                boton = new JButton("Presioname");
                boton.addActionListener(this);
                getContentPane().add(boton);

                setSize(640, 400);
                setUndecorated(true);
                setVisible(true);
        }

        public static void main(String[] args) {
                new EjemploFullscreen();
        }

        public void actionPerformed(ActionEvent e) {
                if(!estaFull)
                        grafica.setFullScreenWindow(this);
                else
                        grafica.setFullScreenWindow(null);
                estaFull = !estaFull;
        }
}

Descargar código fuente

Existen dos maneras de definir constantes en C Sharp: usando const o readonly. Cuando se usa const, es posible acceder a la variable directamente desde la clase (sin instanciar un objeto), como si se tratase de un atributo estático; mientras que con readonly, es un tipo de constantes que funciona como un atributo normal, y que una vez inicializada no se le puede cambiar el valor.

Veamos un ejemplo sencillo para aclararnos:

using System;
public class Constantes {
  // crear constante PI
  public const double PI = 3.14159;
  // radio es una constante esta sin iniciar
  public readonly int radio;
  public Constantes( int radioValue ) {
     radio = radioValue;
  }
}
// Clase UsarConstantes
public class UsarConstantes {
  // metodo Main crea un objeto de tipo 'Constantes'
  // y muestra los valores
  static void Main( string[] args ) {
     Random random = new Random();
     Constantes valoresConstantes =
        new Constantes( random.Next( 1, 20 ) );
     Console.WriteLine( "Radio = " + valoresConstantes.radio +
        "\nCircunferencia = " +
        2 * Constantes.PI * valoresConstantes.radio);
  }
}

Resultado…

Descargar código fuente

Las variables estáticas son atributos de una clase que están disponibles para todas las instancias de dicha clase, y a los cuales puedes acceder directamente (sin instanciar un objeto) de la forma Clase.Variable.

Los destructores son métodos que se ejecutan cuando se elimina un objeto; son especialmente útiles si deseamos hacer algo en particular, antes de eliminar la referencia al objeto. A continuación un sencillo ejercicio, en donde se ejemplifica el uso de las variables estáticas y de los destructores en C Sharp:

using System;
namespace Estatico{
   public class Clase {
      //un atributo normal
      private string variable;
      //esta variable esta disponible para todas
      //las instancias de esta clase
      private static int contador;
      //constructor
      public Clase(string x) {
         variable = x;
         //aumentar valor de la variable estatica
         ++contador;
         Console.WriteLine("Constructor de "+variable);
      }
      ~Clase(){
         --contador;
         Console.WriteLine("Se destruyo una de las instancias ("+variable+")"+contador);
      }
      public static int Contador{
         get{
            return contador;
         }
      }
   }
}

Clase que utiliza los valores estáticos de la clase anterior:

using System;
namespace Estatico{
   public class Principal{
      static void Main(string[] args){
         Console.WriteLine("Contador antes de crear objetos: "+Clase.Contador);
         //crear 2 instancias de la clase
         Clase objeto1 = new Clase("primero");
         Clase objeto2 = new Clase("segundo");
         Console.WriteLine("Contador despues de crear objetos: "+Clase.Contador);
         //eliminar referencias a los objetos
         objeto1 = null;
         objeto2 = null;
         //forzar al recolector de basura a ejecutarse
         System.GC.Collect();
         //esperar hasta que el recolector de basura termine su trabajo
         System.GC.WaitForPendingFinalizers();
         //despues de la recolecta de basura...
         Console.WriteLine("Despues de la recolecta de basura, contador: "+Clase.Contador);
      }
   }
}

Descargar código fuente

Al momento de acceder a los atributos de una clase, podemos usar métodos para asignar y obtener dichos datos (normalmente llamados getters y setters). En C Sharp podemos usar una caracterí­stica llamada ‘propiedades’, por medio de la cual declaramos un alias de acceso público para los atributos de acceso privado.

Me explico. Cuando declaramos atributos en una clase, lo más aconsejable es crearlos con el modificador de acceso private. Por tal motivo no es posible acceder a dichos atributos directamente desde el objeto (de la manera: objeto.atributo), porque como vimos en esta entrada nos arrojará errores de compilación.

Aquí­ es cuando las ‘propiedades’ son especialmente útiles. Una propiedad es como un alias que nos permite acceder a los atributos de manera segura, y con la que nos ahorramos tiempo y espacio en nuestro código. Vamos directamente con un ejemplo, y posteriormente una breve explicación del mismo.

Clase de ejemplo, que implementa una ‘propiedad’ para acceder al atributo:

public class Clase {
	//atributo
	private int variable;
	//constructor
	public Clase(int variable) {
		this.variable = variable;
	}
	//declaracion de la propiedad
	public int atributo{
		//get sirve para devolver el valor del atributo
		get{
			return variable;
		}
		//set sirve para cambiar el valor del atributo
		set{
			variable = value;
		}
	}
}

En la lí­nea 9 tenemos la declaración de la propiedad; en dicha declaración debemos especificar un nombre (diferente al del atributo al que vamos a acceder), y un tipo (en este caso int, entero). Dentro de la propiedad tenemos dos bloques: get y set. Dentro de get debemos poner los valores a retornar cuando se acceda a la propiedad; mientras que en set podemos usar la palabra clave value para asignar un valor al atributo.

En la siguiente clase se utiliza la propiedad de la clase anterior, para obtener y modificar los valores del atributo:

using System;
public class Propiedades {
	public Propiedades() {
		//declaracion del objeto
		Clase objeto = new Clase(5);
		//obteniendo el valor de la variable 'variable'
		//usando la propiedad 'atributo' (se usa el bloque get)
		Console.WriteLine("El atributo del objeto es "+ objeto.atributo);
		Console.WriteLine("Cambiando el valor usando la propiedad 'atributo'...");
		//cambiando el valor de la variable 'variable'
		//usando la propiedad 'atributo' (se usa get)
		objeto.atributo = 10;
		Console.WriteLine("Ahora el atributo del objeto es "+ objeto.atributo);
	}
	static void Main(string[] args){
		new Propiedades();
	}
}

Como puedes observar, es posible obtener y modificar los datos de un atributo privado usando una ‘propiedad’ pública, y todo de una manera totalmente segura, puesto que dentro de la ‘propiedad’ podemos verificar la consistencia de los datos.

El resultado…

Descargar código fuente

Tal como veí­amos en el ejemplo anterior, en donde explicabamos las nociones básicas de la programación orientada a objetos en C Sharp, los objetos pueden tener uno o más constructores. El siguiente ejemplo es una modificación del anterior ejercicio, en donde declaramos y usamos varios constructores.

El código…

La clase Tiempo2 que declara 5 constructores; el primero de ellos (lí­nea 9) no recibe argumentos e inicia las variables a cero; el segundo recibe solo parámetro e inica solo una de los atributos de la clase; mientras que el quinto constructor (lí­nea 32) recibe como parámetro un objeto del mismo tipo de la clase, y usando los atributos de dicho objeto inicia los atributos propios:

using System;
public class Tiempo2
{
  private int hora;    // 0 -23
  private int minuto;  // 0-59
  private int segundo;  // 0-59
  // Constructor de la clase Tiempo que inicialize
  //las variables a cero para poner la hora en media noche
  public Tiempo2()
  {
     cambiarHora( 0, 0, 0 );
  }
  // Contructor que recibe unicamente la
  // hora, y lo demas lo inicia a 0
  public Tiempo2( int hora )
  {
     cambiarHora( hora, 0, 0 );
  }
  // Contructor que recibe la hora y el
  // minuto, y lo demas lo inicia a 0
  public Tiempo2( int hora, int minuto )
  {
     cambiarHora( hora, minuto, 0 );
  }
  // Contructor que recibe los tres atributos
  public Tiempo2( int hora, int minuto, int segundo )
  {
     cambiarHora( hora, minuto, segundo );
  }
  // Constructor que utiliza los datos de otro
  //metodo de tipo Tiempo2 para inciar los datos
  public Tiempo2( Tiempo2 hora )
  {
     cambiarHora( hora.hora, hora.minuto, hora.segundo );
  }
  // este metodo asigna una nueva hora en formato 24-horas.
  public void cambiarHora(
     int valorHora, int valorMinuto, int valorSegundo )
  {
     hora = ( valorHora >= 0 &amp;amp;&amp;amp; valorHora < 24 ) ?
        valorHora : 0;
     minuto = ( valorMinuto >= 0 &amp;amp;&amp;amp; valorMinuto < 60 ) ?
        valorMinuto : 0;
     segundo = ( valorSegundo >= 0 &amp;amp;&amp;amp; valorSegundo < 60 ) ?
        valorSegundo : 0;
  }
  // convertir a hora universal con el metodo format
  public string horaUniversal()
  {
     return String.Format(
        "{0:D2}:{1:D2}:{2:D2}", hora, minuto, segundo );
  }
  // convertir a tiempo estandar (12 horas) usando el metodo format
  public string horaEstandar()
  {
     return String.Format( "{0}:{1:D2}:{2:D2} {3}",
        ( ( hora == 12 || hora == 0 ) ? 12 : hora % 12 ),
        minuto, segundo, ( hora < 12 ? "AM" : "PM" ) );
  }
}

Clase en donde se utilizan los diferentes tipos de constructores:

using System;
class PruebaTiempo2 {
  static void Main( string[] args ) {
     Tiempo2 hora1, hora2, hora3, hora4, hora5, hora6;
     hora1 = new Tiempo2();               // 00:00:00
     hora2 = new Tiempo2( 2 );            // 02:00:00
     hora3 = new Tiempo2( 21, 34 );       // 21:34:00
     hora4 = new Tiempo2( 12, 25, 42 );   // 12:25:42
     hora5 = new Tiempo2( 27, 74, 99 );   // 00:00:00
     hora6 = new Tiempo2( hora4 );        // 12:25:42
     String salida = "Construido con: " +
        "\nhora1: todos los argumentos por defecto" +
        "\n\t" + hora1.horaUniversal() +
        "\n\t" + hora1.horaEstandar();
     salida += "\nhora2: hora especifica; minuto y segundo por defecto" +
        "\n\t" + hora2.horaUniversal() +
        "\n\t" + hora2.horaEstandar();
     salida += "\nhora3: hora y minuto especifico; segundo por defecto" +
        "\n\t" + hora3.horaUniversal() +
        "\n\t" + hora3.horaEstandar();
     salida += "\nhora4: los tres argumentos especificamente" +
        "\n\t" + hora4.horaUniversal() +
        "\n\t" + hora4.horaEstandar();
     salida += "\nhora5: los tres argumentos especificamente" +
        "\n\t" + hora5.horaUniversal() +
        "\n\t" + hora5.horaEstandar();
     salida += "\nhora6: otro objeto de tipo Tiempo2 (hora4)" +
        "\n\t" + hora6.horaUniversal() +
        "\n\t" + hora6.horaEstandar();
     Console.WriteLine( salida );
  }
}

El resultado del programa es el siguiente:

Descargar código fuente

La POO es un paradigma de programación que intenta abstraer los módulos de cada programa en objetos. Los objetos son instancias de clases, en las que se declaran/especifican al menos dos cosas: los atributos, los métodos y opcionalmente los constructores.

Los atributos son las variables que posee el objeto, mientras que los métodos son las funciones o procedimientos que podemos invocar para realizar operaciones especí­ficas sobre los atributos.

Como en Java, en C Sharp utilizamos siempre clases y objetos, aún cuando no tengamos claro el concepto. Por ejemplo, el simple hola mundo:

using System;
class Hola{
   static void Main(string[] args){
      Console.WriteLine("Hola parce!");
   }
}

En cada lí­nea de código estamos usando la programación orientada a objetos: lí­nea 1, creamos una clase (llamada Hola); lí­nea 2, declaramos un método (función) para nuestra clase; lí­nea 3, usando la clase Console invocamos el método WriteLine. Todo, programación orientada a objetos.

Ejemplo de POO en C Sharp

En el siguiente ejemplo tomado del libro Cómo programar en C Sharp de Deitel, se utiliza una clase llamada tiempo. Dicha clase posee tres atributos (hora, minuto, segundo; todos variables enteras), y tres métodos. Vamos con el código, y mí¡s abajo una explicación:

using System;
public class Tiempo
{
  private int hora;    // 0 -23
  private int minuto;  // 0-59
  private int segundo;  // 0-59
  // Constructor de la clase Tiempo que inicialize
  //las variables a cero para poner la hora en media noche
  public Tiempo()
  {
     cambiarHora( 0, 0, 0 );
  }
  // este metodo asigna una nueva hora en formato 24-horas.
  public void cambiarHora(
     int valorHora, int valorMinuto, int valorSegundo )
  {
     hora = ( valorHora >= 0 && valorHora < 24 ) ?
        valorHora : 0;
     minuto = ( valorMinuto >= 0 && valorMinuto < 60 ) ?
        valorMinuto : 0;
     segundo = ( valorSegundo >= 0 && valorSegundo < 60 ) ?
        valorSegundo : 0;
  }
  // convertir a hora universal con el metodo format
  public string horaUniversal()
  {
     return String.Format(
        "{0:D2}:{1:D2}:{2:D2}", hora, minuto, segundo );
  }
  // convertir a tiempo estandar (12 horas) usando el metodo format
  public string horaEstandar()
  {
     return String.Format( "{0}:{1:D2}:{2:D2} {3}",
        ( ( hora == 12 || hora == 0 ) ? 12 : hora % 12 ),
        minuto, segundo, ( hora < 12 ? "AM" : "PM" ) );
  }
}

• En la segunda lí­nea vemos la instrucción public class Tiempo; esto no es mí¡s que la declaración de nuestra clase. Las clases por lo general son de tipo public, aunque si usamos clases internas anónimas es recomendable que sean private, aunque eso es otro tema… sigamos.
• En las lí­neas 4, 5 y 6 tenemos la declaración de los atributos de nuestra clase. Fí­jate como todos ellos son private; es un buen tip de programación que los atributos de nuestras clases sean privados, lo que significa que sólamente serí¡n accesibles desde los métodos de la clase.
• En la lí­nea 9 tenemos la declaración de un constructor. Los constructores son los métodos invocados en el momento de crear objetos; su función es la darle valores a los atributos del objeto. Podemos tener cuantos constructores necesitemos, por supuesto con diferente tipo de argumentos. Ademí¡s, es necesario tener en cuenta que los constructores son métodos que NO tienen ningún valor de retorno, y que deben llevar el mismo nombre de la clase.
• En las lí­neas 14, 25 y 31 estí¡n declarados los métodos o funciones, que permiten realizar operaciones sobre nuestro objeto. Por ejemplo, el método cambiarHora recibe tres argumentos, con los cuales modifica los atributos. Por lo general, los métodos de las clases son de tipo public, lo que permite invocarlos directamente a través de una instancia de la clase (es decir, un objeto).

Con el siguiente código, utilizamos la clase Tiempo:

using System;
class PruebaTiempo {
  static void Main( string[] args ) {
     Tiempo tiempo = new Tiempo();  // llamada al constructor de Tiempo
     string salida;
     // mostrar datos iniciales
     salida = "Hora universal inicial es: " +
        tiempo.horaUniversal() +
        "\nHora estandar inicial es: " +
        tiempo.horaEstandar();
     // cambiar hora (valida)
     tiempo.cambiarHora( 13, 27, 6 );
     // aniadir nueva hora a la salida
     salida += "\n\nHora universal despues de cambiada: " +
        tiempo.horaUniversal() +
        "\nHora estandar despues de cambiada: " +
        tiempo.horaEstandar();
     // cambiar hora (invalida)
     tiempo.cambiarHora( 99, 99, 99 );
     salida += "\n\nDespues de poner valores invalidos: " +
        "\nHora universal: " + tiempo.horaUniversal() +
        "\nHora estandar: " + tiempo.horaEstandar();
     Console.WriteLine( salida );
  }
}

• En la lí­nea 3 creamos un objeto de tipo tiempo. Por lo general la sintaxis para crear objetos es la siguiente: Clase objeto = new Clase(). Es decir, el nombre de la clase, el nombre del objeto, y posteriormente se incia el objeto haciendo una invocación al constructor de la clase (anteponiendo la instrucción new).
• En la lí­nea 8, invocamos uno de los métodos de la clase (horaUniversal). La sintaxis para la invocación de los métodos es: objeto.nombreMetodo(arg1, arg2, ...). Así­, en la lí­nea 12 podemos ver otro ejemplo de invocación, en la que pasamos algunos argumentos al método.

El resultado del programa es el siguiente:

Descargar código fuente

Acceso a los atributos de un objeto

Si al momento de declarar los atributos de una clase utilizamos el modificador de acceso public, es posible acceder a dichos atributos directamente de la siguiente manera: objeto.variable; ó objeto.variable = unValor;. Esto por supuesto NO es recomendable, es decir, los atributos de una clase deberí­an ser SIEMPRE privados.

De igual forma, si hemos declarado atributos con el modificador de acceso private, NO es posible acceder directamente a ellos. Así­ que para modificarlos, debemos crear métodos de acceso público, algo por supuesto mí¡s seguro. Si intentamos acceder directamente a atributos que se han declarado como privados, obtendremos errores de compilación.