基于javaswing和mysql实现的员工工资管理系统

项目上传到了github，下载EPMS文件夹即可，源码都在里面，记得给我一个star
https://github.com/XK-coding/projects.git
  

---

  
工资管理系统EPMS

这个项目是基于javaswing和mysql数据库所开发的
java编译器是eclipse，版本是2020-12-R
mysql管理工具是navicat，版本是8.1
1.功能模块计划

1.1java语言连接数据库jdbc

我们要通过java来操作数据库，起首就要把他们连接起来
代码实现逻辑：
四参五步：我们需要四个参数和五个步调来成功连接数据库，在这之前，我们需要创建一个lib文件夹，然后再导入我们所需要的mysql-connector的jar包
四参：

• 加载jdbc连接mysql的驱动driver
  
• 连接mysql数据库的地址url
  
• 连接msyql的用户名user
  
• 连接mysql的密码password
  

五步：

• 加载jdbc的驱动
  
• 连接mysql的连接对象
  
• 预编译sql执行
  
• 执行sql语句
  
• 关闭数据库
  

代码如下：

1. package com.jdbc;
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.PreparedStatement;
6. import java.sql.ResultSet;
7. import java.sql.SQLException;
9. public class DBConnection {
10.         //1.加载jdbc连接mysql的驱动
11.         public final static String driver = "com.mysql.cj.jdbc.Driver";
12.        
13.         //2.连接mysql数据库的地址
14.         public final static String url = "jdbc:mysql://localhost:3306/wages";
15.        
16.         //3.连接mysql的用户名
17.         public final static String user = "root";
18.        
19.         //4.连接mysql的密码
20.         public final static String pwd = "txk0x7d2";
21.        
22.         //static静态代码块加载jdbc的驱动
23.         static {
24.                 try {
25.                         Class.forName(driver);
26.                 } catch (ClassNotFoundException e) {
27.                         // TODO Auto-generated catch block
28.                         e.printStackTrace();
29.                 }
30.         }
31.        
32.         //连接mysql的连接对象
33.         public static Connection getConn() {
34.                 try {
35.                         return DriverManager.getConnection(url, user, pwd);
36.                 } catch (SQLException e) {
37.                         // TODO Auto-generated catch block
38.                         e.printStackTrace();
39.                 }
40.                 return null;
41.         }
42.        
43.         //关闭连接，保证mysql资源的释放，能够充分使用资源
44.         public static void close(ResultSet rs, PreparedStatement ps, Connection conn) {
45.                 try {
46.                         if (rs != null) {
47.                                 rs.close();
48.                         }
49.                         if (ps != null) {
50.                                 ps.close();
51.                         }
52.                         if (conn != null) {
53.                                 conn.close();
54.                         }
55.                 } catch (Exception e) {
56.                         // TODO Auto-generated catch block
57.                         e.printStackTrace();
58.                 }
59.         }
60.        
61.         //验证jdbc的使用
62.         public static void main(String[] args) {
63.                 System.out.println(getConn()+"数据库连接成功！");
64.         }
66. }

复制代码

1.2系统登录Login

系统登录界面如图所示：

代码实现逻辑：

• 起首我们先获取用户输入在账号和密码文本框中的字符串，然后将其拿到我们所连接的数据库里面账号表中，在该表中进行查询相应的账号和密码并拿出来与用户所输入的对比，如果相等则登录成功，反之提示“用户名或密码错误！”；
  
• 同时我们要选择ComboBox下拉选择框里面所设置的值，比方管理员登录，则通过这个来区分开不同范例的用户登录后所能使用的功能。管理员能够使用全部功能，而员工则会隐藏部分功能，好比对工资表的操作等等。
  

代码实现：

