Después de llevar unos cuantos años trabajando con Java he de reconocer que nunca me había planteado la posibilidad de obtener la certificación, sin embargo, las cosas han cambiado y he decidido emprender el camino de las certificaciones en aquellas herramientas con las que trabajo habitualmente. Por eso he decidido prepararme la certificación OCP JAVA SE 8 exam 1Z0-809. Mi actual empresa no será mi última empresa, para facilitar estas transiciones futuras he decidido obtener las certificaciones necesarias que allanen el paso de una a otra empresa certificando el conocimiento que he acumulado.

Periódicamente iremos actualizando con entradas relacionadas con temas incluidos en esta certificación que cubre los aspectos básicos del lenguaje.

En esta primera entrada hablamos de 3 principios básicos del lenguaje como son encapsulación, herencia y polimorfismo.

Encapsulación

En contraposición a la programación estructura la programación orientada a objetos entiende que datos y comportamientos asociados como una única unidad, esto es a lo que comúnmente denominamos clase. Los atributos y métodos que compondrán la clase están íntimamente relacionados.

Modificadores de acceso

Los modificadores de acceso determinan el nivel de visibilidad de cada elemento Java: clase, método o atributo. Estos modificadores nos permiten ejercer de manera efectiva la encapsulación.

Java soporta 4 tipos de modificadores:

• Public. Si una clase o un método es declarado como Public, será accesible desde cualquier punto.
• Private. Si se declara un miembro como  Private solo será accesible desde la propia clase. Las clases no pueden ser declaradas como Private.
• Protected. Los miembros declarados muestran un comportamiento Public para las clases derivadas y un comportamiento Private para el resto de clases.
• Default (en caso de no declarar ningún modificador). Los miembros definidos como Default serán accesibles únicamente por las clases declaradas bajo el mismo package.

herencia

La herencia es un mecanismo de reusabilidad de la programación orientada a objetos. Con la herencia, las propiedades de varios objetos son empleadas para establecer relaciones entre los diferentes objetos. La abstracción y las propiedades comunes son proporcionadas por la superclase, la cual es especializada en la sublcase.

polimorfismo

El polimorfismo, como su mismo nombre sugiere múltiples formas, se refiere a la posibilidad de acceder a un variado rango de funciones distintas a través del mismo interfaz. O sea, que, en la práctica, un mismo identificador puede tener distintas formas (distintos cuerpos de función, distintos comportamientos) dependiendo, en general, del contexto. Dos ejemplos claros de esta característica son la sobreescritura de métodos (overriding) y la sobrecarga de métodos (overloading).

The post OCP Java SE 8 Exam 1Z0-809: Diseño de Clases Java appeared first on Developando.com.

La instalación de Java 8 es muy sencilla, a continuación te detallamos los pasos para completarla con éxito:

En primer lugar lo que vamos a realizar es la descarga del fichero empaquetado correspondiente. Esta descarga se puede hacer desde la web de Oracle, sin embargo, de esta manera evitamos la aceptación de licencia.

# cd /opt
#  wget --no-check-certificate --no-cookies --header "Cookie: oraclelicense=accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/8u72-b15/jdk-8u72-linux-x64.tar.gz
# tar xvf jdk-8u72-linux-x64.tar.gz

 instalación de java 8 con alternatives

Una vez realizada la descarga y desempaquetado del fichero en el directorio opt realizamos los siguientes pasos:

# sudo update-alternatives --install /usr/bin/java java /opt/jdk1.8.0_72/bin/java 2
# sudo update-alternatives --config java

Cuando ejecutemos update-alternatives nos mostrará un menú textual a través del cual elegir la configuración de java que queremos usar en nuestro sistema. La versión actual activa estará marcada con un asterisco en la parte de la izquierda.

Existen 4 opciones para la alternativa java (que provee /usr/bin/java).

 Selección Ruta Prioridad Estado
