Años mas tarde decidí volver al escritorio, e invertí en uno, así también en  una cómoda silla, y un PC mas o menos decente; la sensación increíble, trabajar a gusto, poder tener libros y cuadernos donde rayar,  lápices y plumones a mano, muy cómodo en verdad, pero tuve que reciclar el portátil anterior, y solo me quede con el de escritorio, hasta allí todo bien, hasta que… tuve la necesidad de moverme otra vez… perdí muchos eventos interesantes por no tener la movilidad en un pc, y bueno… volví a invertir en una computadora portátil… como se sabe, todos somos generales después de la guerra…,y aprendí a mezclar ambas cosas,confort y movilidad,  compre unos cables para poder conectar al monitor del escritorio, un teclado y mouse inalámbricos, y ahora puedo estar a gusto trabajando, a dos monitores y llevando conmigo la información a todos lados… Ahora el escritorio salió del dormitorio,  se fueron las distracciones de recostarse en la cama, de ver la televisión, de andar de aquí para allá, ahora me puedo enfocar, y veo notablemente el cambio, siento que hago mucho mas en menos tiempo, estoy mucho mas concentrado en lo que estoy haciendo.

El saber escoger el espacio de trabajo es importante, trata de separar aguas(el dormitorio es para descansar, entre otras…),  si vas a trabajar desde la casa, crea tu propio entorno, que sea tu lugar especial, pon fotografías, lápices, libros, notas, música, etc, lo que quieras, si vas a pasar bastantes horas sentado, no crees que es una muy buena inversión tu comodidad?…

yo ya estoy empezando a construir el mio… y tu no te ánimas?…

si andas falta de idea, te dejo algo para que te inspires link

Salto realizado el 27 de marzo de 2011, en skydiveandes, camino a melipilla, Chile.

Como anteriormente se pudo ver, Spring, gestiona el ciclo de vida del bean durante toda su ejecución, la cual se basa en tres etapas; ,la inicialización, el uso, y la destrucción.

1. Inicialización: Los servicios de la aplicación son creados, configurados y se pueden asignar recursos del sistema.
2. Uso: En esta esta se procesan las peticiones de los clientes, los comportamientos de la aplicación son llevados acabo en esta etapa, siendo esta la que ocupa la mayor parte del tiempo del ciclo de vida.
3. Destrucción: En la destrucción se liberan los recursos del sistema mediante el garbage colletion.

2. Fases:

2.1 Inicialización:

2.1.1 Carga de la definición de Beans

¿Que pasa cuando se instancia  un ApplicacionContext?

ApplicationContext context = new ClassPathXmlApplicationContext(“basic-context.xml”);

La fase de inicialización esta completa cuando se crea el contexto,  en esta etapa se parsean el o los archivos xml de configuración , las definiciones de los beans son cargados en el contexto del BeanFactory, como anteriormente se menciono, estos se crean con  un identificador único, para el contexto, luego, se invocan a clases y métodos especiales que nos permiten modificar las definiciones de los beans que fueron creados anteriormente, esta funcion la realizan los beans del tipo BeanFactoryPostProcessor, los cual nos permiten manipular, transformar  grupos de definiciones de beans antes que  los objetos sean creados, podemos incluso crear nuestras propias implementaciones de esta interfaz.

Clases que implementan BeanFactoryPostProcesor en Spring 2.5

AspectJWeavingEnabler, CustomAutowireConfigurer, CustomEditorConfigurer, CustomScopeConfigurer,

PreferencesPlaceholderConfigurer, PropertyOverrideConfigurer, PropertyPlaceholderConfigurer,

PropertyResourceConfigurer, ServletContextPropertyPlaceholderConfigurer

Un ejmeplo de una clase que implementa BeanFactoryPostProcessor es la clase PropertyPlaceholderConfigurer, que nos permite substituir valores de variables para los beans desde archivos de configuración, ejemplo tenemos un archivo datasource.properties que contiene la forma clave=valor como la siguiente entrada:

driver=com.mysql.jdbc.Driver
dbname=mysql:mydb

Para cargar las propiedades del archivo, se tiene que  usar la sintaxis  del placeholder  

{...}

