Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Temas - Expermicid

Páginas: [1] 2 3 ... 10
1
Redes y antenas / Introduccion al diseño de lan
« en: Enero 26, 2016, 10:46:16 pm »
Pequeño pdf con una introduccion sobre diseño de lan.
En donde se explica el modelo de redes jerarquicas y sus beneficios. Consideraciones para los switches de redes jerarquicas, caracteristicas de cada uno de ellos dependiendo de la capa y algunas otras cosas mas.



Descarga: https://mega.nz/#!pxRG1YYB!1xGjUarmNJL_fv_K0dKc4mJGM1UGOq8iSdCW7ytODE4

3
Criptografía / Proteger confidencilidad de mails con PGP
« en: Agosto 25, 2015, 01:21:31 pm »
Buenas a todos!!!

El siguiente post detallará los pasos a seguir para poder configurar lo necesario y así poder mandar mail protegidos por PGP.
Para una introducción sobre PGP los invito a pasar primeramente por este post de Cl0udswX.

Para comenzar necesitaremos instalar los siguiente paquetes: thunderbird o icedove y enigmail.

Configurando Icedove

Al ejecutar Icedove por primera vez podremos configurar la dirección de correo, ya sea crear un nueva o utilizar una ya existente. En caso de no querer hacerlo ahora lo podremos hacer más adelante.
En mi caso presionamos “Omitir esta etapa y utilizar mi dirección existente”.


Colocamos los datos de nuestra cuenta y por último presionamos "Finalizado"


En este punto ya vamos a poder utilizar nuestro correo para mandar y leer mails comunes.


Configurando Enigmail

Vamos al menú Enigmail > Asistente de Configuración.
Dejamos seleccionado "Si, deseo que me ayude el asistente" y presiono "Siguiente"


Elegimos el modo en que queremos que se cifren los mensajes (automático, siempre por defecto, nunca por defecto) según el gusto de cada uno.


Definimos si queremos que los mail se firmen por defecto o no.


En este paso nos dará la posibilidad de crear las claves para PGP o utilizar unas existentes en el caso de tenerlas.


Antes de finalizar nos mostrará las acciones que se van a realizar dependiendo de lo que hayamos elegido.
Presionamos "Siguiente".


En la generación de la clave nos va a pedir una contraseña y luego nos avisa que el proceso puede tardar algunos minutos y que para acelerarlo nos recomienda navegar por internet o que hagamos un uso intensivo del disco.


Al finalizar la generación de la clave se nos da la posibilidad de crear un certificado de renovación. Dicho certificado puede usarse para invalidad nuestra clave.



Ya tenemos configurado Enigmail.


Mandando mails cifrado y firmados

Para utilizar las opciones empezamos a escribir un mail y podemos elegir firmar y/o cifrar desde el menú "Enigmail" o desde los botones


Un mail cifrado se ve así.


Para decifrarlo debemos utilizar nuestra clave privada que elegimos en la creación de la clave pública.

Saludos

4
Redes y antenas / Nagios
« en: Junio 08, 2015, 07:36:14 pm »

Nagios es una herramienta de código libre orientada a la supervisión automática y continua de Infraestructura IT.

Algunas de las características que tiene son:

  • Monitoreo de Servicios de Red
  • Monitoreo de Host y sus recursos como CPU, Memoria, Discos, etc
  • Desarrollo de Plugins para el chequeo de una infinidad de plataformas y servicios
  • Capacidad de Services Checks en paralelo
  • Capacidad de Definir Host/Servicios padres o hijos, lo que permite detectar el origen del problema en caso de no ser de la propia máquina
  • Definición de Contactos para el envío de notificaciones
  • Capacidad de definir manejadores de eventos para el manejo de eventos de manera proactiva
  • Log de eventos
  • Interface Web para la visualización de estados de servicio, históricos, Archivo de Log, etc
  • Integración con herramientas que la comunidad ha desarrollado
  • Multiplataforma, aunque fue desarrollado originalmente para correr sobre Linux

La página oficial es https://www.nagios.org/.
Para probar dicha herramienta podemos descargarla desde la página, que nos provee el source o también máquinas virtuales ya preparadas.

Probando Nagios

Descargamos unas de las maquinas virtuales y utilizamos VMware o Virtual Box según conveniencia o gusto.


Podemos  loguearnos como root con la password 'nagiosxi'.
Para acceder a nagios, usamos un navegador e introducimos la ip que se nos detalla.


Entramos y vamos a necesitar ingresar algunos datos para la instalación.


Luego nos logueamos y por única vez tenemos que leer y aceptar los términos de la licencia.
Y ya podemos visualizar los diferentes menús y utilizarlos.


Saludos

5
E-Zines / The Original Hacker n° 13
« en: Mayo 04, 2015, 09:07:03 am »


STORED PROCEDURES

Descarga: Aqui

Saludos

6
Redes y antenas / Túnel IPv6 sobre IPv4
« en: Abril 25, 2015, 01:57:26 pm »
Buenas a todos!!!! Como andan?
Después de tanto tiempo, a mi me pareció una eternidad, vengo a hacer una pequeña contribución.

Primero que nada definamos lo que es un túnel:

Wikipedia:

Citar
Se conoce como túnel o tunneling a la técnica que consiste en encapsular un protocolo de red sobre otro (protocolo de red encapsulador) creando un túnel de información dentro de una red de computadoras. La técnica de tunelizar se suele utilizar para trasportar un protocolo determinado a través de una red que, en condiciones normales, no lo aceptaría. Otro uso de la tunelización de protocolos es la creación de diversos tipos de redes privadas virtuales.

En el siguiente aporte se va a detallar como hacer para crear un Túnel de IPv6 sobre IPv4, mediante la web https://tunnelbroker.net/ que nos provee Hurricane Electric.


Hurricane Electric además ofrece una certificación de IPv6 como lo menciona Cl0udswX aquí

Vayamos a lo nuestro.

Creación de una cuenta

