Ayuda IT

Crear un nuevo volumen logico en linux CentOS

2012-07-09T20:21:00.000+02:00

Un volumen lógico tiene unas propiedades muy parecidas a una partición normal y corriente, pero con algunas ventajas, como la facilidad a la hora de hacer backups.

Para crear un volumen lógico nuevo en nuestra máquina linux CentOS, lo primero que debemos hacer es comprobar si tenemos espacio disponible en alguno de nuestros grupos de volúmenes.

Esto lo podemos hacer con el comando

vgdisplay

que nos mostrará los nombres de los grupos de volúmenes y el espacio disponible en cada uno de ellos.

Para crear el volumen lógico usaremos el comando "lvcreate". Si, por ejemplo, queremos crear un nuevo volumen lógico que se llame "dbdata01" usando el grupo de volúmenes "vg00" con una capacidad de 4 Gb usaremos el comando

lvcreate -n dbdata01 -L 4G vg00

Una vez creado el nuevo volumen lógico podremos ver sus propiedades (y las de los demás volúmenes lógicos que tengamos) con el comando

lvdisplay

Ahora sólo debéis crear un sistema de ficheros sobre el nuevo volumen lógico (formatearlo con "mkfs") y ya podéis empezar a usarlo.

Sencillo y útil, ¿no es así?

Añadir un disco a un volumen logico de linux CentOS

2012-07-07T12:02:00.002+02:00

Con el paso del tiempo la máquina que instalamos con linux CenOS se nos habra ido quedando sin espacio en disco.

Podemos añadir un nuevo disco a nuestro sistema para conseguir más espacio.

Usaremos este disco nuevo para extender el espacio disponible en nuestro volumen lógico.

Una vez añadido el nuevo disco debemos crear un nuevo volumen físico sobre él.

Para saber a qué dispositivo corresponde el nuevo disco que hemos añadido podemos usar el comando

fdisk -l

que nos mostrará los dispositivos (discos) disponibles.
El que no contiene ninguna partición es nuestro nuevo disco (por ejemplo /dev/sdb)

Para crear el nuevo volumen físico usaremos el comando

pvcreate /dev/sdb 

Podemos visualizar los volumenes físicos de nuestro sistema con el comando

pvdisplay

Ahora debemos extender un grupo de volumenes usando el nuevo volumen físico que acabamos de crear.

Para saber cuales son los grupos de volumenes disponibles en nuestro sistema usaremos el comando

vgdisplay

Si el grupo de volumenes que queremos extender es, por ejemplo, VolGroup00, debemos usar el comando
vgextend VolGroup00 /dev/sdb

Una vez que el grupo de volumenes tiene más espacio disponible podemos extender el volumen lógico que queramos.

Para saber los volumenes lógicos que tenemos disponibles en nuestro sistema podemos usar el comando

lvdisplay

Si quisieramos, por ejemplo, añadir 2 Gb más de capacidad al volumen lógico /dev/VolGroup00/LogVol00 tendríamos que usar el comando

lvextend -L +2GB /dev/VolGroup00/LogVol00

Por último, para que el nuevo espacio añadido al volumen lógico esté disponible para su uso debemos usar el comando resize para agrandar la partición correspondiente.

resize2fs /dev/VolGroup00/LogVol00

Añadir un nuevo disco a nuestra máquina linux Debian

2012-07-05T19:36:00.001+02:00

Con el paso del tiempo la máquina que instalamos con linux Debian se nos habra ido quedando sin espacio en disco.

Podemos añadir un nuevo disco a nuestro sistema para conseguir más espacio.

Una vez añadido el nuevo disco debemos crear una nueva partición y formatearla antes de poder montar el disco para poder usarlo.

Para saber a qué dispositivo corresponde el nuevo disco que hemos añadido podemos usar el comando

fdisk -l

que nos mostrará los dispositivos (discos) disponibles.
El que no contiene ninguna partición es nuestro nuevo disco (por ejemplo /dev/sdb)

Para crear las particiones usaremos el comando

fdisk /dev/sdb

y seguimos las instrucciones.

A continuación creamos un sistema de ficheros en la nueva partición.

Para saber cúal es el formato de las particiones que ya tenemos en nuestro sistema podemos usar el comando

df -hT

Para crear el nuevo sistema de ficheros usamos el comando
mkfs.ext3 /dev/sdb1

