Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 76 vistas

    Configurar Spring Con Maven en Eclipse

    Cargado por

    donmarfell
    Este documento describe los pasos para agregar Spring a un proyecto en Eclipse usando Maven. Estos incluyen: 1) agregar la dependencia de Spring al archivo pom.xml, 2) agregar parámetros al archivo web.xml para habilitar Spring, y 3) definir el archivo de configuración applicationContext.xml. También explica cómo inyectar dependencias de Spring en clases Java.

    Copyright:

    © All Rights Reserved
    Descargue como DOC, PDF, TXT o lea en línea desde Scribd

    Configurar Spring Con Maven en Eclipse

    Cargado por

    donmarfell
    76 vistas6 páginas
    Este documento describe los pasos para agregar Spring a un proyecto en Eclipse usando Maven. Estos incluyen: 1) agregar la dependencia de Spring al archivo pom.xml, 2) agregar parámetros al archivo web.xml para habilitar Spring, y 3) definir el archivo de configuración applicationContext.xml. También explica cómo inyectar dependencias de Spring en clases Java.

    Descripción original:

    Configuracion Spring y maven

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    DOC, PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Este documento describe los pasos para agregar Spring a un proyecto en Eclipse usando Maven. Estos incluyen: 1) agregar la dependencia de Spring al archivo pom.xml, 2) agregar parámetros al archivo web.xml para habilitar Spring, y 3) definir el archivo de configuración applicationContext.xml. También explica cómo inyectar dependencias de Spring en clases Java.

    Copyright:

    © All Rights Reserved
    Descargue como DOC, PDF, TXT o lea en línea desde Scribd
    Descargar como doc, pdf o txt
    76 vistas6 páginas

    Configurar Spring Con Maven en Eclipse

    Cargado por

    donmarfell
    Este documento describe los pasos para agregar Spring a un proyecto en Eclipse usando Maven. Estos incluyen: 1) agregar la dependencia de Spring al archivo pom.xml, 2) agregar parámetros al archivo web.xml para habilitar Spring, y 3) definir el archivo de configuración applicationContext.xml. También explica cómo inyectar dependencias de Spring en clases Java.

    Copyright:

    © All Rights Reserved
    Descargue como DOC, PDF, TXT o lea en línea desde Scribd
    Descargar como doc, pdf o txt
    Está en la página 1de 6

    Aadir Spring con Maven en Eclipse

    Pasos a seguir:
    - Agregaremos Spring a nuestras dependencias en el pom.xml.
    - Agregamos al fichero web.xml los parmetros para usar Spring.
    - Definimos el fichero applicationContext.xml dentro de resource\spring\
    - Ejemplo de IoC en clases java.
    1.) Agregaremos Spring a nuestras dependencias en el pom.xml:
    pom.xml DependenciasAdd y buscamos la dependencia "org.springframework. En los
    resultados de bsqueda, seleccionamos la dependencia y versin correcta, en nuestro caso
    "spring-2.5.6.jar".

    Si al pulsar Guardar(OK) Maven no inicia la descarga de la dependencia automticamente, hacemos


    clic derecho sobre el proyecto, Maven Update Dependencies. Esto iniciar la descarga de

    dependencias.

    El pom.xml quedar con el siguiente cdigo:


    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring</artifactId>
    <version>2.5.6</version>
    </dependency>

    2.) Agregamos al fichero web.xml los parmetros para usar Spring:


    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.4"
    xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" >
    <!-- Spring framework context file -->
    <!-- Default configuration, it could be omitted -->
    <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext.xml</param-value>
    <!-- O tambin puede hacerse asi:
    <param-value>
    classpath:/spring/applicationContext.xml
    </param-value>
    -->
    </context-param>
    <!-- Spring framework context loader listener -->
    <listener>
    <listener-class>
    org.springframework.web.context.ContextLoaderListener
    </listener-class>
    </listener>

    </web-app>
    3.) Definimos el fichero applicationContext.xml dentro de resource\spring\
    <?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd"
    default-autowire="no" >
    <!-- Incluimos los otros ficheros de configuracin -- >
    <import resource="spring/spring-web.xml"/>
    <import resource="spring/spring-beans.xml"/>
    <import resource="spring/manager-context.xml"/>
    <import resource="spring/hibernate-context.xml"/>
    <import resource="datasource-context.xml"/>
    <!-- Podemos leer los .properties a partir de Spring 2.5 de la siguiente manera -- >
    <context:property-placeholder location="lang/fichero.properties"/>
    </beans>
    Un ejemplo de los ficheros de configuracin que importamos (Ej. Manager-context.xml
    ) en nuestro applicationContext.xml:
    <?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-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/util
    http://www.springframework.org/schema/util/spring-util-3.0.xsd">
    <bean id="draftManager" class="es.aragon.sfe.core.manager.impl.DraftManagerImpl">
    <property name="draftDAO" ref="draftDAO"/>
    </bean>
    <bean id="draftDAO" class="es.aragon.sfe.core.dao.impl.DraftDaoImpl">
    <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <bean id="abogadoService" class="seinsir.gestionprocesal.abogado.service.AbogadoBean"/>

    4.) Ejemplo de IoC en clases java.


    Ahora podemos comenzar a utilizar en los ficheros .java los objetos(bean) que nos hemos creado
    desde Spring.
    import com.opensymphony.xwork2.ActionSupport;
    import es.aragon.sfe.core.dao. IDraftDao;
    public class LoginAction extends ActionSupport {
    private static final long serialVersionUID = 1L;
    private IDraftDao draftDAO;
    //Fjese que los objetos inyectados por Spring son del tipo de su Interfaz
    private IAbogadoService abogadoService;
    //getters & setters del objeto inyectado (draftDAO, abogadoService)
    }

    En Spring se pueden importar los fichero.properties de dos formas distintas:


    valor.usuario = usuario
    valor.cantidad = 10

    Mtodo tradicional en XML:


    1. Definiendo directamente un PropertyPlaceholderConfigurer que contendr todos los .properties
    que queramos utilizar.
    <bean id=propertyConfigurer
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location">
    <value>classpath:fichero.properties</value>
    </property>
    </bean>

    Ms fcil todava con context:property-placeholder (OJO: slo disponible a partir de Spring 2.5)
    <context:property-placeholder location="classpath:fichero.properties" />

    Nota: Para importar ms de un fichero, simplemente se separan con comas.


    Ahora ya estamos en condiciones de inyectar los valores de los parmetros definidos en el
    fichero.properties en nuestro applicationContext.xml
    <bean id="beanSpring" class="com.danielme.blog.spring.properties.BeanSpring">
    <property name="cantidad" value="${valor.cantidad}" />
    <property name="usuario" value="${valor.usuario}" />
    </bean>

    Y listo. Ejecutamos nuestro Main para comprobar que la inyeccin se ha realizado correctamente, y
    que incluso el nmero se ha inyectado en un Integer. No obstante, deberemos tener cuidado con estas
    conversiones ya que son susceptibles de provocar un hermoso java.lang.NumberFormatException.

    Nota: se pueden importar .properties desde cualquier ubicacin utilizando un location como
    file:///C:\\configuraciones\\config.properties. Esta posibilidad puede ser interesante a la hora de
    simplificar la configuracin de aplicaciones web.

    Mtodo con Anotaciones:


    Si usamos Spring 3.1 se pueden inyectar los valores de los parmetros de los .properties
    simplemente utilizando la anotacin @Value. En nuestro ejemplo, primero tendramos que habilitar
    el autowiring mediante anotaciones en el applicationContext.xml y eliminar la inyeccin en
    beanSpring de las propiedades cantidad y usuario. Pero vamos a ir un paso ms all y realizar la
    definicin del propio bean con anotaciones. As pues, el fichero applicationContext.xml quedara
    as:
    <?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.1.xsd">
    <!-- ruta en la que se buscarn los beans anotados -->
    <context:component-scan base-package="com.danielme" />
    <context:property-placeholder location="classpath:config.properties" />
    </beans>

    Ahora tendremos que anotar el bean con @Service para que los instancie el contenedor y hacer la
    inyeccin mediante @Value. Esta inyeccin se va a hacer directamente en los atributos por lo que se
    puede prescindir de los setters si se crearon slo para poder inyectar las dependencias.
    package com.danielme.blog.spring.properties;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
    @Service
    public class BeanSpring{
    @Value("${valor.cantidad}")
    private Integer cantidad;
    @Value("${valor.usuario}")
    private String usuario;
    public Integer getCantidad(){
    return cantidad;
    }
    public String getUsuario() {
    return usuario;
    }

    Como vemos, gracias a Spring 3.1 podemos seguir reduciendo los XML en favor del uso de
    anotaciones siguiendo la tendencia impulsada por JEE y que poco a poco se va imponiendo en el
    mundo Spring.
    En el caso de que estemos usando una versin a anterior a Spring 3.1, se puede realizar tambin la
    inyeccin mediante autowired definiendo los valores de los properties como beans de Spring de la
    siguiente forma:
    <bean id="cantidad" class="java.lang.Integer">
    <constructor-arg value="${valor.cantidad}"/>
    </bean>
    <bean id="usuario" class="java.lang.String">
    <constructor-arg value="${valor.usuario}"/>
    </bean>

    Es una solucin menos elegante y limpia que la anterior pero nos permite seguir definiendo y
    configurando los beans con anotaciones en versiones anteriores de Spring que, por otra parte,
    tampoco podemos calificar como antiguas ya que Spring 3.1 se public en diciembre de 2011.
    Nota: Podemos tambin leer fichero.properties desde una clase java de la siguiente manera:
    import java.util.Properties;
    public void conectar() {
    properties = new Properties();
    String url;
    String login;
    String password;
    try {
    //Cargamos los datos de nuestro fichero.properties
    properties.load(ConnectionOracle.class.getClassLoader().
    getResourceAsStream("lang/fichero.properties"));
    } catch (IOException ex) {
    LOG.error("Existe un error al cargar el properties :"+ex);
    ex.printStackTrace();
    }
    url=properties.getProperty("url.oracle.server");
    login=properties.getProperty("url.oracle.server.usuario");
    password=properties.getProperty("url.oracle.server.password");
    conectar(url, login, password);
    }

    También podría gustarte