El requerimiento para poder crear el túnel es estar registrado en la web. Por lo tanto el primer paso es registrarse. Nos va a pedir datos personales como el usuario, nuestro nombre, un mail, el lugar donde vivimos y un teléfono.
Si no ha habido ningún problema nos mostrará el siguiente mensaje:

Citar
You have successfully registered for Hurricane Electric's free IPv6 tunnelbroker service.
Your account information should be arriving in your email ([email protected]) shortly.

If you have not received your account information within the next few hours, please contact us at [email protected] and include your username in the email.

Y recibiremos en un mail la contraseña.

Creando el túnel

Ya con nuestro usuario y contraseña nos logueamos.
En la parte centrar habrá un panel con las últimas noticias sobre actualizaciones y mantenimiento que se vayan produciendo en los túneles que ofrecen.
Del lado derecho podrán encontrar un conjunto de links sobre temas importantes
Y del lado izquierdo aparecerá un menú sobre la cuenta, que nos permitirá modificar los datos personales anteriormente ingresados y desloguearnos. Y abajo un menú de funciones de usuario, con las opciones Crear túnel regular, Crear túnel BGP y Escáner de puertos para IPv6. En nuestro caso vamos a centrarnos en “Crear túnel regular”.


Para la creación del túnel nos pide los siguientes datos:
  • IPv4, colocamos nuestra IP pública, que es la que nos especifica en el punto de abajo. En caso de colocar alguna IP errónea nos lanza una advertencia con la descripción del problema.
  • Servidor de túnel, tenemos la posibilidad de elegir de una lista amplia de servidores disponibles en diferentes lugares de Asia, Europa y América del Norte.
      
Cada uno elige según le convenga o le guste.
Y por último presionamos Crear Túnel.

Nuevamente si todo fue correcto se nos dirigirá a un nueva pantalla en donde en un primer plano vemos los datos del túnel creado.


Configuración del túnel

Por el momento solo hemos creado el túnel, ahora es necesario configurarlo en nuestra computadora.
La misma página, si ponemos en la solapa “Ejemplo de configuración” nos da la posibilidad de elegir nuestro sistema operativo y proveernos los comandos o pasos necesarios.


Por ejemplo para el caso de Windows no da una serie de comando para poner en consola. Para Ubuntu/Debian te da una serie de linear para agregar al archivo /etc/network/interface.

Testeando el túnel

Para testear nuestra conectividad vamos  a usar la página  http://test-ipv6.com/


Saludos

7
E-Zines / The Original Hacker n° 12
« en: Marzo 21, 2015, 10:57:21 am »


Objetos Recursivos. Categorías anidadas en Europe Engine.

Descarga: link

Saludos

8
Dudas y pedidos generales / [SOLUCIONADO] Interacción Jsp-Java
« en: Enero 23, 2015, 02:33:50 pm »
Buenas a todos!!!

Alguno que tenga conocimientos de Jsp, sabe si existe alguna forma de poder hacer una interacción entre algo desarrollado en jsp y alguna aplicación de escritorio en java en ambas direcciones.

Saludos

9
Manuales y libros / Sistemas Distribuidos - Tanenbau
« en: Enero 20, 2015, 12:12:58 pm »

Preparando resumenes para dar finales me tope con este libro que tenia guardado y se los comparto.

Descarga: https://mega.co.nz/#!oghFVTaC!LuX3aekxzqU8aOW5ekEhI14abZPlx7lVqzI6-k00n94

Saludos

10
Hacking ShowOff / [Xss] Pasionlibertadores
« en: Enero 08, 2015, 02:57:00 pm »



Web: http://www.pasionlibertadores.com/index.html
Vector: <img src=x onerror=prompt(1)>
Reportado: SI

Saludos

11
E-Zines / The Original Hacker n° 11
« en: Diciembre 31, 2014, 10:14:12 pm »
Despues de tanto tiempo sin postear nada xD Voy volviendo a las andadas.



Shana Tova - Edicion Especial
50 tips, tricks y hacks en php y howto para europio engine

Descarga: https://mega.co.nz/#!d4YQjKxY!qA_MM8Gw26umdbUvviRg91nedfx1J6ZQhVhXf4f0i3k

Fuente: http://www.originalhacker.org/

Saludos

12
Base de Datos / Explicación visual de los JOINs de SQL
« en: Noviembre 12, 2014, 12:25:33 pm »
Comparto este post porque me parecio bastante buena la ayuda que puede ser tener los digramas de Venn para entender los joins

--------------------------------------------------------------------------------

Hace ya algún tiempo, mientras aprendía a hacer consultas avanzadas a SQL a marchas forzadas, empecé a buscar información que me explicara mejor cómo funcionaban los JOINs de SQL. ¡Hay tantos! La verdad es que al principio, cuesta entenderlos bastante.

Pero entonces me topé con un artículo que el bueno de Jeff Atwood (creador de Stackoverflow) escribió allá por el 2007. Jeff, utiliza diagramas de Venn para explicar de manera muy concisa cada JOIN. Soy consciente de que mucha gente no busca en inglés por lo que me dije, ¿por qué no lo traducimos?

Si has intentado comprender cómo funcionan los JOINs y no acabas de entenderlos y, lo que es peor, dudas sobre qué JOIN usar, tan solo debes tener una imagen en mente. Con estos sencillos ejemplos, pretendo solo que te hagas a la idea de lo que un JOIN en concreto te devolverá.

Tengamos estas dos tablas como ejemplos:

Código: Text
  1. id nombre     id  nombre
  2. -- ------     --  ------
  3. 1  Homer      1   Marge
  4. 2  Bart       2   Homer
  5. 3  Marge      3   Spidercerdo
  6. 4  Maggie     4   Moe

Vamos a unir las tablas por el campo del nombre de distintas formas y vamos a ver cómo resultan.

Inner join

Código: MySQL
  1. SELECT * FROM TablaA
  2. INNER JOIN TablaB
  3. ON TablaA.nombre = TablaB.nombre

Código: Text
  1. id  nombre     id   nombre
  2. --  ------     --   ------
  3. 1   Homer      2    Homer
  4. 3   Marge      1    Marge


