Renan Huanca http://renidev.javabolivia.com Just want to share my experiences when working in software development Sat, 08 May 2010 12:38:14 +0000 http://wordpress.org/?v=2.7.1 en hourly 1 Como grabar las peticiones o requests con JMeter http://renidev.javabolivia.com/2010/05/08/como-grabar-las-peticiones-o-requests-con-jmeter/ http://renidev.javabolivia.com/2010/05/08/como-grabar-las-peticiones-o-requests-con-jmeter/#comments Sat, 08 May 2010 12:38:14 +0000 Renan Huanca http://renidev.javabolivia.com/?p=493 Hola Amigos,

Acá un vídeo muy bueno de como grabar la peticiones o requests utilizando JMeter para hacer las pruebas de carga or también llamadas pruebas de stress. (Aunque esta en ingles pero creo que es lo suficientemente descriptivo)

Espero les sea de utilidad :)

Su amigo, Renan

]]> http://renidev.javabolivia.com/2010/05/08/como-grabar-las-peticiones-o-requests-con-jmeter/feed/ Hola Mundo con Spring BlazeDS y Flex http://renidev.javabolivia.com/2010/05/02/hola-mundo-con-spring-blazeds-y-flex/ http://renidev.javabolivia.com/2010/05/02/hola-mundo-con-spring-blazeds-y-flex/#comments Mon, 03 May 2010 00:54:09 +0000 Renan Huanca http://renidev.javabolivia.com/?p=467 Hola amigos, acá comparto un ejemplo de como desarrollar un “Hola mundo” con Spring BlazeDS y con Flex.

Vamos directo al código :)

Maven

Las principales cosas que definimos en el archivo maven son:

  1. Dependencias JSP/Servlet.
  2. Dependencias para el Spring framework.
  3. Dependencias para el Spring BlazeDS.
  4. Plugin para compilar java con 1.5 que tiene soporte para anotaciones.
?View Code XML
<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">
    ...
 
    <!-- defining some properties -->
    <properties>
        <org.springframework.version>3.0.0.RELEASE</org.springframework.version>
    </properties>
 
    <!-- dependencies -->
    <dependencies>
        ...
        <!-- jsp/servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
 
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
 
        <!-- spring 3 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.flex</groupId>
            <artifactId>spring-flex</artifactId>
            <version>1.0.3.RELEASE</version>
        </dependency>
 
        <!-- blazeds -->
        <dependency>
            <groupId>com.adobe.blazeds</groupId>
            <artifactId>blazeds-core</artifactId>
            <version>3.2.0.3978</version>
        </dependency>
        <dependency>
            <groupId>com.adobe.blazeds</groupId>
            <artifactId>blazeds-proxy</artifactId>
            <version>3.2.0.3978</version>
        </dependency>
        <dependency>
            <groupId>com.adobe.blazeds</groupId>
            <artifactId>blazeds-opt</artifactId>
            <version>3.2.0.3978</version>
        </dependency>
        <dependency>
            <groupId>com.adobe.blazeds</groupId>
            <artifactId>blazeds-remoting</artifactId>
            <version>3.2.0.3978</version>
        </dependency>
 
        ...
    </dependencies>
    <build>
        <finalName>helloblazeds</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                </configuration>
            </plugin>
            ...    
        </plugins>
    </build>
</project>

web.xml

