# sudo apt-get install subversion

Crear la ruta /var/svn:

# mkdir /var/svn

Instalar apache2 y libapache2-svn:

# sudo apt-get install apache2 libapache2-svn

Crear el fichero /etc/subversion/passwd y añadir el primer usuario:

# htpasswd -c /etc/subversion/passwd user_name

Para añadir el resto de usuarios:

# htpasswd -c /etc/subversion/passwd user_name

Editar /etc/apache2/mods-enabled:

<Location /svn>
  DAV svn
  SVNParentPath /var/svn
  AuthType Basic
  AuthName "Subversion Repository"
  AuthUserFile /etc/subversion/passwd
  <LimitExcept GET PROPFIND OPTIONS REPORT>
    Require valid-user
  </LimitExcept>
</Location>

Crear los repositorios de subversion:

# svnadmin create /var/svn/repo
# chown -R www-data /var/svn/repo

Reiniciar apache2:

# /etc/init.d/apache2 restart

Crear la estructura de directorios TTB (Trunk, Tags, Branches):

# svn mkdir http://localhost/svn/repo/trunk  -m "Creating trunk"
# svn mkdir http://localhost/svn/repo/tags  -m "Creating tags"
# svn mkdir http://localhost/svn/repo/branches  -m "Creating branches"

Dependencias a añadir al fichero pom.xml de Maven.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring</artifactId>
            <version>2.5.6.SEC01</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>2.5.6.SEC01</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.4</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-core</artifactId>
            <version>2.0.5.RELEASE</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>

Modificaciones de /WEB-INF/web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

 
    <!-- Listener que inicializa el contexto de Spring -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- Ubicación del fichero de configuración de Spring -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <!-- Dispatcher Servlet -->
    <servlet>
        <servlet-name>springapp</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springapp</servlet-name>
        <url-pattern>*.htm</url-pattern>
    </servlet-mapping>
    <!-- Filtro de Spring Security que intercepta las llamadas a las URL de
         la aplicación -->
    <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>springSecurityFilterChain</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

Contenido de /WEB-INF/applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:security="http://www.springframework.org/schema/security"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-2.5.xsd
        http://www.springframework.org/schema/security
        http://www.springframework.org/schema/security/spring-security-2.0.4.xsd">
 
    <!-- Configuración del acceso a las diferentes URL de la aplicación en función del
         rol del usuario. En este caso toda la aplicación está protegida y se requiere
         de un usuario con rol ROLE_USER para acceder -->
    <security:http auto-config="true">
        <security:intercept-url pattern="/**" access="ROLE_USER" />
    </security:http>
 
    <!-- Algunos usuarios de prueba. Posteriormente podremos cambiar el servicio para
         que vaya a buscar la información de los usuarios a otro lugar (BBDD) -->
    <security:authentication-provider>
        <security:user-service>
            <security:user name="admin" password="admin" authorities="ROLE_USER, ROLE_ADMIN" />
            <security:user name="user1" password="user1" authorities="ROLE_USER" />
            <security:user name="user1" password="user1" authorities="ROLE_USER" />
        </security:user-service>
    </security:authentication-provider>
 
</beans>

Una vez hecho esto, al acceder a cualquier recurso de la aplicación se nos mostrará la pantalla de login por defecto de Spring Security. Otro día veremos cómo personalizar esta página de login. Os dejo con una captura de la página:

Un saludo

Las ventajas, pensándolo detenidamente 5 minutos saltan a la vista:

• Cuatro ojos ven más que dos. Esto es evidente. El código generado es de mucha más calidad.
• El hecho de que alguien supervise directamente nuestro trabajo (nuestra pareja de programación) influye en que nos esforcemos más.
• Dos personas comparten la responsabilidad de una tarea. El stress es menor.
• Mejora las relaciones de equipo.
• Amplifica la transmisión del conocimiento.

La excusa para no utilizarla que siempre he escuchado es la misma:

“¿Cómo voy a tener a dos personas haciendo una tarea cuando podría hacerla una única persona?”.

Normalmente esta gente suele ser la misma que ve a los programadores, no como una persona o un profesional, sino como un gasto en la cuenta de su proyecto y mi consejo: alejate de esta gente como de la peste

• core.jar: Almacena la lógica de negocio común.
• web.war: Aplicación web que hace uso de la lógica de negocio (utiliza core.jar).

Cada vez que modificamos la lógica de negocio subiendo código al gestor de versiones y se genere un artefacto core.jar queremos que se genere un nuevo artefacto web.war que incluya las modificaciones de el primero. Esto lo podemos conseguir fácilmente con Hudson, Maven y Archiva. Partimos de la base que tenemos el servidor Hudson montado y que tenemos dos proyectos definidos “core” y “web”. Ambos proyectos funcionan con Maven.

Instalación y arranque rápido de Apache archiva:

• Descargar y descomprimir Apache Archiva en la máquina que vaya a hacer de servidor de repositorios Maven. En mi caso es la misma máquina dónde se encuentra Hudson.
• Ejecutar Apache Archiva:

# $ARCHIVA_HOME/bin/archiva console

• Definir los repositorios que consideremos oportunos y usuarios con perfil “Repository Manager”. En mi caso trabajaré con el repositorio “snapshots” que viene definido por defecto.

Configuración Maven:

• Editar el fichero pom.xml de todos los proyectos y añadir el repositorio archiva:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<repositories>
	...
	<repository>
		<id>archiva.snapshots</id>
		<url>http://localhost:8081/archiva/repository/snapshots/</url>
		<releases>
			<enabled>false</enabled>
		</releases>
		<snapshots>
			<enabled>true</enabled>
		</snapshots>
	</repository>
	...
</repositories>

• Editar el fichero pom.xml del proyecto web y añadir la dependencia al proyecto core, por ejemplo:

1
2
3
4
5

<dependency>
	<groupId>com.sourcerebels</groupId>
	<artifactId>core</artifactId>
	<version>0.0.1-SNAPSHOT</version>
</dependency>

• Editar el fichero de configuración de Maven (settings.xml):

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<servers>
	...
	<server>
		<id>archiva.internal</id>
		<username>usuario_archiva</username>
		<password>password_archiva</password>
	</server>
	<server>
		<id>archiva.snapshots</id>
		<username>usuario_archiva</username>
		<password>password_archiva</password>
	</server>
	...
</servers>

Configuración Hudson:

• Para cada uno de los artefactos del proyecto configuraremos que se despliegue en el repositorio “archiva.snapshots”:

• Con este punto conseguiremos que cada vez que se genere una nueva versión del fichero core.jar esta se archive en el repositorio Maven. Ahora para que el proyecto web se construya cuando alguno de los snapshots de los que depende sean construidos:

Esto es todo
]]> http://www.sourcerebels.com/blog/integracion-rapida-de-maven-con-apache-hudson-y-apache-archiva/feed/ 0 http://www.sourcerebels.com/blog/nueva-etapa/ http://www.sourcerebels.com/blog/nueva-etapa/#comments Tue, 23 Mar 2010 08:37:17 +0000 Edu http://www.sourcerebels.com/blog/?p=311 Por fin, después de casi 9 años en Indra (anteriormente Soluziona), cambio de lugar de trabajo. Por ahora no adelantaré mucho. Voy al departamento de movilidad de una empresa mucho más pequeña y más orientada hacia el Open-Source. Por este motivo quizás, las entradas que vaya escribiendo tengan que ver con tecnologías diferentes a las que estoy acostumbrado a utilizar.

Nunca se sabe. Ya iremos viendo y escribiendo por aquí lo que vaya aprendiendo, así como las cosas que me llamen la atención sobre esta nueva aventurilla

Un saludo a todos

]]> http://www.sourcerebels.com/blog/nueva-etapa/feed/ 5 http://www.sourcerebels.com/blog/atajos-de-teclado-en-eclipse/ http://www.sourcerebels.com/blog/atajos-de-teclado-en-eclipse/#comments Wed, 24 Feb 2010 21:47:05 +0000 Edu http://www.sourcerebels.com/blog/?p=277 Estos son algunos de los atajos de teclado que me facilitan un poquito más el día a día cuando utilizo Eclipse para escribir código Java. No he querido abusar por que los considero bastante engorrosos de aprender pero si te interesa esto siempre puedes pulsar Ctrl+Shift+L e indicarme tus preferidos

Ctrl+Alt+H – Mostrar la jerarquía de llamadas de un método

Si presionamos esta combinación de teclas se nos mostrará una pantalla donde, a modo de árbol, podremos inspeccionar toda la jerarquía de llamadas de un método, esto es, qué otros métodos le llaman, que otros métodos llaman a estos últimos y así sucesivamente. Haciendo click en cualquiera de los resultados, abriremos un editor directamente en el código.



Alt+Shift+P – Abrir fichero Maven pom.xml

Esta combinación de teclas sirve para buscar el fichero pom.xml de cualquier artefacto tanto en el workspace como en cualquiera de los repositorios maven2 que tengamos definidos.



Nota: Si no me equivoco, esta combinación sólo está disponible si utilizas el plug-in de integración de Apache Maven 2 m2eclipse.

Ctrl+Shift+G – Buscar texto en workspace

La siguiente combinación de teclas permite buscar rápidamente el texto seleccionado en todo el workspace. La ventana de resultados sería similar a esta.



Ctrl+Shift+R / Ctrl+Shift+T – Abrir recurso / Abrir tipo

En el caso de Ctrl+Shift+R Muestra un cuadro de dialogo donde podemos teclear un texto y que permite filtrar rápidamente un fichero de los proyectos que tengamos abiertos en ese momento en el workspace. El funcionamiento de Ctrl+Shift+T es similar al de Ctrl+Shif+R sólo que en este caso podemos abrir tipos de Java únicamente.


Nota: Abrir tipo funciona únicamente, al menos a mi, en la perspectiva Java o J2EE

F4 – Mostrar la jerarquía de un tipo

Sitúa el cursor sobre un tipo en un código Java, pulsa F4 y te aparecerá una pantalla (en mi configuración de Eclipse la de más a la izquierda). Esta pantalla permite ver la jerarquía de herencia de una clase Java (parte superior) así como la lista de propiedades y métodos de la misma clase (parte inferior).



]]> http://www.sourcerebels.com/blog/atajos-de-teclado-en-eclipse/feed/ 0 http://www.sourcerebels.com/blog/control-de-versiones-con-git/ http://www.sourcerebels.com/blog/control-de-versiones-con-git/#comments Wed, 10 Feb 2010 12:34:16 +0000 Edu http://www.sourcerebels.com/blog/?p=260 Últimamente ando bastante engorilado con Git, por lo que este post pretende ser una introducción muy rápida de las cuatro cosillas que estoy aprendiendo sobre este VCS estos días. En siguientes entradas, o lo que es lo mismo sólo $DEITY sabe cuando, muy probablemente escribiré como montar un repositorio Git utilizando el servicio gratuito ofrecido por github.com.

