码迷,mamicode.com
首页 > 其他好文 > 详细

Camel查找组件方式

时间:2014-09-06 16:10:53      阅读:308      评论:0      收藏:0      [点我收藏+]

标签:camel component 查找

   在前面的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解析出组件名称,再由组件名称获取到组件实例的过程应该就很清楚了,至于查找组件到底有什么作用,在什么时候被调用,下次再讲解。

Camel查找组件方式

标签:camel component 查找

原文地址:http://blog.csdn.net/xtayfjpk/article/details/39100919

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!