En el web.xml tenemos:

  1. Definición de un Filtro para soportar caracteres UTF8.
  2. Mapeo de la servlet de Spring para manejar cualquier pedido que pase por /messagebroker/*.
?View Code XML
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="ifm_service_catalog" 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">
 
    <display-name>Hello World with SpringBlazeDS</display-name>
 
    <!-- filter -->
    <filter>
        <filter-name>encoding-filter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
 
    <filter-mapping>
        <filter-name>encoding-filter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
 
    <!-- servlet -->
 
    <servlet>
        <servlet-name>spring-flex</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/flex-servlet-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>spring-flex</servlet-name>
        <url-pattern>/messagebroker/*</url-pattern>
    </servlet-mapping>
 
    <!-- Welcome file list -->
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>
</web-app>

flex-servlet-context.xml, services-config.xml y remoting-config.xml

El flex-servlet-context.xml es bien sencillo. Solo le indicamos a Spring que paquete escanear para buscar clases anotadas y la definición del bean MessageBroker para la integración con Flex.

?View Code 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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:flex="http://www.springframework.org/schema/flex"
       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
                           http://www.springframework.org/schema/flex
                           http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
    <context:component-scan base-package="test.flex" />
    <flex:message-broker/>
</beans>

El services-config.xml sirve para definir los canales y servicios que serán soportados. Véase también que en el canal estamos indicando como vienen los pedidos, en este caso “/messagebroker/amf”

?View Code XML
<?xml version="1.0" encoding="UTF-8"?>
<services-config>
    <services>
        <service-include file-path="remoting-config.xml" />
        <default-channels>
           <channel ref="my-amf-channel"/>
        </default-channels>
    </services>
 
    <channels>
        <channel-definition id="my-amf-channel" class="mx.messaging.channels.AMFChannel">
            <endpoint url="http://{server.name}:{server.port}/{context.root}/messagebroker/amf"
                      class="flex.messaging.endpoints.AMFEndpoint"/>
        </channel-definition>
    </channels>
    <logging>
        <target class="flex.messaging.log.ConsoleTarget" level="Error">
            <properties>
                <prefix>[BlazeDS]</prefix>
                <includeDate>false</includeDate>
                <includeTime>false</includeTime>
                <includeLevel>false</includeLevel>
                <includeCategory>false</includeCategory>
            </properties>
            <filters>
                <pattern>Endpoint.*</pattern>
                <pattern>Service.*</pattern>
                <pattern>Configuration</pattern>
            </filters>
        </target>
    </logging>
    <system>
        <redeploy>
            <enabled>false</enabled>
        </redeploy>
    </system>
</services-config>

En el remoting-config.xml definimos el adaptar java para AMF.

?View Code XML
<?xml version="1.0" encoding="UTF-8"?>
<service id="remoting-service"
         class="flex.messaging.services.RemotingService">
    <adapters>
        <adapter-definition id="java-object"
                            class="flex.messaging.services.remoting.adapters.JavaAdapter"
                            default="true"/>
    </adapters>
    <default-channels>
        <channel ref="my-amf-channel"/>
    </default-channels>
</service>

Clase SayHello

La siguiente clase esta anotada como servicio y también como destinación remota para AMF :)

?View Code JAVA
package test.flex;
 
import java.io.*;
import java.util.List;
import org.springframework.flex.remoting.RemotingDestination;
import org.springframework.stereotype.Service;
 
@Service("SayHello")
@RemotingDestination
public class SayHello {
 
    public String hello(){
        return "Hola Mundo";
    }
}

Finalmente el código en Flex :)

En la aplicación Flex tenemos:

  1. Definición de object RemoteObject.
  2. Un botón pulsante para llamar al metodo hello().
  3. Definición de dos funciones flex para manejar la respuesta en caso de éxito y fallo de la llamada.
?View Code XML
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
<mx:Script>
<![CDATA[
import mx.rpc.events.ResultEvent;
import mx.rpc.events.FaultEvent;
import mx.utils.ObjectUtil;
import mx.controls.Alert;
import mx.utils.StringUtil;
 
/**
 * Response handler
 */            
private function resultHandler(event:ResultEvent):void{
    Alert.show( ObjectUtil.toString(event.result) );   
}
/**
 * Failure handler
 */
private function faultHandler(event:FaultEvent):void{
    Alert.show( ObjectUtil.toString(event.fault) );
}
]]>
 
</mx:Script>
 
<!-- Remote object that is accessed from the server.-->
<mx:RemoteObject id="remoteObject" 
 destination="SayHello"   
 result="resultHandler(event)"
 fault="faultHandler(event)"     
 endpoint="http://localhost:8080/helloblazeds/messagebroker/amf"/>
 
<mx:Panel width="457" 
    height="228" 
    layout="vertical" 
    title="Hola Mundo con AMF/Flex y BlazeDS" 
    horizontalAlign="center">
    <mx:Button label="Hola Mundo!" click="remoteObject.hello()"/>
