在前面的Camel示例中，路由的构建中调用了RouteBuilder的from,to方法，该方法的参数为一个uri字符串。Camel运行是由组件(component)进行组织的，而我们传递的参数为一字符串，所以Camel要根据这个uri字符串来查找到对应的组件，即要维护uri到组件之间的映射关系。
查找组件的过程是调用DefaultCamelContext中的getComponent(String name)方法来完成的，至于该方法什么时候被调用，调用该方法真正目的是什么在后面讲解Camel运行原理时说明，为什么要先要讲清楚组件的查找过程，也是为讲解Camel运行原理做准备的。下面是getComponent(String name)方法源码:
public Component getComponent(String name) {
//调用重载方法
return getComponent(name, autoCreateComponents);
}
public Component getComponent(String name, boolean autoCreateComponents) {
synchronized (components) {
//先根据名称在components这个Map中查找
Component component = components.get(name);
//如果没有找到并且要自动创建组件
if (component == null && autoCreateComponents) {
try {
if (log.isDebugEnabled()) {
log.debug("Using ComponentResolver: {} to resolve component with name: {}", getComponentResolver(), name);
}
//获取组件解析器根据组件名称进行解析，返回组件
component = getComponentResolver().resolveComponent(name, this);
if (component != null) {
addComponent(name, component);
if (isStarted() || isStarting()) {
// 组件返回后，如果是实现了Service接口，则调用startService方法
if (component instanceof Service) {
startService((Service)component);
}
}
}
} catch (Exception e) {
throw new RuntimeCamelException("Cannot auto create component: " + name, e);
}
}
log.trace("getComponent({}) -> {}", name, component);
return component;
}
}
在上面的方法中使用了synchronized关键字，当然这是在进行线程同步，因为CamelContext中可以运行多个路由，而CamelContext的是单例的所以，components这个成员变量就存在多个线程并发访问的问题，加上synchronized关键字就是为了避免重复创建组件。
现在就看resolveComponent方法了，下面是DefaultComponentResolver的resolveComponent方法源码：
public Component resolveComponent(String name, CamelContext context) {
Object bean = null;
try {
//先在注册表中进行查找
bean = context.getRegistry().lookupByName(name);
getLog().debug("Found component: {} in registry: {}", name, bean);
} catch (Exception e) {
getLog().debug("Ignored error looking up bean: " + name, e);
}
if (bean != null) {
if (bean instanceof Component) {//如果在注册表中找到了组件则直接返回
return (Component) bean;
} else {
//如果不是Component类型则尝试进行转化
Component component = CamelContextHelper.convertTo(context, Component.class, bean);
if (component != null) {
return component;
}
}
// we do not throw the exception here and try to auto create a component
}
// not in registry then use component factory
Class<?> type;
try {//注册表中没有找到则调用findComponent方法
type = findComponent(name, context);
if (type == null) {
// not found
return null;
}
} catch (NoFactoryAvailableException e) {
return null;
} catch (Exception e) {
throw new IllegalArgumentException("Invalid URI, no Component registered for scheme: " + name, e);
}
if (getLog().isDebugEnabled()) {
getLog().debug("Found component: {} via type: {} via: {}{}", new Object[]{name, type.getName(), factoryFinder.getResourcePath(), name});
}
//根据获取的组件Class类型，利用反射创建出其实例
if (Component.class.isAssignableFrom(type)) {
return (Component) context.getInjector().newInstance(type);
} else {
throw new IllegalArgumentException("Type is not a Component implementation. Found: " + type.getName());
}
}
在上面的方法中，查找组件的方法就有了两种，一是在注册表中进行查找，找到了并且是Component类型实例则直接返回，如果不是则尝试进行转化；二是调用findComponent方法继续查找。下面是findComponent方法源码：
private Class<?> findComponent(String name, CamelContext context) throws ClassNotFoundException, IOException {
if (factoryFinder == null) {
factoryFinder = context.getFactoryFinder(RESOURCE_PATH);
}
return factoryFinder.findClass(name);
}
首先根据资源路径获取出一个FactoryFinder实例，再调用其findClass方法，其中RESOURCE_PATH为一常量，值为META-INF/services/org/apache/camel/component/
一看，就知道这是要根据在类路径的某一特定路径下的资源进行查找。获取FactoryFinder实例过程很简单就不讲了，FactoryFinder是一接口，返回的真实类型为DefaultFactoryFinder，下面是DefaultFactoryFinder的findClass方法源码：
public Class<?> findClass(String key) throws ClassNotFoundException, IOException {
return findClass(key, null);
}
public Class<?> findClass(String key, String propertyPrefix) throws ClassNotFoundException, IOException {
//参数key就是组件名称,propertyPrefix为null，所以最后prefix就为一空字符串
String prefix = propertyPrefix != null ? propertyPrefix : "";
//重classMap中进行查找
Class<?> clazz = classMap.get(prefix + key);
if (clazz == null) {//没有找到则调用newInstance方法
clazz = newInstance(doFindFactoryProperties(key), prefix);
if (clazz != null) {//放入calssMap中缓存起来
classMap.put(prefix + key, clazz);
}
}
return clazz;
}
newInstance方法需要一个Properties对象，该对象中就旋转了组件名称与组件类型(Calss)的映射关系，下面是doFindFactoryProperties方法源码：
private Properties doFindFactoryProperties(String key) throws IOException {
//path就是获取FactoryFinder时传入的资源路径，即META-INF/services/org/apache/camel/component/
//key就是组件名称
String uri = path + key;
//根据uri把资源流返回，所以就是在类路径META-INF/services/org/apache/camel/component/下的一个名为key的文件(其实就是一properits文件)读取出来
InputStream in = classResolver.loadResourceAsStream(uri);
if (in == null) {
throw new NoFactoryAvailableException(uri);
}
// lets load the file
BufferedInputStream reader = null;
try {
reader = IOHelper.buffered(in);
Properties properties = new Properties();
//文件内容读取properties文件中，包含了组件名称与组件类型映射关系
properties.load(reader);
return properties;
} finally {
IOHelper.close(reader, key, null);
IOHelper.close(in, key, null);
}
}
下面是newInstance方法源码：
private Class<?> newInstance(Properties properties, String propertyPrefix) throws ClassNotFoundException, IOException {
String className = properties.getProperty(propertyPrefix + "class");
if (className == null) {
throw new IOException("Expected property is missing: " + propertyPrefix + "class");
}
Class<?> clazz = classResolver.resolveClass(className);
if (clazz == null) {
throw new ClassNotFoundException(className);
}
return clazz;
}
该方法很简单就是获取key为class的值出来，该值就为组件类型。
根据上述，获取组件实例的途径有两种：
a.在注册表中进行查找
b.从在类路径META-INF/services/org/apache/camel/component/下与组件名称同名的一个properties文件中获取
这两种途径在查找到组件后都会进行缓存，以免重复查找。
至此，根据uri解析出组件名称，再由组件名称获取到组件实例的过程应该就很清楚了，至于查找组件到底有什么作用，在什么时候被调用，下次再讲解。