练习~虚拟线上银行

数据库操作，网络编程及多线程的综合练习~

 

 

客户端：

UI层

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class ATMUI{

    //主方法
    public static void main(String [] args){
    ATMUI ui = new ATMUI();
    ui.initBO();
    ui.initFrame();
    ui.showLogin();
    }
    
    //初始化业务对象
    //业务对象，每个用户对于一个业务对象并保存该用户数据
    //因此，启动程序和每次退出都要创建一个新的业务对象给下一个用户使用
    
    public ATMBO bo = null;
    public void initBO(){
        bo = new ATMBO();
    }
    
    //初始化主窗口
    
    //界面宽与高
    public int width = 960;
    public int height = 660;
    
    //界面窗口
    public JFrame jFrame = null;
    //层叠容器
    public JLayeredPane layeredPane = null;
    
    //背景层
    public JPanel backLayer = null;
    //前景层
    public JPanel frontLayer = null;
    //前景层布局器
    public CardLayout cardLayout = null;
    
    public void initFrame(){
        
        //-----初始化窗口与层叠容器------
        //创建窗口对象，窗口标题为————
        jFrame = new JFrame("ATM触摸屏系统");
        
        //创建层叠容器对象
        layeredPane = new JLayeredPane();
        //设置层叠容器大小
        layeredPane.setPreferredSize(new Dimension(width, height));
        
        //把层叠容器添加到窗口中
        jFrame.add(layeredPane);
        //设置窗口不能放大缩小
        jFrame.setResizable(false);
        //设置窗口大小适应内容（层叠容器）大小
        jFrame.pack();
        //设置窗口居中显示
        jFrame.setLocationRelativeTo(null);
        //设置窗口可见（默认不可见）
        jFrame.setVisible(true);
        //设置窗口关闭时程序关闭
        jFrame.addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                bo.socclose();
                System.exit(0);
            }
        });
        
        //----在层叠容器中加背景层----
        //创建背景层对象
        backLayer = new JPanel();
        //设置背景层布局器FlowLayout的水平间距为0（默认是5）
        ((FlowLayout)backLayer.getLayout()).setHgap(0);
        //设置背景层布局器FlowLayout的垂直间距为0（默认是5）
        ((FlowLayout)backLayer.getLayout()).setVgap(0);
        
        //设置背景层大小（同窗口）
        backLayer.setSize(width, height);
        //设置背景层位置（相对于窗口左上角）
        backLayer.setLocation(0, 0);
        
        //创建背景图对象
        JLabel bg = new JLabel (new ImageIcon("img/bg.jpg"));
        //在背景层中添加背景图
        backLayer.add(bg);
        
        //把背景层添加到层叠容器的较底层
        layeredPane.add(backLayer, new Integer(0));    
        
        //-----在层叠容器中增加前景层-----
        //创建前景层对象
        frontLayer = new JPanel();
        //创建CardLayout布局器对象，水平、垂直间距为0
        cardLayout = new CardLayout(0, 0);
        //将前景层的布局器设成CardLayout
        frontLayer.setLayout(cardLayout); 
        //把前景层的背景色设成透明（这样才能看到背景层）
        frontLayer.setOpaque(false);
        //设置前景层大小（同窗口）
        frontLayer.setSize(width, height);
        //设置前景层位置（相对于窗口左上角）
        frontLayer.setLocation(0, 0);
        
        //把前景层添加到层叠容器的较顶层
        layeredPane.add(frontLayer, new Integer(1));    
        
        
    }
    
    //登录界面
    //本案例中，前景界面层使用了CardLayout，是希望做到调用对应的方法时，把对应的层面调到最顶层即可；另外，每个层面第一次调用时，则初始化，后面的调用就可以直接把已初始化的层面调出并把些必须的组件重置即可
    
    //登录层容器
    public JPanel loginPane = null;
    //登录卡号输入框
    public JTextField loginCodeInput = null;
    //登录密码输入框
    public JPasswordField loginPassInput = null;
    //登录提示信息
    public JLabel loginTipsLabel = null;
    
    public void showLogin(){
        if(loginPane == null){
        //-----登录层未初始化时----
        
        //创建登录层容器对象
        loginPane = new JPanel();
        //把登录层的背景色设成透明
        loginPane.setOpaque(false);
        
        //---往登录层容器中添加组件---
        //创建一个垂直BOX容器
        Box loginBox = Box.createVerticalBox();
        //在垂直BoX中添加180高度的距离
        loginBox.add(Box.createVerticalStrut(170));
        
        //创建一个欢迎信息容器
        JPanel welcome_panel = new JPanel();
        //把欢迎信息容器的背景色设成透明
        welcome_panel.setOpaque(false);
        //创建欢迎信息”欢迎使用海阁银行”
        JLabel welcome_label = new JLabel("欢迎使用线上银行");
        //设置信息字体
        welcome_label.setForeground(Color.WHITE);
        welcome_label.setFont(new Font("华文行楷", Font.PLAIN, 35));
        //把欢迎信息添加到欢迎信息容器中
        welcome_panel.add(welcome_label);
        //把欢迎信息容器添加到垂直Box容器中
        loginBox.add(welcome_panel);
        
        //在垂直BOX中添加30高度的距离
        loginBox.add(Box.createVerticalStrut(30));
        //创津一个卡号输入容器
        JPanel code_panel = new JPanel();
        //把卡号输入容器的背景色设成透明
        code_panel.setOpaque(false);
        //创津提示输入卡号信息"请输入卡号:"
        JLabel code_label = new JLabel("请输入卡号：");
        //设置信息字体
        code_label.setForeground(Color.WHITE);
        code_label.setFont(new Font("华文仿宋", Font.BOLD, 25));
        //把提示输入卡号信息添加到卡号输入容器中
        code_panel.add(code_label);
        //创建卡号输入框
        loginCodeInput = new JTextField(10);
        //设置卡号输入框字体
        loginCodeInput.setFont(new Font("华文仿宋", Font.PLAIN, 25));
        //把卡号输入框添加到卡号输入容器中
        code_panel.add(loginCodeInput);
        //把卡号输入容器添加到垂直BOX容器中
        loginBox.add(code_panel);
        
        //在变直的X中添加20高度的距离
        loginBox.add(Box.createVerticalStrut(20));
        
        //类似于卡号输入块，创建密码输入块
        JPanel pass_panel = new JPanel();
        pass_panel.setOpaque(false);
        JLabel pass_label = new JLabel("请输入密码：");
        pass_label.setForeground(Color.WHITE);
        pass_label.setFont(new Font("华文仿宋",Font.BOLD, 25));
        pass_panel.add(pass_label);
        loginPassInput = new JPasswordField(10);
        loginPassInput.setFont(new Font("华文仿宋" , Font.PLAIN , 25));
        pass_panel.add(loginPassInput);
        loginBox.add(pass_panel); 
        
        //在垂直BoX中添加孔高度的距离
        loginBox.add(Box.createVerticalStrut(30));
        
        //创建按钮容器
        JPanel btn_panel = new JPanel();
        //把按钮容器的背景色设成透明
        btn_panel.setOpaque(false);
        //创建登录按钮并设置字体
        JButton login_btn = new JButton("登  录");
        login_btn.setFont(new Font("微软雅黑", Font.PLAIN, 15));
        //把登录按钮添加到按钮容器中
        btn_panel.add(login_btn); 
        
        //创建重置按钮并设置字体
        JButton reset_btn = new JButton("重  置");
        reset_btn.setFont ( new Font ("微软雅黑", Font.PLAIN , 15));
        //把重置按钮添加到按钮容器中
        btn_panel.add(reset_btn);
        //把按钮容器添加到垂直BOX容器中
        loginBox.add(btn_panel);
        
        //在垂直BoX中添加10高度的距离
        loginBox.add(Box.createVerticalStrut(10));
        
        //创建登录提示信息容器
        JPanel tips_panel = new JPanel();
        //把登录提示信息容器的背景色设成透明
        tips_panel.setOpaque(false);
        //创建登录提示信息对象并设置字体（默认无提示文字）
        loginTipsLabel = new JLabel("");
        loginTipsLabel.setForeground(new Color(238,32,32));
        loginTipsLabel.setFont(new Font("华文仿宋", Font.BOLD, 20));
        //把登录提示信息添加到登录提示信息容器中
        tips_panel.add(loginTipsLabel);
        //把登录提示信息容器添加到垂直的boX容器中
        loginBox.add(tips_panel);
        //把垂直BoX容器添加到登录层容器中
        loginPane.add(loginBox);
        
        //-----显示登录层-----
        //把登录层添加到前景层容器中
        frontLayer.add("loginPane", loginPane);
        //使登录层在前景层容器中置于顶层显示
        cardLayout.show(frontLayer, "loginPane");
        //"刷新"前景层使其可视化
        frontLayer.validate();
        //使卡号输入框获取焦点（方便直接输入）
        loginCodeInput.requestFocus();
        
        //-----监听重置按钮事件-----
        reset_btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent ae){
                //清空卡号输入框、密码输入框和提示信息
                loginCodeInput.setText("");
                loginPassInput.setText("");
                loginTipsLabel.setText("");
                //使卡号输入框获取焦点
                loginCodeInput.requestFocus();
            }
        });
        
        //-----监听登录按钮事件------
        login_btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent ae){
                //获取用户输入的卡号和密码
                String code_str = loginCodeInput.getText();
                String pass_str = new String(loginPassInput.getPassword());
                //判断输入是否为空，为空则提示
                if("".equals(code_str)){
                    loginTipsLabel.setText("卡号不能为空！");
                    loginCodeInput.requestFocus();
                }else if("".equals(pass_str)){
                    loginTipsLabel.setText("密码不能为空！");
                    loginPassInput.requestFocus();
                }else{
                    //若卡号和密码输入都不为空调用业务对象的登录业务方法并返回结果
                    int login_rtn = bo.dologin(code_str, Integer.valueOf(pass_str));
                    if(login_rtn == -2){
                        //返回-2，表示网络出现异常
                        loginTipsLabel.setText("出现异常!");
                    }else if(login_rtn == -1){
                        //返回-1，表示登录成功，显示主菜单界面
                        showMenu();
                    }else if(login_rtn == 3){
                        //返回3表示错误已超过3次，显示吞卡提示界面
                        showTunka();
                    }else{
                        //返回非―1且非表示错误但未超过3次机会，提示输入错误信息
                        loginCodeInput.setText("");
                        loginPassInput.setText("");
                        loginTipsLabel.setText("卡号或密码错误，请重新输入，您还有"+(3-login_rtn)+"次机会!");
                        loginCodeInput.requestFocus();
                    }
                }
            }
        });
        }else{
            //-----登录层已初始化----
            //使登录层在前景层容器中置于顶层显示
            cardLayout.show(frontLayer, "loginPane");
            //重置
            loginCodeInput.setText("");
            loginPassInput.setText("");
            loginTipsLabel.setText("");
            loginCodeInput.requestFocus();
        }
    }
    
    //吞卡提示界面
    public JPanel tunkaPane = null;

    public void showTunka(){
        if(tunkaPane == null){
        //----吞卡界面未初始化前-----
        tunkaPane = new JPanel();
        tunkaPane.setOpaque(false);
        
        //-----添加组件-----
        Box tunkaBox = Box.createVerticalBox();
        
        tunkaBox.add(Box.createVerticalStrut(180));
        
        JPanel tunka_panel = new JPanel();
        tunka_panel.setOpaque(false);
        JLabel tunka_label = new JLabel("您已超过3次输入机会，系统吞卡，请联系客服！");
        tunka_label.setForeground(Color.WHITE);
        tunka_label.setFont(new Font("微软雅黑",Font.PLAIN,25));
        tunka_panel.add(tunka_label);
        tunkaBox.add(tunka_panel);
        
         tunkaBox.add(Box.createVerticalStrut(30));
        
        JPanel btn_panel = new JPanel();
        btn_panel.setOpaque(false);
        JButton tunka_btn = new JButton("确   定");
        tunka_btn.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        btn_panel.add(tunka_btn);
        JButton zuobi_btn = new JButton("忘记密码（^-^）");
        zuobi_btn.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        btn_panel.add(zuobi_btn);
        tunkaBox.add(btn_panel);
        
        tunkaPane.add(tunkaBox);
        
        //吞卡提示界面
        frontLayer.add("tunkaPane", tunkaPane);
        cardLayout.show(frontLayer, "tunkaPane");
        frontLayer.validate();
        
        //监听按钮事件
        zuobi_btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent ae){
                //shownopassword();
            }
        });
        
        tunka_btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent ae){
            
            quit();
            }
        });
        
    }else{
        //----吞卡界面已初始化-----
        cardLayout.show(frontLayer, "tunkaPane");
    }
    }
    
    //免密码界面
    /*
    public JPanel nopasswordPane = null;
    public JTextField nopinput = null;
    public JLabel nopl = null;
    
    public void shownopassword(){
        if(nopasswordPane == null){
            nopasswordPane = new JPanel();
            nopasswordPane.setOpaque(false);
            
            Box nopasswordbox = Box.createVerticalBox();
            nopasswordPane.add(nopasswordbox);
            
            nopasswordbox.add(Box.createVerticalStrut(200));
            
            JPanel nopshu = new JPanel();
            nopshu.setOpaque(false);
            JLabel nopshutips = new JLabel("账号：");
            nopshutips.setForeground(Color.WHITE);
            nopshutips.setFont(new Font("微软雅黑", Font.PLAIN, 20));
            nopshu.add(nopshutips);
            nopinput = new JTextField(10);
            nopinput.setFont(new Font("华文仿宋", Font.PLAIN, 25));
            nopshu.add(nopinput);
            nopasswordbox.add(nopshu);
            
            nopasswordbox.add(Box.createVerticalStrut(30));
            
            JPanel nopbtn = new JPanel();
            nopbtn.setOpaque(false);
            JButton nopqb = new JButton("确  定");
            nopqb.setFont(new Font("华文仿宋", Font.BOLD, 20));
            nopbtn.add(nopqb);
            JButton nopfb = new JButton("返  回");
            nopfb.setFont(new Font("华文仿宋", Font.BOLD, 20));
            nopbtn.add(nopfb);
            nopasswordbox.add(nopbtn);
            
            nopasswordbox.add(Box.createVerticalStrut(30));

            JPanel noptips = new JPanel();
            noptips.setOpaque(false);
            nopl = new JLabel();
            nopl.setForeground(new Color(238,32,32));
            nopl.setFont(new Font("华文仿宋", Font.BOLD, 20));
            noptips.add(nopl);
            nopasswordbox.add(noptips);
            
            //监听
            nopqb.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                    String nopget = nopinput.getText();
                    bo.current_index = -1;
                    int p = -1;
                    bo.dologin(nopget,  p);
                    if(bo.current_index == -1){
                        nopinput.setText("");
                        nopinput.requestFocus();
                        nopl.setText("账号输入有误！！");
                    }else{
                        showLogin();
                        loginCodeInput.setText(serverBO.code[bo.current_index]);
                        Integer i = serverBO.password[bo.current_index];
                        loginPassInput.setText(i.toString());
                        bo.cs = 0;
                        nopl.setText("");
                        nopinput.setText("");
                        nopinput.requestFocus();
                    }
                }
            });
            
            nopfb.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                    nopinput.setText("");
                    nopl.setText("");
                    showLogin();
                    bo.cs = 0;
                }
            });
            
            //设置界面
            frontLayer.add("nopasswordPane", nopasswordPane);
            cardLayout.show(frontLayer, "nopasswordPane");
            frontLayer.validate();
            nopinput.requestFocus();
        }else{
            cardLayout.show(frontLayer, "nopasswordPane");
            nopinput.requestFocus();
        }
    }*/
    
    //主菜单界面
    public JPanel menuPane = null;
    
    public void showMenu(){
        if(menuPane == null){
            //----主菜单界面未初始化前----
            menuPane = new JPanel();
            menuPane.setOpaque(false);
            menuPane.setLayout(new BorderLayout());
            
            //----添加组件----
            //头部信息显示快，位于北区
            Box tipsBox = Box.createVerticalBox();
            menuPane.add(tipsBox, BorderLayout.NORTH);
            
            tipsBox.add(Box.createVerticalStrut(150));
            
            JLabel tips_label = new JLabel("请选择您要的服务");
            tips_label.setForeground(Color.WHITE);
            tips_label.setFont(new Font("华文行楷", Font.PLAIN, 30));
            tips_label.setAlignmentX(Component.CENTER_ALIGNMENT);
            tipsBox.add(tips_label);
            
            //左栏按钮区，位于西区
            Box menuLeft = Box.createVerticalBox();
            menuPane.add(menuLeft, BorderLayout.WEST);
            
            menuLeft.add(Box.createVerticalStrut(50));
            
            JButton chaxun_btn = new JButton("查询余额");
            chaxun_btn.setFont(new Font("华文仿宋", Font.BOLD, 25));
            menuLeft.add(chaxun_btn);
            
            menuLeft.add(Box.createVerticalStrut(100));
            
            JButton cunkuan_btn = new JButton("存   款");
            cunkuan_btn.setFont(new Font("华文仿宋", Font.BOLD, 25));
            menuLeft.add(cunkuan_btn);
            
            menuLeft.add(Box.createVerticalStrut(100));
            
            JButton qukuan_btn = new JButton("取   款");
            qukuan_btn.setFont(new Font("华文仿宋", Font.BOLD, 25));
            menuLeft.add(qukuan_btn);
            
            //右栏按钮块，位于东区
            Box menuRight = Box.createVerticalBox();
            menuPane.add(menuRight, BorderLayout.EAST);
            
            menuRight.add(Box.createVerticalStrut(50));
            
            JButton xiugai_btn = new JButton("修改密码");
            xiugai_btn.setFont(new Font("华文仿宋", Font.BOLD, 25));
            xiugai_btn.setAlignmentX(Component.RIGHT_ALIGNMENT);
            menuRight.add(xiugai_btn);
            
            menuRight.add(Box.createVerticalStrut(100));
            
            JButton zhuanzhang_btn = new JButton("转   账");
            zhuanzhang_btn.setFont(new Font("华文仿宋", Font.BOLD, 25));
            zhuanzhang_btn.setAlignmentX(Component.RIGHT_ALIGNMENT);
            menuRight.add(zhuanzhang_btn);
            
            menuRight.add(Box.createVerticalStrut(100));
            
            JButton quit_btn = new JButton("退   卡");
            quit_btn.setFont(new Font("华文仿宋", Font.BOLD, 25));
            quit_btn.setAlignmentX(Component.RIGHT_ALIGNMENT);
            menuRight.add(quit_btn);
            
            //----显示主菜单界面层----
            frontLayer.add("menuPane", menuPane);
            cardLayout.show(frontLayer, "menuPane");
            frontLayer.validate();
            
            //监听
            chaxun_btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent ae){
            
            showChaxun();
            }
        });
            
            cunkuan_btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent ae){
            
            showCunkuan();
            }
        });
            
            
            qukuan_btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent ae){
            
            showQukuan();
            }
        });
        
        xiugai_btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent ae){
            
            showXiugai();
            }
        });
        
        zhuanzhang_btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent ae){
            
            showZhuanzhang();
            }
        });
        
        quit_btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent ae){
            
            quit();
            }
        });
        
        }else{
            //----界面初始化后----
            cardLayout.show(frontLayer, "menuPane");
        }
    }
    
    //公共提示界面
    public JPanel tishiPane = null;
    public JLabel tishil = null;
    public void showtishi(){
        if(tishiPane == null){
            //----未初始化----
            tishiPane = new JPanel();
            tishiPane.setOpaque(false);
            
            //-----添加组件----
            Box tishibox = Box.createVerticalBox();
            tishiPane.add(tishibox);
            
            tishibox.add(Box.createVerticalStrut(200));
            
            //提示语
            JPanel tishi_p = new JPanel();
            tishi_p.setOpaque(false);
            tishil = new JLabel();
            tishil.setForeground(Color.WHITE);
            tishil.setFont(new Font("微软雅黑", Font.PLAIN, 25));
            tishi_p.add(tishil);
            tishibox.add(tishi_p);
            
            tishibox.add(Box.createVerticalStrut(30));
            
            //按钮
            JPanel fanghui = new JPanel();
            fanghui.setOpaque(false);
            JButton fhbtn = new JButton("返   回");
            fhbtn.setFont(new Font("华文仿宋", Font.BOLD, 20));
            fanghui.add(fhbtn);
            tishibox.add(fanghui);
            
            //监听
            fhbtn.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                showMenu();
                }
            });
            
            //设置界面
            frontLayer.add("tishiPane", tishiPane);
            cardLayout.show(frontLayer, "tishiPane");
            frontLayer.validate();
        
        }else{
            cardLayout.show(frontLayer, "tishiPane");
        }
    }
    
    //查询界面
    public void showChaxun(){
        showtishi();
        tishil.setText("您的账户余额是"+bo.dochaxun()+"元");
    }
    
    //存款界面
    public JPanel cunkuanPane = null;
    public JTextField cuninput = null;
    public JLabel cunl = null;
    
    public void showCunkuan(){
        if(cunkuanPane == null){
            cunkuanPane = new JPanel();
            cunkuanPane.setOpaque(false);
            
            Box cunkuanbox = Box.createVerticalBox();
            cunkuanPane.add(cunkuanbox);
            
            cunkuanbox.add(Box.createVerticalStrut(200));
            
            JPanel cunshu = new JPanel();
            cunshu.setOpaque(false);
            JLabel cunshutips = new JLabel("请输入存款金额：");
            cunshutips.setForeground(Color.WHITE);
            cunshutips.setFont(new Font("微软雅黑", Font.PLAIN, 25));
            cunshu.add(cunshutips);
            cuninput = new JTextField(5);
            cuninput.setFont(new Font("华文仿宋", Font.PLAIN, 30));
            cunshu.add(cuninput);
            cunkuanbox.add(cunshu);
            
            cunkuanbox.add(Box.createVerticalStrut(30));
            
            JPanel cunbtn = new JPanel();
            cunbtn.setOpaque(false);
            JButton cunqb = new JButton("确  定");
            cunqb.setFont(new Font("华文仿宋", Font.BOLD, 20));
            cunbtn.add(cunqb);
            JButton cunfb = new JButton("返  回");
            cunfb.setFont(new Font("华文仿宋", Font.BOLD, 20));
            cunbtn.add(cunfb);
            cunkuanbox.add(cunbtn);
            
            cunkuanbox.add(Box.createVerticalStrut(30));

            JPanel cuntips = new JPanel();
            cuntips.setOpaque(false);
            cunl = new JLabel();
            cunl.setForeground(new Color(238,32,32));
            cunl.setFont(new Font("华文仿宋", Font.BOLD, 25));
            cuntips.add(cunl);
            cunkuanbox.add(cuntips);
            
            //监听
            cunqb.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                    String cunget = cuninput.getText();
                    if("".equals(cunget)){
                        cunl.setText("输入不能为空！！");
                    }else{
                        double cunr = bo.docunkuan(Double.valueOf(cunget));
                        if(cunr == 1){
                            cuninput.setText("");
                            cuninput.requestFocus();
                            cunl.setText("");
                            showCunkuanSuccess();
                        }else{
                            cunl.setText("您输入的金额不是整百数值，请重新输入！！");
                            cuninput.setText("");
                            cuninput.requestFocus();
                        }
                    }
                }
            });
            
            cunfb.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                    cuninput.setText("");
                    cunl.setText("");
                    showMenu();
                }
            });
            
            //设置界面
            frontLayer.add("cunkuanPane", cunkuanPane);
            cardLayout.show(frontLayer, "cunkuanPane");
            frontLayer.validate();
            cuninput.requestFocus();
        }else{
            cardLayout.show(frontLayer, "cunkuanPane");
            cuninput.requestFocus();
        }
    }
    
    //存款成功提示界面
    public void showCunkuanSuccess(){
        showtishi();
        tishil.setText("存款成功！您的账户余额为"+bo.dochaxun()+"元");
    }
    
    //取款界面
    public JPanel qukuanPane = null;
    public JTextField quinput = null;
    public JLabel qul = null;

    public void showQukuan(){
        if(qukuanPane == null){
            qukuanPane = new JPanel();
            qukuanPane.setOpaque(false);
            
            Box qukuanbox = Box.createVerticalBox();
            qukuanPane.add(qukuanbox);
            
            qukuanbox.add(Box.createVerticalStrut(200));
            
            JPanel qushu = new JPanel();
            qushu.setOpaque(false);
            JLabel qushutips = new JLabel("请输入取款金额：");
            qushutips.setForeground(Color.WHITE);
            qushutips.setFont(new Font("微软雅黑", Font.PLAIN, 25));
            qushu.add(qushutips);
            quinput = new JTextField(5);
            quinput.setFont(new Font("华文仿宋", Font.PLAIN, 30));
            qushu.add(quinput);
            qukuanbox.add(qushu);
            
            qukuanbox.add(Box.createVerticalStrut(30));
            
            JPanel qubtn = new JPanel();
            qubtn.setOpaque(false);
            JButton quqb = new JButton("确  定");
            quqb.setFont(new Font("华文仿宋", Font.BOLD, 20));
            qubtn.add(quqb);
            JButton qufb = new JButton("返  回");
            qufb.setFont(new Font("华文仿宋", Font.BOLD, 20));
            qubtn.add(qufb);
            qukuanbox.add(qubtn);
            
            qukuanbox.add(Box.createVerticalStrut(30));

            JPanel qutips = new JPanel();
            qutips.setOpaque(false);
            qul = new JLabel();
            qul.setForeground(new Color(238,32,32));
            qul.setFont(new Font("华文仿宋", Font.BOLD, 25));
            qutips.add(qul);
            qukuanbox.add(qutips);
            
            //监听
            quqb.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                    String quget = quinput.getText();
                    if("".equals(quget)){
                        qul.setText("输入不能为空！！");
                    }else{
                        int qur = bo.doqukuan(Double.valueOf(quget));
                        if(qur == 1){
                            quinput.setText("");
                            quinput.requestFocus();
                            qul.setText("");
                            showQukuanSuccess();
                        }else{
                            qul.setText("您的账户余额不足！！");
                            quinput.setText("");
                            quinput.requestFocus();
                        }
                    }
                }
            });
            
            qufb.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                    quinput.setText("");
                    qul.setText("");
                    showMenu();
                }
            });
            
            //设置界面
            frontLayer.add("qukuanPane", qukuanPane);
            cardLayout.show(frontLayer, "qukuanPane");
            frontLayer.validate();
            quinput.requestFocus();
        }else{
            cardLayout.show(frontLayer, "qukuanPane");
            quinput.requestFocus();
        }
    }
    
    //取款成功提示界面
    public void showQukuanSuccess(){
        showtishi();
        tishil.setText("取款成功！您的账户余额为"+bo.dochaxun()+"元");
    }
    
    //修改密码界面
    public JPanel xiugaiPane = null;
    public JPasswordField jiuinput = null;
    public JPasswordField xininput = null;
    public JPasswordField queinput = null;
    public JLabel xiul = null;
    
    public void showXiugai(){
        if(xiugaiPane == null){
            xiugaiPane = new JPanel();
            xiugaiPane.setOpaque(false);
            
            Box xiugaibox = Box.createVerticalBox();
            xiugaiPane.add(xiugaibox);
            
            xiugaibox.add(Box.createVerticalStrut(180));

            //旧密码输入
            JPanel jiushu = new JPanel();
            jiushu.setOpaque(false);
            JLabel jiushutips = new JLabel("请输入旧密码：");
            jiushutips.setForeground(Color.WHITE);
            jiushutips.setFont(new Font("微软雅黑", Font.PLAIN, 20));
            jiushu.add(jiushutips);
            jiuinput = new JPasswordField(10);
            jiuinput.setFont(new Font("华文仿宋", Font.PLAIN, 25));
            jiushu.add(jiuinput);
            xiugaibox.add(jiushu);
            
            xiugaibox.add(Box.createVerticalStrut(15));

            //新密码输入
            JPanel xinshu = new JPanel();
            xinshu.setOpaque(false);
            JLabel xinshutips = new JLabel("请输入新密码：");
            xinshutips.setForeground(Color.WHITE);
            xinshutips.setFont(new Font("微软雅黑", Font.PLAIN, 20));
            xinshu.add(xinshutips);
            xininput = new JPasswordField(10);
            xininput.setFont(new Font("华文仿宋", Font.PLAIN, 25));
            xinshu.add(xininput);
            xiugaibox.add(xinshu);
            
            xiugaibox.add(Box.createVerticalStrut(15));

            //新密码确定
            JPanel queshu = new JPanel();
            queshu.setOpaque(false);
            JLabel queshutips = new JLabel("请确认新密码：");
            queshutips.setForeground(Color.WHITE);
            queshutips.setFont(new Font("微软雅黑", Font.PLAIN, 20));
            queshu.add(queshutips);
            queinput = new JPasswordField(10);
            queinput.setFont(new Font("华文仿宋", Font.PLAIN, 25));
            queshu.add(queinput);
            xiugaibox.add(queshu);
            
            xiugaibox.add(Box.createVerticalStrut(30));

            //按钮
            JPanel xiubtn = new JPanel();
            xiubtn.setOpaque(false);
            JButton xiuqb = new JButton("确  定");
            xiuqb.setFont(new Font("华文仿宋", Font.BOLD, 20));
            xiubtn.add(xiuqb);
            JButton xiufb = new JButton("返  回");
            xiufb.setFont(new Font("华文仿宋", Font.BOLD, 20));
            xiubtn.add(xiufb);
            xiugaibox.add(xiubtn);
            
            xiugaibox.add(Box.createVerticalStrut(30));

            //提示语
            JPanel xiutips = new JPanel();
            xiutips.setOpaque(false);
            xiul = new JLabel();
            xiul.setForeground(new Color(238,32,32));
            xiul.setFont(new Font("华文仿宋", Font.BOLD, 25));
            xiutips.add(xiul);
            xiugaibox.add(xiutips);
            
            //监听
            xiuqb.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                String jiustr = new String(jiuinput.getPassword());
                String xinstr = new String(xininput.getPassword());
                String questr = new String(queinput.getPassword());
                
                if("".equals(jiustr)){
                    xiul.setText("旧密码不能为空！！");
                    jiuinput.requestFocus();
                }else if("".equals(xinstr)){
                    xiul.setText("新密码不能为空！！");
                    xininput.requestFocus();
                }else if("".equals(questr)){
                    xiul.setText("请再次输入新密码！！");
                    queinput.requestFocus();
                }else{
                    int n = bo.doxiugai(Integer.valueOf(jiustr), Integer.valueOf(xinstr), Integer.valueOf(questr));

                    if(n == -1){
                        xiul.setText("出现异常！");
                    }else if(n == 0){
                        jiuinput.setText("");
                        xininput.setText("");
                        queinput.setText("");
                        xiul.setText("旧密码输入有误！！");
                    }else if(n == 1){
                        jiuinput.setText("");
                        xininput.setText("");
                        queinput.setText("");
                        showXiugaiSuccess();
                    }else{
                        xininput.setText("");
                        queinput.setText("");
                        xiul.setText("两次密码输入不一致！！");
                    }
                }
                }
            });
            
            xiufb.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                jiuinput.setText("");
                xininput.setText("");
                queinput.setText("");
                xiul.setText("");
                showMenu();
                }
            });
            
            //界面设置
            frontLayer.add("xiugaiPane", xiugaiPane);
            cardLayout.show(frontLayer, "xiugaiPane");
            frontLayer.validate();
            jiuinput.requestFocus();
        }else{
            cardLayout.show(frontLayer, "xiugaiPane");
            jiuinput.setText("");
            xininput.setText("");
            queinput.setText("");
            xiul.setText("");
            jiuinput.requestFocus();
        }
    }
    
    //密码修改成功提示界面
    public JPanel xiusuc = null;
    
    public void showXiugaiSuccess(){
        if(xiusuc == null){
            xiusuc = new JPanel();
            xiusuc.setOpaque(false);
            
            //组件
            Box xiusbox = Box.createVerticalBox();
            xiusuc.add(xiusbox);
            
            xiusbox.add(Box.createVerticalStrut(200));
            
            JPanel xiusp = new JPanel();
            xiusp.setOpaque(false);
            JLabel xiustips = new JLabel("修改密码成功！请按确认重新登陆");
            xiustips.setForeground(Color.WHITE);
            xiustips.setFont(new Font("微软雅黑", Font.PLAIN, 25));
            xiusp.add(xiustips);
            xiusbox.add(xiusp);

            xiusbox.add(Box.createVerticalStrut(30));
            
            JPanel xiubq = new JPanel();
            xiubq.setOpaque(false);
            JButton xiusbtn = new JButton("确   认");
            xiusbtn.setFont(new Font("华文仿宋", Font.BOLD, 20));
            xiubq.add(xiusbtn);
            xiusbox.add(xiubq);
            
            //监听
            xiusbtn.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                bo.cs = 0;
                showLogin();
                }
            });
            
            //设置界面
            frontLayer.add("xiusuc", xiusuc);
            cardLayout.show(frontLayer, "xiusuc");
            frontLayer.validate();
            
        }else{
            cardLayout.show(frontLayer, "xiusuc");
        }
    }
    
    //转账界面
    public JPanel zhuanpane = null;
    public JTextField kahaoinput = null;
    public JTextField jineinput = null;
    public JLabel zhuantips = null;
    public void showZhuanzhang(){
        if(zhuanpane == null){
            //组件
            zhuanpane = new JPanel();
            zhuanpane.setOpaque(false);
            
            Box zhuanbox = Box.createVerticalBox();
            zhuanpane.add(zhuanbox);
            
            zhuanbox.add(Box.createVerticalStrut(200));
            
            JPanel kahaop = new JPanel();
            kahaop.setOpaque(false);
            JLabel kahaot = new JLabel("请输入转账账号：");
            kahaot.setForeground(Color.WHITE);
            kahaot.setFont(new Font("微软雅黑", Font.PLAIN, 25));
            kahaoinput = new JTextField(10);
            kahaoinput.setFont(new Font("华文仿宋", Font.PLAIN, 30));
            kahaop.add(kahaot);
            kahaop.add(kahaoinput);
            zhuanbox.add(kahaop);
            
            zhuanbox.add(Box.createVerticalStrut(15));
            
            JPanel jinep = new JPanel();
            jinep.setOpaque(false);
            JLabel jinet = new JLabel("请输入转账金额：");
            jinet.setForeground(Color.WHITE);
            jinet.setFont(new Font("微软雅黑", Font.PLAIN, 25));
            jineinput = new JTextField(10);
            jineinput.setFont(new Font("华文仿宋", Font.PLAIN, 30));
            jinep.add(jinet);
            jinep.add(jineinput);
            zhuanbox.add(jinep);
            
            zhuanbox.add(Box.createVerticalStrut(30));
            
            JPanel zhuanbp = new JPanel();
            zhuanbp.setOpaque(false);
            JButton zhuanqbtn = new JButton("确   认");
            zhuanqbtn.setFont(new Font("华文仿宋", Font.BOLD, 20));
            JButton zhuanfbtn = new JButton("返   回");
            zhuanfbtn.setFont(new Font("华文仿宋", Font.BOLD, 20));
            zhuanbp.add(zhuanqbtn);
            zhuanbp.add(zhuanfbtn);
            zhuanbox.add(zhuanbp);
            
            zhuanbox.add(Box.createVerticalStrut(30));
            
            JPanel zhuantp = new JPanel();
            zhuantp.setOpaque(false);
            zhuantips = new JLabel();
            zhuantips.setForeground(new Color(238,32,32));
            zhuantips.setFont(new Font("华文仿宋", Font.BOLD, 25));
            zhuantp.add(zhuantips);
            zhuanbox.add(zhuantp);
            
            //监听
            zhuanqbtn.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                    String zh = kahaoinput.getText();
                    String je = jineinput.getText();
                    if("".equals(zh)){
                        zhuantips.setText("转账账户不能为空！");
                        kahaoinput.requestFocus();
                    }else if("".equals(je)){
                        zhuantips.setText("转账金额不能为空！");
                        jineinput.requestFocus();
                    }else{
                        int f = bo.dozhuanzhang(zh, Double.valueOf(je));
                        if(f == -1){
                            zhuantips.setText("出现异常！");
                        }else if(f == 0){
                            zhuantips.setText("转账账户不存在！");
                        }else if(f == 1){
                            zhuantips.setText("您不能为自己转账！");
                        }else if(f == 2){
                            zhuantips.setText("转账金额超过账户余额！");
                        }else{
                            showZhuanzhangsuccess();
                        }
                    }
                }
            });
            
            zhuanfbtn.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent ae){
                    showMenu();
                }
            });
            
            //界面
            frontLayer.add("zhuan", zhuanpane);
            cardLayout.show(frontLayer, "zhuan");
            frontLayer.validate();
            kahaoinput.requestFocus();
        }else{
            cardLayout.show(frontLayer, "zhuan");
            zhuantips.setText("");
            kahaoinput.setText("");
            jineinput.setText("");
            kahaoinput.requestFocus();
        }
    }
    
    //转账成功提示界面    
    public void showZhuanzhangsuccess(){
        showtishi();
        tishil.setText("转款成功！您的账户余额为"+bo.dochaxun()+"元");
    }
    
    //退卡
    public void quit(){
    //重新初始化业务对象
    initBO();
    //重新显示登录界面
    showLogin();
    }
    
}

业务层

import java.io.*;
import java.net.*;

public class ATMBO{
    //服务端ip
    public String ip = "127.0.0.1";
    //服务器端口
    public int port = 5000;
    //存储当前账号游标
    public String current_code = null;
    //储存错误次数
    public int cs = 0;
    
    //创建Socket对象
    Socket socket = null;
    DataOutputStream output = null;
    DataInputStream input = null;
    
    //登陆业务
    //1.用户输入的卡号和密码作为登录业务方法的两个参数，有前面ATMUI类调用的时候传入
    //2.登陆业务处理后要“告知”ATMUI类结果，因此设一个int返回值，如果卡号和密码都正确，登陆成功，则返回-1，若果卡号和密码都不正确，则返回错误次数（超过3次吞卡），因此，当前账户登录错误次数也要作为全局变量储存起来。


    public int dologin(String code_input, int password_input){
        int rtn = -1;
        try{
            //通过服务器ip和端口，创建Socket对象，连接服务器
            socket = new Socket(ip, port);
            
            //获取Socket输出流，并包装为DataOutputStream
            output = new DataOutputStream(socket.getOutputStream());
            //拼接要传输的参数
            String send = "dologin&" +code_input+"&"+password_input;
            //加密输出
            encryptWrite(send, output);
            
            //获取Socket输入流，并包装为DataInputStream
            input = new DataInputStream(socket.getInputStream());
            //获取并解密，接收返回结果
            String receive = readDecrypt(input);
            if("-1".equals(receive)){
                cs++;
                rtn = cs;
            }else{
                current_code = receive;
                rtn = -1;
            }
            return rtn;
        }catch(Exception ex){
            ex.printStackTrace();
            return -2;
        }
        
    }
    
