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;
018
019 import java.lang.reflect.Field;
020 import java.lang.reflect.Method;
021
022 import javax.xml.bind.annotation.XmlAccessType;
023 import javax.xml.bind.annotation.XmlAccessorType;
024 import javax.xml.bind.annotation.XmlRootElement;
025 import javax.xml.bind.annotation.XmlTransient;
026
027 import org.apache.camel.CamelContext;
028 import org.apache.camel.CamelContextAware;
029 import org.apache.camel.Endpoint;
030 import org.apache.camel.EndpointInject;
031 import org.apache.camel.Produce;
032 import org.apache.camel.impl.CamelPostProcessorHelper;
033 import org.apache.camel.impl.DefaultEndpoint;
034 import org.apache.camel.spring.util.ReflectionUtils;
035 import org.apache.camel.util.ObjectHelper;
036 import org.apache.commons.logging.Log;
037 import org.apache.commons.logging.LogFactory;
038 import org.springframework.beans.BeanInstantiationException;
039 import org.springframework.beans.BeansException;
040 import org.springframework.beans.factory.config.BeanPostProcessor;
041 import org.springframework.context.ApplicationContext;
042 import org.springframework.context.ApplicationContextAware;
043
044 /**
045 * A bean post processor which implements the <a href="http://camel.apache.org/bean-integration.html">Bean Integration</a>
046 * features in Camel. Features such as the <a href="http://camel.apache.org/bean-injection.html">Bean Injection</a> of objects like
047 * {@link Endpoint} and
048 * {@link org.apache.camel.ProducerTemplate} together with support for
049 * <a href="http://camel.apache.org/pojo-consuming.html">POJO Consuming</a> via the
050 * {@link org.apache.camel.Consume} annotation along with
051 * <a href="http://camel.apache.org/pojo-producing.html">POJO Producing</a> via the
052 * {@link org.apache.camel.Produce} annotation along with other annotations such as
053 * {@link org.apache.camel.RecipientList} for creating <a href="http://camel.apache.org/recipientlist-annotation.html">a Recipient List router via annotations</a>.
054 * <p>
055 * If you use the <camelContext> element in your <a href="http://camel.apache.org/spring.html">Spring XML</a>
056 * then one of these bean post processors is implicity installed and configured for you. So you should never have to
057 * explicitly create or configure one of these instances.
058 *
059 * @version $Revision: 749562 $
060 */
061 @XmlRootElement(name = "beanPostProcessor")
062 @XmlAccessorType(XmlAccessType.FIELD)
063 public class CamelBeanPostProcessor implements BeanPostProcessor, ApplicationContextAware {
064 private static final transient Log LOG = LogFactory.getLog(CamelBeanPostProcessor.class);
065 @XmlTransient
066 private CamelContext camelContext;
067 @XmlTransient
068 private ApplicationContext applicationContext;
069 @XmlTransient
070 private CamelPostProcessorHelper postProcessor;
071
072 public CamelBeanPostProcessor() {
073 }
074
075 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
076 injectFields(bean);
077 injectMethods(bean);
078 if (bean instanceof CamelContextAware) {
079 CamelContextAware contextAware = (CamelContextAware)bean;
080 if (camelContext == null) {
081 LOG.warn("No CamelContext defined yet so cannot inject into: " + bean);
082 } else {
083 contextAware.setCamelContext(camelContext);
084 }
085 }
086 return bean;
087 }
088
089 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
090 if (bean instanceof DefaultEndpoint) {
091 DefaultEndpoint defaultEndpoint = (DefaultEndpoint) bean;
092 defaultEndpoint.setEndpointUriIfNotSpecified(beanName);
093 }
094 return bean;
095 }
096
097 // Properties
098 // -------------------------------------------------------------------------
099
100 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
101 this.applicationContext = applicationContext;
102 }
103
104 public CamelContext getCamelContext() {
105 return camelContext;
106 }
107
108 public void setCamelContext(CamelContext camelContext) {
109 this.camelContext = camelContext;
110 postProcessor = new CamelPostProcessorHelper(camelContext) {
111 @Override
112 protected RuntimeException createProxyInstantiationRuntimeException(Class<?> type, Endpoint endpoint, Exception e) {
113 return new BeanInstantiationException(type, "Could not instantiate proxy of type " + type.getName() + " on endpoint " + endpoint, e);
114 }
115 };
116 }
117
118 // Implementation methods
119 // -------------------------------------------------------------------------
120
121 /**
122 * A strategy method to allow implementations to perform some custom JBI
123 * based injection of the POJO
124 *
125 * @param bean the bean to be injected
126 */
127 protected void injectFields(final Object bean) {
128 ReflectionUtils.doWithFields(bean.getClass(), new ReflectionUtils.FieldCallback() {
129 public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
130 EndpointInject annotation = field.getAnnotation(EndpointInject.class);
131 if (annotation != null) {
132 injectField(field, annotation.uri(), annotation.name(), bean);
133 }
134 Produce produce = field.getAnnotation(Produce.class);
135 if (produce != null) {
136 injectField(field, produce.uri(), produce.ref(), bean);
137 }
138 }
139 });
140 }
141
142 protected void injectField(Field field, String endpointUri, String endpointRef, Object bean) {
143 ReflectionUtils.setField(field, bean, getPostProcessor().getInjectionValue(field.getType(), endpointUri, endpointRef, field.getName()));
144 }
145
146 protected void injectMethods(final Object bean) {
147 ReflectionUtils.doWithMethods(bean.getClass(), new ReflectionUtils.MethodCallback() {
148 @SuppressWarnings("unchecked")
149 public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
150 setterInjection(method, bean);
151 getPostProcessor().consumerInjection(method, bean);
152 }
153 });
154 }
155
156 protected void setterInjection(Method method, Object bean) {
157 EndpointInject annoation = method.getAnnotation(EndpointInject.class);
158 if (annoation != null) {
159 setterInjection(method, bean, annoation.uri(), annoation.name());
160 }
161 Produce produce = method.getAnnotation(Produce.class);
162 if (produce != null) {
163 setterInjection(method, bean, produce.uri(), produce.ref());
164 }
165 }
166
167 protected void setterInjection(Method method, Object bean, String endpointUri, String endpointRef) {
168 Class<?>[] parameterTypes = method.getParameterTypes();
169 if (parameterTypes != null) {
170 if (parameterTypes.length != 1) {
171 LOG.warn("Ignoring badly annotated method for injection due to incorrect number of parameters: " + method);
172 } else {
173 String propertyName = ObjectHelper.getPropertyName(method);
174 Object value = getPostProcessor().getInjectionValue(parameterTypes[0], endpointUri, endpointRef, propertyName);
175 ObjectHelper.invokeMethod(method, bean, value);
176 }
177 }
178 }
179
180 public CamelPostProcessorHelper getPostProcessor() {
181 ObjectHelper.notNull(postProcessor, "postProcessor");
182 return postProcessor;
183 }
184 }