Spring MVC y Spring Security

En este post voy a explicar cómo proteger una aplicación Spring MVC utilizando el módulo Spring Security. Se trata de una guía muy ràpida y para nada seria. Se parte de la base de que tenemos un proyecto web Maven recien generado

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

Integración rápida de Maven con Hudson y Archiva

Supongamos que tenemos un proyecto dividido en varios módulos de funcionalidad y que cada módulo de funcionalidad genera un artefacto. Por ejemplo:

• 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
VN:F [1.9.2_1090]
please wait...
Rating: 0.0/5 (0 votes cast)

---

Atajos de teclado en Eclipse

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).

My top recomentations for new programmers

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

Spring Annotations Inject properties / Anotaciones Spring Inyectar properties

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;
    }
}