Docker la herramienta del desarrollador, instalando wordpress

Docker es esa herramienta que todo desarrollador debería conocer.
¿Qué es? pues un contenedor, contenedor?, si una herramienta que nos permite instalar un tomcat, un mysql con un apache utilizarlo en nuestro proceso de desarrollo y al terminarlo lo podemos guardar o directamente tirarlo a la basura.

Gracias a esto no necesitamos instalar nada en nuestro equipo.

Existe un repositorio oficial donde podéis encontrar imágenes para ser utilizadas con Docker

https://hub.docker.com/explore/

¿Como se instala?. Aquí os pongo una guía para ubuntu.

1. Realizamos  sudo apt-get update
2. Instalamos el docker sudo apt-get -y install docker.io
3. Podemos querer que se ejecute al iniciar el pc sudo update-rc.d docker defaults
4. Arrancamos el servicio docker service docker start

Instalando una imagen de wordpress + mysql

1. Necesitamos localizar una imagen de wordpress vamos a 
   https://hub.docker.com/explore/ y buscamos por wordpress nos salen unas cuantas, pero vamos a utilizar tutum/wordpress.
2. Ejecutamos sudo docker run -d -p 80:80 tutum/wordpress /run.sh
3. Listando los docker que se ejecutan sudo docker ps
4. Ejecutamos el navegador web, ponemos nuestra ip y ya nos saldrá la instalación de wordpress.
5. Si queremos parar sudo docker stop "CONTAINER ID" identificador que nos da sudo docker ps

Con esto ya tendríamos una imagen de wordpress para poder desarrollar sobre ella.

Conectándote a la Máquina Virtual de Java (JVM)

La entrada de hoy va de como te conectas a la máquina virtual de java mediante programación, y te preguntarás ¿para qué me voy a conectar a la maquina virtual?, pues muy fácil, podrás controlar la memoria, threads y leer las propiedades del sistema.

package es.jnovo;

import java.io.File;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.Set;

import javax.management.MBeanServerConnection;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;

import com.sun.tools.attach.AgentInitializationException;
import com.sun.tools.attach.AgentLoadException;
import com.sun.tools.attach.AttachNotSupportedException;
import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import com.sun.tools.attach.spi.AttachProvider;

public class Jvm {

 public static void main(String[] args) {
  systema();
 }

 public static String systema() {
  StringBuilder salida = new StringBuilder();
  try {
   final AttachProvider attachProvider = AttachProvider.providers().get(0);

   VirtualMachineDescriptor descriptor = null;
   for (VirtualMachineDescriptor virtualMachineDescriptor : attachProvider.listVirtualMachines()) {

    // System.out.println(virtualMachineDescriptor.displayName());

    if (virtualMachineDescriptor.displayName().contains("eclipse")) {
     descriptor = virtualMachineDescriptor;
    }
   }

   if (descriptor == null)
    throw new RuntimeException("No tienes descriptor de la maquina virtual");

   VirtualMachine virtualMachine;

   virtualMachine = attachProvider.attachVirtualMachine(descriptor);

   final String home = virtualMachine.getSystemProperties().getProperty("java.home");
   final String agent = home + File.separator + "lib" + File.separator + "management-agent.jar";

   virtualMachine.loadAgent(agent);

   final Object portObject = virtualMachine.getAgentProperties().get("com.sun.management.jmxremote.localConnectorAddress");

   final JMXServiceURL target = new JMXServiceURL(portObject + "");
   final JMXConnector connector = JMXConnectorFactory.connect(target);
   final MBeanServerConnection remote = connector.getMBeanServerConnection();

   // listamos los threads del sistema
   ObjectName objName = new ObjectName(ManagementFactory.THREAD_MXBEAN_NAME);
   Set mbeans = remote.queryNames(objName, null);
   for (ObjectName name : mbeans) {
    ThreadMXBean threadBean = ManagementFactory.newPlatformMXBeanProxy(remote, name.toString(), ThreadMXBean.class);
    long threadIds[] = threadBean.getAllThreadIds();
    for (long threadId : threadIds) {
     ThreadInfo threadInfo = threadBean.getThreadInfo(threadId);
     System.out.println(threadInfo.getThreadName() + " / " + threadInfo.getThreadState());
    }
   }
  } catch (AttachNotSupportedException e) {
  } catch (IOException e) {

  } catch (AgentLoadException e) {
  } catch (AgentInitializationException e) {
  } catch (MalformedObjectNameException e) {
  }
  return salida.toString();
 }
}

