Esta vez les mostrare un pequeño ejemplo de como usar el MultiActionController de Spring 2.5

Descripcion del ejemplo

Bueno, esta pequeña aplicación lo unico que hace es mostrar un formulario con un solo campo que corresponde al nombre de una mascota. Cada vez que se hace submit del nombre de la mascota, esta se adiciona a una lista en session llamada pets (no recomiendo usar variables en session). Luego esta lista se va desplegando en la parte inferior del formulario.

Para este ejemplo voy a asumir que ya tienen las librerías de spring y también configurado en el archivo web.xml de tu aplicación.

A  grandes rasgos lo que vamos a hacer es lo siguiente:

• Creamos el bean Pet (solo para los propositos de este ejemplo)
• Crear y declarar PetController en el contexto de spring.
• Crear el view JSP y declararlos en el contexto de spring.
• Probar la funcionalidad.

Creamos el bean Pet (solo para los propositos de este ejemplo)

package bo.sumasoftware.hellospring;

/**
 * @author renan
 */
public class Pet {
    String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Este bean, es solo para nuestro ejemplo y solo tiene una propiedad llamada name con su respectivo get y set. Se utilizara para leer datos del formulario y tambien para desplegar.

Crear y declarar PetController en el contexto de spring.

package bo.sumasoftware.hellospring;

import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.ArrayList;

/**
 * @author renan
 */
public class PetController extends MultiActionController {
    /**
     * This is called form http://localhost:8080/<context>/pet.do?method=form
     *
     * @param request
     * @param response
     * @param pet
     * @return
     */
    public ModelAndView form(HttpServletRequest request, HttpServletResponse response, Pet pet) {
        if(pet.getName()!=null){
            List pets = (List) request.getSession().getAttribute("pets");
            if(pets == null) {
                pets = new ArrayList();
                request.getSession().setAttribute("pets",pets);
            }
            pets.add(pet);
        }
        ModelAndView mav = new ModelAndView("pet");
        mav.getModel().put("pet", new Pet());
        return mav;
    }
}

Fuiu, es un poco largo la clase no?   pero ni modo, lo mas importante es que que estamos declarando un método con el nombre form, por si acaso esto no es un nombre especial ni nada por el estilo, puede ser cualquier nombre que ustedes definan. Lo importante es saber solo usando este nombre se podrá llamar a este método desde url o formulario.

Pet, es el nombre del beanForm o commandName como se lo llama en spring. Es en este objeto que spring colocar los valores de los import del html from que viene del browser. Algo también interesante es que no es requerido definir este parámetro, también se puede colocar otros, mas información en http://static.springframework.org/spring/docs/2.0.x/reference/mvc.html#mvc-controller-multiaction.

pets, es la lista que desplegaremos en el jsp, lo interesante es que se hace proceso para crearla si no esta en session.

new ModelAndView(“pet”), de esta forma le decimos a spring a que view queremos que direccione la salida del controller.

ahora veremos como se define el controller en el contexto de spring