Un inner join produce únicamente el conjunto de registros que están tanto en la Tabla A como en la Tabla B.

Full outer join

Código: MySQL
  1. SELECT * FROM TablaA
  2. FULL OUTER JOIN TablaB
  3. ON TablaA.nombre = TablaB.nombre

Código: Text
  1. id    nombre     id    nombre
  2. --    ------     --    ------
  3. 1     Homer      2     Homer
  4. 2     Bart       null  null
  5. 3     Marge      1     Marge
  6. 4     Maggie     null  null
  7. null  null       3     Spidercerdo      
  8. null  null       4     Moe


Full outer join produce el conjunto de todos los recursos de la Tabla A y de la Tabla B, haciendo coincidir los registros de ambos lados si están disponibles. Si no hay coincidencias, el lado que falte, contendrá null.

Left outer join

Código: MySQL
  1. SELECT * FROM TablaA
  2. LEFT OUTER JOIN TablaB
  3. ON TablaA.nombre = TablaB.nombre

Código: Text
  1. id  nombre     id    nombre
  2. --  ------     --    ------
  3. 1   Homer      2     Homer
  4. 2   Bart       null  null
  5. 3   Marge      1     Marge
  6. 4   Maggie     null  null


Left outer join reproduce todos los registros de la Tabla A, con los registros completos (donde se pueda), de la Tabla B. Si no hay coincidencias en el registro, el lado derecho contendrá null.

Estas son las operaciones básicas que podemos hacer con JOIN. No obstante, vamos a ver algunos trucos para obtener otras partes de las tablas que nos puedan interesar.

Código: MySQL
  1. SELECT * FROM TableA
  2. LEFT OUTER JOIN TableB
  3. ON TableA.name = TableB.name
  4. WHERE TablaB.id IS null

Código: Text
  1. id  nombre     id     nombre
  2. --  ------     --     ------
  3. 2   Bart       null   null
  4. 4   Maggie     null   null


Para obtener los registros que solo estén en la Tabla A, pero no en la Tabla B, realizaremos el mismo left outer join, y excluimos los registros de la derecha que no queremos, con where.

Código: MySQL
  1. SELECT * FROM TablaA
  2. FULL OUTER JOIN TablaB
  3. ON TableA.nombre = TablaB.nombre
  4. WHERE TablaA.id IS null
  5. OR TablaB.id IS null

Código: Text
  1. id    nombre     id    nombre
  2. --    ------     --    ------
  3. 2     Bart       null  null
  4. 4     Maggie     null  null
  5. null  null       3     Spidercerdo
  6. null  null       4     Moe


En este caso, obtendremos los registros únicos de la Tabla A y de la Tabla B. Para lograrlo, ejecutamos el mismo full outer join, y luego excluimos los resultados indeseados de ambos lados con where.

Ten en cuenta que, aunque no están aquí incluidos por parecerme redundante, podemos cambiar LEFT por RIGHT si queremos darle la vuelta al gráfico, operando así con la tabla derecha como principal, en vez de la izquierda

Fuente: funcion13
Autor: Antonio Laguna

Saludos

13
Wargames y retos / Desafio Excepciones en java
« en: Noviembre 12, 2014, 09:52:08 am »
Buenas les dejo un pequeño desafío, bastante fácil sobre excepciones.


Objetivos:

Decir cuál sería la salida al siguiente código y por qué es esa salida, o por qué no es otra.

La idea del desafío es dar una primera respuesta sin tener que recurrir a ejecutar el código.

Usuarios que contestaron bien al desafio:

- fermino
- LKI

Saludos


14
E-Zines / The Original Hacker n° 10
« en: Noviembre 09, 2014, 01:49:37 pm »


Guia definitiva para montar un servidor GNU/Linux Profesional.

Guia ilustrada paso a paso para novatos y expertos.

Descarga: https://mega.co.nz/#!0wpxgJQa!bJLkfBxM0Dnd3S7O84CnfUpBApW2nK1_2mNpGhJm3gY

Fuente: http://www.originalhacker.org/

Saludos

15
Sobreescritura y sobrecarga de métodos son 2 conceptos que pueden parecer confusos pero veremos que en sí representan algo muy simple.

Debemos saber que estas propiedades de la Programación Orientada a Objetos nos traen algunas ventajas como por ejemplo la facilidad, extensibilidad y flexibilidad en el código.

Pero que son?

La sobrecarga y sobreescritura no son mas que dos conceptos aplicados al trabajo con métodos, específicamente en el uso que le queremos dar. Estos conceptos dependen principalmente de nuestra lógica de programación y el enfoque o forma de trabajo, depende de lo que queremos hacer. ¿Como así?, veamos de forma mas clara cada concepto.

Sobrecarga de métodos (Overloading)

En java sabemos que si ya declaramos una variable o un método con un nombre en especifico, no podemos declarar otra variable o método que se llame igual, sin embargo esta regla no aplica cuando usamos la Sobrecarga de métodos, ya que esta permite usar el mismo nombre del método pero solo si se tiene diferente firma, ¿firma?, cuando hablamos de la firma de un método, nos referimos a sus parámetros.

En resumen la sobrecarga permite declarar métodos que se llamen igual pero que reciban parámetros diferentes (no pueden haber 2 métodos con el mismo nombre y los mismos parámetros), por esta razón lo que define a que método se ingresa, son los argumentos que se envían como parámetros.

Anteriormente mencioné algo sobre la forma de trabajo o lógica de programación, esto es porque supongamos que yo quiero hacer sumas, pero mi programa debe sumar por aparte 2 números enteros o 2 números doubles, para esto tengo 2 opciones.

1. crear 2 métodos, uno llamado sumaEnteros(int a, int b) y otro sumaDoubles(double a, double b)

2. Aplicar el concepto de sobrecarga, donde aunque también vamos a crear 2 metodos, los vamos a llamar con el mismo nombre pero con diferentes parametros, sumar(int a, int b) y sumar(double a, double b) quedando algo como esto:

