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