------------------------------------------------------------
 0 /usr/lib/jvm/java-8-oracle/jre/bin/java 1073 modo automático
* 1 /opt/jdk1.8.0_72/bin/java 2 modo manual
 2 /usr/java/jdk1.6.0_45/bin/java 100 modo manual
 3 /usr/lib/jvm/java-7-openjdk-amd64/jre/bin/java 1071 modo manual
 4 /usr/lib/jvm/java-8-oracle/jre/bin/java 1073 modo manual

Pulse <Intro> para mantener el valor por omisión [*] o pulse un número de selección: 2

 comprobar la instalación de java

Finalmente para comprobar que hemos realizado bien la instalación de java 8 basta con que escribamos en la consola

# java −version

java version "1.8.0_72"
Java(TM) SE Runtime Environment (build 1.8.0_72−b15)
Java HotSpot(TM) 64−Bit Server VM (build 25.72−b15, mixed mode)

 En resumen

Como véis es muy sencillo instalar java 8 en nuestro sistema. Cualquier duda o problema no dudes en escribir un comentario.

The post Instalación Java 8 en Linux Mint appeared first on Developando.com.

<div class="block text-center">
<!-- Begin MailChimp Signup Form -->
<div id="mc_embed_signup">
	<form action="//developando.us5.list-manage.com/subscribe/post?u=6b94988cb3057591894ee1671&amp;id=f3a8227f05" method="post" id="mc-embedded-subscribe-form" name="mc-embedded-subscribe-form" class="validate" target="_blank" novalidate>
	    <div id="mc_embed_signup_scroll">
			<input size="75" type="email" value="" name="EMAIL" class="email" id="mce-EMAIL" placeholder="email address" style="    height: 25px;    border: 1px;    margin: 0px !important;    font-size: 20px;    border-radius: 5px;" required>
		    <!-- real people should not fill this in and expect good things - do not remove this or risk form bot signups-->
		    <div style="position: absolute; left: -5000px;" aria-hidden="true"><input type="text" name="b_6b94988cb3057591894ee1671_f3a8227f05" tabindex="-1" value=""></div>
			<button id="mc-embedded-subscribe" class="vc_general vc_btn3 vc_btn3-size-md vc_btn3-shape-rounded vc_btn3-style-flat vc_btn3-icon-left vc_btn3-color-info"><i class="vc_btn3-icon fa fa-check"></i> Suscribirme</button>
	    </div>
	</form>
</div>
</div>
<!--End mc_embed_signup-->

The post Código Mailchimp para Theme Jupiter appeared first on Developando.com.

instalación de xampp en windows

Xampp es un servidor independiente de plataforma, software libre, que consiste principalmente en la base de datos MySQL, el servidor web Apache y los intérpretes para lenguajes de script: PHP y Perl. El nombre proviene del acrónimo de X (para cualquiera de los diferentes sistemas operativos), Apache, MySQL, PHP, Perl.

En resumidas cuentas nos proporciona un entorno de desarrollo rápido para poder probar nuestras aplicaciones PHP (entre otras cosas).

Para instalarlo en Windows simplemente vamos a la página de descargas y bajamos el instalador y lo ejecutamos. Seguir los pasos es muy sencillo.

Instalación de composer en windows.

Hace algún tiempo hablamos sobre Composer en esta entrada para arrancar un proyecto con CakePHP. Es un gestor de dependencias para php, te permite declarar las librerías de las cuales tu proyecto depende o necesita y las instala en el proyecto por ti. Para instalarlo basta con descargar el instalador y ejecutarlo.

Antes de instalar Composer debes tener instalado php en tu pc. Si has instalado xampp primero bastará con indicarle la instalación de php que está en el directorio de xampp.

Si todo ha ido bien debes ejecutar composer -v en una consola y debe aparecer algo similar a la imagen siguiente:

Iniciar un proyecto laravel