</mx:Panel>    		
</mx:Application>
]]> http://renidev.javabolivia.com/2010/05/02/hola-mundo-con-spring-blazeds-y-flex/feed/ Mi presentación en la FLISOL - El Alto - Bolivia, 2010 http://renidev.javabolivia.com/2010/04/25/mi-presentacion-en-la-flisol-el-alto-bolivia-2010/ http://renidev.javabolivia.com/2010/04/25/mi-presentacion-en-la-flisol-el-alto-bolivia-2010/#comments Sun, 25 Apr 2010 23:30:12 +0000 Renan Huanca http://renidev.javabolivia.com/?p=463 Hola Amigos acá comparto la presentación que hice el sábado (de Abril) pasado con motivo de la FLISOL en la ciudad de El Alto - Bolivia, 2010.

Procesos aplicados al desarrollo de software
View more presentations from Renan Huanca.
]]> http://renidev.javabolivia.com/2010/04/25/mi-presentacion-en-la-flisol-el-alto-bolivia-2010/feed/ Escaneando anotaciones con Spring http://renidev.javabolivia.com/2010/04/18/escaneando-anotaciones-con-spring/ http://renidev.javabolivia.com/2010/04/18/escaneando-anotaciones-con-spring/#comments Sun, 18 Apr 2010 23:52:33 +0000 Renan Huanca http://renidev.javabolivia.com/?p=446 Hola Amigos, acá comparto un poco de código que escribí esta semana.

El Problema

Esta semana estaba trabajando con AMF, mi problema era listar las classes que estaban anotadas con la anotación @RemotingDestination, para luego poder listarlas en una consola. (Con el objetivode mostrar los servicion AMF disponibles en el servidor)

Aca un ejemplo de una clase anotada con @RemotingDestination

?View Code JAVA
package some.good.packague.to.work; // :)
 
import org.springframework.flex.remoting.RemotingDestination;
import org.springframework.stereotype.Service;
 
@Service("userService")
@RemotingDestination
public class UserService{
 
    public String getUserName(String userId) {
        .....
        return "The best name in the world :)";
    }
 
}

La Solución

Primeramente estaba viendo Javassist, pero al final me quede con una solución con Spring.

El ejemplo lo encontré el blog de Java Chimaera, pero le hice algunas modificaciones para que ahora soporte buscar clases tanto en linux como en windows.

El Código

?View Code JAVA
package yep.this.is.a.very.good.package;
 
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.classreading.SimpleMetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.util.ClassUtils;
 
import java.util.Set;
import java.util.HashSet;
import java.io.IOException;
 
/**
 * This class is a adaptation of:
 *
 *    http://java-chimaera.blogspot.com/2008/10/scanning-classpath-annotated-classes.html
 */
/**
 * @author Renan Huanca
 * @since Apr 16, 2010 9:52:12 PM
 */
public class AnnotatedClassFinder {
    private String basePackage;
    private ResourcePatternResolver resourceResolver = null;
    private MetadataReaderFactory metadataReaderFactory = null;
    private TypeFilter annotationFilter = null;
 
    public AnnotatedClassFinder(String basePackage) {
        this.basePackage = basePackage;
        this.resourceResolver = new PathMatchingResourcePatternResolver(
                Thread.currentThread().getContextClassLoader());
        this.metadataReaderFactory = new SimpleMetadataReaderFactory();
    }
 
    public static AnnotatedClassFinder getInstance(String basePackage){
        return new AnnotatedClassFinder(basePackage);
    }
 
