// 建筑隐喻影响下的代码组织
// 强调"蓝图"、"基础"、"结构"
public class ApplicationArchitecture {
  // "基础层" - 类似建筑的地基
  private final DatabaseLayer databaseLayer;
  // "结构层" - 类似建筑的框架
  private final BusinessLogicLayer businessLayer;
  // "装饰层" - 类似建筑的装修
  private final PresentationLayer presentationLayer;
  
  public ApplicationArchitecture() {
    // 必须按顺序构建：先地基，再框架，最后装修
    this.databaseLayer = new DatabaseLayer();
    this.businessLayer = new BusinessLogicLayer(databaseLayer);
    this.presentationLayer = new PresentationLayer(businessLayer);
  }
}

// 农业隐喻影响下的代码组织
// 强调"生长"、"培育"、"适应"
public class EvolvingSystem {
  // "种子" - 最小可行产品
  private final MinimalFeatureSet seedFeatures;
  // "生长" - 渐进式扩展
  private final List<FeatureGrowth> growthHistory;
  // "修剪" - 持续重构
  private final RefactoringStrategy pruningStrategy;
  
  public void evolve(UserFeedback feedback) {
    // 根据环境（用户反馈）调整生长方向
    growthHistory.add(featureGrowth.adapt(feedback));
    pruningStrategy.prune(deadCode);
  }
}

// 建筑隐喻的典型实现：严格的分层架构
// 每一层只能调用下一层，不能跨层调用
public abstract class Layer {
  protected final Layer nextLayer;
  
  protected Layer(Layer nextLayer) {
    this.nextLayer = nextLayer;
  }
  
  public abstract Response handle(Request request);
}

public class PresentationLayer extends Layer {
  public PresentationLayer(Layer nextLayer) {
    super(nextLayer);
  }
  
  @Override
  public Response handle(Request request) {
    // 处理展示逻辑
    ViewModel viewModel = toViewModel(request);
    return nextLayer.handle(new Request(viewModel));
  }
}

public class BusinessLayer extends Layer {
  public BusinessLayer(Layer nextLayer) {
    super(nextLayer);
  }
  
  @Override
  public Response handle(Request request) {
    // 处理业务逻辑
    BusinessResult result = processBusinessLogic(request);
    return nextLayer.handle(new Request(result));
  }
}

// 农业隐喻的典型实现：渐进式开发
public class FeatureGarden {
  private final List<Feature> plantedFeatures = new ArrayList<>();
  private final List<Feature> matureFeatures = new ArrayList<>();
  
  // "播种"：实现最小可行功能
  public void plantFeature(FeatureSeed seed) {
    Feature feature = seed.sprout();
    plantedFeatures.add(feature);
  }
  
  // "培育"：根据反馈迭代完善
  public void cultivate(UserFeedback feedback) {
    for (Feature feature : plantedFeatures) {
      if (feedback.isRelevant(feature)) {
        feature.grow(feedback);
      }
    }
  }
  
  // "收获"：功能成熟后发布
  public void harvest() {
    Iterator<Feature> iterator = plantedFeatures.iterator();
    while (iterator.hasNext()) {
      Feature feature = iterator.next();
      if (feature.isMature()) {
        matureFeatures.add(feature);
        iterator.remove();
      }
    }
  }
  
  // "修剪"：移除不再需要的功能
  public void prune(Feature feature) {
    plantedFeatures.remove(feature);
    matureFeatures.remove(feature);
  }
}

需求分析 → 系统设计 → 详细设计 → 编码 → 测试 → 维护
   ↓          ↓          ↓        ↓       ↓       ↓
 规格书     蓝图       施工图   施工    验收    交付

种子 → 发芽 → 生长 → 修剪 → 收获
  ↓      ↓      ↓      ↓      ↓
MVP   迭代1   迭代2   重构   发布

// 敏捷开发的迭代式实现
public class AgileDevelopment {
  private final ProductBacklog backlog;
  private final List<Sprint> completedSprints = new ArrayList<>();
  
  // Sprint 计划：选择本迭代的"种子"
  public Sprint planSprint(int duration) {
    List<UserStory> stories = backlog.selectTopItems(10);
    return new Sprint(stories, duration);
  }
  
  // Sprint 执行：让功能"生长"
  public Increment executeSprint(Sprint sprint) {
    Increment increment = new Increment();
    for (UserStory story : sprint.getStories()) {
      // 小步前进，频繁交付
      Feature feature = developFeature(story);
      increment.addFeature(feature);
    }
    return increment;
  }
  