1. package com.ui;
3. import java.awt.EventQueue;
5. import javax.swing.JFrame;
6. import javax.swing.JPanel;
7. import javax.swing.border.EmptyBorder;
9. import com.dao.AccountDAO;
10. import com.entity.Account;
11. import com.entity.UserType;
12. import com.util.StringUtil;
14. import javax.swing.JLabel;
15. import javax.swing.JOptionPane;
17. import java.awt.Font;
18. import javax.swing.JTextField;
19. import javax.swing.JPasswordField;
20. import javax.swing.JComboBox;
21. import javax.swing.DefaultComboBoxModel;
22. import javax.swing.JButton;
23. import java.awt.event.ActionListener;
24. import java.awt.event.ActionEvent;
26. public class Login extends JFrame {
28.         private JPanel contentPane;
29.         private JTextField userNameTextField;
30.         private JComboBox userTypeComboBox;
31.         private JTextField passwordField;
33.         /**
34.          * Launch the application.
35.          */
36.         public static void main(String[] args) {
37.                 EventQueue.invokeLater(new Runnable() {
38.                         public void run() {
39.                                 try {
40.                                         Login frame = new Login();
41.                                         frame.setVisible(true);
42.                                 } catch (Exception e) {
43.                                         e.printStackTrace();
44.                                 }
45.                         }
46.                 });
47.         }
49.         /**
50.          * Create the frame.
51.          */
52.         public Login() {
53.                 setResizable(false);
54.                 setTitle("\u767B\u5F55");
55.                 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
56.                 setBounds(100, 100, 330, 311);
57.                 contentPane = new JPanel();
58.                 contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
60.                 setContentPane(contentPane);
61.                 contentPane.setLayout(null);
62.                
63.                 JLabel lblNewLabel = new JLabel("\u8D26\u53F7\uFF1A");
64.                 lblNewLabel.setFont(new Font("宋体", Font.PLAIN, 18));
65.                 lblNewLabel.setBounds(26, 51, 70, 25);
66.                 contentPane.add(lblNewLabel);
67.                
68.                 userNameTextField = new JTextField();
69.                 userNameTextField.setBounds(85, 53, 150, 24);
70.                 contentPane.add(userNameTextField);
71.                 userNameTextField.setColumns(10);
72.                
73.                 JLabel lblNewLabel_1 = new JLabel("\u5BC6\u7801\uFF1A");
74.                 lblNewLabel_1.setFont(new Font("宋体", Font.PLAIN, 18));
75.                 lblNewLabel_1.setBounds(26, 104, 70, 25);
76.                 contentPane.add(lblNewLabel_1);
77.                
78.                 userTypeComboBox = new JComboBox();
79.                 userTypeComboBox.setModel(new DefaultComboBoxModel(new UserType[] {UserType.ADMIN, UserType.EMPLOYEE}));
80.                 userTypeComboBox.setBounds(122, 157, 113, 23);
81.                 contentPane.add(userTypeComboBox);
82.                
83.                 JButton loginButton = new JButton("\u767B\u5F55");
84.                 loginButton.addActionListener(new ActionListener() {
85.                         public void actionPerformed(ActionEvent ae) {
86.                                 //登录按钮绑定事件
87.                                 loginAct(ae);
88.                         }
89.                 });
90.                 loginButton.setBounds(26, 198, 93, 23);
91.                 contentPane.add(loginButton);
92.                
93.                 JButton disposeButton = new JButton("\u9000\u51FA");
94.                 disposeButton.addActionListener(new ActionListener() {
95.                         public void actionPerformed(ActionEvent e) {
96.                                 //退出
97.                                 dispose();
98.                         }
99.                 });
100.                 disposeButton.setBounds(214, 238, 93, 23);
101.                 contentPane.add(disposeButton);
102.                
103.                 JLabel lblNewLabel_2 = new JLabel("\u5DE5\u8D44\u7BA1\u7406\u7CFB\u7EDF\u767B\u5F55");
104.                 lblNewLabel_2.setFont(new Font("宋体", Font.PLAIN, 24));
105.                 lblNewLabel_2.setBounds(61, 10, 206, 31);
106.                 contentPane.add(lblNewLabel_2);
107.                
108.                 JButton registerButton = new JButton("\u6CE8\u518C");
109.                 registerButton.setBounds(161, 198, 93, 23);
110.                 contentPane.add(registerButton);
111.                
112.                 passwordField = new JTextField();
113.                 passwordField.setColumns(10);
114.                 passwordField.setBounds(85, 107, 150, 24);
115.                 contentPane.add(passwordField);
116.         }
118.         protected void loginAct(ActionEvent ae) {
119.                 // TODO Auto-generated method stub
120.                 String userName = userNameTextField.getText().toString();
121.                 String password = passwordField.getText().toString();
122.                 UserType selectedItem = (UserType)userTypeComboBox.getSelectedItem();
123.                 //判断用户名是否为空
124.                 if (StringUtil.isEmpty(userName)) {
125.                         JOptionPane.showMessageDialog(this, "用户名不能为空！");
126.                         return;
127.                 }
128.                 //判断密码是否为空
129.                 if (StringUtil.isEmpty(password)) {
130.                         JOptionPane.showMessageDialog(this, "密码不能为空！");
131.                         return;
132.                 }
133.                
134.                 if ("系统管理员".equals(selectedItem.getName())) {
135.                         //系统管理员登录
136.                         AccountDAO accountDAO = new AccountDAO();
137.                         Account accountTmp = new Account();
138.                         accountTmp.setZhanghao(userName);
139.                         accountTmp.setPassword(password);
140.                         Account account = accountDAO.login(accountTmp);
141.                         if (account == null) {
142.                                 JOptionPane.showMessageDialog(this, "用户名或密码错误！");
143.                                 return;
144.                         } else {
145.                                 JOptionPane.showMessageDialog(this, "登录成功！");
146.                                 AdminSystem frame = new AdminSystem();
147.                                 frame.setVisible(true);
148.                                 dispose();
149.                         }
150.                 } else {
151.                         //员工登录
152.                 }
153.         }
154. }

复制代码

1.3实体类计划entity

我们要通过java来操作数据库中表里面的数据，那么数据库中的每一张表就对应着java里面的一个实体类，所以我们在这里创建账号表account所对应的实体类Account
代码实现逻辑：

• 起首我们要和表中的数据保持同等，同样的在实体类中声明相对应的数据和范例
  
• 然后我们选中全部声明的数据，来generate他们的getter and setter方法，以便于后面得到值和设置值
  

代码如下：

1. package com.entity;
3. public class Account {
4.         private int id;
5.         private String zhanghao;
6.         private String password;
7.         public int getId() {
8.                 return id;
9.         }
10.         public void setId(int id) {
11.                 this.id = id;
12.         }
13.         public String getZhanghao() {
14.                 return zhanghao;
15.         }
16.         public void setZhanghao(String zhanghao) {
17.                 this.zhanghao = zhanghao;
18.         }
19.         public String getPassword() {
20.                 return password;
21.         }
22.         public void setPassword(String password) {
23.                 this.password = password;
24.         }
26. }

复制代码

1.4管理员系统AdminSystem

通过管理员选项登录成功后我们会创建一个管理员系统的界面，如图所示

在这里，我们先介绍员工工资管理，点进去后我们会跳转到员工工资管理界面
代码实现逻辑：
这一个主要是ui的计划，而我是通过javaswing来计划的，用eclipse里面扩展的功能WindowBuilder来图形化创建界面，最后给按钮绑定点击事件即可。
代码实现如下：

