什么是DSL？
领域特定语言，针对一个特定的领域，具有受限表达性的一种计算机程序语言。可以看做是一种抽象处理的方式。
具有四个元素，第一个是计算机程序设计语言，使用DSL来指挥计算机做事情，语言性（一种特定的语言），受限的表达性，并不像同通用的设计语言那样具有广泛的能力，针对一个明确的领域。
分类有哪些？
外部DSL：不同于应用系统主要使用语言的语言，通常采用自定义语法，宿主应用的代码采用文本解析技术对外部DSL编写的脚本进行解析。例子如：正则表达式、SQL、AWK以及Struts的配置文件等
内部DSL：通用语言的特定语法，用内部DSL写成的脚本是一段合法的程序，但是它具有特定的风格，而且仅仅用到了语言的一部分特性，用于处理整个系统一个小方面的问题；
语言工作台：一种专用的IDE，用于定义和构建DSL，具体的讲，语言工作台不仅用来确定DSL的语言结构，而且是人们编写DSL脚本的编辑环境，最终的脚本讲编辑环境和语言本身紧密的结合在一起；
为什么需要DSL？
1、提高开发效率，通过DSL来抽象构建模型，抽取公共的代码，减少重复的劳动；
2、和领域专家沟通，领域专家可以通过DSL来构建系统的功能；
3、执行环境的改变，可以弥补宿主语言的局限性；
DSL的处理可能包含那几个步骤？
1、DSL脚本；
2、解析脚本；
3、语义模型；
4、生成代码或者执行模型；
为啥groovy能比较好的构建DSL？
1、不需要class文件，可以直接执行脚本；
2、闭包等特性以及语法的简介，使用非常灵活；
3、可以和java系统无缝的整合；
4、Groovy自身不是 DSL。 Groovy官方已经发布了较多基于 Groovy书写的 DSL，比如 GANT， GORM， XMLBuilder， HtmlBuilder等等；
使用groovy做DSL的例子？
1、一个自定义的dsl，例如这个：
ParseDsl.make {
to "Nirav Assar"
from "Barack Obama"
body "How are things? We are doing well. Take care"
idea "The economy is key"
request "Please vote for me"
xml
}2、那必须要有地方解析这个规则：
//groovy methodMissing如果找不到方法，就会调用这个方法 里面用到了这个特性
import groovy.xml.MarkupBuilder;
/**
* 解析一个自定义的DSL文本的类，类似解析规则
*/
class ParseDsl {
String toText
String fromText
String body
def sections = []
def static make(closure) {
ParseDsl memoDsl = new ParseDsl()
closure.delegate = memoDsl
closure()
}
def to(String toText) {
this.toText = toText
}
def from(String fromText) {
this.fromText = fromText
}
def body(String bodyText) {
this.body = bodyText
}
def methodMissing(String methodName, args) {
def section = new Section(title: methodName, body: args[0])
sections << section
}
def getXml() {
doXml(this)
}
def getHtml() {
doHtml(this)
}
def getText() {
doText(this)
}
private static doXml(ParseDsl memoDsl) {
def writer = new StringWriter()
def xml = new MarkupBuilder(writer)
xml.memo() {
to(memoDsl.toText)
from(memoDsl.fromText)
body(memoDsl.body)
for (s in memoDsl.sections) {
"$s.title"(s.body)
}
}
println writer
}
private static doHtml(ParseDsl memoDsl) {
def writer = new StringWriter()
def xml = new MarkupBuilder(writer)
xml.html() {
head {
title("Memo")
}
body {
h1("Memo")
h3("To: ${memoDsl.toText}")
h3("From: ${memoDsl.fromText}")
p(memoDsl.body)
for (s in memoDsl.sections) {
p {
b(s.title.toUpperCase())
}
p(s.body)
}
}
}
println writer
}
private static doText(ParseDsl memoDsl) {
String template = "Memo\nTo: ${memoDsl.toText}\nFrom: ${memoDsl.fromText}\n${memoDsl.body}\n"
def sectionStrings =""
for (s in memoDsl.sections) {
sectionStrings += s.title.toUpperCase() + "\n" + s.body + "\n"
}
template += sectionStrings
println template
}
}关于groovy中的闭包？
http://docs.codehaus.org/pages/viewpage.action?pageId=167477326
groovy中的闭包是一个匿名的代码块，可以接受参数，并返回一个返回值，也可以引用和使用在他周围的，可见域中定义的变量。Groovy 之所以包含闭包，是因为它可以让开发者写出更简约、更易懂的代码。Java 开发者通常用一个单方法的接口（Runable，采用Command设计模式），并结合匿名内部类来实现；而Groovy 则允许以一种更简易、直白的方式来实现。额外的，相较匿名内部类，闭包有很少量的约束，包括一些额外的功能。
例子代码：
//第一个例子
def shout = {src->
return src.toUpperCase()
}
println shout("Hello World")
//模拟一个for循环的例子,在List的循环中添加Closure
def names = ["alibaba-inc.com","bixiao.zy","hello world","iamzhongyong"]
printInfo = {
println "hello,${it},welcome"
}
names.each printInfo
//Colsure作为方法的入参
def closureMethod(Closure c) {
c.call("iamzhongyong")
}
closureMethod { name->
println "Closure called "+name
}
//为参数提供默认值
greetString = { greet,name = "iamzhongyong" ->
return "${greet},${name}"
}
assert greetString("welcome") == "welcome,iamzhongyong"
assert greetString("hello","bixiao.zy") == "hello,bixiao.zy"
//使用闭包实现单方法接口
interface Test {
def one()
}
def test = {println 'one'} as Test
test.one()
//使用闭包实现多方法接口
interface Test {
def one()
def two()
}
def test = [
one: {println 'one'},
two: {println 'two'}
] as Test
test.one()
test.two()lambda和闭包（closure）的区别是什么
lambda就是匿名函数——即没有名字的函数。前面你已经看到过一些例子了。闭包就是封闭在其定义所处环境的任意函数。
http://lggege.iteye.com/blog/543730
http://docs.codehaus.org/pages/viewpage.action?pageId=167477326
http://groovy.codehaus.org/Builders
http://confluence.jetbrains.com/display/GRVY/Scripting+IDE+for+DSL+awareness