Java实现ATM架构设计

• 2022 年 7 月 14 日
• 笔记
• Java SE小项目, 架构设计

云ATM架构设计

说明

//www.processon.com/view/link/62ca68ee5653bb74ddcdd582 点击连接可查看项目流程图，帮助小伙伴们开发

启动程序（Start.java）

public class Start {
    public static void main(String[] args) {
        MainView viewObj = new MainView();
        viewObj.mainView();
    }
}

视图层（View）

1、主菜单（MainView）

// 主菜单
// 温馨提示，当用户进入小功能后在输入窗口输入 Q/q 可以退出当前功能
public class MainView {
    /*
        打印菜单
        无参数、无返回值
        根据原型图 打印主菜单
        接收用户输入，并作简单判断 （如用户输入超出选择范围。返回重新输入）
        根据用户输入的编号调用相应接口
    */
    public static void mainView() {}

    /*
        注册
        无参数、无返回值
        让用户输入 用户名，调用 service.UserService.login(name);  参数：用户名  返回值：0：存在   1：不存在  2: 被冻结， 先判断用户名是否存在,是否被冻结
        再输入密码，确认密码，并判断两次密码是否一致，输入的用户名密码是否符合规定，这部分逻辑自己处理
        打印密保问题，让用户输入答案（密保不强制用户设置，可以为空）
        调用 service.UserService.register(); // 接收参数：用户名、密码、密保答案1、密保答案2  返回值 0：注册成功, 1：未知错误
        通过返回值做逻辑处理
    */
    public static void registerView() {}

    /*
        登录
        无参数、无返回值
        让用户输入 用户名  调用 service.UserService.login(name); 参数：用户名  返回值：0：存在   1：不存在  3: 被冻结， 先判断用户名是否存在,是否被冻结
        再输入密码  调用 service.UserService.login(name, password); 接收参数：用户名、密码  返回值 0：登录成功, 1：密码有误
        通过返回值做逻辑处理
        若连续三次密码输入错误 则调用 AdminService.lockUser(name) 锁定账户
        登录成功 将用户名赋值给 view.UserView.currentUser 属性，调用用户界面 view.UserView.userView() 进入用户菜单界面
    */
    public static void loginView() {}

    /*
        忘记密码
        被 mainView()调用、无参数、无返回值
        让用户输入 用户名,调用 service.UserService.login(name);  参数：用户名  返回值：0：存在   1：不存在  3: 被冻结， 先判断用户名是否存在,是否被冻结
        打印密保问题，让用户输入答案，
        调用 service.UserService.forgetPwd(name, 答案1， 答案2);根据返回值做相应处理
        若连续输入三次密保答案均不正确 则调用 service.AdminService.lockUser(name) 锁定账户
        再输入密码，确认密码，并判断两次密码是否一致，
        调用 service.AdminService.resetService(name, newPassword) // 无返回值
        若密保未设置 则提示若要找回密码请联系管理员
    */
    public static void forgetPwdView() {}

    /*
        管理员登录
        被 mainView()调用、无参数，无返回值
        让用户输入用户名，调用 service.AdminService.adminLogin(name);
        adminLogin可先判断管理员用户名是否存在，// 返回值： 0：用户名存在  1：用户名不存在
        再输入密码 service.AdminService.adminLogin(name, password);  // 返回值： 0：登录成功  1：密码不正确
        若密码连续输入三次错误，则让界面睡1分钟，让用户无法操作
        若登录成功 将用户名赋值给 view.AdminView.currentAdmin; 并返回返回管理员界面 view.AdminView.adminView();
    */
    public static void adminLoginView(String name, String password) {}
}

2、用户菜单（UserView）

// 用户菜单层
public class UserView {
    // 定义
    public static String currentUser;
    public static boolean isLoop = true;
    /*
        打印用户菜单 （参照原型图）
        无参数、无返回值
        接收用户输入。并作简单判断
        根据用户输入的编号调用对应方法

        若查看余额，直接调用 String balance = dao.Data.showBalance(currentUser);// 参数： 当前用户名   返回用户余额
        若查看流水 直接调用 String flowNew = dao.Data.flowNew(currentUser); //参数： 当前用户名   返回流水信息
    */
    public static void userView() {}

    /*
        转账
        被 userView() 调用， 无参数，无返回值
        让用户输入转账对象，调用 service.UserService.login(name);  参数：目标用户名  返回值：0：存在   1：不存在  3: 被冻结， 先判断用户名是否存在,是否被冻结
        让用户输入转账金额， 调用 service.CoreService.transfer(currentUser, 转账对象，转账金额);
        根据返回值再做处理
    */
    public static void transferView(){}