Reemplaza cadenas en java con replaceAll a traves de la clase StringBuilder

Si necesitas un método que realice un reemplazado de una cadena por otra utiliza el siguiente

/**
      * Metodo que reemplaza cadenas en un stringbuilder
      *
       * @param builder
      * @param from
      * @param to
      */
      private void replaceAll(StringBuilder builder, String from, String to) {
            int index = builder.indexOf(from);
            while (index != -1) {
                  builder.replace(index, index + from.length(), to);
                  index += to.length(); // Move to the end of the replacement
                  index = builder.indexOf(from, index);
            }
      }

Operaciones con Decimales en Java (redondeo)

Si necesitáis realizar operaciones con  números decimales tienes que utilizar java.math.BigDecimal, en el siguiente ejemplo comprobamos que la variable numericoDecimal no es 0 y le asignamos la operación multiplicación de un Double y una división por un int redondeado los decimales hacia arriba:

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Prueba {
 public static void main(String[] args) {
  Double numeroDecimal2= new Double(24.2);
  BigDecimal numericoDecimal = new BigDecimal(24.5);

  // comprobacion si el valor del BigDecimal es 0
  numericoDecimal= numericoDecimal.compareTo(BigDecimal.ZERO) != 0 ?
   numericoDecimal.multiply(BigDecimal.valueOf(numeroDecimal2)).divide(BigDecimal.valueOf(12), RoundingMode.HALF_UP) 
   : BigDecimal.ZERO;
  System.out.println(numericoDecimal);
 }
}

La salida da 49.41

Scheduler o Programador de tareas en Java Version2

Otra versión de un scheduler o programador de tareas y esta vez para máquinas virtuales jdk 1.4 o anteriores. Las clases utilizadas son  java.util.Timer y   java.util.TimerTask.
Hay dos Timer y dos Task, un Timer que arranca la alarma y otro que la para, una Task que ejecuta un contador y otra que para las Tasks y los Timers

import java.util.Timer;

import java.util.TimerTask;



public class Alarma {

private long tiempoCarenciaMilisegundos = 3000;

private long tiempoEjecucionAlarmaTask = 3000;

private AlarmaTimer alarmaTimer = new AlarmaTimer();

private AlarmaTask alarmaTask = new AlarmaTask();

private AlarmaParaTimer alarmaParaTimer = new AlarmaParaTimer();

private AlarmaParaTask alarmaPararTask = new AlarmaParaTask();



/**

 * @param args

 */

public static void main(String[] args) {

System.out.println("Inicio del Main");

Alarma alarma = new Alarma(1000, 3000);

alarma.arrancaAlarmaTimer();

alarma.arrancaAlarmaParaTimer();

System.out.println("Fin del Main");

}



/**

 * Constructor de la clase

 * @param tiempoCarenciaMilisegundos

 * @param tiempoEjecucionAlarmaTask

 */



public Alarma(long tiempoCarenciaMilisegundos,

long tiempoEjecucionAlarmaTask) {

this.tiempoCarenciaMilisegundos = tiempoCarenciaMilisegundos;

this.tiempoEjecucionAlarmaTask = tiempoEjecucionAlarmaTask;

}

private void arrancaAlarmaTimer() {

alarmaTimer.arrancaTimer();

}

private void arrancaAlarmaParaTimer() {

alarmaParaTimer.arrancaParaTimer();

}

public class AlarmaTask extends TimerTask {

private int contador = 0;

public void run() {

System.out.println("Se ejecuta la alarma " + contador++);

}

}

public class AlarmaTimer extends Timer {

private final Timer tiempo = new Timer();

public void arrancaTimer() {

tiempo.scheduleAtFixedRate(alarmaTask, tiempoCarenciaMilisegundos,

tiempoEjecucionAlarmaTask);

};

}

public class AlarmaParaTask extends TimerTask {

public void run() {

System.out.println("Se ejecuta la cancelacion de la alarma ");

alarmaTask.cancel();

alarmaTimer.cancel();

alarmaTimer.purge();

System.out.println("Se ejecuta el parado de este timer/task ");

alarmaPararTask.cancel();

alarmaParaTimer.cancel();

alarmaParaTimer.purge();

System.exit(0);

}

}

public class AlarmaParaTimer extends Timer {

private final Timer tiempo = new Timer();

public void arrancaParaTimer() {

tiempo.scheduleAtFixedRate(alarmaPararTask, 20000, 1);

};
}
}