Ahora ya podemos montar y empezar a usar el nuevo disco con el comando
mount /dev/sdb1 /mnt

Si queremos que el nuevo disco se monte automáticamente al iniciar linux podemos modificar el fichero

/etc/fstab

para añadir el nuevo dispositivo.

Cambiar el puerto TCP del servicio sshd

2012-07-03T19:12:00.001+02:00

Podemos evitar la gran mayoría de los ataques automáticos contra nuestro servidor simplemente cambiando el puerto TCP donde corre el demonio sshd.

Para hacer esto sólo tenemos que modificar el fichero /etc/ssh/sshd_config cambiando la entrada

Port 22

por el número de puerto de nuestra elección, por ejemplo

Port 1222

Después debemos reiniciar el servidor ssh para que empiece a escuchar en el nuevo puerto.

Simple y muy efectivo.

Convertir entre un objecto java y json

2012-06-18T14:41:00.000+02:00

La forma más sencilla de convertir entre un objecto java y xml es mediante el uso de las librerias de Jettison y XStream.

Lo único que debemos hacer es usar los métodos toXML() y toJava() de la propia clase XStream para convertir de objeto java a una cadena json y de una cadena json a objecto java respectivamente.

Muy sencillo.

Convertir entre un objecto java y xml

2012-06-06T20:56:00.001+02:00

La forma más sencilla de convertir entre un objecto java y xml es mediante el uso de la libreria XStream.

Lo único que debemos hacer es usar los métodos toXML() y toJava() de la propia clase XStream para convertir de objeto java a xml y de xml a objecto java respectivamente

Increiblemente simple.

Añadir un controller de spring a nuestra aplicación web

2012-05-31T19:46:00.002+02:00

Un Controller de spring se encarga de mapear las url de nuestra web con los programas java que se ejecutan.

Para añadir un controller sólo debemos añadir una clase java y marcarla con la anotación java @Controller.

A continuación podemos marcar algunos métodos de la clase java con la anotación java @RequestMapping indicando que este método se debe ejecutar en respuesta a una petición a la url que indiquemos como valor.

También podemos marcar el valor devuelto por la función con la anotación java @ResponseBody para que el Controller de spring use el valor devuelto por el método como el cuerpo de la respuesta html a la url anterior.

Es muy simple.

Añadir un fichero de configuración de springframework en springsource tool suite

2012-05-24T21:06:00.002+02:00

La forma más sencilla de añadir un fichero de configuración de springframework a nuestro proyecto usando springsource tool suite es usando el diálogo que aparece cuando hacemos click en el menú "File - New - Other..." y a continuación filtramos por "spring".

Seleccionamos la opción "Spring Bean Configuration File" y seguimos las instrucciones.

Podremos añadir beans y contextos de spring de una forma muy fácil.

Cambiar la localización del fichero de configuración de springframework

2012-05-19T18:58:00.000+02:00

Cuando usamos el DispatchServlet de springframework en nuestro proyecto web, este, por defecto, busca un archivo de configuración en el directorio WEB-INF con el siguiente nombre:

"nombre-del-servlet"-servlet.xml

Muchas veces nos será útil cambiar la localización y el nombre de este fichero para mantener todos los ficheros de configuración en el mismo sitio.

Para hacer esto podemos usar el parámetro de inicio llamado "contextConfigLocation" que indicará el nombre y localización del fichero de configuración.

Así, nuetro fichero web.xml quedaría algo como:

<web-app>
  <display-name>Nioos Api - Login</display-name>
  <servlet>
      <servlet-name>dispatcherServlet</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>/WEB-INF/conf/spring-config.xml</param-value>
          <description>Spring Framework context configuarion files location</description>
      </init-param>      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>dispatcherServlet</servlet-name>
      <url-pattern>/*</url-pattern>
  </servlet-mapping>
</web-app>

Útil si nos gusta tener la cosas ordenadas.

Añadir las librerias de springframework usando maven

2012-05-18T21:14:00.002+02:00

La forma más sencilla de añadir las librerías de spring a nuestro proyecto web es usando maven.

Lo único que hay que hacer es añadir la dependencia "spring-web" al fichero pom.xml de maven.

El fichero en cuestión quedará algo como:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.nioos.api</groupId>
<artifactId>NioosApiLogin</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>Nioos Login Webapp</name>
<url>https://api.nioos.com/NioosApiLogin</url>
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<build>
    <finalName>NioosApiLogin</finalName>
</build>
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>3.1.1.RELEASE</version>
    </dependency> </dependencies>
</project>

Esta única dependencia añadirá todo el resto de librerías necesarias para nuestro proyecto.

Agregar springframework a nuestro proyecto web

2012-05-16T20:39:00.002+02:00

Spring es un framework de desarrollo de aplicaciones java muy popular que podemos usar para desarrollar nuestras aplicaciones web.

Para empezar a usarlo en nuestro proyecto web lo más simple es añadir uno de los servlets que vienen empaquetados con este framework, en concreto, el DispatcherServlet.

Para hacer esto sólo tenemos que modificar el fichero web.xml de nuestra aplicacion web y añadir el servlet y el mapeo correspondiente.

Por ejemplo:

<web-app>
  <display-name>Nioos Api - Login</display-name>
  <servlet>
      <servlet-name>dispatcherServlet</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>dispatcherServlet</servlet-name>
      <url-pattern>/*</url-pattern>
  </servlet-mapping>
</web-app>

Fácil, ¿verdad?

Añadir jQuery UI al proyecto web

2012-04-17T21:24:00.000+02:00

jQuery UI es una librería muy conocida y útil que nos permite añadir de una forma muy sencilla elementos dinámicos a nuestro interface de usuario (la página web).

jQuery UI nos permitirá añadir cuadros de diálogo, selectores, desplegables, botones, animaciones, etc.

Lo único que debemos hacer es añadir la librería javascript

<link rel="stylesheet" href="http://ajax.googleapis.com/ajax/libs/jqueryui/1.8.18/themes/base/jquery-ui.css" /> 

y la hoja de estilo

<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jqueryui/1.8.18/jquery-ui.min.js"></script>

en la cabecera de nuestra página web.

Para poder usar esta librería también debemos añadir la librería jQuery a nuestra página web.

La forma más sencilla de encontrar las últimas versiones de estas librerías y hojas de estilo es visitando el blog de jQuery UI.
Allí podremos encontrar enlaces al CDN de Google, al CDN de Microsoft o descargar las últimas versiones de la librería y de las hojas de estilo (hay varias, una para cada combinación de colores).

Muy sencillo.

Personalizar la página de error con el widget de Google

2012-04-14T19:27:00.001+02:00

Google proporciona un widget de busqueda especial que podemos usar en nuestras páginas personalizadas de error para ofrecer a nuestros usuarios la oportunidad de buscar la página en la que realmente están interesados.

Lo único que hay que hacer es añadir el código a nuestra página de error personalizada:

<script type="text/javascript">
  var GOOG_FIXURL_LANG = 'es';
  var GOOG_FIXURL_SITE = 'http://nioos.com'
</script>
<script type="text/javascript"
  src="http://linkhelp.clients.google.com/tbproxy/lh/wm/fixurl.js">
</script>

Donde "GOOG_FIXURL_LANG" es el idioma en el que aparecerá diálogo de búsqueda de Google y "GOOG_FIXURL_SITE" es la dirección de nuestro sitio web.

Fácil, ¿verdad?

Personalizar las páginas de error de tomcat

2012-04-01T21:14:00.002+02:00

Personalizar las páginas de error de tomcat es muy sencillo, lo único que hay que hacer es modificar el fichero web.xml de la aplicación web y añadir los parámetros:

error-page error-code: es el código de error HTTP que queremos personalizar, por ejemplo 404 significa "archivo no encontrado"
error-page location: es la página web que queremos mostrar como respuesta a este error

<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Nioos Web Application</display-name>
<filter>
    <filter-name>simplePageCachingFilter</filter-name>
    <filter-class>net.sf.ehcache.constructs.web.filter.SimplePageCachingFilter</filter-class>
    <init-param>
      <param-name>cacheName</param-name>
      <param-value>simplePageCachingFilter</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>simplePageCachingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<error-page>
    <error-code>404</error-code>
    <location>/no-encontrado.html</location>
</error-page> </web-app>

Realmente muy sencillo.

Automatizar las fechas del archivo sitemap.xml con maven

2012-03-31T20:05:00.000+02:00

Es posible automatizar la fechas del archivo sitemap.xml usando maven.

Para esto debemos crear una nueva carpeta de recursos web (por ejemplo "src/main/webresources") donde dejaremos una versión modificada de nuestro fichero sitemap.xml.

Este fichero sitemap.xml ya no contendra las fechas explícitamente, sino que tendrá la variable ${timestamp}:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
    <url>
        <loc>http://nioos.com</loc>
        <lastmod>${timestamp}</lastmod>
    </url>
    <url>
        <loc>http://nioos.com/login.html</loc>
        <lastmod>${timestamp}</lastmod>
    </url>
    <url>
        <loc>http://nioos.com/sitemap.html</loc>
        <lastmod>${timestamp}</lastmod>
    </url>
    <url>
        <loc>http://nioos.com/politica-privacidad.html</loc>
        <lastmod>${timestamp}</lastmod>
    </url>
    <url>
        <loc>http://nioos.com/condiciones-servicio.html</loc>
        <lastmod>${timestamp}</lastmod>
    </url>
    <url>
        <loc>http://nioos.com/politica-contenido.html</loc>
        <lastmod>${timestamp}</lastmod>
    </url>
</urlset>

La variable ${timestamp} la definiremos en el fichero de configuración de nuestro de maven, al igual que nuestra nueva carpeta de recursos:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>ui.nioos.com</groupId>
<artifactId>NioosUI</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<name>NioosUI Webapp</name>
<url>http://www.nioos.com</url>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <timestamp>${maven.build.timestamp}</timestamp>
    <maven.build.timestamp.format>yyyy-MM-dd</maven.build.timestamp.format>
</properties>

<build>
    <finalName>NioosUI</finalName>
    
    <plugins>
        <plugin>
            <artifactId>maven-war-plugin</artifactId>
            <version>2.2</version>
            <configuration>
                <webResources>
                    <resource>
                        <filtering>true</filtering>
                        <directory>src/main/webresources</directory>
                    </resource>
                </webResources>
            </configuration>
        </plugin>
    </plugins>
    
</build>
<dependencies>
    <dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache-web</artifactId>
        <version>2.0.4</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>
</project>

Aquí hemos definido las propiedades:

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <timestamp>${maven.build.timestamp}</timestamp>
  <maven.build.timestamp.format>yyyy-MM-dd</maven.build.timestamp.format></properties>

que posteriormente serán usadas en el nuevo fichero sitemap.xml, y también hemos configurado el plugin war de maven para que actualize los ficheros de la nueva carpeta con la fecha de la última compilación:

<plugins>
  <plugin>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.2</version>
    <configuration>
      <webResources>
        <resource>
          <filtering>true</filtering>
          <directory>src/main/webresources</directory>
        </resource>
      </webResources>
    </configuration>  </plugin>
</plugins>

De esta forma cada vez que compilemos el proyecto web usando maven el fichero sitemap.xml estará actualizado con la fecha de la última compilación de nuestro proyecto y los buscadores podrán actualizar sus índices de búsqueda de una forma más sencilla.

El archivo sitemap.xml

2012-03-24T10:56:00.002+01:00

A veces es recomendable crear un archivo sitemap.xml para nuestro sitio web para que los motores de búsqueda tengan más sencillo indexar nuestras páginas web.

Este archivo se debe dejar en el directorio raiz de nuestro sitio web.

Su formato es muy sencillo, se encuentra definido en http://www.sitemaps.org/, y básicamente es la lista de las páginas web de nuestro sitio web junto con la fecha de su última modificación.
Así los motores de búsqueda sabran cuando han cambiado nuestras páginas y volverán a indexarlas.

Crear este fichero no requiere mucho trabajo.

El archivo robots.txt

2012-03-14T21:37:00.001+01:00

Si nuestro sitio web contiene páginas antiguas, o directorios que contienen imagenes sin importancia, o por cualquier razón queremos avisar a Google o cualquier otro buscador que no estamos interesados en que indexe ciertas páginas ó directorios de nuestro sitio web debemos usar un archivo robots.txt

Este archivo se debe dejar en el directorio raíz de nuestro sitio web.

La sintaxis concreta de este archivo es muy sencilla y se puede encontrar en http://www.robotstxt.org/

Subir cambios al repositorio mercurial

2012-02-27T19:11:00.001+01:00

Una vez que hemos instalado el plugin de mercurial en springsource tool suite y que hemos creado un repositorio en bitbucket, podemos subir nuestros cambios a nuestro repositorio de mercurial.

Si nos posicionamos en la carpeta raíz de nuestro proyecto y hacemos click con el botón derecho aparecerá el dialogo contextual de eclipse.

Desde aquí podemos seleccionar "Team - Share project..." y en el diálogo seleccionamos Mercurial.

Después seleccionamos "Team - Commit..." y seleccionamos los ficheros que queremos subir al repositorio. Debemos también poner un mensaje al commit.

Por último seleccionamos "Team - Commit...", rellenamos la URL, usuario y password de nuestro repositorio de bitbucket y le damos al botón de finalizar.

Los nuevos cambios en los ficheros apareceran en nuestro repositorio y los podremos compartir con el resto de nuestro equipo.

Sencillo, ¿verdad?

Crear un nuevo repositorio en bitbucket

2012-02-26T18:47:00.000+01:00

Una vez nos hemos abierto una cuenta en bitbucket, para crear un nuevo repositorio lo único que debemos hacer es ir a "Repositories - create repository" y rellenar el formulario que se nos muestra.

Realmente fácil.

Instalar el plugin de mercurial en springsource tool suite

2012-02-25T09:48:00.002+01:00

El plugin de mercurial no está disponible directamente como una extensión de SpringSource Tool Suite, por lo que se debe instalar a traves del eclipse marketplace.

Para hacer esto debemos ir al menú "Help - Eclipse Marketplace..." y allí buscar "mercurial".

Una vez localizado le damos al botón "Install" y el plugin se instalará.

Es muy sencillo.

Instalar el eclipse marketplace client en springsource tool suite

2012-02-24T20:32:00.003+01:00

A veces tendremos que instalar un plugin de eclipse en nuestra instalación de SpringSource Tool Suite.

Si el plugin que queremos instalar no está disponible como una extensión de SpringSource Tool Suite entonces lo más cómodo es usar el eclipse marketplace client para instalarlo.

Eclipse marketplace client es un módulo de eclipse que podemos instalar directamente en STS desde "Help - Install New Software...".

Seleccionamos "Indigo" en "Work with..." y después podemos encontrar el marketplace client en el apartado "General Purpose Tools".

Es muy fácil.

Instalar el control de versiones mercurial

2012-02-23T23:16:00.001+01:00

A la hora de desarrollar es importante tener un sistema de control de versiones de nuestro codigo.

Para esto podemos usar un sistema de control de versiones distribuido como es mercurial.

Lo podemos descargar desde la página http://mercurial.selenic.com/downloads/

Instalarlo es muy sencillo, basta con ejecutar el programa.

Después podemos registrarnos en Bitbucket, un servicio de internet que nos permitirá, de forma gratuita, alojar nuestro código en sus servidores usando mercurial.
El código alojado en este servidor puede ser privado o público y accesible a todo el mundo.

Usar el api de youtube con jquery

2012-02-21T22:28:00.000+01:00

Al igual que ya hemos hecho con el api de twitter, es posible usar el api de youtube junto con jquery, en concreto con sus potentes capacidades ajax, para mostrar los videos próximos a nuestra zona de busqueda sobre el mapa de nuestro sitio web.

El uso de ajax con jquery es muy simple como vamos a ver con la siguiente función:

function buscarYouTube(distancia, lat, lng) {
    var youTubeUrl = "https://gdata.youtube.com/feeds/api/videos?alt=jsonc&v=2&max-results=50&orderby=published&location=" + lat + "," + lng + "&location-radius=" + distancia + "m";
    $.ajax({
        url: youTubeUrl,
        cache: false,
        dataType: "jsonp",
        beforeSend: mostrarBuscando(),
        complete: ocultarBuscando(),
        success: function(data) {
            if (data) {
                var innerData = data.data;
                if (innerData) {
                    var items = innerData.items;
                    if (items) {
                        var len = items.length;
                        for (var i = 0; i < len; i++) {
                            var item = items[i];
                            if (item) {
                                parsearYouTubeItem(item);
                            }
                        }
                    }
                }
            }
        },
        error: function(jqXHR, textStatus, errorThrown) {
            //Tracking error youTube
            _gaq.push(['_trackEvent', 'Error', 'youTubeText', textStatus]);
            _gaq.push(['_trackEvent', 'Error', 'youTubeError', errorThrown]);
        }
    });
}

En primer lugar construimos la URL de búsqueda en youtube con los parámetros que queremos, en este caso, la latitud, la longitud, y el radio de búsqueda (en metros).

var youTubeUrl = 
"https://gdata.youtube.com/feeds/api/videos?alt=jsonc&v=2&max-results=50&orderby=published&location="
 + lat + "," + lng + "&location-radius=" + distancia + "m";

El resto ya sabemos como hacerlo.

Hay una pequeña demo online en http://www.nioos.com

Configuración básica de ehcache en tomcat

2012-02-18T20:49:00.001+01:00

Después de añadir el filtro ehcache a nuestra aplicación web debemos configurarlo.

Para hacerlo debemos añadir un fichero que se llame "ehcache.xml" a nuestra aplicación web.
Este fichero debe estar accesible a en el classpath de la aplicación web.

Este fichero "ehcache.xml" tendra un contenido parecido al siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
  <diskStore path="java.io.tmpdir"/>
  <defaultCache
    maxElementsInMemory="20"
    eternal="false"
    timeToIdleSeconds="60"
    timeToLiveSeconds="3600"
    overflowToDisk="true"
  />
  <!-- Page and Page Fragment Caches -->
  <cache name="simplePageCachingFilter"
    maxElementsInMemory="20"
    eternal="false"
    timeToIdleSeconds="3600"
    timeToLiveSeconds="86400"
    overflowToDisk="true">
  </cache>
</ehcache>

El elemento diskStore indica el directorio donde se almacenarán los ficheros creados por la cache cuando sea necesario.

El elemento defaultCache contiene la configuración de la cache por defecto.

El elemento cache es la configuración de cada cache en concreto.
El valor del parámetro name debe coincidir con el valor del parámetro cacheName del filtro previamente añadido.
El valor del parámetro maxElementsInMemory indica el máximo número de objectos almacenados en memoria.
El valor del parámetro timeToIdleSeconds indica el número de segundos que deben pasar desde la última vez que se accede a un objecto concreto en la cache para que ese objecto sea borrado de la cache.
El valor del parámetro timeToLiveSeconds indica el número de segundos que deben pasar para que ese objecto sea borrado de la cache, no importa si se ha accedido recientemente al objeto en cache.
El parámetro overflowToDisk indica si, cuando se supera el número máximo de objectos almacenados en memoria, maxElementsInMemory, los objectos más antiguos se deben almacenar en disco.

No es dificil y las ventajas son muchas.

Añadir un filtro a nuestra aplicación web en tomcat

2012-02-17T20:37:00.001+01:00

Para añadir un filtro a nuestra aplicación web en tomcat debemos editar el fichero web.xml que se encuentra en el directorio WEB-INF de nuestra aplicación web.

Por ejemplo, si queremos añadir un filtro que comprima todas las páginas que servimos (aumentando de esta forma el ancho de banda disponible para servir a un mayor número de usuarios), debemos añadir lo siguiente al fichero web.xml

<filter>
  <filter-name>simplePageCachingFilter</filter-name>
  <filter-class>net.sf.ehcache.constructs.web.filter.SimplePageCachingFilter</filter-class>
  <init-param>
    <param-name>cacheName</param-name>
    <param-value>simplePageCachingFilter</param-value>
  </init-param>
</filter>

<filter-mapping>
  <filter-name>simplePageCachingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

La etiqueta "filter" contiene el nombre del filtro (filter-name) que debe coincidir con el nombre que aparece en "filter-mapping".
La etiqueta "filter" también contiene la clase Java que implementa el filtro, esta clase debe estar disponible en el classpath de nuestra aplicación web (como una librería en el directorio "WEB-INF/lib" o como una clase compilada en el directorio "WEB-INF/classes", si se está usando maven las librerías de las depedencias se copian al primer directorio automáticamente).
Por último, dentro de esta etiqueta "filter" se puede añadir los parámetros de inicio "init-param" necesarios para configurar el filtro.

La etiqueta "filter-mapping", además del nombre del filtro (filter-name) tiene el parámetro "url-pattern", que indica sobre qué urls se aplicará el filtro (en el ejemplo "/*" significa todas las urls).