标签：Hero name Power level Simple each new Heroes Super

2 A Simple Tutorial with Super Heroes

本章将循序渐进地介绍 Voyage（对象到文档映射器）提供的各种可能性。我们将使用一个简单但并不简约的领域：超级英雄、技能及其装备。您将学习如何保存和检索对象。

2.1 创建连接

安装好 MongoBD 后，我们就可以开始连接数据库了，如下所示：

| repository |
repository := VOMongoRepository 
		host: 'localhost' 
		database: 'superHeroes'.
repository enableSingleton.

如果没有连接到数据库，可以使用内存存储库（用于应用程序原型开发）。

| repository |
repository := VOMemoryRepository new. 
repository enableSingleton

通过这个方法，你可以像连接真实的数据库一样工作，以后在开发过程中可以透明地切换模式。

通常，我们定义一个方法来建立资源库。例如，我们可以在稍后的 Hero 类中添加一个类方法。

Hero class >> setUpConnection
	| repository |
	repository := VOMongoRepository 
		host: 'localhost' 
		database: 'superHeroes'.
	repository enableSingleton.

2.2 SuperHeroes

现在，我们可以定义域的第一个版本。下图显示了我们将在本教程中使用的模型。

2.3 英雄

我们来定义Hero类

Object subclass: #Hero
  instanceVariableNames: 'name level powers'
  classVariableNames: ''
  package: 'SuperHeroes'

Hero >> name
    ^ name
    
Hero >> name: aString
    name := aString
    
Hero >> level
    ^ level
    
Hero >> level: anObject
    level := anObject
    
Hero >> powers
    ^ powers ifNil: [ powers := Set new ]
    
Hero >> addPower: aPower
    self powers add: aPower

2.4 技能

我们来定义Power类

Object subclass: #Power
  instanceVariableNames: 'name'
  classVairableNames: ''
  package: 'SuperHeroes'

Power >> name
    ^ name
    
Power >> name: aString
    name := aString

添加printOn:，以改进超级英雄的导航和调试的方法。

2.5 根类

现在，我们必须决定要保存和查询的对象是什么。为此，我们应声明要保存的对象图的根。根可以是系统中的任何类。声明根的方法是在我们所要保存的对象的类侧实现类方法 isVoyageRoot。我们稍后会看到定义根的意义。现在，我们只需将 Hero 定义为根。

Hero class >> isVoyageRoot 
   ^ true

我们就可以创建一些超级英雄，然后把他们保存在数据库中。

Hero new
   name: 'Spiderman';
   level: #epic;
   addPower: (Power new name: 'Super-strength');
   addPower: (Power new name: 'Wall-climbing');
   addPower: (Power new name: 'Spider instinct');
   save.
Hero new
   name: 'Wolverine';
   level: #epic;
   addPower: (Power new name: 'Regeneration');
   addPower: (Power new name: 'Adamantium claws');
   save.

2.6 检查MongoDB

我们可以直接在数据库中查看对象的保存情况。

> show dbs
local        0.078GB
superHeroes  0.078GB

> use superHeroes
switched to db superHeroes

> show collections
Hero

现在我们可以看到超级英雄实际上是如何存储的。db.Hero.find()[0] 获取集合中的第一个对象。

> db.Hero.find()[0]
{
	"_id" : ObjectId("d847065c56d0ad09b4000001"),
	"#version" : 688076276,
	"#instanceOf" : "Hero",
	"level" : "epic",
	"name" : "Spiderman",
	"powers" : [
		{
			"#instanceOf" : "Power",
			"name" : "Spider instinct"
		},
		{
			"#instanceOf" : "Power",
			"name" : "Super-strength"
		},
		{
			"#instanceOf" : "Power",
			"name" : "Wall-climbing"
		}
	]
}

请注意技能的保存方式：它们被嵌入到代表超级英雄的文档中。

2.7 查询

回到Pharo中，我们可以执行一些查询，以获取存储在数据库中的对象。

Hero selectAll.
> an OrderedCollection(a Hero( Spiderman ) a Hero( Wolverine ))