Scheduler o Programador de tareas en Java

Hoy posteo un pedacito de código de esos que suelo utilizar de vez en cuando para ejecutar en background tareas que se deben de realizar a horas intempestivas sin que moleste a nadie . Se trata de un programador de tareas o scheduler utilizando la clase Executors del paquete java.util.concurrent para versiones iguales o superiores 1.5 de java.

public class Schedule {

private ScheduledExecutorService programador;

private long tiempoRetardo;

private long tiempoEjecucion;

private long tiempoParada;

private static final int NUMERO_THREADS = 1;

private static final boolean PUEDE_PARAR_TAREA_SI_EJECUTA = false;

public static void main(String[] args) {

System.out.println("Inicio de main del proceso");

Schedule execute = new Schedule(3, 1, 20);

execute.activaProcesoYPara();

System.out.println("Fin del main del proceso");

}

/**

* Constructor

* 

* @param tiempoInicial

* @param tiempoEjecucion

* @param tiempoParada

*/

public Schedule(long tiempoRetardo, long tiempoEjecucion, long tiempoParada) {

this.tiempoRetardo = tiempoRetardo;

this.tiempoEjecucion = tiempoEjecucion;

this.tiempoParada = tiempoParada;

programador = Executors.newScheduledThreadPool(NUMERO_THREADS);

}

/**

* Metodo que activa el programador

* 

* el proceso se ejecutara 17 veces(contador = 17) ya que hay

* un retardo de 3 segundos. El proceso de parada tiene un ejecucion de 20

* segundos.

* 

*/

public void activaProcesoYPara() {

Runnable ejecucionTarea = new EjecucionTarea();

ScheduledFuture programadorTareaFutura = programador.scheduleWithFixedDelay(ejecucionTarea, tiempoRetardo,

tiempoEjecucion, TimeUnit.SECONDS);

Runnable paradaProceso = new PararTarea(programadorTareaFutura);

programador.schedule(paradaProceso, tiempoParada, TimeUnit.SECONDS);

}

/**

* Clase que se utiliza para la ejecucion de la tarea

* 

*/

private static final class EjecucionTarea implements Runnable {

/**

* Variable contador

*/

private int contador;

/*

* (non-Javadoc)

* 

* @see java.lang.Runnable#run()

*/

public void run() {

++contador;

System.out.println("valor del contador " + contador);

}

}

/**

* 

* Clase que se utiliza para parar la tarea que se ejecuta en el

* {@link ScheduledFuture}

* 

*/

private final class PararTarea implements Runnable {

private ScheduledFuture programadorFuturo;

/**

* Constructor.

* 

* @param programadorTareaFuturo

*/

public PararTarea(ScheduledFuture programadorTareaFuturo) {

programadorFuturo = programadorTareaFuturo;

}

/*

* (non-Javadoc)

* 

* @see java.lang.Runnable#run()

*/

public void run() {

System.out.println("Parando la tarea");

programadorFuturo.cancel(PUEDE_PARAR_TAREA_SI_EJECUTA);

programador.shutdown();

}

}

}

Inicializar una constante del tipo Map-HashMap(HasMap)

Seguro que alguna vez has necesitado inicializar un hasmap desde tu aplicacion java, aqui os dejo un  snippet

private static final Map CONSTANT_MAP = Collections
            .unmodifiableMap(new HashMap() {
                {
                    put(1, "one");
                    put(2, "two");
                }
            });

Elimina los duplicados en el ArrayList de java

//Elimina los duplicados en el arraylist
ArrayList listaFinal = new ArrayList();
HashSet h = new HashSet(listaFinal);
listaFinal.clear();
listaFinal.addAll(h);

de ResourceBundle a Properties en java (ResourceBundle to Properties java)

package gl.jnovo;

import java.util.Enumeration;
import java.util.Properties;
import java.util.ResourceBundle;

public class ResourceBundleToProperties {