Código: Java
  1. public void sumar(int a, int b) {
  2.         int suma=a+b;
  3.         System.out.println("la suma es: "+suma);
  4. }
  5.      
  6. public void sumar(double a, double b) {  
  7.         double suma=a+b;
  8.         System.out.println("la suma es: "+suma);
  9. }

Podemos ver que los 2 métodos se llaman igual pero poseen parámetros diferentes, así cuando sean llamados, dependiendo del parámetro enviado se accede al método.

Y no es igual? para que sobrecargar si en ultimas se crea el mismo numero de métodos? 

La pregunta anterior es muy valida y tiene mucha lógica, pero como en otros casos la respuesta también gira en torno a la facilidad, las buenas practicas y la búsqueda de aplicaciones optimizadas. El ejemplo es muy simple y poco complejo, pero imaginemos una aplicación donde se tenga la misma acción pero con procesos diferentes?

Por ejemplo encender un motor y si tenemos diferentes tipos de encendido como el eléctrico, encendido térmico, encendido de combustión etc etc. donde los procesos son muy diferentes pero en ultimas el objetivo es el mismo, pero cada uno necesita ciertas características únicas para encender, aquí podríamos aplicar la sobrecarga para no preocuparnos por llamar los métodos por su nombre sino tan solo llamando al mismo pero enviando los parámetros (características) propios de cada tipo de motor y listo, dependiendo de lo que mandemos java sabrá que motor queremos iniciar.

Sobreescritura de métodos (Overriding)

La Sobreescritura es la forma por la cual una clase que hereda puede re-definir los métodos de su clase Padre, de esta manera puede crear nuevos métodos con el mismo nombre de su superClase.

Es decir, si tengo una clase padre con el método ingresar() yo puedo crear en la clase hija un método que también se llame ingresar() pero implementándolo según lo que necesite (siguiendo obviamente unas reglas que veremos mas adelante) a esto se le llama sobreescritura.

Y para que? si cuando se hereda se pueden usar los métodos de la superClase sin tener que declararlos otra vez, entonces porque sobreescribirlos?

Esta pregunta es muy común, la respuesta es que también depende de lo que queremos hacer, si lo que queremos es extender una funcionalidad por medio de la herencia y si bien, en la clase padre existe el método ingresar(), el método y la lógica que tenga es propia de esa clase, si yo quiero vincularle algo mas a ese método pero que sea especifico para la clase hija, no podría, ya que tendría que modificarlo en la clase padre y de esta manera ya se perdería el enfoque como tal, pues dicha funcionalidad sería común para todas las clases hijas que hereden de la superClase.

Por la razón anterior, la sobreescritura nos permite extender la funcionalidad de un método heredado para hacerlo especifico a lo que necesitemos, pudiendo implementar la lógica que queramos en nuestras clases hijas para el mismo método.

Y cuales son las reglas?

Así como en la sobrecarga nos fijamos en los parámetros, en la sobreescritura nos debemos fijar en que la estructura del método sea igual a la de su superClase, no solo el mismo nombre sino el mismo numero de argumentos y tipo de retorno (o al menos un subtipo de este), así como no tener un nivel de acceso mas restrictivo que el original (que en la clase padre sea protected y en la hija sea private por ejemplo) tampoco se pueden sobreescribir métodos static ni final. (ya que static representa métodos globales y final constantes.)

Algo que también debemos mencionar es que podemos identificar un método sobreescrito cuando tiene la anotación @override, esto es muy común encontrarlo cuando trabajamos con clases abstractas o interfaces, donde se obliga a implementar los métodos de estas si son heredadas o implementadas respectivamente, sin embargo no es obligatorio ponerlo pero si  es recomendable, pues de esta manera el compilador reconoce que se están sobreescribiendo los métodos ayudando a que si nos equivocamos al crear un método distinto, el compilador nos avisaría. Adicionalmente si tenemos la anotación inmediatamente podremos saber que se está aplicando el concepto, algo muy útil cuando trabajamos con código de otras personas.

Veamos un ejemplo donde se sobreescribe el método tocar()

Código: Java
  1. Public class Instrumento{
  2.         public String tipo;
  3.  
  4.         public abstract void tocar() {
  5.                 System.out.println("Tocar un Instrumento");
  6.         }
  7. }
  8.  
  9.  
  10. class Guitarra extends Instrumento {
  11.         @Override        
  12.         public void tocar() {
  13.                 System.out.println("Tocar La Guitarra");
  14.         }
  15. }

Como vemos la clase Guitarra hereda de la clase Instrumento, esta ultima tiene el método tocar() con una implementación diferente a la del método en la clase Guitarra (el mensaje es distinto), al tener la anotación @Override nos damos cuenta que se está sobreescribiendo dicho método y se le puede dar la lógica que queramos especifica para la clase Guitarra.

Ingresar a uno u otro método depende de la lógica del llamado, también es algo muy ligado al polimorfismo donde por medio de este se puede acceder a uno u otro método, por ejemplo si queremos acceder al método tocar() de la clase guitarra aplicando la sobreescritura y el polimorfismo tendríamos que hacer una instancia de la clase padre con un objeto de la clase hija así:

Código: Java
  1. Instrumento miGuitarra=new Guitarra();
  2. miGuitarra.tocar();

con esto accederíamos al método tocar de la clase guitarra.

Conclusiones!!!

Como pudimos ver los 2 conceptos son muy similares pero con enfoques totalmente diferentes, en sí el concepto como tal no es confuso y a medida que se va conociendo de a pocos su aplicación tampoco lo será.

Y Listo!!!!! con esto vimos a nivel general lo que representan la sobrecarga y sobreescritura de métodos, recuerden que la forma de dominarles es la práctica y ver su comportamiento con diferentes ejercicios.

Fuente: codejavu

Saludos

16
Otros lenguajes / Online Compilation and Execution
« en: Octubre 24, 2014, 10:24:54 pm »

Compile Online es un pagina que permite compilar y ejecutar codigo en un gran variedad de lenguajes de forma online.

Link

Saludos