    <bean name="/pet.do" class="bo.sumasoftware.hellospring.PetController">
        <property name="methodNameResolver">
            <bean class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
                <property name="paramName" value="method"/>
            </bean>
        </property>
    </bean>

/pet.do,  es la forma de mapear la llamada desde un url. Cabe señalar que esta forma de mapeo es una de las mas basicas, spring tienes algunas como por ejemplo basado en archivo xml y tambien archivo de propiedades.

ParameterMethodNameResolver, este es el que me interesa mas, con esto le estamos diciendo al controller como se van a llamar a sus metodos. Aca estamos definiendo que para llamar a algun metodo de la clase PetController, ya sera por un get(url) o post(formulario) se tiene que incluir como dato un valor llamado ‘method‘, esta variable contendra el nombre del metodo dentro del controller que queremos llamar. (para el emplo el valor que tendra sera ‘form’)

Crear el view JSP y declararlos en el contexto de spring.

Creamos un archivo con el nombre pet.jsp dentro de un folder llamado /jsp. (mas adelante la explicacion del por que)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<html>
<head><title>Pet</title></head>
<body>
<form:form action="pet.do" method="post" commandName="pet">
    <h4>Pet</h4>
    Pet Name:<form:input path="name"/><br/>
    <input type="hidden" name="method" value="form"/><br/>
    <input type="submit"/>
</form:form>
<h4>pets</h4>
<c:forEach items="${sessionScope.pets}" var="pet">
    ${pet.name} <br/>
</c:forEach>

</body>
</html>

Este jsp, no estan largo. que bueno , la primera parte solo es para definir los tags que vamos a usar en este caso el tag form de spring y el tag c de jstl.

Como veran se define un formulario donde se define que el action sera pet.do, osea que cuando se haga submir del formulario el request se dirigira a este. Despues se define tambien un input, que sirve para declarar un input field, que tiene el nombre name.

name=”method” value=”form”, este es el mas, mas importante, acá indicamos cual sera el método a llamar del controller, sino hacemos esto, les aseguro que tendremos muchos dolores de cabeza. Cabe tambien señalar que no es necesario que sea una constante, puede cambiar, lo puedes setear con java script o algun otro truco que conozcas. Lo importante es enviar un valor.

Despues lo que hacemo es iterar una lista que esta en session que se llama pets, se despliega el nombre y nada mas.

Ahora a mapear las views

    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

Bueno, esta es la forma mas basica de mapear view, todos los jsps tienen que estar dentro de el folder /jsp/. Como es tan basica y tambien la mas sencilla  a veces uno no se da cuenta como es que se puede llamar a una view especifica.

La clave esta en la clase ModelAndView en el controller, si vuelven al codigo del controller veran que hay una sentencia como esta: new ModelAndView(“pet”). Lo que hara spring es buscar un archivo pet.jsp que este dentro de la carpeta jsp.

Probar la funcionalidad.

Ahora a probar,  el url para llamar al controller sera:

http://localhost:8080/hello/pet.do?method=form

Como veran, estoy colocando como paremetro extra que metodo del controller voy a llamar.

Luego aparecera un formulario como esto:

En el input field pueden colocar nombres de sus mascotas y veran que se iran adicionando en una lista debajo de la palabra pets.

Finalmente para aquellos que quieren ver algo mas, acá tengo el código fuente. (para los que usan maven, tambien esta el pom.xml, para los que no, tendran que incluir los jars necesarios)

Encontré un buen post acerca de como funciona el SpringMVC veanlo.

Comentarios son bien recibidos, hasta la próxima

Esta vez mostrare como crear una aplicación Spring con Maven

Descripción del Ejemplo

Se creara una aplicación que simplemente mostrar “Hello World with Spring “. El mensaje sera obtenido de un bean llamado Greeting.

Vamos asumir que ya tienen instalado maven2, y java , no sera necesario que bajen Spring ya que el mismo maven lo hara por ustedes.

A grandes rasgos, los pasos serán los siguientes:

• Crear aplicación base con maven.
• Editar pom.xml para adicionar dependencia base de Spring.
• Crear el bean Greeting.
• Crear archivo de contexto de aplicación de Spring.
• Modificar clase App y para probar funcionalidad.

Crear aplicación base con maven

Para esto vamos a hechar mano del comando mvn archetype:create. Nos posicionaremos en el folder donde deseemos trabajar y ejecutamos el siguiente comando:

mvn archetype:create -DgroupId=com.sumasoftware.hellospring -DartifactId=HelloSpring

Con la ejecución del anterior comando se creara un folder llamado HelloSpring

con la respectiva estructura de directorios de maven.

(Justo vi un post en otro blog sobre este aspecto, asi que pueden verlo para mas detalles)

Editar pom.xml para adicionar dependencia base de Spring

Ingresamos al folder llamado HelloSpring y editamos el archivo con cualquier editor a disposición.

Sera algo parecido a esto:

<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.sumasoftware.hellospring</groupId>
    <artifactId>HelloSpring</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>HelloSpring</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

Dentro del tag <dependencies> adicionamos:

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

Como verán solo vamos a utilizar el core de spring, osea la base. Esto es suficiente para lo que necesitamos ahora. Por supuesto para una aplicación mas compleja necesitaríamos adicionar mas dependencias (ej.: spring-context, spring-tx, spring-web, etc…)

Crear el bean Greeting

Ok. ahora vamos al código. por fin!:) pero es algo fácil. Vamos a crear el siguiente bean Greeting en el folder HelloSpring/src/main/java/com/sumasoftware/hellospring. (Ojo, que com/sumasoftware/hellospring es el paquete de la clase )