Hero selectOne: [ :each | each name = 'Spiderman' ].
> a Hero( Spiderman )

Hero selectMany: [ :each | each level = #epic ].
> an OrderedCollection(a Hero( Spiderman ) a Hero( Wolverine ))

由于 MongoDB 内部存储的是 JSON，因此查询的参数可以是一个字典，如下所示：

Hero selectOne: { #name -> 'Spiderman' } asDictionary.
> a Hero( Spiderman ) 

Hero selectMany: { #level -> #epic } asDictionary.
> an OrderedCollection(a Hero( Spiderman ) a Hero( Wolverine )

下面是一个更复杂的查询:

Hero
	selectMany: { #level -> #epic } asDictionary 
	sortBy: { #name -> VOOrder ascending } asDictionary
	limit: 10
	offset: 0

2.8 其他基本操作

计数

Hero count.
> 2

Hero count: [ :each | each name = 'Spiderman' ]
> 1

删除

hero := Hero selectAll anyOne.
hero remove.
> a Hero

从类中删除所有对象。

Hero removeAll.
> Hero class

2.9 添加一个新的根

现在，我们将改变需求，表明我们希望能够查询另一类对象：技能。请注意，在添加根对象时，必须刷新数据库或执行迁移，例如加载旧对象并重新发布它们。

每次更改数据库 "模式 "时，都应使用以下表达式重置数据库：

VORepository current reset.

什么时候需要添加新的根类

在面对是否有必要添加一个类作为根的问题时，有两个要点需要考虑。

首先，一个显而易见的考虑因素是，我们是否需要将查询对象与引用对象分开。
其次，如果需要确保共享子部分而不重复，则应将子部分声明为根。例如，如果您需要在两个超级英雄之间共享一种能力，并希望确保在加载两个超级英雄时不会获得相同技能的两个副本。

2.10 Power作为根

Power class >> isVoyageRoot
    ^ true

现在，我们可以单独保存技能对象，如下所示：

Power new name: 'Fly'; save.
Power new name: 'Super-strength'; save.

如果使用 show collections 功能在数据库中看不到新的对象，可能是遇到了 Voyage 的 BUG，需要在 Pharo 图像中重置内存数据库缓存：

VORepository current reset.

现在保存对象并再次检查 mongo 数据库，应该会显示

> show collections
	Hero
	Power

现在我们可以保存英雄及其技能。为了进行全面的测试，我们将执行 Hero removeAll 来清除数据库中的英雄，并执行以下操作：

| fly superStrength |
fly := Power selectOne: [ :each | each name = 'Fly']. 
superStrength := Power selectOne: [ :each | each name = 'Super-strength'].
Hero new
	name: 'Superman'; level: #epic;
	addPower: fly; 
	addPower: superStrength; 
	save.

请注意，虽然我们保存的技能与英雄无关，但这并不是必须的，因为保存英雄会自动保存其技能。

现在，当我们查询数据库时，我们可以看到一个英雄引用了另一个技能集合，而这些技能并没有嵌套在英雄对象中。

2.11 关系

Voyage支持根对象之间的循环引用，但不支持对嵌入对象的循环引用。我们将在下一节中看到这一点。

2.12 扩展`Hero`类

现在，我们将用装备来扩展 Hero 类。这个示例表明，根集合声明是静态的：当一个超类被定义为根集合时，mongo db 中的集合将包含该类及其子类的实例。如果我们想让每个子类都有一个集合，就必须将每个子类都定义为根集合，并在每个类中复制 isVoyageRoot 方法。

我们为 Hero 类添加一个名为 equipment 的新实例变量。

Object subclass: #Hero
   instanceVariableNames: 'name level powers equipment' 
   classVariableNames: ''
   package: 'SuperHeroes'

Hero >> equipment
   ^ equipment ifNil: [ equipment := Set new ]
   
Hero >> addEquipment: anEquipment 
   self equipment add: anEquipment

由于我们更改了类的结构，因此我们应该执行VORepository current reset来重置数据库的本地缓存。

现在，我们把Equipment定义为新的根类。

Object subclass: #Equipment
    instanceVariableNames: ''
    classVariableNames: ''
    package: 'SuperHeroes'

Equipment class >> isVoyageRoot
    ^ true

然后我们定义两个子类Weapon和Armor

Equipment subclass: #Weapon
	instanceVariableNames: ''
	classVariableNames: ''
	category: 'SuperHeroes'

Equipment subclass: #Armor
	instanceVariableNames: ''
	classVariableNames: ''
	category: 'SuperHeroes'

现在，保存一个携带装备的英雄时，也会把装备作为单独的对象进行保存

Hero new
    name: 'Iron-Man';
    level: #epic;
    addEquipment: Armor new;
    save.

我们可以看到对象是如何保存在数据库中的：

> db.Hero.find()[1]
{
	"_id" : ObjectId("d8475734421aa909b4000001"),
	"#instanceOf" : "Hero",
	"#version" : NumberLong("2898020230"),
	"equipment" : [
		{
			"#instanceOf" : "Armor"
		}
	],
	"level" : "epic",
	"name" : "Iron-Man",
	"powers" : null
}

因为我们没有将Weapon和Armor定义成单独的根，所以数据库中只有一个名为Equipment的集合，其中既包含武器又包含盔甲。

2.13 装备也可以拥有技能

事实上，装备也可以有技能(就像雷神之锤)。因此，我们为设备增加了以下技能：

Object subclass: #Equipment
    instanceVariableNames: 'powers'
    classVariableNames: ''
    package: 'SuperPowers'

Equipment >> powers
    ^ powers ifNil: [ powers := Set new ]
    
Equipment >> addPower: aPower
    self powers add: aPower

由于我们改变了类的结构，我们应该重置数据库的本地缓存：

VORepository current reset

现在，我们可以为铁人添加一个具有技能的装备，如下所示：

| hero fly superStrength |
hero := Hero selectOne: [ :each | each name = 'Iron-Man' ].
fly := Power selectOne: [ :each | each name = 'Fly' ].
superStrength := Power selectOne: [ :each | each name = 'Super-strength' ].
hero addEquipment: (Armor new
        addPower: fly;
        addPower: superStrength;
        yourself);
save.

我们在数据库中看到，"装备 "集合包含 "盔甲 "对象。

> db.Equipment.find()[0]
{
	"_id" : ObjectId("d8475777421aa909b4000003"),
	"#instanceOf" : "Armor",
	"#version" : NumberLong("4204064627")
}

请注意，一个装备可以包含另一个装备。由于 Equipment类是一个集合根，因此我们没有任何东西来处理循环引用。

2.14 总结

这个小教程展示了在 Mongo 数据库中存储对象是多么容易。它补充了各种可能的解决方案，如使用 Fuel 序列化对象、使用内存 SandStone 方法或使用 Garage 进行更传统的关系数据库映射。

标签：Hero,name,Power,level,Simple,each,new,Heroes,Super
From： https://www.cnblogs.com/zh-geek/p/18019081

A Simple Tutorial with Super Heroes

2 A Simple Tutorial with Super Heroes

2.1 创建连接

2.2 SuperHeroes

2.3 英雄

2.4 技能

2.5 根类

2.6 检查MongoDB

2.7 查询

2.8 其他基本操作

计数

删除

2.9 添加一个新的根

什么时候需要添加新的根类

2.10 Power作为根

2.11 关系

2.12 扩展`Hero`类

2.13 装备也可以拥有技能

2.14 总结

相关文章

赞助商

阅读排行

A Simple Tutorial with Super Heroes

2 A Simple Tutorial with Super Heroes

2.1 创建连接

2.2 SuperHeroes

2.3 英雄

2.4 技能

2.5 根类

2.6 检查MongoDB

2.7 查询

2.8 其他基本操作

计数

删除

2.9 添加一个新的根

什么时候需要添加新的根类

2.10 Power作为根

2.11 关系

2.12 扩展Hero类

2.13 装备也可以拥有技能

2.14 总结

相关文章

赞助商

阅读排行

2.12 扩展`Hero`类