17
Java / Tipos y clases genéricos en Java
« en: Octubre 13, 2014, 02:15:42 pm »
Buenas a todos!!!

Para entender un poco este concepto veamos un ejemplo:

"Una fábrica de juegos de PC desea modelar un sistema de selección aleatoria de Jugadores (RandomSelector). Dado que la selección aleatoria se usa en muchos y variados juegos (p.e: selección aleatoria de números, de cartas, de colores, de fichas, etc.) se detallo que el RandomSelector debería ser diseñado de tal forma que se pueda usar con cualquier tipo de objetos.
El funcionamiento debería ser el siguiente: Una vez creado el RandomSelector con el tipo de Objeto que va a seleccionar este permanece así. Al RandomSelector se le pueden agregar N objetos a seleccionar. Cuando se le dice selectNext() retorna un objeto seleccionado de manera aleatoria."

En java, cuando se define una nueva clase, se debe conocer el tipo de datos con el que se trabajará. Pero en este caso necesitamos que sea independiente al tipo de datos, y así poder reutilizar la clase sin necesidad de hacer alteraciones al código.
Es aquí donde entra el concepto de tipos genéricos.

La utilización seria:

Código: Java
  1. public class RandomSelector<T> {
  2.  
  3. }

T es un tipo genérico que será sustituido por el tipo real cuando se instancie la clase.
Al RandomSelector se le podía agregar N objetos, vamos a necesitar hacer uso de alguna colección para ir guardando los objetos.

Código: Java
  1. import java.util.ArrayList;
  2. import java.util.Random;
  3.  
  4. public class RandomSelector<T> {
  5.  
  6.         private ArrayList<T> elementos;
  7.         private Random rn;
  8.        
  9.         public RandomSelector() {
  10.                 this.elementos = new ArrayList<T>();
  11.                 this.rn = new Random();
  12.         }
  13.  
  14. }

Verán como a la colección se le da como tipo de datos a T, el tipo genérico.
rn es de tipo Random, y nos va servir más adelante para la aleatoriedad.
Agregamos el método agregarElemento que recibe como parámetro un objeto de tipo T y lo agrega a la colección.

Código: Java
  1. public void agregarElemento(T elemento) {
  2.         this.elementos.add(elemento);
  3. }

Por otro lado, el método selectNext retorna un elemento de tipo T, y que es el que se ubica en la posición 'x' de la colección elementos. Dichas posición 'x' se obtiene con un numero aleatorio que va desde 0 al tamaño de la colección - 1

Código: Java
  1. public T selectNext() {
  2.         return this.elementos.get(rn.nextInt(this.elementos.size()));
  3. }

Probemos como funcionaría:

Código: Java
  1. public static void main(String[] args) {
  2.         RandomSelector<String> rS1 = new RandomSelector<String>();
  3.         rS1.agregarElemento("Piedra");
  4.         rS1.agregarElemento("Papel");
  5.         rS1.agregarElemento("Tijera");
  6.         System.out.println(rS1.selectNext());
  7.                
  8.         RandomSelector<Integer> rS2 = new RandomSelector<Integer>();
  9.         rS2.agregarElemento(1);
  10.         rS2.agregarElemento(2);
  11.         rS2.agregarElemento(3);
  12.         System.out.println(rS2.selectNext());
  13. }



Usamos un primer objeto RandomSelector con T = String y uno segundo con T = Integer. Y funcionó de igual manera sin importar el tipo

Por último existen una serie de convenciones para nombrar a los genéricos:
  • E – Element (usado bastante por Java Collections)
  • N – Number (para números)
  • K – Key (Llave, usado en mapas)
  • T – Type (Representa un tipo, es decir, una clase)
  • V – Value (representa el valor, también se usa en mapas)

Saludos

18
Java / Guía de colecciones en Java
« en: Octubre 12, 2014, 11:17:32 pm »
Lo que me motivó a escribir esta guía de colecciones en java es el inmenso tamaño del framework de colecciones que puede echar para a atrás a cualquier programador que se ponga a investigar las APIs sin ordenar un poco las ideas. Hay tantas interfaces e implementaciones que es fácil perderse y no saber que usar en cada momento.

Esta pequeña guía de colecciones en Java pretende explicar, de manera sencilla, que las colecciones en Java y que implementación sería mejor que usases para cada caso.

Este va a ser un post extenso, así que voy a ser tan amable de proporcionaros una pequeña tabla de contenidos.

1- Tipos de colecciones en java
  • Listas
  • Sets
  • Maps
  • Colas

2- Listas
  • ArrayList
  • LinkedList
  • Vector
  • CopyOnWriteArrayList

3- Sets

  • HashSet
  • LinkedHashSet
  • TreeSet
  • EnumSet
  • CopyOnWriteArraySet
  • ConcurrentSkipListSet

4- Maps
  • HashMap
  • LinkedHashMap
  • TreeMap
  • EnumMap
  • WeakHashMap
  • HashTable
  • ConcurrentHashMap

5- Colas
  • ArrayDeque
  • LinkedBlockingDeque
  • LinkedList
  • PriorityQueue
  • PriorityBlockingQueue

6- Diagramas de clases
  • Diagrama de clases: Listas
  • Diagrama de clases: Sets
  • Diagrama de clases: Maps
  • Diagrama de clases: Colas

7- Notas finales


Tipos de colecciones en Java

Los tipos de colecciones vienen representados por interfaces. Una serie de interfaces clasifica las colecciones de Java en los siguientes tipos:

- Listas: Una lista ordenada, o secuencia. Normalmente permiten duplicados y tienen acceso aleatorio (es decir, puedes obtener elementos alojados en cualquier índice como si de un array se tratase).
- Sets: Colecciones que no admiten dos elementos iguales. Es decir, colecciones que no admiten que un nuevo elemento B pueda añadirse a una colección que tenga un elemento A cuando A.equals(B).
- Maps: Colecciones que asocian un valor a una clave. Parecido a la estructura de “array asociativo” que se encuentra en otros lenguajes. Un Map no puede tener dos claves iguales.
- Colas: Colecciones que permiten crear colas LIFO o FIFO. No permiten acceso aleatorio, solo pueden tomarse objetos de su principio, final o ambos, dependiendo de la implementación.

