进入正文，本文是尝试分析下Fel的实现原理，以及优缺点和aviator——我自己开源的EL之间的简单比较。

    Fel的实现原理跟Simple EL是类似，都是使用template生成中间代码——也就是普通的java代码，然后利用javac编译成class，最后运行，当然，这个过程都是动 态的。JDK6已经引入了编译API，在此之前的版本可以调用sun的类来编译，因为javac其实就是用java实现的。回到Fel里 面，FelCompiler15就是用 com.sun.tools.javac.Main来编译，而FelCompiler16用标准的javax.tools.JavaCompiler来编译的。

    文法和语法解释这块是使用antlr这个parse generator生成的，这块不多说，有兴趣可以看下antlr，整体一个运行的过程是这样：

    这个思路我在实现aviator之前就想过，但是后来考虑到API需要用的sun独有的类，而且要求classpath必须有tools.jar这个依赖包，就放弃了这个思路，还是采用ASM生成字节码的方式。题外，velocity的优化可以采用这个思路，我们有这么一个项目是这么做的，也准备开源了。

    看看Fel生成的中间代码，例如a+b这样的一个简单的表达式，假设我一开始不知道a和b的类型，编译是这样：

    我稍微改了下FEL的源码，让它打印中间生成的java代码，a+b生成的中间结果为：

     可见，FEL对表达式解析和解释后，利用template生成这么一个普通的java类，而a和b都从context中获取并转化为Object类型，这里没有做任何判断就直接认为a和b是要做字符串相加，然后拼接字符串并返回。

     问题出来了，因为没有在编译的时候传入context（我们这里是null），FEL会将a和b的类型默认都为java.lang.Object，a+b解释为字符串拼接。但是运行的时候，我完全可以传入a和b都为数字，那么结果就非常诡异了：

输出：

    1+3.14的结果，作为字符串拼接就是13.14，而不是我们想要的4.14。如果将表达式换成a*b，就完全运行不了

    这个问题对于Simple EL同样存在，如果没有在编译的时候能确定变量类型，这无法生成正确的中间代码，导致运行时出错，并且有可能造成非常诡异的bug。

    这个问题的本质是因为Fel和Simple EL没有自己的类型系统，他们都是直接使用java的类型的系统，并且必须在编译的时候确定变量类型，才能生成高效和正确的代码，我们可以将它们称为“强类型的EL“。

    现在让我们在编译的时候给a和b加上类型，看看生成的中间代码：

    查看中间代码：

可以看到这次将a和b都强制转为double类型了，做数值相加，结果也正确了：

    Simple EL我没看过代码，这里猜测它的实现也应该是类似的，也应该有同样的问题。

    相比来说，aviator这是一个弱类型的EL，在编译的时候不对变量类型做任何假设，而是在运行时做类型判断和自动转化。过去提过，我给aviator的定位是一个介于EL和script之间的东西，它有自己的类型系统。 例如，3这个数字，在java里可能是long,int,short,byte，而aviator统一为AviatorLong这个类型。为了在这两个类 型之间做适配，就需要做很多的判断和box,unbox操作。这些判断和转化都是运行时进行的，因此aviator没有办法做到Fel这样的高效，但是已 经做到至少跟groovy这样的弱类型脚本语言一个级别，也超过了JXEL这样的纯解释EL，具体可以看这个性能测试。

   强类型还是弱类型，这是一个选择问题，如果你能在运行前就确定变量的类型，那么使用Fel应该可以达到或者接近于原生java执行的效率，但是失去了灵活性；如果你无法确定变量类型，则只能采用弱类型的EL。

   EL涌现的越来越多，这个现象有点类似消息中间件领域，越来越多面向特定领域的轻量级MQ的出现，而不是原来那种大而笨重的通用MQ大行其道，一方面是互 联网应用的发展，需求不是通用系统能够满足的，另一方面我认为也是开发者素质的提高，大家都能造适合自己的轮子。从EL这方面来说，我也认为会有越来越多 特定于领域的，优点和缺点一样鲜明的EL出现，它们包含设计者自己的目标和口味，选择很多，就看取舍。

while true do  # 无限重复

a = "str"        # 以“str”为内容创建字符串，赋值给a

a.concat("ing")  # 为a所指向的对象添加“ing”

p(a)             # 显示“string”

end

每次都重新创建一个"str"对象，内部就是重复创建一个char[],这是相当奢侈，aux.shared就是用于共享char[],

以字面量创建的字符串会共享一个char[],当要发生变化时，将字符串复制到一个非共享的内存中，变化针对这

个新拷贝进行，这就是所谓的“copy-on-write"技术。解释了String的内部构造，貌似还没有介绍String是怎么

实现mutable，我们写一个Ruby扩展测试下，我们想写这样一个Ruby类：

class Test

def test

str="str"

str.concat("ing")

end

end

对应的c语言代码就是：

   rb_define_class函数定义了一个类Test,rb_define_method将t_test方法以test的名称添加到Test类。在

t_test中，通过rb_str_new2每次生成一个RString结构，然后通过rb_str_cat2将str与"ing"连接起来，添加

了一些打印用于跟踪。利用mkmf产生Makefile,写一个extconf.rb

require 'mkmf'

create_makefile("string_hack");

执行ruby extconf.rb，将产生一个Makefile,执行make，生成一个string_hack.so的链接库。扩展写完了，通过

ruby调用：

require 'string_hack"

t=Test.new

(1..3).each{|i| t.test}

输出：

before concat: str:0x40098a40, str.aux.shared:0x3, str.ptr:str

after concat: str:0x40098a40, str.aux.shared:0x8, str.ptr:string

before concat: str:0x40098a2c, str.aux.shared:0x3, str.ptr:str

after concat: str:0x40098a2c, str.aux.shared:0x8, str.ptr:string

before concat: str:0x40098a18, str.aux.shared:0x3, str.ptr:str

after concat: str:0x40098a18, str.aux.shared:0x8, str.ptr:string

从结果可以看出，在str concat之前之后，str指向的位置没有改变，改变的仅仅是str中ptr指向的字符串的值

，看看rb_str_cat2函数的实现就一目了然了：

VALUE rb_str_cat(str, ptr, len)

    VALUE str;

    const char *ptr;

    long len;

{

    if (len < 0) {

        rb_raise(rb_eArgError, "negative string size (or size too big)");

    }

    if (FL_TEST(str, STR_ASSOC)) {

        rb_str_modify(str);

        REALLOC_N(RSTRING(str)->ptr, char, RSTRING(str)->len+len);

        memcpy(RSTRING(str)->ptr + RSTRING(str)->len, ptr, len);

        RSTRING(str)->len += len;

        RSTRING(str)->ptr[RSTRING(str)->len] = '"0'; /* sentinel */

        return str;

    }

    return rb_str_buf_cat(str, ptr, len);

}

VALUE rb_str_cat2(str, ptr)

    VALUE str;

    const char *ptr;

{

    return rb_str_cat(str, ptr, strlen(ptr));

}

//string.c