Entradas con la etiqueta ‘java’

Después  de algún tiempo regreso para compartirles algo que he aprendido. Durante los últimos dos años he estado trabajando en el lenguaje de programación JAVA. Ya compartiré algunas cosas que he aprendido al respecto.

Por ahora les comento que recientemente obtuve la certificación Java OCJP (Oracle Certification Java Professional JAVA SE 6 Programmer), aquí les voy a comentar qué deben hacer para aplicar.

Como requisito previo que necesitan para aplicar es tener una Tarjeta de Crédito Internacional para poder comprar la certificación, ya que se compra por Internet.

Los pasos que deben seguir son los siguientes:

  • Van a donde dice Sign in para que crean una nueva cuenta.
Certificación Java: Crear cuenta en PearsonVue

Certificación Java

  • En la siguiente pantalla deben escoger las opciones: en Narrow by Category seleccionan Information Technology TI. y en Select your testing program escogen Oracle.
Escoger Information Technology y Oracle.

Escoger Information Technology y Oracle.

  • En la siguiente ventana damos clic en Schedule a Test
Damos clic en Schedule a Test

Damos clic en Schedule a Test

  • Bajamos un poco y damos clic en el enlace que dice Proctored
Clic en Proctored

Clic en Proctored

  • En la siguiente pantalla damos clic al enlace Create a Web Account
Creamos una cuenta en PearsonVue

Creamos una cuenta en PearsonVue

  • En la siguiente página llenamos los datos personales y donde dice: Previous Testing History escogemos No. Aquí algo importante es que cuando nos pida la dirección pongamos lo más explícita que podamos, es decir, calle principal, número, calle secundaria, nombre del edificio y alguna referencia, ya que a esa dirección nos enviarán la certificación.
Certificacion Java

Escogemos que no tenemos un ID de Oracle Testing

Como yo ya tengo una cuenta voy a iniciar sesión. Después que creen su cuenta para iniciar sesión deben seguir los pasos previos e ingresan su usuario y contraseña temporal que les será enviado por correo electrónico.

El usuario y contraseña enviados al correo

El usuario y contraseña enviados al correo

  • Después de iniciar sesión en la siguiente pantalla deben elegir el examen que van a dar para obtener la certificación que en nuestro caso es el 1Z0-851 Java Standard Edition 6 Programmer Certified Professional Exam.
    Escogemos examen 1Z0-851

    Escogemos examen 1Z0-851

     

  • Luego escogemos el idioma en que queremos dar el examen y nos aparece el precio, en esta caso cuesta 150 dólares.
Escogemos el idioma en que daremos el examen

Escogemos el idioma en que daremos el examen

  • Damos clic en Next y en la siguiente pantalla indicamos nuestra ubicación geográfica y seleccionamos el centro donde daremos el examen de certificación:
Escogemos el centro donde daremos el examen

Escogemos el centro donde daremos el examen

  • Damos clic en Next y escogemos la fecha y hora en la que daremos el examen:
Escogemos fecha y hora para el examen

Escogemos fecha y hora para el examen

  • Luego damos clic en Next y se nos muestra toda la información sobre el examen como fecha, hora y el centro donde se dará, verificamos la información y damos clic en Next:
Verificamos la información

Verificamos la información

  • En la siguiente pantalla ingresamos la forma de pago, es decir los datos de la tarjeta de crédito:
Ingresamos datos de la tarjeta de crédito

Ingresamos datos de la tarjeta de crédito

  • Todavía no se ha procesado la forma de pago y aún no hemos hecho el pago de 150 dólares. Damos clic en Next y en la siguiente pantalla se muestra la confirmación del pago. Una vez que demos clic en Next en la siguiente pantalla se habrá efectuado el cargo a la tarjeta de crédito. De ahí solo queda esperar la confirmación que nos llegará al mail con la factura y la información del examen.

Y eso es todo para aplicar a una certificación Java.

Vamos a ver un ejemplo de polimorfismo en Java con el uso de interfaces. En la definición de Polimorfismo tenemos:

El polimorfismo es un concepto de la programación orientada a objetos que nos permite programar en forma general, en lugar de hacerlo en forma específica. En general nos sirve para programar objetos con características comunes y que todos estos compartan la misma superclase en una jerarquía de clases, como si todas fueran objetos de la superclase. Esto nos simplifica la programación.

No nos vamos a enfocar mucho en la teoría sino en la parte práctica. Vamos a usar una interfaz para aplicar el concepto de polimorfismo.

Primero creamos un proyecto Java en Eclipse. y vamos a crear en el src el package llamado com.practica.polimorfismo.

Ahora vamos a crear la clase Figura.java que contendrá el siguiente código:

publicclass Figura  {

private String nombre;

private String color;

public Figura(String nombre) {

super();

this.nombre = nombre;

}

public Figura(String nombre, String color) {

super();

this.nombre = nombre;

this.color = color;

}

public String getNombre() {

return nombre;

}

publicvoid setNombre(String nombre) {

this.nombre = nombre;

}

public String getColor() {

return color;

}

publicvoid setColor(String color) {

this.color = color;

}

}

Esta va a ser nuestra super clase de la cual heredarán otro tipo de figuras. Esta clase es simplemente un POJO que tiene el nombre y el colo de la figura y sus getters y setters y dos constructores, aunque solo usaremos uno.

Ahora vamos a crear una interfaz. En Eclipse nos vamos a File -> New -> Other -> Interface. La interfaz se llamara OperacionesFigura.java Esta interfaz contendrá el siguiente código:

package com.practica.polimorfismo;

publicinterface OperacionesFigura {

      double calcularArea();

Figura figura();

}

Básicamente la interfaz tendrá dos métodos. Uno es el método calcularArea() que devolverá un double con el valor del área de la figura, y otro método que nos devolverá todo el objeto Figura. Como sabemos cada figura tiene diferente forma de calcular el área, pero todas tienen esta característica por eso las figuras que implementen esta interfaz deberán implementar estos dos métodos.

Ahora vamos a crear la clase Triángulo.java. Esta clase va a extender o heredar de Figura y a implementar la interfaz OperacionesFigura.

package com.practica.polimorfismo;

publicclass Triangulo extends Figura implements OperacionesFigura {

privatedouble base;

private Double altura;

public Triangulo(String nombre, String color, double base, Double altura) {

super(nombre, color);

this.base = base;

this.altura = altura;

}

@Override

publicdouble calcularArea() {

return (base * altura) / 2;

}

publicdouble getBase() {

return base;

}

publicvoid setBase(double base) {

this.base = base;

}

public Double getAltura() {

return altura;

}

publicvoid setAltura(Double altura) {

this.altura = altura;

}

@Override

public Figura figura() {

return new Figura(getNombre(), getColor());

}

}

Triangulo.java tendrá los atributos propios de un triángulo que son base y altura y además los atributos de la super clase Figura, es decir el nombre y el color. Aquí al implementar la interfaz tenemos el método calcularArea() que es base * altura dividido para 2, en el método figura retornamos una nueva Figura obteniendo el nombre y el color de la super clase. Además tenemos un constructor con todos los atributos de Triangulo y de la super clase Figura.

Ahora aplicamos lo mismo a otra figura. Creamos la clase Circulo.java:

package com.practica.polimorfismo;

importstatic java.lang.Math.*;

publicclass Circulo extends Figura implements OperacionesFigura {

privatedouble radio;

public Circulo(String nombre, String color, double radio) {

super(nombre, color);

this.radio = radio;

}

/*

* (non-Javadoc)

*

* @see com.practica.polimorfismo.OperacionesFigura#calcularArea()

*/

@Override

publicdouble calcularArea() {

returnPI * pow(radio, 2);

}

publicdouble getRadio() {

return radio;

}

publicvoid setRadio(double radio) {

this.radio = radio;

}

@Override

public Figura figura() {

returnnew Figura(getNombre(), getColor());

}

}

Tiene la misma estructura que Triangulo. En este caso tiene como atributo el radio del círculo y en calcularArea() aplicamos la fórmula del área del círculo.

Una vez realizado esto vamos a ver cómo ejecutar estos procedimientos. Para ello creamos la clase CalcularOperacionesFigura.java que contendrá el siguiente código:

package com.practica.polimorfismo;

import java.util.ArrayList;
import java.util.List;

public class CalcularOperacionesFigura {

/**
* @param args
*/

public static void main(String[] args) {
OperacionesFigura of = new Triangulo(“Triangulo”, “Azul”, 15.0, 3.0);
OperacionesFigura of2 = new Circulo(“Circulo”, “Verde”, 12.3);
List<OperacionesFigura> lista = new ArrayList<OperacionesFigura>();
lista.add(of);
lista.add(of2);

calcularArea(lista);
}

public static void calcularArea(List<OperacionesFigura> listaOperacionesFiguras) {
for (OperacionesFigura of : listaOperacionesFiguras) {
System.out.println(“Area es:  ” + of.calcularArea());
System.out.println(“Nombre es: ” + of.figura().getNombre());
System.out.println(“Color es: ” + of.figura().getColor());
}
}

}

Analicemos un poco el código.

En el método main creamos una instancia de la interfaz OperacionesFigura y le decimos que es igual a new Triángulo y llenamos los valores del constructor: nombre, color, base, altura. Podemos hacer esto porque Triángulo implementa OperacionesFigura. Luego hacemos lo propio para Circulo.java  y le instanciamos desde la interfaz.

Hecho esto creamos una lista genérica de la interfaz List<OperacionesFigura> lista, como es genérica solo se puede agregar a la lista objetos de tipo OperacionesFigura. Hecho eso agregamos a la lista las dos interfaces que instanciamos anteriormente

Ahora creamos un método que se llama calcularArea que recibe como parámetro una lista de interfaz de tipo OperacionesFigura. Luego con un foreach recorremos nuestra lista y accedemos a los métodos de la interfaz que son calcularArea() y figura() y de esa manera podemos obtener el área de la Figura que creamos en la instancia. Nótese que se accede a los métodos de la interfaz y no de Triangulo o Circulo. De esta manera la interfaz sabrá qué calculo debe hacer para obtener el área gracias a la implementación de la interfaz.

Este es un ejemplo sencillo de polimorfismo.

Para descargar el código fuente se puede ir a: http://mygnet.net/codigos/java/varios/ejemplo_de_polimorfismo_en_java.3541

En la primera parte les mostré cómo validar el RUC de una persona natural.  En la segunda parte les mostré cómo validar el RUC para persona jurídica o extranjera.  Ahora les mostraré cómo validar el RUC para empresas públicas.

RUC para empresas públicas

La estructura de este tipo de RUC se muestra en la siguiente figura:

RUC empresa públicaLa validación de este tipo de RUC se basa en el algoritmo de Módulo 11. Los coeficientes son: 3, 2, 7, 6, 5, 4, 3, 2.

