Rails源码阅读（三）Rails::Initializer

 

启动的落脚点

不论启动console还是启动server，最终都需要加载rails环境，这个落脚点在environment.rb中的Rails::Initializer.run 

Rails::Initializer.run do |config|

。。。

end

 

启动前的配置Configuration

加载rails环境，需要的配置是比较多的，例如：启动的root_path，启动时要加载的frameworks，加载的路径，插件的位置，数据库的配置，log的配置，i18n的配置等等。这些都在Configuration类中配置。

  # The Configuration class holds all the parameters for the Initializer and
  # ships with defaults that suites most Rails applications. But it's possible
  # to overwrite everything. Usually, you'll create an Configuration file
  # implicitly through the block running on the Initializer, but it's also
  # possible to create the Configuration instance in advance and pass it in
  # like this:
  #
  #   config = Rails::Configuration.new
  #   Rails::Initializer.run(:process, config)
  class Configuration

  。。。

  end

  

启动前再配置

    def self.run(command = :process, configuration = Configuration.new)
      yield configuration if block_given?
      initializer = new configuration
      initializer.send(command)
      initializer
    end

# 在上面environment的启动中，configuration参数使用了默认的配置值Configuration.new

# 同时看到了，yield configuration if block_given?会把configuration传递给block，这样可以在启动时配置config的一些参数，而不用修改configuration类（这样也是可以的）

# 再回到上面的落脚点的代码，看到了这里的参数config原来就是configuration，也就是说想知道怎么配置config，需要了解configuration的内容和api。

好了，好多人跟我一样，困惑许久的config是什么，如何配置的问题，现在解决了。

 

启动1

继续往下看，这里有一句：initializer = new configuration

这种写法让我这种多年的javaer很反感，明明这么写更好理解么：initializer = Initializer.new(configuration)

javaer理解中的new是这样的：User user = new User(...)

initializer.send(command)

 

 

 

这里调用了实例方法command，根据command = :process知道，调用的方法是process方法。就是这里进入启动环节。

 

启动2 可以说，直接看这里就是rails的启动过程

    # Sequentially step through all of the available initialization routines,
    # in order (view execution order in source).
    def process

。。。

    end

 

 

启动3 仔细看看启动都做了些什么

check_ruby_version

检查版本，不对的话会报异常，详细略

 

install_gem_spec_stubs

看看stub的字样，表示这里的install其实是个“伪”install，目的是给plugin使用的。

说明：

  This allows Gem plugins to depend on Rails even when the Gem version of Rails shouldn't be loaded

代码：

  install_gem_spec_stubsGem.loaded_specs[stub] = Gem::Specification.new 。。。

 

set_load_path

配置$LOAD_PATH

说明：Set the $LOAD_PATH based on the value of Configuration

 

add_gem_load_paths

使用的对象为@gems

  来源：configuration中的@gems << Rails::GemDependency.new(name, options)

调用了Rails::GemDependency的add_load_paths方法，这个方法内容主要使用了gem ‘some_gem' 'edition_n'

 

require_frameworks

依次执行 require ‘activesupport’ 等， 简而言之，这里才真正的require了，这里之后才真正可以使用这些framework

这里之后的方法，基本可以说能使用rails的这些组件了

 

set_autoload_paths

字面意义

把configuration里面的auto_load_paths 赋值给了ActiveSupport::Dependencies

关于ActiveSupport::Dependencies，以后再看看，暂不清楚内部原理

 

add_plugin_load_paths

主要由plugin_loader来

 

load_environment

这里会调用到所在环境（production，development，test）对应的rb文件

    def environment_path
      "#{root_path}/config/environments/#{environment}.rb"
    end

 并且把常量设置在了Object中（好处呢，首先是在任何地方都可以直接用了吧）

        (self.class.constants - constants).each do |const|
          Object.const_set(const, self.class.const_get(const))
        end

 我在我的环境里看了看，果然常量增加了不少

 

#irb初始情况下：
irb(main):011:0>  Object.constants.size
=> 101

#我的rails环境
?> Object.constants.size
=> 429

最后再重复一个问题，程序运行到这里，能不能使用rails的插件呢？

可以！例如active_support

