El método getClass() explicación y uso práctico – Construyendo librerías en Java I.

El siguiente articulo es el primero de una serie de artículos en donde intentare expresar un conjunto de ideas de una arquitectura de aplicación que nos permita con el tiempo crear proyectos de software robustos. Para conseguir este objetivos tendremos que ver primero algunos tópicos avanzados en Java.

 

libreria_java

Accediendo a la información de la clase

El método getClass() se encuentra definido en Object como un método final, dicho método devuelve una representación en tiempo de ejecución de la clase del objeto sobre el cual podemos acceder a una serie de caracteristicas del objeto por ejemplo: el nombre de la clase, el nombre de su superclase y los nombres de los interfaces que implementa.

Mostrando el nombre de la clase

Observe el siguiente código de la clase PruebaNombre.java:

public class PruebaNombre {
	public String nombreClase() {
		return this.getClass().getSimpleName();
	}
	public static void main(String[] args) {
		PruebaNombre prueba = new PruebaNombre();
		System.out.print(prueba.nombreClase());
	}
}

Al ejecutar nos imprime PruebaNombre el cual es el nombre simple para la clase en cuestión, lo importante aquí es que accedemos a la clase por medio de this.getClass() y de ahí accedemos al nombre de la clase con el método getSimpleName, que es lo que devolvemos.

Accediendo a atributos

Ahora por medio de getClass vamos a crear un método para acceder a los atributos existentes en la clase para imprimir el nombre y valor de cada atributo:

import java.lang.reflect.Field;
public class PruebaAtributos {
	String atributo_1 = "valor 1";
	String atributo_2 = "valor 2";
	String valor_x = null;
	