1. package com.ui;
3. import java.awt.EventQueue;
5. import javax.swing.JFrame;
6. import javax.swing.JPanel;
7. import javax.swing.border.EmptyBorder;
8. import javax.swing.JButton;
9. import java.awt.event.ActionListener;
10. import java.awt.event.ActionEvent;
12. public class AdminSystem extends JFrame {
14.         private JPanel contentPane;
16.         /**
17.          * Launch the application.
18.          */
19.         public static void main(String[] args) {
20.                 EventQueue.invokeLater(new Runnable() {
21.                         public void run() {
22.                                 try {
23.                                         AdminSystem frame = new AdminSystem();
24.                                         frame.setVisible(true);
25.                                 } catch (Exception e) {
26.                                         e.printStackTrace();
27.                                 }
28.                         }
29.                 });
30.         }
32.         /**
33.          * Create the frame.
34.          */
35.         public AdminSystem() {
36.                 setResizable(false);
37.                 setTitle("\u7BA1\u7406\u5458\u7CFB\u7EDF");
38.                 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
39.                 setBounds(100, 100, 323, 207);
40.                 contentPane = new JPanel();
41.                 contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
43.                 setContentPane(contentPane);
44.                 contentPane.setLayout(null);
45.                
46.                 JButton btnNewButton = new JButton("\u5458\u5DE5\u4FE1\u606F\u7BA1\u7406");
47.                 btnNewButton.addActionListener(new ActionListener() {
48.                         public void actionPerformed(ActionEvent e) {
49.                         }
50.                 });
51.                 btnNewButton.setBounds(10, 26, 121, 23);
52.                 contentPane.add(btnNewButton);
53.                
54.                 JButton btnNewButton_1 = new JButton("\u5458\u5DE5\u5DE5\u8D44\u7BA1\u7406");
55.                 btnNewButton_1.addActionListener(new ActionListener() {
56.                         public void actionPerformed(ActionEvent e) {
57.                                 AdminWages frame = new AdminWages();
58.                                 frame.setVisible(true);
59.                         }
60.                 });
61.                 btnNewButton_1.setBounds(157, 26, 121, 23);
62.                 contentPane.add(btnNewButton_1);
63.                
64.                 JButton btnNewButton_2 = new JButton("\u5458\u5DE5\u8003\u52E4\u7BA1\u7406");
65.                 btnNewButton_2.setBounds(10, 76, 121, 23);
66.                 contentPane.add(btnNewButton_2);
67.                
68.                 JButton btnNewButton_3 = new JButton("\u5458\u5DE5\u6D25\u8D34\u7BA1\u7406");
69.                 btnNewButton_3.setBounds(157, 76, 121, 23);
70.                 contentPane.add(btnNewButton_3);
71.                
72.                 JButton btnNewButton_3_1 = new JButton("\u9000\u51FA\u7CFB\u7EDF");
73.                 btnNewButton_3_1.addActionListener(new ActionListener() {
74.                         public void actionPerformed(ActionEvent e) {
75.                                 dispose();
76.                         }
77.                 });
78.                 btnNewButton_3_1.setBounds(100, 124, 95, 29);
79.                 contentPane.add(btnNewButton_3_1);
80.         }
82. }

复制代码

2.员工工资管理AdminWages

员工工资管理功能则包含了对员工工资信息的增编削查，下面会分别介绍这几个功能
2.1员工工资添加功能

代码实现逻辑：

• 起首我们连接mysql，然后预编译sql执行，String 一个sql，把添加语句放在sql变量里面，“？”用来作为占位符
  
• 然后我们对应工资表wages里面的数据把用户输入的数据得到后设置到wages里面去，最后关闭数据库
  

1.         //增加功能
2.         public boolean add(Wages wages) {
3.                
4.                 //1.连接mysql
5.                 Connection conn = DBConnection.getConn();
6.                
7.                 //2.预编译sql执行
8.                 String sql = "insert into wages values(?,?,?,?,?,?,?)";
9.                 try {
10.                         PreparedStatement ps = conn.prepareCall(sql);
11.                         ps.setInt(1, wages.getCode());
12.                         ps.setInt(2, wages.getBaseWages());
13.                         ps.setInt(3, wages.getPostWages());
14.                         ps.setFloat(4, (float) wages.getMoney());
15.                         ps.setInt(5, wages.getSubsidy());
16.                         ps.setInt(6, wages.getDeduction());
17.                         ps.setFloat(7, (float) wages.getFact());
18.                         //执行操作更改
19.                         boolean result = ps.executeUpdate() > 0;
20.                         //关闭数据库
21.                         DBConnection.close(null, ps, conn);
22.                         return result;
23.                 } catch (SQLException e) {
24.                         // TODO Auto-generated catch block
25.                         e.printStackTrace();
26.                 }
27.                 return false;
28.         }

复制代码

2.2员工工资修改功能

和添加功能差不多，只是sql语句不一样

1. //修改功能
2.         public boolean update(Wages wages) {
3.                
4.                 //1.连接mysql
5.                 Connection conn = DBConnection.getConn();
6.                
7.                 //2.预编译sql执行
8.                 String sql = "update wages set baseWages=?,postWages=?,money=?,subsidy=?,deduction=?,fact=? where code=?";
9.                 try {
10.                         PreparedStatement ps = conn.prepareCall(sql);
11.                        
12.                         ps.setInt(1, wages.getBaseWages());
13.                         ps.setInt(2, wages.getPostWages());
14.                         ps.setFloat(3, (float) wages.getMoney());
15.                         ps.setInt(4, wages.getSubsidy());
16.                         ps.setInt(5, wages.getDeduction());
17.                         ps.setFloat(6, (float) wages.getFact());
18.                         ps.setInt(7, wages.getCode());
19.                         //执行操作更改
20.                         boolean result = ps.executeUpdate() > 0;
21.                         //关闭数据库
22.                         DBConnection.close(null, ps, conn);
23.                         return result;
24.                 } catch (SQLException e) {
25.                         // TODO Auto-generated catch block
26.                         e.printStackTrace();
27.                 }
28.                 return false;
29.         }