El procedimiento es el siguiente:

  • Se multiplican los primeros nueve dígitos del RUC por cada uno de los coeficientes que le corresponde en la misma posición.
  • Se suma ese resultado.
  • Se divide ese resultado para el módulo, como este RUC es módulo 11, se divide la suma para 11, y se obtiene su residuo.
  • Se resta el módulo (en este caso 11) de el residuo de la división anterior.
  • El resultado es el dígito verificador. Si ese número coincide con el número del RUC de la posición 9 el RUC es correcto.

Excepción: Si el residuo es cero, el dígito verificador es cero.

Ejemplo:
Coeficiente:     3     2     7    6    5    4   3   2

RUC:                   1     7     6    0   0   0    1    5     5   0   0   0   1

Producto:         3   14   42   0   0   0   3   10   14

Sumatoria:        72

Residuo:             72 dividido para 11 da como respuesta 6, y como residuo 6.

Resta:                 11 – 6 = 5.

5 Es el dígito verificador.

El código es el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class ValidaRucEP {
 
	public static final int NUM_PROVINCIAS = 24;
 
	public static Boolean validaRucEP(String ruc) {
		final int prov = Integer.parseInt(ruc.substring(0, 2));
		boolean resp = false;
 
		if (!((prov &gt; 0) &amp;&amp; (prov &lt;= NUM_PROVINCIAS))) {
			resp = false;
		}
 
		// boolean val = false;
		Integer v1, v2, v3, v4, v5, v6, v7, v8, v9;
		Integer sumatoria;
		Integer modulo;
		Integer digito;
		int[] d = new int[ruc.length()];
 
		for (int i = 0; i &lt; d.length; i++) {
			d[i] = Integer.parseInt(ruc.charAt(i) + "");
		}
 
		v1 = d[0] * 3;
		v2 = d[1] * 2;
		v3 = d[2] * 7;
		v4 = d[3] * 6;
		v5 = d[4] * 5;
		v6 = d[5] * 4;
		v7 = d[6] * 3;
		v8 = d[7] * 2;
		v9 = d[8];
 
		sumatoria = v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
		modulo = sumatoria % 11;
		if (modulo == 0) {
			return true;
		}
		digito = 11 - modulo;
 
		if (digito.equals(v9)) {
			resp = true;
		} else {
			resp = false;
		}
		return resp;
	}
 
	public static void main(String[] args) {
		String ruc_dato = "1760001550001";
		if (validaRucEP(ruc_dato)) {
			System.out.println("El RUC es correcto");
		} else
			System.out.println("El RUC es incorrecto");
	}
}

Espero que les sirva.

Pueden descargarse el código fuente de esta explicación en el siguiente enlace:

Valida RUC Empresas Públicas del Ecuador
Valida RUC Empresas Públicas del Ecuador
ValidaRucEP.java
Version: 1.0
1.2 KiB
841 Downloads
Details

En la primera parte les mostré cómo validar el RUC de una persona natural. Ahora les mostraré cómo validar el RUC de una persona jurídica o extranjera.

RUC de persona jurídica o extranjera

La estructura de este tipo de RUC se muestra en la siguiente figura:

Estructura del RUC de persona jurídicaLa validación de este tipo de RUC se basa en el algoritmo de Módulo 11. Los coeficientes son: 4, 3, 2, 7, 6, 5, 4, 3, 2.

El procedimiento es el siguiente:

  • Se multiplican los primeros nueve dígitos del RUC por cada uno de los coeficientes que le corresponde en la misma posición.
  • Se suma ese resultado.
  • Se divide ese resultado para el módulo, como este RUC es módulo 11, se divide la suma para 11, y se obtiene su residuo.
  • Se resta el módulo (en este caso 11) de el residuo de la división anterior.
  • El resultado es el dígito verificador. Si ese número coincide con el número del RUC de la posición 10 el RUC es correcto.

Excepción: Si el residuo es cero, el dígito verificador es cero.

Ejemplo:
Coeficiente:     4     3     2    7   6   5   4   3   2

RUC:                   1     7     9    0   0   1    1    6     7   4   0   0   1

Producto:         4   21   18   0   0   5   4   18   14

Sumatoria:        84

Residuo:             84 dividido para 11 da como respuesta 7, y como residuo 7.

Resta:                 11 – 7 = 4.

4 Es el dígito verificador.

El código es el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public class ValidaRucSociedades {
 
	/**
	 * @param args
	 */
	private static final int NUM_PROVINCIAS = 24;
	// public static String rucPrueba = “1790011674001″;
	private static int[] coeficientes = { 4, 3, 2, 7, 6, 5, 4, 3, 2 };
	private static int constante = 11;
 
	public static Boolean validacionRUC(String ruc) {
		boolean resp_dato = false;
		final int prov = Integer.parseInt(ruc.substring(0, 2));
		if (!((prov &gt; 0) &amp;&amp; (prov &lt;= NUM_PROVINCIAS))) {
			resp_dato = false;
		}
 
		int[] d = new int[10];
		int suma = 0;
 
		for (int i = 0; i &lt; d.length; i++) {
			d[i] = Integer.parseInt(ruc.charAt(i) + "");
		}
 
		for (int i = 0; i &lt; d.length - 1; i++) {
			d[i] = d[i] * coeficientes[i];
			suma += d[i];
		}
 
		int aux, resp;
 
		aux = suma % constante;
		resp = constante - aux;
 
		resp = (aux == 0) ? 0 : resp;
 
		if (resp == d[9]) {
			resp_dato = true;
		} else {
			resp_dato = false;
		}
		return resp_dato;
	}
 
	public static void main(String[] args) {
		String ruc_dato = "1790011674001";
		if (validacionRUC(ruc_dato))
			System.out.println("El RUC es correcto");
		else
			System.out.println("El RUC es incorrecto");
	}
}

