concern 只是一个 extend ActiveSupport::Concern 的 module。

既可以在 model 中使用,也可以在 controller 中使用。
使用方式: include ConcernName

concern 用途

一、用于把特定功能代码集合封装成一个 concern,提高代码可读性和方便代码重构;
二、把多个 model 或者 多个 controller 重复的功能集合代码封装成一个 concern。

concern 定义

#定义一
module MyConcern
 extend ActiveSupport::Concern
 ...
end
#定义二
concern MyConcern do 
 ...
end

以上两种定义 concern 的方式完全等同

常见 concern 内部定义

ActiveSupport::Concern 提供了一种约定配置:
约定 ClassMethods 用来给类添加类方法(可选)
module ClassMethods
end
定义 included 作为当当前 module(也就是子 concern) 被 include 的回调方法(可选)
def self.included
end

如果不使用 ClassMethods,concern 与普通 module 是一样的

module FirstConcern
 #把ActiveSupport::Concern中的方法 加入到 当前module模块方法(与class类方法原理相同)中
 extend ActiveSupport::Concern
 def self.included(base) 
 base.instance_eval do
 scope :jief, ->{...}
 has_many :table
 end
 # 或者
 #base.class_eval do
 # ... 
 #end
 ...
 end
 #included 也可以这样
 #included do 
 # 这里作用域是base
 # 
 # ...
 #end
 module ClassMethods
 #定义类方法
 def my_method
 end
 ...
 end
 #或者
 # class_methods do
 # ...
 # end
end

ActiveSupport::Concern 代码详解

module Concern
 # 负责当定义多个 included 抛出异常
 class MultipleIncludedBlocks < StandardError #:nodoc:
 def initialize
 super "Cannot define multiple 'included' blocks for a Concern"
 end
 end
 # extended 是回调方法,当 当前module(这里指的是ActiveSupport::Concern) 被 extend 的时候执行
 # 参数--base是extend当前模块的module或者class
 # 用途,在base的作用域初始化@dependencies为空数组 []
 #@_dependencies是base的类实例变量(类实例变量只有类可以访问,他的实例无法访问),
 #用于记录base中include哪些module,顺序---从上到下,深度--1
 def self.extended(base) #:nodoc:
 base.instance_variable_set(:@_dependencies, [])
 end
 #这里的 append_features 是 对 Module.append_features 的扩展
 # Module#include 方法最终是 通过 Module.append_features 实现的(参数顺序是相反的)
 # append_features 只有在多个concern,include嵌套(即一个concern include 若干个其他的concern)时
 #使用此时扩展后的append_features。
 # 当子concern被include时 调用append_features(可理解成 include) 和 included,
 #append_features 在 included 之前调用
 # 参数--base是include当前模块的module或者class
 def append_features(base)
 if base.instance_variable_defined?(:@_dependencies)
 # instance_variable_defined? 用于判断实例变量是否存在。
 #如果 base是module,并且 extend ActiveSupport::Concern,
 # 也就是当 base是concern(这里称其为父concern)时,
 # @_dependencies 就会在上面extended回调方法中初始化
 #否则 这里不会执行。
 #把当前concern 加入到 base(父concern)的 类实例变量 @_dependencies中
 base.instance_variable_get(:@_dependencies) << self
 return false
 else
 # 当base不是concern(base 是 class 或者 是普通 module),才会执行
 #如果base 已经继承了self(子concern) 就不再执行,
 #这也就是 多次include 同一个module时,实际上只执行了第一次的原因
 return false if base < self 
 #遍历子concern 类实例变量 @_dependencies,base include 每一个子concern include的module
 @_dependencies.each { |dep| base.include(dep) } 
 super #执行祖先链后面按序逐个查找并执行 append_features 方法
 #如果子concern 定义了 module ClassMethods,
 # base 会 extend 该module-ClassMethods
 base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods) 
 #在base作用域中执行 子concern中 included 方法的内容(Proc实例)
 base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block) 
 end
 end
 #这里扩展了 Module#included 方法
 def included(base = nil, &block)
 if base.nil?
 #这里的处理 实现了 included do ... end
 raise MultipleIncludedBlocks if instance_variable_defined?(:@_included_block)
 # 通过实例变量@_included_block,实现了 included 传入的块(这里变成了Proc对象) 共享,
 # 即append_features能够访问到
 @_included_block = block
 else
 super
 end
 end
 #这里实现了 class_methods do ... end
 def class_methods(&class_methods_module_definition)
 # mod 判断子concern中是否定义了 module ClassMethods,没有就用Module.new 初始化
 mod = const_defined?(:ClassMethods, false) ?
 const_get(:ClassMethods) :
 const_set(:ClassMethods, Module.new)
 # mod 把 传入的块(这里变成了Proc对象) 添加到 mod 中
 mod.module_eval(&class_methods_module_definition)
 end
 end