Ya estamos listos para arrancar nuestro proyecto con Laravel, para ello, vamos a la carpeta htdocs dentro de xampp desde la consola y ejecutamos el siguiente comando:

composer create-project laravel/laravel nombre_del_proyecto –prefer-dist

Como ves composer empezará a descargar  e instalar todos los componentes necesarios para crear nuestro proyecto.

Para verificar que todo ha ido bien, basta con arrancar el apache de xampp y en el navegador ir a la url http://localhost/nombre_proyecto/public donde deberás ver una pantalla como la siguiente:

¡ Ya puedes continuar el desarrollo bajo Laravel !

The post Laravel con Xampp y Composer en Windows appeared first on Developando.com.

ghost: crear el usuario administrador

Para acceder al registro de usuario debemos añadir /ghost a la url de la instalación de ghost que hayamos configurado, nosotros como lo hicimos en OpenShift nuestra url queda de la siguiente manera: http://ghost-developando.rhcloud.com/ghost Esta url nos lleva a la siguiente pantalla:

En ella tenemos que introducir el título del blog, nombre, dirección de correo y contraseña para terminar de configurar correctamente la instancia de Ghost. Cuando completemos los datos y hagamos clic en Ok, let’s do this se grabarán los datos de nuestro usuario (hemos detectado que en ocasiones el primer intento devuelve un error, insiste hasta obtener el mensaje de que todo ha ido bien).

Realizado esto si accedemos a la url de nuestra instacia veremos que el títutlo del blog se ha actualizado con los datos que introdujimos anteriormente. Ahora, si volvemos a introducir la url terminada en /ghost nos aparecerá la pantalla de login para acceder a la administración de Ghost.

Introduciendo el email y nuestra contraseña accederemos al dashboard de Ghost para empezar a probrarlo.

Ya está listo todo para poder empezar a trastear con tu instancia de Ghost. Como ves, la primera entrada que está publicada es un pequeño resumen de las cosas que puedes hacer.  

The post Ghost owner: crea tu usuario administrador appeared first on Developando.com.

probando ghost: crear una cuenta en openshift

Vamos a utilizar la cuenta OpenShift Online para explicar los pasos que debemos seguir para conseguir nuestra instancia de Ghost con la cuenta limitada que nos ofrece. Lo primero vamos a su sitio web pinchando  aquí.

Hacemos clic en Sign up for free lo que nos llevará a una pantalla de registro en la que completaremos nuestros datos. 

Una vez completado el registro debemos validar nuestra dirección de correo electrónico y aceptar los términos y condiciones del servicio a través del enlace que nos enviarán al correo electrónico con el que nos hayamos registrado. Una vez hecho esto podremos empezar a crear nuestra primera aplicación en Openshift.

Probando ghost: crear una aplicación en openshift

Desde la pantalla inicial del dashboard de bienvenida podemos empezar a crear nuestra primera aplicación de una manera muy sencilla como vamos a ver. Por lo pronto haremos clic Create your first application now.

En la pantalla siguiente usaremos la herramienta de búsqueda introduciendo la palabra Ghost en ella y haciendo clic para buscar.

Seleccionamos la segunda opción (o la primera … nosotros hemos seleccionado la segunda). Tras esto debes completar los datos necesarios para generar tu aplicación.

Después de completar los datos y hacer clic en create application debemos esperar unos minutos a que finalice el proceso de creación de nuestra aplicación. Una vez finalizado podremos acceder a nuestra instalación de ghost desde el panel de aplicaciones de OpenShift.

Si has seguido todos los pasos ya tendrás lista tu instancia de Ghost para poder empezar a probar esta apasionante plataforma de blogging, aunque primero deberás crear tu usuario de administración siguiendo esta entrada.

The post Ghost: empieza a probarlo gratis con OpenShift Online appeared first on Developando.com.

En este tutorial vamos a ver lo sencillo que resulta migrar a Ghost nuestro blog alojado en la plataforma Blogger. Si lo que quieres es crear una instancia y probar Ghost puedes crear tu instancia gratuita aquí.

