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.spring.handler;
018
019 import java.util.HashMap;
020 import java.util.HashSet;
021 import java.util.Map;
022 import java.util.Set;
023
024 import javax.xml.bind.Binder;
025 import javax.xml.bind.JAXBContext;
026 import javax.xml.bind.JAXBException;
027 import org.w3c.dom.Element;
028 import org.w3c.dom.Node;
029 import org.w3c.dom.NodeList;
030
031 import org.apache.camel.builder.xml.Namespaces;
032 import org.apache.camel.model.FromDefinition;
033 import org.apache.camel.model.SendDefinition;
034 import org.apache.camel.spi.NamespaceAware;
035 import org.apache.camel.spring.CamelBeanPostProcessor;
036 import org.apache.camel.spring.CamelConsumerTemplateFactoryBean;
037 import org.apache.camel.spring.CamelContextFactoryBean;
038 import org.apache.camel.spring.CamelEndpointFactoryBean;
039 import org.apache.camel.spring.CamelJMXAgentDefinition;
040 import org.apache.camel.spring.CamelProducerTemplateFactoryBean;
041 import org.apache.camel.spring.remoting.CamelProxyFactoryBean;
042 import org.apache.camel.spring.remoting.CamelServiceExporter;
043 import org.apache.camel.util.ObjectHelper;
044 import org.apache.camel.view.ModelFileGenerator;
045 import org.apache.commons.logging.Log;
046 import org.apache.commons.logging.LogFactory;
047 import org.springframework.beans.factory.BeanDefinitionStoreException;
048 import org.springframework.beans.factory.config.BeanDefinition;
049 import org.springframework.beans.factory.config.RuntimeBeanReference;
050 import org.springframework.beans.factory.parsing.BeanComponentDefinition;
051 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
052 import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
053 import org.springframework.beans.factory.xml.ParserContext;
054
055 /**
056 * Camel namespace for the spring XML configuration file.
057 */
058 public class CamelNamespaceHandler extends NamespaceHandlerSupport {
059
060 private static final Log LOG = LogFactory.getLog(CamelNamespaceHandler.class);
061 protected BeanDefinitionParser endpointParser = new BeanDefinitionParser(CamelEndpointFactoryBean.class);
062 protected BeanDefinitionParser beanPostProcessorParser = new BeanDefinitionParser(CamelBeanPostProcessor.class);
063 protected Set<String> parserElementNames = new HashSet<String>();
064 protected Binder<Node> binder;
065 private JAXBContext jaxbContext;
066 private Map<String, BeanDefinitionParser> parserMap = new HashMap<String, BeanDefinitionParser>();
067
068 public ModelFileGenerator createModelFileGenerator() throws JAXBException {
069 return new ModelFileGenerator(getJaxbContext());
070 }
071
072 public void init() {
073 // remoting
074 addBeanDefinitionParser("proxy", CamelProxyFactoryBean.class);
075 addBeanDefinitionParser("template", CamelProducerTemplateFactoryBean.class);
076 addBeanDefinitionParser("consumerTemplate", CamelConsumerTemplateFactoryBean.class);
077 addBeanDefinitionParser("export", CamelServiceExporter.class);
078
079 // jmx agent
080 addBeanDefinitionParser("jmxAgent", CamelJMXAgentDefinition.class);
081
082 // endpoint
083 addBeanDefinitionParser("endpoint", CamelEndpointFactoryBean.class);
084
085 // camel context
086 boolean osgi = false;
087 Class cl = CamelContextFactoryBean.class;
088 try {
089 cl = Class.forName("org.apache.camel.osgi.CamelContextFactoryBean");
090 osgi = true;
091 } catch (Throwable t) {
092 // not running with camel-osgi so we fallback to the regular factory bean
093 LOG.trace("Cannot find class so assuming not running in OSGI container: " + t.getMessage());
094 }
095
096 if (osgi) {
097 LOG.info("camel-osgi.jar detected in classpath");
098 } else {
099 LOG.info("camel-osgi.jar not detected in classpath");
100 }
101
102 if (LOG.isDebugEnabled()) {
103 LOG.debug("Using " + cl.getCanonicalName() + " as CamelContextBeanDefinitionParser");
104 }
105 registerParser("camelContext", new CamelContextBeanDefinitionParser(cl));
106 }
107
108 private void addBeanDefinitionParser(String elementName, Class<?> type) {
109 BeanDefinitionParser parser = new BeanDefinitionParser(type);
110 registerParser(elementName, parser);
111 parserMap.put(elementName, parser);
112 }
113
114 protected void createBeanPostProcessor(ParserContext parserContext, String contextId, Element childElement, BeanDefinitionBuilder parentBuilder) {
115 String beanPostProcessorId = contextId + ":beanPostProcessor";
116 childElement.setAttribute("id", beanPostProcessorId);
117 BeanDefinition definition = beanPostProcessorParser.parse(childElement, parserContext);
118 // only register to camel context id as a String. Then we can look it up later
119 // otherwise we get a circular reference in spring and it will not allow custom bean post processing
120 // see more at CAMEL-1663
121 definition.getPropertyValues().addPropertyValue("camelId", contextId);
122 parentBuilder.addPropertyReference("beanPostProcessor", beanPostProcessorId);
123 }
124
125 protected void registerScriptParser(String elementName, String engineName) {
126 registerParser(elementName, new ScriptDefinitionParser(engineName));
127 }
128
129 protected void registerParser(String name, org.springframework.beans.factory.xml.BeanDefinitionParser parser) {
130 parserElementNames.add(name);
131 registerBeanDefinitionParser(name, parser);
132 }
133
134 public Set<String> getParserElementNames() {
135 return parserElementNames;
136 }
137
138 protected Object parseUsingJaxb(Element element, ParserContext parserContext) {
139 try {
140 binder = getJaxbContext().createBinder();
141 return binder.unmarshal(element);
142 } catch (JAXBException e) {
143 throw new BeanDefinitionStoreException("Failed to parse JAXB element: " + e, e);
144 }
145 }
146
147 public JAXBContext getJaxbContext() throws JAXBException {
148 if (jaxbContext == null) {
149 jaxbContext = createJaxbContext();
150 }
151 return jaxbContext;
152 }
153
154 protected JAXBContext createJaxbContext() throws JAXBException {
155 StringBuilder packages = new StringBuilder();
156 for (Class cl : getJaxbPackages()) {
157 if (packages.length() > 0) {
158 packages.append(":");
159 }
160 packages.append(cl.getName().substring(0, cl.getName().lastIndexOf('.')));
161 }
162 return JAXBContext.newInstance(packages.toString(), getClass().getClassLoader());
163 }
164
165 protected Set<Class> getJaxbPackages() {
166 Set<Class> classes = new HashSet<Class>();
167 classes.add(org.apache.camel.spring.CamelContextFactoryBean.class);
168 classes.add(org.apache.camel.ExchangePattern.class);
169 classes.add(org.apache.camel.model.RouteDefinition.class);
170 classes.add(org.apache.camel.model.config.StreamResequencerConfig.class);
171 classes.add(org.apache.camel.model.dataformat.DataFormatsDefinition.class);
172 classes.add(org.apache.camel.model.language.ExpressionDefinition.class);
173 classes.add(org.apache.camel.model.loadbalancer.RoundRobinLoadBalancerDefinition.class);
174 return classes;
175 }
176
177 protected class CamelContextBeanDefinitionParser extends BeanDefinitionParser {
178 public CamelContextBeanDefinitionParser(Class type) {
179 super(type);
180 }
181
182 @Override
183 protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
184 super.doParse(element, parserContext, builder);
185
186 String contextId = element.getAttribute("id");
187
188 // lets avoid folks having to explicitly give an ID to a camel context
189 if (ObjectHelper.isEmpty(contextId)) {
190 contextId = "camelContext";
191 element.setAttribute("id", contextId);
192 }
193
194 // now lets parse the routes with JAXB
195 Object value = parseUsingJaxb(element, parserContext);
196
197 if (value instanceof CamelContextFactoryBean) {
198 // set the property value with the JAXB parsed value
199 CamelContextFactoryBean factoryBean = (CamelContextFactoryBean)value;
200 builder.addPropertyValue("id", contextId);
201 builder.addPropertyValue("routes", factoryBean.getRoutes());
202 builder.addPropertyValue("intercepts", factoryBean.getIntercepts());
203 builder.addPropertyValue("interceptFroms", factoryBean.getInterceptFroms());
204 builder.addPropertyValue("interceptSendToEndpoints", factoryBean.getInterceptSendToEndpoints());
205 builder.addPropertyValue("dataFormats", factoryBean.getDataFormats());
206 builder.addPropertyValue("onCompletions", factoryBean.getOnCompletions());
207 builder.addPropertyValue("onExceptions", factoryBean.getOnExceptions());
208 builder.addPropertyValue("builderRefs", factoryBean.getBuilderRefs());
209 builder.addPropertyValue("properties", factoryBean.getProperties());
210 builder.addPropertyValue("packageScan", factoryBean.getPackageScan());
211 if (factoryBean.getPackages().length > 0) {
212 builder.addPropertyValue("packages", factoryBean.getPackages());
213 }
214 }
215
216 boolean createdBeanPostProcessor = false;
217 NodeList list = element.getChildNodes();
218 int size = list.getLength();
219 for (int i = 0; i < size; i++) {
220 Node child = list.item(i);
221 if (child instanceof Element) {
222 Element childElement = (Element)child;
223 String localName = child.getLocalName();
224 if (localName.equals("beanPostProcessor")) {
225 createBeanPostProcessor(parserContext, contextId, childElement, builder);
226 createdBeanPostProcessor = true;
227 } else if (localName.equals("endpoint")) {
228 registerEndpoint(childElement, parserContext, contextId);
229 } else {
230 BeanDefinitionParser parser = parserMap.get(localName);
231 if (parser != null) {
232 BeanDefinition definition = parser.parse(childElement, parserContext);
233 String id = childElement.getAttribute("id");
234 if (ObjectHelper.isNotEmpty(id)) {
235 parserContext.registerComponent(new BeanComponentDefinition(definition, id));
236 if (localName.equals("jmxAgent")) {
237 builder.addPropertyReference("camelJMXAgent", id);
238 }
239 }
240 }
241
242 }
243 }
244 }
245
246 // register as endpoint defined indirectly in the routes by from/to types having id explict set
247 registerEndpointsWithIdsDefinedInFromOrToTypes(element, parserContext, contextId);
248
249 // lets inject the namespaces into any namespace aware POJOs
250 injectNamespaces(element);
251 if (!createdBeanPostProcessor) {
252 // no bean processor element so lets create it by ourself
253 Element childElement = element.getOwnerDocument().createElement("beanPostProcessor");
254 element.appendChild(childElement);
255 createBeanPostProcessor(parserContext, contextId, childElement, builder);
256 }
257 }
258 }
259
260 protected void injectNamespaces(Element element) {
261 NodeList list = element.getChildNodes();
262 Namespaces namespaces = null;
263 int size = list.getLength();
264 for (int i = 0; i < size; i++) {
265 Node child = list.item(i);
266 if (child instanceof Element) {
267 Element childElement = (Element)child;
268 Object object = binder.getJAXBNode(child);
269 if (object instanceof NamespaceAware) {
270 NamespaceAware namespaceAware = (NamespaceAware)object;
271 if (namespaces == null) {
272 namespaces = new Namespaces(element);
273 }
274 namespaces.configure(namespaceAware);
275 }
276 injectNamespaces(childElement);
277 }
278 }
279 }
280
281 /**
282 * Uses for auto registering endpoints from the <tt>from</tt> or <tt>to</tt> DSL if they have an id attribute set
283 */
284 protected void registerEndpointsWithIdsDefinedInFromOrToTypes(Element element, ParserContext parserContext, String contextId) {
285 NodeList list = element.getChildNodes();
286 int size = list.getLength();
287 for (int i = 0; i < size; i++) {
288 Node child = list.item(i);
289 if (child instanceof Element) {
290 Element childElement = (Element)child;
291 Object object = binder.getJAXBNode(child);
292 // we only want from/to types to be registered as endpoints
293 if (object instanceof FromDefinition || object instanceof SendDefinition) {
294 registerEndpoint(childElement, parserContext, contextId);
295 }
296 // recursive
297 registerEndpointsWithIdsDefinedInFromOrToTypes(childElement, parserContext, contextId);
298 }
299 }
300 }
301
302 private void registerEndpoint(Element childElement, ParserContext parserContext, String contextId) {
303 String id = childElement.getAttribute("id");
304 // must have an id to be registered
305 if (ObjectHelper.isNotEmpty(id)) {
306 BeanDefinition definition = endpointParser.parse(childElement, parserContext);
307 definition.getPropertyValues().addPropertyValue("camelContext", new RuntimeBeanReference(contextId));
308 parserContext.registerComponent(new BeanComponentDefinition(definition, id));
309 }
310 }
311
312 }