Wednesday, February 25, 2015

Patrones de diseño - Patrón Observador

Patrones de diseño - Patrón Observador



Patrón Observer se utiliza cuando hay muchos-uno a la relación entre los objetos como si un objeto es modificado, sus objetos depenedent deben ser notificados automáticamente.Patrón Observer cae bajo la categoría patrón de comportamiento.

Implementación

Patrón Observer utiliza tres clases de actores. Asunto, Observador y Cliente. El sujeto es un objeto que tiene métodos para unir y separar los observadores a un objeto cliente. Hemos creado un Observador clase abstracta y una clase de sujeto concreto que se está extendiendo la clase Observer.
ObserverPatternDemo, nuestra clase de demostración, utilizará Asunto y concreto objeto de clase para mostrar el patrón de observador en la acción.
Patrón Observador UML Diagrama

Paso 1

Crear Subject clase.
Subject.java
import java.util.ArrayList;
import java.util.List;

public class Subject {
 
   private List<Observer> observers = new ArrayList<Observer>();
   private int state;

   public int getState() {
      return state;
   }

   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }

   public void attach(Observer observer){
      observers.add(observer);  
   }

   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }  
}

Paso 2

Create Observer class.
Observer.java
public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}

Paso 3

crar concrete observer classes
BinaryObserver.java
public class BinaryObserver extends Observer{

   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) ); 
   }
}
OctalObserver.java
public class OctalObserver extends Observer{

   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
     System.out.println( "Octal String: " + Integer.toOctalString( subject.getState() ) ); 
   }
}
HexaObserver.java
public class HexaObserver extends Observer{

   public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println( "Hex String: " + Integer.toHexString( subject.getState() ).toUpperCase() ); 
   }
}

Paso 4

usar objectos observadores Subject y concrete.
ObserverPatternDemo.java
public class ObserverPatternDemo {
   public static void main(String[] args) {
      Subject subject = new Subject();

      new HexaObserver(subject);
      new OctalObserver(subject);
      new BinaryObserver(subject);

      System.out.println("First state change: 15"); 
      subject.setState(15);
      System.out.println("Second state change: 10"); 
      subject.setState(10);
   }
}

Paso 5

Verificar salida
First state change: 15
Hex String: F
Octal String: 17
Binary String: 1111
Second state change: 10
Hex String: A
Octal String: 12
Binary String: 1010

Fuente : http://www.tutorialspoint.com/design_pattern/observer_pattern.htm

Editorconfig en nuestro entorno de trabajo


¿Que es EditorConfig?

EditorConfig ayuda a los desarrolladores definir y mantener estilos de codificación uniformes entre los diferentes editores y entornos de desarrollo. El proyecto EditorConfig consiste en un formato de archivo para definir estilos de codificación y una colección de plugins editor de texto que permiten a los editores para leer el formato de archivo y se adhieren a los estilos definidos.Archivos EditorConfig son de fácil lectura y trabajan muy bien con los sistemas de control de versiones.

¿como es un archivo EditorConfig?

Archivo de ejemplo

A continuación se muestra un ejemplo .editorconfig archivo de ajuste de fin de línea y estilos de sangría para los archivos de Python y JavaScript.
 # EditorConfig is awesome: http://EditorConfig.org

# top-most EditorConfig file
root = true

# Unix-style newlines with a newline ending every file
[*]
end_of_line = lf
insert_final_newline = true

# Matches multiple files with brace expansion notation
# Set default charset
[*.{js,py}]
charset = utf-8

# 4 space indentation
[*.py]
indent_style = space
indent_size = 4

# Tab indentation (no size specified)
[*.js]
indent_style = tab

