Software Passion http://www.softwarepassion.com by Krzysztof Grajek Wed, 04 Apr 2012 19:53:54 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 IT coverage with Arquillian Jacoco extension http://www.softwarepassion.com/it-coverage-with-arquillian-jacoco-extension/ http://www.softwarepassion.com/it-coverage-with-arquillian-jacoco-extension/#comments Wed, 04 Apr 2012 19:45:31 +0000 admin http://www.softwarepassion.com/?p=801 This is a short note on how to enable coverage analysis for your Integration Tests. I will assume that you are sane developer and use maven as your build tool. For static code analysis, nice charts and all kinds of statistics I’m going to use Sonar.

For actual code coverage analysis on the sonar side we are going to use Jacoco. To get a brief comparision of coverage analysis tools available for sonar have a look here

I’m going to use JBoss Arquillian for our Integration Testing needs (for this example actually that would be in-container test of the whole persistence layer using additional arquillian extension).

Maven configuration part:

To configure your maven project and enable code coverage for your integration tests all you have to do is to add two dependencies and declare a single plugin to at least one of your existing build profiles (you can of course create a separate profile just for Jacoco if you need too)

Dependencies:

1
2
3
4
5
6
7
8
9
10
11
            <dependency>
                <groupId>org.jboss.arquillian.extension</groupId>
                <artifactId>arquillian-jacoco</artifactId>
                <scope>test</scope>
                <version>1.0.0.Alpha1</version>
            </dependency>
            <dependency>
                <groupId>org.jacoco</groupId>
                <artifactId>org.jacoco.core</artifactId>
                <version>0.5.3.201107060350</version>
            </dependency>

…and the plugin part..

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
                   <plugin>
                        <groupId>org.jacoco</groupId>
                        <artifactId>jacoco-maven-plugin</artifactId>
                        <version>0.5.3.201107060350</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>prepare-agent</goal>
                                </goals>
                            </execution>
                            <execution>
                                <id>report</id>
                                <phase>prepare-package</phase>
                                <goals>
                                    <goal>report</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>

Sonar configuration Part

As of Sonar 2.12 you no longer need to install a separate plugin for Jacoco library, all you have to do is to enable it and configure on the sonar administration pages.
Log in as administrator, select one of your projects and go to ‘Configuration’ -> ‘Settings’.

Select ‘Code Coverage’ tab and set Jacoco as your default coverage analysis engine.

Once this is done, run your build either with sonar plugin enabled in your pom.xml or with mvn sonar:sonar and wait for your statistics.

Edit your sonar dashboard settings to see the IT coverage widget and actual statistics.

]]> http://www.softwarepassion.com/it-coverage-with-arquillian-jacoco-extension/feed/ 0 Same theme in all your editors http://www.softwarepassion.com/same-theme-in-all-your-editors/ http://www.softwarepassion.com/same-theme-in-all-your-editors/#comments Thu, 16 Feb 2012 09:05:30 +0000 admin http://www.softwarepassion.com/?p=780

In search for a nice looking, balanced and easy on the eyes editor theme I have encountered ‘Solarized’ theme lately. I’m not going to write here about its colors I like, its a personal preference, but the most interesting feature of this particular theme is that, its available for many popular editors starting from VIM to IntelliJ IDEA and Visual Studio.

Go the the website, download the files and check it out yourself: Solarized Theme

]]> http://www.softwarepassion.com/same-theme-in-all-your-editors/feed/ 0 $9.99 eBook Deal of the Day http://www.softwarepassion.com/9-99-ebook-deal-of-the-day/ http://www.softwarepassion.com/9-99-ebook-deal-of-the-day/#comments Mon, 06 Feb 2012 08:43:20 +0000 admin http://www.softwarepassion.com/?p=715 Just to share the info with the community, in other words, for anyone who doesn’t know yet :) . InformIT sells selected ebooks for less then 10 bucks in a special offer called ‘$9.99 eBook Deal of the Day.‘.
You can subscribe to their feed and watch for some interesting titles

]]> http://www.softwarepassion.com/9-99-ebook-deal-of-the-day/feed/ 0 Apache Camel – JDBC with Spring Transaction support http://www.softwarepassion.com/apache-camel-jdbc-with-spring-transaction-support/ http://www.softwarepassion.com/apache-camel-jdbc-with-spring-transaction-support/#comments Thu, 22 Dec 2011 13:17:33 +0000 admin http://www.softwarepassion.com/?p=726 Continuing my journey with Fuse ESB (ServiceMix) and Apache Camel I will present a small example on how to route your messages in a transacted way using Spring Transaction Manager.
For the purpose of this tutorial we are going to define a datasource to in memory Hsqldb instance and configure it with ‘org.springframework.jdbc.datasource.DataSourceTransactionManager’. Our camel example will be based on the tutorial/document from the FuseSource website itself which could be found at : http://fusesource.com/docs/router/2.5/transactions/index.html.
Our application will do the following:

  1. Create database table in the in-memory hsqldb database and populate it with same data – we are going to use JdbcTemplate for this purpose
  2. The route itself will pick up a messages from the specified directory, one by one, one of the messages will contain data causing an exception and rolling back our transaction and database commit.
  3. After each message is processed sucessfully the dump of our database will be printed to the console
  4. If the exception occurs and the transaction will be rolled back, the appropriate log would be displayed stating the current database content

The full source code for this example, packaged as a maven based project can be downloaded from the Github website.

1. We are going to use 2 spring beans for our example, one with injected datasource in a constructor which will populate our database data:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package tutorial.jdbc;

import javax.sql.DataSource;