herramienta para migrar a ghost: “blogger2ghost”

A pesar de que dentro de los planes del equipo que está desarrollando Ghost se encuentra  el desarrollo de herramientas para migrar nuestro blog la comunidad una vez más, se ha adelantado. 

De ahí que nos encontremos con esta herramienta de migración a Ghost que nos permitirá extraer todo el contenido de nuestro blog en un fichero JSON para cargarlo en nuestro flamante nuevo blog en Ghost.

Esta herramienta ha sido desarrollada por Juho Vepsäläinen y nos permite migrar nuestro blog de una manera sencilla.

MIGRAR DE BLOGGER A GHOST EN 3 PASOS

• Lo que debemos hacer primeramente es ir a la herramienta, por supuesto. Una vez allí introducimos la dirección de nuestro blog de Blogger y hacer clic en “Get Ghost JSON”.

Blogger to Ghost

• Con el fichero descargado nos vamos a nuestra parte de administración de Ghost que se encuentra en la ruta mi-blog-ghost-url/debug e importar nuestro fichero JSON.

• Si todo ha ido correctamente ya hemos finalizado el proceso. En caso de tener alguna incidencia podemos reportarlo aquí.

The post Ghost: Migrar desde Blogger a Ghost appeared first on Developando.com.

compressor.io : presentación

Compressor.io es una herramienta 100% web que nos promete reducir hasta en un 90% el peso de nuestra imágenes para conseguir reducir la carga de nuestros desarrollos web. La interfaz de compressor.io hace que sea sumamente sencillo procesar todas nuestras imágenes.

Los formatos que podemos procesar con compressor.io son los más empleados hoy día en web: JPG, PNG, GIF y SVG. El procesamiento de las imágenes está apoyado en tecnologías opensource de tratamiento de imágenes:

• pngquant: utilidad para la compresión con pérdida de archivos PNG.
• OptiPNG: utilidad para la optimización sin pérdida de información de archivos PNG.
• JpegOptim: comprime y optimiza archivos JPG.
• Gifsicle: esta utilidad nos permite optimizar, editar y crear GIFs.
• Scour: script en Python para la limpieza y optimización de archivos SVG.

Antes de comprobar las bondades de compressor.io cabe recordar que la autoría de las imágenes que proceséis con compressor.io no se verá modificada. Según nos indican en la web se pueden procesar un número ilimitado de imágenes que permanecerán durante 6 horas en los servidores de compressor.io antes de ser eliminadas definitivamente.

optimizar imágenes con compressor.io

Para el ejemplo vamos a utilizar la siguiente imagen que tiene un peso de 292Kb

Para procesar las imágenes en compressor.io es tan sencillo como una vez hayamos hecho clic en TRY IT!, seleccionemos el tipo de compresión y seleccionemos las imágenes.

Una vez que finalice el proceso descubrimos una nueva sorpresa, y es que compressor.io, nos permite almacenar las imágenes directamente en los servicios de Google Drive o Dropbox además de la tradicional descarga a nuestro equipo claro.

Nosotros hemos descargado el fichero, y ahora en sus propiedades muestra un tamaño de 125Kb que desde los 292Kb que marcaba anteriormente supone una reducción del más del 50% del peso eligiendo la optimización con pérdida.

 Este es el fichero de resultado.

RESUMIENDO

El tamaño final de la imagen evidentemente dependerá del tipo de compresión que decidamos así como de la información que le sobre al archivo, al contrario que otras herramientas como optimizilla, compressor.io es mucho más sencilla de utilizar y mantiene una calidad aceptable en las imágenes resultado, como podemos observar. 

The post Compressor.io: Optimiza tus imágenes al máximo appeared first on Developando.com.

• Paths y Path – Localización del fichero o nombre, no su contenido.
• Files - Operaciones con el contenido del fichero.
• StandardCharsets y Charset - Para manejar la codificación del archivo de texto.
• File.toPath – Método que permite interactuar con código antiguo a través del nuevo API java.nio

