Monthly Archives: February 2009

Como configurar una aplicacion basica Spring 2.5 con Maven 2

Published / by Renan Huanca / Leave a Comment

Hola java adictos,

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 馃槈

How to use transacions with Spring 2.5 AOP and Hibernate 3.2.5

Published / by Renan Huanca / 4 Comments on How to use transacions with Spring 2.5 AOP and Hibernate 3.2.5

Hello friends.

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

Como crear paquetes de distribucion con maven

Published / by Renan Huanca / Leave a Comment

Hola espero estos links les sirva.

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

Very first steps in python

Published / by Renan Huanca / Leave a Comment

Hi, today I’d begun to write some code in python.

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:
    pyhonconsole
  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

How to use spring’s component-scan and annotation-config

Published / by Renan Huanca / Leave a Comment

What context:annotation-config is for?

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. 馃檪