  // Sprint 回顾：评估"收成"
  public void reviewSprint(Increment increment, StakeholderFeedback feedback) {
    // 根据反馈调整下一轮的"种植计划"
    backlog.reprioritize(feedback);
  }
  
  // 持续"修剪"：重构
  public void refactor(Increment increment) {
    increment.improveInternalStructure();
  }
}

// 多隐喻思维的示例
public class SoftwareProject {
  
  // 在架构设计阶段使用建筑隐喻
  public Architecture designArchitecture(Requirements requirements) {
    // 像建筑师一样思考：结构、稳定性、可扩展性
    return new Architecture()
        .withFoundation(dataLayer)
        .withStructure(businessLayer)
        .withFacade(presentationLayer);
  }
  
  // 在迭代开发阶段使用农业隐喻
  public void developIteratively(Backlog backlog) {
    // 像农民一样思考：播种、培育、收获
    for (Sprint sprint : sprints) {
      plant(backlog.getTopItems());
      cultivate(sprint);
      harvest(increment);
    }
  }
  
  // 在质量保证阶段使用编程隐喻
  public void ensureQuality(Code code) {
    // 像程序员一样思考：逻辑、正确性、验证
    verify(code.getLogic());
    validate(code.getOutput());
    prove(code.getCorrectness());
  }
  
  // 在问题解决阶段使用战争隐喻
  public void solveProblems(List<Bug> bugs) {
    // 像指挥官一样思考：优先级、资源分配、目标
    prioritize(bugs);
    allocateResources(team);
    eliminate(criticalBugs);
  }
}

// 转型前：建筑隐喻主导的瀑布开发
public class WaterfallProject {
  // 所有需求在项目开始时确定
  private final List<Requirement> allRequirements;
  // 设计完成后不允许变更
  private final Design frozenDesign;
  
  public WaterfallProject(List<Requirement> requirements) {
    this.allRequirements = requirements;
    this.frozenDesign = designAll(requirements);
  }
  
  public Product execute() {
    // 严格按照阶段执行
    Code code = implementAll(frozenDesign);
    TestResult tests = testAll(code);
    if (!tests.allPassed()) {
      // 发现问题代价巨大
      throw new ProjectFailedException("Late defect found");
    }
    return new Product(code);
  }
}

// 转型后：农业隐喻主导的敏捷开发
public class AgileProject {
  private final ProductBacklog backlog;
  private final List<Increment> increments = new ArrayList<>();
  
  public AgileProject(ProductBacklog backlog) {
    this.backlog = backlog;
  }
  
  public Product execute() {
    // 渐进式生长
    while (backlog.hasItems()) {
      Sprint sprint = planSprint(backlog);
      Increment increment = developSprint(sprint);
      
      // 根据反馈调整方向
      UserFeedback feedback = collectFeedback(increment);
      backlog.reprioritize(feedback);
      
      increments.add(increment);
    }
    return new Product(increments);
  }
}

// 综合运用多种隐喻设计一个电商平台
public class ECommercePlatform {
  
  // 建筑隐喻：稳定的基础架构
  public Infrastructure designInfrastructure() {
    return Infrastructure.builder()
        .foundation(new DatabaseCluster())    // 地基
        .structure(new MicroserviceMesh())    // 框架
        .facade(new APIGateway())             // 外立面
        .build();
  }
  
  // 农业隐喻：渐进式功能开发
  public void developFeatures(ProductBacklog backlog) {
    for (Sprint sprint : planSprints(backlog)) {
      // 播种新功能
      List<Feature> features = plantFeatures(sprint.getStories());
      // 培育和修剪
      features.forEach(f -> cultivate(f, sprint.getFeedback()));
      // 收获成熟的特性
      harvestMatureFeatures(features);
    }
  }
  
  // 编程隐喻：精确的质量保证
  public QualityReport ensureQuality(System system) {
    return QualityReport.builder()
        .correctness(verifyLogic(system))      // 逻辑正确性
        .reliability(stressTest(system))       // 压力测试
        .performance(benchmark(system))        // 性能基准
        .security(penetrationTest(system))     // 安全渗透测试
        .build();
  }
  
  // 战争隐喻：紧急问题处理
  public void handleIncident(Incident incident) {
    // 评估"敌情"
    Severity severity = assessSeverity(incident);
    // 调集"兵力"
    Team responseTeam = assembleTeam(severity);
    // "消灭"问题
    responseTeam.resolve(incident);
    // "战后复盘"
    postMortem(incident);
  }
}