Apache Camel源码研究之Language

朴灿烈づ我的快乐病毒、 2023-06-24 15:26 21阅读 0赞

> Apache Camel通过`Language`将`Expression`和`Predicate`的构造操作合并在一起，减少了概念，也降低了扩展难度，是的整体架构更加清晰。

### 1. 概述 ###

Apache Camel为了更好地实现EIP，在架构设计层面**抽象出了`Language`的概念来充当`Expression`和`Predicate`的工厂**。而对于后两者，Camel内置了多种实现，并且留出了足够的扩展以满足使用者的自定义需求，本文我们将较为深入地研究Apache Camel在这方面的努力，以便未来更加自如地面对可能的业务需求。

### 2. 源码解读 ###

本次的用例如下：

@Test
    public void transform() throws Exception { 
    	CamelTestUtil.defaultPrepareTest2(new RouteBuilder() { 
    
    		@Override
    		public void configure() throws Exception { 
    			from("stream:in?promptMessage=Enter something:")// 
    					.transform().constant("fulizhe") // 
    					.to("stream:err");//
    		}
    	});
    }

为了尽量减少外部变量以专注本次的主题，我们选择了最为简单的`ConstantLanguage`，最终效果是不论我们输入任何内容，最终打印到控制台上的都是"fulizhe"。

以上用例启动时候得到如下堆栈：  
![堆栈图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xxemtjeDM_size_16_color_FFFFFF_t_70]  
综合前几篇博客的分析，从以上堆栈图中我们可以得出如下结论：

1.  路由配置时候的`transform()`会导致`TransformDefinition`实例的构建，而该实例类型间接继承自`ProcessorDefinition<T>`，于是就有了上面截图中的`createProcessor(RouteContext routeContext)`方法的回调。
2.  `createProcessor(RouteContext routeContext)`方法的调用最终将构建出`TransformProcessor`实例介入到Camel Route的执行链条中，关于这一点之前的博客也已经论述过了。
3.  观察上一步中提到的`TransformProcessor`实例在Camel Route逻辑链条中的执行，首当其冲的就是对`Expression.evaluate(Exchange exchange, Class<T> type)`回调，Apache Camel会将得到的值根据当前Exchange的MEP（Message Exchange Pattern）设置到对应Message的Body中。

在得出以上结论之后，现在的问题就成了**Camel是如何找到相应Expression的实现类的**？追寻这个问题的答案，我们找到了`ExpressionDefinition.createExpression()`方法：

1.  首先我们来看看这个`ExpressionDefinition`类。我们意外地发现该类直接实现了接口 `Expression`, `Predicate`。相较于我们之前研究的`ProcessorDefinition<T>`只用于初始化操作，`ExpressionDefinition`类同时还承担了运行时`Expression`, `Predicate`对内的统一门面，也就是说，Apache Camel提供的`Expression`, `Predicate`能力，是通过继承自该类来完成的，这一点从以下继承链可见一斑。  
    ![ExpressionDefinition继承链][ExpressionDefinition]  
    从以上继承链中，我们不仅可以看到耳熟能详的constant（对应`ConstantExpression`），simple（对应`SimpleExpression`），method（对应`MethodCallExpression`/`BeanExpression`）之外，还有其他多达十余种实现。正所谓的"总有一款适合你！"
2.  遵循本文最开始的用例，我们将目光集中到`ConstantExpression`类上，再结合下面贴出的`ExpressionDefinition.createExpression()`方法实现，应该可以对于问题获得一个较为清晰的答案：
    
        // ExpressionDefinition.createExpression()
        public Expression createExpression(CamelContext camelContext) { 
            if (getExpressionValue() == null) { 
                if (getExpressionType() != null) { 
                    setExpressionValue(getExpressionType().createExpression(camelContext));
                } else if (getExpression() != null) { 
                	// 初次进入, 都会走这里
                    ObjectHelper.notNull("language", getLanguage());
                    // 核心, 其中的检索逻辑正是Language强大扩展性的来源, 也正式将Language和Expression关联上了; 
                    // 而这其中的检索逻辑正是依赖于CamelContext.resolveLanguage(String language)的实现, 具体分析参见下方
                    // 而这里的getLanguage()方法正是检索的关键, 子类就是通过覆写该方法来达到自定义实现类的目的的. 例如ConstantExpression覆盖返回的就是 constant 。
                    Language language = camelContext.resolveLanguage(getLanguage());
                    if (language == null) { 
                        throw new NoSuchLanguageException(getLanguage());
                    }
                    String exp = getExpression();
                    // should be true by default
                    boolean isTrim = getTrim() == null || getTrim();
                    // trim if configured to trim
                    if (exp != null && isTrim) { 
                        exp = exp.trim();
                    }
                    // 这一步说明了, 我们可以使用外置的配置文件来存放我们的expression, 格式如下:
                    // 1. resource:file:nameOfFile
                    // 2. resource:classpath:nameOfFile
                    // 3. resource:http:uri
                    // resolve the expression as it may be an external script from the classpath/file etc
                    exp = ResourceHelper.resolveOptionalExternalScript(camelContext, exp);
        
        			// 在本例中就是回调ConstantLanguage实现自接口Language的createExpression(String expression)方法
                    setExpressionValue(language.createExpression(exp));
                    // 此处提供了 AfterPropertiesConfigured 接口实现的回调, Expression的实现类(正如上面所论述的, 一般都是ExpressionDefinition)可以通过实现该接口来完成更多的配置
                    configureExpression(camelContext, getExpressionValue());
                }
            }
            return getExpressionValue();
        }

通过以上分析，现在最后的疑问就是Language实现类的检索了，追寻堆栈，我们最终找到了`DefaultCamelContext`类。