    public Set findByAnnotation(Class annotation) {
        this.annotationFilter = new AnnotationTypeFilter(annotation);
        Set <Class>annotatedClasses = new HashSet();
        /*
        * First of all we load all resources that are under a specific package by using a ResourcePatternResolver.
        * By doing so we will use class files as simple resources without passing
        * by the ClassLoader which can for example cause the execution of a static initialization block.
        * It resolves also transparently resources in jars.
        */
        String candidateClassesLocationPattern = "classpath*:" + basePackage + "/**/*.class";
        Resource[] resources = null;
        try {
            resources = resourceResolver.getResources(candidateClassesLocationPattern);
        } catch (IOException e) {
            throw new RuntimeException(
                    "An I/O problem occurs when trying to resolve ressources matching the pattern : "
                            + candidateClassesLocationPattern, e);
        }
 
        /*
        * then we proceed resource by resource, using a MetadataReaderFactory to create
        * MetadataReader wich hides the ASM related interface and complexity.
        *
        */
        for (Resource resource : resources) {
            MetadataReader metadataReader = null;
            try {
                metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
 
                if (this.annotationFilter.match(metadataReader, metadataReaderFactory)) {
 
                    /*
                    * the AnnotationMetadata is a simple abstaction of the informations
                    * that holds the annotation
                    */
                    String className = convertResourceToClassName(resource, basePackage);
                    try {
                        annotatedClasses.add(ClassUtils.forName(className));
                    } catch (Exception e) {
                        throw new RuntimeException("problems occurs when trying to load the annotated class : " + className, e);
                    }
                }
            } catch (IOException e) {
                throw new RuntimeException("An I/O problem occurs when trying to process resource : " + resource, e);
            }
        }
 
        return annotatedClasses;
    }
 
    static String convertResourceToClassName(Resource resource, String basePackage) throws IOException {
        String path = resource.getFile().getPath();
        String pathWithoutSuffix = path.substring(0, path.length() - ClassUtils.CLASS_FILE_SUFFIX.length());
        String relativePathWithoutSuffix = "";
        if(System.getProperty("file.separator").equals("\\")) {
            relativePathWithoutSuffix = pathWithoutSuffix.substring(pathWithoutSuffix.indexOf(basePackage.replace('/', '\\')));
            relativePathWithoutSuffix = relativePathWithoutSuffix.replace('\\', '/');
        } else if(System.getProperty("file.separator").equals("//")) {
            relativePathWithoutSuffix = pathWithoutSuffix.substring(pathWithoutSuffix.indexOf(basePackage));
        } else {
            throw new RuntimeException("File separator is not recognized");
        }
 
        // taking out extra \ or /
        relativePathWithoutSuffix = relativePathWithoutSuffix.substring(1);
 
        return relativePathWithoutSuffix.replace('/', '.');
    }
}

Como llamarlo?

?View Code JAVA
AnnotatedClassFinder finder = AnnotatedClassFinder.getInstance("/the/package/you/want/to/search");
Set classes = finder.findByAnnotation(RemotingDestination.class);
]]> http://renidev.javabolivia.com/2010/04/18/escaneando-anotaciones-con-spring/feed/ Convertir PDF a SWF con AIR 2 beta http://renidev.javabolivia.com/2010/04/04/convertir-pdf-a-swf-con-air-2-beta/ http://renidev.javabolivia.com/2010/04/04/convertir-pdf-a-swf-con-air-2-beta/#comments Sun, 04 Apr 2010 20:52:22 +0000 Renan Huanca http://renidev.javabolivia.com/?p=433 Introducción

Hola Amigos, acá comparto una la solución a un problema que tuve esta semana. Se trata de convertir un archivo PDF al formato flash SWF.

Aca un resumen de los problemas:

  1. No existe (al momento) una forma nativa dentro de AIR para convertir un archivo pdf a swf, entonces tuve que hacer la llamada al comando pdf2swf.exe (SWFTools) desde AIR
  2. La opcion de ejecutar comandos de linea solo esta disponible en Adobe AIR 2 Beta (al momento), entonces me anime a usar la versión beta

El código

?View Code FLEX
import __AS3__.vec.Vector;
 
import flash.desktop.NativeProcess;
import flash.desktop.NativeProcessStartupInfo;
import flash.events.IOErrorEvent;
import flash.events.NativeProcessExitEvent;
import flash.events.ProgressEvent;
import flash.events.TimerEvent;
import flash.filesystem.File;
import flash.utils.Timer;
 
import mx.core.FlexGlobals;
 