    /*
        预约存款
        输入预约的时间，这里使用正则来匹配时间，判断时间输入的是否符合规定
        做一个 random 随机数（0和1） 若为0则打印已预约，为1打印此时间已被预约，重新输入
        输入存款金额，对输入进行处理，是否为数字且>0, 若不是则提醒并返回重新输入
        调用 service.CoreService.reserve() // 参数： 当前用户， 存款金额， 预约时间   返回值（int）: 存款码
        返回存款码，打印给用户
    */
    public static void reserveView(){}

    /*
        预约取款
        输入预约的时间，这里使用正则来匹配时间，判断时间输入的是否符合规定
        做一个 random 随机数（0和1） 若为0则打印已预约，为1打印此时间已被预约，重新输入
        输入取款金额，对输入进行处理，是否为数字且>0, 若不是则提醒并返回重新输入
        调用 service.CoreService.withdraw()  // 参数： 当前用户， 存款金额, 预约时间   返回值： 取钱码 ，-1: 余额不足
        根据返回做逻辑处理
        若返回值不为 -1 则返回取款码，并将取款码打印给用户查看
    */
    public static void withdrawView(){}

    /*
        用户修改密码
        输入原密码， 调用 service.UserService.login(currentUser, password);
        若返回 1 则原密码输入有误，若连续三次输入错误，则调用 service.AdminService.lockUser(name) 锁定账户 并返回至主菜单
        若返回 0，则原密码输入正确，再输入新密码，确认密码，并判断两次密码是否一致，
        调用 service.AdminService.resetService(currentUser, newPassword) 修改密码，无返回值
    */
    public static void setPwdView(){}

    /*
        退出登录
        将 currentUser 置为null, 让循环条件 isLoop = false;
        并返回到主菜单
    */
    public static void loginView(){}
}

3、管理员菜单（AdminView)

// 管理员菜单层
public class AdminView {
    // 当前登录的管理员
    public static String currentAdmin;
    // 循环条件
    public static boolean isLoop = true;
    /*
        打印管理员用户菜单 （参照原型图）
        无参数、无返回值
        接收用户输入。并作简单判断
        根据用户输入的编号调用对应方法

        若用户选择开通账户 则调用 view.MainView.registerView(); // 无参数无返回值
    */
    public static void adminView(){}

    /*
        冻结用户
        让管理员输入需要冻结的用户名
        调用 service.AdminService.lockUser(name);
        若返回1则用户名不存在，让用户重新输入
        若为0则冻结成功
    */
    public static void lockView(){}

    /*
        修改用户余额
        输入用户名，调用 service.UserService.login(name);  参数：目标用户名  返回值：0：存在   1：不存在  3: 被冻结， 先判断用户名是否存在,是否被冻结
        若存在，则调用 double balance = dao.Data.showBalance(currentUser); 打印当前余额
        提示管理员输入 修改额度为多少，调用 service.AdminService.setBalance(name, balance);
        打印修改额度成功！
    */
    public static void setBalanceView(){}

    /*
        开通管理员账户
        用户输入注册的用户名，判断用户名是否符合规定
        若符合，调用 service.AdminService.adminRegister(name);
        adminRegister 来判断该用户名是否已被注册 // 返回值： 0：未被注册  1：已被注册
        若未被注册 则提示输入密码，再次输入确认密码，判断两次密码是否一致，并判断是否符合规定
        若一致，则调用 service.AdminService.adminRegister(name, password);  // 无返回值
        完成注册
    */
    public static void adminRegisterView(){}

    /*
        重置用户密码
        让管理员输入需要重置密码的用户名
        调用 service.AdminView.resetService(name); // 返回值： 0：重置成功  1：用户名不存在
        根据返回值做逻辑处理
        若重置成功，则打印密码重置成功，新密码为 000000 请尽快修改该密码
    */
    public static void resetView(){}

    /*
        退出登录
        将 currentAdmin 置为null, 让循环条件 isLoop = false;
        并返回 主菜单
    */
    public static void loginView(){}
}

业务逻辑层 （service）

1、用户登录注册相关业务处理 （UserService）

/*
    注册、登录、忘记密码、管理员登录
    预约存款、预约取款、转账、查看余额、查看流水、修改密码，退出登录
    开通账户、冻结账户、修改额度、开通管理员账户、重置用户密码，退出登录
*/

