Rail's Polymorphic Associations

 英文原文：http://robots.thoughtbot.com/post/159809241/whats-the-deal-with-rails-polymorphic-associations

 1 class Person < ActiveRecord::Base  2 
 3   has_one :address, :as => :addressable  4 
 5 end  6 
 7 class Company < ActiveRecord::Base  8 
 9   has_one :address, :as => :addressable 10 
11 end 12 
13 class Address < ActiveRecord::Base 14 
15   belongs_to :addressable, :polymorphic => true 16 
17 end

以上的例子显示出address可以属于任意的model，另一个写法可以是：

1 class Address < ActiveRecord::Base 2 
3   belongs_to :person 4 
5   belongs_to :company 6 
7 end

这样的话，address表中会有两个foreign key。但这两个中只有一个有值，因为一个地址要么属于某个人，要么属于某个公司。

has_one和has_many可引用as这个关键字的参数作为“polymorphic interface”，那这是什么东东呢？

Polymorphic interface让我联想到Ruby中诸如“<< message”这样的语句。我可以将message传给一堆不同的东西，如数组、字串、IO等。而且，当它们收到时都知道要做什么。

我把<<当作这些不同的类都实现的一个接口。从静态语言（比如Java）的角度来说，有以下这样一个接口：

1 public interface Collection { 2 
3   Collection <<(Object anObject); 4 
5 }

其他的类都实现了这个接口：

 1 public class Array implements Collection {  2 
 3   public Collection << (Object object) {  4 
 5     // add object to me
 6 
 7   }  8 
 9 } 10 
11 public class String implements Collection { 12 
13   public Collection << (Object object) { 14 
15     // add object to me
16 
17   } 18 
19 }

同样的道理，最好我们最开始看到的那些rails类有如下关系就好了：

 1 class Address < ActiveRecord::Base  2 
 3 end  4 
 5 class Person < Address  6 
 7 end  8 
 9 class Company < Address 10 
11 end

但是，Person和Company显然都不可能是Address，那我们就把polymorphic interface作为父类名：

 1 class Addressable < ActiveRecord::Base  2 
 3 end  4 
 5 class Person < Addressable  6 
 7 end  8 
 9 class Company < Addressable 10 
11 end

这样就好多了。Person和Company都变成Addressable了，那Address怎么办呢？

1 class Addressable < ActiveRecord::Base 2 
3   has_one :address 4 
5 end

这样，Person和Company都“has_one”address，它们从Addressable继承了这个属性，而且，这里也不用声明“:polymorphic => true”

问题似乎解决了，但Person和Company都继承自Addressable的话，就造成了“Single-table inheritance”（STI）。若是Person和Company没有什么共同的属性，STI就会给我们一张巨大的表，当某一行存的是Company属性时，所有Person的栏位都是空的；若存的是Person属性时，所有Company的栏位也会是空的。如果还有更多的类要继承Addressable，那这个表就会越长越大。

如果不考虑数据库的话，这样的模型是可以讲得通的，只考虑继承行为不考虑状态。

这里，我们可以看到STI的继承关系适合一些有相同属性而不是行为的类。

事实上，有3种常用方法可以用来表达关系数据库的继承关系。但Rails只提供我们STI。

1. Single Table Inheritance (STI) - 所有的继承关系指向同一张表，并且表中会附加Type栏，里面存放类名。

2. One Table per Concrete Class - 每一个具体的类各自有一张表，基类是抽象类，它没有表。任何常用的属性会在子类中重复。

3. One Table per Class - 继承关系中的每个类都有自己的表，子类的表中有foreign key指向对应的父类表中的某一行。

第二种明显不能用，所以看一下第三种。

回到Person，Company和Addressable的例子，如果它们各自有一张表，那数据库会是什么样呢？

1 addressables (id) 2 
3 people (id, name, age, height, weight, addressable_id) 4 
5 companies (id, size, established_date, addressable_id) 6 
7 addresses (id, street, city, state, addressable_id)

当我们从数据库中度一个Person时，我们通过addressable_id和addressables表做join。当我们需要一个Person的address时，我们通过addressable_id和address表做join。

至此，我们用继承代替了polymorphic association。

要是，我们再加一个特性，让用户能给people和companies加tag该怎么做呢？我们可以用Rais插件acts_as_taggable，而它是使用polymorphic associations的。下面我们不用它，看会发生什么。

增加一个Taggable类，但Ruby不支持多重继承，也没有Java/C#的接口方式。那我们用Ruby的module，这样的话Addressable也要被改为module。

 1 module Addressable  2 
 3 end
 4 
 5 module Taggable  6 
 7 end
 8 
 9 class Person < ActiveRecord::Base 10 
11   include Addressable 12 
13   include Taggable 14 
15 end
16 
17 class Company < ActiveRecord::Base 18 
19   include Addressable 20 
21   include Taggable 22 
23 end

但在Rails中，我们不能直接写：

1 module Addressable 2 
3   has_one :address 4 
5 end

而要写成：

 1 module Addressable  2 
 3   def self.included(klazz) # klazz is that class object that included this module
 4 
 5     klazz.class_eval do  6 
 7       has_one :address  8 
 9     end 10 
11   end 12 
13 end

现在数据库就变成这样了：

1 addresses (id, street, city, state, person_id, company_id)

一个address不能既属于person又属于company，看来我们又回到最初的问题了。

我们只好用polymorphic associations。

先对问题来个小小的总结：首先，我们用了polymorphic associations；然后，我们决定重构，用“更自然的方式”—— 继承，得到了Addressable和Taggable两个类。但当Person和Company都需要Taggable时，我们使用了Ruby的module方式来实现多重继承，但这却使我们回到了问题的起点。

于是，我们用polymorphic associations，并称这样的association为polymorphic interface。

 1 class Address < ActiveRecord::Base  2 
 3   # here's where we'll use Addressable
 4 
 5   belongs_to :addressable, :polymorphic => true  6 
 7 end  8 
 9 class Tagging < ActiveRecord::Base 10 
11   # here's where we'll use Taggable
12 
13   belongs_to :taggable, :polymorphic => true 14 
15 end

Java/.Net世界中的Object-relational mapping (ORM)库，它们提供了3种继承方式，而Rais中只提供STI。因为，Ruby缺少interface机制，所以使用另外两种的话相对其他支持interface的语言来说就不够强大。上面我们看到，当我们新加Tagbble需求的时候就不够用了。

而Rails的polymorphic associations在Java/.Net的ORM库中也没有使用过，是因为，Ruby用module来实现多重继承的方式有独一无二的地方，polymorphic associations就是这个独一无二。如果读过acts_as_taggable插件的代码，就会发现它用了polymorphic associations，并且它用了module来包含任何共用的行为。如果在你的类定义中调用了acts_as_taggble，所有的这些行为就都可以马上用了。