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.util; 018 019 import java.util.ArrayList; 020 import java.util.Collection; 021 import java.util.List; 022 023 import org.apache.camel.CamelContext; 024 import org.apache.camel.Endpoint; 025 import org.apache.camel.Exchange; 026 import org.apache.camel.Expression; 027 import org.apache.camel.NoSuchEndpointException; 028 import org.apache.camel.spi.Injector; 029 import org.apache.camel.spi.Language; 030 import org.apache.camel.spi.Registry; 031 032 import static org.apache.camel.util.ObjectHelper.isNotNullAndNonEmpty; 033 import static org.apache.camel.util.ObjectHelper.isNullOrBlank; 034 import static org.apache.camel.util.ObjectHelper.notNull; 035 /** 036 * A number of helper methods 037 * 038 * @version $Revision: 56978 $ 039 */ 040 public final class CamelContextHelper { 041 /** 042 * Utility classes should not have a public constructor. 043 */ 044 private CamelContextHelper() { 045 } 046 047 /** 048 * Returns the mandatory endpoint for the given URI or the 049 * {@link org.apache.camel.NoSuchEndpointException} is thrown 050 */ 051 public static Endpoint getMandatoryEndpoint(CamelContext camelContext, String uri) 052 throws NoSuchEndpointException { 053 Endpoint endpoint = camelContext.getEndpoint(uri); 054 if (endpoint == null) { 055 throw new NoSuchEndpointException(uri); 056 } else { 057 return endpoint; 058 } 059 } 060 061 public static String getEndpointKey(String uri, Endpoint ep) { 062 return ep.isSingleton() ? uri : ("Ox" + Integer.toHexString(ep.hashCode()) + ":" + uri); 063 } 064 065 /** 066 * Returns the mandatory endpoint for the given URI and type or the 067 * {@link org.apache.camel.NoSuchEndpointException} is thrown 068 */ 069 public static <T extends Endpoint> T getMandatoryEndpoint(CamelContext camelContext, String uri, Class<T> type) { 070 Endpoint endpoint = getMandatoryEndpoint(camelContext, uri); 071 return ObjectHelper.cast(type, endpoint); 072 } 073 074 /** 075 * Returns a list of all endpoints of the given type 076 * 077 * @param camelContext the camel context 078 * @param type the type of the endpoints requested 079 * @return a list which may be empty of all the endpoint instances of the 080 * given type 081 */ 082 public <T> List<T> getEndpoints(CamelContext camelContext, Class<T> type) { 083 return getEndpointsImpl(camelContext, type, false); 084 } 085 086 /** 087 * Returns a list of all singleton endpoints of the given type 088 * 089 * @param camelContext the camel context 090 * @param type the type of the endpoints requested 091 * @return a list which may be empty of all the endpoint instances of the 092 * given type 093 */ 094 public static <T> List<T> getSingletonEndpoints(CamelContext camelContext, Class<T> type) { 095 return getEndpointsImpl(camelContext, type, true); 096 } 097 098 /** 099 * Returns a list of all singleton or regular endpoints of the given type 100 */ 101 private static <T> List<T> getEndpointsImpl(CamelContext camelContext, Class<T> type, boolean singleton) { 102 List<T> answer = new ArrayList<T>(); 103 Collection<Endpoint> endpoints = singleton ? camelContext.getSingletonEndpoints() : camelContext.getEndpoints(); 104 for (Endpoint endpoint : endpoints) { 105 if (type.isInstance(endpoint)) { 106 T value = type.cast(endpoint); 107 answer.add(value); 108 } 109 } 110 return answer; 111 } 112 113 /** 114 * Converts the given value to the requested type 115 */ 116 public static <T> T convertTo(CamelContext context, Class<T> type, Object value) { 117 notNull(context, "camelContext"); 118 return context.getTypeConverter().convertTo(type, value); 119 } 120 121 /** 122 * Converts the given value to the specified type throwing an {@link IllegalArgumentException} 123 * if the value could not be converted to a non null value 124 */ 125 public static <T> T mandatoryConvertTo(CamelContext context, Class<T> type, Object value) { 126 T answer = convertTo(context, type, value); 127 if (answer == null) { 128 throw new IllegalArgumentException("Value " + value + " converted to " + type.getName() + " cannot be null"); 129 } 130 return answer; 131 } 132 133 /** 134 * Creates a new instance of the given type using the {@link Injector} on the given 135 * {@link CamelContext} 136 */ 137 public static <T> T newInstance(CamelContext context, Class<T> beanType) { 138 return context.getInjector().newInstance(beanType); 139 } 140 141 /** 142 * Look up the given named bean in the {@link Registry} on the 143 * {@link CamelContext} 144 */ 145 public static Object lookup(CamelContext context, String name) { 146 return context.getRegistry().lookup(name); 147 } 148 149 /** 150 * Look up the given named bean of the given type in the {@link Registry} on the 151 * {@link CamelContext} 152 */ 153 public static <T> T lookup(CamelContext context, String name, Class<T> beanType) { 154 return context.getRegistry().lookup(name, beanType); 155 } 156 157 /** 158 * Look up the given named bean in the {@link Registry} on the 159 * {@link CamelContext} or throws 160 */ 161 public static Object mandatoryLookup(CamelContext context, String name) { 162 Object answer = lookup(context, name); 163 notNull(answer, "registry entry called " + name); 164 return answer; 165 } 166 167 /** 168 * Look up the given named bean of the given type in the {@link Registry} on the 169 * {@link CamelContext} 170 */ 171 public static <T> T mandatoryLookup(CamelContext context, String name, Class<T> beanType) { 172 T answer = lookup(context, name, beanType); 173 notNull(answer, "registry entry called " + name + " of type " + beanType.getName()); 174 return answer; 175 } 176 177 /** 178 * Resolves the given language name into a {@link Language} or throws an exception if it could not be converted 179 */ 180 public static Language resolveMandatoryLanguage(CamelContext camelContext, String languageName) { 181 notNull(camelContext, "camelContext"); 182 notNull(languageName, "languageName"); 183 184 Language language = camelContext.resolveLanguage(languageName); 185 if (language == null) { 186 throw new IllegalArgumentException("Could not resolve language: " + languageName); 187 } 188 return language; 189 } 190 191 /** 192 * Resolves the mandatory language name and expression text into a {@link Expression} instance 193 * throwing an exception if it could not be created 194 */ 195 public static Expression resolveMandatoryExpression(CamelContext camelContext, String languageName, String expressionText) { 196 notNull(expressionText, "expressionText"); 197 198 Language language = resolveMandatoryLanguage(camelContext, languageName); 199 Expression<Exchange> expression = language.createExpression(expressionText); 200 if (expression == null) { 201 throw new IllegalArgumentException("Could not create expression: " + expressionText + " with language: " + language); 202 } 203 return expression; 204 } 205 206 /** 207 * Evaluates the @EndpointInject annotation using the given context 208 */ 209 public static Endpoint getEndpointInjection(CamelContext camelContext, String uri, String name, String injectionPointName, boolean mandatory) { 210 Endpoint endpoint = null; 211 if (isNotNullAndNonEmpty(uri)) { 212 endpoint = camelContext.getEndpoint(uri); 213 } else { 214 if (isNullOrBlank(name)) { 215 name = injectionPointName; 216 } 217 if (mandatory) { 218 endpoint = mandatoryLookup(camelContext, name, Endpoint.class); 219 } else { 220 endpoint = lookup(camelContext, name, Endpoint.class); 221 } 222 } 223 return endpoint; 224 } 225 226 }