冬瓜争做全栈瓜
冬瓜争做全栈瓜

7. Molinillo 依赖校验

7. Molinillo 依赖校验_第1张图片

引子

通过「PodSpec 管理策略」对 CocaPods-Core 的分析，我们大体了解了 Pod 是如何被解析、查询与管理的。有了这些整体概念之后，我们就可以逐步深入 pod install 的各个细节。

今天我们就来聊聊 Pod 的依赖校验工具 --- Molinillo[1]。

开始前，需要聊聊依赖校验的背景。

依赖管理的挑战

同大多数包管理工具一样 Pod 会将传递依赖的包用扁平化的形式，安装至 workspace 目录 (即：Pods/)。

依赖传递：pod A 依赖于 pod B，而 pod B 依赖 Alamofire。

7. Molinillo 依赖校验_第2张图片

可以看到，经依赖解析原有的依赖树被拍平了，安装在同层目录中。

然而在大型项目中，遇到的更多情况可能像下面这样：

7. Molinillo 依赖校验_第3张图片

依赖冲突： 即 pod A 和 pod B 分别依赖不同版本的 Alamofire。这就是 依赖地狱[2] 的开始。

依赖地狱：指在操作系统中由于软件之间的依赖性不能被满足而引发的问题。

随着项目的迭代，我们不断引入依赖并最终形成错综复杂的网络。这使得项目的依赖性解析变得异常困难，甚至出现 致命错误[3]。

那么，产生的问题有哪些类型 ？

问题类型

依赖过多/多重依赖

即项目存在大量依赖关系，或者依赖本身有其自身依赖（依赖传递），导致依赖层级过深。像微信或淘宝这样的超级应用，其中的单一业务模块都可能存在这些问题，这将使得依赖解析过于复杂，且容易产生依赖冲突和依赖循环。

依赖冲突

即项目中的两个依赖包无法共存的情况。可能两个依赖库内部的代码冲突，也可能其底层依赖互相冲突。上面例子中因 Alamofire 版本不同产生的问题就是依赖冲突。

依赖循环

即依赖性关系形成一个闭合环路。如下图三个 pod 库之间互相依赖产生循环：

7. Molinillo 依赖校验_第4张图片

要判断依赖关系中是否存在依赖环，则需要通依赖仲裁算法来解决。

依赖关系的解决

对于依赖过多或者多重依赖问题，我们可通过合理的架构和设计模式来解决。而依赖校验主要解决的问题为：

  1. 检查依赖图是否存在版本冲突；

  2. 判断依赖图是否存在循环依赖；

版本冲突的解决方案

对于版本冲突可通过修改指定版本为带兼容性的版本范围问题来避免。如上面的问题有两个解决方案：

  • 通过修改两个 pod 的 Alamofire 版本约束为 ~> 4.0 来解决。

  • 去除两个 pod 的版本约束，交由项目中的 Podfile 来指定。

不过这样会有一个隐患，由于两个 Pod 使用的主版本不同，可能带来 API 不兼容，导致 pod install 即使成功了，最终也无法编译或运行时报错。

还有一种解决方案，是基于语言特性来进行依赖性隔离。如 npm 的每个传递依赖包如果冲突都可以有自己的 node_modules 依赖目录，即一个依赖库可以存在多个不同版本。

7. Molinillo 依赖校验_第5张图片

循环依赖的解决方案

循环依赖则需要需要进行数学建模生成 DAG 图，利用拓扑排序的拆点进行处理。通过确定依赖图是否为 DAG 图，来验证依赖关系的合理性。

一个 DAG 图的示例：

7. Molinillo 依赖校验_第6张图片

DAG 是图论中常见的一种描述问题的结构，全称 有向无环图 （Directed Acyclic Graph）。想了解更多，可查看冬瓜的文章 --- 「从拓扑排序到 Carthage 依赖校验算法」。

另外，各种包管理工具的依赖校验算法也各不相同，有如 Dart 和 SwiftPM 所使用的 PubGrub[4]，作者号称其为下一代依赖校验算法，Yarn 的 Selective dependency resolutions[5]，还有我们今天聊到的 Molinillo。

Molinillo

Molinillo 作为通用的依赖解析工具，它不仅应用在 CocoaPods 中，在 Bundler 1.9 版本也采用 Molinillo。另外，值得注意的是 Bundler 在 Ruby 2.6 中被作为了默认的 Gem 工具内嵌。可以说 Ruby 相关的依赖工具都通过 Molinillo 完成依赖解析。

ResolutionState

Molinillo 算法的核心是基于回溯 (Backtracking)[6] 和 [向前检查 (forward checking)](https://en.wikipedia.org/wiki/Look-ahead_(backtracking "向前检查 (forward checking)"))，整个过程会追踪栈中的两个状态 DependencyState 和 PossibilityState。

module Molinillo
  # 解析状态
  ResolutionState = Struct.new(
    # [String] 当前需求名称
    :name,
    # [Array] 未处理的需求
    :requirements,
    # [DependencyGraph] 依赖关系图
    :activated,
    # [Object] 当前需求
    :requirement,
    # [Object] 满足当前需求的可能性
    :possibilities,
    # [Integer] 解析深度
    :depth,
    # [Hash] 未解决的冲突，以需求名为 key
    :conflicts,
    # [Array] 记录着未处理过的需要用于回溯的信息
    :unused_unwind_options
  )

  class ResolutionState
    def self.empty
      new(nil, [], DependencyGraph.new, nil, nil, 0, {}, [])
    end
  end

  # 记录一组需求和满足当前需求的可能性
  class DependencyState < ResolutionState
  # 通过不断 pop 过滤包含的可能性，找出最符合需求的解
    def pop_possibility_state
      PossibilityState.new(
        name,
        requirements.dup,
        activated,
        requirement,
        [possibilities.pop],
        depth + 1,
        conflicts.dup,
        unused_unwind_options.dup
      ).tap do |state|
        state.activated.tag(state)
      end
    end
  end

  # 仅包含一个满足需求的可能性
  class PossibilityState < ResolutionState
  end
end


光看 state 定义大家可能觉得云里雾里。这里很有必要解释一下：


我们说的需求 (requirement) 到底是指什么呢？大家可以理解为在 Podfile 中声明的 pod。之所以称为需求，是由于无法判断定义的 dependency 是否合法。 假设它合法，又是否存在符合需求限制版本的解呢 ？即是否存在对应的 PodSpec 我们不而知。因此，这些未知状态称为统一被可能性 possibility。




Tips: 了解这个概念非常重要，这也是笔者在几乎写完本文的情况下，才想明白这些变量名的意义。????




Resolution Loop


我们先通过图来了解一下 Molinillo 的核心流程 (先忽略异常流）：

7. Molinillo 依赖校验_第7张图片

可以看到整个流程就是不断的将 requirement 的 possibility 过滤和处理，一层层剥离转换为 DependencyState，如此循环往复。


Molinillo 的入口为 Resolution::resolve 方法，也是上图对应的实现，逻辑如下：


# lib/molinillo/resolution.rb

def resolve
  # 1. 初始化 timer 统计耗时初始位置打点
  # 2. 内部会调用 push_initial_state 初始化 DependencyState 压栈
  # 3. 初始化 DependencyGraph 实例
  start_resolution

  while state
    break if !state.requirement && state.requirements.empty?
    # 输出一个进度占位
    indicate_progress
    if state.respond_to?(:pop_possibility_state) # DependencyState
      # 调试日志入口
      # 如果环境变量 MOLINILLO_DEBUG 是非 nil 就输出 log
      # 这里的调试日志有助于排查 Pod 组件的依赖问题
      debug(depth) { "Creating possibility state for #{requirement} (#{possibilities.count} remaining)" }
      state.pop_possibility_state.tap do |s|
        if s
          states.push(s)
          activated.tag(s)
        end
      end
    end
    # 处理栈顶 Possibility State
    process_topmost_state
  end
 # 遍历 Dependency Graph 
  resolve_activated_specs
ensure
  end_resolution
end



    

  1. 首先 #start_resolution 会初始化 timer 用于统计解析耗时，在这个方法中还会调用 #push_initial_state 初始化 DependencyState 入栈，以及 DependencyGraph 初始化。
    2. 

  2. 获取栈顶 state 检查是否存在待解析需求，接着调用 #pop_possibility_state 进行 state 转换并入栈。
    3. 

  3. 调用 #process_topmost_state 处理栈顶的 Possibility State，如果当前 state 可被激活，则将该 Possiblity 存入 DependencyGraph 对应顶点的 payload 中。否则判定为冲突，需要进行状态回滚。
    4. 

  4. 循环直到 state 的可能性全部处理结束。
    5. 

  5. 调用 #resolve_activated_specs ，遍历 DependencyGraph 以存储更新需求的可能性，解析结束。
    6. 



当然，依赖处理并非这么简单，复杂的过滤和回溯逻辑都隐藏在 #process_topmost_state 中。


ResolutionState 的变化


其实从 ResolutionState 的定义能够看出，为了方便回溯和数据还原，state 是以 Struct 结构定义的。同时在每次 #pop_possibility_state 中，通过 #dup[7] 对 diff 数据进行了复制。


这里用依赖传递的例子来展示解析后状态栈的变化。假设我们在 Podfile 中声明了 A，B，C 三个依赖，他们的关系为：A -> B -> C。


target 'Example' do
  pod 'C', :path => '../'
  pod 'B', :path => '../'  
  pod 'A', :path => '../’
end



在 #resolve_activated_specs 方法设置断点，在解析结束时打印状态栈 @states（简化处理后）如下：


 [
   #, 
   #
   #
   #
   # 省略了 C、C、A、A...
   #


可以看到栈内保存的 states 中 DependencyState 与 PossibilityState 是成对出现的。不过最后入栈的 DependencyState 是一个空状态，requirements 也为空，此时无法再 pop state 循环结束。


DependencyGraph


其实包括 Molinillo 在内的依赖解析工具都会在运行期间对依赖关系进行建模来构建依赖图，毕竟这是我们表达依赖关系的方式。那么 DependencyGraph (以下简称 dg ) 是如何定义：


module Molinillo

  class DependencyGraph
    # 有向边
    Edge = Struct.new(:origin, :destination, :requirement)
    # @return [{String => Vertex}] 用字典保存顶点, key 为顶点名称(即 requirement.name)
    attr_reader :vertices
    # @return [Log] 操作日志
    attr_reader :log
  ...
end



另外 Vertex 定义如下：


module Molinillo
  class DependencyGraph
    class Vertex
      attr_accessor :name
      # @return [Object] 顶点的元数据，reqiuremnt 对应的 possiblity
      attr_accessor :payload
      # @return [Array] 需要依赖该顶点可能性能的需求
      attr_reader :explicit_requirements
      # @return [Boolean] 是否为根结点
      attr_accessor :root
      # @return [Array] 出度 {Edge#origin}
      attr_accessor :outgoing_edges
      # @return [Array] 入度 {Edge#destination}
      attr_accessor :incoming_edges
      # @return [Array] 入度的起点
      def predecessors
        incoming_edges.map(&:origin)
      end
      # @return [Array] 出度的终点
      def successors
        outgoing_edges.map(&:destination)
      end
      ...
    end
  end
end


熟悉图论的同学都了解，图的保存常用的方式是邻接表和邻接矩阵。


Molinillo 则通过 map + list，vertext 字典与边集数组来保存。如果仅用边集数组来查询顶点本身效率并不高，好在顶点直接用了字典保存了。


Molinillo 通过栈来维护解析状态，不断将解析结果 possibility 存入 dg 的 payload 中，同时记录了各个顶点的依赖关系，即 dg 的出度和入度。

7. Molinillo 依赖校验_第8张图片



    

  • 在有向图中对于一个顶点来说，如果 Molinillo 则通过 map + list，v一条边的终点是这个顶点，这条边就是这个顶点的入度；
    • 

  • 在有向图中对于一个顶点来说，如果一条边的起点是这个顶点，这条边就是这个顶点的出度。
    • 





当成功解析的一刻，dg 图也构建完毕。


Operation Log


当解析过程出现冲突时，状态栈要回溯直接 pop 一下就完事了，而 dg 咋办 ? 它可没法 pop。


好在 Molinillo 设计了 Operation Log 机制，通过 Log 记录 dg 执行过的操作。这些操作类型包括：AddEdgeNoCircular、AddVertex、DeleteEdge、DetachVertexNamed、SetPayload、Tag。


Log 结构如下：


# frozen_string_literal: true

module Molinillo
  class DependencyGraph
    class Log
      def initialize
        @current_action = @first_action = nil
      end

      def pop!(graph)
        return unless action = @current_action
        unless @current_action = action.previous
          @first_action = nil
        end
        action.down(graph)
        action
      end

      # 回撤到指定的操作节点
      def rewind_to(graph, tag)
        loop do
          action = pop!(graph)
          raise "No tag #{tag.inspect} found" unless action
          break if action.class.action_name == :tag && action.tag == tag
        end
      end

      private

      # 插入操作节点
      def push_action(graph, action)

        action.previous = @current_action
        @current_action.next = action if @current_action
        @current_action = action
        @first_action ||= action
        action.up(graph)
      end
      ...
    end
  end
end



标准的链表结构，Log 提供了当前指针 @current_action 和表头指针 @first_action 便于链表的遍历。接着看看 Action：


# frozen_string_literal: true

module Molinillo
  class DependencyGraph

    class Action
      # @return [Symbol] action 名称
      def self.action_name
        raise 'Abstract'
      end

      # 对图执行正向操作
      def up(graph)
        raise 'Abstract'
      end

      # 撤销对图的操作
      def down(graph)
        raise 'Abstract'
      end
       
      # @return [Action,Nil] 前序节点
      attr_accessor :previous
      # @return [Action,Nil] 后序节点
      attr_accessor :next
    end
  end
end



Action 本身是个抽象类，Log 通过 Action 子类的 #up、#down 来完成对 dg 的操作和撤销。所提供的 Action 中除了 Tag 特殊一点，其余均是对 dg 的顶点和边的 CURD 操作。这里以 AddVertex 为例：


# frozen_string_literal: true

require_relative 'action'
module Molinillo
  class DependencyGraph
  # @!visibility private
    class AddVertex < Action # :nodoc:
      def self.action_name
        :add_vertex
      end
      
      # 操作添加顶点
      def up(graph)
        if existing = graph.vertices[name]
          @existing_payload = existing.payload
          @existing_root = existing.root
        end
        vertex = existing || Vertex.new(name, payload)
        graph.vertices[vertex.name] = vertex
        vertex.payload ||= payload
        vertex.root ||= root
        vertex
      end

      # 删除顶点
      def down(graph)
        if defined?(@existing_payload)
          vertex = graph.vertices[name]
          vertex.payload = @existing_payload
          vertex.root = @existing_root
        else
          graph.vertices.delete(name)
        end
      end

      # @return [String] 顶点名称 (或者说依赖名称)
      attr_reader :name
      # @return [Object] 顶点元数据
      attr_reader :payload
      # @return [Boolean] 是否为根
      attr_reader :root
  ...
    end
  end
end



Action 子类均声明为 private 的，通过 Log 提供的对应方法来执行。


def tag(graph, tag)
  push_action(graph, Tag.new(tag))
end

def add_vertex(graph, name, payload, root)
  push_action(graph, AddVertex.new(name, payload, root))
end

def detach_vertex_named(graph, name)
  push_action(graph, DetachVertexNamed.new(name))
end

def add_edge_no_circular(graph, origin, destination, requirement)
  push_action(graph, AddEdgeNoCircular.new(origin, destination, requirement))
end

def delete_edge(graph, origin_name, destination_name, requirement)
  push_action(graph, DeleteEdge.new(origin_name, destination_name, requirement))
end

def set_payload(graph, name, payload)
  push_action(graph, SetPayload.new(name, payload))
end



最后 log 声明的这些方法会由 dg 直接调用，如 #addVertext:


module Molinillo
  class DependencyGraph
    def add_vertex(name, payload, root = false)
      log.add_vertex(self, name, payload, root)
    end
    ...
  end
end



Unwind For Conflict


有了 op log 之后我们还需要一样重要的东西：哨兵节点。由 Tag 类来承载：


# frozen_string_literal: true
module Molinillo
  class DependencyGraph
    # @!visibility private     
    class Tag < Action

      def up(graph)
      end
       
      def down(graph)
      end

      attr_reader :tag

      def initialize(tag)
        @tag = tag
      end
    end
  end
end



作为哨兵节点 Tag 的 #up 与 #down 操作总是成对出现的。在 Molinillo 中有两处需要进行状态回溯，分别为可能性校验和冲突状态回撤。


可能性校验


#possibility_satisfies_requirements? 方法用于冲突产生的前后，用于判断该可能性能否同时满足多个需求：


def possibility_satisfies_requirements?(possibility, requirements)
  name = name_for(possibility)

  activated.tag(:swap)
  activated.set_payload(name, possibility) if activated.vertex_named(name)
  satisfied = requirements.all? { |r| requirement_satisfied_by?(r, activated, possibility) }
  activated.rewind_to(:swap)

  satisfied
end



为了直观的说明参数，我们举个例子。Case 1假设 Podfile 中存在 pod A 和 B，且 A、B 分别依赖了 Alamofire 3.0 和 4.0，那么对应的参数为：


possibility: #
requirements: [
  3.0 source=nil external_source=nil>,    4.0 source=nil external_source=nil>
]



现在来看方法实现：


    

  1. 首先 activated 就是 Podfile 解析生成的 dg 对象，这里将 symbol :swap 作为标识用于稍后的回撤；
    2. 

  2. 调用 #set_payload 将顶点 Alamofire 的 payload 修改为 possibility 版本；
    3. 

  3. 遍历 requirements 并调用代理的 #requirement_satisfied_by 以校验 possiblity 在 dg 中存在的可能性；
    4. 

  4. 调用 #rewind_to 将顶点的修改回撤至 :swap 前的状态，最后返回检验结果。
    5. 





Tips: 此处的代理是指 CocoaPods，它做为 Molinillo 的 client 实现了很多代理方法，后续会聊到。




作为候选项 possibility 当然不止一个，代理提供的查询方法 #search_for(dependency) 会返回所有符合 requiremnt 名称的依赖。在 CocoaPods 中，就是通过 Pod::Source 查询获得所有版本的 Pod::Specification，具体可以看上一篇文章：PodSpec 管理策略[8]。


冲突状态回撤


依赖解析过程出现冲突属于正常情况，此时通过回撤也许可以避免部分冲突，找出其它可行解。Molinillo 通过定义 Conflict 来记录当前的冲突的必要信息：


Conflict = Struct.new(
  :requirement,
  :requirements,
  :existing,
  :possibility_set,
  :locked_requirement,
  :requirement_trees,
  :activated_by_name,
  :underlying_error
)



重点关注 underlying_error，它记录了所拦截的指定类型错误，并用于状态回撤时的一些判断依据 (后面会解释)。这里我们先看一下定义的错误类型：


# frozen_string_literal: true

module Molinillo

  class ResolverError < StandardError; end
   
  # 错误信息："Unable to find a specification for `#{dependency}`"
  class NoSuchDependencyError < ResolverError ... end
        
  # 错误信息："There is a circular dependency between ..."
  class CircularDependencyError < ResolverError ... end
        
  # 当出现版本冲突时抛出
  # 错误信息："Unable to satisfy the following requirements:\n\n ..."
  class VersionConflict < ResolverError ... end
end



除了主动拦截错误之外，possiblity 不存在时也会主动生成冲突，同时进入状态回撤处理。发生冲突后调用 #create_conflict 和 #unwind_for_conflict 两个方法分别用于生成 Conflict 对象和状态回撤。


def process_topmost_state
  if possibility
    attempt_to_activate
  else
    create_conflict
    unwind_for_conflict
  end
rescue CircularDependencyError => underlying_error
  create_conflict(underlying_error)
  unwind_for_conflict
end

def attempt_to_activate
  debug(depth) { 'Attempting to activate ' + possibility.to_s }
  existing_vertex = activated.vertex_named(name)
  if existing_vertex.payload
    debug(depth) { "Found existing spec (#{existing_vertex.payload})" }
    attempt_to_filter_existing_spec(existing_vertex)
  else
    latest = possibility.latest_version
    possibility.possibilities.select! do |possibility|
      requirement_satisfied_by?(requirement, activated, possibility)
    end
    if possibility.latest_version.nil?
      # ensure there's a possibility for better error messages
      possibility.possibilities << latest if latest
      create_conflict
      unwind_for_conflict
    else
      activate_new_spec
    end
  end
end

def attempt_to_filter_existing_spec(vertex)
  filtered_set = filtered_possibility_set(vertex)
  if !filtered_set.possibilities.empty?
    activated.set_payload(name, filtered_set)
    new_requirements = requirements.dup
    push_state_for_requirements(new_requirements, false)
  else
    create_conflict
    debug(depth) { "Unsatisfied by existing spec (#{vertex.payload})" }
    unwind_for_conflict
  end
end



可以看到这 3 个方法中处理了 4 处冲突的情况。其中 #process_topmost_state 方法拦截了 CircularDependencyError 并将其记录在 Conflict 的 underlying_error 中，其余的都是因为 possibility 可行解不存在而主动抛出冲突。


我们简化成下面的状态图：

7. Molinillo 依赖校验_第9张图片

可以理解 possiblity 状态机，通过不断检查可能性，一旦出错主动生成异常。为什么要这么做 ？因为状态回溯的成本是很高的，一旦发生意味着我们之前检查工作可能就白费了。这也是 Molinillo 前向查询的充电，通过提早暴露问题，提前回溯。


unwind_for_conflict


了解了冲突时如何产生之后，接下来该 #unwind_for_conflict 登场了：


def unwind_for_conflict
  details_for_unwind = build_details_for_unwind
  unwind_options = unused_unwind_options
  debug(depth) { "Unwinding for conflict: #{requirement} to #{details_for_unwind.state_index / 2}" }
  conflicts.tap do |c|
    sliced_states = states.slice!((details_for_unwind.state_index + 1)..-1)
    raise_error_unless_state(c)
    activated.rewind_to(sliced_states.first || :initial_state) if sliced_states
    state.conflicts = c
    state.unused_unwind_options = unwind_options
    filter_possibilities_after_unwind(details_for_unwind)
    index = states.size - 1
    @parents_of.each { |_, a| a.reject! { |i| i >= index } }
    state.unused_unwind_options.reject! { |uw| uw.state_index >= index }
  end
end



冲突回溯就涉及到前面说过的两个状态需要处理，分别是状态栈 @states 和 dg 内容的回溯。@state 本身是数组实现的，其元素是各个状态的 state, 要回溯到指定的 state 则要利用 state_index，它保存在 UnwindDetails 中：


UnwindDetails = Struct.new(
  :state_index,
  :state_requirement,
  :requirement_tree,
  :conflicting_requirements,
  :requirement_trees,
  :requirements_unwound_to_instead
)

class UnwindDetails
  include Comparable
  ...
end



这里解释一下 requirement_trees，这里是指以当前需求作为依赖的需求。以上面的 Case 1 为例，当前冲突的 requirement 就是 Alamofire，对应 requirement_trees 就是依赖了 Alamofire 的 Pod A 和 B：


[
  [
    ,
     3.0 ...>
  ],[
    ,
     4.0 ...>
  ]
]



#build_details_for_unwind 主要用于生成 UnwindDetails，大致流程如下：


def build_details_for_unwind
  current_conflict = conflicts[name]
  binding_requirements = binding_requirements_for_conflict(current_conflict)
  unwind_details = unwind_options_for_requirements(binding_requirements)

  last_detail_for_current_unwind = unwind_details.sort.last
  current_detail = last_detail_for_current_unwind

  # filter & update details options
  ...
  current_detail
end



    

  1. 以 conflict.requirement 为参数，执行 #binding_requirements_for_conflict 以查找出存在冲突的需求 binding_requirements。查询是通过代理的 #search_for(dependency) 方法；
    2. 

  2. 通过 #unwind_options_for_requirements 遍历查询到的 binding_requirements 获取 requirement 对应的 state 以及该 state 在栈中的 index，用于生成 unwind_details；
    3. 

  3. 对 unwind_details 排序，取 last 作为 current_detail 并进行其他相关的修改。
    4. 



关于如何获取 state_index 和 unwind_details:


def unwind_options_for_requirements(binding_requirements)
  unwind_details = []

  trees = []
  binding_requirements.reverse_each do |r|
    partial_tree = [r]
    trees << partial_tree
    unwind_details << UnwindDetails.new(-1, nil, partial_tree, binding_requirements, trees, [])
    # 1.1 获取 requirement 对应的 state
    requirement_state = find_state_for(r)
    # 1.2 确认 possibility 存在
    if conflict_fixing_possibilities?(requirement_state, binding_requirements)
      # 1.3 生成 detail 存入 unwind_details
      unwind_details << UnwindDetails.new(
        states.index(requirement_state),
        r,
        partial_tree,
        binding_requirements,
        trees,
        []
      )
    end
    
    # 2. 沿着 requirement 依赖树的父节点获取其 state
    parent_r = parent_of(r)
    next if parent_r.nil?
    partial_tree.unshift(parent_r)
    requirement_state = find_state_for(parent_r)
    # 重复 1.2， 1.3 步骤 ...
  
    # 6. 沿着依赖树，重复上述操作
    grandparent_r = parent_of(parent_r)
    until grandparent_r.nil?
      partial_tree.unshift(grandparent_r)
      requirement_state = find_state_for(grandparent_r)
      # 重复 1.2、1.3 步骤 ...
      parent_r = grandparent_r
      grandparent_r = parent_of(parent_r)
    end
  end

  unwind_details
end



确认 state_index 后，栈回溯反而比较简单了，直接 #slice! 即可：


sliced_states = states.slice!((details_for_unwind.state_index + 1)..-1)



dg 回撤还是 activated.rewind_to(sliced_states.first || :initial_state) if sliced_states。回撤结束后，流程重新回到 Resolution Loop。


SpecificationProvider


最后一节简单聊聊 SpecificationProvider。为了更好的接入不同平台，同时保证 Molinillo 的通用性和灵活性，作者将依赖描述文件查询等逻辑抽象成了代理。


SpecificationProvider 作为单独的 Module 声明了接入端必须实现的 API：


module Molinillo
   module SpecificationProvider

    def search_for(dependency)
      []
    end

    def dependencies_for(specification)
      []
    end
    ...
  end
end



而 Provider 就是在 Molinillo 初始化的时候注入的：


require_relative 'dependency_graph'

module Molinillo

  class Resolver
    require_relative 'resolution'

    attr_reader :specification_provider
    attr_reader :resolver_ui

    def initialize(specification_provider, resolver_ui)
      @specification_provider = specification_provider
      @resolver_ui = resolver_ui
    end

    def resolve(requested, base = DependencyGraph.new)
      Resolution.new(specification_provider,
                     resolver_ui,
                     requested,
                     base).
        resolve
    end
  end
end



而在 CocoaPods 中的初始化方法则是：


# /lib/CocoaPods/resolver.rb
def resolve
  dependencies = @podfile_dependency_cache.target_definition_list.flat_map do |target|
    @podfile_dependency_cache.target_definition_dependencies(target).each do |dep|
      next unless target.platform
      @platforms_by_dependency[dep].push(target.platform)
    end
  end.uniq
  @platforms_by_dependency.each_value(&:uniq!)
  @activated = Molinillo::Resolver.new(self, self).resolve(dependencies, locked_dependencies)
  resolver_specs_by_target
rescue Molinillo::ResolverError => e
  handle_resolver_error(e)
end



该方法则处于 pod install 中的 resolve dependencies 阶段：

7. Molinillo 依赖校验_第10张图片

NoSuchDependencyError


另外，为了更好的处理产生的异常，同时保证核心逻辑对 provider 的无感知，Molinillo 将代理方法做了一层隔离，并且对异常做了统一拦截：


module Molinillo
  module Delegates

    module SpecificationProvider

      def search_for(dependency)
        with_no_such_dependency_error_handling do
          specification_provider.search_for(dependency)
        end
      end

      def dependencies_for(specification)
        with_no_such_dependency_error_handling do
          specification_provider.dependencies_for(specification)
        end
      end

      ...

      private

      def with_no_such_dependency_error_handling
        yield
      rescue NoSuchDependencyError => error
        if state
          ...
        end
        raise
      end
    end
  end
end



总结


本篇文章从依赖解析的状态维护、状态存储、状态回溯三个维度来解构 Molinillo 的核心逻辑，它们分别对应了 ResolutionState、DependencyGraph、UnwindDetail 这三种数据结构。


一开始写这篇内容时，头脑中对于这些概念是未知的，因为一开始就直接看了作者对 Molinillo 的架构阐述[9]更是完全找不到思绪，好在我有 VSCode ！


最终依据不同 Case 下的数据呈现，一点点的进行源码调试，大致摸清的 Molinillo 的状态是如何变化转移的。最后一点，英文和数据结构还是很重要的，possiblity 你理解了吗 ？


知识点问题梳理


这里罗列了五个问题用来考察你是否已经掌握了这篇文章，如果没有建议你加入收藏再次阅读：


    

  1. 说说 Resolution 栈中的 state 是如何转移的 ？
    2. 

  2. DependencyGraph 的数据通过什么方式进行回撤的 ？
    3. 

  3. #process_topmost_state 处理了几种 conflict 情况 ？
    4. 

  4. UnwindDetail 的 state_index 是如何获取的 ？
    5. 

  5. 作者如何利用 SpecificationProvider 来解偶的 ？
    6. 



参考资料


[1]


Molinillo: https://github.com/CocoaPods/Molinillo
 [2]

依赖地狱: https://www.wikiwand.com/zh-hans/%E7%9B%B8%E4%BE%9D%E6%80%A7%E5%9C%B0%E7%8B%B1
 [3]

致命错误: https://www.wikiwand.com/en/Fatal_exception_error
 [4]

PubGrub: https://medium.com/@nex3/pubgrub-2fb6470504f
 [5]

Selective dependency resolutions: https://classic.yarnpkg.com/en/docs/selective-version-resolutions
 [6]

回溯 (Backtracking): https://en.wikipedia.org/wiki/Backtracking
 [7]

#dup: https://stackoverflow.com/questions/10183370/whats-the-difference-between-rubys-dup-and-clone-methods
 [8]

PodSpec 管理策略: https://zhuanlan.zhihu.com/p/275680356
 [9]

Molinillo 的架构阐述: https://github.com/CocoaPods/Molinillo/blob/master/ARCHITECTURE.md


























你可能感兴趣的:(java,编程语言,分布式,人工智能,go)






    

  • Python常用的10个自动化脚本（附详细源码）！
进击的六角龙
Pythonpython自动化自动化办公开发语言

    前言Python是一种强大的编程语言，非常适合自动化各种任务。以下列出了Python常用于自动化的10个脚本示例，涵盖了文件管理、网络操作、数据处理等多个方面（文末附python学习资料）。1.文件备份脚本这个脚本可以定期备份指定目录下的所有文件到另一个位置。importshutilimportosimportdatetimedefbackup_files(src,dst):timestamp=d
    

    • 

  • JavaEE笔记1
Ouwly

    目标1.认识JavaEEJava语言分为三大类1.JavaSE2.JavaME3.JavaEEJavaSE，标准版，主要用于开发和部署桌面、服务器以及嵌入设备和实时环境中的Java应用程序。例如，Java应用程序开发平台Eclipse。JavaEE，企业版，主要针对企业应用的开发。例如，电子商务网站、ERP系统。JavaME，微型版，主要针对消费类电子设备的。例如，蜂窝电话和可视电话、数字机顶盒、
    

    • 

  • Java反射机制笔记
爱吃大猫的小鱼
java笔记

    在一些组件或者框架中开发中,他们本身是不知道要处理哪些类,例如jackson组件,我们给他什么类,他就要处理转换什么类newObjectMapper().writeValueAsString(user)newObjectMapper().writeValueAsString(admin)newObjectMapper().writeValueAsString(result)在web.xml中配置了
    

    • 

  • 集合框架学习题
奶糖趣多多
java开发语言

    ArrayList集合存储HashMap元素并遍历importjava.util.ArrayList;importjava.util.HashMap;importjava.util.Set;publicclassArrayListIncludeHashMapDemo{publicstaticvoidmain(String[]args){//创建ArrayList集合ArrayList>array=
    

    • 

  • 智能合约与身份验证：区块链技术的创新应用
星途码客
前沿科技智能合约区块链

    一、引言区块链，一个近年来备受瞩目的技术名词，已经从最初的数字货币领域扩展到了众多行业。那么，究竟什么是区块链？它为何如此重要？本文将深入剖析区块链技术的原理、应用及未来发展。二、区块链的基本概念区块链，从本质上讲，是一个去中心化的分布式数据库。它由一系列按照时间顺序排列的数据块组成，并采用密码学方式保证不可篡改和不可伪造。每一个数据块中包含了一定时间内的所有交易信息，包括交易的数量、交易的时间、
    

    • 

  • hive学习记录
2302_80695227
hive学习hadoop

    一、Hive的基本概念定义：Hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张表，并提供类SQL查询功能。Hive将HQL（HiveQueryLanguage）转化成MapReduce程序或其他分布式计算引擎（如Tez、Spark）的任务进行计算。数据存储：Hive处理的数据存储在HDFS（HadoopDistributedFileSystem）上。执行引擎：Hive的
    

    • 

  • Java Servlet
Qi妙代码
javaservlet开发语言

    1.Servlet进行动态网页开发1.1.用于开发动态的网页书写流程：写一个class类，去继承一个Httpservlet重写service方法，注意一定要super.service()进行动态网页的开发在web.xml中配置Servlet01com.wyb.servlet.Servlet01Servlet01/servlet/Servlet01注意：servlet-name是自己任意命名的，ur
    

    • 

  • javaee学习过程
如初^
javaee

    javaee包含了javase，然后在此基础上还使用了更多的技术。另外javaee常常跟javaweb挂钩，实际上javaee是javaweb的子集，但是个人更偏向javaee的学习，在此过程中，实际上会使用到javaweb的相关技术，但是这里着重学习javaee。学习javaee先从搭建环境开始，这里使用的是intellijidea+tomcat+mySQL进行的开发。对于intellijide
    

    • 

  • java gc 触发条件_jvm 什么情况下会触发minor gc
李硕蕾
javagc触发条件

    展开全部当JVM无法为一个新的对象分配空间时会触发MinorGC。虚拟机在进行minorGC之前会判断老年代最大的可用连续空间是否32313133353236313431303231363533e78988e69d8331333433626465大于新生代的所有对象总空间1、如果大于的话，直接执行minorGC2、如果小于，判断是否开启HandlerPromotionFailure，没有开启直接F
    

    • 

  • CityHash、FarmHash
秋夫人
哈希算法算法数据结构

    CityHash和FarmHash都是由Google开发的非加密哈希函数，专为快速处理大量数据而设计。它们在数据中心和大规模分布式系统中尤其有用，用于任务如数据分区、查找优化、数据校验等。这两种哈希函数都以其高效的性能和良好的分布特性而著称。CityHashCityHash是一系列哈希函数的集合，专门优化用于哈希字符串。它提供了多种版本，如CityHash32、CityHash64和CityHas
    

    • 

  • Rust简介、安装指南
陪倩碎碎念
rust开发语言后端

    一、Rust简介Rust是一种由Mozilla开发的系统级编程语言，自2010年首次公开发布以来，因其高性能、并发性、安全性以及开发人员友好的语法而备受瞩目。Rust的设计旨在解决传统系统级编程语言的常见问题，同时提供卓越的开发体验。以下是Rust的主要特点及其适用领域的详细阐述：特点：1.安全性：Rust的安全性体现在其独特的内存管理模型上。通过引入所有权和借用规则，Rust在编译时即能预防内存
    

    • 

  • 重塑互联网生态：探索Web 3.0、大数据与隐私保护的新篇章
Thanks_ks
IT洞察集Web3.0去中心化隐私保护技术大数据智慧引擎互联网生态重塑智能合约与DA数据安全与法规未来互联网展望

    目录引言：互联网的新纪元Web3.0：去中心化的乌托邦愿景1.去中心化架构的崛起2.智能合约与自治组织的兴起3.用户体验与创新的飞跃大数据：驱动未来的智慧引擎1.数据海洋的挖掘与利用2.数据安全与隐私保护3.人工智能与大数据的融合隐私保护：构建信任的基石1.用户数据权益的觉醒2.隐私保护技术的创新3.构建可信的互联网环境结语：展望未来引言：互联网的新纪元随着互联网技术的日新月异，我们正迈入一个全新
    

    • 

  • JAVA中数组的用法
乐愉爱吃番茄
python算法java

    在Java中，数组是一种存储相同数据类型元素的集合。以下是关于Java中数组的用法：一、数组的声明与初始化声明数组先声明后初始化：收起java复制int[]array;声明并初始化：收起java复制int[]array=newint[5];//创建一个长度为5的整数数组简化形式：收起java复制intarray[]=newint[5];初始化数组静态初始化：收起java复制int[]array={
    

    • 

  • 如何从MongoDB迁移到MySQL？这有现成经验！
36大数据

    作者：小码哥最近的一个多月时间都在做数据库的迁移工作，我目前在开发的项目在上古时代是使用MySQL作为主要数据库的，后来由于一些业务上的原因从MySQL迁移到了MongoDB，使用了几个月的时间后，由于数据库服务非常不稳定，再加上无人看管，同时MongoDB本身就是无Schema的数据库，最后导致数据库的脏数据问题非常严重。目前团队的成员没有较为丰富的Rails开发经验，所以还是希望使用Activ
    

    • 

  • Java GC 详解：Minor GC和Full GC以及CMS理解
搬山道猿
javajvm开发语言

    ConcurrentMarkandSweep(并发标记-清除)CMS的官方名称为“MostlyConcurrentMarkandSweepGarbageCollector”(主要并发-标记-清除-垃圾收集器).其对年轻代采用并行STW方式的[mark-copy(标记-复制)算法],对老年代主要使用并发[mark-sweep(标记-清除)算法]CMS的设计目标是避免在老年代垃圾收集时出现长时间的卡顿
    

    • 

  • JavaEE(2)
无柳丶先生
java-eejava

    Servlet创建一个类继承HttpServlet，重写dogetdopost方法，并在web.xml中配置Servlet作用1.接收用户发送的请求数据2.调用其他的Java程序来处理请求3.向前端做出响应请求地址ip:端口/项目名/servlet程序地址IP和端口找服务器Servlet生命周期创建：第一次访问Servlet程序时，由服务器创建初始化:在构造方法执行完成后，调用init()执行一些
    

    • 

  • 分享10个国内可以使用的GPT中文网站
GPT-Hub
gpt机器学习人工智能神经网络自然语言处理gpt-3AI作画

    在今天的人工智能领域，基于对话的语言模型已成为研究的热点，尤其是像ChatGPT这样因其出色的语言理解与对话交互能力而广受关注的模型。本文将介绍10个国内可以直接使用GPT的网站，旨在为大家在选择和使用这些优秀的AI工具时提供有价值的参考。星河易创地址：星河易创AI-AI对话、AI绘画、AI音乐等多功能人工智能应用系统星河易创是一款国内AI系统，提供集AI对话(GPT-3.5,GPT-4)、AI绘
    

    • 

  • SpringBoot项目中使用SpringData-JPA持久化数据
火星刻苦的杏仁
springbootjavamybatis

    目录一、什么是JPA二、SpringData-JPA与MybatisPuls的区别三、项目中使用JPAJPA常用注解JPA进阶使用技巧一、什么是JPAJPA是JavaPersistenceAPI的简称，中文名Java持久层API，其设计目标主要是为了简化现有的持久化开发工作和整合ORM技术。简单地说，JPA就是为POJO（PlainOrdinaryJavaObject）提供持久化的标准规范，即将J
    

    • 

  • MyBatis框架与spring框架整合
李恩11
mybatisspringjava

    MyBatis—Spring项目目前大部分的Java互联网项目，都是用SpringMVC+Spring+MyBatis搭建平台的。使用SpringIoC可以有效的管理各类的Java资源，达到即插即拔的功能；通过SpringAOP框架，数据库事务可以委托给Spring管理，消除很大一部分的事务代码，配合MyBatis的高灵活、可配置、可优化SQL等特性，完全可以构建高性能的大型网站。毫无疑问，MyB
    

    • 

  • java 设计模式（包括工厂介绍）
李恩11
java设计模式开发语言

    什么是设计模式设计模式是在软件设计中反复出现的问题的通用解决方案。它们是经过多次验证和应用的指导原则，旨在帮助软件开发人员解决特定类型的问题，提高代码的可维护性、可扩展性和重用性。设计模式是一种抽象化的思维方式，可以帮助开发人员更好地组织和设计他们的代码。它们提供了一种通用的框架，可以用于解决各种不同的软件设计问题。设计模式不是完整的代码，而是一种描述问题和解决方案之间关系的模板。设计模式并不是一
    

    • 

  • 利用Spring Boot的@Transactional注解保障业务数据的一致性
潘多编程
springboot数据库oracle

    在现代软件开发中，特别是在分布式系统和微服务架构中，确保数据的一致性是一项至关重要的任务。当应用程序需要处理多个数据库操作时，保证这些操作要么全部成功，要么全部失败（即所谓的原子性），以及确保这些操作不会干扰其他并发运行的操作（即隔离性），成为了软件工程师们面临的挑战之一。Spring框架，尤其是SpringBoot，提供了一系列工具来简化这个过程，其中之一就是@Transactional注解。什
    

    • 

  • C# 爬虫技术：京东视频内容抓取的实战案例分析
小白学大数据
pythonc#爬虫开发语言python

    摘要随着互联网技术的飞速发展，数据的获取和分析变得愈发重要。爬虫技术作为数据获取的重要手段之一，广泛应用于各个领域。本文将重点探讨C#语言在京东视频抓取中的实现过程，分析其技术细节，并提供相应的代码实现。引言京东作为中国领先的电商平台，拥有海量的商品信息和用户数据。通过爬虫技术，我们可以从京东网站抓取视频数据，用于市场分析、用户行为研究等。C#作为一种强大的编程语言，提供了丰富的网络编程接口，非常
    

    • 

  • 2024年Java爬虫利器：Jsoup详细介绍与用法_java jsoup(1)
2401_84562143
程序员java爬虫开发语言

    .method(Connection.Method.GET).execute();DocumentloginDoc=loginForm.parse();Elementform=loginDoc.select(“form”).first();//填充表单字段form.select(“input[name=username]”).val(“username”);form.select(“input[n
    

    • 

  • 一文讲清楚，AI、AGI、AIGC与AIGC、NLP、LLM，ChatGPT等概念
GPT-Hub
人工智能自然语言处理agigptchatgpt机器学习神经网络

    本文旨在深入解析人工智能（AI）、通用人工智能（AGI）、人工智能生成内容（AIGC）、自然语言处理（NLP）、大型语言模型（LLM）以及ChatGPT等关键概念，并探讨它们在现代科技发展中的重要性和实际应用。1.AI（人工智能）人工智能（AI）是指通过计算机技术来模仿、扩展甚至超越人类智能的广泛领域。AI并不局限于一种特定的技术，而是涵盖了多种技术手段，包括机器学习和深度学习等子领域。AI的应用
    

    • 

  • 每日英语单词学习 @2023-01-18
Hedgehoginwind

    每日5组单词词组学习。第1组anniversary周年纪念日devastating破坏性极大的commemoration纪念仪式gorge峡谷；咽喉；狼吞虎咽onlooker旁观者ravine沟壑；峡谷第2组compatible可共用的stagnant停滞的；不发展的giveup放弃bankonsth指望；依靠demostrate证明punishment惩罚；处罚第3组avenueofinfect
    

    • 

  • Java爬虫开发：Jsoup库在图片URL提取中的实战应用
小白学大数据
pythonjava爬虫开发语言测试工具前端javascript

    在当今的互联网时代，数据的获取和处理变得尤为重要。对于网站内容的自动化抓取，爬虫技术扮演着不可或缺的角色。Java作为一种广泛使用的编程语言，拥有丰富的库支持网络爬虫的开发。其中，Jsoup库以其简洁、高效的特点，成为处理HTML内容和提取数据的优选工具。本文将详细介绍如何使用Jsoup库开发Java爬虫，以实现图片URL的提取。Jsoup库简介Jsoup是一个用于解析HTML文档的Java库，它
    

    • 

  • Java Operator SDK
快乐骑行^_^
日常分享专栏java开发语言OperatorSDK

    JavaOperatorSDK生成项目骨架快速入门模式和最佳实践使用示例Operators实现示例OperatorQuarkusSpringBootOperators代表Kubernetes管理集群和非集群资源。这个JavaOperatorSDK(JOSDK)旨在通过使用一个对Java开发人员来说应该感觉自然的API，使编写Kubernetes操作员变得尽可能容易，并且不必担心许多低级细节，因为S
    

    • 

  • Java报错处理系列之：Unable to make protected void java.util.ResourceBundle.setParent
快乐骑行^_^
日常分享专栏java

    Java报错处理系列之：Internalerror:Unabletomakeprotectedvoidjava.util.ResourceBundle.setParentaccessible:modulejava.basedoesnot"opensjava.util"tounnamedmodule@7f1302d6一、完整报错二、报错原因三、解决方法四、更多报错解决方案一、完整报错执行Java代码
    

    • 

  • JAVA Guava排序器Ordering原理代码
邓家少爷

    一创建排序器排序器:可以用来为构建复杂的比较器，以完成集合排序的功能:本质上来说，Ordering实例无非就是一个特殊的Comparator实例。Ordering把很多基于Comparator的静态方法（如Collections.max）包装为自己的实例方法（非静态方法），并且提供了链式调用方法，来定制和增强现有的比较器//创建排序器@TestpublicvoidcreateOreing(){//
    

    • 

  • 工厂模式和策略模式的区别
Stringzhua
每日一问策略模式工厂模式

    文章目录工厂模式（FactoryPattern）设计意图适用场景结构优点缺点Java实现案例策略模式（StrategyPattern）设计意图适用场景结构优点缺点Java实现案例对比总结工厂模式（FactoryPattern）设计意图工厂模式的主要目的是将对象的创建与使用分离，通过一个工厂类来负责创建实例。这样，当我们需要创建新的对象时，不需要直接使用构造函数，而是通过工厂类来生成对象。这种模式在
    

    • 

  • java线程Thread和Runnable区别和联系
zx_code
javajvmthread多线程Runnable

    我们都晓得java实现线程2种方式，一个是继承Thread，另一个是实现Runnable。
模拟窗口买票，第一例子继承thread，代码如下
package thread;
public class ThreadTest {
public static void main(String[] args) {
Thread1 t1 = new Thread1(
    

    • 

  • 【转】JSON与XML的区别比较
丁_新
jsonxml

    1.定义介绍
(1).XML定义
扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。
XML是标
    

    • 

  • c++ 实现五种基础的排序算法
CrazyMizzz
C++c算法

    #include<iostream>
using namespace std;
//辅助函数，交换两数之值
template<class T>
void mySwap(T &x, T &y){
T temp = x;
x = y;
y = temp;
}
const int size = 10;
//一、用直接插入排
    

    • 

  • 我的软件
麦田的设计者
我的软件音乐类娱乐放松

         这是我写的一款app软件，耗时三个月，是一个根据央视节目开门大吉改变的，提供音调，猜歌曲名。1、手机拥有者在android手机市场下载本APP，同意权限，安装到手机上。2、游客初次进入时会有引导页面提醒用户注册。（同时软件自动播放背景音乐）。3、用户登录到主页后，会有五个模块。a、点击不胫而走，用户得到开门大吉首页部分新闻，点击进入有新闻详情。b、
    

    • 

  • linux awk命令详解
被触发
linux awk

    awk是行处理器: 相比较屏幕处理的优点，在处理庞大文件时不会出现内存溢出或是处理缓慢的问题，通常用来格式化文本信息
awk处理过程: 依次对每一行进行处理，然后输出
awk命令形式:
awk [-F|-f|-v] ‘BEGIN{} //{command1; command2} END{}’ file
[-F|-f|-v]大参数，-F指定分隔符，-f调用脚本，-v定义变量 var=val
    

    • 

  • 各种语言比较
_wy_
编程语言

                        Java Ruby PHP 擅长领域                  
    

    • 

  • oracle 中数据类型为clob的编辑
知了ing
oracle clob

    public void updateKpiStatus(String kpiStatus,String taskId){
Connection dbc=null;
Statement stmt=null;
PreparedStatement ps=null;
try {
dbc = new DBConn().getNewConnection();
//stmt = db
    

    • 

  • 分布式服务框架 Zookeeper -- 管理分布式环境中的数据
矮蛋蛋
zookeeper

    原文地址：
http://www.ibm.com/developerworks/cn/opensource/os-cn-zookeeper/
安装和配置详解
本文介绍的 Zookeeper 是以 3.2.2 这个稳定版本为基础，最新的版本可以通过官网 http://hadoop.apache.org/zookeeper/来获取，Zookeeper 的安装非常简单，下面将从单机模式和集群模式两
    

    • 

  • tomcat数据源
alafqq
tomcat

    数据库
JNDI(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。
没有使用JNDI时我用要这样连接数据库：
03.  Class.forName("com.mysql.jdbc.Driver"); 
04.  conn
    

    • 

  • 遍历的方法
百合不是茶
遍历

                                                          遍历
在java的泛
    

    • 

  • linux查看硬件信息的命令
bijian1013
linux

    linux查看硬件信息的命令
一.查看CPU：
cat /proc/cpuinfo
 
二.查看内存：
free
 
三.查看硬盘：
df
 
linux下查看硬件信息
1、lspci 列出所有PCI 设备；
lspci - list all PCI devices:列出机器中的PCI设备（声卡、显卡、Modem、网卡、USB、主板集成设备也能
    

    • 

  • java常见的ClassNotFoundException
bijian1013
java

    1.java.lang.ClassNotFoundException: org.apache.commons.logging.LogFactory   添加包common-logging.jar2.java.lang.ClassNotFoundException: javax.transaction.Synchronization    
    

    • 

  • 【Gson五】日期对象的序列化和反序列化
bit1129
反序列化

    对日期类型的数据进行序列化和反序列化时，需要考虑如下问题：
 
1. 序列化时，Date对象序列化的字符串日期格式如何
2. 反序列化时，把日期字符串序列化为Date对象，也需要考虑日期格式问题
3. Date A -> str -> Date B,A和B对象是否equals
  默认序列化和反序列化
 
 
import com
    

    • 

  • 【Spark八十六】Spark Streaming之DStream vs. InputDStream
bit1129
Stream

      1. DStream的类说明文档：
 
/**
* A Discretized Stream (DStream), the basic abstraction in Spark Streaming, is a continuous
* sequence of RDDs (of the same type) representing a continuous st
    

    • 

  • 通过nginx获取header信息
ronin47
nginx header

    1. 提取整个的Cookies内容到一个变量，然后可以在需要时引用，比如记录到日志里面，
if ( $http_cookie ~* "(.*)$") {
        set $all_cookie $1;
}
    变量$all_cookie就获得了cookie的值，可以用于运算了

    

    • 

  • java-65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999
bylijinnan
java

    参考了网上的http://blog.csdn.net/peasking_dd/article/details/6342984
写了个java版的：
public class Print_1_To_NDigit {
/**
* Q65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999
* 1.使用字符串
    

    • 

  • Netty源码学习-ReplayingDecoder
bylijinnan
javanetty

    ReplayingDecoder是FrameDecoder的子类，不熟悉FrameDecoder的，可以先看看
http://bylijinnan.iteye.com/blog/1982618
API说，ReplayingDecoder简化了操作，比如：
FrameDecoder在decode时，需要判断数据是否接收完全：
public class IntegerH
    

    • 

  • js特殊字符过滤
cngolon
js特殊字符js特殊字符过滤

    1.js中用正则表达式 过滤特殊字符, 校验所有输入域是否含有特殊符号function stripscript(s) {    var pattern = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）&mdash;—|{}【】‘；：”“'。，、？]"
    

    • 

  • hibernate使用sql查询
ctrain
Hibernate

    
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.hibernate.Hibernate;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transa
    

    • 

  • linux shell脚本中切换用户执行命令方法
daizj
linuxshell命令切换用户

    经常在写shell脚本时，会碰到要以另外一个用户来执行相关命令，其方法简单记下：
 
1、执行单个命令：su - user -c "command"
如：下面命令是以test用户在/data目录下创建test123目录
[root@slave19 /data]# su - test -c "mkdir /data/test123" 
    

    • 

  • 好的代码里只要一个 return 语句
dcj3sjt126com
return

    别再这样写了：public boolean foo() {    if (true) {         return true;     } else {          return false;    
    

    • 

  • Android动画效果学习
dcj3sjt126com
android

    1、透明动画效果
方法一：代码实现
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
View rootView = inflater.inflate(R.layout.fragment_main, container, fals
    

    • 

  • linux复习笔记之bash shell (4)管道命令
eksliang
linux管道命令汇总linux管道命令linux常用管道命令

    转载请出自出处：
http://eksliang.iteye.com/blog/2105461  
  bash命令执行的完毕以后，通常这个命令都会有返回结果，怎么对这个返回的结果做一些操作呢？那就得用管道命令‘|’。
    上面那段话，简单说了下管道命令的作用，那什么事管道命令呢？
    答：非常的经典的一句话，记住了，何为管
    

    • 

  • Android系统中自定义按键的短按、双击、长按事件
gqdy365
android

    在项目中碰到这样的问题：
由于系统中的按键在底层做了重新定义或者新增了按键，此时需要在APP层对按键事件（keyevent）做分解处理，模拟Android系统做法，把keyevent分解成：
1、单击事件：就是普通key的单击；
2、双击事件：500ms内同一按键单击两次；
3、长按事件：同一按键长按超过1000ms（系统中长按事件为500ms）；
4、组合按键：两个以上按键同时按住； 
    

    • 

  • asp.net获取站点根目录下子目录的名称
hvt
.netC#asp.nethovertreeWeb Forms

    使用Visual Studio建立一个.aspx文件(Web Forms)，例如hovertree.aspx,在页面上加入一个ListBox代码如下：
<asp:ListBox runat="server" ID="lbKeleyiFolder" />
 
那么在页面上显示根目录子文件夹的代码如下：
string[] m_sub
    

    • 

  • Eclipse程序员要掌握的常用快捷键
justjavac
javaeclipse快捷键ide

      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。   曾有人在豆瓣评
《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个
程序员图书列表，目的也就是通过读书，让程序员变懒。  写道 程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可
    

    • 

  • c++编程随记
lx.asymmetric
C++笔记

     为了字体更好看，改变了格式……
 
&&运算符：
 
#include<iostream>
using namespace std;
int main(){
     int a=-1,b=4,k;
     k=(++a<0)&&!(b--
    

    • 

  • linux标准IO缓冲机制研究
音频数据
linux

    一、什么是缓存I/O(Buffered I/O)缓存I/O又被称作标准I/O,大多数文件系统默认I/O操作都是缓存I/O。在Linux的缓存I/O机制中，操作系统会将I/O的数据缓存在文件系统的页缓存(page cache)中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。1.缓存I/O有以下优点:A.缓存I/O使用了操作系统内核缓冲区，
    

    • 

  • 随想 生活
暗黑小菠萝
生活

    其实账户之前就申请了，但是决定要自己更新一些东西看也是最近。从毕业到现在已经一年了。没有进步是假的，但是有多大的进步可能只有我自己知道。
 
毕业的时候班里12个女生，真正最后做到软件开发的只要两个包括我，PS：我不是说测试不好。当时因为考研完全放弃找工作，考研失败，我想这只是我的借口。那个时候才想到为什么大学的时候不能好好的学习技术，增强自己的实战能力，以至于后来找工作比较费劲。我
    

    • 

  • 我认为POJO是一个错误的概念
windshome
javaPOJO编程J2EE设计

     
            这篇内容其实没有经过太多的深思熟虑，只是个人一时的感觉。从个人风格上来讲，我倾向简单质朴的设计开发理念；从方法论上，我更加倾向自顶向下的设计；从做事情的目标上来看，我追求质量优先，更愿意使用较为保守和稳妥的理念和方法。
   &
    

    •