Ruby中嵌套内部类访问外部类变量与方法的实现方案

首先明确Ruby的核心设计规则：Ruby里的类嵌套仅为词法层面的命名空间嵌套，不存在传统面向对象语言中内部类自动绑定外部类实例的机制，Inner类和Outer类本质是两个独立的类，只是Inner的类名被放在了Outer的命名空间下，这就是示例代码中访问变量、方法报错的根本原因。

在保持两个类同属Fluent::Plugin模块的前提下，按你要访问的成员类型选择对应实现即可，都是Ruby社区通用的标准写法，没有奇技淫巧：

先区分你要访问的成员类型 #

Outer类里定义的成员分两类，访问逻辑完全不一样，别搞混：

• 类级别成员：直接写在Outer类定义体里、不属于实例方法的内容，比如你示例里的@outer_var，是挂在Outer类本身这个对象上的，和Outer的实例没关系
• 实例级别成员：写在Outer的实例方法里的内容，比如你示例里自定义的outer_method、Fluent插件父类提供的log方法，这些都属于Outernew出来的实例对象，只有拿到具体的Outer实例才能调用

场景1：访问Outer的类级别成员 #

这类成员不需要实例化Outer就能访问，直接通过Outer类的常量引用调用即可：

module Fluent::Plugin
  class Outer < Fluent::Plugin::Output
    @outer_class_var = "Hello from outer class variable"
    # 类级别方法
    def self.shared_class_method
      puts "I'm a class method of Outer"
    end

    class Inner
      def initialize
        # 读类级别实例变量
        puts Outer.instance_variable_get(:@outer_class_var)
        # 调用类级别方法
        Outer.shared_class_method
      end
    end
  end
end

如果频繁访问的话，可以在Inner里写个小的helper方法返回Outer类对象，不用每次硬写类名。

场景2：访问Outer的实例级别成员（你示例里报错的log、outer_method都属于这类） #

这是实际开发中最常见的场景：你在Outer的实例方法里创建Inner对象，需要用到Outer实例的方法。唯一推荐的做法是显式把Outer实例的引用传给Inner，不要搞任何隐式的作用域hack：
修改后的可运行代码如下：

require "fluent/plugin/output"

module Fluent::Plugin
  class Outer < Fluent::Plugin::Output
    @outer_class_var = "Hello from outer class variable"

    class Inner
      # 初始化时接收传入的Outer实例
      def initialize(outer)
        @outer = outer
        # 调用Outer实例的log方法
        @outer.log.info "Hello from inner initialize"
        # 调用自定义的Outer实例方法
        @outer.outer_method
        # 要访问类级别变量还是通过Outer类引用拿
        puts Outer.instance_variable_get(:@outer_class_var)
      end
    end

    def initialize
      super # 必须调用父类初始化方法，否则Fluent插件的log、配置等能力不会加载
      # 创建Inner时把当前Outer实例self传进去
      Inner.new(self)
      log.info "Hello from outer initialize"
    end

    def outer_method
      puts "Hello from outer method"
    end
  end
end

为什么这是最佳实践？ #

• 依赖完全显式，没有隐式耦合，任何人看代码都能立刻知道Inner依赖Outer实例，后续重构、排错成本极低
• 完全符合Fluent插件的开发规范，不会破坏插件的生命周期、多worker隔离、日志注册等内置逻辑
• 单元测试非常方便，测试Inner的时候可以直接传入mock对象，不需要初始化完整的Output插件

不推荐的反模式 #

不要为了省传参的几行代码用下面这些写法，后期维护会踩大坑：

• 利用闭包在类定义时把外层self塞给Inner，会导致两个类的词法作用域强绑定，只要调整类的定义位置逻辑就会崩
• 把需要共享的方法全改成类级方法，会破坏Fluent插件的实例隔离，多worker运行时大概率出现变量串扰
• 用全局变量、常量缓存Outer实例引用，会导致内存泄漏、线程安全问题

内容的提问来源于stack exchange，提问作者Dante