Listas

La colección más básica de Java. También, es la más usada por los programadores que no han investigado el framework de colecciones a fondo por hacernos pensar que se trata de una especie de array hipervitaminado ya que hace su trabajo y es fácil de entender.

Sin embargo, por grande que sea la tentación de usar una lista (como un ArrayList) para todo, ¡has de resistir!

Sabiendo los requisitos de tu aplicación, seguramente encontrarás otra colección que haga el trabajo de una lista mejor. Procura asegurarte de que cuando vas a usar una lista es porque realmente te hace falta, no porque no conoces el resto. La diferencia de rendimiento puede ser enorme. Y cuando digo enorme, me refiero a superior a un 600% en según que operaciones.

¿Qué beneficios tienen las listas?

- Acceso aleatorio.
- Están ordenadas (Podemos usar Colections.sort() para ordenar los elementos siguiendo el criterio que queramos).
- Podemos añadir / eliminar elementos sin ninguna restricción.
- Tienen un iterador especial ListIterator que permite modificar la lista en cualquier dirección.
- Siguen la notación de los arrays, por lo que son fáciles de comprender.

¿Qué problemas tienen las listas?

- Bajo rendimiento en operaciones especialziadas respecto a otras colecciones.

A continuación voy a enumerar todas las listas de Java con sus características, además, daré una pequeña explicación de cuando deberíais usar esa lista.

Tipos de Lista
  • ArrayList: Muy rápida accediendo a elementos, relativamente rápida agregando elementos si su capacidad inicial y de crecimiento están bien configuradas. Es la lista que deberías usar casi siempre.
  • LinkedList: Una lista que también es una cola (hablaré de esto más tarde). Más rápida que ArrayList añadiendo elementos en su principio y eliminando elementos en general. Utilízala en lugar de ArrayList si realizas más operaciones de inserción (en posición 0) o de eliminación que de lectura. La diferencia de rendimiento es enorme.
  • Vector: Terreno peligroso. Vector es una colección deprecated (obsoleta), así que usadla únicamente si necesitáis un ArrayList concurrente. El rendimiento de Vector es superior al de Collections.syncronizedList(new ArrayList()).
  • CopyOnWriteArrayList: Colección concurrente que es muy poco eficiente en operaciones de escritura, pero muy rápida en operaciones de lectura. Usala sobre Vector (o synced ArrayList) cuando el número de lecturas concurrentes sea mucho mayor al número de escrituras.

Sets

Los sets, o conjuntos, son colecciones que por norma general no admiten elementos iguales en su interior. Como mencionaba antes, dos elementos A y B son iguales si A.equals(B).

Podemos añadir y eliminar elementos de un set, así como saber si determinado elemento está en un set, pero no tenemos acceso aleatorio, por lo que hay que tener muy claro cuando queremos usarlos.

Una colección normal, en apariencia, nos da todo lo anterior -excepto el hecho de eliminar duplicados-, así que, ¿por qué usar un Set y no una Lista?, el motivo es simple: eficiencia.

Supongamos este código:

Código: Java
  1. List b = new ArrayList();
  2.      
  3. if (!b.contains(1))
  4.     b.add(1);

La funcionalidad es la misma que la de set.add, pero el rendimiento es muchísimo peor, hasta el punto de que podemos tener problemas muy serios cuando añadamos muchos elementos y no queremos eso, ¿verdad?.

¿Qué beneficios tienen los sets?

- No permiten elementos duplicados.
- Implementación muy eficiente de .add para asegurarnos de que no hay duplicados.

¿Qué desventajas tienen?

- No tienen acceso aleatorio.
- Solo algunos tipos de set pueden ordenarse y lo hacen de forma poco eficiente.

¿Cuando deberíamos usar un set sobre una lista?, y ¿qué tipo de set?, veámoslo…

Tipos de Set

  • HashSet: La implementación más equilibrada de la interfaz Set. Es rápida y no permite duplicados, pero no tiene ningún tipo de ordenación. Utilízala si necesitas un control de duplicados pero no ningún tipo de ordenación o acceso aleatorio.
  • LinkedHashSet: Un HashSet que incluye ordenación de elementos por orden de entrada, una velocidad de iteración mucho mayor y un rendimiento mucho peor a la hora de añadir elementos. Utilizala si necesitas un Set ordenado por orden de inserción o si vas a usar un Set que vaya a realizar solamente operaciones de iteración.
  • TreeSet: Un set que incluye una implementación de un árbol rojo-negro. Este Set puede ser ordenado, pero su rendimiento es mucho peor en cualquier operación (menos iteración) respecto aun HashSet. Utilizalo solo si necesitas un Set con un criterio de ordenación específico y ten cuidado con las inserciones.
  • EnumSet: La mejor implementación de Set para tipos enumerados (Enum). Utilizala si quieres crear un Set de Enums.
  • CopyOnWriteArraySet: Set concurrente que tiene un gran rendimiento de lectura, pero pésimo de escritura, eliminado y contains. Úsalo solo en Sets concurrentes que apenas tengan estas operaciones.
  • ConcurrentSkipListSet: Set concurrente y ordenable. Utilizalo solo cuando requieras un Set ordenable (como TreeSet) en entornos de concurrencia. En Sets de tamaños muy grandes su rendimiento empeora notablemente.

Maps

Los maps son colecciones que asocian un valor con una clave. Tanto la clave como el valor pueden ser cualquier tipo de datos de Java: Objetos, primitivos, otras colecciones, etc.

Las implementaciones son muy parecidas a los Sets debido a que, internamente, utilizan un Set (la implementación varía según el tipo de Map) para garantizar que no hay elementos duplicados en las claves.

¿Que ventajas tienen los map?

- Asociación clave -> valor.
- Gracias a que utilizan internamente un Set, garantizan que no habrá dos claves iguales.
- Es fácil reconocer cuando necesitamos usar un Map.

