camel-core/src/main/java/org/apache/camel/impl/DefaultEndpoint.java - camel - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.camel.impl;

 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.net.URI;
 import java.util.Map;

 import org.apache.camel.CamelContext;
 import org.apache.camel.CamelContextAware;
 import org.apache.camel.Component;
 import org.apache.camel.Endpoint;
 import org.apache.camel.EndpointConfiguration;
 import org.apache.camel.EndpointConfiguration.UriFormat;
 import org.apache.camel.Exchange;
 import org.apache.camel.ExchangePattern;
 import org.apache.camel.PollingConsumer;
 import org.apache.camel.RuntimeCamelException;
 import org.apache.camel.spi.HasId;
 import org.apache.camel.support.ServiceSupport;
 import org.apache.camel.util.EndpointHelper;
 import org.apache.camel.util.ObjectHelper;
 import org.apache.camel.util.URISupport;

 /**
  * A default endpoint useful for implementation inheritance.
  * <p/>
  * Components which leverages <a
  * href="http://camel.apache.org/asynchronous-routing-engine.html">asynchronous
  * processing model</a> should check the {@link #isSynchronous()} to determine
  * if asynchronous processing is allowed. The <tt>synchronous</tt> option on the
  * endpoint allows Camel end users to dictate whether they want the asynchronous
  * model or not. The option is default <tt>false</tt> which means asynchronous
  * processing is allowed.
  *
  * @version
  */
 public abstract class DefaultEndpoint extends ServiceSupport implements Endpoint, HasId, CamelContextAware {

     // private String endpointUri;
     private EndpointConfiguration config;
     private CamelContext camelContext;
     private Component component;
     private ExchangePattern exchangePattern = ExchangePattern.InOnly;
     // option to allow end user to dictate whether async processing should be
     // used or not (if possible)
     private boolean synchronous;
     private final String id = EndpointHelper.createEndpointId();

     /**
      * Constructs a fully-initialized DefaultEndpoint instance. This is the
      * preferred method of constructing an object from Java code (as opposed to
      * Spring beans, etc.).
      *
      * @param endpointUri the full URI used to create this endpoint
      * @param component the component that created this endpoint
      */
     protected DefaultEndpoint(String endpointUri, Component component) {
         this.camelContext = component == null ? null : component.getCamelContext();
         this.component = component;
         this.setEndpointUri(endpointUri);
     }

     /**
      * Constructs a DefaultEndpoint instance which has <b>not</b> been created
      * using a {@link Component}.
      * <p/>
      * <b>Note:</b> It is preferred to create endpoints using the associated
      * component.
      *
      * @param endpointUri the full URI used to create this endpoint
      * @param camelContext the Camel Context in which this endpoint is operating
      */
     @Deprecated
     protected DefaultEndpoint(String endpointUri, CamelContext camelContext) {
         this(endpointUri);
         this.camelContext = camelContext;
     }

     /**
      * Constructs a partially-initialized DefaultEndpoint instance.
      * <p/>
      * <b>Note:</b> It is preferred to create endpoints using the associated
      * component.
      *
      * @param endpointUri the full URI used to create this endpoint
      */
     @Deprecated
     protected DefaultEndpoint(String endpointUri) {
         this.setEndpointUri(endpointUri);
     }

     /**
      * Constructs a partially-initialized DefaultEndpoint instance. Useful when
      * creating endpoints manually (e.g., as beans in Spring).
      * <p/>
      * Please note that the endpoint URI must be set through properties (or
      * overriding {@link #createEndpointUri()} if one uses this constructor.
      * <p/>
      * <b>Note:</b> It is preferred to create endpoints using the associated
      * component.
      */
     protected DefaultEndpoint() {
         super();
     }

     public int hashCode() {
         return getEndpointUri().hashCode() * 37 + 1;
     }

     @Override
     public boolean equals(Object object) {
         if (object instanceof DefaultEndpoint) {
             DefaultEndpoint that = (DefaultEndpoint)object;
             return ObjectHelper.equal(this.getEndpointUri(), that.getEndpointUri());
         }
         return false;
     }

     @Override
     public String toString() {
         return String.format("Endpoint[%s]", URISupport.sanitizeUri(getEndpointUri()));
     }

     /**
      * Returns a unique String ID which can be used for aliasing without having
      * to use the whole URI which is not unique
      */
     public String getId() {
         return id;
     }

     public String getEndpointUri() {
         if (config == null) {
             String uri = createEndpointUri();
             if (uri == null) {
                 throw new IllegalArgumentException("endpointUri is not specified and " + getClass().getName()
                     + " does not implement createEndpointUri() to create a default value");
             }
             setEndpointUri(uri);
         }
         return config.toUriString(UriFormat.Canonical);
     }

     public EndpointConfiguration getEndpointConfiguration() {
         return config;
     }

     public String getEndpointKey() {
         if (isLenientProperties()) {
             // only use the endpoint uri without parameters as the properties is
             // lenient
             String uri = getEndpointUri();
             if (uri.indexOf('?') != -1) {
                 return ObjectHelper.before(uri, "?");
             } else {
                 return uri;
             }
         } else {
             // use the full endpoint uri
             return getEndpointUri();
         }
     }

     public CamelContext getCamelContext() {
         return camelContext;
     }

     /**
      * Returns the component that created this endpoint.
      *
      * @return the component that created this endpoint, or <tt>null</tt> if
      *         none set
      */
     public Component getComponent() {
         return component;
     }

     public void setCamelContext(CamelContext camelContext) {
         this.camelContext = camelContext;
     }

     public PollingConsumer createPollingConsumer() throws Exception {
         return new EventDrivenPollingConsumer(this);
     }

     public Exchange createExchange(Exchange exchange) {
         Class<Exchange> exchangeType = getExchangeType();
         if (exchangeType != null) {
             if (exchangeType.isInstance(exchange)) {
                 return exchangeType.cast(exchange);
             }
         }
         return exchange.copy();
     }

     /**
      * Returns the type of the exchange which is generated by this component
      */
     @SuppressWarnings("unchecked")
     public Class<Exchange> getExchangeType() {
         Type type = getClass().getGenericSuperclass();
         if (type instanceof ParameterizedType) {
             ParameterizedType parameterizedType = (ParameterizedType)type;
             Type[] arguments = parameterizedType.getActualTypeArguments();
             if (arguments.length > 0) {
                 Type argumentType = arguments[0];
                 if (argumentType instanceof Class) {
                     return (Class<Exchange>)argumentType;
                 }
             }
         }
         return null;
     }

     public Exchange createExchange() {
         return createExchange(getExchangePattern());
     }

     public Exchange createExchange(ExchangePattern pattern) {
         return new DefaultExchange(this, pattern);
     }

     /**
      * Returns the default exchange pattern to use for createExchange().
      *
      * @see #setExchangePattern(ExchangePattern exchangePattern)
      */
     public ExchangePattern getExchangePattern() {
         return exchangePattern;
     }

     /**
      * Sets the default exchange pattern to use for {@link #createExchange()}.
      * The default value is {@link ExchangePattern#InOnly}
      */
     public void setExchangePattern(ExchangePattern exchangePattern) {
         this.exchangePattern = exchangePattern;
     }

     /**
      * Returns whether synchronous processing should be strictly used.
      *
      * @see #setSynchronous(boolean synchronous)
      */
     public boolean isSynchronous() {
         return synchronous;
     }

     /**
      * Sets whether synchronous processing should be strictly used, or Camel is
      * allowed to use asynchronous processing (if supported).
      *
      * @param synchronous <tt>true</tt> to enforce synchronous processing
      */
     public void setSynchronous(boolean synchronous) {
         this.synchronous = synchronous;
     }

     public void configureProperties(Map<String, Object> options) {
         // do nothing by default
     }

     /**
      * A factory method to lazily create the endpointUri if none is specified
      */
     protected String createEndpointUri() {
         return null;
     }

     /**
      * Sets the endpointUri if it has not been specified yet via some kind of
      * dependency injection mechanism. This allows dependency injection
      * frameworks such as Spring or Guice to set the default endpoint URI in
      * cases where it has not been explicitly configured using the name/context
      * in which an Endpoint is created.
      */
     public void setEndpointUriIfNotSpecified(String value) {
         if (config == null) {
             // FIXME: set the component first
             // ObjectHelper.notNull(camelContext, "camelContext");
             int s = value.indexOf(":");
             if (camelContext != null && s > 0) {
                 component = camelContext.getComponent(value.substring(0, s));
             }
             setEndpointUri(value);
         }
     }

     /**
      * Sets the URI that created this endpoint.
      */
     protected void setEndpointUri(String endpointUri) {
         if (endpointUri == null) {
             config = null;
             return;
         }
         try {
             if (component != null) {
                 config = component.createConfiguration(endpointUri);
             } else {
                 MappedEndpointConfiguration cfg = new MappedEndpointConfiguration(null);
                 cfg.setURI(new URI(endpointUri));
                 config = cfg;
             }
         } catch (Exception e) {
             throw new RuntimeCamelException(e);
         }
     }

     public boolean isLenientProperties() {
         // default should be false for most components
         return false;
     }

     @Override
     protected void doStart() throws Exception {
         // noop
     }

     @Override
     protected void doStop() throws Exception {
         // noop
     }
 }
	/**
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.apache.camel.impl;

	import java.lang.reflect.ParameterizedType;
	import java.lang.reflect.Type;
	import java.net.URI;
	import java.util.Map;

	import org.apache.camel.CamelContext;
	import org.apache.camel.CamelContextAware;
	import org.apache.camel.Component;
	import org.apache.camel.Endpoint;
	import org.apache.camel.EndpointConfiguration;
	import org.apache.camel.EndpointConfiguration.UriFormat;
	import org.apache.camel.Exchange;
	import org.apache.camel.ExchangePattern;
	import org.apache.camel.PollingConsumer;
	import org.apache.camel.RuntimeCamelException;
	import org.apache.camel.spi.HasId;
	import org.apache.camel.support.ServiceSupport;
	import org.apache.camel.util.EndpointHelper;
	import org.apache.camel.util.ObjectHelper;
	import org.apache.camel.util.URISupport;

	/**
	* A default endpoint useful for implementation inheritance.
	* <p/>
	* Components which leverages <a
	* href="http://camel.apache.org/asynchronous-routing-engine.html">asynchronous
	* processing model</a> should check the {@link #isSynchronous()} to determine
	* if asynchronous processing is allowed. The <tt>synchronous</tt> option on the
	* endpoint allows Camel end users to dictate whether they want the asynchronous
	* model or not. The option is default <tt>false</tt> which means asynchronous
	* processing is allowed.
	*
	* @version
	*/
	public abstract class DefaultEndpoint extends ServiceSupport implements Endpoint, HasId, CamelContextAware {

	// private String endpointUri;
	private EndpointConfiguration config;
	private CamelContext camelContext;
	private Component component;
	private ExchangePattern exchangePattern = ExchangePattern.InOnly;
	// option to allow end user to dictate whether async processing should be
	// used or not (if possible)
	private boolean synchronous;
	private final String id = EndpointHelper.createEndpointId();

	/**
	* Constructs a fully-initialized DefaultEndpoint instance. This is the
	* preferred method of constructing an object from Java code (as opposed to
	* Spring beans, etc.).
	*
	* @param endpointUri the full URI used to create this endpoint
	* @param component the component that created this endpoint
	*/
	protected DefaultEndpoint(String endpointUri, Component component) {
	this.camelContext = component == null ? null : component.getCamelContext();
	this.component = component;
	this.setEndpointUri(endpointUri);
	}

	/**
	* Constructs a DefaultEndpoint instance which has <b>not</b> been created
	* using a {@link Component}.
	* <p/>
	* <b>Note:</b> It is preferred to create endpoints using the associated
	* component.
	*
	* @param endpointUri the full URI used to create this endpoint
	* @param camelContext the Camel Context in which this endpoint is operating
	*/
	@Deprecated
	protected DefaultEndpoint(String endpointUri, CamelContext camelContext) {
	this(endpointUri);
	this.camelContext = camelContext;
	}

	/**
	* Constructs a partially-initialized DefaultEndpoint instance.
	* <p/>
	* <b>Note:</b> It is preferred to create endpoints using the associated
	* component.
	*
	* @param endpointUri the full URI used to create this endpoint
	*/
	@Deprecated
	protected DefaultEndpoint(String endpointUri) {
	this.setEndpointUri(endpointUri);
	}

	/**
	* Constructs a partially-initialized DefaultEndpoint instance. Useful when
	* creating endpoints manually (e.g., as beans in Spring).
	* <p/>
	* Please note that the endpoint URI must be set through properties (or
	* overriding {@link #createEndpointUri()} if one uses this constructor.
	* <p/>
	* <b>Note:</b> It is preferred to create endpoints using the associated
	* component.
	*/
	protected DefaultEndpoint() {
	super();
	}

	public int hashCode() {
	return getEndpointUri().hashCode() * 37 + 1;
	}

	@Override
	public boolean equals(Object object) {
	if (object instanceof DefaultEndpoint) {
	DefaultEndpoint that = (DefaultEndpoint)object;
	return ObjectHelper.equal(this.getEndpointUri(), that.getEndpointUri());
	}
	return false;
	}

	@Override
	public String toString() {
	return String.format("Endpoint[%s]", URISupport.sanitizeUri(getEndpointUri()));
	}

	/**
	* Returns a unique String ID which can be used for aliasing without having
	* to use the whole URI which is not unique
	*/
	public String getId() {
	return id;
	}

	public String getEndpointUri() {
	if (config == null) {
	String uri = createEndpointUri();
	if (uri == null) {
	throw new IllegalArgumentException("endpointUri is not specified and " + getClass().getName()
	+ " does not implement createEndpointUri() to create a default value");
	}
	setEndpointUri(uri);
	}
	return config.toUriString(UriFormat.Canonical);
	}

	public EndpointConfiguration getEndpointConfiguration() {
	return config;
	}

	public String getEndpointKey() {
	if (isLenientProperties()) {
	// only use the endpoint uri without parameters as the properties is
	// lenient
	String uri = getEndpointUri();
	if (uri.indexOf('?') != -1) {
	return ObjectHelper.before(uri, "?");
	} else {
	return uri;
	}
	} else {
	// use the full endpoint uri
	return getEndpointUri();
	}
	}

	public CamelContext getCamelContext() {
	return camelContext;
	}

	/**
	* Returns the component that created this endpoint.
	*
	* @return the component that created this endpoint, or <tt>null</tt> if
	* none set
	*/
	public Component getComponent() {
	return component;
	}

	public void setCamelContext(CamelContext camelContext) {
	this.camelContext = camelContext;
	}

	public PollingConsumer createPollingConsumer() throws Exception {
	return new EventDrivenPollingConsumer(this);
	}

	public Exchange createExchange(Exchange exchange) {
	Class<Exchange> exchangeType = getExchangeType();
	if (exchangeType != null) {
	if (exchangeType.isInstance(exchange)) {
	return exchangeType.cast(exchange);
	}
	}
	return exchange.copy();
	}

	/**
	* Returns the type of the exchange which is generated by this component
	*/
	@SuppressWarnings("unchecked")
	public Class<Exchange> getExchangeType() {
	Type type = getClass().getGenericSuperclass();
	if (type instanceof ParameterizedType) {
	ParameterizedType parameterizedType = (ParameterizedType)type;
	Type[] arguments = parameterizedType.getActualTypeArguments();
	if (arguments.length > 0) {
	Type argumentType = arguments[0];
	if (argumentType instanceof Class) {
	return (Class<Exchange>)argumentType;
	}
	}
	}
	return null;
	}

	public Exchange createExchange() {
	return createExchange(getExchangePattern());
	}

	public Exchange createExchange(ExchangePattern pattern) {
	return new DefaultExchange(this, pattern);
	}

	/**
	* Returns the default exchange pattern to use for createExchange().
	*
	* @see #setExchangePattern(ExchangePattern exchangePattern)
	*/
	public ExchangePattern getExchangePattern() {
	return exchangePattern;
	}

	/**
	* Sets the default exchange pattern to use for {@link #createExchange()}.
	* The default value is {@link ExchangePattern#InOnly}
	*/
	public void setExchangePattern(ExchangePattern exchangePattern) {
	this.exchangePattern = exchangePattern;
	}

	/**
	* Returns whether synchronous processing should be strictly used.
	*
	* @see #setSynchronous(boolean synchronous)
	*/
	public boolean isSynchronous() {
	return synchronous;
	}

	/**
	* Sets whether synchronous processing should be strictly used, or Camel is
	* allowed to use asynchronous processing (if supported).
	*
	* @param synchronous <tt>true</tt> to enforce synchronous processing
	*/
	public void setSynchronous(boolean synchronous) {
	this.synchronous = synchronous;
	}

	public void configureProperties(Map<String, Object> options) {
	// do nothing by default
	}

	/**
	* A factory method to lazily create the endpointUri if none is specified
	*/
	protected String createEndpointUri() {
	return null;
	}

	/**
	* Sets the endpointUri if it has not been specified yet via some kind of
	* dependency injection mechanism. This allows dependency injection
	* frameworks such as Spring or Guice to set the default endpoint URI in
	* cases where it has not been explicitly configured using the name/context
	* in which an Endpoint is created.
	*/
	public void setEndpointUriIfNotSpecified(String value) {
	if (config == null) {
	// FIXME: set the component first
	// ObjectHelper.notNull(camelContext, "camelContext");
	int s = value.indexOf(":");
	if (camelContext != null && s > 0) {
	component = camelContext.getComponent(value.substring(0, s));
	}
	setEndpointUri(value);
	}
	}

	/**
	* Sets the URI that created this endpoint.
	*/
	protected void setEndpointUri(String endpointUri) {
	if (endpointUri == null) {
	config = null;
	return;
	}
	try {
	if (component != null) {
	config = component.createConfiguration(endpointUri);
	} else {
	MappedEndpointConfiguration cfg = new MappedEndpointConfiguration(null);
	cfg.setURI(new URI(endpointUri));
	config = cfg;
	}
	} catch (Exception e) {
	throw new RuntimeCamelException(e);
	}
	}

	public boolean isLenientProperties() {
	// default should be false for most components
	return false;
	}

	@Override
	protected void doStart() throws Exception {
	// noop
	}

	@Override
	protected void doStop() throws Exception {
	// noop
	}
	}