	public void imprimirAtributos() {
		Field[] fields = this.getClass().getDeclaredFields();
		for(Field field : fields) {
                try {
                	String fieldName = field.getName();
                	Object fieldValue = field.get(this);
					System.out.println(fieldName + ":" + fieldValue);
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
            }
	}
	public static void main(String[] args) {
		PruebaAtributos prueba = new PruebaAtributos();
		prueba.imprimirAtributos();
	}
}

En este caso el resultado del código es el siguiente:

atributo_1:valor 1
atributo_2:valor 2
valor_x:null

Accediendo al constructor, creando elementos dinámicos

Desde la instancia de clase también podemos acceder a los constructores de clase, para a partir de estos crear una nueva instancia dinámica del objeto en cuestión, observe el siguiente código:

import java.lang.reflect.InvocationTargetException;

public class PruebaNewInstance {
	public String atributo_1 = "valor default";
	/**
	 * Constructores normales
	 * 
	 * @param atributo_value
	 */
	public PruebaNewInstance(String atributo_value){
        this.atributo_1 = atributo_value;
    }
	public PruebaNewInstance(){}
	/**
	 * Devuelve una instancia de PruebaNewInstance dinamica a partir de un constructor con atributos
	 * @param atributo_value
	 * @return
	 */
	static public PruebaNewInstance constructor(String atributo_value) {
		try {
			return PruebaNewInstance.class.getConstructor(String.class).newInstance(atributo_value);
		} catch (InstantiationException | IllegalAccessException
				| IllegalArgumentException | InvocationTargetException
				| NoSuchMethodException | SecurityException e) {
			e.printStackTrace();
		}
		return null;
	}
	/**
	 * Devuelve una instancia de PruebaNewInstance dinamica a a patir del constructor vacio
	 * 
	 * @return
	 */
	static public PruebaNewInstance constructor() {
		try {
			return PruebaNewInstance.class.newInstance();
		} catch (InstantiationException | IllegalAccessException
				| IllegalArgumentException | SecurityException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static void main(String[] args) {
		PruebaNewInstance prueba = new PruebaNewInstance("valor_atributo_1");
		System.out.println(prueba.atributo_1);
		// Creando un objeto desde un constructor dinamico
		PruebaNewInstance prueba2 = PruebaNewInstance.constructor("val_atrib_1 constructor Dinamico");
		System.out.println(prueba2.atributo_1);
		//
		PruebaNewInstance prueba3 = PruebaNewInstance.constructor();
		System.out.println(prueba3.atributo_1);
	}
}

El resultado del código anterior es:

valor_atributo_1
val_atrib_1 constructor Dinamico
valor default

Código completo

Dejo un enlace del código en cuestión: [ PruebaGetClass.java ]

Conclusiones

¿Se te ocurre algunas formas de utilizar estas características del lenguaje java?, bien esto lo podríamos utilizar para p.e. acceder a los nombres y atributos y a partir de esto realizar determinadas acciones.

¿Para donde vamos?

Podríamos crear un objeto abstracto Model el cual podría servir como un objeto persistencia del cual podríamos heredar en otros objetos p.e. PersonasModel debería de conectar a la tabla personas, también podríamos agregar atributos como prmary_key y a partir de estos valores realizar consultas SQL como INSERT, UPDATE, SELECT.

Linux crear un lanzador con login para Root

En ocasiones necesitamos ejecutar determinada tarea con permisos de usuario root p.e. arrancar determinado servicio como web o de base de datos. Desgraciadamente cuando agregamos un lanzador en nuestro escritorio este se ejecutara con los permisos del usuario que le haga clic en el lanzador en cuestión.

Crear un lanzador

Bien imaginemos que queremos ejecutar el siguiente script con permisos de usuario root:

/bin/mi_script.sh

Para esto vamos a crear un lanzador con el comento gnome-desktop-item-edit como vemos a continuación:

 #Creando lanzador en el escritorio
gnome-desktop-item-edit --create-new ~/Escritorio/

Esto nos debería de ejecutar una ventana similar a la que se muestra a continuación:

 

Creador de lanzadores

Credor de lanzadores

Este comando básicamente nos genera un lanzador el cual no es otra cosa que un archivo de texto que contiene la información de la aplicación a ejecutar cuando le damos clic, para mayor información del formato consulte:

https://developer.gnome.org/integration-guide/stable/desktop-files.html.es

Agregando login root al lanzador

Una vez que tengamos abierta la ventana de la configuración agregamos lo siguiente en el campo de comando:

gksudo bash /bin/mi_script.sh

Con esto estamos diciendo que el comando bash /bin/mi_script.sh sera ejecutado con permisos de usuario root por medio del comando gksudo el cual es una versión gráfica del comando sudo, a continuación se ilustra la imagen:

lanzador_con_gksudo

Notas:

  • El comando gksudo funciona para gnome para kde puedes ocupar el kdesudo.
  • Para tener disponible el comando gksudo debes de instalar previamente gnome-panel.

Instalar Firefox 36 Beta en Debian, Ubuntu, Mint y derivados

El 15 de enero de este año(2015) salio la versión Beta de firefox 36, veremos como instalar esta versión en nuestro sistema debian o derivados:

 

Pasos de instalación

1.- Agregando repositorio y actualizando la lista de paquetes

Lo primero que tenemos que hacer es agregar la fuente de firefox beta y posteriormente actualizamos la lista de paquetes disponibles, para esto ejecutamos las siguientes lineas:

#Agregando el nuevo repositorio
sudo apt-add-repository ppa:mozillateam/firefox-next

#Actualizando lista de paquetes
sudo apt-get update

2.- Actualizando firefox

#Actualizando el repositorio de firefox
sudo apt-get install --only-upgrade firefox

#instalando las traducciones adecuadas.
sudo apt-get install firefox-locale-es firefox-locale-es:i386

Finalmente probamos que todo funcione de forma correcta, para esto ejecutamos el lanzador de aplicaciones presionando Alt + F2 y escribimos firefox nos debería de abrir el firefox de ahí nos vamos a Help/About Mozilla firefox. Esto nos debería de aparecer que la versión es la 36

Que es el protocolo ARP y como acceder a sus tablas desde Android.

El protocolo ARP (Address Resolution Protocol) nos sirve para resolver direcciones físicas(MAC) a partir de las direcciones logicas(IP).

En ocasiones un nodo en la red necesita saber la dirección MAC de determinado equipo y sí solo conoce la dirección IP entonces realiza una solicitud ARP con esta dirección IP esperando que el equipo propietario de dicha dirección le responda con su dirección MAC.

Para que quede mas claro tratare de explicar esto con una imagen:

protocolo_arpComo podemos ver el nodo con IP 192.168.0.1 y MAC 10:16:F8:BA:19:57 Desea saber la dirección MAC del equipo con IP 192.168.0.9 por lo tanto envía una solicitud ARP a todos los equipos(broadcast) preguntando algo como:

Equipo 192.168.0.9 ¿me puedes enviar tu dirección MAC?

 

Esta «pregunta»(ARP – Request) les llega a todos los equipos a la red, pero solamente el equipo que tenga la dirección 192.168.0.9 será quien responda dicha pregunta(ARP-Reply) con algo como:

Equipo 192.168.0.1, yo soy 192.168.0.9 y mi dirección física es: 00:D1:16:19:34:01

Si nos percatamos en el ARP-Reply(respuesta) la respuesta la envia al equipo con MAC 10:16:F8:BA:19:57 por lo cual la solicitud no es enviada a todos los equipos como en el caso del ARP-Request(solicitud).

Tablas ARP

Todo este proceso de obtener la relaciones de direcciones IP y MACs puede provocar bastante trafico en la red sobre todo en el proceso de solicitud ya que como vimos se llena toda la red de paquetes.

Por esta razón los equipos van generando una tabla en donde almacenan esta información y con esto evitar la necesidad de realizar solicitudes ARPs. Dichas tablas son conocidas como Tablas ARPs.

Obteniendo las tablas ARPs:

Cuando configuramos una red es bastante común el ocupar las direcciones MAC y su relación con las direcciones IPs para determinadas configuraciones p.e. configurar una NAT, asignación de direcciones IPs especificas, bloqueo de equipos, etc…

La mayoría de los sistemas operativos cuentan con el comando arp el cual nos muestra dichas tablas veamos como obtenerlas en los sistemas operativos mas comunes:

#Linux, MAC y Windows
arp -a
#En Windows tmb se puede ocupar
arp -g

Tablas ARPs en Android.

En android no contamos con dicho comando sin embargo podemos acceder a un archivo (arp) ubicado en /proc/net/ (en esta carpeta están las configuraciones de red de android) en el cual se encuentran las tablas arp, sin mas veamos como visualizar dichas tablas.

cat /proc/net/arp

Nota: para acceder a la consola en android podemos ocupar la aplicación: «Terminal Emulator for Android», la cual puedes acceder desde:

https://play.google.com/store/apps/details?id=jackpal.androidterm&hl=es

NOTA2: Los sistemas operativos Unix(Linux & MAC) cuentan tambien con el archivo /proc/net/arp

Para mayor info: