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