Java连接Oracle数据库开发银行管理系统【三、实现篇】

package com.ll.test;

import com.ll.service.Bank;

public class TestBank {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Bank().mainMenu();// 启动程序
    }
}

package com.ll.service;

import java.util.List;
import java.util.Scanner;

import com.ll.po.Admin;
import com.ll.po.Customer;

public class Bank {

    //创建Scanner对象接收用户从键盘输入
    Scanner input = new Scanner(System.in);
    //创建AdminService对象，该对象定义了管理员的所有功能
    AdminService as = new AdminService();
    //创建CustomerService对象，该对象定义了顾客的所有功能
    CustomerService cs = new CustomerService();
    //声明成员变量顾客对象，顾客登录时保存顾客信息，然后在顾客其他功能中使用
    Customer cust1 = null;
    /*
     * 银行系统主菜单及主菜单流程控制方法
     */
    public void mainMenu() {
        System.out.println("------------------银行系统--------------------");
        System.out.println("******************1.管理员********************");
        System.out.println("******************2.顾客**********************");
        System.out.println("-----------------------------------------------");
        //用户输入不合法时控制循环输入，输入合法时操作结束退出循环。
        while (true) {
            System.out.print("请选择：");
            //接收用户输入的菜单操作id
            int menuId = input.nextInt();
            //判断1,2为合法输入
            if (menuId == 1 || menuId == 2) {
                System.out.print("请输入用户名：");
                //接收用户输入的用户名
                String user = input.next();
                System.out.print("请输入密码：");
                //接收用户输入的密码
                String pwd = input.next();
                //用户选择1.管理员时的操作
                if (menuId == 1) {
                    //创建一个管理员对象（在这个项目中其实没啥大的用处，但是如果再添加功能的就方便多了，例如，更新密码）
                    Admin admin = new Admin();
                    admin.setAdminName(user);
                    admin.setAdminPwd(pwd);
                    //调用AdminService的登录方法将管理员对象当做参数传入进行登录验证
                    boolean isLogin = as.adminLogin(admin);
                    //返回结果为true表明登录成功，进入管理员菜单。
                    if (isLogin) {
                        System.out.println("登录成功！");
                        adminMenu();// 调用管理员功能菜单项
                        //返回结果为false表明登录失败，重新回到主菜单。
                    } else {
                        System.out.println("登录失败！");
                        mainMenu();// 递归，主菜单
                    }
                }
                //用户选择2.顾客时的操作
                if (menuId == 2) {
                    // 新建一个客户对象，保存这个登录对象，
                    Customer cust = new Customer();
                    //把接收的用户名和密码设置到顾客对象中
                    cust.setCustName(user);
                    cust.setCustPwd(pwd);
                    //调用CustomerService的登录方法将顾客对象当做参数传入进行登录验证，
                    //并拿到该顾客所有信息，存放到事先声明的成员变量cust1中
                    cust1 = cs.custLogin(cust);
                    if (cust1 != null) {
                        System.out.println("登录成功！");
                        custMenu();// 跳转到客户功能菜单
                        //判断如果返回的对象为空，则表示登录失败，回到主菜单
                    } else {
                        System.out.println("登录失败！");
                        mainMenu();// 返回主菜单
                    }
                }
                //合法操作完成时退出循环
                break;
                //非法输入时，输出信息，然后重新让用户输入。
            } else {
                System.out.println("非法输入，请重新输入。");
                continue;// 跳转到主菜单
            }
        }
    }
    
    /*
     * 管理员主菜单及管理员菜单流程控制方法
     */
    public void adminMenu() {
        System.out.println("\t\t银行系统[管理员]                ");
        System.out.println("************************************************");
        System.out
                .println("1.添加顾客          2.计算储蓄总额           3.富豪排行榜            4.退出  ");
        System.out.println("************************************************");
        //管理员输入不合法时控制循环输入，输入合法时操作结束退出循环。
        while (true) {
            System.out.print("请选择：");
            //接收管理员输入的菜单操作id
            int menuId = input.nextInt();
            //判断1,2,3,4为合法输入
            if (menuId == 1 || menuId == 2 || menuId == 3 || menuId == 4) {
                //管理员选择1.添加顾客时的操作
                if (menuId == 1) {
                    System.out.print("请输入顾客银行卡号：");
                    //接收用户输入的顾客银行卡号
                    String custNumber = input.next();
                    System.out.print("请输入顾客姓名：");
                    //接收用户输入的顾客姓名
                    String custName = input.next();
                    System.out.print("请输入顾客身份证：");
                    //接收用户输入的顾客身份证
                    String custIdCard = input.next();
                    System.out.print("请输入顾客开户金额：");
                    //接收用户输入的顾客开户金额
                    double custMoney = input.nextDouble();
                    System.out.print("请输入初始密码：");
                    //接收用户输入的初始密码
                    String custPwd = input.next();
                    // 新建一个对象
                    Customer cust = new Customer();
                    //将接收到的输入值设定到顾客对象中
                    cust.setCustNumber(custNumber);
                    cust.setCustName(custName);
                    cust.setCustIdCard(custIdCard);
                    cust.setCustPwd(custPwd);
                    cust.setCustMoney(custMoney);
                    //开户日期取系统的当前日期来设置
                    // 注意时间类的使用
                    cust.setCustDate(new java.sql.Date(new java.util.Date()
                            .getTime()));
                    System.out.println(new java.sql.Date(new java.util.Date()
                            .getTime()));
                    //调用AdminService的添加顾客方法将顾客对象当做参数传入进行添加操作。
                    boolean isInsert = as.addCust(cust);
                    //判断如果返回为true说明添加成功，进入管理员子菜单
                    if (isInsert) {
                        System.out.println("添加成功！");
                        //进入管理员子菜单
                        subMenu();
                        //判断如果返回为false说明添加失败，回到管理员主菜单
                    } else {
                        System.out.println("添加失败！");
                        adminMenu();
                    }
                }
                //管理员选择2.计算储蓄总额时的操作
                if (menuId == 2) {
                    //调用AdminService的计算储蓄总额方法。
                    double sumMoney = as.calSumMoney();
                    //输出计算结果
                    System.out.println("当前存款总额为：" + sumMoney);
                    //进入管理员子菜单
                    subMenu();
                }
                //管理员选择2.富豪排行榜时的操作
                if (menuId == 3) {
                    //调用AdminService的富豪排行榜方法。
                    List<Customer> custList = as.rankMoney();
                    System.out.println("名次\t姓名\t\t\t身份证号\t\t\t金额");
                    //遍历结果List，输出信息
                    for (int i = 0; i < custList.size(); i++) {
                        Customer cust = custList.get(i);
                        System.out.println((i + 1) + "\t" + cust.getCustName()
                                + "\t\t\t" + cust.getCustIdCard() + "\t"
                                + cust.getCustMoney());
                    }
                    //进入管理员子菜单
                    subMenu();
                }
                //管理员选择4.退出时的操作
                if (menuId == 4) {
                    System.out.println("感谢使用，欢迎下次光临！");
                    System.exit(0);
                }
                //合法操作完成时退出循环
                break;
                //非法输入时，输出信息，然后重新让用户输入。
            } else {
                System.out.println("非法输入，请重新输入。");
                continue;
            }
        }
    }
    /*
     * 顾客主菜单及顾客主菜单流程控制方法
     */
    public void custMenu() {
        // 顾客登录成功显示界面
        System.out.println("\t\t银行系统[顾客]                ");
        System.out.println("************************************************");
        System.out
                .println("1.存款     2.取款      3.查询余额      4.转账     5.修改密码     6.退出  ");
        System.out.println("************************************************");
        //顾客输入不合法时控制循环输入，输入合法时操作结束退出循环。
        while (true) {
            System.out.print("请选择：");
            //接收顾客输入的菜单操作id
            int menuId = input.nextInt();
            //判断1,2,3,4,5,6为合法输入
            if (menuId == 1 || menuId == 2 || menuId == 3 || menuId == 4
                    || menuId == 5 || menuId == 6) {
                //顾客选择1.存款时的操作
                if (menuId == 1) {
                    System.out.print("请输入存款金额：");
                    //接收输入的存款金额
                    double money = input.nextDouble();
                     //设定当前登录顾客的账户金额为原账户金额+存款金额
                    cust1.setCustMoney(cust1.getCustMoney() + money);
                    //调用CustomerService的存取款方法将当前设定好的cust1作为参数传入进行存款操作。
                    boolean isUpdate = cs.addsubMoney(cust1);
                    //如果返回true表明存款成功，打印当前余额，进入顾客子菜单
                    if(isUpdate){
                        System.out.println("存款成功，当前余额：" + cust1.getCustMoney());
                        //进入顾客子菜单
                        subMenu();
                    //如果返回false表明存款失败，回到顾客主菜单
                    }else{
                        System.out.println("存款失败！");
                        //如果存款失败，因为cust1中的数据已经改变，所以重新从数据库获取最新的数据
                        cust1 = cs.selectCust(cust1);
                        //回到顾客主菜单
                        custMenu();
                    }
                }
                //顾客选择2.取款时的操作
                if(menuId == 2){
                    System.out.print("请输入取款金额：");
                    //接收输入的取款金额
                    double money = input.nextDouble();
                    //判断取款金额和当前余额的大小关系，若余额不足打印输出，进入顾客子菜单
                    if(money > cust1.getCustMoney()){
                        System.out.println("余额不足，当前余额：" + cust1.getCustMoney());
                        //进入顾客子菜单
                        subMenu();
                    //若余额充足，进行取款操作
                    }else{
                        //设定当前登录顾客的账户金额为原账户金额-取款金额
                        cust1.setCustMoney(cust1.getCustMoney() - money);
                        //调用CustomerService的存取款方法将当前设定好的cust1作为参数传入进行取款操作。
                        boolean isUpdate = cs.addsubMoney(cust1);
                        //如果返回true表明取款成功，打印当前余额，进入顾客子菜单
                        if(isUpdate){
                            System.out.println("取款成功，当前余额：" + cust1.getCustMoney());
                            //进入顾客子菜单
                            subMenu();
                        //如果返回false表明取款失败，回到顾客主菜单
                        }else{
                            System.out.println("取款失败！");
                            //如果取款失败，因为cust1中的数据已经改变，所以重新从数据库获取最新的数据
                            cust1 = cs.selectCust(cust1);
                            //回到顾客主菜单
                            custMenu();
                        }
                    }
                }
                //顾客选择3.查询余额时的操作
                if(menuId == 3){
                    //打印输出当前余额
                    System.out.println("当前余额：" + cust1.getCustMoney());
                    //进入顾客子菜单
                    subMenu();
                }
                //顾客选择4.转账时的操作
                if(menuId == 4){
                    //顾客输入不存在转入账户时控制循环输入，输入正常转入账户时操作结束退出循环。
                    while(true){
                        System.out.print("请输入转入账号：");
                        //接收顾客输入转入账户Id
                        String inNumber = input.next();
                        //新建一个顾客对象
                        Customer cust = new Customer();
                        //将输入的输入转入账户Id设定到新建的顾客对象中
                        cust.setCustNumber(inNumber);
                        //调用CustomerService的查询顾客方法将当前设定好的cust作为参数传入进行查询。
                        Customer cust2 = cs.selectCust(cust);
                        //如果返回的结果为null，表明输入的账号不存在，打印输出信息并继续输入
                        if(cust2 == null){
                            System.out.println("输入账号不存在，请重新输入。");
                            continue;
                        //如果返回的结果不为null，表明输入的账号存在，继续转账操作
                        }else{
                            System.out.print("请输入转入金额：");
                            //接收顾客输入转账金额
                            double transMoney = input.nextDouble();
                            //判断转账金额和当前余额的大小关系，若余额不足打印输出，进入顾客子菜单
                            if(transMoney > cust1.getCustMoney()){
                                System.out.println("账户余额不足，当前余额：" + cust1.getCustMoney());
                                //进入顾客子菜单
                                subMenu();
                            //若余额充足，进行转账操作
                            }else{
                                //调用CustomerService的转账方法，传入当前顾客对象，转入账户Id，转账金额进行转账操作。
                                boolean isTrans = cs.transMoney(cust1, inNumber, transMoney);
                                //如果返回为true，表明转账成功，重新获取当前顾客信息，进入顾客子菜单
                                if(isTrans){
                                    System.out.println("转账成功！");
                                    //重新获取当前顾客信息
                                    cust1 = cs.selectCust(cust1);
                                    //进入顾客子菜单
                                    subMenu();
                                //如果返回为false，表明转账失败，回到顾客主菜单
                                }else{
                                    System.out.println("转账失败！");
                                    //回到顾客主菜单
                                    custMenu();
                                }
                            }
                            //转账操作完成时退出循环
                            break;
                        }
                    }
                }
                //顾客选择5.修改密码时的操作
                if(menuId == 5){
                    //顾客输入错误密码时控制循环输入，输入正确密码时操作结束退出循环。
                    while(true){
                        System.out.print("请输入旧密码：");
                        //接收顾客输入旧密码
                        String oldPwd = input.next();
                        //判断顾客输入的旧密码与当前顾客的密码是否一致
                        //输入正确密码时
                        if(oldPwd.equals(cust1.getCustPwd())){
                            System.out.print("请输入新密码：");
                            //接收用户输入新密码
                            String newPwd = input.next();
                            //设定当前顾客的密码为新密码
                            cust1.setCustPwd(newPwd);
                            //调用CustomerService的修改密码方法，传入当前顾客对象进行修改密码操作。
                            boolean isUpdate = cs.updatePwd(cust1);
                            //如果返回为true，表明密码修改成功，回到登录主菜单重新登录
                            if(isUpdate){
                                System.out.println("密码修改成功！");
                                //回到登录主菜单
                                mainMenu();
                            //如果返回为false，表明密码修改失败，回到顾客主菜单
                            }else{
                                System.out.println("密码修改失败！");
                                //重新获取当前顾客信息
                                cust1 = cs.selectCust(cust1);
                                //回到顾客主菜单
                                custMenu();
                            }
                            break;
                        //输入错误密码时，打印输出信息，重新输入
                        }else{
                            System.out.println("旧密码错误，请重新输入。");
                            continue;
                        }
                    }
                }
                //顾客选择6.退出时的操作
                if(menuId == 6){
                    //输出信息，退出系统
                    System.out.println("感谢使用，欢迎下次光临！");
                    System.exit(0);
                }
                //合法操作完成时退出循环
                break;
            //非法输入时，输出信息，然后重新让用户输入。
            }else{
                System.out.println("非法输入，请重新输入。");
                continue;
            }
        }
    }
    /*
     * 顾客子菜单及顾客子菜单流程控制方法
     */
    public void subMenu(){
        System.out.println("1.返回登录主菜单\t2.返回顾客主菜单\t3.退出系统");
        //顾客输入不合法时控制循环输入，输入合法时操作结束退出循环。
        while(true){
            System.out.print("请选择：");
            //接收顾客输入的子菜单操作id
            int menuId = input.nextInt();
            //判断1,2,3为合法输入
            if(menuId == 1 || menuId == 2 || menuId == 3){
                //顾客选择1.返回登录主菜单时的操作
                if(menuId == 1){
                    //返回登录主菜单
                    mainMenu();
                }
                //顾客选择2.返回顾客主菜单时的操作
                if(menuId == 2){
                    //返回顾客主菜单
                    custMenu();
                }
                //顾客选择3.退出系统时的操作
                if(menuId == 3){
                    //输出信息，退出系统
                    System.out.println("感谢使用，欢迎下次光临！");
                    System.exit(0);
                }
                //合法操作完成时退出循环
                break;
            //非法输入时，输出信息，然后重新让用户输入。
            }else{
                System.out.println("非法输入，请重新输入。");
                continue;
            }
        }
    }
}

package com.ll.service;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.ll.dao.AdminDao;
import com.ll.dao.AdminDaoImpl;
import com.ll.dao.BaseDao;
import com.ll.po.Admin;
import com.ll.po.Customer;

//这个类进行处理从数据库操作的结果，然后返回到前台显示界面，起逻辑处理功能
public class AdminService extends BaseDao {

    AdminDao adao = new AdminDaoImpl();

    // 处理数据库登录查询的结果
    public boolean adminLogin(Admin admin) {
        ResultSet rs = adao.adminLogin(admin);
        int count = 0;
        try {
            while (rs.next()) {
                count = rs.getInt(1);
            }
            if (count > 0) {
                return true;
            } else {
                return false;
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return false;
        } finally {
            close();// 关闭所有开启的连接
        }
    }

    // 处理添加顾客的数据库操作
    public boolean addCust(Customer cust) {
        int count = adao.addCust(cust);
        if (count > 0) {
            return true;
        } else {
            return false;
        }
    }

    // 处理数据库查询总额的结果
    public double calSumMoney() {
        ResultSet rs = adao.calSumMoney();
        double sumMoney = 0.0;
        try {
            while (rs.next()) {
                sumMoney = rs.getDouble(1);// 获得总金额
            }
            return sumMoney;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return sumMoney;
        } finally {
            close();
        }
    }

    // 处理数据库查询以金额排序的操作
    public List<Customer> rankMoney() {
        ResultSet rs = adao.rankMoney();
        List<Customer> custList = new ArrayList<Customer>();
        try {
            while (rs.next()) {
                // 每次都是new的对象，都是新对象，加入到集合中
                Customer cust = new Customer();
                cust.setCustNumber(rs.getString("custnumber"));
                cust.setCustName(rs.getString("custname"));
                cust.setCustPwd(rs.getString("custpwd"));
                cust.setCustIdCard(rs.getString("custidcard"));
                cust.setCustMoney(rs.getDouble("custmoney"));
                cust.setCustDate(rs.getDate("custdate"));
                custList.add(cust);// 添加到集合
            }
            return custList;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        } finally {
            close();
        }
    }
}

package com.ll.service;

import java.sql.ResultSet;
import java.sql.SQLException;

import com.ll.dao.BaseDao;
import com.ll.dao.CustomerDao;
import com.ll.dao.CustomerDaoImpl;
import com.ll.po.Customer;

//此类处理数据库操作结果，返回到客户前台显示
public class CustomerService extends BaseDao {

    CustomerDao cdao = new CustomerDaoImpl();

    // 处理顾客登录的数据库操作结果
    public Customer custLogin(Customer cust) {
        ResultSet rs = cdao.custLogin(cust);
        Customer cust1 = null;
        try {
            while (rs.next()) {
                // 把登录的客户所有信息保存在一个对象中
                cust1 = new Customer();
                cust1.setCustNumber(rs.getString("custnumber"));
                cust1.setCustName(rs.getString("custname"));
                cust1.setCustPwd(rs.getString("custpwd"));
                cust1.setCustIdCard(rs.getString("custidcard"));
                cust1.setCustMoney(rs.getDouble("custmoney"));
                cust1.setCustDate(rs.getDate("custdate"));
            }
            return cust1;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        } finally {
            close();// 关闭所有连接
        }
    }

    // 处理顾客存款的数据库操作结果
    public boolean addsubMoney(Customer cust) {
        int count = cdao.addsubMoney(cust);
        if (count > 0) {
            return true;
        } else {
            return false;
        }
    }

    // 处理查询用户的所有的数据的数据库操作结果
    public Customer selectCust(Customer cust) {
        ResultSet rs = cdao.selectCust(cust);
        Customer cust1 = null;
        try {
            while (rs.next()) {
                // 把查询到的最新数据重新保存在新的对象中
                cust1 = new Customer();
                cust1.setCustNumber(rs.getString("custnumber"));
                cust1.setCustName(rs.getString("custname"));
                cust1.setCustPwd(rs.getString("custpwd"));
                cust1.setCustIdCard(rs.getString("custidcard"));
                cust1.setCustMoney(rs.getDouble("custmoney"));
                cust1.setCustDate(rs.getDate("custdate"));
            }
            return cust1;// 把新对象返回
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        } finally {
            close();
        }
    }

    // 处理转账的数据库操作结果
    public boolean transMoney(Customer cust, String inNumber, double money) {
        boolean isTrans = cdao.transMoney(cust, inNumber, money);
        return isTrans;
    }

    // 处理更新密码的数据库操作结果
    public boolean updatePwd(Customer cust) {
        int count = cdao.updatePwd(cust);
        if (count > 0) {
            return true;
        } else {
            return false;
        }
    }
}

package com.ll.po;

//Admin类是数据库表administrator的映射类，用来存储administrator表的数据
public class Admin {

    private String adminId;
    private String adminPwd;
    private String adminName;

    public String getAdminId() {
        return adminId;
    }

    public void setAdminId(String adminId) {
        this.adminId = adminId;
    }

    public String getAdminPwd() {
        return adminPwd;
    }

    public void setAdminPwd(String adminPwd) {
        this.adminPwd = adminPwd;
    }

    public String getAdminName() {
        return adminName;
    }

    public void setAdminName(String adminName) {
        this.adminName = adminName;
    }
}

package com.ll.po;

import java.sql.Date;

//Customer类是数据库表customer的映射类，用来存储customer表的数据
public class Customer {

    private String custNumber;
    private String custName;
    private String custPwd;
    private String custIdCard;
    private double custMoney;
    private Date custDate;