En la tercera parte les enseñaré a validar el RUC para empresas públicas.

Pueden descargarse el código fuente de esta explicación en el siguiente enlace:

Valida RUC Sociedades Ecuador
Valida RUC Sociedades Ecuador
ValidaRucSociedades.java
Version: 1.0
1.2 KiB
851 Downloads
Details

En este nuevo tutorial les voy a enseñar a validar el RUC ecuatoriano. La validación de la cédula del Ecuador lo pueden encontrar en el siguiente enlace: http://www.coplec.org/?q=2008/07/01/validador-de-c%C3%A9dula-ecuatoriana

Les puse ese enlace porque usaremos ese código para validar uno de los tres tipos de RUC que existen en el Ecuador.

Los tres tipos de RUC son:

  1. RUC de persona jurídica o extranjera.- Es del tipo 1790011674001
  2. RUC de persona pública (entidades estatales).- Es del tipo 1760001550001
  3. RUC de persona natura.- Es del tipo 1701300103001

Se mostrará la validación por partes según cada tipo de RUC.

RUC de personas naturales

La estructura de este tipo de RUC se muestra en la siguiente figura:

Estructura del RUC de persona naturalSu validación se explica a continuación:

  • El RUC de una persona natural será 13 dígitos, sin letras, sin caracteres especiales , únicamente números, de los cuales los 10 primeros será la cédula de identidad.
  • Las 2 primeras posiciones corresponden a la provincia donde fue expedida, por lo cual los dos primeros números no será mayor a 24 ni menor a 1.
  • El tercer dígito es menor a 6 ( 0,1,2,3,4,5 ).
  • Del cuarto al noveno dígito es un número consecutivo de 6 dígitos.
  • El décimo dígito es el dígito verificador.
  • Del décimo primer dígito al décimo tercer dígito, identifican en forma consecutiva el número de establecimientos. Empieza siempre con el 0001.

El número de RUC es: 1710034065001 independientemente del número de establecimientos que tenga el contribuyente, no existe un número de RUC tal como 1710034065002.

La validación de la cédula de Identidad pasa un algoritmo “Módulo 10″. Al número se lo divide en 13 partes, las 9 primeras son el número mismo, la 10 es el dígito autoverificador, y las 3 restantes indican si es principal o establecimiento adicional. Los coeficientes usados para verificar el décimo dígito de la cédula, mediante el algoritmo “Módulo 10″ son: 2.1.2.1.2.1.2.1.2

Como se ve en la imagen se usan los 9 primeros dígitos del RUC. Los números de las posiciones impares e multiplican por 2, y los números de las posiciones pares se multiplican por 1. Si el resultado de multiplicar por 2 es mayor a 9, se resta 9. Como en la figura, 12 – 9 = 3.

Luego se suman todos los valores del producto. En este caso la respuesta es 25.

Luego se resta este número de su decena superior. La decena superior a 25 es 30. Por lo tanto queda: 30 – 25 = 5.

Y 5 es el dígito verificador, si este número coincide con el décimo dígito del RUC la cédula es correcta.

Excepción: Si el resultado de la resta es 10, el dígito verificador será 0.

Usando el código de la página que les puse arriba y haciéndole una pequeña modificación, el resultado queda:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
public class ValidaCedula {
	private static final int NUM_PROVINCIAS = 24;
 
	public static Boolean validacionCedula(String cedula) {
		boolean isValid = false;
		if (cedula == null || cedula.length() != 10) {
			isValid = false;
		}
		final int prov = Integer.parseInt(cedula.substring(0, 2));
 
		if (!((prov &gt; 0) &amp;&amp; (prov &lt;= NUM_PROVINCIAS))) {
			isValid = false;
		}
 
		int[] d = new int[10];
		for (int i = 0; i &lt; d.length; i++) {
			d[i] = Integer.parseInt(cedula.charAt(i) + "");
		}
 
		int imp = 0;
		int par = 0;
 
		for (int i = 0; i &lt; d.length; i += 2) { 			d[i] = ((d[i] * 2) &gt; 9) ? ((d[i] * 2) - 9) : (d[i] * 2);
			imp += d[i];
		}
 
		for (int i = 1; i &lt; (d.length - 1); i += 2) {
			par += d[i];
		}
 
		final int suma = imp + par;
 
		int d10 = Integer.parseInt(String.valueOf(suma + 10).substring(0, 1)
				+ "0")
				- suma;
 
		d10 = (d10 == 10) ? 0 : d10;
 
		if (d10 == d[9]) {
			isValid = true;
		} else {
			isValid = false;
		}
 
		return isValid;
	}
 
	public static void main(String[] args) {
		String ruc_dato = "1710034065001";
		if (validacionCedula(ruc_dato.substring(0, 10)))
			System.out.println("El RUC es correcto");
		else
			System.out.println("El RUC es incorrecto");
	}
}

Una explicación del código. Hay una parte donde dice:

d[i] = ((d[i] * 2) > 9) ? ((d[i] * 2) – 9) : (d[i] * 2);