    //查询业务
    public double dochaxun(){
        double rtn = 0;
        try{
            String send = "dochaxun&"+current_code;
            encryptWrite(send, output);
            
            String receive = readDecrypt(input);
            rtn = Double.valueOf(receive);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return rtn;
    }

    //存款业务
    public double docunkuan(double cunkuan){
        double rtn = 0;
        try{
            
            String send = "docunkuan&"+current_code+"&"+cunkuan;
            encryptWrite(send, output);
            
            String receive = readDecrypt(input);
            rtn = Double.valueOf(receive);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return rtn;
    }

    //取款业务
    public int doqukuan(double qukuan){
        int rtn = 0;
        try{
            String send = "doqukuan&"+current_code+"&"+qukuan;
            encryptWrite(send, output);
            
            String receive = readDecrypt(input);
            rtn = Integer.valueOf(receive);
            
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return rtn;
    }
    
    //密码修改业务
    public int doxiugai(int jiu, int xin, int que){
        int rtn = -1;
        try{
            String send = "doxiugai&"+current_code+"&"+ jiu +"&"+ xin +"&"+ que;
            encryptWrite(send, output);
            
            String receive = readDecrypt(input);
            rtn = Integer.valueOf(receive);
            
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return rtn;
    }
    
    //转账业务
    public int dozhuanzhang(String z, double m){
        int rtn = -1;
        try{
            String send = "dozhuanzhang&"+current_code+"&"+ z +"&"+ m;
            encryptWrite(send, output);
            
            String receive = readDecrypt(input);
            rtn = Integer.valueOf(receive);
            
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return rtn;
    }
    
    
    //加密输出
        public void encryptWrite(String src, DataOutputStream output) throws IOException{
            //将一个字符串转换成字符数组
            char[] char_arr = src.toCharArray();
            //对每个字符·进行加密操作
            for(int i=0; i<char_arr.length; i++){
                output.writeChar(char_arr[i] + 12);
            }
            //在输出内容后加一个特殊符号作为结束符
            output.writeChar(33333);
            //刷写内容
            output.flush();
        }
        
        //读取解密
        public String readDecrypt(DataInputStream input) throws IOException{
            String rtn = "";
            
            while(true) {
                //从输出流中读取一个字符，直到结束符
                int char_src = input.readChar();
                if(char_src != 33333){
                    rtn = rtn + (char)(char_src - 12);
                }else{
                    break;
                }
            }
            return rtn;
        }

        public void socclose() {
            try {
                if(output != null){output.close();}
                if(input != null){input.close();}
                if(socket != null){socket.close();}
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
}

 

 

服务端：

import java.io.*;
import java.net.*;
import java.sql.*;

public class serverBO{
    
    public static void main(String [] args){
        //定义serverSocket，用于监听某个端口，等待客户端连接
        ServerSocket server_socket = null;
        
        try{
            //创建ServerSocket对象，监听端口5000
            server_socket = new ServerSocket(5000);
            System.out.println("ready");
            while(true){
                //调用ServerSocket的accept方法，等待客户端连接，成功连接之后，返回Socket对象
                Socket socket = server_socket.accept();
                
                new thread(socket).start();
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }finally{
            try{
                //关闭ServerSocket
                if(server_socket != null){
                    server_socket.close();
                }
            }catch(Exception ex){
                ex.printStackTrace();
            }
        }
    }
    
    //登陆业务
    //1.用户输入的卡号和密码作为登录业务方法的两个参数，有前面ATMUI类调用的时候传入
    //2.登陆业务处理后要“告知”ATMUI类结果，因此设一个int返回值，如果卡号和密码都正确，登陆成功，则返回-1，若果卡号和密码都不正确，则返回错误次数（超过3次吞卡），因此，当前账户登录错误次数也要作为全局变量储存起来。

    public String dologin(String code_input, int password_input){
        //定义数据库连接对象
        Connection conn = null;
        //定义传输对象statement
        Statement stmt = null;
        //定义结果焦对象ResultSet
        ResultSet rs = null;
        try{
            //加载Driver驱动
            Class.forName("com.mysql.jdbc.Driver");
            //创建数据库连接对象Connection
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bank", "root", "root");
            //创建一个向数据库发送命令并返回结果的传送对象statement
            stmt =conn.createStatement();
            
            //定义sql命令，查询符合输入的卡号和密码的数据
            String sql = "select * from account where code = '"+code_input + "' and password = " + password_input;
            //将sql命令通过sql传送对象Statement传送到数据库执行，并返回卡号
            rs = stmt.executeQuery(sql);
            
            //处理结果集
            if(rs.next()){
                //如果存在符合输入的卡号和密码条件的数据，表示登录成功，返回卡号
                return code_input;
            }else{
                //如果不存在该数据，表示登录失败，返回“-1”
                return "-1";
            }
        }catch(Exception e){
            e.printStackTrace();
            //有异常返回-1
            return "-1";
        }finally{
            try{
                if(rs != null){ rs.close();}
                if(stmt != null){stmt.close();}
                if(conn != null){conn.close();}
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        
    }
    
    //查询业务
    public double dochaxun(String current_code){
        double rtn = 0.0;
        
        //定义数据库连接对象
        Connection conn = null;
        //定义传输对象statement
        Statement stmt = null;
        //定义结果焦对象ResultSet
        ResultSet rs = null;
        
        try{
            //加载Driver驱动
            Class.forName("com.mysql.jdbc.Driver");
            //创建数据库连接对象Connection
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bank", "root", "root");
            //创建一个向数据库发送命令并返回结果的传送对象statement
            stmt =conn.createStatement();
            
            //定义sql命令，查询对应卡号的余额
            String sql = "select money from account where code = '"+current_code + "'";
            //将sql命令通过sql传送对象Statement传送到数据库执行，并返回结果集
            rs = stmt.executeQuery(sql);
            
            //处理结果集
            if(rs.next()){
                //获取余额信息
                rtn = rs.getDouble("money");
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(rs != null){ rs.close();}
                if(stmt != null){stmt.close();}
                if(conn != null){conn.close();}
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        return rtn;
    }
    
    //存款业务
    public int docunkuan(String current_code, double cunkuan){
        double ck = cunkuan;
        double p = ck/100;
        int c = (int) p;
        if(c == p) {
            //定义数据库连接对象
            Connection conn = null;
            //定义传输对象statement
            Statement stmt = null;
            
            try{
                //加载Driver驱动
                Class.forName("com.mysql.jdbc.Driver");
                //创建数据库连接对象Connection
                conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bank", "root", "root");
                //创建一个向数据库发送命令并返回结果的传送对象statement
                stmt =conn.createStatement();
                
                //定义sql命令，修改对应卡号的余额
                String sql = "update account set money = money + "+cunkuan+" where code = '" + current_code + "'";  
                //将sql命令通过sql传送对象Statement传送到数据库执行
                stmt.executeUpdate(sql);
            }catch(Exception e){
                e.printStackTrace();
            }finally{
                try{
                    if(stmt != null){stmt.close();}
                    if(conn != null){conn.close();}
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
            return 1;
        }else{
            return 0;
        }
    }
    
    //取款业务
    public int doqukuan(String current_code, double qukuan){
        double money = dochaxun(current_code);
        if(qukuan > money){
            return 0;
        }else{
            Connection conn = null;
            Statement stmt = null;
            
            try{
                Class.forName("com.mysql.jdbc.Driver");
                conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bank", "root", "root");
                stmt =conn.createStatement();
                
                String sql = "update account set money = money - "+ qukuan + " where code = '" + current_code + "'";  
                stmt.executeUpdate(sql);
            }catch(Exception e){
                e.printStackTrace();
            }finally{
                try{
                    if(stmt != null){stmt.close();}
                    if(conn != null){conn.close();}
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
            return 1;
        }
    }
    
    //密码修改业务
    public int doxiugai(String current_code, int jiu, int xin, int que){
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try{
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bank", "root", "root");
            stmt =conn.createStatement();
            
            String sql = "select * from account where code = '"+current_code + "'";
            rs = stmt.executeQuery(sql);
            
            //处理结果集
            rs.next();
            int password = rs.getInt("password");
            
            //密码修改
            if(jiu == password){
                if(xin == que){
                    String sql1 = "update account set password = " + xin + " where code = '"+current_code + "'";
                    stmt.executeUpdate(sql1);
                    return 1;
                }else{
                    return 2;
                }
            }else{
                return 0;
            }
            
        }catch(Exception e){
            e.printStackTrace();
            return 0;
        }finally{
            try{
                if(rs != null){ rs.close();}
                if(stmt != null){stmt.close();}
                if(conn != null){conn.close();}
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    
    //转账业务
    public int dozhuanzhang(String current_code, String z, double m){
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        
        try{
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bank", "root", "root");
            stmt = conn.createStatement();
            
            String sql = "select * from account where code = '"+z + "'";
            rs = stmt.executeQuery(sql);
            if(!(rs.next())){
                return 0;
            }else{
                String zcode = rs.getString("code");
                if(zcode.equals(current_code)){
                    return 1;
                }
            }
            double money = dochaxun(current_code);
            if(m > money){
                return 2;
            }
            
            try{
                //设置事务的提交方式为非自动提交
                conn.setAutoCommit(false);
                String sql1 = "update account set money = money - "+ m + " where code = '" + current_code + "'";  
                String sql2 = "update account set money = money + "+ m + " where code = '" + z + "'";  
                stmt.executeUpdate(sql1);
                stmt.executeUpdate(sql2);
                //提交事务：
                conn.commit();
                return 3;
            }catch(SQLException e){
                conn.rollback();
                e.printStackTrace();
                return -1;
            }finally{
                conn.setAutoCommit(true);
            }
        }catch(Exception e){
            e.printStackTrace();
            return -1;
        }finally{
            try{
                if(rs != null){ rs.close();}
                if(stmt != null){stmt.close();}
                if(conn != null){conn.close();}
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    
    //加密输出
    public void encryptWrite(String src, DataOutputStream output) throws IOException{
        //将一个字符串转换成字符数组
        char[] char_arr = src.toCharArray();
        //对每个字符·进行加密操作
        for(int i=0; i<char_arr.length; i++){
            output.writeChar(char_arr[i] + 12);
        }
        //在输出内容后加一个特殊符号作为结束符
        output.writeChar(33333);
        //刷写内容
        output.flush();
    }
    
    //读取解密
    public String readDecrypt(DataInputStream input) throws IOException{
        String rtn = "";
        
        while(true) {
            //从输出流中读取一个字符，直到结束符
            int char_src = input.readChar();
            if(char_src != 33333){
                rtn = rtn + (char)(char_src - 12);
            }else{
                break;
            }
        }
        return rtn;
    }
    
}

//线程
class thread extends Thread{
    serverBO bo = new serverBO();
    
    Socket socket = null;
    DataInputStream input;
    DataOutputStream output;
    public thread(Socket s){
        socket = s;
        try {
            input = new DataInputStream(socket.getInputStream());
            output = new DataOutputStream(socket.getOutputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public void run(){
        try {
            while (true) {
                //读取并解密
                String receive = bo.readDecrypt(input);
                //现在从客户端传输过来的数据格式为“参数1&参数2&参数3...”，因此要进行解析
                //其中第一个参数是指要调用的业务方法
                String[] param = receive.split("&");
                if ("dologin".equals(param[0])) {
                    //登陆业务：第二个参数是用户输入的卡号；第三个是密码
                    String send = bo.dologin(param[1], Integer.valueOf(param[2]));
                    //把业务处理结果加密并输出返回
                    bo.encryptWrite(String.valueOf(send), output);
                } else if ("dochaxun".equals(param[0])) {
                    //查询业务：第2个参数是当前账号的游标
                    double send = bo.dochaxun(param[1]);
                    //把业务处理结果加密并输出返回
                    bo.encryptWrite(String.valueOf(send), output);
                } else if ("docunkuan".equals(param[0])) {
                    //存款业务：第二个参数是当前账号的游标，第三个是用户输入的金额
                    int send = bo.docunkuan(param[1],
                            Double.valueOf(param[2]));
                    bo.encryptWrite(String.valueOf(send), output);
                } else if ("doqukuan".equals(param[0])) {
                    //取款业务
                    int send = bo.doqukuan(param[1],
                            Double.valueOf(param[2]));
                    bo.encryptWrite(String.valueOf(send), output);
                } else if ("dozhuanzhang".equals(param[0])) {
                    //转帐业务
                    int send = bo.dozhuanzhang(param[1],
                            param[2], Double.valueOf(param[3]));
                    bo.encryptWrite(String.valueOf(send), output);
                } else if ("doxiugai".equals(param[0])) {
                    //密码修改业务
                    int send = bo.doxiugai(param[1],
                            Integer.valueOf(param[2]),
                            Integer.valueOf(param[3]),
                            Integer.valueOf(param[4]));
                    bo.encryptWrite(String.valueOf(send), output);
                }
            }
        } catch (EOFException e) {
            System.out.println("线程关闭");
        } catch (SocketException e) {
            System.out.println("socket关闭，线程结束");
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                if(input != null){ input.close();}
                if(output != null){ output.close();}
                if(socket != null){ socket.close();}
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}