    public String getCustNumber() {
        return custNumber;
    }

    public void setCustNumber(String custNumber) {
        this.custNumber = custNumber;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustPwd() {
        return custPwd;
    }

    public void setCustPwd(String custPwd) {
        this.custPwd = custPwd;
    }

    public String getCustIdCard() {
        return custIdCard;
    }

    public void setCustIdCard(String custIdCard) {
        this.custIdCard = custIdCard;
    }

    public double getCustMoney() {
        return custMoney;
    }

    public void setCustMoney(double custMoney) {
        this.custMoney = custMoney;
    }

    public Date getCustDate() {
        return custDate;
    }

    public void setCustDate(Date custDate) {
        this.custDate = custDate;
    }
}

DRIVER_CLASS=oracle.jdbc.driver.OracleDriver
DB_URL=jdbc:oracle:thin:@
DB_IP=localhost
DB_PORT=:1521
DB_SID=:BANK
USER=system
PASS=123456


#下面是Mysql的

#DRIVER_CLASS=com.mysql.jdbc.Driver
#DB_URL=jdbc:mysql://
#DB_IP=localhost
#DB_PORT=:3306
#DB_SID=/BANK
#USER=root
#PASS=123456

package com.ll.dao;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class Config {

    private static Properties pros = new Properties();

    static {
        try {
            //加载配置文件内容到Properties对象中
            pros.load(Config.class.getResourceAsStream("db.properties"));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static final String DRIVER_CLASS = (String) pros.get("DRIVER_CLASS");
    public static final String DB_URL = (String) pros.get("DB_URL");
    public static final String DB_IP = (String) pros.get("DB_IP");
    public static final String DB_PORT = (String) pros.get("DB_PORT");
    public static final String DB_SID = (String) pros.get("DB_SID");
    public static final String USER = (String) pros.get("USER");
    public static final String PASS = (String) pros.get("PASS");

}

package com.ll.dao;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class BaseDao {
    private Connection con = null;
    private PreparedStatement psm = null;
    private Statement sm = null;
    private ResultSet rs = null;

    // 进行数据库连接
    private void getConn() {
        try {
            // 1.加载驱动
            Class.forName(Config.DRIVER_CLASS);
            // 2.获取连接
            String url = Config.DB_URL + Config.DB_IP + Config.DB_PORT
                    + Config.DB_SID;
            String user = Config.USER;
            String pass = Config.PASS;
            con = DriverManager.getConnection(url, user, pass);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    // 查询操作
    public ResultSet select(String sql, Object[] objs) {
        // 获得数据库的连接
        getConn();
        try {
            psm = con.prepareStatement(sql);
            if (objs != null) {
                for (int i = 0; i < objs.length; i++) {
                    psm.setObject(i + 1, objs[i]);
                }
            }
            rs = psm.executeQuery();
            return rs;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }

    // 更新操作
    public int update(String sql, Object[] objs) {
        // 获得数据库连接
        getConn();
        try {
            psm = con.prepareStatement(sql);
            if (objs != null) {
                for (int i = 0; i < objs.length; i++) {
                    psm.setObject(i + 1, objs[i]);
                }
            }
            int count = psm.executeUpdate();
            return count;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return -1;
        }
    }

    // 事务管理
    public boolean batch(String[] sql) {
        getConn();
        try {
            con.setAutoCommit(false);
            sm = con.createStatement();
            if (sql != null) {
                for (int i = 0; i < sql.length; i++) {
                    sm.addBatch(sql[i]);
                }
            }
            int[] count = sm.executeBatch();
            boolean flg = true;
            for (int i : count) {
                if (i <= 0) {
                    flg = false;
                    break;
                }
            }
            if (flg) {
                con.commit();// 提交事物
            } else {
                con.rollback();// 进行回滚
            }
            return flg;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return false;
        }
    }

    // 关闭所有的连接
    public void close() {
        try {
            if (rs != null) {
                rs.close();
            }
            if (psm != null) {
                psm.close();
            }
            if (sm != null) {
                sm.close();
            }
            if (con != null) {
                con.close();
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

package com.ll.dao;

import java.sql.ResultSet;

import com.ll.po.Admin;
import com.ll.po.Customer;

public interface AdminDao {
    // 返回的类型有操作数据库的返回的类型决定
    // 管理员登陆
    public ResultSet adminLogin(Admin admin);

    // 添加顾客(开户)
    public int addCust(Customer cust);

    // 计算储蓄总额
    public ResultSet calSumMoney();

    // 富豪排行榜
    public ResultSet rankMoney();
}

package com.ll.dao;

import java.sql.ResultSet;

import com.ll.po.Customer;

public interface CustomerDao {

    // 顾客登陆
    public ResultSet custLogin(Customer cust);

    // 存款、取款
    public int addsubMoney(Customer cust);

    // 查询余额
    public double selectMoney(Customer cust);

    // 转账
    public boolean transMoney(Customer cust, String inNumber, double money);

    // 修改密码
    public int updatePwd(Customer cust);

    // 查询顾客
    public ResultSet selectCust(Customer cust);
}

package com.ll.dao;

import java.sql.ResultSet;

import com.ll.po.Admin;
import com.ll.po.Customer;

public class AdminDaoImpl extends BaseDao implements AdminDao {
    // 此类只负责操作数据库，把查询结果不做处理直接返回，返回到service中进行处理
    // 管理员登录
    @Override
    public ResultSet adminLogin(Admin admin) {
        // TODO Auto-generated method stub
        //管理员查询的sql
        String sql = "select count(adminname) from administrator where adminname = ‘"
                + admin.getAdminName()
                + "‘ and adminpwd = ‘"
                + admin.getAdminPwd() + "‘";
        //调用共通的查询方法执行sql
        ResultSet rs = select(sql, null);
        //查询到的结果不做处理直接返回
        return rs;
    }

    // 添加客户
    @Override
    public int addCust(Customer cust) {
        // TODO Auto-generated method stub
        //添加顾客的sql
        String sql = "insert into customer values(‘" + cust.getCustNumber()
                + "‘,‘" + cust.getCustName() + "‘,‘" + cust.getCustPwd()
                + "‘,‘" + cust.getCustIdCard() + "‘," + cust.getCustMoney()
                + ",to_date(‘" + cust.getCustDate() + "‘,‘yyyy-MM-dd‘))";// 一定要进行格式转换，Mysql中不用
        //调用共通的增删改方法执行sql
        int count = update(sql, null);
        close();
        return count;
    }

    // 计算总金额
    @Override
    public ResultSet calSumMoney() {
        // TODO Auto-generated method stub
        //计算储蓄总额的sql
        String sql = "select sum(custmoney) from customer";
        //调用共通的查询方法执行sql
        ResultSet rs = select(sql, null);
        return rs;
    }

    // 富豪排行榜，以金额进行排序
    @Override
    public ResultSet rankMoney() {
        // TODO Auto-generated method stub
        //查询所有顾客信息并按金额排序的sql
        String sql = "select * from customer order by custmoney desc";
        //调用共通的查询方法执行sql
        ResultSet rs = select(sql, null);
        return rs;
    }
}

package com.ll.dao;

import java.sql.ResultSet;

import com.ll.po.Customer;

public class CustomerDaoImpl extends BaseDao implements CustomerDao {
    // 此类只操作用户功能关于数据库的操作，返回操作结果
    // 用户登录
    @Override
    public ResultSet custLogin(Customer cust) {
        // TODO Auto-generated method stub
        //顾客查询的sql
        String sql = "select * from customer where custname = ‘"
                + cust.getCustName() + "‘ and custpwd = ‘" + cust.getCustPwd()
                + "‘";
        //调用共通的查询方法执行sql
        ResultSet rs = select(sql, null);
        return rs;
    }

    @Override
    public int addsubMoney(Customer cust) {
        // TODO Auto-generated method stub
        //存取款的sql
        String sql = "update customer set custmoney = " + cust.getCustMoney()
                + " where custnumber = ‘" + cust.getCustNumber() + "‘";
        //调用共通的增删改方法执行sql
        int count = update(sql, null);
        close();
        //返回影响行数
        return count;
    }

    @Override
    public double selectMoney(Customer cust) {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public boolean transMoney(Customer cust, String inCustId, double money) {
        //转账的两个更新sql
        String sql1 = "update customer set custmoney = custmoney - " + money
                + " where custnumber = ‘" + cust.getCustNumber() + "‘";
        String sql2 = "update customer set custmoney = custmoney + " + money
                + " where custnumber = ‘" + inCustId + "‘";
        //用数组保存两个sql
        String[] sqlArr = { sql1, sql2 };
        //调用共通的批处理方法执行多个sql
        boolean isTrans = batch(sqlArr);
        close();
        return isTrans;
    }

    @Override
    public int updatePwd(Customer cust) {
        // TODO Auto-generated method stub
        //修改密码的sql
        String sql = "update customer set custpwd = ‘" + cust.getCustPwd()
                + "‘";
        //调用共通的增删改方法执行sql
        int count = update(sql, null);
        //调用共通关闭资源方法
        close();
        return count;
    }

    @Override
    public ResultSet selectCust(Customer cust) {
        // TODO Auto-generated method stub
        //查询顾客的sql
        String sql = "select * from customer where custnumber = ‘"
                + cust.getCustNumber() + "‘";
        //调用共通的查询方法执行sql
        ResultSet rs = select(sql, null);
        return rs;
    }
}