como en el siguiente ejemplo, que crea un data source, en donde los … serán reemplazados por las claves de nuestra configuración, en este caso, driver y dbname.

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   <property name="driverClassName"><value>${driver}</value></property>
   <property name="url"><value>jdbc:${dbname}</value></property>
 </bean>

para poder leer y cargar el archivo, spring entre otros, nos proporciona, prefijos para los namespace de configuración que nos facilita el trabajo, uno de estos es el   <context>.

<context:property-placeholder location=“/WEB-INF/datasource.properties” />

2.1.2 Inicialización de la instancia del Bean

• Cada bean, es instanciado en forma temprana, es creado en el orden correcto  con la inyección de sus dependencias.
• Después de la inyección de dependencias, los beans pasan a una etapa de post procesamiento, luego de esta etapa, están inicializados y listos para ser usados.

La etapa del post procesamiento se puede  separar en  dos,  se le puede ordenar inicializar la instancia del bean,o se puede implementar un BeanPostProcessors, que nos permite modificar de una manera personalizada las nuevas instancias de los beans.

Si queremos ejecutar comportamientos específicos o invocar  métodos que necesitemos en la instanciación de  bean,  spring nos proporciona mas de una manera para poder hacerlo; mediante la anotación de la JSR-250 @PostConstruct, o a través del init-method, en el cual se especifica el nombre del método inicial que se ejecutará durante la instanciación del bean, esto se realiza en  el archivo de configuración de Spring,  y una tercera opción, es implementando la interfaz InitializingBean.

Vía Anotación:

package com.spring.basic.initialization;

import javax.annotation.PostConstruct;

public class SimpleBeanImpl {

	@PostConstruct
	void initMehtod(){
		//metodo a inicial que es ejecutado despues de que
		//la inyeccion de dependencias haya finalizado
	}

}

* esto es para Spring 2.5 o superior
Para habilitar esta característica, debemos agregar en el archivo de configuración el bean CommonAnnotationBeanPostProcessor o lo recomendado es usar el namespace <context:annotation-config/> , solo bastan con agregarlo tal cual.

Mediante el init-method:

El método debe ser publico, y el bean no debe tener dependencias.

<bean id="simpleBean" class="com.spring.basic.initialization.SimpleBeanImpl" init-method="initMehtod"/>

y mediante la implementación de InitializingBean:

Para versiones inferiores  a spring 2.5, es recomendable usar esta implementación, para versiones superiores o igual a la 2.5,  se recomienda usar @PostConstruct.

package ...
import org.springframework.beans.factory.InitializingBean;
public class SimpleBeanImpl implements InitializingBean {

	@Override
	public void afterPropertiesSet() throws Exception {
		// para versiones inferiores a spring 2.5
	}
}

El método afterPropertiesSet() es invocado automáticamente por Spring.

La interfaz BeanPostProcessor nos permite llevar a cabo configuraciones adicionales, entre sus funciones, nos permite modificar la instancia de un bean en cualquier momento, spring detecta automáticamente estos tipos de beans,  los podemos usar para trabajar con proxies, o para marcar algunas interfaces de modo que la inyección sea requerida, como lo proporciona la anotación @Required, para habilitar esta opción, solo basta agregar <context:annotation-config/> a la configuración.

La interfaz nos provee de dos métodos para poder modificar las instancias, el primero de ellos, es el postProcessAfterInitialization, que nos retorna una nueva instancia después de que se haya hecho la llamada de  inicialización, y el otro método, postProcessBeforeInitialization, quien  lo realiza antes de la llamada de instanciación.

Existe una implementación de BeanPostProcessor llamada RequiredAnnotationBeanPostProcessor que nos permite verificar en tiempo de configuración que todas las propriedades marcadas con la anotación @Required estén seteadas correctamente, si no usamos esta verificación, no nos daríamos cuenta hasta usar el bean que su dependencia no fue inyectada.

...

	private DataSource dataSource;

	/**
	 * Set del datasource
	 * @param dataSource the data source
	 */
	@Required
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}

public class SimpleBeanImpl {

	@PreDestroy
	void release(){
                //se llama antes que se realize la destruccion de la instancia del bean
		//sin restriccion del nombre del metodo ni de visibilidad
	}

}

<bean id="simpleBean" class="...SimpleBean" destroy-method="release"/>

public class SimpleBeanDestroy implements DisposableBean {