En primer lugar indicar que Git es un sistema distribuido, a diferencia de por ejemplo Subversion o CVS que son centralizados. Esto para nosotros qué quiere decir? Básicamente que no trabajamos con una copia local del código fuente sino con una copia local o clon del repositorio original, más conocido como “master”.
Las ventajas más importante de trabajar de esta forma, siempre bajo mi punto de vista, son que disponemos de todas las utilidades propias del VCS sin ni siquiera tener que estar conectado a una red. Muy útil para acceder al historico de modificaciones de un fichero, comparar versiones, hacer un commit o cualquier cosa que hagas normalmente con tu VCS desde un sitio donde no dispongas de conexión.

Git define también 5 tipos de objetos alguno de los cuales nos serán familiares si hemos trabajado con un VCS antes:

• Blob: El contenido de un fichero gestionado por Git e identificable por el Hash SHA1 que se obtiene del dicho contenido.
• Tree: La estructura del repositorio en un momento determinado (normalmente un commit). Un objeto de tipo Tree tiene N objetos de tipo Blob asociados.
• Commit: Una “foto” del repositorio una vez se han introducido una serie de cambios. Un objeto de tipo commit tiene 1 objeto de tipo Tree asociado.
• Tag: Una etiqueta, normalmente sirve para marcar objetos de tipo commit.
• Índice: Imagen de los cambios que se aplicarán al repositorio en el siguiente commit. En Git, por defecto sólo aplican aquellos cambios que se encuentran reflejados en este índice (están STAGED).

Git a diferencia que otros VCS como Subversion no almacena únicamente los cambios de un fichero sino que almacena el contenido completo de cada revisión. Esto sumado a la forma de trabajar que tiene con los objetos que indiqué antes hacen que en general el funcionamiento de Git sea muy ágil y, bajo mi punto de vista, mucho menos susceptible a error (piensa que cada vez que le pides una revisión en concreto, Git no debe “montarla” sólo “localizarla”).

Sólo por estas cosillas, ya comienzo a estar tentado de cambiar. ¿Habeis trabajado con Git o similar? ¿Qué os parece? ¿Cambiaríais vuestro Subversion/CVS?

Por cierto el libro que estoy leyendo es “Version Control with Git” de la editorial O’Reilly Media por si alguien quiere echarle una leída.

]]> http://www.sourcerebels.com/blog/control-de-versiones-con-git/feed/ 0 http://www.sourcerebels.com/blog/my-top-recomentations-for-new-programmers/ http://www.sourcerebels.com/blog/my-top-recomentations-for-new-programmers/#comments Sun, 07 Feb 2010 11:00:26 +0000 Edu http://www.sourcerebels.com/blog/?p=250 Unsorted list:
• If you use a versioning control system, spend some time learning its basic usage (checkout, checkin, update, diff, merge, …). If you don’t use it, go quickly to get one. Im currently using svn and git.
• Don’t be scared about refactoring your code.
• Write your own documentation. Document your work for your personal profit. While you are documenting and organizing you are thinking in your job by looking it from a different point of view. Think in documentation like in a software-piece, it must be useful and reusable.
• Constantly, try to improve your knowledge about every day tools usage by knowing its internals (keyboard shorcuts or processes) or just learning from your colleages (or Internet users) usage.
• Write automated tests and execute it. You can use continuous integration for doing the job. I like the Hudson CI server.
• Don’t be IDE-dependent for your compilation, use scripts or tools specifically designed for this task. Actually Maven will be my first choice because Java is my main plattform.
• Get feedback about your code. Show them into colleagues or use communities like StackOverflow.
• Learn what KISS and Convention over configuration means. Be aware about overengineering.
• Don’t try to write your own framework or libraries for later use. Learn writing it  if you want, but use well-known community libraries or frameworks. I personally work mainly with Spring Framework and Apache commons.
• Backup your data. Use your own/preferred method. I personally like dropbox.
• Most important. Don’t try to acomplish all of this at same time. Just be patient and

Please, feedback

]]> http://www.sourcerebels.com/blog/my-top-recomentations-for-new-programmers/feed/ 4 http://www.sourcerebels.com/blog/spring-annotations-inject-properties-anotaciones-spring-inyectar-properties/ http://www.sourcerebels.com/blog/spring-annotations-inject-properties-anotaciones-spring-inyectar-properties/#comments Fri, 04 Dec 2009 23:24:47 +0000 Edu http://www.sourcerebels.com/blog/?p=239 applicationContext.xml:

File parameters.properties / Fichero parameters.properties:

MyComponent.path=/some/path

Spring component / Componente gestionado por Spring:

import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;
 
@Component("MyComponent")
public class MyComponent {
 
    private String path;
 
    @PostConstruct
    public void loadPath() {
 
        System.out.println("Loading from " + this.path);
    }
 
    public String getPath() {
        return path;
    }
 
    public void setPath(String path) {
        this.path = path;
    }
}

]]> http://www.sourcerebels.com/blog/spring-annotations-inject-properties-anotaciones-spring-inyectar-properties/feed/ 0 http://www.sourcerebels.com/blog/simple-javascript-call-from-java-llamada-simple-a-javascript-desde-java/ http://www.sourcerebels.com/blog/simple-javascript-call-from-java-llamada-simple-a-javascript-desde-java/#comments Fri, 04 Dec 2009 21:45:14 +0000 Edu http://www.sourcerebels.com/blog/?p=235 Simple call / Llamada simple:

1 2 3 4 5 6 7 8 9 10 11

try { ScriptEngineManager factory = new ScriptEngineManager(); ScriptEngine engine = factory.getEngineByName("JavaScript");   //Simple call to println javascript function engine.eval("println('Texto JavaScript')");   } catch (ScriptException ex) {   //Do something }

Calling a function / Llamando a una función:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

try {   ScriptEngineManager factory = new ScriptEngineManager(); ScriptEngine engine = factory.getEngineByName("JavaScript"); engine.eval("function amessagefunction(atext){ return 'The secret message is ' + atext;}"); Invocable invocable = (Invocable) engine; Object object = invocable.invokeFunction("amessagefunction", "abc"); System.out.println(object);   } catch (NoSuchMethodException ex) {   //Do something   } catch (ScriptException ex) {   //Something is wrong, perhaps }

]]> http://www.sourcerebels.com/blog/simple-javascript-call-from-java-llamada-simple-a-javascript-desde-java/feed/ 0 http://www.sourcerebels.com/blog/terminator-terminal-emulator/ http://www.sourcerebels.com/blog/terminator-terminal-emulator/#comments Sun, 29 Nov 2009 11:06:34 +0000 Edu http://www.sourcerebels.com/blog/?p=229 Cool terminal emulator for GNU/Linux users.

I installed on my Ubuntu box just typping:

$ sudo apt-get update
$ sudo apt-get install terminator

Looks like this:



]]> http://www.sourcerebels.com/blog/terminator-terminal-emulator/feed/ 0 http://www.sourcerebels.com/blog/simple-spring-proxy/ http://www.sourcerebels.com/blog/simple-spring-proxy/#comments Mon, 23 Nov 2009 20:04:00 +0000 Edu http://www.sourcerebels.com/blog/?p=224 Simply a code I wrote today at my Spring Training / Simplemente un código que escribí hoy en el curso de Spring.

applicationContext.xml:

1 2 3 4 5 6 7 8 9 10

<?xml version="1.0" encoding="UTF-8" ?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">   <bean id="postProcessor" class="com.sourcerebels.test.postprocessor.PostProcessor"/> <bean id="someBusinessRule" class="com.sourcerebels.test.postprocessor.SomeBusinessRule" lazy-init="true"> <property name="message" value="someBusinessRule executed"/> </bean> </beans>

Advice:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

package com.sourcerebels.test.postprocessor;   import java.lang.reflect.Method; import org.springframework.aop.AfterReturningAdvice; import org.springframework.aop.MethodBeforeAdvice;   public class TransactionAdvice implements MethodBeforeAdvice, AfterReturningAdvice {   public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println("Starting Transaction"); }   public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { System.out.println("Commit Transaction"); } }

BusinessRule interface:

1 2 3 4 5 6

package com.sourcerebels.test.postprocessor;   public interface BusinessRule {   void run(); }

SomeBusinessRule class:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

package com.sourcerebels.test.postprocessor;   public class SomeBusinessRule implements BusinessRule {   private String message;   public void run() { System.out.println(message); }   public String getMessage() { return message; }   public void setMessage(String message) { this.message = message; } }

Postprocessor:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

package com.sourcerebels.test.postprocessor;   import org.springframework.aop.framework.ProxyFactory; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor;   /** * @author edu@sourcerebels.com */ public class PostProcessor implements BeanPostProcessor {   public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("postProcessBeforeInitialization"); return bean; }   public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("postProcessAfterInitialization"); if (bean instanceof BusinessRule) { System.out.println("building proxy object"); ProxyFactory proxyFactory = new ProxyFactory(bean); proxyFactory.addInterface(BusinessRule.class); proxyFactory.addAdvice(new TransactionAdvice()); return proxyFactory.getProxy(); } return bean; } }

Main:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

package com.sourcerebels.test.postprocessor;   import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;   public class Main {   public static void main(String[] args) {   String[] paths = { "com/sourcerebels/test/postprocessor/applicationContext.xml" }; ApplicationContext ctx = new ClassPathXmlApplicationContext(paths);   BusinessRule negocio = (BusinessRule) ctx.getBean("someBusinessRule"); negocio.run();   negocio = (BusinessRule) ctx.getBean("someOtherBusinessRule"); negocio.run(); } }

]]> http://www.sourcerebels.com/blog/simple-spring-proxy/feed/ 0 http://www.sourcerebels.com/blog/apache-maven-compiler-jvm-compliance-level-compilador-nivel-de-especificacion-jvm/ http://www.sourcerebels.com/blog/apache-maven-compiler-jvm-compliance-level-compilador-nivel-de-especificacion-jvm/#comments Sun, 22 Nov 2009 12:31:55 +0000 Edu http://www.sourcerebels.com/blog/?p=213 At your pom.xml / En tu fichero pom.xml:

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-compiler-plugin</artifactId>
	<configuration>
		<source>1.6</source>
		<target>1.6</target>
	</configuration>