¿Qué desventajas tienen los map?

- Rendimiento no muy elevado comparado con otras colecciones.

Tipos de Map
  • HashMap: La implementación más genérica de Map. Un array clave->valor que no garantiza el orden de las claves (de la misma forma que un HashSet). Si necesitas un Map no-concurrente que no requiera ordenación de claves, este es el tuyo. Si os fijais en el código de HashSet, veréis que curiosamente utiliza un HashMap internamente.
  • LinkedHashMap: Implementación de map que garantiza orden de claves por su tiempo de inserción; es decir, las claves que primero se creen serán las primeras. También puede configurarse para que la orden de claves sea por tiempo de acceso (las claves que sean accedidas precederán a las que no son usadas). Itera más rápido que un HashMap, pero inserta y elimina mucho peor. Utilizalo cuando necesites un HashMap ordenado por orden de inserción de clave.
  • TreeMap: Un Map que permite que sus claves puedan ser ordenadas, de la misma forma que TreeSet. Usalo en lugar de un HashMap solo si necesitas esta ordenación, ya que su rendimiento es mucho peor que el de HashMap en casi todas las operaciones (excepto iteración).
  • EnumMap: Un Map de alto rendimiento cuyas claves son Enumeraciones (Enum). Muy similar a EnumSet. Usadlo si vais a usar Enums como claves.
  • WeakHashMap: Un Map que solo guarda referencias blandas de sus claves y valores. Las referencias blandas hacen que cualquier clave o valor sea eligible por el recolector de basura si no hay ninguna otra referencia al mismo desde fuera del WeakHashMap. Usa este Map si quieres usar esta característica, ya que el resto de operaciones tienen un rendimiento pésimo. Comúnmente usado para crear registros que vayan borrando propiedades a medida que el sistema no las vaya necesitando y vaya borrando sus referencias.
  • HashTable: Map deprecated y concurrente. Básicamente, es un HashMap concurrente que no debes usar nunca. En su lugar, utiliza ConcurrentHashMap.
  • ConcurrentHashMap: Un Map concurrente que no permite valores nulos. Sustitución básica de HashTable. Usala si necesitas un HashMap concurrente.

Colas

Las colas son estructuras que ofrecen un gran rendimiento al obtener elementos de su principio o de su final, representando colas LIFO / FIFO, aunque también veremos colas ordenadas en función de otros criterios.

Deberás usar una cola cuando vayas a recuperar siempre el primer o último elemento de una serie. Se usan para implementar las mencionadas colas LIFO / FIFO, así como colas de prioridades (como puede ser un sistema de tareas o de procesos).

Cabe destacar que hay dos tipos de colas, Queues y Deques. Las primeras solo proporcionan métodos para acceder al último elemento de la cola, mientras que las Deques permiten acceder a cualquiera de los dos extremos.

¿Qué ventajas tienen las colas?

- Ofrecen un gran rendimiento al recuperar el primer o último objeto de la cola.
- Permiten crear estructuras LIFO / FIFO o colas de prioridades con muy buen rendimiento.

¿Qué desventajas tienen las colas?

- La iteración por las colas suele ser muy lenta.
- El acceso aleatorio, de la misma manera, es muy lento.

Tipos de colas
  • ArrayDeque: Una implementación de Deque de rendimiento excepcional. Implementa tanto cola LIFO como FIFO al ser una Deque y es la Cola que deberías usar si quieres implementar una de estas dos estructuras.
  • LinkedBlockingDeque: Una Deque concurrente que has de usar cuando quieras usar un ArrayDeque en entornos multihilo.
  • LinkedList: LinkedList, anteriormente mencionada en la sección de listas, también es una Deque, sin embargo, su rendimiento es muy inferior al de ArrayDeque. No deberías usar LinkedList cuando quieras usar una cola.
  • PriorityQueue: Una cola que se ordena mediante un Comparator, permitiendo crear una Cola donde el primer elemento no dependerá de su tiempo de inserción, sino de cualquier otro factor (tamaño, prioridad, etc). Deberemos usarlo cuando necesitemos este comparator, ya que ArrayDeque no lo permite.
  • PriorityBlockingQueue: La versión concurrente de PriorityQueue.

Diagramas de clases

Para entender mejor el framework de colecciones, nada como un diagrama de clases de todas los tipos de colección. He aquí dicho diagrama, por cortesía de karambelkar.info:

Diagrama de clases – List


Diagrama de clases – Set


Diagrama de clases – Maps


Diagrama de clases – Colas


Notas finales

A la hora de usar colecciones en Java, lo más importante es elegir el tipo de colección. Cuando trabajemos con colecciones, siempre declararemos las instancias con el nombre de su interfaz, aprovechando el enlace dinamico.

De esta forma, aunque la implementación cambie en el futuro, podemos tener claro que la aplicación no va a dar fallos (ya que estamos usando las interfaces y estas tienen los métodos que usan sus implementaciones).

A la hora de escoger la implementación de cada tipo de colección, debéis fijaros en dos cosas:

- Si estamos trabajando en un entorno concurrente o no.
- En el rendimiento de las operaciones que vamos a necesitar en las distintas implementaciones válidas para nuestro entornos (concurrentes o no).

Sabiendo eso ya podréis empezar a explotar a fondo el Framework de colecciones en Java y no limitaros a usar las colecciones Vanilla, mal de muchos programadores que empiezan en este lenguaje.

Confío en que la lectura haya sido interesante y fructífera, para mi lo ha sido, por lo menos.

Fuente: luaces-novo

Saludos

19
Java / Introducción a las aplicaciones Web con JAVA
« en: Octubre 12, 2014, 10:01:50 pm »

Escrito por: Macario Polo y Daniel Villafranca

Contenido:

Introducción a la tecnología WEB con J2EE
Introducción a JSP
EJBs
Algunos ejemplos
Ejercicios prácticos

Descarga: https://mega.co.nz/#!pkoBEYZC!dJ_XXs35E8VQ1otspUlfpPpU5hr_vNYm67DMePq6X6Y