但不全部，例如有些组建还要进行初始化操作，像active_record的数据库建立等

 

preload_frameworks

作用是为了Passenger/JRuby等使用

主要操作是显式调用各个组件的 framework.load_all! 方法

我看了看几个组件，居然是都有load_all!这个方法

module ActiveSupport
  def self.load_all!
    [Dependencies, Deprecation, Gzip, MessageVerifier, Multibyte, SecureRandom, TimeWithZone]
  end
。。。
end

module ActiveRecord
  # TODO: Review explicit loads to see if they will automatically be handled by the initilizer.
  def self.load_all!
    [Base, DynamicFinderMatch, ConnectionAdapters::AbstractAdapter]
  end
。。。
end

 

initialize_encoding

这个类做了什么呢，怎么设置编码的呢？

Ruby1.8设置$KCODE

Ruby1.9默认是utf-8了

# For Ruby 1.8, this initialization sets $KCODE to 'u' to enable the
    # multibyte safe operations. Plugin authors supporting other encodings
    # should override this behaviour and set the relevant +default_charset+
    # on ActionController::Base.
    #
    # For Ruby 1.9, this does nothing. Specify the default encoding in the Ruby
    # shebang line if you don't want UTF-8.
    def initialize_encoding
      $KCODE='u' if RUBY_VERSION < '1.9'
    end

 

 

initialize_database

这里才建立数据库连接了！！

也就是说从这里开始才能使用ActiveRecord来查询数据库

 

initialize_cache

放置缓存，页面缓存，块缓存等的地方

*1 如果默认位置： "#{root_path}/tmp/cache/"路径不存在则用内存了

    def default_cache_store
        if File.exist?("#{root_path}/tmp/cache/")
          [ :file_store, "#{root_path}/tmp/cache/" ]
        else
          :memory_store
        end
      end

*2 这里从config得到了cache_store的类型，并初始化了一个cache_store

     这里居然用了silence_wornings，很明显不让你随意设置咯

silence_warnings { Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store(configuration.cache_store) }

 

*3 cache_store的结果是返回一个cache_store对象，并不是一个配置

    # Creates a new CacheStore object according to the given options.
    #
    # If no arguments are passed to this method, then a new
    # ActiveSupport::Cache::MemoryStore object will be returned.
    #
    # If you pass a Symbol as the first argument, then a corresponding cache
    # store class under the ActiveSupport::Cache namespace will be created.
    # For example:
    #
    #   ActiveSupport::Cache.lookup_store(:memory_store)

 

initialize_framework_caches

这里只是简单的使用了上面设置的cache

 

    def initialize_framework_caches
      if configuration.frameworks.include?(:action_controller)
        ActionController::Base.cache_store ||= RAILS_CACHE
      end
    end

 

 

initialize_logger

initialize_framework_logging

设置logger，如果config里面设置了logger，则基本跳过了。

*1 logger用的哪个类呢

     logger = ActiveSupport::BufferedLogger.new(configuration.log_path)

*2 production的特殊配置

          if configuration.environment == "production"
            logger.auto_flushing = false
          end  

 

*3 logger leve 这里是默认的，可以在config里配置新的

 

      def default_log_path
        File.join(root_path, 'log', "#{environment}.log")
      end

      def default_log_level
        environment == 'production' ? :info : :debug
      end

*4 可以给不同的组建单独配置其logger

     这个在ide测试的时候有用，比如在test里，可以把active_record的log打入ide，便于调试

    def initialize_framework_logging
      for framework in ([ :active_record, :action_controller, :action_mailer ] & configuration.frameworks)
        framework.to_s.camelize.constantize.const_get("Base").logger ||= Rails.logger
      end

      ActiveSupport::Dependencies.logger ||= Rails.logger
      Rails.cache.logger ||= Rails.logger
    end

 

initialize_dependency_mechanism

代理了类加载的机制，从而可以配置在开发环境和product环境中，加载类可以用不同的机制

 

    # Sets the dependency loading mechanism based on the value of
    # Configuration#cache_classes.
    def initialize_dependency_mechanism
      ActiveSupport::Dependencies.mechanism = configuration.cache_classes ? :require : :load
    end

 

 ActiveSupport::Dependencies这个类显然有很重要的地位，比如你看看大部分你用到的类都没有使用require ‘xxx’方法！！

 

 

