001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.camel.component.xslt;
018
019 import java.util.Map;
020 import javax.xml.transform.TransformerFactory;
021 import javax.xml.transform.URIResolver;
022
023 import org.apache.camel.Endpoint;
024 import org.apache.camel.builder.xml.ResultHandlerFactory;
025 import org.apache.camel.builder.xml.XsltBuilder;
026 import org.apache.camel.builder.xml.XsltUriResolver;
027 import org.apache.camel.converter.jaxp.XmlConverter;
028 import org.apache.camel.impl.UriEndpointComponent;
029 import org.apache.camel.util.ObjectHelper;
030 import org.apache.camel.util.ResourceHelper;
031 import org.slf4j.Logger;
032 import org.slf4j.LoggerFactory;
033
034 /**
035 * An <a href="http://camel.apache.org/xslt.html">XSLT Component</a>
036 * for performing XSLT transforms of messages
037 */
038 public class XsltComponent extends UriEndpointComponent {
039
040 private static final String SAXON_TRANSFORMER_FACTORY_CLASS_NAME = "net.sf.saxon.TransformerFactoryImpl";
041 private static final Logger LOG = LoggerFactory.getLogger(XsltComponent.class);
042 private XmlConverter xmlConverter;
043 private URIResolver uriResolver;
044 private boolean contentCache = true;
045 private boolean saxon;
046
047 public XsltComponent() {
048 super(XsltEndpoint.class);
049 }
050
051 public XmlConverter getXmlConverter() {
052 return xmlConverter;
053 }
054
055 public void setXmlConverter(XmlConverter xmlConverter) {
056 this.xmlConverter = xmlConverter;
057 }
058
059 public URIResolver getUriResolver() {
060 return uriResolver;
061 }
062
063 public void setUriResolver(URIResolver uriResolver) {
064 this.uriResolver = uriResolver;
065 }
066
067 public boolean isContentCache() {
068 return contentCache;
069 }
070
071 public void setContentCache(boolean contentCache) {
072 this.contentCache = contentCache;
073 }
074
075 public boolean isSaxon() {
076 return saxon;
077 }
078
079 public void setSaxon(boolean saxon) {
080 this.saxon = saxon;
081 }
082
083 protected Endpoint createEndpoint(String uri, final String remaining, Map<String, Object> parameters) throws Exception {
084 String resourceUri = remaining;
085 LOG.debug("{} using schema resource: {}", this, resourceUri);
086 final XsltBuilder xslt = getCamelContext().getInjector().newInstance(XsltBuilder.class);
087
088 // lets allow the converter to be configured
089 XmlConverter converter = resolveAndRemoveReferenceParameter(parameters, "converter", XmlConverter.class);
090 if (converter == null) {
091 converter = getXmlConverter();
092 }
093 if (converter != null) {
094 xslt.setConverter(converter);
095 }
096
097 String transformerFactoryClassName = getAndRemoveParameter(parameters, "transformerFactoryClass", String.class);
098 Boolean saxon = getAndRemoveParameter(parameters, "saxon", Boolean.class, isSaxon());
099 if (transformerFactoryClassName == null && saxon) {
100 transformerFactoryClassName = SAXON_TRANSFORMER_FACTORY_CLASS_NAME;
101 }
102
103 TransformerFactory factory = null;
104 if (transformerFactoryClassName != null) {
105 // provide the class loader of this component to work in OSGi environments
106 Class<?> factoryClass = getCamelContext().getClassResolver().resolveMandatoryClass(transformerFactoryClassName, XsltComponent.class.getClassLoader());
107 LOG.debug("Using TransformerFactoryClass {}", factoryClass);
108 factory = (TransformerFactory) getCamelContext().getInjector().newInstance(factoryClass);
109 }
110
111 if (parameters.get("transformerFactory") != null) {
112 factory = resolveAndRemoveReferenceParameter(parameters, "transformerFactory", TransformerFactory.class);
113 }
114
115 if (factory != null) {
116 LOG.debug("Using TransformerFactory {}", factory);
117 xslt.getConverter().setTransformerFactory(factory);
118 }
119
120 ResultHandlerFactory resultHandlerFactory = resolveAndRemoveReferenceParameter(parameters, "resultHandlerFactory", ResultHandlerFactory.class);
121 if (resultHandlerFactory != null) {
122 xslt.setResultHandlerFactory(resultHandlerFactory);
123 }
124
125 Boolean failOnNullBody = getAndRemoveParameter(parameters, "failOnNullBody", Boolean.class);
126 if (failOnNullBody != null) {
127 xslt.setFailOnNullBody(failOnNullBody);
128 }
129 String output = getAndRemoveParameter(parameters, "output", String.class);
130 configureOutput(xslt, output);
131
132 Integer cs = getAndRemoveParameter(parameters, "transformerCacheSize", Integer.class, Integer.valueOf(0));
133 xslt.transformerCacheSize(cs);
134
135 // default to use the cache option from the component if the endpoint did not have the contentCache parameter
136 boolean cache = getAndRemoveParameter(parameters, "contentCache", Boolean.class, contentCache);
137
138 // if its a http uri, then append additional parameters as they are part of the uri
139 if (ResourceHelper.isHttpUri(resourceUri)) {
140 resourceUri = ResourceHelper.appendParameters(resourceUri, parameters);
141 }
142
143 // lookup custom resolver to use
144 URIResolver resolver = resolveAndRemoveReferenceParameter(parameters, "uriResolver", URIResolver.class);
145 if (resolver == null) {
146 // not in endpoint then use component specific resolver
147 resolver = getUriResolver();
148 }
149 if (resolver == null) {
150 // fallback to use a Camel specific resolver
151 resolver = new XsltUriResolver(getCamelContext().getClassResolver(), remaining);
152 }
153 // set resolver before input stream as resolver is used when loading the input stream
154 xslt.setUriResolver(resolver);
155
156 configureXslt(xslt, uri, remaining, parameters);
157
158 return new XsltEndpoint(uri, this, xslt, resourceUri, cache);
159 }
160
161 protected void configureXslt(XsltBuilder xslt, String uri, String remaining, Map<String, Object> parameters) throws Exception {
162 setProperties(xslt, parameters);
163 }
164
165 protected void configureOutput(XsltBuilder xslt, String output) throws Exception {
166 if (ObjectHelper.isEmpty(output)) {
167 return;
168 }
169
170 if ("string".equalsIgnoreCase(output)) {
171 xslt.outputString();
172 } else if ("bytes".equalsIgnoreCase(output)) {
173 xslt.outputBytes();
174 } else if ("DOM".equalsIgnoreCase(output)) {
175 xslt.outputDOM();
176 } else if ("file".equalsIgnoreCase(output)) {
177 xslt.outputFile();
178 } else {
179 throw new IllegalArgumentException("Unknown output type: " + output);
180 }
181 }
182
183 }