	@Override
	public void destroy() throws Exception {
		//sping se encarga de llamar a este método en el momento adecuado
	}
}

El mejor uso al ipad

link: http://leerestademoda.com/

1.- Introducción a Spring

• EL objetivo de Spring

- Proveer el soporte  para desarrollar aplicaciones empresariales con java.

- Enfocarnos en resolver nuestro problema de dominio.

• El rol en la arquitectura de aplicaciones empresariales.

- El core de Spring nos da la posibilidad de configurar nuestra aplicación de maneras sencillas,así  también el de poder realizar una integración con aplicaciones empresariales,  realizar testing y poder manejar el acceso a la data.

- Permite integrar y configurar componentes de manera sencilla; parte de los componentes son  plain java objects.

- Integrar pool de conexiones  de base de datos, transacciones, seguridad, messaging, acceso remoto, entre otras.

- Realizar testing,  desacoplando  los objetos desde nuestros ambientes(testing, producción) , realizar test unitarios o de integración.

- El acceder a la data de una manera mucho mas fácil, spring  nos entrega soporte para la gran parte de las tecnologías de acceso de datos, como lo son JDBC,JPA,JDO,HIBERNATE,IBATIS, ya ahora llamado MyIbatis, otra característica es que maneja los recursos por nosotros, un ejemplo de esto es que puede adquirir la conexión, participar en la transacción, manejar las exceptions, procesar resultados, etc; nos provee de helpers como lo es JdbcTemplate.

- Soporte para el desarrollo de aplicaciones Web, permite la integración con JSF, Struts, Velocity, FreeMaker y algunos otros, nos permite trabajar con el patrón de diseño MVC, rendear las vistas,validación de formularios, manejo de estados con web flow,  acciones de usuarios, etc, así también, aplicar una capa de seguridad con spring Security.

- Soporte en el desarrollo de aplicaciones empresariales,  desarrollando webservices,  asegurando servicios con accesos de control, planificando jobs y procesos, integrando servicios de mensajería.

• La base de spring se puede definir mediante el triangulo de Spring

- Inyección de dependencia

- Programacion orientada a aspectos

-y Abstracción de servicios empresariales.

2 .- Beans y contenerdores:

• En Spring un bean es un objeto que vive y que es manipulado por el contenedor, no confundir con un javabean.
• Spring gestiona todo el ciclo de vida de la aplicación, todos los beans son inicializados antes que se utilicen.
• Los beans siempre son creados en orden correcto, Spring se encarga de resolver la dependencia de cada uno de ellos.
• Cada bean posee un identificador único
• Encapsula las implementaciones dado  el despliegue de la aplicación, oculta los detalles de la implementación.

2.1 – Los beans.

Un bean es un objeto, y como tal puede ser bastante simple,  como el siguiente:

Con sus atributos, getters y setters, tal y cual, es un objeto plano en java, para pasarlo a un bean de Spring, tenemos que ponerlo en un contenedor de beans, que no es mas que una definición en un archivo xml.

Esta es una clase que no contiene dependencias, si quisiéramos instanciar la clase vía reflection, bastaría con hacer:

SimpleBean simpleBean = new SimpleBean();

Pero Spring nos provee de una interfaz para proporcionar la configuración de una aplicación, esta es el ApplicationContext.

ApplicationContext context = new ClassPathXmlApplicationContext(“basic-context.xml”);
SimpleBean simpleBean = (SimpleBean) context.getBean("simpleBean",SimpleBean.class);

Ahora Spring es quien contiene y maneja todo el ciclo de vida del bean llamado “simpleBean” que definimos mas arriba.

2.2 Inyección de dependencias.

Spring nos permite el poder inyectar dependencias a nuestros beans vía setter, o constructor.

2.2.1 Inyección de dependencia por constructor.

Es equivalente a:

SimpleBean sb = new SimpleBean(787545, "valor del tipo string", new HashMap...);

Beneficios de la inyección por constructor:

1. Cumplir con las dependencias obligatorias.
2. Proveer de inmutabilidad
3. Programar de una forma consistente, creación e inyección en una sola linea de código.

2.2.2 Inyección de dependencia por Setter.

Es equivalente a:

SimpleBean sb = new SimpleBean();
sb.setId(787545);
sb.setName("valor del tipo string");
sb.setMaps(new HashMap()...);

Beneficios de la inyección por Setter:

1. Permitir dependencias por defecto u opcionales.
2. Tener nombres descriptivos.
3. Seguir la convención JavaBeanTM
4. Se hereda de forma automática.

También se pueden combinar.

Los puristas prefieren uno sobre otro,¿Cual usar?,  tu elijes, se consistente…

2.2.3 Dependencias y configuración en detalle ver aqui

En resumen, dentro de los beneficios de las inyecciones de dependencia podemos mencionar.

• Al objeto se le entrega lo necesario para trabajar, simplifica el código, permite la reutilización, permite resolver la dependencias entre los componentes.
• Nos permite trabajar con interfaces, para ocultar los detalles de la implementación
• Promueve las pruebas de manera aislada o de todos los componentes juntos.
• Maneja el ciclo de vida del objeto.

package com.spring.basic.factory;

import org.springframework.beans.factory.FactoryBean;

/**
 * Clase de muestra de como funciona el facoryBean de spring
 * <ul>
 * 	<li>Spring autodetecta  cualquier implementacion del {@link FactoryBean } y retorna el objeto creado por
 * el metodo <code>getObject()</code></li>
 * <li>Nos permite encapsular la creacion del objeto</li>
 * <li>Spring nos permitira dejarlo como un bean Singleton</li>
 * </ul>
 * @author jbovet
 */
public class ObjectFactory implements FactoryBean {

	/***
	 * Objeto que sera devuelto
	 */
	private MockObject mockObject;

	private Integer idMock;
	private String nameMock;
	private boolean isSingleton = Boolean.TRUE;

	/***
	 * retorna la instancia del objeto MockObject
	 */
	public Object getObject() throws Exception {
		if (mockObject ==null) {
			initMockObject();
		}
		return mockObject;
	}

	/***
	 * crea la instancia del objeto
	 */
	private void initMockObject() {
		//se crea el objeto mediante constructor
		mockObject = new MockObject(nameMock,idMock);
	}

	/***
	 * Obtiene la clase del objeto
	 */
	public Class<MockObject> getObjectType() {
		return MockObject.class;
	}

	/**
	 * el factorybean se registra como singleton
	 * @see org.springframework.beans.factory.FactoryBean#isSingleton()
	 */
	public boolean isSingleton() {
		return isSingleton;
	}

	public void setIdMock(Integer idMock) {
		this.idMock = idMock;
	}
	public void setNameMock(String nameMock) {
		this.nameMock = nameMock;
	}
}

<?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:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd">

	<bean id="mockObjectFactory" class="com.spring.basic.factory.ObjectFactory">
		<property name="idMock" value="123"/>
		<property name="nameMock" value="mockito"/>
	</bean>
        <!--bean que usa el objeto mock -->
	<bean id="simpleBean">
	    <property name="mockObject" ref="mockObjectFactory"/>
	</bean>
</beans>

package com.spring.basic.factory;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestFactory {

	public static void main(String[] args) throws Exception {
		ApplicationContext context = new ClassPathXmlApplicationContext("classpath:com/spring/basic/factory/factory-context.xml");
		MockObject mockObject = (MockObject) context.getBean("mockObjectFactory");
		System.out.println(mockObject.toString());
		//SimpleBean sb = (SimpleBean) context.getBean("simpleBean", SimpleBean.class);
		//sb.doSomething();
	}
}

El uso de los FactoryBeans en Spring:

• JndiObjectFactoryBean: para poder trabajar con objetos JNDI
• Nos permite crear proxies remotos
• Para configurar el acceso a la data.(ibatis, hibernate,jpa,etc)

4.- Creando un Spring Application Context

Un Spring Application Context puede ser ejecutado en casi cualquier ambiente, incluyendo en sistema de testing como Junit, dentro de una aplicacion web, con EJB’s, o e una aplicación  standalone de java, podemos cargar el contexto de partes, como lo es el classpath, desde el sistema de archivos, o como un recurso dentro de una aplicion web, para esto, spring nos proporciona 3 implementaciones para cargar nuestros beans.

4.1 Usando prefijos.

classpath:

new ClassPathXmlApplicationContext(“classpath:org/spring/basic/application-config.xml”);