El uso del símbolo de pregunta ? es un equivalente al uso del if. Todo lo que está entre el ? y los dos puntos será lo que suceda en caso de ser verdadero, y lo que está después de los dos puntos sucederá en caso de ser falso.

Validar el ingreso del RUC de Ecuador en Java – Segunda parte

Validar el ingreso del RUC de Ecuador en Java – Tercera parte

Para conocer un poco más sobre la estructura del RUC pueden visitar el siguiente sitio: http://www.campvs.org/legislacion/index.php?option=com_content&task=view&id=18&Itemid=69

Si desean pueden descargarse el archivo en el siguiente enlace:

Valida Cedula del Ecuador
Valida Cedula del Ecuador
ValidaCedula.java
Version: 1.0
1.3 KiB
1147 Downloads
Details

Este es un programa que hicimos en la universidad. Está hecho en un applet de Java en Netbeans. Primero les explico cómo funciona este método de encriptación y desencriptación y luego el funcionamiento del programa.

El método de encriptación simétrica se llama así porque usa la misma clave para encriptar y desencriptar. La clave es un valor numérico.

Para entender cómo funciona vamos a usar un ejemplo.

El mensaje a encriptar será: HOLA MUNDO ES UNA FRASE COMUN y la clave va a ser 4.

Lo que hacemos es agrupar el texto en número de caracteres según la clave y formar una matriz. Así con esa frase y esa clave nos quedaría:

H   O   L   A
_   M  U  N
D   O   _   E
S   _   U   N
A   _   F    R
A   S   E    _
C   O   M   U
N  _    _    _

Para el ejemplo reemplacé los espacios con guiones bajos. Viendo esa frase en una línea sería:

HOLA | _MUN |DO_E | S_UN |A_FR | ASE_ | COMU | N_ _ _ |

Al último puse 3 guiones bajos para completar los 4 caracteres finales. Para encriptar la frase viendo la matriz vamos cogiendo los caracteres de la primera columna, luego de la segunda, etc, la frase nos queda:

H_DSAACN  -> Primera columna
OMO__SO_  -> Segunda columna
LU_UFEM_ -> Tercera columna
ANENR_U_ -> Cuarta columna

La frase encriptada completa nos queda:

H_DSAACNOMO__SO_LU_UFEM_ANENR_U_

Tomando en cuenta que los guiones bajos son en realidad espacios.

Ahora analizando el número de caracteres tenemos que la frase original tiene 29 caracteres incluyendo los espacios, mientras que la frase encriptada tiene 31 caracteres (no se toma en cuenta el último espacio).

Este dato necesitamos para el proceso de desencriptación. Para eso se parte de la frase encriptada y se divide el número de caracteres para la clave. Si el residuo es cero, la respuesta de la división es el número de filas de la matriz, si no es cero el número de filas de la matriz es la respuesta d ela división más uno.

Si dividimos 31 para 4 la respuesta es 7 con residuo 3, como no es exacta entonces el número de filas será 7 + 1 = 8. Quiere decir que debemos agrupar la frase encriptada en grupo de 8 caracteres así:

H_DSAACNOMO__SO_LU_UFEM_ANENR_U    -> Frase encriptada

H_DSAACN | OMO__SO_ | LU_UFEM_ | ANENR_U

Para formar la matriz cada grupo de caracteres es una columna de la matriz, nos queda por tanto:

H   O    L   A
_   M   U   N
D   O    _   E
S    _    U   N
A   _    F    R
A   S    E    _
C    O   M   U
N   _   _

Nuevamente volvemos a la matriz original y ya es cuestión de leer las filas en orden y se obtiene el mensaje desencriptado.

Esto es lo que haremos en el programa hecho en Java.

Lo pueden descargar del siguiente enlace: http://www.mygnet.net/codigos/java/criptografia/encriptacion_simetrica_con_metodo_matricial.3224

En este tutorial vamos a ver cómo manejar archivos XML usando el lenguaje de programación Java.

Para hacer este manejo se necesita un API que nos permita manipular archivos XML desde Java. La verdad existen muchos basta hacer una búsqueda en Google para encontrar varios API que nos permiten hacer eso.

Entre los muchos API que existen hay uno particularmente fácil de usar, cuando hacíamos este proyecto en la Universidad empezamos desde cero, el ingeniero solo nos envío a hacer un programa que manipule un archivo XML relacionado con un sistema de riego usando como lenguaje de programación Java y además almacene información en una base de datos de PostgreSQL al mismo tiempo, el único problema es que no sabíamos como hacer eso.

Fue así que di con estos API’s pero entre tantos no sabíamos cuál usar. Finalmente la mayoría de tutoriales nos llevaba a un API que parecía ser lo bastante fácil de manejar, así que lo escogimos, se llama JDOM y se lo puede bajar gratuitamente de la página http://www.jdom.org/

Aquí no vamos a explicar su funcionamiento completo, es más ni siquiera sé qué nomás permite este API. Así que nos limitaremos a lo básico: crear nuevos elementos en un archivo XML y los eliminaremos. Por cierto, con JDOM puedes hacer todo, desde crear un archivo XML desde cero, hasta manipular uno ya existente, incluyendo poder hacer consultas XPath.

En la parte de documentación de JDOM en http://www.jdom.org/docs/apidocs/ podrás conocer todos los componentes de este API.

Si buscas más información de este API aquí te dejo un buen tutorial que podría servirte: http://www.webtaller.com/construccion/lenguajes/java/lecciones/java-xml-jdom.php