public class PDF2SWFConverter
{
	private var command:String;
	private var finished:Boolean = false;
	private var error:Boolean = false;
	private var timer:Timer;
 
	public function PDF2SWFConverter(command:String)
	{
		this.command = command;	
	}
 
	public static function getInstance():PDF2SWFConverter{
		return new PDF2SWFConverter("/path/to/pdf2swf.exe");	
	} 
 
	public function convert(pdfPath:String, swfPath:String):Boolean {
		var nativeProcessStartupInfo:NativeProcessStartupInfo =  new NativeProcessStartupInfo();
		var commandFile:File = new File(command); 
		nativeProcessStartupInfo.executable = commandFile;
		var args:Vector.<String> = new Vector.<String>();
		args.push(pdfPath);
		args.push("-t");
		args.push("-T9");
		args.push("-o");
		args.push(swfPath);
 
		nativeProcessStartupInfo.arguments = args;
		var process:NativeProcess;
 
		timer = new Timer(1);
 
		process = new NativeProcess();
		process.start(nativeProcessStartupInfo);
		process.addEventListener(NativeProcessExitEvent.EXIT, onExit);
		process.addEventListener(ProgressEvent.STANDARD_ERROR_DATA, onErrorData);
		process.addEventListener(IOErrorEvent.STANDARD_ERROR_IO_ERROR, onIOError);
 
		timer.addEventListener(TimerEvent.TIMER, myTimerHandler);
 
		this.finished = false;
		this.error = false;
		timer.start();
 
		return !error;
	}
 
	protected function onExit(event:NativeProcessExitEvent):void
	{
		this.finished = true;
	}
 
	public function onErrorData(event:ProgressEvent):void
	{
      		this.error = true;
          		this.finished = true; 
      	}
 
	public function onIOError(event:IOErrorEvent):void
      	{
      		this.error = true;
      		this.finished = true;
      	}
 
      	public function myTimerHandler(e:TimerEvent):void{
      		if(this.finished)
		{
			timer.stop();
		} 
	}
}

Convertir PDF a SWF

Para llamar desde Flex al comando pdf2swf.exe, usamos los objectos: NativeProcessStartupInfo y NativeProcess.

NativeProcessStartupInfo, nos permite definir la información inicial de la llamada (nombre de comando y parametros) a un comando de linea. Este objecto es usado como parámetro para el método start del objeto NativeProcess.

NativeProcess, nos permite realizar la llamada a un comando de linea. Cabe advertir que por motivos de seguridad, no es posible ejecutar archivos .bat.

También es necesario señalar que para ejecutar de comandos de linea la aplicacion AIR tiene que tener configurado el perfil de escritorio extendido. Para esto tenemos que añadir lo siguiente al app.xml de la aplicacion AIR:

?View Code XML
<i><supportedProfiles>extendedDesktop</supportedProfiles></i>

Como llamar a PDF2SWFConverter

Para llamar al objecto basta con lo siguiente:

?View Code JAVA
var converter:PDF2SWFConverter = PDF2SWFConverter.getInstance();
converter.convert("/path/to/doc.pdf","/path/to/new/doc.swf");

Esta clase es un wrapper (envoltura) para el comando, la ventaja es que uno puede llamar a la clase, ejecutar la conversión y continuar con la secuencia de instrucciones gracias a que se usa el el objeto Timer.

]]> http://renidev.javabolivia.com/2010/04/04/convertir-pdf-a-swf-con-air-2-beta/feed/ UnitTests http://renidev.javabolivia.com/2010/01/14/unittests/ http://renidev.javabolivia.com/2010/01/14/unittests/#comments Fri, 15 Jan 2010 00:57:50 +0000 Renan Huanca http://renidev.javabolivia.com/?p=409 Hola Amigos, disculpen el tiempo que no pude postear. Lo que pasa es que en mi trabajo me tenían muy ocupado :)

Hoy no puedo escribir, pero por lo menos quiero compartir dos muy buenos podcasts de los amigos de JavaHispano.

Les recomiendo que escuchen ya que hablan de las estrategias que usaron algunas empresas para implementar un proceso de unittest.