Las siguientes clases también son usadas de manera generalizada cuando trabajamos con ficheros de texto tanto en Java 7 como en versiones anteriores:

• Scanner – Permite leer ficheros de una manera sencilla.
• BufferedReader - Permite accesos de lectura línea a línea.
• BufferedWriter - Permite accesos de escritura línea a línea.

Cuando realizamos operaciones de lectura/escritura con ficheros de texto:

• Frecuentemente será buena idea utilizar buffering (por defecto el tamaño son 8K)
• Siempre tendremos que tener en cuenta el manejo de excepciones de IOException y FileNotFoundException.

java 7 : Codificación de caracteres

Para realizar operaciones sobre ficheros de texto en Java 7 tenemos que tener en cuenta que esas operaciones de lectura/escritura siempre usan una codificación de caracteres de manera implícita para traducir las cadenas de bytes en texto. Aquí es donde frecuentemente nos encontramos antes el primer problema. 

Las clases FileReader y FileWriter utilizan de manera implícita la codificación de caracteres del sistema. Sin embargo, no es apropiado utilizarlo debido a los problemas que puede ocasionar usar nuestro código en diferentes sistemas operativos por ejemplo. La manera correcta es emplear aquellas clases que nos obliguen a realizar una declaración explícita de la codificación de caracteres como por ejemplo:

FileInputStream fis = new FileInputStream("test.txt");
InputStreamReader in = new InputStreamReader(fis, "UTF-8");
 
FileOutputStream fos = new FileOutputStream("test.txt");
OutputStreamWriter out = new OutputStreamWriter(fos, "UTF-8");
 
Scanner scanner = new Scanner(file, "UTF-8"); 

java 7 + ejemplo 1

package es.ivoto.cera.config;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class LeerEscribirFicheroTextoJDK7 {
 
  public static void main(String... aArgs) throws IOException{
   LeerEscribirFicheroTextoJDK7 text = new LeerEscribirFicheroTextoJDK7();
 
    //Tratamiento con fichero pequeño con Java 7
    List<String> lines = text.readSmallTextFile(FILE_NAME);
    log(lines);
    lines.add("Esta es una línea añadida desde el código.");
    text.writeSmallTextFile(lines, FILE_NAME);
 
    //Tratamiento para ficheros grandes usando buffering
    text.readLargerTextFile(FILE_NAME);
    lines = Arrays.asList("Down to the Waterline", "Water of Love");
    text.writeLargerTextFile(OUTPUT_FILE_NAME, lines);   
  }
 
  final static String FILE_NAME = "C:\Temp\input.txt";
  final static String OUTPUT_FILE_NAME = "C:\Temp\output.txt";
  final static Charset ENCODING = StandardCharsets.UTF_8;
 
  //Para ficheros pequeños. Java 7
 
  /**
   Nota: el javadoc de Files.readAllLines dice que es recomendable para pequeños ficheros. 
   Pero su implementación usa buffering, por lo que también es recomendable para usarlo 
   con ficheros de texto de mayor tamaño.
  */  
  List<String> readSmallTextFile(String aFileName) throws IOException {
    Path path = Paths.get(aFileName);
    return Files.readAllLines(path, ENCODING);
  }
 
  void writeSmallTextFile(List<String> aLines, String aFileName) throws IOException {
    Path path = Paths.get(aFileName);
    Files.write(path, aLines, ENCODING);
  }
 
  //Para ficheros grandes Java 7
 
  void readLargerTextFile(String aFileName) throws IOException {
    Path path = Paths.get(aFileName);
    try (Scanner scanner =  new Scanner(path, ENCODING.name())){
      while (scanner.hasNextLine()){
        //procesa cada línea del mismo modo
        log(scanner.nextLine());
      }      
    }
  }
 
  void readLargerTextFileAlternate(String aFileName) throws IOException {
    Path path = Paths.get(aFileName);
    try (BufferedReader reader = Files.newBufferedReader(path, ENCODING)){
      String line = null;
      while ((line = reader.readLine()) != null) {
        //procesa cada línea del mismo modo
        log(line);
      }      
    }
  }
 
  void writeLargerTextFile(String aFileName, List<String> aLines) throws IOException {
    Path path = Paths.get(aFileName);
    try (BufferedWriter writer = Files.newBufferedWriter(path, ENCODING)){
      for(String line : aLines){
        writer.write(line);
        writer.newLine();
      }
    }
  }
 
  private static void log(Object aMsg){
    System.out.println(String.valueOf(aMsg));
  }
 
} 

