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.DefaultComponent;
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 DefaultComponent {
039        private static final transient Logger LOG = LoggerFactory.getLogger(XsltComponent.class);
040        private XmlConverter xmlConverter;
041        private URIResolver uriResolver;
042        private boolean contentCache = true;
043    
044        public XmlConverter getXmlConverter() {
045            return xmlConverter;
046        }
047    
048        public void setXmlConverter(XmlConverter xmlConverter) {
049            this.xmlConverter = xmlConverter;
050        }
051    
052        public URIResolver getUriResolver() {
053            return uriResolver;
054        }
055    
056        public void setUriResolver(URIResolver uriResolver) {
057            this.uriResolver = uriResolver;
058        }
059    
060        public boolean isContentCache() {
061            return contentCache;
062        }
063    
064        public void setContentCache(boolean contentCache) {
065            this.contentCache = contentCache;
066        }
067    
068        protected Endpoint createEndpoint(String uri, final String remaining, Map<String, Object> parameters) throws Exception {
069            String resourceUri = remaining;
070            LOG.debug("{} using schema resource: {}", this, resourceUri);
071            final XsltBuilder xslt = getCamelContext().getInjector().newInstance(XsltBuilder.class);
072    
073            // lets allow the converter to be configured
074            XmlConverter converter = resolveAndRemoveReferenceParameter(parameters, "converter", XmlConverter.class);
075            if (converter == null) {
076                converter = getXmlConverter();
077            }
078            if (converter != null) {
079                xslt.setConverter(converter);
080            }
081    
082            String transformerFactoryClassName = getAndRemoveParameter(parameters, "transformerFactoryClass", String.class);
083            TransformerFactory factory = null;
084            if (transformerFactoryClassName != null) {
085                // provide the class loader of this component to work in OSGi environments
086                Class<?> factoryClass = getCamelContext().getClassResolver().resolveClass(transformerFactoryClassName, XsltComponent.class.getClassLoader());
087                if (factoryClass != null) {
088                    factory = (TransformerFactory) getCamelContext().getInjector().newInstance(factoryClass);
089                } else {
090                    LOG.warn("Cannot find the TransformerFactoryClass with the class name: {}", transformerFactoryClassName);
091                }
092            }
093    
094            if (parameters.get("transformerFactory") != null) {
095                factory = resolveAndRemoveReferenceParameter(parameters, "transformerFactory", TransformerFactory.class);
096            }
097    
098            if (factory != null) {
099                xslt.getConverter().setTransformerFactory(factory);
100            }
101    
102            ResultHandlerFactory resultHandlerFactory = resolveAndRemoveReferenceParameter(parameters, "resultHandlerFactory", ResultHandlerFactory.class);
103            if (resultHandlerFactory != null) {
104                xslt.setResultHandlerFactory(resultHandlerFactory);
105            }
106    
107            Boolean failOnNullBody = getAndRemoveParameter(parameters, "failOnNullBody", Boolean.class);
108            if (failOnNullBody != null) {
109                xslt.setFailOnNullBody(failOnNullBody);
110            }
111            String output = getAndRemoveParameter(parameters, "output", String.class);
112            configureOutput(xslt, output);
113            
114            Integer cs = getAndRemoveParameter(parameters, "transformerCacheSize", Integer.class, Integer.valueOf(0));
115            xslt.transformerCacheSize(cs);
116    
117            // default to use the cache option from the component if the endpoint did not have the contentCache parameter
118            boolean cache = getAndRemoveParameter(parameters, "contentCache", Boolean.class, contentCache);
119    
120            // if its a http uri, then append additional parameters as they are part of the uri
121            if (ResourceHelper.isHttpUri(resourceUri)) {
122                resourceUri = ResourceHelper.appendParameters(resourceUri, parameters);
123            }
124    
125            // lookup custom resolver to use
126            URIResolver resolver = resolveAndRemoveReferenceParameter(parameters, "uriResolver", URIResolver.class);
127            if (resolver == null) {
128                // not in endpoint then use component specific resolver
129                resolver = getUriResolver();
130            }
131            if (resolver == null) {
132                // fallback to use a Camel specific resolver
133                resolver = new XsltUriResolver(getCamelContext().getClassResolver(), remaining);
134            }
135            // set resolver before input stream as resolver is used when loading the input stream
136            xslt.setUriResolver(resolver);
137            
138            configureXslt(xslt, uri, remaining, parameters);
139    
140            return new XsltEndpoint(uri, this, xslt, resourceUri, cache);
141        }
142    
143        protected void configureXslt(XsltBuilder xslt, String uri, String remaining, Map<String, Object> parameters) throws Exception {
144            setProperties(xslt, parameters);
145        }
146    
147        protected void configureOutput(XsltBuilder xslt, String output) throws Exception {
148            if (ObjectHelper.isEmpty(output)) {
149                return;
150            }
151    
152            if ("string".equalsIgnoreCase(output)) {
153                xslt.outputString();
154            } else if ("bytes".equalsIgnoreCase(output)) {
155                xslt.outputBytes();
156            } else if ("DOM".equalsIgnoreCase(output)) {
157                xslt.outputDOM();
158            } else if ("file".equalsIgnoreCase(output)) {
159                xslt.outputFile();
160            } else {
161                throw new IllegalArgumentException("Unknown output type: " + output);
162            }
163        }
164    
165    }