import org.apache.log4j.Logger;
import org.springframework.jdbc.core.JdbcTemplate;

public class CreateTable {
    private static Logger log = Logger.getLogger(CreateTable.class);

    protected DataSource dataSource;
    protected JdbcTemplate jdbc;

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
   
    public CreateTable(DataSource ds) {
        log.info("CreateTable constructor called");
        setDataSource(ds);
        setUpTable();
    }
   
    public void setUpTable() {
        log.info("About to set up table...");
        jdbc = new JdbcTemplate(dataSource);
        jdbc.execute("create table accounts (name varchar(50), amount int)");
        jdbc.update("insert into accounts (name,amount) values (?,?)",
                new Object[] {"Major Clanger", 2000}
        );
        jdbc.update("insert into accounts (name,amount) values (?,?)",
                new Object[] {"Tiny Clanger", 100}
        );
        log.info("Table created");
    }
}

another bean will be responsible for our route logic, performing database operations. Datasource for this bean is injected using a property (see the camel-context.xml file below for more details):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package tutorial.jdbc;

import java.util.List;

import javax.sql.DataSource;

import org.apache.camel.Exchange;
import org.apache.camel.language.XPath;
import org.apache.log4j.Logger;
import org.springframework.jdbc.core.JdbcTemplate;

public class AccountService {
    private static Logger log = Logger.getLogger(AccountService.class);
    private JdbcTemplate jdbc;

    public AccountService() {
    }

    public void setDataSource(DataSource ds) {
        jdbc = new JdbcTemplate(ds);
    }

    /**
     * Adds a specific amount of money to a named account
     *
     * @param name - account name
     * @param amount - amount to add
     */
    public void credit(@XPath("/transaction/transfer/receiver/text()") String name,
            @XPath("/transaction/transfer/amount/text()") String amount) {
        log.info("credit() called with args name = " + name + " and amount = " + amount);
        int origAmount = jdbc.queryForInt("select amount from accounts where name = ?", new Object[] { name });
        int newAmount = origAmount + Integer.parseInt(amount);
        jdbc.update("update accounts set amount = ? where name = ?", new Object[] { newAmount, name });
    }

    /**
     * Subtract a specific amount of money from a named account.
     *
     * @param name - account name
     * @param amount - amount to add
     */
    public void debit(@XPath("/transaction/transfer/sender/text()") String name, @XPath("/transaction/transfer/amount/text()") String amount) {
        log.info("debit() called with args name = " + name + " and amount = " + amount);
        int iamount = Integer.parseInt(amount);
        if (iamount > 100) {
            throw new IllegalArgumentException("Debit limit is 100");
        }
        int origAmount = jdbc.queryForInt("select amount from accounts where name = ?", new Object[] { name });
        int newAmount = origAmount - Integer.parseInt(amount);
        if (newAmount < 0) {
            throw new IllegalArgumentException("Not enough in account");
        }

        jdbc.update("update accounts set amount = ? where name = ?", new Object[] { newAmount, name });
    }
    public void dumpTable(Exchange ex) {
        log.info("dump() called");
        List<?> dump = jdbc.queryForList("select * from accounts");
        ex.getIn().setBody(dump.toString());
    }
}

Our datasource, transaction manager and injection points for our beans are defined in camel-context.xml file located in ‘resources/META-INF/spring’ directory:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?xml version="1.0" encoding="UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="
      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
      http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">

  <camelContext xmlns="http://camel.apache.org/schema/spring">
    <package>tutorial</package>
  </camelContext>
 
  <!-- spring transaction manager -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- datasource to the database -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
        <property name="driverClass" value="org.hsqldb.jdbcDriver"/>
        <property name="url" value="jdbc:hsqldb:mem:camel"/>
        <property name="username" value="sa"/>
        <property name="password" value=""/>
    </bean>
   
    <!--  Bean to initialize table in the DB -->
    <bean id="createTable" class="tutorial.jdbc.CreateTable">
        <constructor-arg ref="dataSource" />
    </bean>
   
    <!-- Bean for account service -->
    <bean id="accountService" class="tutorial.jdbc.AccountService">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

2 and 3. When our configuration and the spring beans are ready we can start coding our route:

1
2
3
4
5
6
7
8
9
10
11
//our route definition
        //noop option - if true, the file is not moved or deleted in any way
        from("file:src/data?noop=true")
        //mark the route as transacted
        .transacted()
        //execute spring bean methods
        .beanRef("accountService","credit")
        .beanRef("accountService","debit")
        .beanRef("accountService","dumpTable")
        //log the result
        .to("log:ExampleRouter");

4. For simple error handling mechanism I have decided to use ‘onException’ which will be executed every time an exception will be thrown in our route and transaction will be rolled back

1
2
3
4
5
6
7
8
//handle exceptions and log them
        //handle exceptions and log them
        onException(IllegalArgumentException.class).
        maximumRedeliveries(0)
        .handled(true)
        .beanRef("accountService", "dumpTable")
        .to("file:target/messages?fileName=deadLetters.xml&fileExist=Append")
        .markRollbackOnly();

Remember to use SpringRouteBuilder for our transacted route instead of simple RouteBuilder class, below is the full source of our route configuration using Java DSL:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package tutorial;

import org.apache.camel.spring.SpringRouteBuilder;

/**
 * A Camel Router
 *
 * @version $
 */
public class MyRouteBuilder extends SpringRouteBuilder {