file:

new FileSystemXmlApplicationContext(“file:\tmp\context\application-config.xml”);

http:

ctx.getResource("http://myserver/logo.png);

Los prefijos los podemos utilizar en cualquier lugar donde spring necesite cargar algún recurso, no solamente como  argumento en el constructor del applicationContext.

4.2  Creando mutiples Application Context.

• Un contexto puede ser configurado desde múltiples archivos, permite separar la definición de los beans en grupos lógicos.
• Una buena practica es separar los beans de la aplicación de los  de infraestructura, ya que estos últimos pueden cambiar dependiendo del entorno.

Ejemplo de como cargar los beans de producción con mysql

ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {
“app-config.xml”,
“mysql-infrastructure-config.xml”
});

Ejemplo de como cargar los beans de desarrollo con mysql en test

ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {
“app-config.xml”,
“mysql-test-infrastructure-config.xml”
});

En la segunda parte, veremos mas en profundidad el ciclo de vida de un bean..

Presentación ServiceMix

¿Por  que el articulo?

Uno de los inconvenientes que encontré al momento de empezar a trabajar con apache servicemix, fue el problema con los schemas,  tags, y beans; no se  si es buena practica estar acostumbrado al editor que trae el STS ,pero me facilita mucho el trabajo al configurar los beans de spring, no fue así cuando intente trabajar con los tags de servicemix, ya que de partida me daba errores al encontrar los schemas en el sitio de apache,  fue todo un caos… el tener que aprenderme la estructura que necesita el archivo de servicemix, mmm no tuve mucho tiempo, así que el objetivo fue pasar aquella configuración, a  una mas natural de spring, para esto tome el siguiente ejemplo desde el sitio de apache servicemix,  a grandes rasgos, la idea es tomar un archivo desde la carpeta inbox, moverlo y cambiarle el nombre, siempre y cuando se un archivo con formato xml.

¿Como funciona?

1.  El componente filePoller busca un archivo en el directorio inbox cada 1000 ms.
2.  Una vez que el archivo es encontrado en el directorio, el filePoller consigue un thread desde el manejador de tareas. El thread    se utiliza para procesar el archivo.
3. El filePoller crea un mensaje normalizado que contiene el archivo que sera transmitido. Se envía el mensaje normalizado al NMR.
El NMR routea el mensaje hasa el componente filesender.
4. El fileSender transforma el mensaje normalizado de nuevo a un archivo y lo coloca en el directorio outbox.

Lo primero que voy a hacer es crear un proyecto maven, para ello me voy al STS(Spring Tool Suite).

File->New->Other->Maven Project

Le damos next y nos  pedira el nombre y la ubicación del proyecto,  le damos siguiente donde seleccionaremos que tipo de archetype de maven queremos; para este caso utilizaremos el servicemix-embedded-simple


Luego nos preguntara el groupId y el artifactId, lo completamos y damos finarlizar.Nos creara un proyecto con la siguiente estructura.

Una clase Main y un archivo llamado servicemix.xml como lo muestra la figura anterior.

Ahora crearemos dos carpetas en la raiz del proyecto, una llamada inbox, y outbox, también un Spring Bean Configuration File dentro de la carpeta resources, lo llamare context-jbi.xml y sera donde alojare la configuración de los beans.

Servicemix nos provee la opción y el soporte de Spring, para lo cual, dispone de una clase llamada SpringJBIContainer , este  contenedor JBI, añade algunos métodos de ayuda para facilitar la configuración a través de archivos XML  de spring, teniendo en cuenta esto, vamos a crear un bean de esa clase.

<bean id="jbi" class="org.apache.servicemix.jbi.container.SpringJBIContainer">
   <property name="embedded" value="true" />
   <property name="activationSpecs">
    <list>
      <ref bean="activationSpecFileSender"/>
      <ref bean="activationSpecFilePoller"/>
    </list>
   </property>
 </bean>

