Gridshore software engineering weblog - Springframework

Last entry ...

nospam@example.com (Jettro Coenradie) — Sat, 19 Jan 2008 20:58:56 +0100

Welcome to the last entry of this blog. No I am not quitting, I am just moving. I just installed a new blog software framework. I was starting to dislike the way to interact and I wanted something that contained more out of the box. I am in the middle of moving to wordpress software. There is a very good reason to do this. I had found a great tool on the mac called MarsEdit. And again this could not be used with serendipity. I hope I did make a good choice. Since there is a lot of information in the old blog, I did not take this blog offline. It will stay to exist, but I will not make changes there anymore.

I hope to see you at the new version of the blog (check the page at http://www.gridshore.nl). You can attach you feedreader to the following url: feed://www.gridshore.nl/feed/

Creating an application with maven2, jpa, springframework and intellij

nospam@example.com (Jettro Coenradie) — Wed, 21 Nov 2007 19:49:46 +0100

Some time ago I started working with intellij, recently I bought a mac, and now I want to start programming. But where to start? There are some mandatory things, or not? Well lets just start and try to make it as flexible as possible so we can use other frameworks for some layers. For now I will focus on the following technologies:

Springframework
JPA, the hibernate implementation
Java 5 and annotations

When creating the sample I started of programming in Intellij. Even with the excellent integration of JPA and Hibernate I still had a lot op problems creating the sample. Damn this is not easy. So what do you do when you are stuck? You start reading, I already had some books that could help me out. Still I like the Java Persistence with Hibernate book the best. The similarities between hibernate and JPA enabled me to quicker learn the basics. So I started reading, I came to the conclusion I had or wanted to start using annotations. It struck me how well Intellij was helping me again.

Just a few tips when developing with intellij, maven, jpa, spring, etc.

Create a new project based on an external model, click next and choose maven. Click next again and browse to the folter containing the master pom file. Click next and you have the option to select the project. The finish will create your new project with all modules present.

By default the spring and jpa facets are not present. You need to add them to the modules. Open the module settings (right mouse click and select menu item) and add the plus sign for adding a facet. The following screen shows the result of adding the spring facet and creating a new File Set. Another cool thing is that you can create a datasource to a database and connect this to a persistent unit. Columns and tables are then checked when creating your annotations.

I like the intellij way of creating new projects, but still I am a maven adept, so I wanted to have it all running with maven. You can find the sample online again. Beware, it is work in progress. I am adding a front end and more logic the coming weeks. Check:
http://gridshore.googlecode.com/svn/trunk/RaffleApp/

If you want to start with jpa, spring and maven I can recommend the following archetype:
http://www.rateyourwriting.com/downloads/jpa-hibernate-archetype.tar.gz
I did not try it out myself, but it looks very good. It is create by Chris Maki (http://www.jroller.com/cmaki/category/JPA+101)

In the reference manual of the springframework I found a sentence that for new applications they prefer not to use the JpaDaoSuppor class. There is another way based on the special bean PersistenceAnnotationBeanPostProcessor. Using this bean you can use annotations like : @Entity, @PersistenceContext from within the spring container.

Back to my problem, for some reason my tests using the AbstractJpaTests did not work with the separate jars for domain and data access (dao). I started by combining them in one module. But I was not satisfied. So I went back to my friend Google. I typed in a query for information about using modules with jpa and springframework. To my surprise I got back a lot of articles about the debate between using DAOs or not. Yes we are back to the discussion about DDD or Domain Driven Design. After reading a lot of posts I guess the following sentence found on a blog item from Craig Wickesser but written by Adam Bien:

I would say: it depends. It depends how complex your application really is.

Now back to the original problem, how to design a application using JPA?

Some of the choices you have to make:

Use annotations or XML or both?
Use JpaTemplate or annotations and (org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor)
Create one or multiple modules
Use a DAO layer or step into the DDD world and use the Persistence class.

In the end I did manage to get back to my so well known structure of a DAO layer and domain objects. What I had to do? We will check the persistence.xml file later on. I had to add the specific classes in this file.

Every problem needs a sample
Let me first explain a bit about the example that I am going to use. For a technology evening at my company I had some books that I could give away to the people present. Since it was an evening about the Google Web Toolkit I created a nice front end application using a file as storage to a Raffle application. Check the following application if you want to see it:
http://gridshore.googlecode.com/svn/trunk/Raffle/

I decided this file thing was not really optimal, so I wanted to create a database backed application. What to use? Well lets try it out JPA, hibernate started to get boring and I wanted to move on. So what is in the raffle applications domain model

Some rules:

A raffle has multiple prices and multiple participants.
A price has a winner
A winner is a participant, or has a participant and a price.

We begin with the project setup using maven:
First the dependencies that you need in your pom:
spring-aop, spring-dao, spring-jpa, spring-hibernate3, hibernate-entitymanager, c3p0, mysql-connector-java, concurrent, spring-mock

Thats about it, put that in the pom.xml, create the structure and do a mvn clean install, or ...

Fire up intelij, create a new project based on this pom.xml and you can do the same things as I showed before.

Well begin with the domain objects:



@MappedSuperclass

public class BaseDomain {

    @Id

    @GeneratedValue

    private Long id;

}



@Entity

@Table (name = "participants")

public class Participant extends BaseDomain {

    private String name;

    @ManyToOne

    @JoinColumn(name = "raffle_id")

    private Raffle raffle;

}



@Entity

@Table(name = "prices")

public class Price extends BaseDomain {

    private String title;

    private String description;

    @ManyToOne

    @JoinColumn(name = "raffle_id")

    private Raffle raffle;

    @OneToOne (mappedBy = "price")

    private Winner winner;

}



@Entity

@Table (name = "winners")

public class Winner extends BaseDomain {

    @OneToOne

    @JoinColumn(name = "price_id")

    private Price price;

    @ManyToOne

    @JoinColumn(name = "participant_id")

    private Participant participant;

}

Next step is to create a DAO interface that does not have anything to do with JPA, I use the interface like this:



public interface BaseDao {

    T save(T entity);

    T loadByExample(T entity);

    T loadById(Long entityId);

    List loadAll();

    List loadByFilter(T entityFilter);

}

For now I will not focus on the implementation, I am not a JPA expert yet . One thing I want to mention is the EntityManager. Using a special annotation we make sure the EntityManager is injected by the container, the spring container in our case.



public abstract class BaseDaoJpa implements BaseDao {

    @PersistenceContext

    private EntityManager entityManager;

...

}

Next step is to configure the spring beans:



<bean id="raffleDao" class="nl.gridshore.samples.raffle.dao.jpa.RaffleDaoJpa"/>



    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">

        <property name="persistenceUnitName" value="raffle"/>

        <property name="jpaVendorAdapter">

            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">

                <property name="databasePlatform" value="${hibernate.sql.dialect}"/>

            </bean>

        </property>

        <property name="dataSource" ref="dataSource"/>

    </bean>



    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">

        <property name="entityManagerFactory" ref="entityManagerFactory"/>

    </bean>



    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>



    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

        <property name="driverClassName" value="${jdbc.driverclass}"/>

        <property name="url" value="${jdbc.url}"/>

        <property name="username" value="${jdbc.username}"/>

        <property name="password" value="${jdbc.password}"/>

    </bean>

Finally we need to configure the the entity manager, this is done with a special file named persistence.xml which is displayed beneath.



<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">

    <persistence-unit name="raffle" transaction-type="RESOURCE_LOCAL">

        <provider>org.hibernate.ejb.HibernatePersistence</provider>

        <class>nl.gridshore.samples.raffle.domain.BaseDomain</class>

        <class>nl.gridshore.samples.raffle.domain.Raffle</class>

        <class>nl.gridshore.samples.raffle.domain.Price</class>

        <class>nl.gridshore.samples.raffle.domain.Participant</class>

        <class>nl.gridshore.samples.raffle.domain.Winner</class>

        <properties>

            <property name="hibernate.archive.autodetection" value="class"/>

            <property name="hibernate.show_sql" value="true"/>

            <property name="hibernate.format_sql" value="true"/>

            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>

        </properties>

    </persistence-unit>    

</persistence>

That is enough to start using the application. However, there is one thing I forget. What about testing this application. Spring comes with a special class for testing called AbstractJpaTests. This is class had familiar functionality, auto dependency injection and rolling back a transaction after the test.

Using this test you still need a database. For the data access tests I am using a combination of dbunit, springframework and hsqldb. Most important part of the test class is the injection of the dao:



public class RaffleDaoJpaTest extends AbstractJpaTests {

    private RaffleDaoJpa raffleDao;



    public void setRaffleDao(RaffleDaoJpa raffleDao) {

        this.raffleDao = raffleDao;

    }



	...



    protected String[] getConfigLocations() {

        return new String[] {"classpath:test-dao-spring.xml","classpath:dao-config.xml"};

    }

}

The following beans are in the special test spring config file together with the datasource for the test database.



    <bean id="dbUnitInsertOperation" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean"

            depends-on="transactionManager">

        <property name="targetObject">

            <bean class="org.dbunit.operation.RefreshOperation" />

        </property>

        <property name="targetMethod" value="execute" />

        <property name="arguments">

            <list>

                <ref bean="dbUnitConnection" />

                <bean id="dbUnitDataSet" class="org.dbunit.dataset.xml.FlatXmlDataSet">

                    <constructor-arg>

                        <bean id="refDataFile" factory-bean="referenceData" factory-method="getInputStream" />

                    </constructor-arg>

                </bean>

            </list>

        </property>

    </bean>



    <bean id="referenceData" class="org.springframework.core.io.ClassPathResource">

        <constructor-arg value="testdata.xml"/>

    </bean>



    <bean id="dbUnitConnection"	class="util.CustomDatabaseConnection">

        <constructor-arg>

            <bean id="connection" factory-bean="dataSource"	factory-method="getConnection" />

        </constructor-arg>

    </bean>

That is about it, again, check the source code, everything is runnable by maven2 and tested on tomcat 5.5. If you want to read more, I used the following resources while creating learning about jpa and the other topics.

Links:
http://www.infoq.com/news/2007/09/jpa-dao
http://debasishg.blogspot.com/
http://www.vitarara.org/cms/struts_2_cookbook/integration_testing
http://dev2dev.bea.com/pub/a/2006/03/jpa-spring-medrec.html?page=6
http://www.jroller.com/cmaki/entry/domain_model_revisited

Loading properties using JNDI within the springframework deployed on tomcat

nospam@example.com (Jettro Coenradie) — Fri, 16 Nov 2007 23:32:54 +0100

Hai All,
finally a new technical item. It is a short item, but I have been struggling to get this to work. Therefore I want to share this so other can use it to configure there properties in a flexible way.

Problem:
Properties like database url's, userid's and pasword's are different in your test environment and your production environment. There are other items you might want to configure.

Solution:
You can make complicated deployment scripts that get the right property files for the right environment. But you need to create different packages for different environments. I think a more elegant solution is to use the JNDI parameters to load the specific environmental values. If there are a lot a good way might be to store them in a database and only configure the database access parameters using JNDI.

The following solution is based on two posts in different forums:
http://forum.java.sun.com/thread.jspa?threadID=647327&messageID=3810991 - gives details about the configuration of tomcat.
http://forum.springframework.org/showthread.php?t=30991 - gives details about the spring configuration

Now the code, we start with the tomcat configuration. The server.xml file contains all the actual values connected to the exposed JNDI parameter names.

server.xml



  <!-- Global JNDI resources -->

  <GlobalNamingResources>

    <!-- Test entry for demonstration purposes -->

    <Environment name="jdbc/username" value="myUser" type="java.lang.String"/>

    <Environment name="jdbc/password" value="myPwd" type="java.lang.String"/>

    <Environment name="jdbc/url" value="jdbc:mysql://servername/schema" type="java.lang.String"/>

    <Environment name="jdbc/drivername" value="com.mysql.jdbc.Driver" type="java.lang.String"/>

  </GlobalNamingResources>

We need to tell the application the names of the parameters that are available. We must add the following items to the web configuration file.

web.xml



<resource-env-ref>

    <resource-env-ref-name>jdbc/username

    <resource-env-ref-type>java.lang.String

</resource-env-ref>

Of course you need to do this for all four parameters. Then the tricky part. This is the one I missed while getting this to work. You need to add a tomcat specific deployment configuration with the following lines

META-INF/context.xml



<Context path="/webapp">

    <ResourceLink name="jdbc/username" global="jdbc/username" type="java.lang.String"/>

    <ResourceLink name="jdbc/password" global="jdbc/password" type="java.lang.String"/>

    <ResourceLink name="jdbc/url" global="jdbc/url" type="java.lang.String"/>

    <ResourceLink name="jdbc/drivername" global="jdbc/drivername" type="java.lang.String"/>

</Context>

Thats is all we need to do to make these values available to the spring beans. So the last part is the spring configuration. We are going to create a PropertyPlaceHolderConfigurer. That way you can access the properties just like properties from a file.

spring-config.xml



    <bean id="databaseprops" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

        <property name="properties">

            <bean class="java.util.Properties">

                <constructor-arg>

                    <map>

                        <entry key="database.username">

                            <jee:jndi-lookup jndi-name="java:comp/env/jdbc/username"/>

                        </entry>

                        <entry key="database.password">

                            <jee:jndi-lookup jndi-name="java:comp/env/jdbc/password"/>

                        </entry>

                        <entry key="database.url">

                            <jee:jndi-lookup jndi-name="java:comp/env/jdbc/url"/>

                        </entry>

                        <entry key="database.drivername">

                            <jee:jndi-lookup jndi-name="java:comp/env/jdbc/drivername"/>

                        </entry>

                    </map>

                </constructor-arg>

            </bean>

        </property>

    </bean>

    <bean id="sampleConfigBean" class="nl.gridshore.samples.config.SampleConfiguredBean">

        <property name="username" value="${database.username}"/>

        <property name="password" value="${database.password}"/>

        <property name="url" value="${database.url}"/>

        <property name="drivername" value="${database.drivername}"/>

    </bean>

This made my deployment life a lot easier, hope you will find some good use of it. Thanks again to contributers on the forum for making the different parts clear to me.

Till next time, which is going to be a piece about JPA.

greetz Jettro Coenradie

Using Spring-ws for creating a webservice

nospam@example.com (Jettro Coenradie) — Wed, 04 Jul 2007 20:33:52 +0200

My previous post was about creating a client with the spring-ws project. This dis take me some time to grasp. But without a published webservice a client is of no much use. Therefore I also had a look at the server side. To my surprise this was even easier than expected. I did have some requirements for the sample:

wsdl generation
marshalling/unmarshalling using jaxb2

That does not sound to bad does it? Well try to do it with axis and you'll be surprised. If you know a little bid about spring-webmvc and the use of the dispatcher, you know you need one configuration file for spring. For the webservice I had to provide the spring config file and one class, yes really, just one class. I used maven to generate the jaxb stuff and this is wat I did:



web.xml

<servlet>

  <servlet-name>spring-ws /servlet-name>

  <servlet-class>org.springframework.ws.transport.http.MessageDispatcherServlet</servlet-class>

</servlet>

<servlet-mapping>

  <servlet-name>spring-ws /servlet-name>

  <url-pattern>/* /url-pattern>

</servlet-mapping>

The spring-ws framework provides a special servlet that receives the requests. No the really hard part, the spring configuration for the endpoint:



<bean class="org.springframework.ws.server.endpoint.mapping.SimpleMethodEndpointMapping">

  <property name="endpoints" ref="congressRegistrationEndpoint"/>

</bean>

<bean id="congressRegistrationEndpoint"  class="nl.gridshore.samples.springws.server.JaxbMarshallingMethodEndpoint">

  <property name="marshaller" ref="marshaller"/>

  <property name="unmarshaller" ref="unmarshaller"/>

</bean>

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">

  <property name="contextPath" value="nl.gridshore.samples.jaxb"/>

</bean>

<bean id="unmarshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">

  <property name="contextPath" value="nl.gridshore.samples.jaxb"/>

</bean>

First check the endpoint mapping, this class SimpleMethodEndpointMapping is found by the dispatcher to map all incoming requests to endpoints. In our case we map to our only endpoint called the congressRegistrationEndpoint. This class has a special super class that needs a marshaller and unmarshaller. Other than that it needs nothing. By convention the name of the Request is used by the super class to know which method to call. In our case we have a CongressRegistrationRequest. Therefore we need to implement to method handleCongressRegistrationRequest as you can see in the following coded block.



public CongressRegistrationResponse handleCongressRegistrationRequest(CongressRegistrationRequest request) {

  ObjectFactory objectFactory = new ObjectFactory();

  CongressRegistrationResponse response = objectFactory.createCongressRegistrationResponse();

  response.setRegistrationCode("code333");

  return response;

}

In this code the argument and the return value are JAXB objects. I created the most easy method, do nothing with the request and always return the same response. Bu as you can see the code itself is very clean. I do not need to do a lot of conding. I think this is probably one of the easiest implementations I have seen that works in java 1.4 as well.

That is it for one of the requirements. Now I also wanted a solution for generating the wsdl. In the end this is only some springframework configuration. You also need an xsd, but you have already used this to generate the jaxb classes with maven. So we can reuse it. Check the following configuration



<bean id="service" class="org.springframework.ws.wsdl.wsdl11.DynamicWsdl11Definition">

  <property name="builder">

    <bean class="org.springframework.ws.wsdl.wsdl11.builder.XsdBasedSoap11Wsdl4jDefinitionBuilder">

      <property name="schema" value="/WEB-INF/classes/congressregistration.xsd"/>

      <property name="portTypeName" value="services"/>

      <property name="locationUri" value="http://localhost:8080/spring-ws-sample-server/"/>

      <property name="targetNamespace" value="http://www.gridshore.nl/samples/definitions"/>

    </bean>

  </property>

</bean>

So you need the location of the xsd, the name of the bean is used to find the wsdl. The locationUri locates the endpoint and the targetNamespace is the namespace used in the xsd. By entering the following url you can find the wsdl.
http://localhost:8080/spring-ws-sample-server/service.wsdl

You can check the code at the google code project.

I know it is pretty short, but with the code you should be able to understand it.

greetz Jettro

Creating a webservice client using Spring-ws and maven2

nospam@example.com (Jettro Coenradie) — Sat, 30 Jun 2007 21:25:00 +0200

Last week I attended the SpringOne Congress in Antwerp. Just one or two days before the congress I wanted to create a proof of concept for a client connecting to a webservice. I have been using the proxy way (spring-remote), but I did not really like the way this works. Therefore I was looking for something else. I stumbled upon the Spring Webservices project. I did try this out before, but not for clients. I started working and it did not look very complicated. I must admit I needed the help from Arjen Poutsma himself to make it work, but now I have a very light weight solution. I like the approach very much, therefore I will briefly describe the solution I have created. You can of course find the sources online as well. Check the google code subversion repo for gridshore.

Overview of application

Build application using maven2

Web application build using spring webmvc

Webservice client created using spring-ws

Mapping between objects and xml using jaxb2 and spring-oxm

Maven 2 for building

This time not much details about the maven2 part. There are some things interesting though. Most important part is the creation of the jaxb generated classes using the maven2 jaxb2 plugin.

Using spring-webmv for web project

I do not think it is really interesting to talk a long time about this. There can be found a lot (better) resources online. I used the spring webmvc project to make the client i18n compatible, used the form controllers from spring to help with the error messages and validation stuff. For the webservices part the most interesting thing starts in the file service-applicationcontext.xml. This spring configurtion file contains the webservice client, the converters for jaxb (using generics to abstract the technique marshalling technique).

Webservice client created using spring-ws

Let's start by having a look at the configuration:



<bean id="congressRegistrationDAO"

    class="nl.gridshore.samples.springws.integration.wsclient.impl.CongressRegistrationGateway">

  <property name="defaultUri" value="${cr.endpoint}" />

  <property name="marshaller" ref="marshaller"/>

  <property name="unmarshaller" ref="unmarshaller"/>

  <constructor-arg index="0" ref="congressRegistrationRequestConverter"/>

  <constructor-arg index="1" ref="congressRegistrationResponseConverter"/>

</bean>

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">

  <property name="contextPath" value="nl.gridshore.samples.jaxb"/>

</bean>

<bean id="unmarshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">

  <property name="contextPath" value="nl.gridshore.samples.jaxb"/>

</bean>

This configured class is the class that knows how to connect to the webservice. It uses a few values and classes to do it's work. The defaultUri is used to find the endpoint to connect to (we obtain it from a property file). Since we use JAXB2 to marshall and unmarshall the request we need the marshaller and unmarshaller. These (un)marshallers are provided by spring-ws as well. Actually they are provided by spring-oxm. The interface for the marshaller is the same as for the unmarshaller. The only thing you need to provide is the package where the jaxb files are generatd in. The other two references are converters used to convert the application specific components to JAXB2 components. More on this later as well. So the most important class is the Gateway class. Let's have a look at that now.



package nl.gridshore.samples.springws.integration.wsclient.impl;



import nl.gridshore.samples.springws.domain.RegistrationDetails;

import nl.gridshore.samples.springws.integration.converter.Converter;

import nl.gridshore.samples.springws.integration.wsclient.CongressRegistrationDAO;



import org.springframework.ws.client.core.support.WebServiceGatewaySupport;

import org.springframework.ws.soap.client.core.SoapActionCallback;



public class CongressRegistrationGateway extends WebServiceGatewaySupport implements CongressRegistrationDAO {

  private final Converter requestConverter;

  private final Converter responseConverter;

	

  public CongressRegistrationGateway(Converter requestConverter,  

      Converter responseConverter) {

    this.requestConverter = requestConverter;

    this.responseConverter = responseConverter;

  }

	

  public String registerForCongress(final RegistrationDetails registrationDetails) {

    Object request = requestConverter.convert(registrationDetails);

    Object response = getWebServiceTemplate().marshalSendAndReceive(request);

    return responseConverter.convert(response);

  }

}

This is it, really. I show you the complete class, but in the end the most important works takes place in one line. That's the one in bold. Here we use the special webServiceTemplate class and ask it to marshall our request object and send it as a soap message to the configured endpoint. Ofcourse you can do a lot more, but for most situations this is all it takes. Do not forget to extend the WebServiceGatewaySupport class.

Mapping between objects and xml using jaxb2 and spring-oxm

Not much to tell here as well. I keep saying this, but that's because it is true. We have configured the marshaller and the unmarshaller which are provided by spring-oxm. We also call the right method from the template adapter called marshalSendAndReceive. I did create an interface and some implementations that enable the gateway to be ignorand to the type of marshalling and unmarshalling we use. This is my first try to do something with generics. There can be a better way, if you know one, please let me know as well . Let's start with the generic interface.



public interface Converter {

  public E convert(T toBeConverted);

}

So we have an interface specifying we have a object as a parameter and an object as a return type. Then there is a method called convert that uses these generic types. At the moment I have two concrete implementations for creating the JAXB request and handling the JAXB Response. One of them is presented below.



public class CongressRegistrationResponseConverter implements Converter {

  public String convert(CongressRegistrationResponse toBeConverted) {

    String response = toBeConverted.getRegistrationCode();

      return response;

  }

}

As you can see we now have a concrete implementation for the generic interface. The returned object is a String and the parameter is a JAXB object called CongressRegistrationResponse. Now look back at the gateway code, check that there is no jaxb reference in that code.

Again check out the code at google code subversion repo for gridshore. You can already find the code for a server implementation there as well. The next blog will deal with the server. I am also working on a sample about the Rule engine called Drools. so stay tuned.

Spring osgi - an evaluation using maven 2 and the special spring osgi archetype

nospam@example.com (Jettro Coenradie) — Wed, 03 Jan 2007 21:20:43 +0100

A few months a go I was reading the website of the springframework. One article subject supprised me. I had never heard of it, OSGi. Curious enough to want to know what it was about I opened the article and started reading. The more I read the more I was certain, this is going to be the next big thing. Then in December I attended The SpringExperience in Miami and of course there was one presentation I had to attend. It turned out I was not the only one interested in spring-OSGi. Adrian Colyer gave a very interesting presentation and almost the complete interface21 team was there. They all think OSGi is going to be the next big thing. If you do a google on spring osgi you will get a lot of hits. Of course none of these is as technical as mine

If you want to read more about the event look at this blog.

Now a few weeks later I had finally found some time to experiment, and of course I want to share what I have learned. This blog item is a step by step approach of creating your own spring-osgi bundle. Later I will add some more complicated bundles with references, listeners and maybe a webserver.

So, how do we start? Well first download all code and install it using maven. Hmm, maybe I should tell you first that you need to install maven 2 and subversion. So, please install subversion and maven2. Then checkout all sources:



svn checkout https://svn.sourceforge.net/svnroot/springframework/spring-osgi/trunk spring-osgi

Than step into the root folder and do a mvn install. You can ofcourse have a look at the samples that come with spring-osgi. Please go to the spring-osgi website and see the tutorials there. We arfe going to create a new bundle using the maven archetype.

If you want to have a look at the complete source code, do a checkout from the following google code website or browse it online



svn checkout http://gridshore.googlecode.com/svn/trunk/SpringOsgiSample gridshore

Using the archetype



mvn archetype:create \

  -DarchetypeGroupId=org.springframework.osgi \

  -DarchetypeArtifactId=spring-osgi-bundle-archetype \

  -DarchetypeVersion=1.0-SNAPSHOT \

  -DgroupId=nl.gridshore.samples.springosgi \

  -DartifactId=bookreview-service \

  -Dversion=1.0-SNAPSHOT \

  -DremoteRepositories=http://static.springframework.org/maven2-snapshots

Have a look at the generated pom.xml file and check mine. There are some things I altered that are important.
- I added the scope - test to the dependencies that did not have it
- I added the following dependencies : jcl104-over-slf4j.osgi, slf4j-log4j-full and log4j.osgi
- removed the dependecy for commons-logging
Check the pom.xml file of the provided samples by spring-osgi, that is where I got it from.

The archetype also provides a .project and .classpath file for eclipse. I had problems when I did a mvn eclipse:clean eclipse:eclipse. Some lines are not added that were in place when the files were provided by the archetype.



    <buildCommand>

      <name>org.eclipse.pde.ManifestBuilder</name>

    </buildCommand>

    <buildCommand>

      <name>org.eclipse.pde.SchemaBuilder</name>

    </buildCommand>

    <nature>org.eclipse.pde.PluginNature</nature>

Not sure whether these are absolutely necessary. I do know a bundle within eclipse is a plugin, therefore you need the plugin nature.

Start coding
The framework of the project is in place and should compile (mvn install). Now it is time to start creating the bundle. We'll start by creating the BookReviewService, the unit test and the implementation of this service. This is pure java code, check the sources if you like. Now add a bean that we can expose as a service to the spring context file. There are two context files out of the box. You can find them in the src/main/resources/META-INF/spring folder.
bundle-context.xml : contains the normal spring configuration
bundle-context-osgi.xml : contains all beans that use the osgi namespace

We have created the spring bean myBookReviewService:



<bean name="myBookReviewService" 

    class="nl.gridshore.samples.springosgi.impl.BookReviewServiceImpl" />

Then we expose this bean as a special osgi service



<osgi:service id="bookReviewServiceOSGi" ref="myBookReviewService"

    interface="nl.gridshore.samples.springosgi.BookReviewService" />

And now we are done, no not really. First we need to create an integration test. We use the special super class AbstractDependencyInjectionSpringContextTests. This test uses the spring config file to configure and start an application context. From the context we obtain our bean and test it to see if it works.
Alter the manifest file
Next step is to alter the manifest file, you can find this file in the META-INF folder at the same level of the src folder. You need to add an export package and the Bundle-classpath



Bundle-Version: 1.0

Bundle-SymbolicName: nl.gridshore.samples.springosgi.bookreviewservice

Bundle-Name: nl.gridshore.samples.springosgi.bookreview-service

Export-Package: nl.gridshore.samples.springosgi

Bundle-ClassPath: .,

 target/classes/

Now we are ready to package our bundle. By using one of the tutorials from the spring-osgi website you can use eclipse/equinox to install and start this bundle. There is however not much to see. Wouldn't it be nice to be able to test within an exsiting osgi container whether your hard labor was wurth it? You can, the next steps will describe how you can create an in container test.

Creating the in container test
Again the framework provides a number of super classes that makes life a lot easier. I am not going to explain in detail what these classes are doing. Still I think one thing is important to know. Your test projects is being transformed into a bundle at runtime with a reference to the bundle under test. But lets start with the creation of the normal jar file that will contain our test.



mvn archetype:create \

  -DgroupId=nl.gridshore.samples.springosgi \

  -DartifactId=bookreview-service-integration-test \

  -Dversion=1.0-SNAPSHOT \

Alter the pom, it should use the parent and have a lot of dependencies. There are two I would like to mention is special:
bookreview-service : this is our own project that we are gonna test
org.springframework.osgi.test : utilit classes for our own test class

The manifest file for the bundle that is created on the fly comes from the test/resources directory and looks like this.



Manifest-Version: 1.0

Bundle-Name: simple-service-integration-tests

Bundle-SymbolicName: nl.gridshore.samples.springosgi.test

Bundle-Activator: org.springframework.osgi.test.JUnitTestActivator

Import-Package: junit.framework,

 org.osgi.framework;specification-version="1.3.0",

 org.springframework.core.io;specification-version="2.1.0",

 org.springframework.osgi.test,

 org.springframework.osgi.test.runner,

 nl.gridshore.samples.springosgi

Now we can create the test, use the ConfigurableBundleCreatorTests as a super class and implement the method to locate your MANIFEST.MF file. You also must implement a method that defines all the dependencies that can be obtained from your local maven repository. Finally you need to add your test methods.



public void testOSGiStartedOk() {

   BundleContext bundleContext = getBundleContext();

   assertNotNull(bundleContext);

}

This test checks if the context for the created bundle can be obtained.



public void testSimpleServiceExported() {

  waitOnContextCreation("nl.gridshore.samples.springosgi.bookreviewservice");

  BundleContext context = getBundleContext();

  ServiceReference ref = context.getServiceReference(BookReviewService.class.getName());

  assertNotNull("Service Reference is null", ref);

  try {

    BookReviewService bookReviewService = (BookReviewService) context.getService(ref);

    assertNotNull("Cannot find the service", bookReviewService);

    List bookreviews = bookReviewService.findBookReviewByKeyword("habits"); 

    assertEquals(1, bookreviews.size());

  } finally {

    context.ungetService(ref);

  }

}

This test first checks if the osgi service can be obtained from the bundle context. Then the obtained service is used and the result is checked. In my case we are looking for a book and if all is well we should be able to find exactly one.

Now do a mvn install on the highest level and you should have a tested spring osgi module

Conclusion
That is about it, I hope this will help some of you, do not hesitate to ask questions if something is not clear. You can find a lot of information on the spring osgi website, there is a google group and google lists about thousands of hits.

Creating a maven archetype for acegi and springframework

nospam@example.com (Jettro Coenradie) — Thu, 31 Aug 2006 20:51:15 +0200

I have created a lot of small applications that include spring and acegi. Most of the time I copy most of the resources from another project. Some time ago I learned about the maven archetypes. An easy way to create the project structure. That was the time I decided that I wanted to have my acegi springframework archetype. Last weeks I found some time to create this archetype. You can download the files here:
http://code.google.com/p/gridshore/
And the generated maven site here:
http://www.gridshore.nl/projects/springframeworkarchetype/index.html
Ofcourse there is also a maven website about creating an archetype, this is not a very extensive website. In this blog item I will explain more about the archetype I created.

First thing to know, well surprise, the archetype is just a maven project. You can start you new archetype by using a maven archetype:
mvn archetype:create
-DgroupId=nl.gridshore.samples.archetype
-DartifactId=SpringframeworkArchetype
-DarchetypeArtifactId=maven-archetype-quickstart
Have a look at the pom for the other properties; scm, distributionManagement, etc.

The project itself contains an src\main\resources\META-INF\maven\archetype.xml file that defines all the resources that need to be copied.



<archetype>

  <id>SpringframeworkArchetype</id>

  <sources>

    <source>src/main/java/App.java</source>

  </sources>

  <testSources>

    <source>src/test/java/AppTest.java</source>

  </testSources>

  <resources>

      <resource>src/main/webapp/index.jsp</resource>

      <resource>src/main/webapp/WEB-INF/web.xml</resource>

      <resource>src/main/webapp/WEB-INF/action-servlet.xml</resource>

      <resource>src/main/webapp/WEB-INF/jsps/welcome.jsp</resource>

      <resource>src/main/webapp/WEB-INF/jsps/adminwelcome.jsp</resource>

      <resource>src/main/webapp/WEB-INF/jsps/accessdenied.jsp</resource>

      <resource>src/main/webapp/WEB-INF/jsps/login.jsp</resource>

      <resource>src/main/webapp/WEB-INF/jsps/loginerror.jsp</resource>

      <resource>src/main/resources/security-springConfig.xml</resource>

      <resource>src/main/resources/views.properties</resource>

      <resource>src/main/resources/errormessages.properties</resource>

      <resource>src/main/resources/sitetext.properties</resource>

      <resource>src/main/resources/log4j.dtd</resource>

      <resource>src/main/resources/log4j.xml</resource>

  </resources>

</archetype>

The structure is pretty easy, you can find all the resources under the directory:
src\main\resources\archetype-resources

You can use the following parameters in your file as placeholders:
http://maven.apache.org/plugins/maven-archetype-plugin/create-mojo.html. Have a look at the src\main\resources\archetype-resources\pom.xml for an example:



  <groupId>$groupId</groupId>

  <artifactId>$artifactId</artifactId>

  <version>$version</version>

Hope that helps you on your way to your own archetype. If you just want to use mine:



mvn install

mvn archetype:create

	-DgroupId=your.groupid

	-DartifactId=your.artifactId

	-DarchetypeArtifactId=SpringframeworkArchetype

	-DarchetypeGroupId=nl.gridshore.samples.archetype

	-DarchetypeVersion=1.0.0-SNAPSHOT

Providing a webservice with Spring and axis

nospam@example.com (Jettro Coenradie) — Sun, 25 Jun 2006 22:00:00 +0200

Finally I found some time to start experimenting with a webservice. I know I am not the first to write about creating your own webservice, still I think this is worth reading. I am writing a step by step creation of a webservice via maven2, axis 1.4 and spring 2.0RC1. Ofcourse you can use older versions, but I want to be ready for the future and keep on using this sample. For now I am working with a HelloWorld sample. I will make it more complicated when needed to show interesting things.

Download the sources here

Step 1 - Configuring your maven project environment
We create a new directory to store all projects : ~/WebservicePoc
Within this directory use the archetype of maven to create a structure for a web project:
The groupid is used within the create pom. The artifactId is used as project id and to create the folder to store all files in. The archetypeArtifactId defines the type of structure to create, in our case a web project.



mvn archetype:create 

          -DgroupId=com.coenradie.webservicespoc 

          -DartifactId=webservice-jaxrpc-style 

          -DarchetypeArtifactId=maven-archetype-webapp

Now it is time to create the pom in the root project directory. Beware if you create this pom first, the archetype:create won't work. Execute the command in a temporary directory and copy the files into the sub-directory of the module we are creating.



...

	<groupId>com.coenradie.webservicespoc</groupId>

	<version>1.0-SNAPSHOT</version>

	<artifactId>WebservicePoc</artifactId>

	<packaging>pom</packaging>

	<name>Webservice proof of concept</name>

	<inceptionYear>2006</inceptionYear>

	<url>http://localhost:8080/webservicepoc</url>

...

	<modules>

		<module>webservice-jaxrpc-style</module>

	</modules>

...

For a complete look at the pom, have a look at the downloadable source code.

We also need to make some adjustments to the generated pom of the webservice-jaxrpc-style module. Again have a look at the sources. Time to try the first compile. Execute the following command in the root of the project:



~/WebservicePoc/mvn install

Step 2 - Decide upon the libraries that we are going to use
For the application we are going to create we are going to use some libraries. We do not want to code ourselves to much. We are going to use the spring library and axis. Add these to the module pom.



  <dependencies>

    <dependency>

      <groupId>org.springframework</groupId>

      <artifactId>spring</artifactId>

      <version>2.0-RC1</version>

    </dependency>

    <dependency>

      <groupId>axis</groupId>

      <artifactId>axis</artifactId>

      <version>1.4</version>

    </dependency>

    <dependency>

      <groupId>axis</groupId>

      <artifactId>axis-jaxrpc</artifactId>

      <version>1.4</version>

    </dependency>

You will notice a problem with spring and maven 2 at the moment of writing. Maven provides the solution in the error message, we need to install the maven library manually. There aresome other options, but for now this is the easiest one. First download spring version 2.0 RC1, than issue the following command:



mvn install:install-file 

          -DgroupId=org.springframework 

          -DartifactId=spring 

          -Dversion=2.0-RC1 

          -Dpackaging=jar

          -Dfile=%PATH_TO_JAR%/spring.jar

Step 3 - Time to get the eclipse wtp to work
I want to deploy the webservice via tomcat and ofcourse I want a nice environment for debugging, deploying, and developing. I like to work with spring WebTools project, there is a pretty good integration with maven from the maven perspective. Lets use that. Fire up your eclipse (with wtp) and create a workspace. Do not create this workspace inside our projects, do it on another part of the disk. After creating this workspace, add the maven repository as a variable by using the following command:



mvn eclipse:add-maven-repo -Declipse.workspace=%PATH_TO_WORKSPACE%/WebservicePoc

Now let maven generate the eclipse project and classpath files, issue the following command:



mvn -Dwtpversion=1.0 eclipse:eclipse

You are ready to import the project into eclipse, "File > Import > Existing projects into workspace"

step 4 - Lets publish a webservice
The webservice is deployed within a web container. Both axis and the spring container run in a servlet. There is a connection between the two via the servlet endpoint which will be discussed in a while. These servlets are configured in the web.xml file. The template for the file is generated by maven, lets add the servlets, servlet mappings and a spring specific parameter.



	<context-param>

		<param-name>contextConfigLocation</param-name>

		<param-value>

			classpath:/applicationContext.xml

		</param-value>

	</context-param>

This parameter specifies the locations where spring can find the configuration files for the container. The applicationContext.xml contains the definition of the beans in the Business service domain. There is another configuration file for spring thats needs to be present. This is the default spring config file based on the name of the servlet that configures the spring container. In our case this file does not contain any beans, but it must be available. It must be called action-servlet.xml since we have given the spring dispatcher servlet the name action. The file should reside next to the web.xml in the WEB-INF folder.



	<servlet>

		<servlet-name>action</servlet-name>

		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

		<load-on-startup>1</load-on-startup>

	</servlet>



	<servlet>

		<servlet-name>axis</servlet-name>

		<servlet-class>org.apache.axis.transport.http.AxisServlet</servlet-class>

		<load-on-startup>2</load-on-startup>

	</servlet>



    <servlet-mapping>

        <servlet-name>action</servlet-name>

        <url-pattern>*.html</url-pattern>

    </servlet-mapping>



	<servlet-mapping>

		<servlet-name>axis</servlet-name>

		<url-pattern>/services/*</url-pattern>

	</servlet-mapping>

Here you can see the spring dispatcher servlet and the axis servlet. Most important to notice is the load-on-startup parameter that tells the order of loading the servlets. The axis servlet connects to the loaded spring context via the special endpoint. Therefore the spring servlet needs to be loaded first. You do not need the dispatcher servlet if you plan to expose only webservices. If you also want to include spring mvc or the like, you do need the dispatcher servlet.

Next task is to configure the axis webservice, this is done via the server-config.wsdd file.



	<service name="JaxrpcwebserviceProvider" provider="java:RPC">

		<parameter name="className"

			value="com.coenradie.webservicepoc.server.jaxrpcstyle.ServiceProvider"/>

		<parameter name="allowedMethods" value="*"/>

		<beanMapping qname="webservicepoc:MessageBean" xmlns:webservicepoc="urn:MessageBean" 

			languageSpecificType="java:com.coenradie.webservicepoc.server.jaxrpcstyle.MessageBean"/>

	</service>

We are creating a jaxrpc style webservice with the name JaxrpcwebserviceProvider. Axis should redirect all calls to this service to the endpoint of type ServiceProvider. This is a subclass of a special spring implementation of the servletendpoint, this class is will be discussed later on. As you can see from the wsdd file, all public methods are exposed via the webservice. As a transport object we use the MessageBean.

Now all configuration is in place, time to do some real coding. We need to implement the following classes and interfaces.
MessageService and MessageServiceImpl - Business service interface and implementation
MessageBean - Object returned via the jaxrpc webservice
RemoteMessageService - Remote interface that is implemented by the service endpoint and therefore implemented by the webservice.
ServiceProvider - the special webservice endpoint that contains access to the laoded spring context. The endpoint contains the method that is called via axis.



public interface MessageService {

	String getMessage();

}



public class MessageServiceImpl implements MessageService {

	public String getMessage() {

		return "Message from my server";

	}

}



public interface RemoteMessageService extends Remote {

	public MessageBean getMessage() throws RemoteException;

}



public class MessageBean implements Serializable {

	private static final long serialVersionUID = -7014683074252469915L;

	private String message;

	private String createDate;

	

	public String getCreateDate() {

		return createDate;

	}

	public void setCreateDate(String createDate) {

		this.createDate = createDate;

	}

	public String getMessage() {

		return message;

	}

	public void setMessage(String message) {

		this.message = message;

	}

}

The most important class is the endpoint, this is the class that gets called by axis. The spring superclass takes care of obtaining the spring web context. You can use this context to find spring wired beans. In our case we use it to find the Business service object MessageService.



public class ServiceProvider extends ServletEndpointSupport implements RemoteMessageService {

	private MessageService messageService;

	

	protected void onInit() {

		this.messageService = (MessageService)getWebApplicationContext().getBean("messageService");

	}

	

	public MessageBean getMessage() {

		MessageBean messageBean = new MessageBean();

		messageBean.setMessage(messageService.getMessage());

		messageBean.setCreateDate(new Date().toString());

		

		return messageBean;

	}

}

Time to fire up the server. You can use the run on server with a right mouse click on the project within eclipse wtp. Popup a browser and go to the following url:
http://localhost:8080/webservice-jaxrpc-style/services
That should give you an overview of all deployed services, probably only the JaxrpcwebserviceProvider.

Step 5 - Using xml spy to send a message via soap to the webservice
The webservice is deployed, you can have a look at the wsdl file, nice. Now we want to call the webservice. We can write a special java client. There is however an easier way with xmlspy. Since this blog item is all about exposing the webservice and not about creating a client, I will use xmlspy.

Fire up xmlspy and use the menu: SOAP > Create new soap request and enter the next url in the pop-up box:
http://localhost:8080/webservice-jaxrpc-style/services/JaxrpcwebserviceProvider?wsdl
After clicking oke, choose the getMessage() operating name, the following request is generated:



<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

	<SOAP-ENV:Body>

		<m:getMessage xmlns:m="http://jaxrpcstyle.server.webservicepoc.coenradie.com" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>

	</SOAP-ENV:Body>

</SOAP-ENV:Envelope>

Then we can send the request over soap via xmlspy: SOAP > Send request to server



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

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

	<soapenv:Body>

		<ns1:getMessageResponse soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" xmlns:ns1="http://jaxrpcstyle.server.webservicepoc.coenradie.com">

			<getMessageReturn href="#id0"/>

		</ns1:getMessageResponse>

		<multiRef id="id0" soapenc:root="0" soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" xsi:type="ns2:MessageBean" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:ns2="urn:MessageBean">

			<createDate xsi:type="soapenc:string">Mon Jun 26 09:48:31 CEST 2006</createDate>

			<message xsi:type="soapenc:string">Message from my server</message>

		</multiRef>

	</soapenv:Body>

</soapenv:Envelope>

That concludes this article, I learned a lot while writing this item, hope you learned something while reading. The coming weeks I want to write about creating a client, doing document style webservices, using spring webservices component and security. Stay tuned.

Using springframework to send an email with streaming attachment

nospam@example.com (Jettro Coenradie) — Tue, 22 Nov 2005 22:46:42 +0100

For a customer of mine I had another fine problem to resolve. He must send an email with a csv file as an attachment to his transport partner. The content for the csv file come from the database. Creating a string that has the contents for the file is easy, it would also be fairly easy to create a file, store it on the file system and add the file as an attachment. There is however one problem; I do not need the file after it has been attached to the email and send.

I started lookin at the api's of springframework related to email. It is not that hard to find some code that looks like the following to create the email to be sent:

1. MimeMessage message = getJavaMailSender().createMimeMessage();
2. MimeMessageHelper helper = new MimeMessageHelper(message,true);
3. helper.setFrom("from@gridshore.nl");
4. helper.setTo("to@gridshore.nl");
5. helper.setText("Text of the email");
6. helper.setSubject("attachment mail sample");

Now for the fun part, how can we attach a generated csv file to the email without storing it on th efile system first.

7. InputStream attach = new ByteArrayInputStream(mailMessage.getBytes());
8. StreamAttachmentDataSource datasource = new StreamAttachmentDataSource(attach,"attachment", "txt/plain");
9. helper.addAttachment(attachmentName,datasource);
10.getJavaMailSender().send(message);

The fun part is in line 8, you must create a custom implementation for the org.springframework.core.io.AbstractResource. This resource must convert an inputstream to an attachment. The code for this class looks like this:

public class StreamAttachmentDataSource extends AbstractResource {
private final static Log logger = LogFactory.getLog(StreamAttachmentDataSource.class);
private ByteArrayOutputStream outputStream;
private String name;
private String contentType;

public StreamAttachmentDataSource(InputStream inputStream, String name,
String contentType) {
this.outputStream = new ByteArrayOutputStream();
this.name = name;
this.contentType = contentType;

int read;
byte[] buffer = new byte[256];
try {
while((read = inputStream.read(buffer)) != -1) {
getOutputStream().write(buffer, 0, read);
}
} catch (IOException e) {
logger.error("Cannot create inputstream for mail attachment");
throw new AddAttachmentMailException("error.technical.mail.attachment");
}
}

public String getDescription() {
return "Stream resource used for attachments";
}

public InputStream getInputStream() throws IOException {
return new ByteArrayInputStream(this.outputStream.toByteArray());
}

public String getContentType() {
return contentType;
}

public String getName() {
return name;
}

public ByteArrayOutputStream getOutputStream() {
return outputStream;
}

}

The hard part is not in the code, it is in finding the right code . What makes this a spring sample? I did use a number of utility classes from spring:
MimeMessageHelper - helps you with creating the mail message, a lot of try catch blocks less than with the standard way.
AbstractResource - This is a convenience class for creating your custom resources
JavaMailSender - Used to send messages that cannot be send as a SimpleMailMessage, implementation of th MailSender interface.

Building backoffice system with spring, hibernate, acegi, sitemesh, iText and other frameworks

nospam@example.com (Jettro Coenradie) — Tue, 06 Sep 2005 22:58:00 +0200

I am working on an application for a friend of mine. Boy am I learning a lot. The coming weeks I want to share some stuff that I have learned. For now I will just give you a few of the frameworks that I have used.

Springframework for the foundation

Hibernate for persistence

Hsqldb for the database during testing and mysql on the server

Acegi for security

Sitemesh for templating

iText for pdf generation

Jakarta ant for building the application war file

Tomcat for deployment (windows for development and linux for deployment

Eclipse and MyEclipseIDE for development

Jotm for transactions over multiple datasources

XaPool for connection pooling

I want to thank Matt Raible for his Book SpringLive and his light version of AppFuse, 'Equinox'. This has helped me a lot. I think it is also time for a review of his book.

Lets start with discussing the environment. I use my laptop to develop the application. For development I use Jdk5, eclipse 3.1 and I have bought the plugin myeclipseide. This plugin helps me with the style sheets, java script, but most of all, with creating the descriptor files and the domain layer for hibernate. You connect via jdbc to mysql and hsqldb. This is done via the database plugin of myeclipseide. Then you select the tables you want to work with and generate the complete domain layer and *.hbm.xml files. There are abstract classes for the generated files and subclasses that contain your custom code. You can use the myeclipseide for creating the framework of your application, and you can also use equinox. Actually I used a cobination. I did not like the way equinox configures tests. For some reason I could not get this to work in eclipse as well as for ant. I prefer a seperate folder for all test files, including resources. Disadvantage is the duplication of config files, but that is my problem. Again use Myeclipseide for running your tomcat web server (version 5.5.9). Ofcourse you can use the ant file to start/stop and deploy your application in tomcat. I prefer myeclipse. I do use ant to generate a war file for the deployment server. I also use ant to startup the hsqldb database and for running the create and fill sql script. This makes it easy to unit test your application. But more about this later.

What are some of the issues that I need to resolve for the application?

Transactions over multiple datasources

Synchronisation from webdatabase and new domain model in the backoffice

Generation of multiple documents, invoice, order approval, packing list, etc

Authentication and authorization, use of multiple roles in the application