    public void configure() {
        //handle exceptions and log them
        onException(IllegalArgumentException.class).
        maximumRedeliveries(0)
        .handled(true)
        .beanRef("accountService", "dumpTable")
        .to("file:target/messages?fileName=deadLetters.xml&fileExist=Append")
        .markRollbackOnly();

        //our route definition
        //noop option - if true, the file is not moved or deleted in any way
        from("file:src/data?noop=true")
        //mark the route as transacted
        .transacted()
        //execute spring bean methods
        .beanRef("accountService","credit")
        .beanRef("accountService","debit")
        .beanRef("accountService","dumpTable")
        //log the result
        .to("log:ExampleRouter");
       
    }
}

To run an example, navigate into the project folder and execute the following command:

1
 mvn camel:run

]]> http://www.softwarepassion.com/apache-camel-jdbc-with-spring-transaction-support/feed/ 0 Java EE 6 Testing with Arquillian Persistence Extension http://www.softwarepassion.com/java-ee-6-testing-with-arquillian-persistence-extension/ http://www.softwarepassion.com/java-ee-6-testing-with-arquillian-persistence-extension/#comments Thu, 22 Dec 2011 07:42:06 +0000 admin http://www.softwarepassion.com/?p=721 Today I will describe my newly discovered library which is an extension to the great JBoss Arquillian project.

The mission of the Arquillian project is to provide a simple test harness that abstracts away all container lifecycle and deployment from the test logic so developers can easily produce a broad range of integration tests for their enterprise Java applications.

Arquillian persistence extension allows you to test JPA related code without filling up the database with test data. All you have to do is to populate .yml file with your data specified. That will be best described with an example.

First of all add arquillian persistence dependencies to your project:

1
2
3
4
5
6
7
8
9
10
11
12
<dependency>
            <groupId>org.jboss.arquillian.extension</groupId>
            <artifactId>arquillian-persistence-api</artifactId>
            <version>${version.arquillian_persistence}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.jboss.arquillian.extension</groupId>
            <artifactId>arquillian-persistence-impl</artifactId>
            <version>${version.arquillian_persistence}</version>
            <scope>test</scope>
        </dependency>

where ‘${version.arquillian_persistence}’ is equal to ’1.0.0.Alpha2′. I assume that you have the basic arquillian tests (for EJB’s and CDI) working, If not read on.

I have found myself setting up arquillian enabled project quite cumbersome, always ending up with some classpath dependency problems while trying to remote test my classes. For those of you new to Arquillian I would strongly recommend starting up with working example provided by Bartosz Majsak and available on github as a ‘Beer-Advisor‘ project.

The ‘Beer-Advisor’ project can be quickly refactored to suit your needs, it lack comments but its so clearly written that it shouldn’t be a problem to grasp the idea.

Ok then, lets get going with the arquillian persistence extension, we are going to use two nice annotations to help us testing our JPA layer: @UsingDataSet and @ShouldMatchDataSet.

We start off with doing some setup, I will copy part of the example from the Beer-Advisor project which you can easily clone and try for yourself:

Having an entity class Beer:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
@Entity
public class Beer implements Serializable
{
   private static final long serialVersionUID = 5892013208071126314L;

   @Id
   @GeneratedValue(strategy = GenerationType.AUTO)
   private Long id;

   @Basic
   private String name;

   @Basic
   private BigDecimal price;

   @Basic
   private BigDecimal alcohol;

   @Basic
   private String code;

   @Enumerated(EnumType.STRING)
   private Type type;

   // If lazy then Glassfish Embedded is facing this problem: https://bugs.eclipse.org/bugs/show_bug.cgi?id=323403
   @ManyToOne(optional = false, cascade = {CascadeType.PERSIST, CascadeType.MERGE})
   private Brewery brewery;

   Beer()
   {
      // to satisfy JPA
   }

   public Beer(Brewery brewery, Type type, String name, BigDecimal price, BigDecimal alcohol)
   {
      this.name = name;
      this.price = price;
      this.alcohol = alcohol;
      this.type = type;
      this.brewery = brewery;
      this.brewery.addBeer(this);
   }
........ Getters and Setters ...............

and simple DAO for managing Beer objects on the persistence layer:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@RequestScoped
public class JpaBeerRepository implements BeerRepository
{
   @PersistenceContext
   private EntityManager em;

   @Override
   public Beer getById(Long id)
   {
      return em.find(Beer.class, id);
   }
..........

@Override
   public Set<Beer> fetchAll()
   {
      CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
      CriteriaQuery<Beer> query = criteriaBuilder.createQuery(Beer.class);
      Root<Beer> from = query.from(Beer.class);
      CriteriaQuery<Beer> select = query.select(from);

      Set<Beer> result = new HashSet<Beer>();
      result.addAll(em.createQuery(select).getResultList());

      return result;
   }