Establecemos que el modo sera embebido, y le pasamos como referencia los activationSpecs

	<bean id="activationSpecFileSender" class="org.apache.servicemix.jbi.container.ActivationSpec">
		<property name="componentName" value="fileSender" />
		<property name="service" ref="fileSenderService" />
		<property name="component">
			<bean class="org.apache.servicemix.components.file.FileWriter">
				<property name="directory" value="${OUTBOX}" />
				<property name="marshaler">
					<bean class="org.apache.servicemix.components.util.DefaultFileMarshaler">
						<property name="fileName">
							<bean
								class="org.apache.servicemix.expression.JaxenStringXPathExpression">
								<constructor-arg value="concat('sample_', /sample/@id, '.xml')" />
							</bean>
						</property>
					</bean>
				</property>
			</bean>
		</property>
	</bean>

Necesitamos crear el componente que buscara el archivo en el directorio inbox, para esto seteamos el nombre del componente, el servicio que hace referencia  al bean del servicio llamado fileSenderService, y creamos el componente que sera utilizado, en este caso unFileWriter.

Ahora crearemos el componente que deja el archivo en la carpeta outbox,steamos el nombre del componente, el servicio, el componente FilePoller, y el destinationService, el cual nos dice donde se routeara , en este caso al fileSenderService

	<bean id="activationSpecFilePoller" class="org.apache.servicemix.jbi.container.ActivationSpec">
		<property name="componentName" value="filePoller" />
		<property name="destinationService" ref="fileSenderService" />
		<property name="service" ref="filePollerService" />
		<property name="component">
			<bean class="org.apache.servicemix.components.file.FilePoller">
				<property name="file" value="${INBOX}" />
				<property name="period" value="1000" />
			</bean>
		</property>
	</bean>

Aquí tenemos los service beans de la clase QName, que en este caso no necesitamos pasarle la definición del xml.

   <bean id="fileSenderService" class="javax.xml.namespace.QName">
       <constructor-arg value="fileSender"/>
   </bean>

   <bean id="filePollerService" class="javax.xml.namespace.QName">
       <constructor-arg value="filePoller"/>
   </bean>

Y para terminar un BeanFactoryPostProcessors, el propertyConfigurer para setear las propiedades en las variables ${INBOX} ${OUTBOX}

	<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="location" value="classpath:rutas.properties" />
	</bean>

Y el rutas.properties

INBOX=/media/A880A33480A307C0/WS_INV/ServiceMixEmbebbed/inbox
OUTBOX=/media/A880A33480A307C0/WS_INV/ServiceMixEmbebbed/outbox

Ahora vamos a la clase Main, donde tendremos que cambiar el archivo a leer en el ClassPathXmlApplicationContext ,por defecto fue creado con servicemix.xml lo cambiamos y leemos el context-jbi.xml quedando la clase de la siguiente manera.

import org.apache.servicemix.jbi.container.SpringJBIContainer;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// This is a very simple example of how you might embed ServiceMix
		try {
			final ApplicationContext context = new ClassPathXmlApplicationContext("context-jbi.xml");
			SpringJBIContainer container = (SpringJBIContainer) context.getBean("jbi");

            container.onShutDown(new Runnable() {
                public void run() {
                    if (context instanceof DisposableBean) {
                        try {
                            ((DisposableBean) context).destroy();
                        } catch (Exception e) {
                            System.out.println("Caught: " + e);
                            e.printStackTrace();
                        }
                    }
                }
            });
		} catch (Exception e) {
			System.out.println("Caught: " + e);
			e.printStackTrace();
		}

	}

}

Como vemos, ya ha quedado nuestro bean, solo falta agregar a las dependencias de maven el servicemix-components

Dejas un archivo xml en la carpeta inbox, y corres la clase main, eso es todo… como ves pasamos de la engorrosa configuracion de service mix del ejemplo

<?xml version="1.0" encoding="UTF-8"?>
<!--

    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
    this work for additional information regarding copyright ownership.
    The ASF licenses this file to You under the Apache License, Version 2.0
    (the "License"); you may not use this file except in compliance with
    the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

-->
<beans xmlns:sm="http://servicemix.apache.org/config/1.0"
	     xmlns:foo="http://servicemix.org/demo/">

  <bean id="jndi" class="org.apache.xbean.spring.jndi.SpringInitialContextFactory"
        factory-method="makeInitialContext" singleton="true" />

	<!-- the JBI container -->
	<sm:container id="jbi" useMBeanServer="true" createMBeanServer="true">

		<sm:activationSpecs>

			<!-- Write files to the outbox directory -->
			<sm:activationSpec componentName="fileSender"
				service="foo:fileSender">
				<sm:component>
					<bean class="org.apache.servicemix.components.file.FileWriter">
						<property name="directory" value="outbox" />
						<property name="marshaler">
							<bean
								class="org.apache.servicemix.components.util.DefaultFileMarshaler">
								<property name="fileName">
									<bean
										class="org.apache.servicemix.expression.JaxenStringXPathExpression">
										<constructor-arg
											value="concat('sample_', /sample/@id, '.xml')" />
									</bean>
								</property>
							</bean>
						</property>
					</bean>
				</sm:component>
			</sm:activationSpec>

			<!-- Look for files in the inbox directory -->
			<sm:activationSpec componentName="filePoller"
				destinationService="foo:fileSender" service="foo:filePoller">
				<sm:component>
					<bean class="org.apache.servicemix.components.file.FilePoller">
						<property name="file" value="inbox" />
						<property name="period" value="1000" />
					</bean>
				</sm:component>
			</sm:activationSpec>
		</sm:activationSpecs>
	</sm:container>

</beans>

a algo mas natural de 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:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">

	<bean id="jbi" class="org.apache.servicemix.jbi.container.SpringJBIContainer">
		<property name="embedded" value="true" />
		<property name="activationSpecs">
			<list>
				<ref bean="activationSpecFileSender"/>
				<ref bean="activationSpecFilePoller"/>
			</list>
		</property>
	</bean>

	<bean id="activationSpecFileSender" class="org.apache.servicemix.jbi.container.ActivationSpec">
		<property name="componentName" value="fileSender" />
		<property name="service" ref="fileSenderService" />
		<property name="component">
			<bean class="org.apache.servicemix.components.file.FileWriter">
				<property name="directory" value="${OUTBOX}" />
				<property name="marshaler">
					<bean class="org.apache.servicemix.components.util.DefaultFileMarshaler">
						<property name="fileName">
							<bean
								class="org.apache.servicemix.expression.JaxenStringXPathExpression">
								<constructor-arg value="concat('sample_', /sample/@id, '.xml')" />
							</bean>
						</property>
					</bean>
				</property>
			</bean>
		</property>
	</bean>

	<bean id="activationSpecFilePoller" class="org.apache.servicemix.jbi.container.ActivationSpec">
		<property name="componentName" value="filePoller" />
		<property name="destinationService" ref="fileSenderService" />
		<property name="service" ref="filePollerService" />
		<property name="component">
			<bean class="org.apache.servicemix.components.file.FilePoller">
				<property name="file" value="${INBOX}" />
				<property name="period" value="1000" />
			</bean>
		</property>
	</bean>

   <bean id="fileSenderService" class="javax.xml.namespace.QName">
       <constructor-arg value="fileSender"/>
   </bean>

   <bean id="filePollerService" class="javax.xml.namespace.QName">
       <constructor-arg value="filePoller"/>
   </bean>

	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="location" value="classpath:rutas.properties" />
	</bean>

</beans>

Eso es por el momento, intentare subir el código fuente del proyecto maven a Git esta semana.

Código disponible aqui

Muchas gracias por darte el tiempo de leer.

Se ha publicado el libro de diseño ágil con TDD  entre sus temas:

• Test Driven Development
• Técnicas de diseño OO para crear código testable.
• Objetos Mocks
• Acceptance TDD
• Papel de TDD en un entorno de desarrollo ágil y su relación con otras técnicas como Integración continua.
• Además el libro tiene un enfoque muy practico contando con multitud de ejemplos en java, c# y python.

Extracto del sitio oficial.

Diseño Ágil con TDD nos enseñará a:* Escribir tests que aumenten la fiabilidad del código.
* Escribir tests de aceptación que nos ayudarán a centrarnos, específicamente, en el problema a resolver.
* Mejorar nuestros diseños para hacerlos más simples y flexibles.
* Escribir código fácil de mantener. Con TDD, los test son documentación viva y actualizada de nuestro código, la mejor documentación posible.
* Encajar TDD dentro del paradigma ágil y relacionarlo con otras técnicas como la integración continua.

El libro esta bajo Licencia Creative Commons-nd Pueden descargar el libro en la pagina oficial.