Software Passion http://www.softwarepassion.com by Krzysztof Grajek Fri, 23 Dec 2011 07:48:47 +0000 en hourly 1 http://wordpress.org/?v=3.0.4 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:

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):

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:

<?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:

//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

//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:

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:

 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:

<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:

@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:

@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:

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

   @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(..)

@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/ 2 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:

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.

        @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:

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:

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:

                <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:

<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

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

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

<?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:

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:

<?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:

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:

<?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:

....
<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:

<?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:

<?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:

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:

<?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:

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:

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:

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:

<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

...
<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’

<?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:

<?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:

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 ServiceMix (Fuse ESB) – File SU + JMS SU Example – Part 1 http://www.softwarepassion.com/servicemix-fuse-esb-file-su-jms-su-example-part-1/ http://www.softwarepassion.com/servicemix-fuse-esb-file-su-jms-su-example-part-1/#comments Thu, 08 Dec 2011 14:39:41 +0000 admin http://www.softwarepassion.com/?p=687

Continuing my adventure with ESB’s and ServiceMix in particular I will describe a simple example of File system and JMS integration.
First of all, we need to do some preparation work to be able to send JMS messages and check if they are delivered/consumed on the JMS message broker. For the purpose of this tutorial I’m going to use Apache ActiveMQ, which by default is provided with ServiceMix.
In this part I’m going to show you how to install ActiveMQ web console for simple monitoring tasks as well as how to build a simple Java application sending XML messages to our JMS message broker.
In the second part of this tutorial I’ll post an example showing how to use ESB to connect JMS and File service units, the application will consume JMS messages and save them to the file system.
So let’s get started.

1. I assume you have downloaded the Fuse ESB and you are able to start it. If not, please have a look into my previouse tutorial under ‘ESB’ category: http://www.softwarepassion.com/apache-servicemix-fuse-esb-with-camel/ , you don’t have to go through the whole tutorial, just read the part about installing and running Fuse ESB instance.

2. First we start with ActiveMQ web console. To install the webconsole you have to execute two commands on the servicemix(fuseesb) console, go to the terminal window where your servicemix is started and type:

features:install war
features:install activemq-web-console

TIP: You can find out more about available features by executing:

features:list

This should install your activemq webconsole application. Go and check it out at: http://localhost:8181/activemqweb/


3. Now we are going to create simple java application allowing us to send JMS messages to our ActiveMQ instance. Most of this steps are borrowed from the blog post of Ian Christian found here

First, create the simplest maven skeleton by issuing:

mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=com.softwarepassion.activemq -DartifactId=producer -Dversion=1.0

Open up the newly created project in eclipse (or any other editor/ide you use) and change the pom.xml file by adding some dependencies:

<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.activemq</groupId>
  <artifactId>producer</artifactId>
  <packaging>jar</packaging>
  <version>1.0</version>
  <name>producer</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>javax.jms</groupId>
      <artifactId>jms</artifactId>
      <version>1.1</version>
    </dependency>
    <dependency>
      <groupId>org.apache.activemq</groupId>
     <artifactId>activemq-core</artifactId>
      <version>5.2.0</version>
    </dependency>
  </dependencies>
  <repositories>
    <repository>
      <id>jboss</id>
      <url>http://repository.jboss.com/maven2</url>
      <releases>
      </releases>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>
</project>

Once this is ready, we can start coding our Java stuff.
We need just two classes:

package com.softwarepassion.activemq;

import javax.jms.ConnectionFactory;
import javax.jms.JMSException;

import org.apache.activemq.ActiveMQConnectionFactory;



public class App
{

    public static String brokerURL = "tcp://localhost:61616";
   
    public static void main( String[] args ) throws JMSException
    {
        // setup the connection to ActiveMQ
        ConnectionFactory factory = new ActiveMQConnectionFactory(brokerURL);
        Producer producer = new Producer(factory, "test");
        producer.run();
        producer.close();
    }
}
package com.softwarepassion.activemq;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Session;
 
public class Producer
{
    private ConnectionFactory factory;
    private Connection connection;
    private Session session;
    private MessageProducer producer;
 
    public Producer(ConnectionFactory factory, String queueName) throws JMSException
    {
        this.factory = factory;
        connection = factory.createConnection();
        connection.start();
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Destination destination = session.createQueue(queueName);
        producer = session.createProducer(destination);
    }
 
