¿Te gustaría aprender Spring Frameworks?
Tenemos los cursos que necesitas.¡Haz clic aquí!

Es posible que en alguna ocasión en una aplicación web en la que se emplee el contenedor de Spring sea necesario utilizar algunos de sus beans en clases instanciadas fuera del contenedor por lo que no podemos recurrir a la inyección de dependencias. Por ejemplo, puede darse el caso de que tengamos que integrar en nuestra aplicación un viejo servicio web de Axis que termine invocando los nuevos beans de negocio definidos en Spring, o bien tengamos que reutilizar algún servelt.

En estas situaciones, no nos quedará más remedio que buscar una estrategia que permita acceder a los beans de Spring que necesitemos. En el presente artículo se va a exponer de forma simple y práctica algunas posibles soluciones para conseguir resolver esta problemática.

Entorno de pruebas:

Requisitos: Conocimientos básicos de Spring IoC y servlets.

Proyecto para pruebas

Para probar las distintas estrategias se va a utilizar un proyecto web que constará únicamente de un servlet y del contenedor de Spring con un bean de ejemplo. Este proyecto se gestionará con Maven, por lo que en primer lugar hay que crear la estructura corrrespondiente. En nuestro caso, sólo hacen falta los directorios “/src/main/java” y “/src/main/webapp”.

En el pom.xml hay que definir dos dependencias: una para poder utilizar Spring IoC en una aplicación web (en este caso concreto, y para la serie 3.x, será spring-web), y otra para los servlets. Ya que esta última está incluída en el contenedor J2EE donde se desplegará el war (en mi caso será Tomcat 6) , se puede definir como provided.

<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.danielme.blog.springioc</groupId>
    <artifactId>obtenerbeans</artifactId>
    <version>1.0</version>
    <name>obtenerbeans</name>
    <packaging>war</packaging>
    <description>Pruebas de uso de beans gestionados por Spring fuera del contenedor. Proyecto base.</description>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <licenses>
        <license>
            <name>El presente proyecto Maven es el código de ejemplo utilizado en el artículo "Spring IoC Container: Utilizando beans fuera del contenedor",
            publicado con licencia "Creative Commons Reconocimiento-NoComercial-CompartirIgual 3.0  Unported" en la web "http://danielme.com"</name>
        </license>
    </licenses>
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.3.2</version>
                    <configuration>
                        <source>1.5</source>
                        <target>1.5</target>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>3.1.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>
El servlet se limitará a devolver una página en html escribiéndola en el response:
packagecom.danielme.blog.springioc.obtenerbeans;
importjava.io.IOException;
importjava.io.PrintWriter;
importjavax.servlet.ServletException;
importjavax.servlet.http.HttpServlet;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
/**
 * Servlet en el se recuperará el bean de Spring.
 * @author http://danielme.com
 *
 */
publicclassServletPrueba extendsHttpServlet
{  
    /**
     * Identificador para serialización
     */
    privatestaticfinallongserialVersionUID = 1L;
    @Override
    protectedvoiddoGet(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException
    {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html><head><title>Spring IoC Container: Utilizando los beans fuera del contenedor - Proyecto de prueba </title></head>"+ "<body>"+ "<h3>HOLA</h3>"+ "</body></html>");
        out.close();
    }

El bean a inyectar es el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
packagecom.danielme.blog.springioc.obtenerbeans;
/**
 * Bean que será instanciado por Spring IoC.
 * @author http://danielme.com
 *
 */
publicclassBeanSpring
{
    /**
     * Devuelve una cadena de prueba
     * @return HelloWorld!!
     */
    publicString getMensajeHelloWorld()
    {
        return"Hello World!!";
    }
}

y su definición en el applicationContext.xml

1
2
3
4
5
6
7
8
9
10
<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="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.xsd">
    <beanid="beanSpring"class="com.danielme.blog.springioc.obtenerbeans.BeanSpring"/>
</beans>

Por último el web.xml, se define el servlet, así como el contexto de Spring:

<?xmlversion="1.0"encoding="UTF-8"?>
<web-appid="springioc"version="2.5"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="
        http://java.sun.com/xml/ns/javaee
        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <display-name>springioc</display-name>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/applicationContext.xml
        </param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    
    <servlet>
        <servlet-name>pruebaSpring</servlet-name>
        <servlet-class>com.danielme.blog.springioc.obtenerbeans.ServletPrueba</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>pruebaSpring</servlet-name>
    <url-pattern>/spring</url-pattern>
  </servlet-mapping>
   
</web-app>

Te esperamos en la segunda parte del artículo en donde hablaremos mas acerca de estos temas, los cuales hoy en día son de vital importancia en el mundo de la tecnología.

¿Te gustaría aprender Spring Frameworks?
Tenemos los cursos que necesitas.¡Haz clic aquí!
About Author

NGuerrero

0 0 votos
Article Rating
Suscribir
Notificar de
guest
0 Comments
Comentarios.
Ver todos los comentarios
0
¿Te gusta este articulo? por favor comentax
()
x
Abrir chat
¿Quieres aprender a programar?
Hola 👋,
¿Te interesa información de nuestros cursos?