// 用户相关业务处理
public class UserService {
    /*
        1、注册
        接收参数：用户名、密码、密保答案1、密保答案2
        返回值 0：注册成功, 1：未知错误
        对密码进行加密处理
        判断传入的密保答案是否为空，如果为空，不做处理 （密保不强制用户一定要设置）
        创建用户对象，并加入集合
    */
    public static int register(String name, String password, String pwdProtectO, String pwdProtectT) {
        // 返回值 0：注册成功, 1：未知错误
        return 0;
    }

    /*
        2、登录
        接收参数：用户名、密码
        返回值 0：登录成功, 1：密码有误
        对密码加密，再进行比较
    */
    public static int login(String name, String password) {
        // 返回值 0：登录成功, 1：密码有误
        return 0;
    }

    /*
        登录，先判断用户名是否存在
        参数：用户名
        返回值：0：存在   1：不存在， 2: 被冻结
    */
    public static int login(String name) {
        // 返回值：0：存在   1：不存在  2: 被冻结
        return 0;
    }

    /*
        3、忘记密码
        接收参数：用户名， 密保答案1、密保答案2
        返回值(int):  0：输入正确, 1、密保答案不正确  2：用户未设置密保
        判断用户是否设置密保
        判断密保答案是否正确
    */
    public static void forgetPwd(String name, String pwdProtect0, String pwdProtect1) {}
}

2、管理员用户相关业务处理（AdminService）

public class AdminService {
    /*
        管理员登录
        参数：用户名
        返回值： 0：用户名存在  1：用户名不存在
    */
    public static int adminLogin(String name) {
        // 返回值： 0：用户名存在  1：用户名不存在
        return 0;
    }

    /*
        管理员登录
        参数：用户名，密码
        返回值： 0：登录成功  1：密码不正确
        对密码进行加密后比对
    */
    public static int adminLogin(String name, String password) {
        // 返回值： 0：登录成功  1：密码不正确
        return 0;
    }

    /*
        冻结账户
        参数：用户名
        修改 isLock 属性
        判断用户名是否存在，不存在返回 1
        存在即冻结， 并更新记录 管理员对象.record += “（记录）”；
        返回值： 0：用户冻结成功 1：用户名不存在
    */
    public static void lockUser(String name) {}

    /*
        修改用户额度
        参数：用户名， 修改的额度
        无返回值
        遍历集合找到用户对象，修改其额度
        并更新记录 管理员对象.record += “（记录）”；
    */
    public static void setBalance(String name, double balance){}

    /*
        开通管理员账户
        参数：用户名，密码
        new一个管理员对象，并添加到管理员集合中
    */
    public static void adminRegister(String name, String password) {}

    /*
        判断该用户名是否已被注册
        参数：用户名难
        返回值： 0：未被注册  1：已被注册
        通过遍历管理员集合来判断
        并更新记录 管理员对象.record += “（记录）”；
    */
    public static int adminRegister(String name) {
        // 返回值： 0：未被注册  1：已被注册
        return 0;
    }

    /*
        重置重置用户密码
        参数 用户名
        返回值： 0：重置成功  1：用户名不存在
        先判断用户是否存在，若存在则将用户密码改为 000000 并加密
        并更新记录 管理员对象.record += “（记录）”；
    */
    public static int resetService(String name){
        // 返回值： 0：重置成功  1：用户名不存在
        return 0;
    }

    /*
        管理员修改用户密码
        参数 用户名,新密码  无返回值
        把密码加密后更新到用户对象
        并更新记录 管理员对象.record += “（记录）”；
    */
    public static void resetService(String name, String newPassword){}
}

3、核心业务逻辑处理（CoreService）

// 核心业务逻辑处理
public class CoreService {
    /*
        转账
        参数： 当前用户， 转账对象， 转账金额
        返回值： 0: 转账成功  1、余额不足
        判断当前用户余额是否充足
        当前用户余额 -= sal, 转帐对象余额 += sal
        记录流水
        return int;
    */
    public static int transfer(String currentUser, String targetUser, double sal) {
        // 返回值： 0: 转账成功  1、余额不足
        return 0;
    };

    /*
        预约存款
        参数： 当前用户， 存款金额， 预约时间
        遍历集合找到用户对象，balance += sal （可以与线下ATM数据库做一个同步更新， 这里我直接给他加上了）
        用 random 随机数生成一个6位数的存款码
        并将 对象中的 存款码，预约时间更新
        并记录流水
        返回值（int）: 存款码
    */
    public static int reserve(String currentUser, double sal, String date){
        // 返回值（int）: 存款码
        return 123456;
    }