package com.sumasoftware.hellospring;
public class Greeting {
    public void sayHello(){
        System.out.println("Hello World with Spring  ");
    }
}

Ahora ejecutamos en la consola el comando:

mvn package

Con esto se verifica que no hay errores de sintaxis y se aprovecha de bajar las dependencias.

Crear archivo de contexto de aplicacion de Spring

Ahora vamos con spring, eeeh!!! . Para esto vamos a crear el archivo appContext.xml dentro de un folder nuevo llamado resources que estara dentro de HelloSpring/src/main. Entonces el path del archivo sera HelloSpring/src/main/resources/appContext.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-2.5.xsd">
    <bean id="greeting" class="com.sumasoftware.hellospring.Greeting"/>
</beans>

Modificar clase App y para probar funcionalidad

Por defecto, cuando maven crea una aplicacion, crea la clase App que solo tiene un Hello World vamos a modificar la clase, para que cargue el contexto de spring, obtenga el bean y llame al metodo sayHello().

package com.sumasoftware.hellospring;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Hello world!
 *
 */
public class App
{
    public static void main( String[] args )
    {
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("classpath:appContext.xml");
        Greeting greeting = (Greeting) context.getBean("greeting");
        greeting.sayHello();
    }
}

Mas referencia acerca de como crear o instanciar el factory lo encuentra en la documentación de Spring

Listo ya terminamos, ahora como lo ejecutamos ? bueno yo lo hice con idea. justo maven tiene un otro plugin que se llama idea que te ayuda a crear el archivo de projecto configurado con las dependencias. Solo se tiene que escribir en la linea de comando mvn idea:idea, maven crea el archivo de proyecto, abrimos el proyecto configuramos la clase main y listo. (Lo mismo hay para eclipse)

Claro te también se puede ejecutar desde linea de comando. Solo que es mas trabajoso, ustedes elijan el que mas les guste.

Una vez ejecutada la clase App, esta despliega en consola lo siguiente:

Feb 28, 2009 1:19:19 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@32fb4f: display name [org.springframework.context.support.ClassPathXmlApplicationContext@32fb4f]; startup date [Sat Feb 28 01:19:19 BOT 2009]; root of context hierarchy
Feb 28, 2009 1:19:19 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [appContext.xml]
Feb 28, 2009 1:19:19 AM org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory
INFO: Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@32fb4f]: org.springframework.beans.factory.support.DefaultListableBeanFactory@16a786
Feb 28, 2009 1:19:19 AM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@16a786: defining beans [greeting]; root of factory hierarchy
Hello World with Spring  

Espero este tutorial sirva de mucha ayuda. Acá esta el código fuente. Comentarios son bien recibidos.

Hasta la proxima

The first time when i was training to use spring and hibernate i wanted to avoid to open and close transaction manually in every method that does some transaction.

   i.e. (pseudo code)
       void createSomeObject(par1, par2, par3) {
           open transaccion
           create object using the given parameters
           persist the object
           close transaction
       }

So i found that spring helps you to do that.

I will assume that you already created the Java Bean (POJO) and it’s hibernate mapping file. ( SomePOJO.java and SomePOJO.hbm.xml files).

1. Define AOP and Transaction  namespace in spring application context configuration file. (Find more about AOP and Transaction Management)

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
       ... ...
</beans>

2. Define data source to configure the database connection parameters.

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="org.postgresql.Driver"/>
    <property name="url" value="jdbc:postgresql://localhost/somedb"/>
    <property name="username" value="someuser"/>
    <property name="password" value="somepassword"/>
</bean>

3. Define Hibernate SessionFactory.

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mappingResources">
        <list>
            <value>/some/package/model/SomePOJO.hbm.xml</value>
        </list>
    </property>
    <property name="hibernateProperties">
        <value>
            hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
        </value>
    </property>
</bean>

4. Define Transaction aspect. (more info)

<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

<tx:advice id="txAdvice" transaction-manager="txManager">
    <tx:attributes>
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

5. Define point cuts in your service.

<aop:config>
    <aop:pointcut id="someServiceMethods" expression="execution(* some.package.service.SomeService.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="someServiceMethods"/>
</aop:config>

Spring will begin a transaction each time a method in SomeService is called. This behavior can be changed (see) , I just tried to do the example the most simple as possible.