  public static void main(String[] args) {
    Properties genericProperties = new Properties();
    ResourceBundle bundle = ResourceBundle.getBundle("dsx");
    Enumeration claves = bundle.getKeys();
    while (claves.hasMoreElements()) {
      String clave = (String) claves.nextElement();
      String valor = bundle.getString(clave);
      genericProperties.put(clave, valor);
    }
  }

}

Xml a Object, Object a Xml. Xstream

Hoy hablaré de Xstream, un serializador de xml y viceversa. Con el podemos convertir un objecto a un xml o un xml a un objecto.
Por ejemplo , supongamos que tenemos el siguiente xml que se corresponde con la clase posterior:

< com.jnovo.vgn.fachada.implementacion.vo.usuariovo>
< nombre>
jorge
< /nombre>
< apellido>
Novo
< /apellido>
< /com.jnovo.vgn.fachada.implementacion.vo.usuariovo>

tendremos una clase como esta


package com.jnovo.vgn.fachada.implementacion.vo;

import java.io.Serializable;
import java.util.Map;

/**
* @author Administrador
*
*/
public class UsuarioVO {


private String nombre;
private String apellido;

public void setNombre(String nombre) {
this.nombre = nombre;
}
public void setApellido(String apellido) {
this.apellido= apellido;
}
public String getNombre() {
return nombre;
}
public String getApellido() {
return apellido;
}


}


si llamas a la clase Xstream

UsuarioVO usuario = new UsuarioVO();

XStream xstream = new XStream();

String xml = xstream.toXML(usuario); --->esto te convierte la clase a un xml


UsuarioVO usuario = (UsuarioVo)xstream.fromXML(xml); ----> convierte un xml a un objecto.

espero que os sirva, sobre todo aquellos que utilizais webservices de .Net llamados desde axis que tienen datasources dentro de un campo string.

Ordenar un List de Objectos mediante Comparator

Si tenemos un List de objectos de la clase tipo ClaseA:

public class ClaseA{
private String titulo;
private Date fechaDate;


public long getFechaLong() {
return fechaDate.getTime();
}
public void setFechaLong(long fechaLong) {
this.fechaLong = fechaLong;
}
}

y lo que queremos es ordenar ese List por un campo de la clase deberemos crear un método estático final java.util.Comparator como el que pongo debajo, la ordenación se hace por el campo fechaDate del tipo java.util.Date


public static final Comparator COMPARA_FECHAS_ClaseA = new Comparator() {

public int compare(Object o1, Object o2) {
if (o1 == o2 || !(o1 instanceof ClaseA ) || !(o2 instanceof ClaseA )) {
return 0;
} else {
ClaseA r1 = (ClaseA) o1;
ClaseA r2 = (ClaseA ) o2;
long date1 = r1.getFechaLong();
long date2 = r2.getFechaLong();
return date1 <= date2 ? ((int) (date1 >= date2 ? 0: 1)): -1;
}
}
};

este método lo metemos en nuestra clase ClaseA quedando como aparece debajo:


public class ClaseA{
private String titulo;
private Date fechaDate;


public long getFechaLong() {
return fechaDate.getTime();
}
public void setFechaLong(long fechaLong) {
this.fechaLong = fechaLong;
}

public static final Comparator COMPARA_FECHAS_ClaseA = new Comparator() {

public int compare(Object o1, Object o2) {
//comprueba si los objectos que le llegan son del tipo de la clase
if (o1 == o2 || !(o1 instanceof ClaseA ) || !(o2 instanceof ClaseA )) {
return 0;
} else {
ClaseA r1 = (ClaseA) o1;
ClaseA r2 = (ClaseA ) o2;
long date1 = r1.getFechaLong();
long date2 = r2.getFechaLong();
// realiza las operaciones de comparación entre las fechas de las clases o1 y o2
return date1 <= date2 ? ((int) (date1 >= date2 ? 0: 1)): -1;
}
}
};
}

Para poder utilizar la ordenación solo hay que llamar al método de la siguiente forma:

List listClasesA= new ArrayList();
// aquí introducirías todos los objectos ClaseA

//Esta es la parte que ordena ese List
Collections.sort(listClasesA, ClaseA.COMPARA_FECHAS_ClaseA);


espero que os sirva ;-)