复制代码

2.3员工工资删除功能

• 和添加功能差不多，也是sql语句不一样。
  
• 但是，因为后面实际使用的时候，我们删除是通过鼠标选中展示数据中所在的行来确定所要删除的数据，所以我们传入一个变量val
  

1. //删除功能
2.         public boolean delete(String val) {
3.                
4.                 //1.连接mysql
5.                 Connection conn = DBConnection.getConn();
6.                
7.                 //2.预编译sql执行
8.                 String sql = "delete from wages where code=?";
9.                 try {
10.                         PreparedStatement ps = conn.prepareCall(sql);
11.                        
12.                         ps.setString(1,val);
13.                        
14.                         //执行操作更改
15.                         boolean result = ps.executeUpdate() > 0;
16.                         //关闭数据库
17.                         DBConnection.close(null, ps, conn);
18.                         return result;
19.                 } catch (SQLException e) {
20.                         // TODO Auto-generated catch block
21.                         e.printStackTrace();
22.                 }
23.                 return false;
24.         }

复制代码

2.4员工工资查询单个员工工资功能

大部分步调和添加功能差不多，
区别在于：

• 查询和增编削不同，是获取数据但是不修改数据，所以是query，而其他三个都会修改数据，所以统称为update
  
• 因为查询到的单条数据有多个数据项，所以要创建一个效果集ResultSet来存放这些数据，同时要让next()游标指向下一条数据才能接着查询所需要的数据项
  
• sql语句不同
  

1. //查询指定员工
2.                 public Wages query(int code) {
3.                        
4.                         //1.连接mysql
5.                         Connection conn = DBConnection.getConn();
6.                        
7.                         //2.预编译sql执行
8.                         String sql = "select * from wages where code=?";
9.                         try {
10.                                 PreparedStatement ps = conn.prepareCall(sql);
11.                                
12.                                 ps.setInt(1,code);
13.                                
14.                                 //执行操作更改
15.                                 ResultSet rs = ps.executeQuery();
16.                                 //创建一份工资对象返回
17.                                 Wages w = new Wages();
18.                                 while (rs.next()) {
19.                                         w.setCode(rs.getInt(1));
20.                                         w.setBaseWages(rs.getInt(2));
21.                                         w.setPostWages(rs.getInt(3));
22.                                         w.setMoney(rs.getDouble(4));
23.                                         w.setSubsidy(rs.getInt(5));
24.                                         w.setDeduction(rs.getInt(6));
25.                                         w.setMoney(rs.getDouble(7));
26.                                 }
27.                                
28.                                
29.                                 //关闭数据库
30.                                 DBConnection.close(rs, ps, conn);
31.                                 return w;
32.                         } catch (SQLException e) {
33.                                 // TODO Auto-generated catch block
34.                                 e.printStackTrace();
35.                         }
36.                         return null;
37.                 }

复制代码

2.5员工工资查询全部员工工资功能

查询全部列和查询指定列大部分一样
区别在于：

• keyword用于模糊查询，因为后面使用时如果keyword为空则全部查询，如果keyword不为空则会被拼接到查询全部的sql语句中作为筛选条件，没错，这两个功能团结起来使用了
  
• 这里用Vector来创建一个二维列表，因为后面所使用时展示的就是二维列表
  

1. //查询所有员工工资信息 keyword用于搜索模糊查询
2.         public Vector<Vector<String>> getAll(String keyword) {
3.                 //1.连接mysql
4.                 Connection conn = DBConnection.getConn();
5.                
6.                 //2.预编译sql执行
7.                 String sql = "select * from wages";
8.                 //如果有关键字，则把它拼接到查询语句当中作限制条件
9.                 if (keyword != null) {
10.                         sql += " where code like '%"+keyword+"%'";
11.                 }
12.                 try {
13.                         PreparedStatement ps = conn.prepareStatement(sql);
14.                        
15.                         //执行操作更改
16.                         ResultSet rs = ps.executeQuery();
17.                         //创建一个二维数组返回
18.                         Vector<Vector<String>> list = new Vector<Vector<String>>();
19.                        
20.                         while (rs.next()) {
21.                                 Vector<String> w = new Vector<String>();
22.                                 w.add(rs.getString(1));
23.                                 w.add(rs.getString(2));
24.                                 w.add(rs.getString(3));
25.                                 w.add(rs.getString(4));
26.                                 w.add(rs.getString(5));
27.                                 w.add(rs.getString(6));
28.                                 w.add(rs.getString(7));
29.                                
30.                                 //把当前对象存储到list集合中
31.                                 list.add(w);
32.                         }
33.                         //关闭数据库
34.                         DBConnection.close(rs, ps, conn);
35.                         return list;
36.                
37.                 } catch (SQLException e) {
38.                         // TODO Auto-generated catch block
39.                         e.printStackTrace();
40.                 }
41.                 return null;
42.         }

复制代码

3.员工工资管理AdminWages的界面计划

这是我们AdminWages的界面图：

3.1员工工资查询功能

起首界面的UI计划是通过WindowBuilder直接图形化创建的，我们只是给这个“查询”按钮添加一个点击事件
代码实现逻辑：

• String一个keyword，如果有就拼接到sql查询语句中当where的条件，如果没有就查询全部
  
• 创建一个二维列表list，把查询到的数据放在里面展示给我们
  

1. JButton btnNewButton = new JButton("\u67E5\u8BE2");
2.                 btnNewButton.addActionListener(new ActionListener() {
3.                         public void actionPerformed(ActionEvent e) {
4.                                 //查询员工工资信息，如果有关键字就模糊搜索，反之查询全部
5.                                 String keyword = textField.getText();
6.                                 WagesDAO w = new WagesDAO();
7.                                 Vector<Vector<String>> list = w.getAll(keyword);
8.                                
9.                                 Vector<String> head =  new Vector<String>();
10.                                 head.add("员工编号");
11.                                 head.add("基本工资");
12.                                 head.add("岗位工资");
13.                                 head.add("水电费");
14.                                 head.add("津贴费");
15.                                 head.add("扣除工资");
16.                                 head.add("实发金额");
17.                                
18.                                 //3.设置值
19.                                 table = new JTable(list,head);
20.                                 scrollPane.setViewportView(table);
21.                                
22.                         }
23.                 });
24.                 btnNewButton.setBounds(196, 29, 93, 23);
25.                 contentPane.add(btnNewButton);

复制代码

3.2员工工资添加功能

界面如图所示：

代码实现逻辑：

• 我们要把用户输入到文本框的数据得到然后通过sql语句插入到数据库的表中
  
• 因为int和double范例在java里面不能直接逼迫转换，所以我们就新建一个类似的字符串变量，再进行相应的转换
  

1. //AdminInsertWages
2. package com.ui;
4. import java.awt.EventQueue;
6. import javax.swing.JFrame;
7. import javax.swing.JPanel;
8. import javax.swing.border.EmptyBorder;
10. import com.dao.WagesDAO;
11. import com.entity.Wages;
13. import javax.swing.JLabel;
14. import javax.swing.JOptionPane;
15. import javax.swing.JTextField;
16. import javax.swing.JButton;
17. import java.awt.event.ActionListener;
18. import java.awt.event.ActionEvent;
20. public class AdminInsertWages extends JFrame {
22.         private JPanel contentPane;
23.         private JTextField code;
24.         private JTextField baseWages;
25.         private JTextField postWages;
26.         private JTextField money;
27.         private JTextField subsidy;
28.         private JTextField deduction;
29.         private JTextField fact;
31.         /**
32.          * Launch the application.
33.          */
34.         public static void main(String[] args) {
35.                 EventQueue.invokeLater(new Runnable() {
36.                         public void run() {
37.                                 try {
38.                                         AdminInsertWages frame = new AdminInsertWages();
39.                                         frame.setVisible(true);
40.                                 } catch (Exception e) {
41.                                         e.printStackTrace();
42.                                 }
43.                         }
44.                 });
45.         }
47.         /**
48.          * Create the frame.
49.          */
50.         public AdminInsertWages() {
51.                 setTitle("\u6DFB\u52A0\u5458\u5DE5\u5DE5\u8D44\u4FE1\u606F");
52.                 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
53.                 setBounds(100, 100, 305, 418);
54.                 contentPane = new JPanel();
55.                 contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
57.                 setContentPane(contentPane);
58.                 contentPane.setLayout(null);
59.                
60.                 JLabel lblNewLabel = new JLabel("\u5458\u5DE5\u7F16\u53F7\uFF1A");
61.                 lblNewLabel.setBounds(28, 27, 90, 27);
62.                 contentPane.add(lblNewLabel);
63.                
64.                 JLabel 基本工资 = new JLabel("\u57FA\u672C\u5DE5\u8D44\uFF1A");
65.                 基本工资.setBounds(28, 64, 90, 27);
66.                 contentPane.add(基本工资);
67.                
68.                 JLabel 岗位工资 = new JLabel("\u5C97\u4F4D\u5DE5\u8D44\uFF1A");
69.                 岗位工资.setBounds(28, 109, 90, 27);
70.                 contentPane.add(岗位工资);
71.                
72.                 JLabel lblNewLabel_3 = new JLabel("\u6C34\u7535\u8D39\uFF1A");
73.                 lblNewLabel_3.setBounds(28, 154, 90, 27);
74.                 contentPane.add(lblNewLabel_3);
75.                
76.                 JLabel lblNewLabel_4 = new JLabel("\u6D25\u8D34\u5DE5\u8D44\uFF1A");
77.                 lblNewLabel_4.setBounds(28, 197, 90, 27);
78.                 contentPane.add(lblNewLabel_4);
79.                
80.                 JLabel lblNewLabel_5 = new JLabel("\u6263\u9664\u85AA\u916C\uFF1A");
81.                 lblNewLabel_5.setBounds(28, 244, 90, 27);
82.                 contentPane.add(lblNewLabel_5);
83.                
84.                 JLabel lblNewLabel_6 = new JLabel("\u5B9E\u53D1\u5DE5\u8D44\uFF1A");
85.                 lblNewLabel_6.setBounds(28, 288, 90, 27);
86.                 contentPane.add(lblNewLabel_6);
87.                
88.                 code = new JTextField();
89.                 code.setBounds(107, 30, 108, 21);
90.                 contentPane.add(code);
91.                 code.setColumns(10);
92.                
93.                 baseWages = new JTextField();
94.                 baseWages.setColumns(10);
95.                 baseWages.setBounds(107, 67, 108, 21);
96.                 contentPane.add(baseWages);
97.                
98.                 postWages = new JTextField();
99.                 postWages.setColumns(10);
100.                 postWages.setBounds(107, 112, 108, 21);
101.                 contentPane.add(postWages);
102.                
103.                 money = new JTextField();
104.                 money.setColumns(10);
105.                 money.setBounds(107, 157, 108, 21);
106.                 contentPane.add(money);
107.                
108.                 subsidy = new JTextField();
109.                 subsidy.setColumns(10);
110.                 subsidy.setBounds(107, 200, 108, 21);
111.                 contentPane.add(subsidy);
112.                
113.                 deduction = new JTextField();
114.                 deduction.setColumns(10);
115.                 deduction.setBounds(107, 247, 108, 21);
116.                 contentPane.add(deduction);
117.                
118.                 fact = new JTextField();
119.                 fact.setColumns(10);
120.                 fact.setBounds(107, 291, 108, 21);
121.                 contentPane.add(fact);
122.                
123.                 JButton btnNewButton = new JButton("\u6DFB\u52A0");
124.                 btnNewButton.addActionListener(new ActionListener() {
125.                         public void actionPerformed(ActionEvent e) {
126.                                 //添加信息
127.                                 Wages wages = new Wages();
128. //                                WagesDAO w = new WagesDAO();
129.                                 //因为不能int直接转string所以要转换类型
130.                                 String codes = code.getText();
131.                                 int code = Integer.valueOf(codes);
132.                                 wages.setCode(code);
133.                                
134.                                 String baseWagess = baseWages.getText();
135.                                 int baseWages = Integer.valueOf(baseWagess);
136.                                 wages.setBaseWages(baseWages);
137.                                
138.                                 String postWagess = postWages.getText();
139.                                 int postWages = Integer.valueOf(postWagess);
140.                                 wages.setPostWages(postWages);
141.                                
142.                                 String moneys = money.getText();
143.                                 double money = Double.valueOf(moneys);
144.                                 wages.setMoney(money);
145.                                
146.                                 String subsidys = subsidy.getText();
147.                                 int subsidy = Integer.valueOf(subsidys);
148.                                 wages.setSubsidy(subsidy);
149.                                
150.                                 String deductions = deduction.getText();
151.                                 int deduction = Integer.valueOf(deductions);
152.                                 wages.setDeduction(deduction);
153.                                
154.                                 String facts = fact.getText();
155.                                 double fact = Double.valueOf(facts);
156.                                 wages.setFact(fact);
157.                                
158.                                 //执行添加
159.                                 WagesDAO w = new WagesDAO();
160.                                 if(w.add(wages)){
161.                     JOptionPane.showMessageDialog(null, "添加成功！");
162.                     
163.                 }else {
164.                     JOptionPane.showMessageDialog(null, "添加失败！");
165.                 }
166.                         }
167.                 });
168.                 btnNewButton.setBounds(25, 346, 93, 23);
169.                 contentPane.add(btnNewButton);
170.                
171.                 JButton btnNewButton_1 = new JButton("\u9000\u51FA");
172.                 btnNewButton_1.addActionListener(new ActionListener() {
173.                         public void actionPerformed(ActionEvent e) {
174.                                 //退出
175.                                 dispose();
176.                         }
177.                 });
178.                 btnNewButton_1.setBounds(160, 346, 93, 23);
179.                 contentPane.add(btnNewButton_1);
180.         }
181. }
183. //AdminWages
184. JButton btnNewButton_1 = new JButton("\u6DFB\u52A0\u4FE1\u606F");
185.                 btnNewButton_1.addActionListener(new ActionListener() {
186.                         public void actionPerformed(ActionEvent e) {
187.                                 //添加信息
188.                                 AdminInsertWages frame = new AdminInsertWages();
189.                                 frame.setVisible(true);
190.                         }
191.                 });
192.                 btnNewButton_1.setBounds(314, 29, 93, 23);
193.                 contentPane.add(btnNewButton_1);