java 7 + : Ejemplo 2

Este ejemplo muestra el uso de Scanner con Java 7 para leer un archivo que contiene las líneas de datos estructurados. Un Scanner se utiliza para leer en cada línea, y un segundo Scanner se utiliza para analizar cada línea en un simple par nombre-valor. La clase Scanner sólo se utiliza para la lectura, no para la escritura.

Java 7 : Clase Scanner

package es.ivoto.cera.config;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Scanner;
 
/**Asumimos que el fichero está codificado en UTF-8. Java 7 +. */
public class LeerConScanner {
 
  public static void main(String... aArgs) throws IOException {
    LeerConScanner parser = new LeerConScanner("C:\Temp\test.txt");
    parser.processLineByLine();
    log("Done.");
  }
 
  /**
   Constructor.
   @param aFileName nombre completo de un fichero existente.
  */
  public LeerConScanner(String aFileName){
    fFilePath = Paths.get(aFileName);
  }
 
 
  /** Método que invoca a {@link #processLine(String)}.  */
  public final void processLineByLine() throws IOException {
    try (Scanner scanner =  new Scanner(fFilePath, ENCODING.name())){
      while (scanner.hasNextLine()){
        processLine(scanner.nextLine());
      }      
    }
  }
 
  /** 
   Método sobreescribible para procesar las líneas de diferentes maneras.
    
   <P>La implementación por defecto espera recibir pares de clave-valor separados por un '='.
   Ejemplo de entradas válidas: 
   <tt>height = 178cm</tt>
   <tt>mass =  95kg</tt>
   <tt>disposition =  "grumpy"</tt>
   <tt>Clave = valor</tt>
  */
  protected void processLine(String aLine){
     Scanner scanner = new Scanner(aLine);
    scanner.useDelimiter("=");
    if (scanner.hasNext()){
      String name = scanner.next();
      String value = scanner.next();
      log("Name is : " + quote(name.trim()) + ", and Value is : " + quote(value.trim()));
    }
    else {
      log("Línea vacía o sin la estructura esperada. No se puede procesar.");
    }
  }
 
  // PRIVADO 
  private final Path fFilePath;
  private final static Charset ENCODING = StandardCharsets.UTF_8;  
 
  private static void log(Object aObject){
    System.out.println(String.valueOf(aObject));
  }
 
  private String quote(String aText){
    String QUOTE = "'";
    return QUOTE + aText + QUOTE;
  }
} 

Si ejecutas el ejemplo se obtendrá:

Name is : 'height', and Value is : '167cm'
Name is : 'mass', and Value is : '65kg'
Name is : 'disposition', and Value is : '"grumpy"'
Name is : 'this is the name', and Value is : 'this is the value'
Done.

The post Java 7 : Leer y escribir ficheros de texto en Java appeared first on Developando.com.

Configurar el Garbage Collector para que nos de esta salida es bastante sencillo. En mi caso el entorno es el siguiente:

Eclipse Kepler + Java 7 + Tomcat 7

He modificado la configuración de arranque del Tomcat para añadirle los siguientes parámetros:

Con estos parámetros la salida que obtenemos es la siguiente salida en nuestra consola:

[GC [PSYoungGen: 72686K->5110K(72704K)] 86900K->32995K(159744K), 0.0176918 secs] [Times: user=0.03 sys=0.02, real=0.02 secs] 
[GC [PSYoungGen: 72694K->17904K(148992K)] 100579K->47708K(236032K), 0.0199841 secs] [Times: user=0.03 sys=0.02, real=0.02 secs] 
[GC [PSYoungGen: 148976K->21989K(153088K)] 178780K->70001K(240128K), 0.0362913 secs] [Times: user=0.11 sys=0.00, real=0.03 secs] 
[GC [PSYoungGen: 153061K->34787K(283136K)] 201073K->100969K(370176K), 0.0318076 secs] [Times: user=0.08 sys=0.00, real=0.04 secs] 
[Full GC [PSYoungGen: 34787K->0K(283136K)] [ParOldGen: 66182K->49354K(117248K)] 100969K->49354K(400384K) [PSPermGen: 18093K->18089K(36352K)], 0.1232627 secs] [Times: user=0.34 sys=0.00, real=0.11 secs] 
[GC [PSYoungGen: 248320K->48632K(296960K)] 297674K->103225K(414208K), 0.0427160 secs] [Times: user=0.11 sys=0.01, real=0.06 secs] 
[GC [PSYoungGen: 296952K->58861K(387072K)] 351545K->127707K(504320K), 0.0549142 secs] [Times: user=0.11 sys=0.03, real=0.05 secs] 
[GC [PSYoungGen: 387053K->36470K(401920K)] 455899K->142959K(519168K), 0.0577764 secs] [Times: user=0.16 sys=0.00, real=0.06 secs] 

Pues si esta es la cara que se te queda al ver lo que el Garbage Collector escupe en tu consola estás leyendo el post adecuado. Como decía, en el Codemotion @alotor nos enseño una diapo en la que al menos pudimos saber relacionar las trazas con los tipos de procesos del Garbage Collector (recolección de jóvenes y STW stop the world) como se ve en la siguiente imagen:

Dado que es un tema extenso se tocaron unos cuantos temas más sin profundizar en demasía aunque dejando el camino trillado para poder seguir investigando sobre el Garbage Collector.

Vamos a analizar el detalle de la salida con el siguiente ejemplo para ver qué está queriendo decir el Garbage Collector:

[GC [PSYoungGen: 387053K->36470K(401920K)] 455899K->142959K(519168K), 0.0577764 secs] [Times: user=0.16 sys=0.00, real=0.06 secs] 

Descripción de la salida del Garbage Collector

[GC [PSYoungGen: 387053K->36470K(401920K)]  

GC indica el que el Garbage Collector que ha entrado en acción no es un [Full GC] ya que en ese caso aparecería ese tipo indicado como se puede ver en el ejemplo de más arriba. 

PSYoungGen nos dice que tipo de collector se emplea. PSYoungGen es el recolector de jóvenes. 

387053K indica el tamaño de la región de jóvenes antes de la ejecución del Garbage Collector.

36470K indica valor posterior a la ejecución del GC que ocupa la región de jóvenes. Cuánto menor sea su número mejor puesto que significará que ha liberado más espacio de memoria.

401920K valor máximo de memoria que puede ocupar la región de jóvenes.

455899K->142959K(519168K), 0.0577764 secs]

455899K tamaño total ocupado en el heap antes de la ejecución del Garbage Collector.

142959K tamaño resultante de la ejecución de GC.

519168K valor del tamaño máximo del heap.

0.0577764 secs tiempo invertido en realizar la operación de liberación de espacio de memoria heap.

conclusiones

Como hemos podido ver es mucho más sencillo ahora entender un poco qué es lo que ocurre y hace el Garbage Collector cuando añadimos los parámetros necesarios para tracear su actividad. 

¡ Todos los comentarios son bien recibidos !

The post Garbage Collector: Intepretando su salida appeared first on Developando.com.