《软件工程》第 11 章 - 结构化软件开发

啊阿狸不会拉杆

发布于 2026-01-21 11:08:12

1060

结构化软件开发是一种传统且经典的软件开发方法，它强调将软件系统分解为多个独立的模块，通过数据流和控制流来描述系统的行为。本章将结合 Java 代码示例、可视化图表，深入讲解面向数据流的分析与设计方法以及实时系统设计的相关内容。

11.1 面向数据流与数据字典

11.1.1 实体 - 关系图

实体 - 关系图（ER 图）用于描述数据对象及其之间的关系，是数据库设计的重要工具。例如，一个简单的图书馆管理系统的 ER 图：

展示了图书、读者和借阅记录之间的关系。

11.1.2 数据流图的实时系统扩充

传统数据流图（DFD）主要关注数据的流动和处理，而实时系统的 DFD 需要考虑时间约束和并发处理。例如，一个简单的温度监控系统的实时 DFD：

展示了温度监控系统的数据流和处理逻辑。

11.1.3 基于数据流的分析方法

基于数据流的分析方法通过识别系统中的数据流和处理过程，建立系统的逻辑模型。例如，一个订单处理系统的分析过程：

顶层 DFD：展示系统与外部实体的交互，如客户、供应商。
0 层 DFD：将系统分解为主要处理过程，如订单接收、订单验证、库存检查等。
详细 DFD：进一步细化每个处理过程的输入和输出。

11.2 面向数据流的设计过程

11.2.1 基本概念和设计过程

面向数据流的设计方法将数据流图转换为软件的模块结构，主要步骤包括：

确定数据流图的类型（变换型或事务型）。
映射数据流图到软件结构。
定义模块接口和控制关系。
优化软件结构。

11.2.2 变换分析

变换分析适用于具有明显输入、变换和输出三个部分的数据流图。例如，一个数据处理系统的变换分析过程：

展示了变换型数据流图的结构。对应的 Java 代码示例：

public class DataProcessingSystem {
    // 输入处理模块
    public static DataObject inputProcessing(InputData input) {
        // 数据验证和转换
        DataObject data = new DataObject();
        data.setValue(input.getValue());
        return data;
    }

    // 中心变换模块
    public static DataObject centralTransform(DataObject data) {
        // 数据处理逻辑
        data.setValue(data.getValue() * 2);
        return data;
    }

    // 输出处理模块
    public static OutputData outputProcessing(DataObject data) {
        // 结果格式化
        OutputData output = new OutputData();
        output.setResult("处理结果: " + data.getValue());
        return output;
    }

    public static void main(String[] args) {
        InputData input = new InputData(10);
        DataObject processedData = inputProcessing(input);
        processedData = centralTransform(processedData);
        OutputData output = outputProcessing(processedData);
        System.out.println(output.getResult());
    }
}

class InputData {
    private int value;

    public InputData(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

class DataObject {
    private int value;

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
}

class OutputData {
    private String result;

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }
}

11.2.3 事务分析

事务分析适用于具有多个事务类型的数据流图，每个事务可能有不同的处理路径。例如，一个银行系统的事务分析过程：

展示了事务型数据流图的结构。对应的 Java 代码示例：

public class BankingSystem {
    // 事务处理器接口
    public interface TransactionHandler {
        void processTransaction(Transaction transaction);
    }

    // 存款处理器
    public static class DepositHandler implements TransactionHandler {
        @Override
        public void processTransaction(Transaction transaction) {
            System.out.println("处理存款事务: " + transaction.getAmount());
            // 存款处理逻辑
        }
    }

    // 取款处理器
    public static class WithdrawalHandler implements TransactionHandler {
        @Override
        public void processTransaction(Transaction transaction) {
            System.out.println("处理取款事务: " + transaction.getAmount());
            // 取款处理逻辑
        }
    }

    // 事务分发器
    public static class TransactionDispatcher {
        public void dispatchTransaction(Transaction transaction) {
            TransactionHandler handler;
            switch (transaction.getType()) {
                case "DEPOSIT":
                    handler = new DepositHandler();
                    break;
                case "WITHDRAWAL":
                    handler = new WithdrawalHandler();
                    break;
                default:
                    throw new IllegalArgumentException("未知事务类型: " + transaction.getType());
            }
            handler.processTransaction(transaction);
        }
    }

    public static void main(String[] args) {
        Transaction transaction = new Transaction("DEPOSIT", 1000.0);
        TransactionDispatcher dispatcher = new TransactionDispatcher();
        dispatcher.dispatchTransaction(transaction);
    }
}

class Transaction {
    private String type;
    private double amount;

    public Transaction(String type, double amount) {
        this.type = type;
        this.amount = amount;
    }

    public String getType() {
        return type;
    }

    public double getAmount() {
        return amount;
    }
}

11.3 实时系统设计

11.3.1 实时系统性能要求

实时系统需要满足严格的时间约束，其性能要求包括：

响应时间：系统对外部事件的响应速度。
吞吐量：系统在单位时间内处理的任务数量。
截止时间：任务必须完成的时间点。

11.3.2 实时系统设计要素

实时系统设计需要考虑以下要素：

任务调度：确定任务执行的顺序和时间分配。
资源管理：合理分配内存、CPU 等资源。
可靠性设计：采用冗余、容错机制，确保系统在异常情况下正常运行。

11.3.3 实时系统设计方法

常见的实时系统设计方法有：

静态优先级调度：为每个任务分配固定优先级，高优先级任务优先执行。
动态优先级调度：任务优先级根据执行情况动态调整。
时间触发架构：任务按预设时间点触发执行。

11.3.4 设计实例

以一个简单的交通灯控制系统为例，展示实时系统设计：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TrafficLightSystem {
    // 交通灯状态
    public enum LightState {
        RED, GREEN, YELLOW
    }

    private LightState currentState = LightState.RED;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    // 初始化系统
    public void initialize() {
        // 设置红灯持续时间为30秒
        scheduler.scheduleAtFixedRate(() -> changeState(LightState.GREEN), 0, 30, TimeUnit.SECONDS);
        // 设置绿灯持续时间为20秒
        scheduler.scheduleAtFixedRate(() -> changeState(LightState.YELLOW), 30, 20, TimeUnit.SECONDS);
        // 设置黄灯持续时间为5秒
        scheduler.scheduleAtFixedRate(() -> changeState(LightState.RED), 50, 5, TimeUnit.SECONDS);
    }

    // 改变交通灯状态
    private synchronized void changeState(LightState newState) {
        this.currentState = newState;
        System.out.println("交通灯状态变更为: " + newState);
        // 触发相应的硬件控制
        controlHardware(newState);
    }

    // 控制硬件
    private void controlHardware(LightState state) {
        // 实际项目中这里会包含控制硬件的代码
        System.out.println("发送信号控制硬件: " + state);
    }

    // 关闭系统
    public void shutdown() {
        scheduler.shutdown();
    }

    public static void main(String[] args) {
        TrafficLightSystem system = new TrafficLightSystem();
        system.initialize();

        // 运行1分钟后关闭系统
        try {
            Thread.sleep(60000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        system.shutdown();
    }
}

本章全面介绍了结构化软件开发的核心内容，通过丰富的 Java 代码示例、可视化图表和详细的文字说明，帮助读者理解和掌握面向数据流的分析与设计方法以及实时系统设计的要点。结构化软件开发方法虽然传统，但在许多领域仍然具有重要的应用价值。如果对某个知识点有疑问，或希望补充更多案例，欢迎随时交流！

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-05-26，如有侵权请联系 cloudcommunity@tencent.com 删除

系统设计