复制代码

3.3员工工资修改功能

界面如图所示：

代码实现逻辑：

• 起首在展示数据表中选中一行
  
• 将选中的那一行的数据得到然后再设置到修改信息界面相应的文本框中
  
• 直接对着原有的数据进行修改
  

1. //AdminUpdateWages
2. package com.ui;
4. import java.awt.EventQueue;
6. import javax.swing.JFrame;
7. import javax.swing.JPanel;
8. import javax.swing.border.EmptyBorder;
10. import com.dao.WagesDAO;
11. import com.entity.Wages;
13. import javax.swing.JLabel;
14. import javax.swing.JOptionPane;
15. import javax.swing.JTextField;
16. import javax.swing.JButton;
17. import java.awt.event.ActionListener;
18. import java.awt.event.ActionEvent;
20. public class AdminUpdateWages extends JFrame {
22.         private JPanel contentPane;
23.         private JTextField code;
24.         private JTextField baseWages;
25.         private JTextField postWages;
26.         private JTextField money;
27.         private JTextField subsidy;
28.         private JTextField deduction;
29.         private JTextField fact;
31.         /**
32.          * Launch the application.
33.          */
34.         public static void main(String[] args) {
35.                 EventQueue.invokeLater(new Runnable() {
36.                         public void run() {
37.                                 try {
38.                                         AdminUpdateWages frame = new AdminUpdateWages(5);
39.                                         frame.setVisible(true);
40.                                 } catch (Exception e) {
41.                                         e.printStackTrace();
42.                                 }
43.                         }
44.                 });
45.         }
47.         /**
48.          * Create the frame.
49.          */
50.         public AdminUpdateWages(int id) {
51.                 //查询工资信息回来
52.                 WagesDAO w = new WagesDAO();
53.                 Wages wages = w.query(id);
54.                
55.                 setTitle("修改信息");
56.                 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
57.                 setBounds(100, 100, 305, 418);
58.                 contentPane = new JPanel();
59.                 contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
61.                 setContentPane(contentPane);
62.                 contentPane.setLayout(null);
63.                
64.                 JLabel lblNewLabel = new JLabel("\u5458\u5DE5\u7F16\u53F7\uFF1A");
65.                 lblNewLabel.setBounds(28, 27, 90, 27);
66.                 contentPane.add(lblNewLabel);
67.                
68.                 JLabel 基本工资 = new JLabel("\u57FA\u672C\u5DE5\u8D44\uFF1A");
69.                 基本工资.setBounds(28, 64, 90, 27);
70.                 contentPane.add(基本工资);
71.                
72.                 JLabel 岗位工资 = new JLabel("\u5C97\u4F4D\u5DE5\u8D44\uFF1A");
73.                 岗位工资.setBounds(28, 109, 90, 27);
74.                 contentPane.add(岗位工资);
75.                
76.                 JLabel lblNewLabel_3 = new JLabel("\u6C34\u7535\u8D39\uFF1A");
77.                 lblNewLabel_3.setBounds(28, 154, 90, 27);
78.                 contentPane.add(lblNewLabel_3);
79.                
80.                 JLabel lblNewLabel_4 = new JLabel("\u6D25\u8D34\u5DE5\u8D44\uFF1A");
81.                 lblNewLabel_4.setBounds(28, 197, 90, 27);
82.                 contentPane.add(lblNewLabel_4);
83.                
84.                 JLabel lblNewLabel_5 = new JLabel("\u6263\u9664\u85AA\u916C\uFF1A");
85.                 lblNewLabel_5.setBounds(28, 244, 90, 27);
86.                 contentPane.add(lblNewLabel_5);
87.                
88.                 JLabel lblNewLabel_6 = new JLabel("\u5B9E\u53D1\u5DE5\u8D44\uFF1A");
89.                 lblNewLabel_6.setBounds(28, 288, 90, 27);
90.                 contentPane.add(lblNewLabel_6);
91.                
92.                 //员工编号
93.                 //除了String，都要类型转换
94.                 String codes = String.valueOf(wages.getCode());
95.                 code = new JTextField(codes);
96.                 code.setBounds(107, 30, 108, 21);
97.                 contentPane.add(code);
98.                 code.setColumns(10);
99.                
100.                 //基本工资
101.                 String baseWagess = String.valueOf(wages.getBaseWages());
102.                 baseWages = new JTextField(baseWagess);
103.                 baseWages.setColumns(10);
104.                 baseWages.setBounds(107, 67, 108, 21);
105.                 contentPane.add(baseWages);
106.                
107.                 //岗位工资
108.                 String postWagess = String.valueOf(wages.getPostWages());
109.                 postWages = new JTextField(postWagess);
110.                 postWages.setColumns(10);
111.                 postWages.setBounds(107, 112, 108, 21);
112.                 contentPane.add(postWages);
113.                
114.                 //水电费
115.                 String moneys = String.valueOf(wages.getMoney());
116.                 money = new JTextField(moneys);
117.                 money.setColumns(10);
118.                 money.setBounds(107, 157, 108, 21);
119.                 contentPane.add(money);
120.                
121.                 //津贴工资
122.                 String subsidys = String.valueOf(wages.getSubsidy());
123.                 subsidy = new JTextField(subsidys);
124.                 subsidy.setColumns(10);
125.                 subsidy.setBounds(107, 200, 108, 21);
126.                 contentPane.add(subsidy);
127.                
128.                 //扣除薪酬
129.                 String deductions = String.valueOf(wages.getDeduction());
130.                 deduction = new JTextField(deductions);
131.                 deduction.setColumns(10);
132.                 deduction.setBounds(107, 247, 108, 21);
133.                 contentPane.add(deduction);
134.                
135.                 //实发金额
136.                 String facts = String.valueOf(wages.getFact());
137.                 fact = new JTextField(facts);
138.                 fact.setColumns(10);
139.                 fact.setBounds(107, 291, 108, 21);
140.                 contentPane.add(fact);
141.                
142.                 JButton btnNewButton = new JButton("修改信息");
143.                 btnNewButton.addActionListener(new ActionListener() {
144.                         public void actionPerformed(ActionEvent e) {
145.                                 //修改信息
146.                                 Wages wages = new Wages();
147.                                 wages.setCode(id); //修改时需要获得该修改人的ID
149.                                 //因为不能int直接转string所以要转换类型
150.                                 String codes = code.getText();
151.                                 int code = Integer.valueOf(codes);
152.                                 wages.setCode(code);
153.                                
154.                                 String baseWagess = baseWages.getText();
155.                                 int baseWages = Integer.valueOf(baseWagess);
156.                                 wages.setBaseWages(baseWages);
157.                                
158.                                 String postWagess = postWages.getText();
159.                                 int postWages = Integer.valueOf(postWagess);
160.                                 wages.setPostWages(postWages);
161.                                
162.                                 String moneys = money.getText();
163.                                 double money = Double.valueOf(moneys);
164.                                 wages.setMoney(money);
165.                                
166.                                 String subsidys = subsidy.getText();
167.                                 int subsidy = Integer.valueOf(subsidys);
168.                                 wages.setSubsidy(subsidy);
169.                                
170.                                 String deductions = deduction.getText();
171.                                 int deduction = Integer.valueOf(deductions);
172.                                 wages.setDeduction(deduction);
173.                                
174.                                 String facts = fact.getText();
175.                                 double fact = Double.valueOf(facts);
176.                                 wages.setFact(fact);
177.                                
178.                                 //执行修改
179.                                 WagesDAO w = new WagesDAO();
180.                                 if(w.update(wages)){
181.                     JOptionPane.showMessageDialog(null, "修改成功！");
182.                     
183.                 }else {
184.                     JOptionPane.showMessageDialog(null, "修改失败！");
185.                 }
186.                         }
187.                 });
188.                 btnNewButton.setBounds(25, 346, 93, 23);
189.                 contentPane.add(btnNewButton);
190.                
191.                 JButton btnNewButton_1 = new JButton("\u9000\u51FA");
192.                 btnNewButton_1.addActionListener(new ActionListener() {
193.                         public void actionPerformed(ActionEvent e) {
194.                                 //退出
195.                                 dispose();
196.                         }
197.                 });
198.                 btnNewButton_1.setBounds(160, 346, 93, 23);
199.                 contentPane.add(btnNewButton_1);
200.         }
201. }
203. //AdminWages
204. JButton btnNewButton_2 = new JButton("\u4FEE\u6539\u4FE1\u606F");
205.                 btnNewButton_2.addActionListener(new ActionListener() {
206.                         public void actionPerformed(ActionEvent e) {
207.                                 //修改信息
208.                                  int rows = table.getSelectedRow();
209.                         if(rows == -1) { //没有选中行时得到的是-1
210.                             JOptionPane.showMessageDialog(null, "请选择行！");
211.                             return;
212.                         }
213.                         //根据行和列，获取对应的数字
214.                         int val = Integer.valueOf((String)table.getValueAt(rows, 0));
215.                         System.out.println(table.getValueAt(rows, 0));
216.                         AdminUpdateWages frame = new AdminUpdateWages(val);
217.                                         frame.setVisible(true);
218.                         }
219.                 });
220.                 btnNewButton_2.setBounds(423, 29, 93, 23);
221.                 contentPane.add(btnNewButton_2);