Saludos

20
Java / Como crear una Aplicación WEB con Java
« en: Octubre 08, 2014, 05:19:34 pm »
Voy a crear una aplicación WEB con Java desde cero usando Eclipse

Es necesario tener un servidor web o de aplicaciones a la mano para poder ejecutarlo, puede ser tan simple como un Tomcat, o si gustan un JBoss, Glassfish, o en mi caso como trabajo diariamente con el Oracle WebLogic.

La idea de esto es que puedan ver paso a paso como se crea la aplicación WEB, como se crea un Servlet(Una aplicación puede tener infinidad de estos), como sobreescribir los métodos de acción doGet y doPost y como llamar la ejecución de estos.

Paso 1. crear el proyecto


Paso 2. Definir el nombre del proyecto y el servidor en el cual este se deploya


Paso 3: Si se requiere algún otro directorio con archivos .class este seria el momento ideal para hacerlo, se puede hacer después , no hay ningún problema


Paso 4: Pongamole un contexto a nuestra aplicación, en mi caso el contexto será /MiAplicacionWeb


Bueno con esto nuestro proyecto WEB ya esta listo ahora vamos a probarlo.
No pongo como crear un paquete pero metí un paquete llamado servlets en mi carpeta de src.
Ahora vamos a crear el Servlet.

Paso 1: Busco en el menú desplegable la creación de mi servlet.


Paso 2: Indico el nombre de la clase que ejecutará el Servlet


Paso 3: El Mapéo del Servlet, osea como lo voy a llamar desde mi explorador


Paso 4: ¿Qué métodos ejecutará mi Servlet? Bueno lo normal es un doGet y un doPost. Solo por cultura general de las aplicaciones web, el protocolo HTTP soporta 7 métodos GET, POST, TRACE, PUT, OPTIONS, DELETE, HEAD, de los cuales tienen muchas funcionalidades pero sigamos con los nuestros GET y POST


Perfecto ya con esto esta listo nuestro mapeo de Servlet ademas de que tenemos nuestra clase con los métodos sobreescritos de doGet y doPost el doGet es para cuando entremos desde el navegador ( En mi caso http://localhost:7001/MiAplicacionWeb/MiServlet ). Además de esto ya implemente una impresión con un OutputStream de mi servlet para que pueda imprimir “Hola mundo, Servlet”

Código: Java
  1. package servlets;
  2.  
  3. import java.io.IOException;
  4. import javax.servlet.ServletException;
  5. import javax.servlet.http.HttpServlet;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  8.  
  9. /**
  10.  * Servlet implementation class MiServlet
  11.  */
  12. public class MiServlet extends HttpServlet {
  13.         private static final long serialVersionUID = 1L;
  14.  
  15.     public MiServlet() {
  16.         super();
  17.     }
  18.  
  19.         protected void doGet(HttpServletRequest request,
  20.                    HttpServletResponse response)
  21.                    throws ServletException, IOException {
  22.                 ServletOutputStream out=response.getOutputStream();
  23.                 out.println("Hola mundo, Servlet!");
  24.                 out.flush();
  25.                 out.close();
  26.         }
  27.  
  28.         protected void doPost(HttpServletRequest request,
  29.                    HttpServletResponse response)
  30.                    throws ServletException, IOException {
  31.  
  32.         }
  33.  
  34. }
  35.  

Una vez llamado el servlet desde mi navegador se verá lo siguiente:


¿Sencillo verdad? Si necesitan que les explique algo mas en especifico no duden en publicar su pregunta, será respondida en cuanto la vea

Ahora unos ejemplos de uso para el método doGet y doPost:

En el caso de doGet es cuando se llama la aplicación desde la URL, este llamado puede contener parámetros la sintaxis es la siguiente

http://servidor:puerto/contextoAplicacion/Servlet?parametro1=texto1&parametro2=texto2

el símbolo ? es para iniciar los parámetros y el & es para separarlos.

En el ejemplo anterior le enviaré el siguiente parámetro:

http://localhost:7001/MiAplicacionWeb/MiServlet?usuario=Juan Perez

Con una pequeña adaptación al método anterior:

Código: Java
  1. protected void doGet(HttpServletRequest request,
  2.                         HttpServletResponse response)
  3.                                         throws ServletException, IOException {
  4.  
  5.         //getParameter() es para obtener los parametros ingresados desde
  6.         //Una URL o por POST, no confundir con getAttribute(String,Object)
  7.         //este método es para obtener datos previamente guardados
  8.  
  9.         String usuario=(String)request.getParameter("usuario");
  10.         ServletOutputStream out=response.getOutputStream();
  11.         out.println("Hola " + usuario);
  12.         out.flush();
  13.         out.close();
  14. }
  15.  

Llamando la URL tal cual como la tengo arriba tengo el siguiente resultado:


Ahora un ejemplo con el método doPost, para esto necesitamos a fuerzas crear un formulario que sea capaz de enviar por método POST
para su comodidad ya tengo un HTML hecho, solo descarguenlo AQUI

Ahora, acabo de adaptar el servlet de la siguiente manera:

Código: Java
  1. protected void doPost(HttpServletRequest request,
  2.                         HttpServletResponse response)
  3.                                         throws ServletException, IOException {
  4.         String usuario = (String) request.getParameter("usuario");
  5.         String password= (String) request.getParameter("password");
  6.         ServletOutputStream out = response.getOutputStream();
  7.  
  8.         if (password.equals("12345678")){
  9.                 out.println("Bienvenido: " + usuario);
  10.         }else{
  11.                  out.println("El password es invalido intentelo de nuevo");
  12.         }
  13.         out.flush();
  14.         out.close();
  15. }

Cuando ingreso el usuario “Carlos” y un password diferente a 12345678 tengo el siguiente resultado:


Cuando ingreso el usuario “Carlos” y el password “12345678″


Señoras y señores todo por el momento, estaré escribiendo pronto, espero les sea de utilidad este artículo.

Fuente: desarrolloinnovador

Saludos

Páginas: [1] 2 3 ... 10