I will try to prepare some package with source code. just let me know.

Regards

-Renan

Explica como  usar el plugin  assembly de maven. Este plugin es muy bueno ya nos ayuda a empaquetar nuestro código fuente para distribuir o crear un jar ejecutable .

http://www.chuidiang.com/chuwiki/index.php?title=Hacer_un_zip_para_distribuir

Este es también bueno que da una vista mas detallada, pero esta en ingles sorry

http://propellors.net/maven/book/assemblies.html

1. I’d like how it is explained in detail
2. I’d like how it is using mave2

so, take a look a it

Spring 2.5 and annotation-based dependency injection

Llenando este formulario ayudaras a encaminar a la comunidad.

Currently there are two version: 2.6.1 and 3.0. Because I’m new I used 2.6.1

Here are the basic steps to begin with

1. Download and install python , http://www.python.org/download/
2. To use python directly from the console you should add the python to your systems path, some think like:
   • In windows set PATH=PATH;c:\python
   • In linux export PATH=PATH:/python
3. If everything is OK, you should be able to write pyhon in the command line and it should return this:
   
4. Now it is time to test some examples. Python’s site have a Beginner guide and some very simple examples
5. You can test the examples directly in the python’s command line
6. If you are plan to use eclipse here there is a good plugin  http://begnu.wordpress.com/2007/09/26/pydev-python-eclipse/, also you may want to see http://begnu.wordpress.com/2007/09/26/pydev-python-eclipse/

Now just test the examples a see what happens

This is it for now. bye.

- Reni

It allow us to use @Autowire, @Required and @Qualifier annotations.

What context:component-scan is for?

It allow @Component, @Service, @Controller, etc.. annotations.

What is the advantage?

It allows us to manage dependency directly in the java class.

Step by Step example.

This example show how to classes:

- Adder.java, A class to do the arithmetic add operation

- Calculator.java, A class that calls the Adder class using the Autowired annotation

1. Write an applicationContext file and put it in the root of the classpath.

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns: xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

       <context:component-scan base-package="test.example"/>
       <context:annotation-config/>
</beans>

you should provide to component-scan the base path you what to scan component

2. Write Adder.java

package test.example;
import org.springframework.stereotype.Component;

@Component("adder")
public class Adder {
    public int add(int a, int b){
        return a + b;
    }
}

3. Write Calculator.java

package test.example;

import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;

@Component("calculator")
public class Calculator {
    private Adder adder;

    @Autowired
    public void setAdder(Adder adder) {
        this.adder = adder;
    }

    public void makeAnOperation(){
        int r1 = adder.add(1,2);
        System.out.println("r1 = " + r1);   
    }
}

4. Write the main method (it can be in a class called Main.java):

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(context);
        xmlReader.loadBeanDefinitions(new ClassPathResource("applicationContext.xml"));
        context.refresh();
        Calculator calculator = (Calculator) context.getBean("calculator");
        calculator.makeAnOperation();
    }

How it is working?

1. We are declaring two components (@Component) ‘Adder’ and ‘Calculator’. It is is very important to note that the name of the component is between (“….”) just next to the @Component annotation.

2. We are declaring one autowired method in Calculator.java. With it, you don’t have to instanciate manually an Adder. just use it.

1. My XHTML file was not well formatted.
2. The majority of parser are a little complicated api, because are more oriented to well formed documents.

So, I found HTML Parser. This one was very easy to use. Here is an example: Let’s have some html called test.html like this:

<html>
    <head></head>
    <body>
        <img>
        <h1>Hello World</h1>
    </body>
</html>

You want to get the tag <h1> that has “Hello Word”, note that the tag <img> is incomplete. Let’s code.

Parser parser = new Parser("test.html");
NodeList list = parser.parse(new HasChildFilter(new StringFilter("Hello World")));
System.out.println("tag founded = " + list.elementAt(0).toHtml());

The previous code finds the tag <h1> and prints:

tag founded = <h1>Hello World</h1>

Here is the explanation:

Parser class, this class is in charge to load the html file.

parser.parse(), is the method that get all nodes or filter the nodes you want to use.

HasChildFilter and StringFilter, are in charge to filter the nodes. In the example we are looking all tags that has children with the text ‘Hello Word’.

These filters, saved me a lot of work, Html Parser has other filters too.

Well this is it for now .