Al descargarte el JDOM te vas a bajar un archivo comprimido ZIP, aquí tienes los archivos para bajarte: http://www.jdom.org/dist/binary/debes bajarte la última versión, ya sea en formato .zip o .tar.gz.

Para usarlo solo debes descomprimir este archivo en la ruta Classpath, es decir, donde están los archivos .class, yo trabajé con Netbeans así que descromprimí el archivo dentro de la carpeta build/classes.

Como había mencionado antes, el programa también hace un almacenamiento en una base de datos de PostgreSQL, para eso necesitamos el JDBC necesario que se lo puede descargar de http://jdbc.postgresql.org/ allí te bajarás un archivo .jar solo debes descomprimirlo en la misma ruta que el JDOM, es decir, en el Classpath.

Aquí no vamos a explicar el funcionamiento de JDOM ni el JDBC para conexión con Postgres, simplemente mostraremos el funcionamiento del programa. Existen gran cantidad de manuales en Internet que te podrían ayudar. Aquí solo se pretende ser una guía de lo que puedes hacer con JDOM.

El programa está hecho con NetBeans y desde la página de MyGnet te puedes bajar todo el programa y lo puedes abrir como Proyecto y ejecutarlo inmediatamente, o si no aquí te voy a dejar los archivos por partes para que los compiles creando un proyecto nuevo, ya sea usando NetBeans, Eclipse  o cualquier programa que te permita programar en Java.

Antes de ir a los códigos vamos a ver el programa funcionando. Antes cabe mencionar el hecho de que este programa fue hecho para manejar un archivo XML de un sistema de riego, modificando el código podemos manejar cualquier cualquier archivo XML.

El archivo XML que usaremos se llama RiegoVale.xml y contiene lo siguiente:

<?xml version=”1.0″ encoding=”UTF-8″?>
<SistemaRiego>
<tipo riego=”Inundacion”>
<Aplicacion>Cultivos de arroz</Aplicacion>
<CostoInicial>Bajo</CostoInicial>
<ConsumoEnergia>Baja</ConsumoEnergia>
<eficiencia>40%-65%</eficiencia>
<Descripcion>El agua es distribuida superficialmente sobre el terreno de regado</Descripcion>
</tipo>
<tipo riego=”Goteo”>
<Aplicacion>Cultivos de espaciamiento amplio</Aplicacion>
<CostoInicial>Alta</CostoInicial>
<ConsumoEnergia>Mediana</ConsumoEnergia>
<eficiencia>90%-95%</eficiencia>
<Descripcion>El agua es distribuida de manera localizada, por gotas, a traves de goteros instalados en mangueras de goteo.</Descripcion>
</tipo>
</SistemaRiego>

Esta es la primera pantalla que aparece al cargar el programa:

Clic en la imagen para ampliar

Clic en la imagen para ampliar

Luego debemos dar clic en “Abrir XML”, se nos cargará la siguiente pantalla:

Clic en la imagen para ampliar

Clic en la imagen para ampliar

Luego al dar clic en “Seleccionar” nos cargará la ruta del archivo en un Label de la página principal:

Clic en la imagen para ampliar

Clic en la imagen para ampliar

Luego al dar clic en Ejecutar, el contenido del archivo XML nos cargará en el área de texto:

Clic en la imagen para ampliar

Clic en la imagen para ampliar

Ahora vamos a realizar una consulta XPath a ese archivo XML. Para ello escribimos la consulta donde dice “Expresión XPath” y damos clic en consultar para ver el resultado:

Clic en la imagen para ampliar

Clic en la imagen para ampliar

Ahora para agregar un dato al archivo XML damos clic en el botón “Agregar Dato”:

Clic en la imagen para ampliar

Clic en la imagen para ampliar

Si habilitamos la casilla “Agregar a la base” los datos se almacenarán simultáneamente en la base de datos de PostgreSQL y en el archivo XML. Para este caso lo haremos solo en el archivo XML. Llenamos los datos y damos clic en el botón “Agregar”, un mensaje nos informará que los datos han sido agregados correctamente y volvemos a la pantalla inicial. Para ver los nuevos datos damos clic en “Ejecutar”:

Clic en la imagen para ampliar

Clic en la imagen para ampliar

Para eliminar un dato damos clic en “Eliminar dato” y aparece la siguiente pantalla:

Clic en la imagen para ampliar

Clic en la imagen para ampliar

Allí encontramos un combobox que contiene, en este caso, los tipos de riego y este dato lo obtiene del archivo XML, los carga desde ahí. No de la base de datos. Ahí al dar clic en “Eliminar” borrará el dato del archivo XML y si activamos la casilla lo borra también de la base de datos.

Finalmente tenemos la opción “Guardar en base”. Esta opción es muy útil. Vamos a suponer que tenemos la base de datos vacía y el archivo XML ya lleno, y lo que queremos es llenar la base de datos con lo que tenemos en el archivo XML, entonces usamos esta opción:

Clic en la imagen para ampliar

Clic en la imagen para ampliar

Ahí existe un combobox que tiene los tipos de riego que obtiene desde el archivo XML, seleccionamos el que queremos y damos clic en “Cargar datos” y en los campos de texto aparece la información, al dar clic en “Grabar” todos los datos quedan almacenados en la base de datos de PostgreSQL.

El proyecto está compuesto por tres archivos .java.

  • Conexion.java

Por medio de este archivo podemos crear la conexión a la base de datos de ProgreSQL. Además podemos ejecutar consultas sql. Para este caso dentro de este archivo tenemos las siguientes líneas de código:

this.driver =”org.postgresql.Driver”;
this.user=”postgres“;
this.pwd=”1234″;
this.cadena=”jdbc:postgresql://localhost:5432/baseRiego“;
this.con=this.crearConexion();

En mi caso yo tengo el usuario postgres, la contraseña 1234 y mi base de datos se llama baseRiego.  Debes cambiar los datos en tu caso de ser necesario.

Para descargarte el código fuente del archivo Conexion.java da clic en el siguiente enlace: http://cyberexplorador.files.wordpress.com/2009/08/conexion.pdf

Recuerda que para que te funcione correctamente este archivo y no te de error debes tener el JDBC en el ClassPath como lo expliqué anteriormente.

  • Ejemplo1.java y EscogerArchivo.java

Estos dos archivos nos permiten manipular los archivos XML con Java usando el API JDOM. Recuerda descomprimir el archivo .zip del JDOM dentro del classpath del proyecto para que estos archivos no te den error alguno.

Para descargarte el código fuente del archivo Ejemplo1.java da clic en el siguiente enlace:

http://cyberexplorador.files.wordpress.com/2009/08/ejemplo1.pdf

Para descargarte el código fuente del archivo EscogerArchivo.java da clic en el siguiente enlace:

http://cyberexplorador.files.wordpress.com/2009/08/escogerarchivo.pdf

Finalmente para que te funcione la base de datos, debes crear en PostgreSQL usando pgAdmin una base llamada, en este caso, baseRiego y dentro de ella crea una tabla usando el siguiente cógigo SQL:

create table Riego(
id_riego text not null primary key,
aplicacion_riego text,
costo_inicial text,
consumo text,
eficiencia text,
descripcion text
);

Puedes probar el programa con el archivo XML llamado RiegoVale.xml, el código lo puse más arriba.

Por cierto para probar las consultas XPath en ese archivo puedes usar de ejemplo estas dos consultas:

SistemaRiego/tipo[@riego=”Inundacion”]/Aplicacion
SistemaRiego/tipo/Aplicacion

También puedes decargarte todo el programa completo para que lo abras con NetBeans. Ahí están incluidos el JDOM y el JDBC. Solo ejecútalo con NetBeans y te funcionará. El enlace es:

http://mygnet.net/codigos/java/documentosxml/manipular_archivos_xml_desde_java.3041

Aquí te dejo una página web muy útil donde tienes 5 ejemplos muy interesantes sobre lo que puedes hacer con JDOM:

http://cubo.uc3m.es/ttlsoc/p5/

Espero que haya sido útil el programa. Cualquier duda no olvides hacerla.

Ah por cierto antes que me olvide. Este programa fue un proyecto de la universidad y lo hicimos entre cuatro compañeros, y para que no digan que violo derechos de autor =) aquí dejo los nombres y los correos de quienes participamos:

Hugo Mora     ==> cyberexplorador.ec@gmail.com
Ángel Chiluisa  ==> angels77._mani@hotmail.com
Gabriel Reyes  ==> g_alejo06@hotmail.com
Pablo Yacelga  ==> yacemiller2324@hotmail.com

create table Riego(

id_riego text not null primary key,

aplicacion_riego text,

costo_inicial text,

consumo text,

eficiencia text,

descripcion text

);

Yo he usado los dos entornos de programación para Java. La diferencia más notable es la velocidad de cada programa. Netbeans es demasiado lento y consume muchos recursos, pero es mucho más potente. Eclipse es más liviano, sin embargo, siempre es necesario descargar plugins para poder adaptarlo a nuestras necesidades a la hora de programar.

Este tema no se centra en dar pros y contras del Netbeans o del Eclipse.  Ambos entornos son muy buenos, pero es verdad que requieres una máquina más potente para Netbeans. Yo con mis 512 MB en RAM tuve problemas para trabajar con la versión 6.5. Así que dejé instalada la versión 6.1. Ahora estoy utilizando también el Eclipse, que aunque no tiene una interfaz tan atractiva es un prograama muy bueno.

Ahora deja tu voto por la interfaz que más te gusta, y no olvides dejar también un comentario. Siempre puede ser útil para los demás usuarios. Cuéntanos tu experiencia con cualquiera de los dos entornos de programación Java (y más lenguajes) que además de ser poderosos tienen algo en común que los hace imprescindible para cualquiér programador: son de código abierto y GRATIS.

[polldaddy poll=1505343]

Para ejecutar y compilar el presente programa se usa el mismo método que se explicó en este artículo.

Así que aquí abreviaremos algunos detalles.

Primero debemos descargarnos el archivo que contiene el código IDL:

Descargar el archivo PDF que contiene el código IDL

Copiamos el contenido y lo pegamos en un Bloc de notas, y guardamos el archivo con el nombre prueba.idl.

Luego descargamos el archivo que contiene el código del Cliente:

Descargar archivo PDF que contiene el código del Cliente en Java.

Copiamos el contenido y lo pegamos en un Bloc de notas, y guardamos el archivo con el nombre EjemploCliente.java.

Luego descargamos el archivo que contiene el código del Cliente:

Descargar archivo PDF que contiene el código del Servidor en Java.

Copiamos el contenido y lo pegamos en un Bloc de notas, y guardamos el archivo con el nombre EjemploServidor.java.

Como el presente programa tiene dos interfaces tenemos dos implementaciones. Cabe decir que esta calculadora hace las siguientes operaciones:

La primera interfaz:

  1. Un número elevado a la potencia 5.
  2. Raíz cuadrada de un número.