# Indentation override for all JS under lib directory
[lib/**.js]
indent_style = space
indent_size = 2

# Matches the exact files either package.json or .travis.yml
[{package.json,.travis.yml}]
indent_style = space
indent_size = 2

¿Dónde se guardan estos archivos?

Al abrir un archivo, plugins EditorConfig buscan un archivo llamado.editorconfig en el directorio del archivo abierto y en cada directorio padre.Una búsqueda de .editorconfig archivos se detendrá si se alcanza la ruta de archivo raíz o un archivo EditorConfig con root=true se encuentra.
Archivos EditorConfig se leen de arriba a abajo y los archivos EditorConfig más cercanos se leen pasado. Propiedades de hacer juego secciones EditorConfig se aplican en el orden en que se leen, por lo que las propiedades de los archivos más estrechos tienen prioridad.
Para usuarios de Windows: Para crear un .editorconfig archivo en el Explorador de Windows, necesita crear un archivo llamado .editorconfig. , que el Explorador de Windows cambiará automáticamente el nombre de.editorconfig .

Formato de archivo detalles

Archivos EditorConfig utilizan un formato INI que es compatible con el formato utilizado por Python ConfigParser Biblioteca , pero [y] están permitidos en los nombres de las secciones. Los nombres de sección son FilePath pegotes , similar al formato aceptado por gitignore . Barras inclinadas (/) se utilizan como separadores de ruta y octothorpes (#) o punto y coma (;) son usadas como comentarios. Los comentarios deben ir en sus propias líneas. Archivos EditorConfig deben ser codificación UTF-8, ya sea con CRLF o separadores de línea LF.
Patrones globales filePath y propiedades EditorConfig actualmente soportados se explican a continuación.

Los patrones de comodines

Los caracteres especiales reconocidos en los nombres de sección para la coincidencia de comodines:
*Coincide con cualquier cadena de caracteres, excepto separadores de ruta ( / )
**Coincide con cualquier cadena de caracteres
?Coincide con cualquier carácter individual
[name]Coincide con cualquier carácter individual en nombre
[!name]Coincide con cualquier carácter individual no de nombre
{s1,s2,s3}Coincide con cualquiera de las cadenas dadas (separados por comas) (Disponible desde EditorConfig Core 0.11.0)
Los caracteres especiales se pueden escapar con una barra invertida para que no se pueden interpretar como patrones de comodines.

Propiedades compatibles

Tenga en cuenta que no todas las propiedades son apoyados por todos los plugins. El wiki tiene una lista completa de propiedades .
  • indent_style: set a la pestaña o el espacio para usar pestañas duras o suaves pestañas respectivamente.
  • indent_size: un número entero que define el número de columnas que se utilizan para cada nivel de sangrado y la anchura de las lengüetas suaves (cuando sea compatible). Cuando se establece en la ficha, se utilizará el valor de tab_width (si se especifica).
  • tab_width: un número entero que define el número de columnas que se utilizan para representar un carácter de tabulación. Por defecto es el valor deindent_size y no suele deben especificarse.
  • end_of_line: set de LF, CR o crlf para controlar cómo se representan los saltos de línea.
  • charset: set para latin1, UTF-8, UTF-8-bom, UTF-16BE o UTF-16LEpara controlar el juego de caracteres. El uso de UTF-8-bom se desalienta.
  • trim_trailing_whitespace: establecido en true para eliminar los espacios en blanco precedentes caracteres de nueva línea y falsa para asegurarse de que no lo hace.
  • insert_final_newline: set para asegurar cierto archivo termina con un salto de línea al guardar y falso para asegurarse de que no lo hace.
  • root: propiedad especial que debe especificarse en la parte superior del archivo fuera de cualquier sección. Se establece en true para detener.editorconfig archivos buscar en el archivo actual.
Actualmente todas las propiedades y valores distinguen entre mayúsculas y minúsculas. Ellos serán minúsculas cuando lo analiza. En general, si no se especifica una propiedad, se utilizarán los ajustes del editor, es decir EditorConfig toma ningún efecto sobre esa parte.
Es aceptable y, a menudo prefería dejar ciertas propiedades EditorConfig no especificado. Por ejemplo, tab_width No es necesario especificar a menos que difiere del valor de indent_size. Además, cuando indent_style se ajusta a lapestaña, puede ser deseable dejar indent_size no especificado para que los lectores pueden ver el archivo usando su formato indentación preferida.Además, si una propiedad no ha sido estandarizada en su proyecto(end_of_line por ejemplo), puede ser mejor para dejarlo en blanco.
Fuente: http://editorconfig.org/

Código Dinámico Evolución VM

Código Dinámico Evolución VM (o Dinamic Code Evolution en ingles)

La máquina virtual de código dinámico Evolución (DCE VM) es una modificación de la Java HotSpot (TM) VM que permite redefinición ilimitado de clases cargadas en tiempo de ejecución. El mecanismo hotswapping actual del HotSpot (TM) VM sólo permite cambiar cuerpos de los métodos. Nuestro mayor VM permite agregar y quitar campos y métodos, así como los cambios en los súper tipos de una clase.
Este es un proyecto de código abierto liberado bajo la GPL v2.0. Puede descargar el código fuente , así como los binarios para Windows, Mac y Linux VMs.

Instalacion


Advertencia: Este es un trabajo en progreso y en la actualidad en un estado experimental. Por el momento, la máquina virtual es lo suficientemente estable como para ser utilizado al depurar programas Java. No se aconseja su uso en un sistema de producción.
Nota: La última versión de Java 1.6 actualización 26 no es compatible con el DCE VM. Todos Java 1.6 versiones anteriores son compatibles.
Actualmente, la versión binaria de la máquina virtual está disponible para el 32-bit y 64-bit de Windows VM, de 32 bits Mac OS Soylatte VM (entiendes aquí ), y de 32 bits Linux 

Archivos ejecutables del instalador

Instrucciones de instalación

Los archivos JAR son ejecutables y contienen un instalador, por lo que es necesario instalar un JRE o JDK de antemano. Se recomienda utilizar la última JDK7 copia binaria disponible en https://jdk7.dev.java.net/ , pero el binario también debe trabajar con instalaciones JDK6 o jre6. Asegúrese de poner en marcha el programa de instalación con privilegios suficientes.
Para iniciar el programa de instalación en Windows con privilegios de administrador desde la línea de comandos abra una consola y el tipo de administrador:
> java -jar dcevm-0.2-win.jar
Para iniciar el programa de instalación en Mac OS con privilegios de administrador del tipo de línea de comandos:
$ sudo java -jar dcevm-0.2-mac.jar
Para iniciar el programa de instalación en Linux con privilegios de administrador del tipo de línea de comandos:
$ sudo java -jar dcevm-0.2-linux.jar
El instalador reemplaza el bin / cliente / jvm.dll y bin / server / jvm.dll con una versión modificada copias de seguridad de la anterior y añadiendo la dcevm.jar al directorio lib / ext /. Estos cambios se deshacen en la desinstalación.
Windows Installer
El instalador buscará instalaciones Java instaladas en los lugares comunes en el sistema de archivos y los muestra en una lista. Si el directorio de instalación deseada no está en la lista, que fácilmente se puede agregar al presionar el botón "Añadir directorio de instalación ...". El "Java Versión" y las columnas "Tipo" muestran información sobre esta instalación. La columna "DCE" muestra el estado de modificación de la máquina virtual.
Para instalar o desinstalar pulse los botones de acuerdo en la parte inferior derecha. Hay incluso un botón para ejecutar automáticamente algunas pruebas de unidad en su instalación.

Fuente : http://ssw.jku.at/dcevm/

Monday, February 23, 2015

JSP sintaxis Parte 2

Scriptles

Usualmente llamamos a todo lo que este dentro de <% %> scriptles pero como vemos hay diferentes tipos de elementos

En el caso de los Scriptles

son basicamente funcionalidades que podemos hacer en un JSP como declaras variables (locales) hacer iteraciones de elementos (while, for) y todo lo mismo que puedes hacer dentro de un metodo lo puedes hacer aqui, hasta declarar clases internas ;)




<html>
<body>
<%
    // This scriptlet declares and initializes "date"
    System.out.println( "Evaluating date now" );
    java.util.Date date = new java.util.Date();
%>
Hello!  The time is now
<%
    out.println( date );
    out.println( "Your machine's address is " );
    out.println( request.getRemoteHost());
%>
</body>
</html>

JSP Sintaxis Parte 1

sintaxis en JSP?

Basicamente es codigo "java insertado en un archivo JSP, que nos ayuda a poder generar procesos o funcionalidades combinados con Html (Scriptles, expressions, directives, declarations).

Pero un momento..

si, es cierto los scriptles son antiguos y ya no usados pero siempre es bueno tener conocimiento de este debido a que apuede que algun dia nos toque algun proyecto del año de la piedra (Dios nos protega y ampare :c ) y tengamos que tocar scriptles.


Todo JSP creado en nuestro proyecto pasa por una fase de traduccion el cual toma el archivo JSP y lo convierte a Servlet luego viene la etapa de compilacion.




Si! estas en lo cierto, asi es como nuestro codigo java en un JSP puede ser entendido por nuestro servidor por que todo es  compilado a codigo Java, todo JSP es un servlet y por lo tanto es codigo Java.

Ahora que tenemos eso claro (eso espero T_T) sigamos con los elementos que podemos usar en nuestros JSPs

Tipos de elementos en JSP

Scriptles:

<html>
<body>
The page count is:
<% out.println(Counter.getCount()); %>
</body>
</html>
Expression:
<html>
<body>
The page count is now:
<%= Counter.getCount() %>
</body>
</html>
Directives:
<%@ page import=”foo.*” %>
<html>
<body>
Hello World!!
</body>
</html>


Declarations:
<html>
<body>
<%! int x=0 %>
</body>
</html>



ver siguiente post Scriptles