   @Override
   public void save(Beer beer)
   {
      if (beer.getId() == null)
      {
         em.persist(beer);
      }
      else
      {
         em.merge(beer);
      }
   }
..................

We can easily test our DAO by creating datasets in yml format and test our logic against it:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Beer:
  - id: 1
    alcohol: 4.5
    name: "Mocny Full"
    price: 1.0
    type: LAGER
    brewery_id: 1
  - id: 2
    alcohol: 55.0
    name: "End of history"
    price: 765
    type: BLOND_ALE
    brewery_id: 2
  - id: 3
    alcohol: 41.0
    name: "Sink The Bismarck!"
    price: 64.0
    type: QUADRUPEL_IPA
    brewery_id: 2
  - id: 4
    alcohol: 8.5
    name: "Delirium Tremens"
    price: 10.0
    type: PALE_ALE
    brewery_id: 3
  - id: 5
    alcohol: 8.4
    name: "Pauwel Kwak"
    price: 4.0
    type: AMBER
    brewery_id: 4

You should put your .yml file into test/resources/datasets folder in you maven project

@UsingDataSet annotation will populate our database with the data specified in beers.yml file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
   @Test
   @UsingDataSet("beers.yml")
   public void shouldReturnBeerByItsId() throws Exception
   {
      // given
      Long beerId = 1L;
      String expectedName = "Mocny Full";

      // when
      Beer beers = beerRepository.getById(beerId);

      // then
      assertThat(beers.getName()).isEqualTo(expectedName);
   }

Now, lets say we want to add new Beer and see if the database will have a specific data in it, for this purpose we are going to use @ShouldMatchDataSet(..)

1
2
3
4
5
6
7
8
9
@Test
    @ShouldMatchDataSet("expected-insert-beer.yml")
    public void shouldSaveNewBeer() throws Exception{
        //when
        Beer b = new Beer();
                //set the necessary fields on the beer object
        beerRepository.save(b);
        assertThat(beerRepository).isNotNull();
    }

after inserting our Beer object to the database through the EntityManager we should end up with a single beer record in our database, exactly like the one specified in ‘expected-insert-beer.yml’.

]]> http://www.softwarepassion.com/java-ee-6-testing-with-arquillian-persistence-extension/feed/ 4 ServiceMix (FuseESB) Unit Testing your routes http://www.softwarepassion.com/servicemix-fuseesb-unit-testing-your-routes/ http://www.softwarepassion.com/servicemix-fuseesb-unit-testing-your-routes/#comments Mon, 19 Dec 2011 11:12:55 +0000 admin http://www.softwarepassion.com/?p=716 Today I will present simple way to test your camel routes. For building camel based service mix application, look into Part 4 of this tutorial series.

Let’s say we have the following route defined in a class extending RouteBuilder class:

1
2
3
public void configure() {
        from("activemq:test2").split(xpath("/notes/note")).parallelProcessing().setHeader("id", simple("123")).to("activemq:test3");
    }

This route will pick up incoming messages on the activemq:test2 queue, split them and deliver to another queue (activemq:test3). To test the route we will replace activemq namespace within camel context with the camel component called ‘seda’ –

component provides asynchronous SEDA behavior, so that messages are exchanged on a BlockingQueue and consumers are invoked in a separate thread from the producer.

1
2
3
4
5
6
        @Override
    protected CamelContext createCamelContext() throws Exception {
        CamelContext context = super.createCamelContext();
        context.addComponent("activemq", context.getComponent("seda"));
        return context;
    }

to get the messages delivered to our end queue we are going to replace it with the mock queue, using an interceptor:

1
2
3
4
5
6
7
RouteDefinition route = context.getRouteDefinitions().get(0);
        route.adviceWith(context, new RouteBuilder() {
            public void configure() throws Exception {
                interceptSendToEndpoint("activemq:test3")
                    .skipSendToOriginalEndpoint().to("mock:quote");
            }
        });

Full source of our unit test will look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import org.apache.camel.CamelContext;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.mock.MockEndpoint;
import org.apache.camel.model.RouteDefinition;
import org.apache.camel.test.junit4.CamelTestSupport;
import org.junit.Test;

public class MyRouteBuilderTest extends CamelTestSupport {

    @Override
    protected CamelContext createCamelContext() throws Exception {
        CamelContext context = super.createCamelContext();
        context.addComponent("activemq", context.getComponent("seda"));
        return context;
    }
    @Override
    protected RouteBuilder createRouteBuilder() throws Exception {
        return new MyRouteBuilder();
    }

    @Test
    public void testMoveFile() throws Exception {
        RouteDefinition route = context.getRouteDefinitions().get(0);
        route.adviceWith(context, new RouteBuilder() {
            public void configure() throws Exception {
                interceptSendToEndpoint("activemq:test3")
                    .skipSendToOriginalEndpoint().to("mock:quote");
            }
        });
       
        MockEndpoint mock = getMockEndpoint("mock:quote");
        mock.expectedMessageCount(3);
        mock.allMessages().body().isNotNull();
        mock.allMessages().header("id").isEqualTo(123);
        template.sendBody("activemq:test2", M_TXT);
        assertMockEndpointsSatisfied();
    }
   
    private static final String M_TXT =   "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
            "<notes>" +
            "<note>" +
            "<to>Anyone</to>" +
            "<from>Kris1</from>" +
            "<heading>Simple Message</heading>" +
            "<body>Check out my Twitter account @grajo</body>" +
            "</note>" +
            "<note>" +
            "<to>Anyone</to>" +
            "<from>Kris2</from>" +
            "<heading>Simple Message</heading>" +
            "<body>Check out my Twitter account @grajo</body>" +
            "</note>" +
            "<note>" +
            "<to>Anyone</to>" +
            "<from>Kris3</from>" +
            "<heading>Simple Message</heading>" +
            "<body>Check out my Twitter account @grajo</body>" +
            "</note>" +
            "</notes>";
}

To use camel unit testing functionality you need to add the following dependencies to your project pom.xml file:

1
2
3
4
5
6
7
8
9
                <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-test</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.2</version>
        </dependency>

Hope that will help anyone to start testing your camel routes. More information and different use cases for mock component, interceptors as well as integration testing concepts can be found in the Camel In Action book

]]> http://www.softwarepassion.com/servicemix-fuseesb-unit-testing-your-routes/feed/ 0 Oracle Certified Master, Java EE 5 Enterprise Architect http://www.softwarepassion.com/oracle-certified-master-java-ee-5-enterprise-architect/ http://www.softwarepassion.com/oracle-certified-master-java-ee-5-enterprise-architect/#comments Fri, 16 Dec 2011 13:07:43 +0000 admin http://www.softwarepassion.com/?p=711 Today I have received very long awaited email from Oracle:

Congratulations! You have passed the Oracle Certified Master, Java EE 5 Enterprise Architect certification. You are among the elite 1% of certified Java professionals who have gone on to achieve the Java Enterprise Architect certification.

I was waiting for the result for almost 4 months since I’ve finished the last part of the certification process and started to fear that I won’t pass while reading on JavaRanch about problems some people had with the diagrams.

Anyway, now I know what it is to be a certified architect ;)

]]> http://www.softwarepassion.com/oracle-certified-master-java-ee-5-enterprise-architect/feed/ 2 ServiceMix (FuseESB) – Camel OSGI Example – Part 4 http://www.softwarepassion.com/servicemix-fuseesb-camel-osgi-example-part-4/ http://www.softwarepassion.com/servicemix-fuseesb-camel-osgi-example-part-4/#comments Wed, 14 Dec 2011 08:28:45 +0000 admin http://www.softwarepassion.com/?p=703 As I have encountered problems developing further my ServiceMix ESB application (you can read about it here) I was forced to switch from the JBI style to pure OSGI (at this point I have to say that the previous parts were mainly based on the information from ServiceMix website which I have to say is a ‘bit’ outdated).
Osgi? Well, even better :) .

Lets start off with the simple OSGI example, you would have to follow at least Part 1 of this series to create basic environment for sending messages to JMS queue on Apache Active MQ.

Our application will pick up the messages from one queue, split them using Splitter EIP into separate messages, set header attribute on each of them and then, process them separately and aggregate them (Aggregator EIP) into a single block of text and print it on the log console.

This time we are not going to create service assembly or any service unit project, we are going to create simple maven artefact and modify its pom.xml file to include necessary dependencies, plugin definitions and packaging type, thats it!

So, first of all start up your eclipse or any other editor (you can do this from the command line too) and create basic maven project:

For eclipse it would be: ‘File’ -> ‘Other’ -> ‘Project’ then select ‘Maven Project’

click ‘Next’, select checkbox with ‘create a simple project’

click ‘Next’, fill up the fields for your newly created artifact and finish

Replace automatically created pom.xml file with the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.apache.servicemix.features</groupId>
        <artifactId>features</artifactId>
        <version>4.4.1-fuse-01-11</version>
    </parent>

    <groupId>com.softwarepassion.camelosgitut</groupId>
    <artifactId>camelosgitut</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>CamelOsgiTut</name>
    <description>Camel OSGI Tutorial</description>
    <packaging>bundle</packaging>
    <dependencies>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-spring</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-bundle-plugin</artifactId>
                <configuration>
                    <instructions>
                        <Bundle-SymbolicName>${project.artifactId}</Bundle-SymbolicName>
                        <Bundle-Description>${project.description}</Bundle-Description>
                        <Import-Package>*</Import-Package>
                        <Private-Package>org.apache.servicemix.examples.camel
                        </Private-Package>
                    </instructions>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <!-- FuseSource maven repositories -->
        <repository>
            <id>fusesource.releases</id>
            <name>FuseSoure releases repository</name>
            <url>http://repo.fusesource.com/maven2/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>fusesource.snapshots</id>
            <name>FuseSource Snapshot Repository</name>
            <url>http://repo.fusesource.com/maven2-snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
            <releases>
                <enabled>false</enabled>
            </releases>
        </repository>
    </repositories>

    <pluginRepositories>
        <!-- FuseSource maven repositories -->
        <pluginRepository>
            <id>fusesource.releases</id>
            <name>FuseSoure releases repository</name>
            <url>http://repo.fusesource.com/maven2/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>fusesource.snapshots</id>
            <name>FuseSource Snapshot Repository</name>
            <url>http://repo.fusesource.com/maven2-snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
            <releases>
                <enabled>false</enabled>
            </releases>
        </pluginRepository>
    </pluginRepositories>
</project>

Now you are ready to build our project for the first time. Execute ‘mvn install’ inside the project directory or from eclipse ‘Run As..’ -> ‘Maven Install’

Bravo! you have created osgi bundle ready to deploy into karaf. Let’s do some coding for our camel logic.
Create two classes inside src/main/java folder, one for Camel Routes definitions using Java DSL and one for managing our aggregation strategy (when we will aggregate our messages into one after the split)

MyRouteBuilder.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.softwarepassion.camelosgitut;

import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.spring.Main;

/**
 * A simple example router to show how to define the route with Java DSL
 *
 * @version $Revision$
 */
public class MyRouteBuilder extends RouteBuilder {
    /**
     * Allow this route to be run as an application
     *
     * @param args
     */
    public static void main(String[] args) throws Exception{
        new Main().run(args);
    }

    public void configure() {
        from("activemq:test2").split(xpath("/notes/note")).parallelProcessing().setHeader("id", simple("123")).to("activemq:test3");
        from("activemq:test3").aggregate(header("id"), new MyAggregationStrategy()).completionTimeout(3000).to("log:ExampleRouter");
    }

   
}

MyAggregationStrategy.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.softwarepassion.camelosgitut;

import org.apache.camel.Exchange;
import org.apache.camel.Message;
import org.apache.camel.processor.aggregate.AggregationStrategy;

public class MyAggregationStrategy implements AggregationStrategy {

    public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
        if (oldExchange == null) {
            return newExchange;
        }
        Message newIn = newExchange.getIn();
        String oldBody = oldExchange.getIn().getBody(String.class);
        String newBody = newIn.getBody(String.class);
        newIn.setBody(oldBody + newBody);
       