// DefaultCamelContext.resolveLanguage()
     public Language resolveLanguage(String language) { 
         Language answer;
         synchronized (languages) { 
             answer = languages.get(language);
    
             // check if the language is singleton, if so return the shared instance
             if (answer instanceof IsSingleton) { 
                 boolean singleton = ((IsSingleton) answer).isSingleton();
                 if (singleton) { 
                     return answer;
                 }
             }
    
    		 // 核心, 这里正是决定从何处检索相应的Language实现的关键
    		 // 默认的实现者是DefaultLanguageResolver
    		 // 其会在 META-INF/services/org/apache/camel/language/ 下查找相应文件中注册的Language实现类
    		 // 另外一个关于 META-INF/services/org/apache/camel/language/resolver/ 目录就交给读者自己去探索了
             // language not known or not singleton, then use resolver
             answer = getLanguageResolver().resolveLanguage(language, this);
    
             // inject CamelContext if aware
             if (answer != null) { 
                 if (answer instanceof CamelContextAware) { 
                     ((CamelContextAware) answer).setCamelContext(this);
                 }
                 if (answer instanceof Service) { 
                     try { 
                         startService((Service) answer);
                     } catch (Exception e) { 
                         throw ObjectHelper.wrapRuntimeCamelException(e);
                     }
                 }
    
                 languages.put(language, answer);
             }
         }
    
         return answer;
     }

通过以上源码，我们可以得出结论：

1.  Apache Camel在检索相应`Expressison`实现类的时候，会从`META-INF/services/org/apache/camel/language/`下查找相应文件。
2.  而这个文件名正是由继承自`ExpressionDefinition`类的子类，通过覆写基类的`getLanguage()`方法来提供的。例如`ConstantExpression.getLanguage()`返回的`constant`字符串。
3.  遵循以上分析，我们可以在camel-core-xxx.jar找到如下内容：  
    ![language扩展][language]
4.  可以看出，camel-core提供了有限个数的expression实现，其他诸如Groovy，JavaScript，SpEL等等都只是提供了相应的契约，而并没有将实现也硬编码在camel-core内部，毕竟这将引入过多的依赖，得不偿失。而我们在使用相关的expression扩展的时候，就需要引入对应的依赖了。例如使用xquery（`XQueryExpression`）时所对应的camel-saxon。  
    ![camel-saxon][]

### 3. 自定义扩展 ###

看到了Apache Camel提供如此多的扩展，肯定有不少小伙伴跃跃欲试想要自己实现一个来玩玩，这对于增加对Apache Camel了解都是大有裨益的。而对于这一块，Apache Camel作为一个极其活跃的社区，当然也是最大化地降低了这方面的门槛 —— 这就是`LanguageExpression`。

通过`LanguageExpression`，只需要简单地几步就能实现自己的Language并无缝并入到Camel的执行链条中。

// 定义ExpressionDefinition子类
    public class LqExpression extends ExpressionDefinition { 
    	public LqExpression() { 
    	}
    
    	public LqExpression(String expression) { 
    		super(expression);
    	}
    
    	public String getLanguage() { 
    		return "lq";
    	}
    }
    
    // 定义Language实现类
    public class LqLanguage extends LanguageSupport implements Language { 
    
    	@Override
    	public Expression createExpression(String expression) { 
    		// 这里直接借用了Camel内置的 simple expression
    		return SimpleBuilder.simple(expression);
    	}
    
    	@Override
    	public Predicate createPredicate(String expression) { 
    		return ExpressionToPredicateAdapter.toPredicate(createExpression(expression));
    	}
    }
    
    // 注册
    1. 创建 META-INF/services/org/apache/camel/language/lq 文件
    2. 以上文件中填入: class=x.y.z.language.LqLanguage
    
    
    // 测试用例
    CamelTestUtil.defaultPrepareTest2(new RouteBuilder() { 
    
    	@Override
    	public void configure() throws Exception { 
    		from("stream:in?promptMessage=Enter something:")//
    				.routeId("customLanuage")// 
    				.transform().language("lq", "${body.length}") //
    				//.transform().language("simple", "${body.length}") //
    			    //.filter("lq", "${body.length} > 3")//
    			    //.setBody(language("lq", "${body.length}")
    				.to("stream:err");//
    	}
    });

### 4. 总结 ###

以本文研究的constant为例：

1.  `ConstantExpression`。`ConstantExpression`(继承自`ExpressionDefinition`, 间接实现`Expression`, `Predicate`) ，其提供给`DefaultCamelContext`检索相应`Language`实现类的线索，也就是覆写自基类的`getLanguage()`方法所返回的"constant"，其指向的是 `META-INF/services/org/apache/camel/language/constant`文件。
2.  `ConstantLanguage`。而在上述 `META-INF/services/org/apache/camel/language/constant`文件中所记录的正是 `ConstantLanguage`类，该类直接实现`Language`接口, 进而提供真正的`Expression`, `Predicate`实现类。

### 5. Links ###

1.  《Camel In Action》 P461
2.  《Apache Camel Developer’s Cookbook》P109
3.  [Languages - Office Site][]
4.  [Expression - Office Site][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xxemtjeDM_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020010122361988.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xxemtjeDM=,size_16,color_FFFFFF,t_70
[ExpressionDefinition]: https://img-blog.csdnimg.cn/20200101232133159.png
[language]: https://img-blog.csdnimg.cn/20200102001436828.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xxemtjeDM=,size_16,color_FFFFFF,t_70
[camel-saxon]: https://img-blog.csdnimg.cn/20200102001851970.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xxemtjeDM=,size_16,color_FFFFFF,t_70
[Languages - Office Site]: https://camel.apache.org/manual/latest/languages.html
[Expression - Office Site]: https://camel.apache.org/manual/latest/expression.html