研究DSL 时发现这篇文章不错，顺手翻译了一下。原文地址 A Groovy DSL from scratch in 2 hours
今天是我的幸运日,我在Dzone发现了 Architecture Rules。这是一个对 Jdepend 进行抽象的一个有趣的小框架。
Architecture Rules 有它自己的Xml Schema定义，
<architecture>
<configuration>
<sourcesno-packages="exception">
<sourcenot-found="exception">spring.jar</source>
</sources>
<cyclicaldependencytest="true"/>
</configuration>
<rules>
<ruleid="beans-web">
<comment>
org.springframework.beans.factory cannot depend on
org.springframework.web
</comment>
<packages>
<package>org.springframework.beans.factory</package>
</packages>
<violations>
<violation>org.springframework.web</violation>
</violations>
</rule>
<ruleid="must-fail">
<comment>
org.springframework.orm.hibernate3 cannot depend on
org.springframework.core.io
</comment>
<packages>
<package>org.springframework.orm.hibernate3</package>
</packages>
<violations>
<violation>org.springframework.core.io</violation>
</violations>
</rule>
</rules>
</architecture>
基于configuration API ，两个小时内我就写出了自己的DSL
architecture {
// cyclic dependency check enabled bydefault
jar "spring.jar"
rules {
"beans-web" {
comment ="org.springframework.beans.factory cannot depend onorg.springframework.web"
'package'"org.springframework.beans"
violation"org.springframework.web"
}
"must-fail" {
comment ="org.springframework.orm.hibernate3 cannot depend onorg.springframework.core.io"
'package'"org.springframework.orm.hibernate3"
violation"org.springframework.core.io"
}
}
}
现在我开始说明我是如何构造这个DSL的，这样你也可以学会如何编写你自己的DSL.
这个DSL和其他基于Groovy的DSL一样使用了Builder 语法：方法调用使用一个闭包作为参数。闭包既可以看做一个函数，也可以看做一个对象。你可以像函数一样执行它，也可以像对象方法调用或属性设置的方式执行它。
为了支持这种 builder 语法，你需要写一个方法，该方法使用 groovy.lang.Closure 作为最后一个参数。
//builder 语法示例
someMethod {
}
//一个如下签名的方法将会被调用
// 返回值可以是 void 或者是 object，由你自己决定
voidsomeMethod(Closure cl) {
// do some other work
cl() // call Closure object
}
下面第一步就是就是创建一个类用来执行DSL配置文件。我将类名取做 GroovyArchitecture
classGroovyArchitecture {
static void main(String[] args) {
runArchitectureRules(newFile("architecture.groovy"))
}
static void runArchitectureRules(File dsl){
Script dslScript = newGroovyShell().parse(dsl.text)
}
}
GroovyArchitecture 类会校验 DSL 文件并生成一个 groovy.lang.Script 对象。如果这个类启动并执行 main 方法，它就会读取当前目录的 architecture. groovy 文件。
现在我们有了一个代码骨架，我们可以继续添加被DSL调用的第一个方法，architecture()
第一个方法的实现是最容易出错的，因为这个方法是在脚本执行时由脚本对象(Sctipt)调用。显然这个对象并没有一个architecture()方法，但Groovy提供了通过 MOP 和Meta-Object 协议的方式动态添加方法。
一个很简单的技术用文字描述起来却非常困难。每一个Groovy对象都有一个MetaClass对象，它负责处理所有向这个Groovy发起的方法调用。 我们所需要做的就是创建一个定制的MetaClass并且赋予这个脚本对象。
classGroovyArchitecture {
static void main(String[] args) {
runArchitectureRules(newFile("architecture.groovy"))
}
static void runArchitectureRules(File dsl){
Script dslScript = newGroovyShell().parse(dsl.text)
dslScript.metaClass =createEMC(dslScript.class, {
ExpandoMetaClass emc ->
})
dslScript.run()
}
static ExpandoMetaClass createEMC(Classclazz, Closure cl) {
ExpandoMetaClass emc = newExpandoMetaClass(clazz, false)
cl(emc)
emc.initialize()
return emc
}
}
我们一步步的分析一下这段代码。我们添加了一个 createEMC方法，它有一个参数是一个闭包。createEMC创建了一个groovy.lang.ExpandoMetaClass 对象，初始化并返回这个对象。ExpandoMetaClass对象实例初始化之前还被传递给了闭包。
这个闭包被当做一个回调函数，用来定制这个ExpandoMetaClass，同时隐藏它被创建和配置的细节。CreateEMC的返回值被赋予了DSLScript Object 的metaClass属性。
我们也调用了。DSLScript Object 的 run()方法，启动脚本的执行。
Groovy 1.1 之后开始有了 ExpandoMetaClass 类型，通过它我们可以按照 Meat-Object协议向一个对象动态添加新的方法。换句话说，通过向一个对象的metaClass属性赋值一个新的ExpandoMetaClass实例，我们可以给这个对象添加任何我们想要的方法。
现在的问题是，如何添加方法？我们需要配置 ExpandoMetaClass 对象。
classGroovyArchitecture {
static void main(String[] args) {
runArchitectureRules(newFile("architecture.groovy"))
}
static void runArchitectureRules(File dsl){
Script dslScript = newGroovyShell().parse(dsl.text)
dslScript.metaClass =createEMC(dslScript.class, {
ExpandoMetaClass emc ->
emc.architecture = {
Closure cl ->
}
})
dslScript.run()
}
static ExpandoMetaClass createEMC(Classclazz, Closure cl) {
ExpandoMetaClass emc = newExpandoMetaClass(clazz, false)
cl(emc)
emc.initialize()
return emc
}
}
我们给ExpandoMeatClass 对象的architecture属性赋予了一个闭包。这个闭包实现了 architecture() 方法，也会接受一样的参数。通过对 architecture 属性赋值，我们就将这个方法加入了DSL 脚本对象，方法原型就是:archutecture(Closure)
这样，我们就可以正确的执行 如下的 DSL 脚本。
// architecture.groovyfile
architecture {
}
下一步就开始加入 Acthitecture 规则类。
importcom.seventytwomiles.architecturerules.configuration.Configuration
importcom.seventytwomiles.architecturerules.services.CyclicRedundancyServiceImpl
importcom.seventytwomiles.architecturerules.services.RulesServiceImpl
classGroovyArchitecture {
static void main(String[] args) {
runArchitectureRules(newFile("architecture.groovy"))
}
static void runArchitectureRules(File dsl){
Script dslScript = newGroovyShell().parse(dsl.text)
Configuration configuration = newConfiguration()
configuration.doCyclicDependencyTest =true
configuration.throwExceptionWhenNoPackages = true
dslScript.metaClass =createEMC(dslScript.class, {
ExpandoMetaClass emc ->
emc.architecture = {
Closure cl ->
}
})
dslScript.run()
newCyclicRedundancyServiceImpl(configuration)
.performCyclicRedundancyCheck()
newRulesServiceImpl(configuration).performRulesTest()
}
static ExpandoMetaClass createEMC(Classclazz, Closure cl) {
ExpandoMetaClass emc = newExpandoMetaClass(clazz, false)
cl(emc)
emc.initialize()
return emc
}
}
Configuration 类为 Architecture Rule 框架设置配置信息，我们使用了两个缺省的值。
下一步是执行脚本中指定jar文件本地位置的动作，我们希望 DSL 脚本类似下面的代码：
//architecture.groovy file
architecture {
classes "target/classes"
jar "myLibrary.jar"
}
添加这两个方法更简单，因为我们不需要再通过 ExpandoMetaClass ，而是设置一个委托(delegate)到闭包对象，也就是architecture()方法执行时做为参数传递进去的那个闭包。
设置委托对象之前，我们还要先创建一个新的类型，ArchitectureDelegate. 对闭包中任何方法或属性的调用都会被 ArchitectureDelegate对象收到，它会提供两个方法 ：classes(String) and jar(String).
importcom.seventytwomiles.architecturerules.configuration.Configuration
classArchitectureDelegate {
private Configuration configuration
ArchitectureDelegate(Configurationconfiguration) {
this.configuration = configuration
}
void classes(String name) {
this.configuration.addSource newSourceDirectory(name, true)
}
void jar(String name) {
classes name
}
}
可以看到，classes() 和 jar() 都是 ArchitectureDelegate 类实际的方法。下一步就是把这个委托类的实例设置到对应的闭包。
importcom.seventytwomiles.architecturerules.configuration.Configuration
importcom.seventytwomiles.architecturerules.services.CyclicRedundancyServiceImpl
importcom.seventytwomiles.architecturerules.services.RulesServiceImpl
classGroovyArchitecture {
static void main(String[] args) {
runArchitectureRules(newFile("architecture.groovy"))
}
static void runArchitectureRules(File dsl){
Script dslScript = newGroovyShell().parse(dsl.text)
Configuration configuration = newConfiguration()
configuration.doCyclicDependencyTest =true
configuration.throwExceptionWhenNoPackages = true
dslScript.metaClass =createEMC(dslScript.class, {
ExpandoMetaClass emc ->
emc.architecture = {
Closure cl ->
cl.delegate = newArchitectureDelegate(configuration)
cl.resolveStrategy =Closure.DELEGATE_FIRST
cl()
}
})
dslScript.run()
newCyclicRedundancyServiceImpl(configuration)
.performCyclicRedundancyCheck()
newRulesServiceImpl(configuration).performRulesTest()
}
static ExpandoMetaClass createEMC(Classclazz, Closure cl) {
ExpandoMetaClass emc = newExpandoMetaClass(clazz, false)
cl(emc)
emc.initialize()
return emc
}
}
Closure 类型的 delegate 属性接受 ArchitectureDelegate 对象。
The resolveStrategy property 设置为 Closure.DELEGATE_FIRST . 其含义就是让方法和属性的调用被委托到 ArchitectureDelegate 对象。
现在可以为 DSL 增加 rules() 方法：
//architecture.groovy file
architecture {
classes "target/classes"
jar "myLibrary.jar"
rules {
}
}
这个方法应该加到哪里呢？加到 ArchitectureDelegate 中。
importcom.seventytwomiles.architecturerules.configuration.Configuration
classArchitectureDelegate {
private Configuration configuration
ArchitectureDelegate(Configurationconfiguration) {
this.configuration = configuration
}
void classes(String name) {
this.configuration.addSource newSourceDirectory(name, true)
}
void jar(String name) {
classes name
}
void rules(Closure cl) {
cl.delegate = newRulesDelegate(configuration)
cl.resolveStrategy =Closure.DELEGATE_FIRST
cl()
}
}
后面的事情一样画葫芦就可以了。
扫一扫
8746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