复制代码

3.4员工工资删除功能

代码实现逻辑：

• 起首在展示数据表中选中一行，得到该行的行号
  
• 然后删除对应行号的数据
  
• 删除数据后更新展示的二维列表
  

1. JButton btnNewButton_3 = new JButton("\u5220\u9664\u4FE1\u606F");
2.                 btnNewButton_3.addActionListener(new ActionListener() {
3.                         public void actionPerformed(ActionEvent e) {
4.                                 //删除功能
5.                                 int rows = table.getSelectedRow();
6.                                 if (rows == -1) {
7.                                         JOptionPane.showMessageDialog(null, "请选择行");
8.                                         return;
9.                                 }
10.                                 //根据行和列，获取对应的数字
11.                                 String val = (String) table.getValueAt(rows, 0);
12.                                 //去WagesDAO中执行删除
13.                                 WagesDAO w = new WagesDAO();
14.                                 boolean result = w.delete(val);
15.                                 if (result) {
16.                                         JOptionPane.showMessageDialog(null, "删除成功！");
17.                                         updateAll(null);
18.                                 } else {
19.                                         JOptionPane.showMessageDialog(null, "删除失败！");
20.                                 }
21.                         }
23.                 });
24.                 btnNewButton_3.setBounds(533, 29, 93, 23);
25.                 contentPane.add(btnNewButton_3);