initialize_whiny_nils

不用多说了，就是whiny_nil 的改写

 

initialize_time_zone

这个意图也清楚。但下面的代码没有弄明白具体含义，待补充吧。

设置adtive_record可以理解，但是最后一行，么意思呢。。。？？？

 

        if configuration.frameworks.include?(:active_record)
          ActiveRecord::Base.time_zone_aware_attributes = true
          ActiveRecord::Base.default_timezone = :utc
        end

 

 

initialize_i18n

    def initialize_i18n
      configuration.i18n.each do |setting, value|
        if setting == :load_path
          I18n.load_path += value
        else
          I18n.send("#{setting}=", value)
        end
      end
    end

  #1 可见，如果配置了load_path则I18n类中加入这个路径；否则，认为是配置i18n的属性

 

  #2 在config中可以这么配置：

  # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
  # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}')]
  #   config.i18n.default_locale = :cn
  config.i18n.default_locale = 'zh_cn'

  config.i18n.load_path += Dir[
    Rails.root.join('config', 'locales', 'user', '*.{rb,yml}'),
    Rails.root.join('config', 'locales', 'message', '*.{rb,yml}')
  ]

  #3 最后，必须要说的是，这里用到了重写的ActiveSupport的类：

class Rails::OrderedOptions < Array                。。。              end

 

initialize_framework_settings 

    # Initializes framework-specific settings for each of the loaded frameworks
    # (Configuration#frameworks). The available settings map to the accessors
    # on each of the corresponding Base classes.
    def initialize_framework_settings
      configuration.frameworks.each do |framework|
        base_class = framework.to_s.camelize.constantize.const_get("Base")

        configuration.send(framework).each do |setting, value|
          base_class.send("#{setting}=", value)
        end
      end
      configuration.active_support.each do |setting, value|
        ActiveSupport.send("#{setting}=", value)
      end
    end

 根据下面的注释，可以知道：

*1 某个framefork都有哪些项目可以配置？例如active_record

     参考framefork的Base类

*2 配置的地方？

     还是上面提到的，在environment的中配置

*3 配置怎么写?

# Show full error reports and disable caching
config.action_controller.consider_all_requests_local = true
config.action_view.debug_rjs                         = true

 #June: we can test cache here(comment 2 lines && uncomment 3 lines after)
config.action_controller.perform_caching             = false
config.action_view.cache_template_loading            = false

 *4 为什么可以这么写？

    还是需要明白Rails::OrderedOptions也就是ActiveSupport::OrderedOptions的用法

 *5 active_support应该没有base类咯，看出来了么

 

initialize_framework_views

基本上可以同上。

 

initialize_metal

请看metal的用法吧

 

add_support_load_paths

空方法？？？

 

check_for_unbuilt_gems

这里可以安装config中配置到gem

 

load_gems

使用config中的gem

 

 

      # pick up any gems that plugins depend on

      add_gem_load_paths

      load_gems

      check_gem_dependencies

 

 

load_application_initializers

config/initializers目录下面的文件会在rails server启动最后顺序执行，顺序为文件名排序，所以有依赖关系的话，就得提前安排一下，例如db:migrate那样加入时间戳么。总之在这里安排顺序就是个很懒的设计了。

看看源码：

    def load_application_initializers
      if gems_dependencies_loaded
        Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
          load(initializer)
        end
      end
    end

 

方法没有叫做after_initialize，因为这里安排的仍然是app启动的一项

 

after_initialize 

这里才是启动之后的操作，回调。

例如这里可以给分页的插件中文话。

 

initialize_database_middleware

这里会检查配置的session_store情况，如果配置了下面的目标内容，就会用数据库来存session了

ActionController::Base.session_store.name == 'ActiveRecord::SessionStore' （去配置config）

 

prepare_dispatcher

# Prepare dispatcher callbacks and run 'prepare' callbacks

看样子好像是加载了dispatcher并define_dispatcher_callbacks(configuration.cache_classes)

这里设置了@@cache_classes = cache_classes

作用：

# In the development environment your application's code is reloaded on
# every request.  This slows down response time but is perfect for development
# since you don't have to restart the webserver when you make code changes.
config.cache_classes = false

 

initialize_routing

代码：

    # If Action Controller is not one of the loaded frameworks (Configuration#frameworks)
    # this does nothing. Otherwise, it loads the routing definitions and sets up
    # loading module used to lazily load controllers (Configuration#controller_paths).
    def initialize_routing
      return unless configuration.frameworks.include?(:action_controller)

      ActionController::Routing.controller_paths += configuration.controller_paths
      #### Me added this line ###
      ActionController::Routing::Routes.add_configuration_file(File.join("/home/lijg/workrubygit/t8", 'config', 'routes2.rb'))
      ActionController::Routing::Routes.add_configuration_file(configuration.routes_configuration_file)
      ActionController::Routing::Routes.reload!
    end

 

这里的作用：

*1 知晓controller的位置，等需要的时候去得到这个类

*2 知晓routes文件的位置，load it

     这里的文件，可以是多个的，内部是可以处理的

configuration_files.each { |config| load(config) }

*3 reload!

      def load!
        Routing.use_controllers!(nil) # Clear the controller cache so we may discover new ones
        clear!
        load_routes!
      end

      # reload! will always force a reload whereas load checks the timestamp first
      alias reload! load!

*4 加入一些自己想要的controller

有时候想测试一个需求（不用git哦），想加入一些自己的routes和mvc看看情况，这个时候就可以用这个了。

这里仅仅是个小实验，所以简单修改了下源码。

*5 注意这里的顺序，路由加入的时候，优先加入的会先匹配。这样我的测试路由优先加入比较好～

 

load_observers

这个是给active_record使用的ActiveRecord::Base.instantiate_observers

看看里面的代码：

"#{observer} must be a lowercase, underscored class name (or an instance of the class itself) responding to the instance method. Example: Person.observers = :big_brother # calls BigBrother.instance"

 

load_view_paths

这两个组件在用view的路径

ActionController::Base.view_paths.load!

ActionMailer::Base.view_paths.load!

 

load_application_classes

*1 如果设置了某些自动加载的路径，这时会加载

     例如在env中这样的设置：config.load_paths <<  "#{RAILS_ROOT}/app/middleware"

*2 加载了这个目录以及子目录下的所有.rb文件

     Dir.glob("#{load_path}/**/*.rb"

*3 这里加载方式：require_dependency

 

    # Eager load application classes
    def load_application_classes
      return if $rails_rake_task
      if configuration.cache_classes
        configuration.eager_load_paths.each do |load_path|
          matcher = /\A#{Regexp.escape(load_path)}(.*)\.rb\Z/
          Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
            require_dependency file.sub(matcher, '\1')
          end
        end
      end
    end 

写到这里，我想需要把rails2的自动加载路径打印出来看看

 

--------------------------------------------------

/home/lijg/workrubygit/t8/app/controllers/

/home/lijg/workrubygit/t8/app

/home/lijg/workrubygit/t8/app/models

/home/lijg/workrubygit/t8/app/controllers

/home/lijg/workrubygit/t8/app/helpers

/home/lijg/workrubygit/t8/lib #看见了，这个在rails2是自动加入的，但rails3好像不同了

/home/lijg/workrubygit/t8/vendor

/home/lijg/workrubygit/t8/config/../vendor/rails/railties/lib/../builtin/rails_info/

/home/lijg/workrubygit/t8/app/middleware #这个是我自己设置的

--------------------------------------------------

 

disable_dependency_loading

用到了这个：ActiveSupport::Dependencies.unhook!

 

本篇完毕

作业：需要再仔细看看的

require_dependency

auto_load

ActiveSupport::Dependencies

 

----本篇完毕---- -----EOF---- ----THE END----

。

。

。

+

o

o

o

 

 

 

 

 

 

 

评论

2 楼 fantaxy025025 2011-10-14  

orcl_zhang 写道

这个太简单了吧。。。

sorry阿，这里暂时占了个位置，还是没有那么多时间一下子写完了～待续～

1 楼 orcl_zhang 2011-10-14  

这个太简单了吧。。。