Templth's blog

Spring Batch in action went in MEAP

2010-07-01T00:36:00.000-07:00

I'm pleased to announce that the book "Spring Batch in action" went in MEAP yesterday. You can read it at the following address: http://www.manning.com/templier/

Salon Linux in Paris

2009-03-19T03:15:00.000-07:00

I'll be present at the Salon Linux 2009 in Paris on April, the 1st and 2nd with my company Argia-Engineering in order to describe and show our service platform Faascape.

Blogging again!

2009-03-11T02:33:00.000-07:00

After a long time without blogging, I decided to start over. In the meantime, I renamed the blog in order to better describe the subjects of articles. These subjects will be now a bit more extensive and will cover the following:

Spring technologies and projects,
OSGi related technologies and projects,
Web2 and JavaScript technlogies,
Modeling and model driven technologies.

With this blog, I will do my utmost to point out interesting aspects of these technologies!

Access CICS with Spring

2005-08-22T01:42:00.000-07:00

Here is an article I have made to explain and show how to access CICS transactions and programs with the Spring JCA support.

This article is published by JavaWorld at the following url:
Access CICS applications with Spring

Use Groovy with Spring

2005-08-16T04:05:00.000-07:00

Groovy is an interesting script engine on the JVM. The main is to provide an embedded component of a Java/J2EE application, to help write and customize business rules, or other moving parts of your application [cf G. Laforge].

I. Support in Spring

Spring offers a support for script tools in the sandbox. This support provides a generic component that can be extended in order to plug an implementation for a dedicated tool. This framework is localized in the org.springframework.beans.factory.script package and the groovy support in the org.springframework.beans.factory.script.groovy package.
This support is based on the facility of Spring to configure beans based on factory. Thus, the configuration of a Groovy object is divided into two steps:

Configuration of the Spring factory for Groovy

Configuration of the bean representing a Groovy object

The factory is simply configured as following:


<bean id="groovyScriptFactory"
   class="org.springframework.beans.factory.script.groovy.GroovyScriptFactory">
    <property name="expirySeconds">
        <value>1</value>
    </property>
</bean>

Then you can configure your script with its location and inject all the properties used by it:


<bean id="testGroovy" singleton="true"
         factory-bean="groovyScriptFactory"
         factory-method="create">
    <constructor-arg>
        <value>classpath:/groovy/simple.groovy</value>
    </constructor-arg>
    <property name="message">
        <value>the value of my propertylt;/value>
    </property>
</bean>

The Groovy script used will be the following. You can see that the value of the "message" property has been injected using Spring...


package groovy;

public class TestImpl implements Test {
    @Property test;
    @Property message;
    @Property method;
    @Property list = {
        param ->
        println "list - param : ${param} - "+param;
    };

    @Property Closure list1  = {
        param ->
        println "hoho! list1 - param : ${param} - "+param;
    };

    public TestImpl() {
        method = { |name| println "Hello, ${name}" }
    }

    void test() {
        println message;
        method(message);
        list("test");
    }
}

In our case, we expose the bean on Groovy thanks to the Test interface, so the application see it and doesn't know that the implementation is a Groovy script!

However, this use isn't mandatory and you can see the Groovy script as a GroovyObject directly and nevertheless inject properties with Spring!!

In the next part of "Use Groovy with Spring", we will show and explain how Steven Devijver load and construct a J2EE based on Groovy scripts and its closure feature, in the Grails project.

JCA documentation in Spring

2005-07-11T02:07:00.000-07:00

The chapter of the JCA support in Spring has been added in the reference documentation with the version 1.2.2 of Spring.
See the following url to read it!!
JCA CCI

"Is EJB3 a Spring killer?"

2005-06-30T01:34:00.000-07:00

This is one of the most asked question at this time. The EJB3 specification has incopored interesting concepts and ideas from leading open source projects to make easier to use, remove lines of code and improve the time of application development.

Spring and EJB3 together
I think that these two technologies don't make exactly the same things and it's a great things to use them together.
There are two parts:
- Access EJB with Spring.
- Use Spring in EJB (transaction, components).

Spring philosophy
Spring permit to build well-defined applications both in an application server and outside/without an application server. This framework underlines that you need to use the appropriated technology for your application: do you really need ejb / jta technologies? Is a servlet container enough? Local or global transactions?
It focuses too on best pratices and design patterns to have a flexible, modular, reusable applications.
EJB3 will surely be easier to use but the technology needs too to have best pratices and design patterns...
Finally, before asking using Spring or EJB3, you may wonder which kind of applications, you need to develop. Then you can choose the appropriate technology(ies)!

Spring, not a specification...
Finally, I think the important thing against is that Spring isn't a specification but EJB3 is...

Readings
Made you your opinion with the following readings!!!

Some threads in the Spring forum on this subject:
EJB3
EJB3.0 without Spring :-)

An article on the onjava site on this subject:
POJO Application Frameworks: Spring Vs. EJB 3.0

Some insteresting blog entries on that subject:
The EJB cult Part 3 - Integrating Spring and EJB 3.0 dependency injection
Spring, EJB 3, and the future

A interesting article of Rob Harrop and Jan Machacek on Spring / EJB integration:
Pro Spring: Spring and EJB

The EJB section of the Spring 1.2.x reference documentation:
Accessing and implementing EJBs

JCA articles on developerWorks

2005-06-29T08:21:00.000-07:00

IBM puts an interesting serie of articles about JCA 1.5 on the developerWorks web site at the following urls:
Part 1
Part 2
Part 3

Geronimo documentations on developerWorks

2005-06-29T08:19:00.000-07:00

IBM puts some interesting documentations about Geronimo on the developerWorks web site at the following url:
http://www-128.ibm.com/developerworks/opensource/top-projects/geronimo.html

Tranql and XAPool

2005-05-30T02:05:00.000-07:00

Geronimo uses an interesting project to transform a jdbc driver into a resource adapter. This project is called Tranql. Its home page is http://tranql.codehaus.org/.

This page doesn't show a lot of informations and it is preferable to go to look at directly in the cvs ;-). The cvs is hosted by codehaus (cvs.tranql.codehaus.org) and the cvs root is /home/projects/tranql/scm.

The project only wrap JDBC driver and doesn't add support to convert a no-xa driver into an xa driver... An interested approach is to develop an integration between Tranql and XAPool. So you can easily create an XA DataSource from a simple DataSource and manage its connections with a JCA connection manager.

For example, with Tranql, you can configure a pool of connections with JCA in this way (using the Spring JCA support of Spring):


<bean id="tranqlManagedConnectionFactory"
      class="org.tranql.connector.jdbc.XADriverMCF">
  <property name="driverName">
    <value>org.hsqldb.jdbcDriver</value>
  </property>
  <property name="url">
    <value>jdbc:hsqldb:hsql://localhost:9002</value>
  </property>
  <property name="user">
    <value>sa</value>
  </property>
  <property name="password">
    <value></value>
  </property>
</bean>

So, to transform this DataSource in a XA compliant one, you only need to change the implementation of the ManagedConnectionManager. This XAPoolDataSourceMCF one integrates XAPool and use its StandardXADataSource class.
The configuration is now:


<bean id="tranqlManagedConnectionFactory"
      class="org.tranql.connector.jdbc.XAPoolDataSourceMCF ">
  <property name="driverName">
    <value>org.hsqldb.jdbcDriver</value>
  </property>
  <property name="url">
    <value>jdbc:hsqldb:hsql://localhost:9002</value>
  </property>
  <property name="user">
    <value>sa</value>
  </property>
  <property name="password">
    <value></value>
  </property>
</bean>

Note: A big problem is that XAPool internally manages the enlistment/delistment of XAResource. So you need to patch this tool to remove the call of enlist and delist on the current transaction.

Here is a sample implementation of XAPoolDataSourceMCF:


package org.tranql.connector.jdbc;

import java.sql.SQLException;

import javax.sql.XAConnection;
import javax.sql.XADataSource;

import org.enhydra.jdbc.standard.StandardXADataSource;
import org.tranql.connector.AllExceptionsAreFatalSorter;

public class XAPoolDataSourceMCF extends AbstractXADataSourceMCF {

  public XAPoolDataSourceMCF() {
    super(new StandardXADataSource(),new AllExceptionsAreFatalSorter());
  }

  public String getUserName() {
    return ((StandardXADataSource)xaDataSource).getUser();
  }

  public String getPassword() {
    return ((StandardXADataSource)xaDataSource).getPassword();
  }

  public void setDriverName(String driverName) {
    try {
      ((StandardXADataSource)xaDataSource).setDriverName(driverName);
    } catch (SQLException ex) { ex.printStackTrace(); }
  }

  public void setUrl(String url) {
    ((StandardXADataSource)xaDataSource).setUrl(url);
  }

  public void setUser(String user) {
    ((StandardXADataSource)xaDataSource).setUser(user);
  }

  public void setPassword(String password) {
    ((StandardXADataSource)xaDataSource).setPassword(password);
  }

}

The latest ManagedConnectionFactory implementation supports XA transactions!

Spring JCA support is out

2005-05-20T08:19:00.000-07:00

The JCA CCI support is now integrated in the Spring framework 1.2.
You can view the corresponding org.springframework.jca package in the Spring CVS of at the following url:

http://cvs.sourceforge.net/viewcvs.py/springframework/spring/src/org/springframework/jca/

Using of Ant in Eclipse

2005-01-13T01:01:00.000-08:00

In order to use the javac task of ant when you launch ant in Eclipse, you need to configure a system property to use the Eclipse compiler.
To do this, you can use a system property for the ant process (-D).


-Dbuild.compiler=org.eclipse.jdt.core.JDTCompilerAdapter

or a task in ant to initialize it. This task you must be called before every other tasks.


<project name="spring-core" default="traduction" basedir=".">



  <target name="eclipse" if="eclipse.running">

    <property name="build.compiler"

              value="org.eclipse.jdt.core.JDTCompilerAdapter" />

  </target>



  <target name="page-preface" depends="eclipse" description="overview">

    ...

  </target>



  ...

</project>

Datasources selection with Spring

2004-12-21T11:21:00.000-08:00

The aim is to permit to an application (and the user) to select a specific datasource to use, so a user can choose a specific database and datas to access. We can use the same mechanism than Acegi: a filter to get the datasource name and place it in known holder ( based on a thread local ) and a specific datasource ( proxy on datasources ) to get this name in order to select the datasource to use.

- Datasource name context: it's in fact a class to store the name of the DataSource et a class (a simple ThreadLocal) to hold it (the known place).
Here is an example of these two classes and interfaces:


public class DataSourceContextHolder {

    private static ThreadLocal contextHolder = new ThreadLocal();



    public static void setContext(DataSourceContext context) {

        contextHolder.set(context);

    }



    public static DataSourceContext getContext() {

        return (DataSourceContext) contextHolder.get();

    }

}


public interface DataSourceContext {

    public void setId(String id);

    public String getId();

}


public class DataSourceContextImpl implements DataSourceContext {

    private String id;



    public void setId(String id) {

        this.id=id;

    }



    public String getId() {

        return id;

    }

}

- Filter to detect context: the filter look for an datasource id in the session and put it in the context holder. The filter might be enhanced to have the feature to select the id and block this change when a user is authenticated on a database.

- Datasource selector: thanks to Spring, there is a datasource abstraction so we can put a proxy between our datasource and application. Our datasource proxy could select another datasource configure in Spring at runtime using the datasource context.
Here is an example of this proxy:


public class DataSourceSelector extends AbstractDataSource

                                implements BeanFactoryAware {

    private BeanFactory beanFactory;



    public void setBeanFactory(BeanFactory beanFactory)

                                               throws BeansException {

        this.beanFactory=beanFactory;

    }



    public Connection getConnection() throws SQLException {

        DataSourceContext context=DataSourceContextHolder.getContext();

        DataSource datasource=(DataSource)beanFactory.getBean(

                                                      context.getId());

        return datasource.getConnection();

    }



    public Connection getConnection(String login,String password)

                                                  throws SQLException {

        DataSourceContext context=DataSourceContextHolder.getContext();

        DataSource datasource=(DataSource)beanFactory.getBean(

                                                      context.getId());

        return datasource.getConnection(arg0,arg1);

    }

}

This mechanism is independant of the application (Spring offers this
facility!) but we must be carefull to not permit to access a database
without be authenticated. The order of filter (with use of security filter such Acegi's) could be dangerous... The solution is not to permit to switch from
a datasource to another when a user is authenticated.

Spring and ORM

2004-12-13T01:05:00.000-08:00

Spring integrates several ORM at this time:

Hibernate
See the following link for more informations:
Spring reference documentation
Hibernate site

JDO
See the following link for informations about Spring and JPox ( a free JDO implementation ):
JPox 1.1 documentation
See the following link for informations about Spring and KODO ( another JDO implementation ):
Confluence

OJB
Javadocs:
Spring javadocs
Examples: see the PetClinic sample application in the Spring distribution!
Threads on the subject:
Spring adds support for ojb
Thread
Announce of support added

TopLink
See the following link for informations about Spring and TopLink:
Spring / TopLink on Oracle site

Spring offers now a perfect integration of tools for J2EE architecture to access datas of relationnal databases.

JCA and Spring

2004-12-12T06:44:00.000-08:00

At the moment, Spring doesn't offer support for JCA ( Java Connector Architecture ). A support of JCA can be helpful in order to hide the use of CCI ( Common Client Interface ) API, to integrate with the IoC container of Spring and to use the AOP framework. The aim is offer facilities to use it:

Configuration of ConnectionFactory in a managed ( get from JNDI ) and in a non-managed mode ( configure as a bean )

Conversion from Record to Object / Object to Record

Declarative of transaction configuration ( local and global transactions ) with interceptors

Use of CCI with template and objects

The idea is then to extend the framework to different EIS to integrate them easier in J2EE applications. For example, with CICS, communications are based on a COMMAREA ( table of bytes ), so it could provide classes to work on table of bytes instead of Record and a data mapper to transform object to COMMAREA / COMMAREA to object.

Integrate JAMon with Spring

2004-11-25T01:44:00.000-08:00

JAMon is a tool to monitor performance of application components. It's
very useful to determine bottlenecks on application and find the impacted component. It provides too statistics on calls ( between the start and the end of monitors ).

This tool can be download at the following url:
http://sourceforge.net/project/showfiles.php?group_id=96550
and you can find its documentations on these sites:
http://jamonapi.sourceforge.net/
http://www.javaperformancetuning.com/tools/jamon/index.shtml

To install it in your application, only JAMon.jar must be in your classpath.

Spring already has an aop interceptor to measure performance of application components based on commons-logging. The idea is to provide a simple JAMon interceptor to start monitor before the call and end it after the call.

It provides too facilities to name the JAMon monitor with class and method names.

The method getMonitorName determines the monitor name:


    protected String getMonitorName(MethodInvocation invocation) {

        StringBuffer monitorName=new StringBuffer();

        monitorName.append(

                invocation.getMethod().getDeclaringClass().getName());

        monitorName.append(" ( ");

        monitorName.append(invocation.getMethod().getName());

        monitorName.append(" )");

        return monitorName.toString();

    }

The Spring AOP interceptor is simple:


import org.aopalliance.intercept.MethodInterceptor;

import org.aopalliance.intercept.MethodInvocation;



import com.jamonapi.Monitor;

import com.jamonapi.MonitorFactory;



public class PerfIntercepteur implements MethodInterceptor {



    protected String getMonitorName(MethodInvocation invocation) {

        StringBuffer monitorName=new StringBuffer();

        monitorName.append(

                invocation.getMethod().getDeclaringClass().getName());

        monitorName.append(" ( ");

        monitorName.append(invocation.getMethod().getName());

        monitorName.append(" )");

        return monitorName.toString();

    }



    public Object invoke(MethodInvocation invocation) throws Throwable {

        Monitor mon=MonitorFactory.start(getMonitorName(invocation));

        Object rval=invocation.proceed();

        mon.stop();

        return rval;

    }

}

and you can configure it in this way:


<!DOCTYPE beans PUBLIC 

                "-//SPRING//DTD BEAN//EN" 

                "http://www.springframework.org/dtd/spring-beans.dtd">



<beans>

    ...

    <bean id="perfInterceptor" class="aop.PerfIntercepteur"/>



    <bean id="autoProxyCreator" class="org.springframework.aop.framework.

                                       autoproxy.BeanNameAutoProxyCreator">

        <property name="interceptorNames">

            <list>

                <idref local="perfInterceptor" />

            </list>

        </property>

        <property name="beanNames">

            <list>

                <idref local="service" />

            </list>

        </property>

    </bean>

</beans>

The aim is to plug the JAMon interceptor on the component of the application layer to identifity the component that has performance problem ( from presentation layer to dao layer ).

Integrate P6Spy with Spring

2004-11-24T05:29:00.000-08:00

P6Spy is a tool to debug JDBC interaction with a database. It's a wrapper
of all JDBC elements ( Connection, PreparedStatement, ResultSet... ) and
it has a powerful feature in order to log all informations about those
interactions.

JDBC wrapper is described in the "Java Performance Tuning" book of Jack Shirazi ( O'Reilly) in the chapter 16.

All elements wrappers have a constructor with the element to wrap. We can use it but
there is another mode for datasource. This last mode must be used to wrap a datasource
defined in an application server for example.

However since we can manage our objects ( beans ) in Spring ( and datasources
too ), it's possible to add a P6Spy datasource and link it with the real datasource
with constructor injection.


<?xml version="1.0" encoding="ISO-8859-1"?>



<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

               "http://www.springframework.org/dtd/spring-beans.dtd">



<beans>

<bean id="myDataSourceTarget"

      class="org.apache.commons.dbcp.BasicDataSource"

      destroy-method="close">

    <property name="driverClassName">

        <value>org.hsqldb.jdbcDriver</value>

    </property>

    <property name="url">

        <value>jdbc:hsqldb:hsql://localhost:9001</value>

    </property>

    <property name="username"><value>sa</value></property>

    <property name="password"><value></value></property>

</bean>



<bean id="myDataSource" class="com.p6spy.engine.spy.P6DataSource"

                                             destroy-method="close">

    <constructor-arg>

        <ref local="myDataSourceTarget"/>

    </constructor-arg>

</bean>



</beans>

Moreover a p6spy.log file must be add to the classpath of the application
to specify the location of the log file.


module.log=com.p6spy.engine.logging.P6LogFactory



executionthreshold=

outagedetection=false

outagedetectioninterval=

filter=false

include     =

exclude     =

sqlexpression =

autoflush   = true

dateformat=

includecategories=

excludecategories=info,debug,result,batch



stringmatcher=

stacktraceclass=



reloadproperties=false

reloadpropertiesinterval=60



useprefix=false



appender=com.p6spy.engine.logging.appender.FileLogger

logfile     = c:/spy.log



append=true



log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender

log4j.appender.STDOUT.layout=org.apache.log4j.PatternLayout

log4j.appender.STDOUT.layout.ConversionPattern=p6spy - %m%n



log4j.logger.p6spy=INFO,STDOUT

The output can be graphically view with a tool like Iron Track SQL.

Advantages of this solution are the following:

It isn't necessary to modify the configuration of the application
server datasource in order to integrate P6Spy.

The use of P6Spy is much easier. No deep knowledge of the format
of the P6Spy configuration file is required ( only specify the location
of log file ).