JavaHispano Podcast - 064 - Test de aplicaciones (Parte 1)
* Blog de Alfredo Casado
* Blog de Julio César Pérez
* Blog de Jose Luis Bugarín
* ¿Por qué hacer test?
* Buenas prácticas para programar tests
* Principio FIRST (Ver capítulo 9)
* Dossier sobre el test de software
* Historia de integración: 1, 2, 3, 4
* Blog de Misko Hevery.
* Crear código testeable.
* Desarrollo TDD.

JavaHispano Podcast - 065 - Test de aplicaciones (Parte 2)
* Blog de Julio César Perez
* Blog de Alfredo Casado
* Blog de Jose Luis Bugarin
* Site de Junit: http://www.junit.org/
* Site de DbUnit: http://www.dbunit.org/
* Site de XMLUnit: http://xmlunit.sourceforge.net/
* Site de JMeter: http://jakarta.apache.org/jmeter/
* Site de Selenium: http://seleniumhq.org/
* Site de Watir: http://watir.com/
* Site de EasyMock: http://easymock.org/
* Site de Mockito: http://mockito.org/
* Site de Fitnesse: http://fitnesse.org/
* Site de Concordion:http://www.concordion.org/
* Site de Hudson: https://hudson.dev.java.net/
* Site de WebDriver: http://code.google.com/p/webdriver/
* Site de SoapUi: http://www.soapui.org/
* Plugin de chuck-norris para hudson.

]]> http://renidev.javabolivia.com/2010/01/14/unittests/feed/ Hello World/Hola Mundo con RESTFul y Spring 3 http://renidev.javabolivia.com/2009/12/06/hello-worldhola-mundo-con-restful-y-spring-3/ http://renidev.javabolivia.com/2009/12/06/hello-worldhola-mundo-con-restful-y-spring-3/#comments Sun, 06 Dec 2009 22:15:19 +0000 Renan Huanca http://renidev.javabolivia.com/?p=401 Introducción.

Este es un ejemplo sencillo de RESTFul usando Spring 3 claro usando maven :)
Para este ejemplo estamos usando el Release Candidate 3 de Spring 3

Dependencias Maven

Solo se necesita una para este ejemplo

?View Code XML
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>3.0.0.RC2</version>
        </dependency>

Repositorio Maven de Spring 3

?View Code XML
        <repository>
            <id>SpringSource Maven Milestone Repository</id>
            <url>http://maven.springframework.org/milestone</url>
        </repository>

Declarando Spring Servlet

La servlet del spring framework se la declara en el web.xml.
Notemos que en el url-pattern, estamos indicando que vamos a mapear cualquier request a la servlet de spring.

?View Code XML
    <servlet>
        <servlet-name>mytest</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>mytest</servlet-name>
        <url-pattern>*</url-pattern>
    </servlet-mapping>

Declarando RESTFul Controller

El secreto esta en la anotación RequestMapping. En este caso, el nombre de la variable en url y en java son las mismas, pero se puede personalizar.

?View Code JAVA
 
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.stereotype.Controller;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletRequest;
...
 
/**
 * @author Renan Huanca
 * @since Nov 22, 2009  10:54:31 AM
 */
 
@Controller
public class RestController {
 
    @RequestMapping("/{tunombre}/")
    public void readTable(@PathVariable String tunombre,
                          HttpServletRequest request,
                          HttpServletResponse response){
        PrintWriter writer = response.getWriter();
        writer.print("Hola Mundo<br/>");
        writer.print("Como estas "+tunombre);
    }
 
}

Referencias

REST in Spring 3: @MVC

]]> http://renidev.javabolivia.com/2009/12/06/hello-worldhola-mundo-con-restful-y-spring-3/feed/ Aplicación multi-modulo “Hola Mundo” con Maven http://renidev.javabolivia.com/2009/11/01/application-multi-modulo-hola-mundo-con-maven/ http://renidev.javabolivia.com/2009/11/01/application-multi-modulo-hola-mundo-con-maven/#comments Mon, 02 Nov 2009 00:16:05 +0000 Renan Huanca http://renidev.javabolivia.com/?p=382 Acá muestro un ejemplo de una aplicación multi-modulo usando maven.