        return newExchange;
    }

}

The last, very important thing we have to do is to install Java DSL route builder. Add beans.xml file into META-INF directory of the resources folder, the full path where the beans.xml file should be located is: ‘/camelosgitut/src/main/resources/META-INF/spring’.

beans.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?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:ctx="http://www.springframework.org/schema/context"
      xmlns:camel="http://camel.apache.org/schema/spring"
      xmlns:osgix="http://www.springframework.org/schema/osgi-compendium"
      xsi:schemaLocation="
      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
      http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd
      http://www.springframework.org/schema/osgi-compendium http://www.springframework.org/schema/osgi-compendium/spring-osgi-compendium.xsd">

  <camel:camelContext xmlns="http://camel.apache.org/schema/spring">
    <!-- install the Java DSL route builder -->
    <package>com.softwarepassion.camelosgitut</package>
  </camel:camelContext>
</beans>

Build the application one more time and deploy the .jar file from the target directory into ‘deploy’ directory of the servicemix runtime:

1
cp target/camelosgitut-0.0.1-SNAPSHOT.jar /home/kris/apache-servicemix-4.4.1-fuse-01-11/deploy/

Now you are ready to send our message to the queue named ‘test2′. Create a simple xml message which would be splitted into smaller parts:

1
<?xml version="1.0" encoding="UTF-8"?><notes><note><to>Anyone</to><from>Kris1</from><heading>Simple Message</heading><body>Check out my Twitter account @grajo</body></note><note><to>Anyone</to><from>Kris2</from><heading>Simple Message</heading><body>Check out my Twitter account @grajo</body></note><note><to>Anyone</to><from>Kris3</from><heading>Simple Message</heading><body>Check out my Twitter account @grajo</body></note></notes>

This message should be split into 3 smaller messages, sent in parallel to the separate queue and there aggregated into single block of text.

]]> http://www.softwarepassion.com/servicemix-fuseesb-camel-osgi-example-part-4/feed/ 1 ServiceMix (Fuse ESB) – Bean Service Unit – Part 3 http://www.softwarepassion.com/servicemix-fuse-esb-%e2%80%93-bean-service-unit-%e2%80%93-part-3/ http://www.softwarepassion.com/servicemix-fuse-esb-%e2%80%93-bean-service-unit-%e2%80%93-part-3/#comments Mon, 12 Dec 2011 12:47:58 +0000 admin http://www.softwarepassion.com/?p=698 Today I will describe how to connect bean type service unit with our existing application build in Part 1 and Part 2.

The ServiceMix Bean component provides integration with beans (POJOs) with the JBI bus to make it easy to use POJOs to process JBI message exchanges. Like in an Message Driven Bean in J2EE a POJO will receive a message from the NMR and process it in any way it likes. Unlike in a JMS component where the coding is already done the Bean component gives the developer the freedom to create any type of message handling but it must be hand coded all the way.

This part of the tutorial shows how to integrate bean service unit to process simple xml message.

We start off by creating a new service unit for our existing project. To do this, go to the project parent folder and execute the following mvn command:

1
2
3
4
5
6
7
mvn archetype:create \
  -DarchetypeGroupId=org.apache.servicemix.tooling \
  -DarchetypeArtifactId=servicemix-bean-service-unit \
  -DarchetypeVersion=2011.01 \
  -DgroupId=com.softwarepassion.jmsfile \
  -DartifactId=jmsfile_bean \
  -Dversion=1.0.0

This command will create our new service unit project and adds new module into our parent pom.xml file.

Now we need to add a dependencies to our newly created service unit for working with MessageExchangeListener:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
<?xml version="1.0" encoding="UTF-8"?>
<project
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
    xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <artifactId>parent</artifactId>
        <groupId>com.softwarepassion.jmsfile</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <groupId>com.softwarepassion.jmsfile</groupId>
    <artifactId>jmsfile_bean</artifactId>
    <version>1.0.0</version>
    <packaging>jbi-service-unit</packaging>
    <name>Apache ServiceMix :: Bean Service Unit</name>
    <build>
        <defaultGoal>install</defaultGoal>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.0.2</version>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.4.3</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.servicemix.tooling</groupId>
                <artifactId>jbi-maven-plugin</artifactId>
                <version>4.4</version>
                <extensions>true</extensions>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>org.apache.servicemix</groupId>
            <artifactId>servicemix-bean</artifactId>
            <version>2011.01</version>
        </dependency>
        <dependency>
            <groupId>org.apache.servicemix</groupId>
            <artifactId>servicemix-core</artifactId>
            <version>3.3.2</version>
        </dependency>
    </dependencies>
</project>

as well as add our service unit dependency to the service assembly:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
....
<dependencies>
    <dependency>
      <groupId>com.softwarepassion.jmsfile</groupId>
      <artifactId>jmsfile_file</artifactId>
      <version>1.0.0</version>
    </dependency>
    <dependency>
      <groupId>com.softwarepassion.jmsfile</groupId>
      <artifactId>jmsfile_jms</artifactId>
      <version>1.0.0</version>
    </dependency>
    <dependency>
        <groupId>com.softwarepassion.jmsfile</groupId>
        <artifactId>jmsfile_bean</artifactId>
        <version>1.0.0</version>
    </dependency>
  </dependencies>
...

Remember that you can make any service unit an eclipse project by executing ‘mvn eclipse:eclipse’ inside that project main directory (where the pom.xml file is located).

Run ‘mvn install’ to test the newly created skeleton code.

If all is fine, you can now proceed wiring our new service unit. For this purpose to make it as simple as possible we will create new file service endpoint which will poll the directory for new files and pass them to our bean service endpoint.