复制代码

3.5工资表格更新功能

代码实现逻辑：

• 创建一个二维列表list
  
• 设置表头
  
• 设置值
  

1. //表格更新
2.         public void updateAll(String keyword) {
3.                 //表格
5.                 WagesDAO w = new WagesDAO();
6.                 Vector<Vector<String>> list = w.getAll(null);
7.                
8.                 //2.设置表头
9.                 Vector<String> head =  new Vector<String>();
10.                 head.add("员工编号");
11.                 head.add("基本工资");
12.                 head.add("岗位工资");
13.                 head.add("水电费");
14.                 head.add("津贴费");
15.                 head.add("扣除工资");
16.                 head.add("实发金额");
17.                
18.                 //3.设置值
19.                 table = new JTable(list,head);
20.                 scrollPane.setViewportView(table);
21.                
22.         }

复制代码

4.数据库计划wages

4.1账号表计划account

账号表计划三个值，id、账号和密码，其中id为自增
数据如图所示：

创建sql代码：

1. CREATE TABLE account  (
3.   id int PRIMARY key NOT NULL,
5.   zhanghao varchar(20) not NULL,
7.   password varchar(20) not NULL
8. )

复制代码

4.2工资表计划wages

工资表创建计划七个值，员工编号、根本工资、岗位工资、水电费、补助、扣除薪酬和实发金额
数据如图所示：

创建sql代码：

1. CREATE TABLE wages  (
3.   code int PRIMARY key NOT NULL,
5.   baseWages int not NULL,
7.   postWages int not NULL,
9.   money float(10, 0) not NULL,
11.   subsidy int not NULL,
13.   deduction int not NULL,
14.   
15.   fact int not NULL
16. )

复制代码

5.EPMS项目搭建

5.1项目搭建如图所示

5.2项目搭建每个package的作用和相互之间的联系

• dao层是各个实体类的操作方法如增编削查等
  
• entity是实体类，每一个实体类对应着数据库中的一张表
  
• test是用来测试的一个包，里面有着对各种方法的测试看其是否能够正常运行
  
• ui是写界面的一个包，有着各个界面的UI计划
  
• util里面是我们本身封装的工具类或者导入的工具类，就是我们提前写好的方法
  
• lib是存放我们依赖文件的一个包，好比mysql-connecttor的jar包
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。