El ejemplo esta basado en este articulo: Chapter 7. Multi-module Enterprise Project

Descripción

Básicamente este ejemplo es solo una aplicación que muestra un el texto “Hola Mundo”.

Esta aplicación esta compuesta por dos módulos: ‘my-webapp’, que define una sevlet que imprime un mensaje y ‘my-module’ que contiene un servicio que devuelve el mensaje que imprime la servlet.

Esta es la estructura de directorios y archivos:

multiapp/
¦   pom.xml
+---my-module
¦   ¦   pom.xml
¦   +---src
¦       +---main
¦           +---java
¦                   HelloWorldService.java
+---my-webapp
    ¦   my-webapp.iml
    ¦   pom.xml
    +---src
        +---main
            +---java
            ¦       HelloWorldServlet.java
            +---webapp
                ¦   index.jsp
                +---WEB-INF
                        web.xml

Archivos pom.xml

pom.xml principal
?View Code XML
<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>edu.renan</groupId>
    <artifactId>multiapp</artifactId>
    <packaging>pom</packaging>
    <version>1.0</version>
    <name>Test Modules App</name>
    <modules>
        <module>my-module</module>
        <module>my-webapp</module>
    </modules>
    <dependencies>
        <dependency>
            <groupId>net.sourceforge.openutils</groupId>
            <artifactId>openutils-testing-testng</artifactId>
            <version>2.2.2</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>multiapp</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

La parte importante en el pom.xml principal es que se definen los módulos: my-webapp y my-module dentro de la etiqueta <modules>

También hay que tomar en cuenta que el packaging es definido como ‘pom’

pom.xml - my-module
?View Code XML
<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>
	<parent>
		<groupId>edu.renan</groupId>
		<artifactId>testmodules</artifactId>
		<version>1.0</version>
	</parent>
	<artifactId>my-module</artifactId>
	<packaging>jar</packaging>
	<name>my-module</name>
</project>

Acá estamos definiendo cual sera el modulo padre usando la etiqueta ≷parent> y el packaging como ‘jar’. Utilice jar por que este modulo generara un jar file.

pom.xml - my-webapp
?View Code XML
<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>
    <parent>
        <groupId>edu.renan</groupId>
        <artifactId>testmodules</artifactId>
        <version>1.0</version>
    </parent>
    <artifactId>my-webapp</artifactId>
    <packaging>war</packaging>
    <version>1.0</version>
    <name>my-webapp</name>
    <dependencies>
        <dependency>
            <groupId>servletapi</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.4</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>edu.renan</groupId>
            <artifactId>my-module</artifactId>
            <version>1.0</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>mywebapp</finalName>
    </build>
</project>

Acá definimos un parent lo mismo que el anterior, pero para el packaging usamos ‘war’, por que este modulo generara una aplicación web.

Classes java y web.xml

HelloWorldService
?View Code JAVA
public class HelloWorldService {
    public String sayHello(){
        return "Hola Mundo";
    }
}

Como verán es solo una clase con un método con un método que retorna el mensaje “Hola Mundo”.

HelloWorldServlet
?View Code JAVA
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;
 
public class HelloWorldServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HelloWorldService helloWorldService = new HelloWorldService();
        response.getWriter().println(helloWorldService.sayHello());
    }
}

Esta servlet solo llama al servicio definido anteriormente.

web.xml
?View Code XML
<web-app 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"
     version="2.4">
 
    <display-name>My Web App</display-name>
    <servlet>
        <servlet-name>helloWorldServlet</servlet-name>
        <servlet-class>HelloWorldServlet</servlet-class>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>helloWorldServlet</servlet-name>
        <url-pattern>/helloWorld</url-pattern>
    </servlet-mapping>
 
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

Espero este ejemplo les sirva mucho, si quieren mas recursos acá tienen algunos que encontré:

El código fuente lo pueden encontrar aquí.

]]> http://renidev.javabolivia.com/2009/11/01/application-multi-modulo-hola-mundo-con-maven/feed/ Ejemplo TestNG http://renidev.javabolivia.com/2009/10/31/ejemplo-testng/ http://renidev.javabolivia.com/2009/10/31/ejemplo-testng/#comments Sat, 31 Oct 2009 15:36:50 +0000 Renan Huanca http://renidev.javabolivia.com/?p=376 Hola amigos,

Acá comparto un ejemplo simple de como usar el TestNG.

El ejemplo se basa en una clases para realizar la operación suma.

Clase a Testear

?View Code JAVA
public class Calc {
    public int add(int a, int b){
        return a + b;
    }
}

Clase de Testeo

?View Code JAVA
import org.testng.annotations.Test;
 
@Test
public class CalcTest {
    public void sumarTest(){
        Calc calc = new Calc();
        assert 2 == calc.add(1,1);
    }
}

Archivo pom.xml

?View Code XML
    ...
    <dependencies>
        <dependency>
            <groupId>net.sourceforge.openutils</groupId>
            <artifactId>openutils-testing-testng</artifactId>
            <version>2.2.2</version>
        </dependency>
    </dependencies>
    ...
    <build>
        <finalName>test</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

Para usar las anotaciones es necesario utilizar java 1.5+

]]> http://renidev.javabolivia.com/2009/10/31/ejemplo-testng/feed/ Autenticación con OpenSSO y HttpClient http://renidev.javabolivia.com/2009/10/25/autenticacion-con-opensso-y-httpclient/ http://renidev.javabolivia.com/2009/10/25/autenticacion-con-opensso-y-httpclient/#comments Sun, 25 Oct 2009 20:37:26 +0000 Renan Huanca http://renidev.javabolivia.com/?p=363 Hola amigos,

Acá comparto una porción de código que use para poder autenticarme a servidor OpenSSO y obtener un el subjectId del usuario usando HttpClient de Jakarta Commons.

Este ejemplo esta basado en este articulo:

REST based Identity Services in OpenSSO, acá se describen los distintos RestFul services que provee OpenSSO

El ejemplo proveído es simplemente un método que recibe como parámetros nombre de usuario y password el cual después usando el PostMethod de HttpClient obtiene el un subjectId.

Aparte también pueden ver un método de utilidad que sirve para leer un InputStream y convertirlo a un String.

?View Code JAVA
    public String authenticate(String username, String password) {
        Configuration configuration = Configuration.getIntance();
        PostMethod postMethod = new PostMethod("http://localhost:8080/opensso/identity/authenticate");
 
        HttpClient httpClient = new HttpClient();
        postMethod.addParameter("username",username);
        postMethod.addParameter("password",password);
        postMethod.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
 
        try {
            httpClient.executeMethod(postMethod);
        } catch (IOException e) {
            throw new RuntimeException("No se puede llamar a servicio de autenticación de OpenSSO");
        }
 
        String response = null;
        try {
            response = readInputStreamAsString(postMethod.getResponseBodyAsStream());
        } catch (IOException e) {
            throw new RuntimeException("No se puede leer respuesta.",e);
        }
        postMethod.releaseConnection();
        return response.substring("token.id=".length()).trim();
    }
 
    private String readInputStreamAsString(InputStream inputStream)
            throws java.io.IOException {
        StringBuffer fileData = new StringBuffer(1000);
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
        char[] buf = new char[1024];
        int numRead = 0;
        while ((numRead = reader.read(buf)) != -1) {
            String readData = String.valueOf(buf, 0, numRead);
            fileData.append(readData);
            buf = new char[1024];
        }
        reader.close();
        return fileData.toString();
    }

Básicamente al llamar al servicio de autenticación, este te retorna un String parecido al siguiente:

token.id=123445656qwerreqerqwerqwre345

Donde “123445656qwerreqerqwerqwre345″, es el identificador del usuario para poder ser usado en una sesión de OpenSSO, es por eso que después hacemos un substring para separar el separarlo.

Esto seria por hoy :) hasta la próxima.

]]> http://renidev.javabolivia.com/2009/10/25/autenticacion-con-opensso-y-httpclient/feed/