At this point our application reads the incoming messages from the JMS queue and save them to the specified directory. Right now we add another endpoint witch will pick up the files from that directory and process them using bean type endpoint – possibly useless in the real world but will show you how to create and connect different types of endpoints in ServiceMix ESB.

First, we need to modify xbean.xml file in our existing file service unit:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated by Apache ServiceMix Archetype -->
<beans xmlns:file="http://servicemix.apache.org/file/1.0"
   xmlns:replaceMe="http://servicemix.apache.org/replaceMe" xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="
       http://servicemix.apache.org/file/1.0 http://servicemix.apache.org/schema/servicemix-file-2011.01.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

    <file:sender service="jmsfile:fileservice"
                endpoint="jmsfile:fileendpoint"
                directory="file:/home/kris/Desktop/filesfromjms" />
   
    <file:poller service="jmsfile:fileservice"
                 endpoint="jmsfile:fileendpointpoller"
                 targetService="jmsfile:beanservice"
                 targetEndpoint="jmsfile:bean"
                 file="file:/home/kris/Desktop/filesfromjms"/>
</beans>

file:poller will poll our directory for new files and pass them to the jmsfile:beanservice service.

Our xbean.xml for bean service unit will look like the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated by Apache ServiceMix Archetype -->
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:file="http://servicemix.apache.org/file/1.0"
      xmlns:bean="http://servicemix.apache.org/bean/1.0"
      xmlns:ns="urn:test:example"
      xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://servicemix.apache.org/file/1.0
        http://servicemix.apache.org/file/1.0/servicemix-file.xsd
        http://servicemix.apache.org/bean/1.0
        http://servicemix.apache.org/bean/1.0/servicemix-bean.xsd" >
       
  <bean:endpoint service="jmsfile:beanservice" endpoint="jmsfile:bean" bean="#myBean"/>

  <!--
   The POJO used by the bean endpoint.
 -->
  <bean id="myBean" class="com.softwarepassion.jmsfile.MyBean"/>
  <!-- END SNIPPET: bean -->

</beans>

and finally our class for handling messages polled from the directory:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.softwarepassion.jmsfile;

import org.apache.servicemix.MessageExchangeListener;

import javax.annotation.Resource;
import javax.jbi.messaging.DeliveryChannel;
import javax.jbi.messaging.ExchangeStatus;
import javax.jbi.messaging.MessageExchange;
import javax.jbi.messaging.MessagingException;
import javax.jbi.messaging.NormalizedMessage;

public class MyBean implements MessageExchangeListener {

    @Resource
    private DeliveryChannel channel;

    public void onMessageExchange(MessageExchange exchange) throws MessagingException {
        System.out.println("Received exchange: " + exchange);
       
        System.out.println("Received exchange: " + exchange);
        System.out.println("getPattern exchange: " + exchange.getPattern());
        System.out.println("getStatus exchange: " + exchange.getStatus());
        System.out.println("Role exchange: " + exchange.getRole().toString());
        NormalizedMessage in = exchange.getMessage("in");
        System.out.println("normalized message: "+in.getContent().toString());
        exchange.setStatus(ExchangeStatus.DONE);
        channel.send(exchange);
    }

}

The basic skeleton for xbean.xml and MyBean.java files were created by the maven archetype in the earlier step.

Now you are ready to test our application, you don’t have to send messages to the queue if you don’t want to, you can just put any xml file into the same directory where the jms messages were saved earlier. Once you deploy the service assembly zip file into your Fuse ESB instance the file should be printed to the console.

Similar to the previous parts, you can get the full source code from GitHub https://github.com/softberries/jms_file_tut/ ‘bean_su’ branch.

]]> http://www.softwarepassion.com/servicemix-fuse-esb-%e2%80%93-bean-service-unit-%e2%80%93-part-3/feed/ 0 ServiceMix (Fuse ESB) – File SU + JMS SU Example – Part 2 http://www.softwarepassion.com/servicemix-fuse-esb-%e2%80%93-file-su-jms-su-example-%e2%80%93-part-2/ http://www.softwarepassion.com/servicemix-fuse-esb-%e2%80%93-file-su-jms-su-example-%e2%80%93-part-2/#comments Fri, 09 Dec 2011 09:17:00 +0000 admin http://www.softwarepassion.com/?p=694 This is the second part of the tutorial on how to build ServiceMix ESB application connecting file system service unit with JMS.
You can find the first part of the tutorial here where I’ve described how to prepare your environment to test our application and possibly other applications in the future. The first part was about creating simple java application to send XML messages to ActiveMQ broker as well on how to set up ActiveMQ web console to watch incoming/outgoing messages.
In this part I will describe how to create necessary service units and service assembly to be able to receive JMS messages on the ESB and save them to the file system.

We start with creating a parent project folder for our service units and service assembly, create an empty directory and put the following pom.xml file in it:

1
2
3
4
5
6
7
8
9
10
11
12
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
  <groupId>com.softwarepassion.jmsfile</groupId>
  <artifactId>parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>Tutorial</name>
  <url>http://servicemix.org</url>
  <modules>
  </modules>
</project>

Now we are going to create our first service unit responsible for filesystem interaction, execute the following maven command:

1
2
3
4
5
6
mvn archetype:create \
  -DarchetypeGroupId=org.apache.servicemix.tooling \
  -DarchetypeArtifactId=servicemix-file-service-unit \
  -DgroupId=com.softwarepassion.jmsfile \
  -DartifactId=jmsfile_file \
  -Dversion=1.0.0

