软件设计-模块化设计初思考二

关注

最新推荐文章于 2025-07-22 20:30:44 发布 · 407 阅读

原创 ·

本内容遵循 CC 4.0 BY-SA 版权协议

软件设计-模块化设计初思考一 软件设计-模块化设计初思考一 模块化设计说明：模块化设计，简单地说就是程序的编写不是开始就逐条录入计算机语句和指令，而是首先用主程序、子程序、子过程等框架把软件的主要结构和流程描述出来，并定义和调试好各个框架之间的输入、输出链接关系。逐步求精的结果是得到一系列以功能块为单位的算法描述。以功能块为单位进行程序设计，实现其求解算法的方法称为模块化。 模块化的目的是为了降低程序复杂度，使程序设计、调试和维护等操作简单化。改变某个子功能只需相应改变相应模块即可。最近在设计软件，突发奇想，把自己的模块化 阅读详情

软件设计-模块化设计初思考二

模块化设计初思考二

软件设计-模块化设计初思考二

书接上回

我们已经
设计了Sender接口用来实现信息的发送，为此我们做了两个实现类，分别实现，邮箱发送与短信发送。（实现类，未实现功能）
设计了 Verify接口 用来实现不同的验证方式为此我们做了两个实现类，分别实现，邮箱验证与账号验证。（实现类，未实现功能）

我们将接口聚合于 AccountModularity 类代码如下

package com.ss.account.main;

import com.ss.account.sender.MailSender;
import com.ss.account.sender.Sender;
import com.ss.account.verify.MailVerify;
import com.ss.account.verify.Verify;

public class AccountModularity {

    //发送接口 实现
    private Sender sender;

    //验证接口 实现
    private Verify verify;

    public AccountModularity() {
        init();
    }

    private void init() {
        sender = new MailSender();
        verify = new MailVerify();
    }

    private String sendVerifyCode(String account) {
        //TODO 处理逻辑
        String code = "123asd";
        return sender.sendVerifyCode(account,code) ? code : null;
    }

    public boolean verifyAccount(String account) {
        //TODO 处理逻辑
        return verify.verifyAccount(account);
    }
}

AccountModularity类的升级

今天我们要对这个类进行升级
升级之前，我们在看看需要的功能：

登录
注册
修改个人信息
验证账号是否存在（隐藏功能）

首先，我们来分析一下，具体功能

package com.ss.account.main;

import com.ss.account.sender.Sender;
import com.ss.account.verify.Verify;
import com.ss.main.BaseModularity;
import com.ss.main.Lifecycle;

/**
 * @author Jangs
 * @param <T> 用户类
 */
public abstract class AccountModularity<T> {

    //发送接口 实现
    protected Sender sender;

    //验证接口 实现
    protected Verify verify;

    /**
     * 保护构造器
     */
    protected AccountModularity() {
    }

    /**
     * 发送 验证码
     * @param account 用户
     * @return String 验证码
     */
    protected abstract String sendVerifyCode(String account) ;

    /**
     * 验证用户是否存在
     * @param account 用户
     * @return boolean 是否存在
     */
    protected abstract boolean verifyAccount(String account);

    /**
     * 登录
     * @return T 用户实体类
     */
    protected abstract T login();

    /**
     * 注册
     * @param t 用户实体类
     */
    protected abstract void register(T t);

    /**
     * 修改个人信息
     * @param t 用户实体类
     */
    protected abstract void updateAccountInfo(T t);

}

边界化

在此，我提出模块化开发的一个理解： 边界化

说明

1、模块内的所有方法，都必须是不能直接被外部访问的
2、提供一个 public 入口方法，来调用其他方法。

举一个例子

我们设计了一个房子，在房子内部设计了它很多的功能，可以做饭，可以洗澡，可以睡觉，但是这些内容都是在房子内部完成的。

如果，我们想要去做饭，我们应该怎么办？
我们需要从门口进入，进入厨房，做饭，出厨房的同时带出饭菜。
这是一整套流程，
我们模块内的所有方法，都必须是不能直接被外部访问的，如果可以直接被外部访问，就好像，我们去做饭不需要进房间一样，那么房子的意义在哪里呢？（家徒无四壁）。别人可以随随便便的进入你家的厨房，去你家洗澡，碎觉。

再举一个例子

我们是一个人，我们可能做很多的事情，但是，当我们需要别人的帮助时，比方，需要他人借给我点钱。
这时我们需要怎么做呢？
直接掏他的口袋，去拿钱？且不说能不能成功，你伸进去的时候，你也被打了。而且，现在都是电子货币。
那正常情况下，我们需要怎么做呢？
第一步、我们需要通知他，我想借点钱。
第二步、由他自己决定，要不要，借钱给我们。

我们不能主宰别人的行为，我们需要通知告知Ta 让Ta 自己来做。

因此，我们的 AccountModularity类 需要以下几项优化
1、将类，修改成抽象类， AbstractAccountModularity类
2、我们需要提供一个入口方法，鉴于，以后的模块都需要此方法，我们直接抽象成抽象类BaseModularity （仅提供入口方法）

入口抽象类

代码如下：

package com.ss.main;

/**
 * @author Jangs
 * 此类 仅提供入口方法
 */
public abstract class BaseModularity {
    /**
     * 入口方法
     */
    public abstract void doService();
    
}

再来

我们设计一个房子（模块）但是，我们也仅仅是提供各种可能性，具体建设，我们不能定义，最后，销毁，我们不可定义
所以，我设计一个生命周期接口，去统一所有模块的初始化与销毁工作。

Lifecycle接口

package com.ss.main;

/**
 * @author Jangs
 */
public interface Lifecycle {
    /**
     * 初始化
     */
    void init();

    /**
     * 销毁
     */
    void destroy();
}

设计此模块的好处如下“
1、统一初始化与销毁
2、为后期多模块组合，树状初始化做装备。
最后我们优化的

本期最终优化成果

AbstractAccountModularity 如此

package com.ss.account.main;

import com.ss.account.sender.Sender;
import com.ss.account.verify.Verify;
import com.ss.main.BaseModularity;
import com.ss.main.Lifecycle;

/**
 * @author Jangs
 * @param <T> 用户类
 */
public abstract class AbstractAccountModularity<T> extends BaseModularity implements Lifecycle {

    //发送接口 实现
    protected Sender sender;

    //验证接口 实现
    protected Verify verify;

    /**
     * 发送 验证码
     * @param account 用户
     * @return String 验证码
     */
    protected abstract String sendVerifyCode(String account) ;

    /**
     * 验证用户是否存在
     * @param account 用户
     * @return boolean 是否存在
     */
    protected abstract boolean verifyAccount(String account);

    /**
     * 登录
     * @return T 用户实体类
     */
    protected abstract T login(String account, String password);

    /**
     * 注册
     * @param t 用户实体类
     */
    protected abstract void register(T t);

    /**
     * 修改个人信息
     * @param t 用户实体类
     */
    protected abstract void updateAccountInfo(T t);

}

自此完成

对于用户模块的抽象已经实现并优化，但是，具体如何调用？我们下期分解
在此我提出几个问题
1、如何实现不同的验证?
2、如果以后同时实现两种验证方式，我们该如何扩展与优化?
3、如果，以后此模块需要扩展，如何扩展？
4、如果，以后需要跟其他模块一同合作，如何链接？
5、我大量使用集成，java又不能实现多继承，日后扩展如何？