La segunda interfaz:

  1. Establece si un número es par o no.
  2. Establece si un número es primo o no.

Entonces la pregunta es ¿por qué el presente artículo dice “Calculadora usando Corba mediante Java usando dos interfaces”. Porque primero era una calculadora que hacía las operaciones básicas y luego la editamos. Así que tú puedes establecer qué operaciones quieres que haga la aplicación y agregar el número de interfaces que necesites. Por cada nueva interfaz deberás agregar un archivo de implementación.

Continuamos…

Ahora nos vamos a descargar la implementación para la primera interfaz:

Descargar el archivo PDF que contiene la implementación para la primera interfaz.

Copiamos el contenido y lo pegamos en un Bloc de notas, y se guarda el archivo con el nombre de CalculadoraImpl.java.

Ahora nos vamos a descargar la implementación para la segunda interfaz:

Descargar el archivo PDF que contiene la implementación para la segunda interfaz.

Copiamos el contenido y lo pegamos en un Bloc de notas, y se guarda el archivo con el nombre de ParidadImpl.java.

Para compilar los archivos usamos los siguientes códigos:

$idlj -fall prueba.idl

$javac CalculadoraImpl.java

$javac ParidadImpl.java

$javac EjemploCliente.java

javac EjemploServidor.java

Finalmente para ejecutar el programa se compila por medio del Símbolo del Sistema usando el siguiente código:

$tnameserv -ORBInitialPort 2000

$java EjemploServidor -ORBInitialHost localhost -ORBInitialPort 2000

$java EjemploCliente -ORBInitialHost localhost -ORBInitialPort 2000

Espero que les sirva el programa. Cualquier duda no olviden dejarla aquí.

Vamos a realizar una aplicación bastante sencilla de Corba.

La aplicación contendrá un archivo IDL, un archivo de servidor y uno de cliente.

El programa lo que hará es ir contando el número de veces que un cliente accede al servidor, cuenta hasta 5 clientes y luego empieza en forma inversa.

Para poder realizar y ejecutar este programa necesitaremos un editor de texto (Bloc de notas está bien) y el JDK de Java, que lo puedes descargar de http://www.java.com/es/

Compilación del programa

Primero vamos a descargarnos el programa que contiene el código del IDL:

Descargar archivo PDF con el código del IDL

Debemos copiar el contenido desde ese archivo y pegarlo en un Bloc de Notas, y guardamos el archivo con el nombre de count.idl.

Ahora vamos a descargarnos el programa que contiene el código Java del Cliente:

Descargar archivo PDF con el código del Cliente

Copiamos el contenido de ese archivo y lo pegamos en el Bloc de Notas, y guardamos el archivo con el nombre de CountClient.java.

Y finalmente nos descargamos el programa que contiene el código Java del Servidor:

Descargar archivo PDF con el código del Servidor

Copiamos el contenido de ese archivo y lo pegamos en un Bloc de Notas, y guardamos el archivo con el nombre de CountServer.java.

Una vez creados los tres archivos debemos compilarlos. Pero para eso debemos ubicar los 3 ficheros en la carpeta que contiene del JDK de Java, por lo general la ruta es:

C:Archivos de programaJava

Yo tengo el JDK 1.6.0_07 y dentro de esa ruta encontramos la carpeta llamada Bin, ahí pegamos los tres archivos. Es decir, en mi caso, la ruta final sería:

C:Archivos de programaJavajdk1.6.0_07bin

Una vez ahí los vamos a compilar. Abrimos un “Símbolo del sistema y nos ubicamos en esa ruta. Basta con pegar en el Símbolo del sistema lo siguiente (en mi caso):

cd C:Archivos de programaJavajdk1.6.0_07bin

La ruta mostrará lo siguiente:

C:Archivos de programaJavajdk1.6.0_07bin>

A esta última ruta la vamos a abreviar con el símbolo de dólar $.

Compilaremos primero el archivo IDL, luego el servidor y luego el cliente; usando los siguientes códigos, respectivamente:

$idlj -fall count.idl

$javac CountClient.java

$javac CountServer.java

Si sale el siguiente mensaje:

Note: .CounterCountPOA.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

Significa que hay que volver a compilar el archivo.

Para entender mejor lo mostraremos en el siguiente gráfico:

Compilar los archivos desde Símbolo del Sistema

Compilar los archivos desde Símbolo del Sistema

Al compilar el archivo IDL se creará una carpeta llamada Counter, que contendrá ciertos archivos auxiliares.  Al compilar los archivos Java se crean unos archivos Class.

Ejecución del programa

Para ejecutar el programa necesitamos tener abiertas tres ventanas del Símbolo del sistema. La primera iniciará el puerto, la segunda ejecutará el servidor y la tercera el cliente. El código para ejecutarla es, respectivamente:

$tnameserv -ORBInitialPort 2000

$java CountServer -ORBInitialHost localhost -ORBInitialPort 2000

$java CountClient -ORBInitialHost localhost -ORBInitialPort 2000

Se deben ejecutar cada uno en diferente ventana del Símbolo del sistema y en ese orden.

Espero que les sirva el programa. Es muy simple pero ayuda a entender el funcionamiento de Corba.

Polls

¿Qué lenguaje de programación utilizas más?

View Results

Loading ... Loading ...
Síguenos en Twitter
Cyberexplorador en Twitter
Comparte este blog
Bookmark and Share
Publicidad
Follow

Get every new post on this blog delivered to your Inbox.

Join other followers: