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

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)

        

            

                
    
                    
  • 掌握 npm 登录与登出：使用 npm login 和 npm logout 命令
                        2401_85743969
npm前端node.js
                        
    npm（NodePackageManager）是JavaScript编程语言的包管理器，广泛用于Node.js项目中管理依赖。npm提供了丰富的功能，包括包的安装、版本管理、发布等。使用npmlogin和npmlogout命令可以与npm仓库进行身份验证和登出操作。本文将详细介绍这两个命令的使用方法和相关场景。一、npmlogin命令的使用npmlogin命令用于在终端中向npm仓库进行身份验证，
    
                    
    • 
                    
  • 【Java探索之旅】运算符解密 位运算，移位运算
                        屿小夏
Java之光java开发语言
                        
    屿小夏：个人主页个人专栏：Java编程秘籍莫道桑榆晚，为霞尚满天！文章目录前言一、位运算符1.1按位与&1.2按位或|1.3按位取反~1.4按位异或^二、移位运算符1.1左移>1.3无符号右移>>>️全篇总结前言位运算符是Java中的重要运算符之一，用于对数据的二进制位进行操作。Java中的位运算符包括按位与（&）、按位或（|）、按位取反（~）和按位异或（^）。这些运算符可以帮助我们进行位级操作，
    
                    
    • 
                    
  • MacOS系统搭建Appium自动化测试环境
                        xiangzhihong8
前端macosappium
                        
    一、Appium简介1.1什么是APPiumAPPium是一个开源测试自动化框架，适用于原生、混合或移动Web应用程序的自动化测试工具。APPium使用WebDriver协议驱动iOS、Android等应用程序。APPium具有如下特点：支持多平台（Android、iOS等）。支持多语言（python、java、ruby、js、c#等)。APPium是跨平台的，可以用在OSX，Windows以及L
    
                    
    • 
                    
  • JavaCV拉取本地摄像头推送到RTMP
                        翻晒时光
视频直播JavaCV转码
                        
    话不多说，直接上源码packagecom.javacvstudy.javacvstudy;importjavax.swing.JFrame;importorg.bytedeco.javacpp.Loader;importorg.bytedeco.javacpp.avcodec;importorg.bytedeco.javacpp.opencv_core.IplImage;importorg.byt
    
                    
    • 
                    
  • 16、Spring 框架基础：开启 Java 企业级开发的新时代
                        翻晒时光
javaspring后端
                        
    嘿，Java开发者们！今天我们要一起探索Spring框架的基础知识。Spring框架是Java企业级开发中最受欢迎的框架之一，它为我们提供了一种轻量级、非侵入式的开发方式，帮助我们构建可维护、可扩展和松耦合的应用程序。让我们一起开启Spring框架的学习之旅，感受它如何简化我们的开发过程，提升开发效率，开启Java企业级开发的新时代！一、Spring框架概述1.什么是Spring框架？Spring
    
                    
    • 
                    
  • 14、Java 对象关系映射（ORM）框架：简化数据库操作的利器
                        翻晒时光
从0学Javajava
                        
    嘿，Java开发者们！在我们的编程旅程中，经常会遇到一个重要的任务，那就是将Java对象和数据库表进行交互。传统的JDBC编程虽然强大，但代码往往会变得繁琐且容易出错。这时候，对象关系映射（ORM）框架就闪亮登场啦它可以极大地简化我们的数据库操作，将Java对象和数据库表之间的映射变得更加简单、直观和高效。今天，我们就来深入探讨一下Java中的ORM框架，看看它们是如何改变我们与数据库打交道的方式
    
                    
    • 
                    
  • There was a problem confirming the ssl certificate: [SSL:CERTIFICATE_ VERIFY_ FAILED]certificate解决方案
                        爱编程的喵喵
Python基础课程pythonpipSSLcertificate解决方案
                        
      大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的知识进行总结与归纳，不仅形成深入且独到的理解，而且能够帮助新手快速入门。  本文主要介绍了Therewasaproblemco
    
                    
    • 
                    
  • chatgpt赋能python：Python怎么安装到U盘
                        vacvefito
ChatGptchatgpt人工智能计算机
                        
    Python怎么安装到U盘在日常的编程工作中，Python是一门十分常用的编程语言。而有时候并非每个人都愿意在电脑上安装Python，或者在外出时需要借助一台非自己的电脑来进行Python编程。因此，将Python安装到U盘成为一个方便实用的选择。为什么要将Python安装到U盘将Python安装到U盘可以让我们在不同设备上进行Python编程，而不用担心设备内是否已经安装了Python。这样可以
    
                    
    • 
                    
  • 2022年最新【Java八股文背诵版面试题】面试必备，查漏补缺；多线程+spring+JVM调优+分布式+redis+算法
                        Java面试_
Javajava面试jvm
                        
    前言春招，秋招，社招，我们Java程序员的面试之路，是挺难的，过了HR，还得被技术面，小刀在去各个厂面试的时候，经常是通宵睡不着觉，头发都脱了一大把，还好最终侥幸能够入职一个独角兽公司，安稳从事喜欢的工作至今...近期也算是抽取出大部分休息的时间，为大家准备了一份通往大厂面试的小捷径，准备了一整套Java复习面试的刷题以及答案，我知道很多同学不知道怎么复习，不知道学习过程中哪些才是重点，其实，你们
    
                    
    • 
                    
  • 网页文件下载的各种方式
                        怪咖学生
前端javascript开发语言
                        
    1.直接通过HTML标签实现文件下载最常见且简便的文件下载方式是使用HTML的标签，配合download属性，允许用户下载文件。适用于静态文件和指定的文件路径。方法：下载文件href:指定文件路径，可以是相对路径或绝对路径。download:指定下载时文件的名称。如果省略，会使用文件的默认名称。优点：简单易用，不需要JavaScript。浏览器原生支持。可用于静态资源的下载。缺点：仅限于文件已经存
    
                    
    • 
                    
  • 开源的数据库监控和管理工具—PMM
                        蚂蚁在飞-
数据库人工智能运维后端
                        
    PMM（PerconaMonitoringandManagement）是一个开源的数据库监控和管理工具，主要用于监控MySQL、MariaDB、MongoDB和PostgreSQL等数据库的性能和健康状况。PMM提供了一套可视化的界面，帮助数据库管理员和开发人员对数据库进行深度监控、性能优化和故障排查。PMM由两个主要组件组成：1.PMMServerPMMServer是PMM的核心组件，负责收集和
    
                    
    • 
                    
  • SpringBoot的细节问题
                        千禧年@
springboot后端java
                        
    一、重点填空Pivotal团队在原有spring框架的基础上开发了全新的SpringBoot框架。SpringBoot框架在开发过程中大量使用约定优于配置的思想来摆脱框架中各种复杂的手动配置。SpringBoot2.1.3版本要求Java8及以上版本的支持。SpringBoot2.1.3版本框架官方声明支持的第三方项目构建工具包括有maven(3.3+)和gradle(4.4+)@RestCont
    
                    
    • 
                    
  • 【2024年华为OD机试】(C卷,100分)- 悄悄话 （Java & JS & Python&C/C++）
                        妄北y
算法汇集笔记总结(保姆级)华为odc语言javapythonjavascript
                        
    一、问题描述题目描述给定一个二叉树，每个节点上站一个人，节点数字表示父节点到该节点传递悄悄话需要花费的时间。初始时，根节点所在位置的人有一个悄悄话想要传递给其他人，求二叉树所有节点上的人都接收到悄悄话花费的时间。输入描述给定二叉树的层序遍历序列：0920-1-1157-1-1-1-132注：-1表示空节点。输出描述返回所有节点都接收到悄悄话花费的时间。38用例输入0920-1-1157-1-1-1
    
                    
    • 
                    
  • npm、cnpm、pnpm、yarn的区别
                        迷途小码农零零发
前端知识库npm前端node.js
                        
    npm,cnpm,pnpm,和yarn都是JavaScript的包管理工具，用于自动化处理包的安装、更新、配置和管理。它们之间的主要区别在于它们各自的实现方式、性能优化、以及一些特有的功能。npmnpm(NodePackageManager)是Node.js的默认包管理器，也是最早被广泛接受和使用的JavaScript包管理工具。它允许用户从npm公共仓库中安装、共享和分发代码包。npm在项目中创
    
                    
    • 
                    
  • Java基础入门3《IDEA使用与数据类型详解》
                        圆圆Alice
Alice的Java学习笔记intellijideajava
                        
    Hi，我又出现了，是Alice，今天我学习的是，刚刚入门，肯定是先搞定各种开发工具，还一些理解性的内容，视频来源于‘蓝桥研究院’.....本节笔记重点提要：本节笔记重点提要：1.IntellijIdea下载与安装2.IntellijIdea使用3.使用IntellijIdea打印一个界面（案列）4.变量5.Java的数据类型、数据范围、符号的意义——————————————————————————
    
                    
    • 
                    
  • Java服务端服务网关：Kong与Spring Cloud Gateway的比较
                        微赚淘客系统开发者@聚娃科技
javakong网络
                        
    Java服务端服务网关：Kong与SpringCloudGateway的比较大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在微服务架构中，服务网关是至关重要的组件，它负责处理服务间的入站和出站流量，提供路由、过滤、限流等功能。Kong和SpringCloudGateway是两个流行的服务网关解决方案，它们各有特点和优势。本文将对Kong和SpringCloudG
    
                    
    • 
                    
  • 你还在以为golang切片扩容是1/4的增加吗?其实早就已经变啦!
                        爱学习的狮王
gogolang开发语言后端
                        
    golang切片扩容原理变化前言切片扩容对比Go1.17(这个版本中的扩容也是目前大部分书籍和博客中讲到的切片扩容内容)Go1.18(这个是目前实际的扩容规则,虽然在1.20中入参变了,但是核心的扩容逻辑没有变,所以还是以1.18举例)结语前言最近看go语言的切片原理时发现实际的扩容规则和一些博客和书上讲的不一致,所以看看各版本的源码中切片的扩容到底是怎么做的,看源码是最快捷且准确的方式,go语言
    
                    
    • 
                    
  • （新春特辑）腾讯开源MimicMotion整合包，最强图片生成跳舞视频的动作视频模型，动作丝滑没有破绽
                        struggle2025
人工智能计算机视觉机器学习AI作画腾讯云AI代码助手
                        
    一、项目介绍：（文末提供下载）腾讯图片生成跳舞视频的项目MimicMotion，高质量人类动作视频生成与置信感姿势。亮点：丰富的细节，良好的时间平滑性，以及长视频长度。效果同时支持面部特征和唇形同步，不止可以搞跳舞视频，也可以做数字人。本文信息图片均来源于GitHub开源地址：https://github.com/Tencent/MimicMotion二、效果展示三、概述近年来，生成式人工智能在图
    
                    
    • 
                    
  • springboot整合Logback
                        m0_74825634
面试学习路线阿里巴巴springbootlogback后端
                        
    Logback介绍描述Logback是由log4j创始人设计的另外一种开源日志组件，性能比log4j要好。相对是一个可靠、通用、快速而又灵活的Java日志框架。Logback主要分三个模块1、logback-core：其他两个模块的基础模块2、logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j。API，可以很方便地更换成其它日志系统，如log4j或JDK14L
    
                    
    • 
                    
  • 【Docker】Docker中的动态容器管理：利用Golang实现Docker容器动态重命名的高级策略与最佳实践
                        m0_74825634
面试学习路线阿里巴巴dockergolang容器
                        
    【Docker】Docker中的动态容器管理：利用Golang实现Docker容器动态重命名的高级策略与最佳实践大家好我是寸铁??总结了一篇【Docker】Docker中的动态容器管理：利用Golang实现Docker容器动态重命名的高级策略与最佳实践喜欢的小伙伴可以点点关注??前言今天遇到一个新的需求，要动态改变运行中的容器名字。可以考虑先把容器删除再重新创建容器那这里要考虑一个问题:假设我容器
    
                    
    • 
                    
  • window10下编译hadoop报错：Failed to execute goal org.apache.maven.plugins:maven-antrun-plugin:1.7:
                        huangxgc
hadoophadoopwindows
                        
    Windows10下buildhadoop2.7.3报错：Failedtoexecutegoalorg.apache.maven.plugins:maven-antrun-plugin:1.7:[ERROR]Failedtoexecutegoalorg.apache.maven.plugins:maven-antrun-plugin:1.7:run(dist)onprojecthadoop-hdf
    
                    
    • 
                    
  • java集成kafka案例
                        沉墨的夜
javakafka开发语言
                        
    要在Java项目中集成ApacheKafka以实现消息的生产和消费，步骤如下：1.引入Maven依赖在您的pom.xml文件中添加以下依赖，以包含Kafka客户端库：org.apache.kafkakafka-clients2.8.0org.springframework.kafkaspring-kafka2.7.02.配置Kafka生产者首先，设置生产者的配置属性：importorg.apach
    
                    
    • 
                    
  • ShardingSphere实例讲解
                        沉墨的夜
java数据库分库分表shardingsphere
                        
    ShardingSphere（原名Sharding-JDBC）是一个开源的分布式数据库中间件，它为Java应用提供了透明的数据库分片、读写分离、分布式事务等功能。在使用ShardingSphere时，应用不需要了解数据库分片的实现细节，它会自动将SQL请求路由到正确的数据库和表。以下是一个简单的ShardingSphere-JDBC实例讲解，展示如何在Java项目中配置和使用Sharding-JD
    
                    
    • 
                    
  • 推荐开源项目：Chat-Template - 快速构建聊天机器人原型的利器
                        侯深业Dorian

                        
    推荐开源项目：Chat-Template-快速构建聊天机器人原型的利器chat-templateChat-TemplateisaReactcomponentthatenablesquickprototypingofbotconversations.项目地址:https://gitcode.com/gh_mirrors/ch/chat-template1、项目介绍Chat-Template是一款基于
    
                    
    • 
                    
  • Google Protocol Buffers介绍
                        fengbingchun
Caffe
                        
    GoogleProtocolBuffers(简称Protobuf)，是Google的一个开源项目，它是一种结构化数据存储格式，是Google公司内部的混合语言数据标准，是一个用来序列化（将对象的状态信息转换为可以存储或传输的形式的过程）结构化数据（即行数据，存储在数据库里，可以用二维表结构来逻辑表达实现的数据）的技术，支持多种语言诸如C++、Java以及Python。可以使用该技术来持久化数据（将
    
                    
    • 
                    
  • Yarn安装和使用
                        米粒宝的爸爸
前端前端
                        
    安装npminstall-gyarnYarn的官网Home|Yarn-JavaScript软件包管理器|Yarn中文文档-Yarn中文网部分命令yarninit-初始化某个项目yarninstall/link-默认安装依赖yarnaddtaco-安装某个依赖并默认保存到packageyarnremovetaco-移除某个依赖yarnaddtaco-dev-安装某个开发时的依赖yarnupgrade
    
                    
    • 
                    
  • Python 网络爬虫进阶：动态网页爬取与反爬机制应对
                        Milk夜雨
pythonpython爬虫
                        
    在上一篇文章中，我们学习了如何使用Python构建一个基本的网络爬虫。然而，在实际应用中，许多网站使用动态内容加载或实现反爬机制来阻止未经授权的抓取。因此，本篇文章将深入探讨以下进阶主题：如何处理动态加载的网页内容应对常见的反爬机制爬虫性能优化通过具体实例，我们将探讨更复杂的网络爬虫开发技巧。一、动态网页爬取现代网页通常通过JavaScript加载动态内容。直接使用requests获取的HTML可
    
                    
    • 
                    
  • CRM 微服务
                        山猪打不过家猪
C#微服务架构云原生
                        
    文章目录项目地址一、项目地址教程作者：教程地址：代码仓库地址：所用到的框架和插件：dbtairflow一、用户与认证服务主要功能：用户注册、登录、注销。认证（OAuth、JWT等）。权限和角色管理（RBAC/ABAC）。单点登录（SSO）。技术亮点：集成第三方身份认证（如Google、AzureAD）。使用APIGateway统一进行身份认证。客户管理服务主要功能：存储和管理客户信息（姓名、联系方
    
                    
    • 
                    
  • 如何规划一台 Linux 主机，步骤是怎样？思维导图 代码示例（java 架构)
                        用心去追梦
linuxjava架构
                        
    规划一台Linux主机，尤其是为了部署Java架构的应用程序，涉及多个步骤。下面我将列出一个基本的规划流程，并提供一些代码示例和建议来帮助你理解如何进行这样的规划。由于思维导图难以通过文本形式表达，我会以结构化的方式描述这个过程，你可以根据这个结构创建自己的思维导图。规划Linux主机（Java应用）1.确定需求应用程序需求：确定Java应用的具体需求，包括预计的用户数量、数据处理量等。硬件资源评
    
                    
    • 
                    
  • Acerola：基于.NET Core的六边形架构服务模板安装与使用指南
                        樊会灿

                        
    Acerola：基于.NETCore的六边形架构服务模板安装与使用指南hexagonal-architecture-acerolaAnHexagonalArchitectureservicetemplatewithDDD,CQRS,TDDandSOLIDusing.NETCore2.0.Allsmallfeaturesaretestableandcouldbemocked.Adapterscoul
    
                    
    • 
                                
  • 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设计
                                    
      
            这篇内容其实没有经过太多的深思熟虑，只是个人一时的感觉。从个人风格上来讲，我倾向简单质朴的设计开发理念；从方法论上，我更加倾向自顶向下的设计；从做事情的目标上来看，我追求质量优先，更愿意使用较为保守和稳妥的理念和方法。 
   &
    
                                
    •