    /*
        预约取款
        参数： 当前用户， 存款金额, 预约时间
        返回值： 取钱码 ，-1: 余额不足
        判断余额是否够用，若余额不足返回 -1，
        充足则更新余额，balance -= sal （这里同存款业务）
        用 random 随机数生成一个6位数的取款码
        并将 对象中的 取款码，预约时间更新
        并记录流水
        并返回取钱码
    */
    public static int withdraw(String currentUser, double sal, String date){
        // 返回值： 取钱码 ，-1: 余额不足
        return -1;
    }
}

数据层（dao）

/*
    用户存储数据采用 HashMap 集合 (普通用户，管理员用户各使用一个集合)， 以用户名作为 key ，用户对象为 value
    普通用户数据 创建用户对象
        用户名                       String name
        密码 （加密）                String password
        是否被冻结                   boolean isLock
        余额                         double balance
        预约存款时间                 String appointmentCTime
        预约取款时间                 String appointmentQTime
        存款金额                     double deposit
        取款金额                     double withdraw
        存钱码                       int depositCode
        取钱码                       int withdrawCode
        流水信息                     String flowNew
        密保问题一答案               String pwdProtectO
        密保问题二答案               String pwdProtectT

    管理员用户 管理员对象
        用户名                       String name
        密码 （加密）                String password
        操作记录                     String record

*/
public class User {
    private String name;
    private String password;
    private boolean isLock = false;
    private double balance;
    private String appointmentCTime;
    private String appointmentQTime;
    private double deposit;
    private double withdraw;
    private int depositCode;
    private int withdrawCode;
    private String flowNew;
    private String pwdProtectO;
    private String pwdProtectT;

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public User(String name, String password, String pwdProtectO, String pwdProtectT) {
        this.name = name;
        this.password = password;
        this.pwdProtectO = pwdProtectO;
        this.pwdProtectT = pwdProtectT;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public boolean isLock() {
        return isLock;
    }


    public void setLock(boolean lock) {
        isLock = lock;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public String getAppointmentCTime() {
        return appointmentCTime;
    }

    public void setAppointmentCTime(String appointmentCTime) {
        this.appointmentCTime = appointmentCTime;
    }

    public String getAppointmentQTime() {
        return appointmentQTime;
    }

    public void setAppointmentQTime(String appointmentQTime) {
        this.appointmentQTime = appointmentQTime;
    }

    public double getDeposit() {
        return deposit;
    }

    public void setDeposit(double deposit) {
        this.deposit = deposit;
    }

    public double getWithdraw() {
        return withdraw;
    }

    public void setWithdraw(double withdraw) {
        this.withdraw = withdraw;
    }

    public int getDepositCode() {
        return depositCode;
    }

    public void setDepositCode(int depositCode) {
        this.depositCode = depositCode;
    }

    public int getWithdrawCode() {
        return withdrawCode;
    }

    public void setWithdrawCode(int withdrawCode) {
        this.withdrawCode = withdrawCode;
    }

    public String getFlowNew() {
        return flowNew;
    }

    public void setFlowNew(String flowNew) {
        this.flowNew = flowNew;
    }

    public String getPwdProtectO() {
        return pwdProtectO;
    }

    public void setPwdProtectO(String pwdProtectO) {
        this.pwdProtectO = pwdProtectO;
    }

    public String getPwdProtectT() {
        return pwdProtectT;
    }

    public void setPwdProtectT(String pwdProtectT) {
        this.pwdProtectT = pwdProtectT;
    }
}

public class SuperUser {
    private String name;
    private String password;
    private String record;

    public SuperUser(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getRecord() {
        return record;
    }

    public void setRecord(String record) {
        this.record = record;
    }
}

public class Data {
    public static HashMap<Object, Object> userMap = new HashMap<>();// 普通用户集合
    public static HashMap<Object, Object> adminMap = new HashMap<>();// 管理员用户集合

    static {
        // 初始化一个管理员账户
        SuperUser james = new SuperUser("james", "heisgoat");
        adminMap.put("james", james);
    }

    /*
        展示用户余额
        参数： 当前用户名
        返回值： double balance
        遍历用户集合获得用户对象， 取出用户余额
    */
    public static double showBalance(String currentUser) {
        // 返回用户余额
        return 0;
    }

    /*
        查看用户流水
        参数： 当前用户名
        返回值： String类型的记录
        遍历用户集合获得用户对象， 取出用户流水信息
    */
    public static String flowNew(String name) {
        return "返回一个字符串";
    }
}