</plugin>

]]> http://www.sourcerebels.com/blog/apache-maven-compiler-jvm-compliance-level-compilador-nivel-de-especificacion-jvm/feed/ 0 http://www.sourcerebels.com/blog/urlrewritefilter-setting-up-configuracion/ http://www.sourcerebels.com/blog/urlrewritefilter-setting-up-configuracion/#comments Sat, 21 Nov 2009 11:09:54 +0000 Edu http://www.sourcerebels.com/blog/?p=209 Add this Maven dependency to your pom.xml or download urlrewrite*.jar from UrlRewriteFilter Home / Añade esta dependencia Maven a tu pom.xml o descarga urlrewrite*.jar desde la home de UrlRewriteFilter.

<dependency>
	<groupId>org.tuckey</groupId>
	<artifactId>urlrewritefilter</artifactId>
	<version>3.1.0</version>
</dependency>

Add this filter definition to your web.xml file / Añade esta definición de filtro a tu fichero web.xml:

<filter>
	<filter-name>UrlRewriteFilter</filter-name>
	<filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class>
</filter>
<filter-mapping>
	<filter-name>UrlRewriteFilter</filter-name>
	<url-pattern>/*</url-pattern>
</filter-mapping>

Add the file urlrewrite.xml to your WEB-INF directory / Añade el fichero urlrewrite.xml a tu directorio WEB-INF:

<!DOCTYPE urlrewrite
	PUBLIC "-//tuckey.org//DTD UrlRewrite 3.0//EN"
	"http://tuckey.org/res/dtds/urlrewrite3.0.dtd">
<urlrewrite>
	<rule>
	   <from>^/some/olddir/(.*)$</from>
	   <to type="redirect">/very/newdir/$1</to>
	</rule>
	<rule match-type="wildcard">
	   <from>/blog/archive/**</from>
	   <to type="redirect">/roller/history/$1</to>
	</rule>
</urlrewrite>

Some useful links / Algunos enlaces útiles:

UrlRewriteFilter Download
UrlRewriteFilter Manual v3.0

]]> http://www.sourcerebels.com/blog/urlrewritefilter-setting-up-configuracion/feed/ 0 http://www.sourcerebels.com/blog/spring-mvc-file-upload-subir-ficheros-al-servidor/ http://www.sourcerebels.com/blog/spring-mvc-file-upload-subir-ficheros-al-servidor/#comments Sat, 21 Nov 2009 09:35:47 +0000 Edu http://www.sourcerebels.com/blog/?p=200 HTML code / Código HTML:

<form method="POST" enctype="multipart/form-data" action="./myControllerURL">
	<input type="file" name="file"/>
	<input type="submit" name="submit" value="File Upload - Subir fichero"/>
</form>

Spring configuration / Configuración Spring:

<bean id="multipartResolver"
	class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
	<property name="maxUploadSize" value="100000000"/>
</bean>

Controller code / código del controlador:

MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
 
MultipartFile file = multipartRequest.getFile("file");
 
InputStream inputStream = null;
OutputStream outputStream = null;
File tmpFile = null;
 
System.out.println("file.getOriginalFileName(): "
		+ file.getOriginalFilename());
System.out.println("size:" + file.getSize());
try {
 
	if (file.getSize() > 0) {
 
		tmpFile = File.createTempFile("document_", ".tmp");
 
		inputStream = file.getInputStream();
		outputStream = new FileOutputStream(tmpFile);
		int readBytes = 0;
		byte[] buffer = new byte[8192];
		while ((readBytes = inputStream.read(buffer, 0, 8192)) != -1) {
			outputStream.write(buffer, 0, readBytes);
		}
		outputStream.close();
		inputStream.close();
		System.out.println("Saved file: " + tmpFile.getAbsolutePath());
	}
 
} catch (IOException ioe) {
	// TODO - Manage the exception.
}

]]> http://www.sourcerebels.com/blog/spring-mvc-file-upload-subir-ficheros-al-servidor/feed/ 0 http://www.sourcerebels.com/blog/maven-integracion-basica-de-xmlbeans/ http://www.sourcerebels.com/blog/maven-integracion-basica-de-xmlbeans/#comments Sun, 15 Nov 2009 11:01:35 +0000 Edu http://www.sourcerebels.com/blog/?p=179 Ruta dónde almacenar los ficheros .xsd:

src/main/xsd

Extracto del fichero pom.xml:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

<plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>xmlbeans-maven-plugin</artifactId> <version>2.3.2</version> <executions> <execution> <id /> <phase>generate-sources</phase> <goals> <goal>xmlbeans</goal> </goals> </execution> </executions> <configuration> <verbose>true</verbose> <quiet>false</quiet> <outputJar>target/schema.jar</outputJar> <javaSource>1.5</javaSource> </configuration> </plugin>

Ruta de generación de ficheros .java:

target/generated-sources

Ruta de generación de ficheros .class:

target/generated-classes

JAR generado:

target/schema.jar

]]> http://www.sourcerebels.com/blog/maven-integracion-basica-de-xmlbeans/feed/ 0 http://www.sourcerebels.com/blog/eclipse-maven-m2eclipse-integracion-con-wtp/ http://www.sourcerebels.com/blog/eclipse-maven-m2eclipse-integracion-con-wtp/#comments Sat, 14 Nov 2009 10:55:21 +0000 Edu http://www.sourcerebels.com/blog/?p=158 Actualización:

Para descargar la integración con WTP, actualmente se debe hacer desde el update site:

http://m2eclipse.sonatype.org/sites/m2e-extras

• Añadir el “update site” del plugin m2eclipse.

http://m2eclipse.sonatype.org/update/

• Instalar los componentes  dentro del grupo “Maven Integration” y el componente “Maven Integration for WTP”.



• Una vez instalados los componentes, reiniciar Eclipse.
• Crearemos un nuevo proyecto Maven pulsando control+N y seleccionando “Maven Project” de la categoría de proyectos “Maven”.



• En la primera pantalla del asistente dejaremos todas las opciones por defecto para crear un proyecto a partir de un arquetipo.
• Escogeremos el arquetipo “maven-archetype-webapp” y pulsaremos “Next”.



• Seleccionaremos los valores de las propiedades GroupId (Agrupación), ArtifactId (Identificador del artefacto), Version y Package.
• 
• Desde este momento ya es posible añadir el proyecto a alguno de los servidores configurados en WTP y lo que es mejor utilizar el depurador en caso de que lo necesitemos.



]]> http://www.sourcerebels.com/blog/eclipse-maven-m2eclipse-integracion-con-wtp/feed/ 0 http://www.sourcerebels.com/blog/eclipse-basico-ejecutar-eclipse-sobre-jdk/ http://www.sourcerebels.com/blog/eclipse-basico-ejecutar-eclipse-sobre-jdk/#comments Sat, 14 Nov 2009 09:58:29 +0000 Edu http://www.sourcerebels.com/blog/?p=146 Algunos plugin de Eclipse, como por ejemplo m2eclipse requieren que la plataforma Eclipse se ejecute sobre un JDK y no un JRE.

Primero de todo para comprobar si nuestra instalación se ejecuta sobre un JRE.

1. Seleccionar la opción “About Eclipse” del menú “Help”.
2. Pulsar el botón “Installation Details”.
3. Seleccionar la pestaña “Configuration”.
4. En ese momento se nos mostrará un listado de propiedades de configuración de Eclipse. Localizar el valor de la propiedad “-vm” para determinar si la instalación se ejecuta sobre un JRE

En mi caso, he detectado que la instalación se ejecuta sobre un JRE porque el valor de la propiedad “-vm” es el siguiente:

-vm
C:\development\Java\jre1.6.0_17\bin\client\jvm.dll

En segundo lugar tendremos que modificar la configuración de Eclipse.

1. Detener la ejecución de Eclipse.
2. Localizar y editar el fichero eclipse.ini de la ruta de instalación de Eclipse.
3. Añadir o editar la propiedad “-vm” para que esta apunte al ejecutable “java” o “javaw” si estamos en el sistema operativo de Microsoft.

En mi caso, y sobre la instalación por defecto en Windows he añadido las dos siguientes líneas al inicio del fichero eclipse.ini:

-vm
C:\development\Java\jdk1.6.0_17\bin\javaw.exe

En tercer lugar comprobaremos que realmente se han aplicado los cambios.



]]> http://www.sourcerebels.com/blog/eclipse-basico-ejecutar-eclipse-sobre-jdk/feed/ 0 http://www.sourcerebels.com/blog/wtf-apple/ http://www.sourcerebels.com/blog/wtf-apple/#comments Sat, 10 Oct 2009 10:46:00 +0000 Edu http://www.sourcerebels.com/blog/?p=136 La imagen habla por si misma.



]]> http://www.sourcerebels.com/blog/wtf-apple/feed/ 0 http://www.sourcerebels.com/blog/debianjava-parte-iv-instalando-y-configurando-mysql/ http://www.sourcerebels.com/blog/debianjava-parte-iv-instalando-y-configurando-mysql/#comments Sun, 25 Jan 2009 17:31:39 +0000 Edu http://www.sourcerebels.com/blog/?p=83 Instalación de MySQL server.

su -c apt-get install mysql-server-5.0

Lo primero que debemos hacer es configurarle una contraseña al usuario root. Esto lo haremos con el comando mysqladmin, que viene incluido en la distribucion de MySQL.

mysqladmin -h localhost -u root password contraseña_nueva_de_root

Como de costumbre, instalaremos las utilidades gráficas.

Instalación de MySQL Administrator.

su -c ‘apt-get install mysql-admin’

MySQL Administrator es una interfaz gráfica para administrar diferentes aspectos de la base de datos MySQL, como por ejemplo la seguridad o las cuentas de usuario.



Primera ejecución de MySQL Administrator

Creación de un nuevo esquema de base de datos: A continuación definiremos un nuevo esquema o base de datos llamado test, sobre el que ejecutaremos algunas pruebas más adelante. Para ello, haremos click en la opción Catalogs del menú de la izquierda. Veremos que en la parte inferior izquierda nos aparece un apartado con los diferentes esquemas de base de datos que hay creados (normalmente information_schema y mysql para una instalación “limpia”), haremos click en una zona libre de ese apartado con el botón derecho y seleccionaremos la opción Create schema tal y como se puede ver en la siguiente captura.



A continuación, se nos solicitará el nombre del nuevo esquema, en nuestro ejemplo hemos asignado el nombre test, ya que este esquema lo utilizaremos más adelante en diferentes pruebas.

Definición de un nuevo usuario con permisos sobre el nuevo esquema creado: Seleccionamos la opción New User del menú, tal y como se ve en la imagen.



A continuación introduciremos el nombre de usuario y la contraseña, y haremos click en el botón Apply Changes en la parte inferior derecha.



En la pestaña Schema Privileges seleccionaremos el esquema test del panel de la izquierda y a continuación seleccionaremos todos los permisos del panel de la derecha y haremos click en el botón flecha izquierda para asignar todos los privilegios seleccionados al usuario test. Con esto lo que haremos será darle acceso desde cualquier host de la red.



El siguiente paso sería probar el usuario pero eso lo haremos más adelante con el programa MySQL Query Browser.

Instalación de MySQL Query Browser

su -c ‘apt-get install mysql-query-browser’

MySQL Query Browser es una interfaz gráfica para ejecutar sentencias o scripts SQL.



Primera ejecución de MySQL Query Browser

Conexiones remotas a la base de datos MySQL: Suponiendo que queramos que alguna máquina de la red pueda conectar con nuestro servidor MySQL utilizando uno de los múltiples clientes que existen deberemos indicarlo a MySQL editando para ello el fichero de configuración /etc/mysql/my.cnf.

Localizaremos el apartado:

[mysqld]

Cambiaremos el valor del parámetro bind-address por la dirección IP pública de la máquina.

bind-address = IP_de_tu_servidor

Reiniciaremos el servidor MySQL

su -c ‘/etc/init.d/mysql stop’

su -c ‘/etc/init.d/mysql start’

Con esto ya tenemos la base de datos funcionando así como un esquema y un usuario para hacer pruebas más adelante.

]]> http://www.sourcerebels.com/blog/debianjava-parte-iv-instalando-y-configurando-mysql/feed/ 2 http://www.sourcerebels.com/blog/debianjava-parte-iii-instalando-algunas-utilidades/ http://www.sourcerebels.com/blog/debianjava-parte-iii-instalando-algunas-utilidades/#comments Sun, 25 Jan 2009 10:55:12 +0000 Edu http://www.sourcerebels.com/blog/?p=40 La instalación de los siguientes paquetes se puede obviar o no en función de vuestros gustos como usuario

Midnight Commander. Gestor de ficheros (Cónsola).

su -c ‘apt-get install mc’

Este programa para mi es indispensable. Se trata de un clon de Norton Commander (el cual ya utilizaba en la época DOS). No explico nada nuevo pero se trata de aumentar la productividad a la hora de trabajar con ficheros, esto se consigue con dos paneles para navegar por el sistema de ficheros, y una serie de atajos de teclado para hacer las tareas más comunes (copiar, mover, crear directorios, trabajar con ficheros comprimidos, FTP, etc.).

Truquillo MC: En la parte inferior verás una linea donde puedes introducir comandos si introduces un comando del tipo “cd ftp://tu_usuario:tu_contraseña@tu_servidor_ftp” abriras una sesión FTP. Es por ese motivo que en la siguiente lista de aplicaciones no incluido ningún cliente FTP.

Unzip. Utilidad para descomprimir ficheros en formato zip (Cónsola).

su -c ‘apt-get install unzip’

Vim. Vi Improved. Editor de textos generalista para términal vi con algunas mejoras (Cónsola).

su -c ‘apt-get install vim’

SciTE. Editor de textos generalista (Gui).

su -c ‘apt-get install scite’

Dillo. Navegador web “ligero” (Gui).

su -c ‘apt-get install dillo’

Iceweasel. Navegador web “completo” (Gui).

su -c ‘apt-get install iceweasel’

Wget. Gestor de descargas (Cónsola).

su -c ‘apt-get install wget’

Estas son las utilidades que yo instalo siempre pero como dijo Groucho Marx “Estos son mis principios. Si no le gustan tengo otros”. Aquí pongo una captura del rollete de hoy



Navegador web Iceweasel y editor de texto SciTE

]]> http://www.sourcerebels.com/blog/debianjava-parte-iii-instalando-algunas-utilidades/feed/ 0 http://www.sourcerebels.com/blog/debianjava-parte-ii-x-window/ http://www.sourcerebels.com/blog/debianjava-parte-ii-x-window/#comments Sat, 24 Jan 2009 07:42:20 +0000 Edu http://www.sourcerebels.com/blog/?p=26 Como comenté en el post anterior, en esta parte instalaremos el sistema gráfico X-Window y el gestor de ventanas XFCE sobre Debian GNU/Linux. Todo estos paquetes más básicos los instalaremos vía gestor de paquetes apt-get. Para ello lo primero será actualizar las listas de paquetes que este gestor tiene configuradas. Esto se hace con un sencillo comando.

su -c ‘apt-get update’

A continuación instalaremos el paquete xserver-xorg.

su -c ‘apt-get install xserver-xorg’

Interesante: apt-get descargará e instalará automáticamente todas las dependencias del paquete xserver-xorg.

Una vez instalado el paquete, se ejecutará automáticamente el asistente de configuración. Este nos preguntará por la resolución que queremos utilizar en nuestro sistema.



Una vez instalado el servidor X-Window ya deberíamos ser capaces de iniciar una sesión gráfica aunque, antes de esto, instalaremos un gestor de ventanas para hacer más amigable el uso de nuestro sistema. Un gestor de ventanas no es otra cosa que la aplicación que indica al servidor gráfico X-Window como se va a comportar este (por ejemplo: como será el aspecto de las ventanas, como se comportará el sistema cuando hagamos alguna acción con el ratón, etc.). Tal y como indicamos al principio, instalaremos el gestor de ventanas XFCE en su versión 4, por tratarse de un sistema ligero y con el que me siento bastante cómodo.

su -c ‘apt-get install xfce4′

Una vez este proceso acabe, por fin, seremos capaces de iniciar una sesión gráfica en el equipo.

startx

Para nuestra desilusión, el sistema no es capaz de iniciar la sesión gráfica. Nos muestra el siguiente mensaje de error:

Fatal server error:

could not open default font ‘fixed’

…

El mensaje de error es bastante explicativo, como hemos partido de una instalación mínima seguramente nos faltará instalar algún paquete adicional. Aparentemente las fuentes del sistema.

su -c ‘apt-get install xfonts-base’

Ahora sí que por fin podremos iniciar la sesión gráfica.

startx

La siguiente captura muestra el gestor de ventanas Xfce4 corriendo sobre nuestro Debian:



]]> http://www.sourcerebels.com/blog/debianjava-parte-ii-x-window/feed/ 0 http://www.sourcerebels.com/blog/debianjava-parte-i-personalizacion-del-entorno/ http://www.sourcerebels.com/blog/debianjava-parte-i-personalizacion-del-entorno/#comments Thu, 22 Jan 2009 22:45:34 +0000 Edu http://www.sourcerebels.com/blog/?p=3 En primer lugar y partiendo de una instalación mínima de Debian GNU/Linux. Esta se ha hecho partiendo de la imagen mini.iso e instalando únicamente el conjunto de paquetes software base. Como no es recomendable el uso del usuario root para el uso ordinario del equipo, lo primero que haremos será definir un nuevo usuario:

useradd -d /home/sourcerebel -s /bin/bash -m sourcerebel

Por defecto, un usuario de unix dispone de un espacio donde instalar sus aplicaciones o simplemente guardar su información, este espacio se conoce como su hogar o, en inglés, home. El parámetro -d indica al comando adduser cual va a ser el directorio home del usuario. El parámetro -m indica al comando adduser que debe crear este directorio.

Bonito de recordar: La variable de entorno $HOME contiene la ruta absoluta al directorio home del usuario actual y que utilizando la orden cd (change directory) sin parámetro alguno, este nos situará en nuestro home.

Importantísimo: Se puede acceder a la ayuda en línea de cualquier comando tecleando la orden man seguida del comando. Aquí podeis encontrar uno de los cientos de listados de comandos disponibles en Internet.

Así mismo, a no ser de que estemos definiendo un usuario de sistema (ver el uso del parámetro –system de la orden adduser), el usuario creado podrá abrir una sesión e introducir órdenes para que el ordenador las ejecute. Esto se hace a través de un intérprete de comandos o shell. Esta definición queda un poco triste por lo que mejor leer esta.

En Unix tradicionalmente existen diferentes intérpretes de comandos aunque jamás conocí a un usuario de Unix/Linux que no utilizase algo que no fuese bash.

Definir el shell por defecto del usuario que estamos creando es lo que indica el parámetro -s.

Añadimos un password para el nuevo usuario creado:

passwd sourcerebel

A partir de este momento, utilizaremos este nuevo usuario para ejecutar todas las instrucciones necesarias para la instalación. En caso que fuese indispensable el uso del usuario root, sería indicado.

Bien, en este punto, estamos delante de una pantalla tipo terminal con la, no despreciable, resolución de 80 columnas x 40 líneas, es un buen momento para detenerse, respirar hondo y pensar

“¿qué es lo que acabo de hacer?”

Bueno, que el entorno es austero es un hecho, pero y “¿ahora que hago con el ratón?, ¿lo tiro a la basura?”. Vamos a hacer más amigable esto dando la posibilidad de utilizar el ratón en este modo, parece un poco raro pero se puede utilizar el ratón en modo texto, es un hecho, conozco a una persona que tiene un amigo que lo vió.

GPM o General Purpose Mouse, nombre original donde los haya, es un servicio o demonio que se encarga de hacer funcionar el ratón en modo texto, que no es una funcionalidad que vayamos a utilizar mucho pero que en algún momento nos puede resultar útil para por ejemplo poder copiar y pegar texto en caso de no tener abierta una sesión gráfica.

Para instalar GPM se debe ejecutar el siguiente comando como usuario root.

su – c ‘apt-get install gpm’

Con la orden su -c, lo que indicamos al sistema es que queremos ejecutar ese comando como usuario root. Tal y como pensabas inmediatamente despues nos pedirá la contraseña del usuario root. apt-get es el gestor de paquetes que viene por defecto en Debian, y lo que estamos indicando con esta orden es que deseamos instalar el paquete gpm.

Consejillo: Copiar y pegar en con el ratón en GNU/Linux es una tarea muy sencilla. Debes saber, no obstante y sobretodo si vienes de un entorno Microsoft, que el funcionamiento no será el esperado. Cuando marcas algo con el ratón, automáticamente este algo que has marcado pasa a estar copiado en el portapapeles o clipboard. Esto, que es muy sencillo de comprender y que tiene toda su lógica si lo piensas detenidamente, puede llegar a crear confusión al principio, aunque acabas cogiendole el gustillo. Para pegar, simplemente tienes que hacer click con el boton derecho.

Como trabajar con un entorno en modo texto puede resultar útil en algunos momentos pero la intención es ser un poquito más productivos y disponer de un entorno más amigable, en siguientes post veremos como instalar un interfaz gráfico.

Como despedida os dejo con una captura del sistema operativo Debian GNU/Linux recien instalado.



]]> http://www.sourcerebels.com/blog/debianjava-parte-i-personalizacion-del-entorno/feed/ 0