围绕EMF探索（3）之初探OCL

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。

 前索引： 围绕EMF探索（1）之存储和查询
 前索引： 围绕EMF探索（2）之再探查询组件

围绕EMF探索（3）之初探OCL

       围绕EMF模型，有个很重要的基础性组件叫 EMF OCL，这是一个实现了OCL2.0标准的组件，提供了对OCL Expression的解析、校验。OCL全称是Object Constraint Language。

 

       对OCL之前接触不是很多。两年前，在MDAChina还存在的时候，见到一些朋友谈论它。但对当时的技术和应用来说，OCL还是过于“理想化”。事实上，直到今天，OCL在国内的应用也是很稀少的。

       如果不是因为探索EMF OCL这个组件的原因，我想我也很难去主动钻研OCL的那有些晦涩的Expression。虽然在UML2中，其已经成为一个用于准确描述模型的关键特性。

 

       其实，使用EMF OCL非常简单，使用QueryFactory构造一个Query对象，设置表达式（Express），以及表达式所依赖的Context（在EMF OCL中，一般是Classifier）。然后对给定eObject对象进行检查和计算。——就这么简单。

 

Query query = QueryFactory.eINSTANCE.createQuery(     "Book.allInstances()->select(b : Book | b <> self and b.title = self.title)",     LibraryPackage.eINSTANCE.getBook()); query.setExtentMap(extents); Collection result = query.evaluate(myBook);

 

       当然，想很熟练的应用EMF OCL，那么就必须会构造正确的Expression。

       所以，不得不花费点时间学习OCL。

 

       OCL的概念和作用就不用在这里啰嗦了，以前的MDAChina那帮爱好者们写了很多有关这方面的文章（可惜mdachina已经不存在），比较典型的就是“MDA之路”那个兄弟写的几篇blog 文章，

http://www.blogjava.net/wxb_nudt/archive/2006/11/29/2188.html 和 http://www.blogjava.net/wxb_nudt/archive/2005/04/04/2858.html 。

 

       对于更精细的了解OCL，可以读读OCL之父Addison Wesley的著作 《Object Constraint Language, The: Getting Your Models Ready for MDA》第二版，可以从下面的地址获取电子书：

http://www.netyi.net/training/4d9e427c-3d58-4f74-b540-ad642c9afccc

       另外，建议大家再看看 《UML2.0参考手册》附录B部分的，这部分内容也是讲OCL的，而且讲了OCL的Basic Type和Syntax。

 

       粗略的把这两本书中一些相关的章节翻了翻，还是很有收获的。当然限于时间问题，只是翻翻而已，留个大概映像，以后慢慢再研究查阅了。

 

       针对OCL，这里简单提几个重点性内容：

 

       OCL是一种语言，而且是一个Query-Only语言，利用OCL所塑造的Expression为模型中的类与类、类方法、类属性做了一层约束。既然是一种语言，那么就具有最基本的两个特性：类型和语法。

       OCL 具有最基本的built-in类型，同时，会将Meta-Model中的所有自定义classifier都认为是类型。针对built-in类型，会有相应的很多逻辑操作相关联，比如“ and, or, xor, not”或者“ *, +, -, /”等等。这方面可以参考，里面有专门的一章节介绍OCL的类型和逻辑操作。

       针对Classifier之类的类型，则存在三个纬度：作用于Classifier的约束；作用于操作（方法）的约束；作用于属性的约束。这三个层面的约束，有不同的语法表达。

Contraints on Classifiers	context Student inv: self.GPA > 2.0
Contraints on Operators	context Course::registerStudent(s : Student) : boolean pre: s.tuitionPaid = true
Contraints on Attributes	context School::tuition : float init: 2500.00

             

       另外，提醒一下。从Eclipse CVS中抓下的ocl plugin project，需要依赖eclipse orbit包中的lpgjavaruntime组件，可以去 http://download.eclipse.org/tools/orbit/downloads/下载，其实就是net.sourceforge.lpg.lpgjavaruntime 包。

 

       先讲讲OCL的小知识吧，今天只顾钻研OCL的基础知识和语法了，还没有来得及研究EMF OCL的源码和结构。简单的扫了几眼，着实比EMF Query复杂很多，看来要花费更多的时间在上面了。