# StringTemplate

## String Template

The string-template: component allows you to process a message using a String Template. This can be ideal when using Templating to generate responses for requests.

Maven users will need to add the following dependency to their `pom.xml` for this component:

    <dependency>
        <groupId>org.apache.camel</groupId>
        <artifactId>camel-stringtemplate</artifactId>
        <version>x.x.x</version>
        <!-- use the same version as your Camel core version -->
    </dependency>

## URI format

    string-template:templateName[?options]

Where templateName is the classpath-local URI of the template to invoke; or the complete URL of the remote template.

You can append query options to the URI in the following format, `?option=value&option=value&...`

## Options

Option | Default | Description
--- | --- | ---
`contentCache` | `false` | New option in Apache Camel 1.4. Cache for the resource content when its loaded.

## Headers

Apache Camel will store a reference to the resource in the message header with key, `org.apache.camel.stringtemplate.resource`. The Resource is an `org.springframework.core.io.Resource` object.

## Hot reloading

The string template resource is by default hot-reloadable for both file and classpath resources (expanded jar). If you set `contentCache=true`, Apache Camel loads the resource only once and hot-reloading is not possible. This scenario can be used in production when the resource never changes.

## StringTemplate Attributes

Apache Camel will provide exchange information as attributes (just a `java.util.Map`) to the string template. The Exchange is transfered as:

key | value
--- | ---
`exchange` | The Exchange itself.
`headers` | The headers of the In message.
`camelContext` | The Camel Context.
`request` | The In message.
`in` | The In message.
`body` | The In message body.
`out` | The Out message (only for InOut message exchange pattern).
`response` | The Out message (only for InOut message exchange pattern).

## Samples

For example you could use a string template as follows in order to formulate a response to a message:

    from("activemq:My.Queue").
      to("string-template:com/acme/MyResponse.tm");

## The Email Sample

In this sample we want to use a string template to send an order confirmation email. The email template is laid out in `StringTemplate` as:

    Dear $headers.lastName$, $headers.firstName$

    Thanks for the order of $headers.item$.

    Regards Camel Riders Bookstore
    $body$

And the java code is as follows:

    private Exchange createLetter() {
        Exchange exchange = context.getEndpoint("direct:a").createExchange();
        Message msg = exchange.getIn();
        msg.setHeader("firstName", "Claus");
        msg.setHeader("lastName", "Ibsen");
        msg.setHeader("item", "Camel in Action");
        msg.setBody("PS: Next beer is on me, James");
        return exchange;
    }

    @Test
    public void testVelocityLetter() throws Exception {
        MockEndpoint mock = getMockEndpoint("mock:result");
        mock.expectedMessageCount(1);
        mock.expectedBodiesReceived("Dear Ibsen, Claus! Thanks for the order of Camel in Action. Regards Camel Riders Bookstore PS: Next beer is on me, James");

        template.send("direct:a", createLetter());

        mock.assertIsSatisfied();
    }

    protected RouteBuilder createRouteBuilder() throws Exception {
        return new RouteBuilder() {
            public void configure() throws Exception {
                from("direct:a").to("string-template:org/apache/camel/component/stringtemplate/letter.tm").to("mock:result");
            }
        };
    }