You can find out more about File SU directly on the ServiceMix website at: http://servicemix.apache.org/servicemix-file.html and about all maven artefacts here: http://servicemix.apache.org/maven-archetypes.html , the information there can be a bit outdated though.

Next we create JMS SU for managing our ActiveMQ communication:

1
2
3
4
5
6
mvn archetype:create \
  -DarchetypeGroupId=org.apache.servicemix.tooling \
  -DarchetypeArtifactId=servicemix-jms-provider-service-unit \
  -DgroupId=com.softwarepassion.jmsfile \
  -DartifactId=jmsfile_jms \
  -Dversion=1.0.0

More info about JMS service unit can be found @ http://servicemix.apache.org/servicemix-jms.html and here: http://servicemix.apache.org/servicemix-jms-new-endpoints.html

Finally we create service assembly connecting our service units:

1
2
3
4
5
6
mvn archetype:create \
  -DarchetypeGroupId=org.apache.servicemix.tooling \
  -DarchetypeArtifactId=servicemix-service-assembly \
  -DgroupId=com.softwarepassion.jmsfile \
  -DartifactId=jmsfile_sa \
  -Dversion=1.0.0

All the modules should be automatically added to our main pom.xml file in the parent project folder.
After creating our Service Assembly we need to update its pom.xml to include dependencies to our service units:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<project>
  ...
  <dependencies>
    <dependency>
      <groupId>com.softwarepassion.jmsfile</groupId>
      <artifactId>jmsfile_file</artifactId>
      <version>1.0.0</version>
    </dependency>
    <dependency>
      <groupId>com.softwarepassion.jmsfile</groupId>
      <artifactId>jmsfile_jms</artifactId>
      <version>1.0.0</version>
    </dependency>
  </dependencies>
  ...
</project>

Before executing ‘mvn install’ on the main pom.xml we need to do one more thing which is updating the jms service unit with ‘activemq-core’ dependency

1
2
3
4
5
6
7
8
9
10
11
12
13
14
...
<dependencies>
    <dependency>
      <groupId>org.apache.servicemix</groupId>
      <artifactId>servicemix-jms</artifactId>
      <version>2011.01</version>
    </dependency>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-core</artifactId>
        <version>5.2.0</version>
    </dependency>
  </dependencies>
...

Now you are ready to run ‘mvn install’ and see if all is ok at this point.

Ok, so we have two service units and service assembly ready, now its time to wire them together, this is done using xml in xbean.xml files. First we modify our xbean.xml file for the file su located at:
‘jms_file_tut/jmsfile_file/src/main/resources’

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated by Apache ServiceMix Archetype -->
<beans xmlns:file="http://servicemix.apache.org/file/1.0"
   xmlns:replaceMe="http://servicemix.apache.org/replaceMe" xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="
       http://servicemix.apache.org/file/1.0 http://servicemix.apache.org/schema/servicemix-file-2011.01.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

    <!--
       The ServiceMix File component provides integration to the file system.
       It can be used to read and write files via URI or to periodically poll directories
       for new files.
       
           http://servicemix.apache.org/servicemix-file.html
   -->
    <!-- BEGIN SNIPPET: file-sender -->
    <!--
       The sender endpoint creates a file from the incoming message and writes it into the specified directory.
       
       Attributes:
           service                     : the endpoint service name
           endpoint                    : the endpoint name
           directory                   : the target directory where to write created file
           autoCreateDirectory         : creates directory if it doesn't exist
           append                      : append to an existing file instead of overwriting it
           marshaler                   : implementation of the FileMarshaler to use (DefaultFileMarshaler by default)
           tempFilePrefix              : the prefix of the temporary file used during file generation
           tempFileSuffix              : the suffix of the temporary file used during file generation
   -->
    <file:sender service="jmsfile:fileservice"
                endpoint="jmsfile:fileendpoint"
                directory="file:/home/kris/Desktop/filesfromjms" />
    <!-- END SNIPPET: file-sender -->

</beans>

This is a simple single endpoint declaration with directory name specified for saving our JMS messages.

For the jms service unit our xbean.xml file looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns:jms="http://servicemix.apache.org/jms/1.0"
      xmlns:test="http://test"
      xmlns:amq="http://activemq.apache.org/schema/core"
      xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://servicemix.apache.org/jms/1.0 http://servicemix.apache.org/schema/servicemix-jms-3.2.3.xsd
      http://activemq.org/config/1.0 http://activemq.apache.org/schema/core/activemq-core-4.1.1.xsd
      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

    <jms:consumer service="jmsfile:jmsservice"
                 endpoint="jmsfile:jmsendpoint"
                  destinationName="test"
                  connectionFactory="#connectionFactory"
          targetService="jmsfile:fileservice"
              targetEndpoint="jmsfile:fileendpoint" />
   
    <amq:connectionFactory id="connectionFactory" brokerURL="tcp://localhost:61616" />

</beans>

This endpoint will consume JMS messages sent to the ‘test’ queue.

Once the wiring is complete, you can run ‘mvn install’ on the main pom.xml file and then copy the ‘.zip’ file from service assembly target folder into the ‘deploy’ directory of your service mix instance.

To watch the log output continuously you can execute the following command on the service mix console:

1
log:tail

Now you can execute our Producer program introduced in Part I of this tutorial and send 10 test messages to ActiveMQ. You should find them saved into the directory specified in xbean.xml of the file service unit configuration.

The full source code for this example is available at github at: https://github.com/softberries/jms_file_tut

]]> http://www.softwarepassion.com/servicemix-fuse-esb-%e2%80%93-file-su-jms-su-example-%e2%80%93-part-2/feed/ 0