    public void run() throws JMSException
    {
        for (int i = 0; i < 10; i++)
        {
            System.out.println("Creating Message " + i);
            Message message = session.createTextMessage(this.mTxt);
            producer.send(message);
        }
    }
 
    public void close() throws JMSException
    {
        if (connection != null)
        {
            connection.close();
        }
    }
 
    private String mTxt =   "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                            "<note>" +
                            "<to>Anyone</to>" +
                            "<from>Kris</from>" +
                            "<heading>Simple Message</heading>" +
                            "<body>Check out my Twitter account @grajo</body>" +
                            "</note>";
}

Once you build your app with maven you can test it by running the App main method. Make sure that your ServiceMix instance is up and running. On Eclipse you can use the shortcut to run your application (Alt + Shift + X and then J).

Once you run your app the new queue named ‘test’ should be created in your ActiveMQ and 10 XML messages should be visible on that queue.

You can download the eclipse maven based project with the full source code for this example from github at: https://github.com/softberries/activemq_tut
In the next part we will build a ServiceMix application which will listen on the test queue for incoming messages and save them as files onto filesystem.

]]> http://www.softwarepassion.com/servicemix-fuse-esb-file-su-jms-su-example-part-1/feed/ 2 Apache ServiceMix (Fuse ESB) with Camel http://www.softwarepassion.com/apache-servicemix-fuse-esb-with-camel/ http://www.softwarepassion.com/apache-servicemix-fuse-esb-with-camel/#comments Wed, 07 Dec 2011 12:11:18 +0000 admin http://www.softwarepassion.com/?p=668

Today I will present a quick intro tutorial into ESB and Camel. While going through the examples on the ServiceMix website I have encountered a few problems preventing me from developing the simplest applications. As the ServiceMix tutorial is a bit outdated I present you with the similar corrected version of the original tutorial.

Download and install Fuse ESB – based on Apache ServiceMix

For the purpose of this tutorial we will use Fuse ESB version 4.4.1. On the FuseSource website you can find the version for Mac, Linux and Windows as well as build your own version from source.
When you finish downloading, unpack the zipped archive into a choosen directory (without spaces in its name), eg. ‘/home/kris/’ -> you should end up with ‘/home/kris/apache-servicemix-4.4.1-fuse-01-11′

Test your installation

You can test your installation by going to the ‘bin’ folder of your servicemix installation and executing: ‘./servicemix’ command.
You should see something similar to this:

You can shutdown you ServiceMix instance by typing ‘shutdown’ and then ‘yes’. For simple debugging purposes you can type ‘log:tail’ to see the constantly scrolling logs of what’s happening inside your ServiceMix instance.

Create a basic folder for your entire ServiceMix application

For all the modules we are going to create in this tutorial we need to create a parent folder first, choose any destination you like and name the folder whatever suits you, let’s say I will name mine ‘softwarepassion’.

Create pom.xml file for your parent folder

This step includes simple ‘copy and paste’ basic parent pom.xml file for our project, this file is identical to the one found on the official ServiceMix tutorial:

<?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.tutorial.camel</groupId>
  <artifactId>parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>SMX-Camel :: Tutorial</name>
  <url>http://servicemix.apache.org</url>
</project>

Create camel based service unit

Navigate into our parent project directory (‘softwarepassion’) and execute the following maven command:

mvn archetype:create -DarchetypeArtifactId=servicemix-camel-service-unit \
-DarchetypeGroupId=org.apache.servicemix.tooling -DartifactId=tutorial-camel-su

This should create a new maven based project with its own pom.xml file. The command additionally updates our parent pom.xml file with info about new child project.

Create service assembly

This is the main module of our project. Service assembly gathers other service units for the project into a single deployable assembly.
To create our service assembly, go to the parent folder (‘softwarepassion’) and execute the following maven command:

mvn archetype:create -DarchetypeArtifactId=servicemix-service-assembly \
-DarchetypeGroupId=org.apache.servicemix.tooling -DartifactId=tutorial-camel-sa

The outcome would be similar to the previous step.
Once you create a service assembly project you would need to update service assembly project pom.xml file with the following dependency information:

<project>
  ...
  <dependencies>
    <dependency>
      <groupId>com.softwarepassion.tutorial.camel</groupId>
      <artifactId>tutorial-camel-su</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>
  ...
</project>

Full pom.xml file of your service assembly should look like this:

<?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.tutorial.camel</groupId>
    <version>1.0-SNAPSHOT</version>
  </parent>
  <groupId>com.softwarepassion.tutorial.camel</groupId>
  <artifactId>tutorial-camel-sa</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jbi-service-assembly</packaging>
  <name>Apache ServiceMix :: Service Assembly</name>
  <build>
    <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>
        <configuration>
          <type>service-assembly</type>
        </configuration>
      </plugin>
    </plugins>
  </build>
  <dependencies>
    <dependency>
      <groupId>com.softwarepassion.tutorial.camel</groupId>
      <artifactId>tutorial-camel-su</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>
</project>

At this point we have the full project skeleton ready – parent project with a single service unit and service assembly.

Build and test deploy

Now we can execute a test build and deploy our application to Apache ServiceMix. Go to the parent directory and execute the following command:

mvn install

You should see a ‘BUILD SUCCESSFUL’ message:

[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO] ------------------------------------------------------------------------
[INFO] Softwarepassion-Camel :: Tutorial ..................... SUCCESS [1.156s]
[INFO] Apache ServiceMix :: Camel Service Unit ............... SUCCESS [4.367s]
[INFO] Apache ServiceMix :: Service Assembly ................. SUCCESS [0.998s]
[INFO] ------------------------------------------------------------------------
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 14 seconds
[INFO] Finished at: Wed Dec 07 11:42:47 CET 2011
[INFO] Final Memory: 51M/366M

Copy the service assembly zip file into ‘deploy’ directory of you ServiceMix installation (make sure its running first).

For my setup it looks like this:

cp tutorial-camel-sa/target/tutorial-camel-sa-1.0-SNAPSHOT.zip /home/kris/apache-servicemix-4.4.1-fuse-01-11/deploy/

Congratulations, you have reached the point where you have basic ESB application with Camel routing set-up up and running.

Modify camel-context.xml file

For the purposes of this tutorial we will create a simple Camel route using Java DSL. First you need to modify camel-context.xml file to inform that we are going to use java dsl style:
You can find camel-context.xml file inside service unit project ‘tutorial-camel-su/src/main/resources’

<?xml version="1.0" encoding="UTF-8"?>
<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.0.xsd
      http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">
        <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
                <package>com.softwarepassion.tutorial.camel</package>
        </camelContext>
</beans>

Implement Camel route

Now we are going to the real job. We need to add implementation for the ‘configure(..)’ method of our RouteBuilder:
Replace the class ‘MyRouteBuilder’:

package com.softwarepassion.tutorial.camel;

import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.builder.RouteBuilder;

/**
* A Camel Router
*/
public class MyRouteBuilder extends RouteBuilder {

public void configure() {

// TODO create Camel routes here. For example:-
//
// from("activemq:test.MyQueue").to("file://test");

}
}

with the following:

package com.softwarepassion.tutorial.camel;

import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.builder.RouteBuilder;

/**
* A Camel Router
*/
public class MyRouteBuilder extends RouteBuilder {

public void configure() {
from("timer://tutorial?fixedRate=true&amp;delay=3000&amp;period=10000")   // 1
.setBody(constant("")).setHeader(Exchange.HTTP_METHOD, constant("POST"))                           // 2
.to("http://twitter.com").convertBodyTo(String.class).process(new Processor(){

public void process(Exchange exchange) throws Exception {
Object body = exchange.getIn().getBody();
System.out.println("BODY: " + body);
}

});
}

}

This route executes the timer every 10 seconds, fetches the ‘softwarepassion.com’ web page, convert the received message body to plain String and uses a Processor do display the content on the console.

I hope this will help someone when starting with ServiceMix ESB + Camel

You can download the full sources from the git repository at: https://github.com/softberries/esb_with_camel

]]> http://www.softwarepassion.com/apache-servicemix-fuse-esb-with-camel/feed/ 1 Small tip for linux geeks http://www.softwarepassion.com/small-tip-for-linux-geeks/ http://www.softwarepassion.com/small-tip-for-linux-geeks/#comments Fri, 02 Dec 2011 09:16:11 +0000 admin http://www.softwarepassion.com/?p=663

For all the linux geeks out there, I would like to share my latest discovery which is CommandLineFu

Go in there, sort the commands by votes, fire up your terminal and practice :)

]]> http://www.softwarepassion.com/small-tip-for-linux-geeks/feed/ 0