银行账户操作的简单模型

最新推荐文章于 2021-04-01 10:17:45 发布

choosezzz

最新推荐文章于 2021-04-01 10:17:45 发布

阅读量777

点赞数 1

分类专栏： mysql学习总结文章标签：反射机制 Annotation注解 Dao 方法封装

本文链接：https://blog.csdn.net/dingse/article/details/78607765

版权

mysql学习总结专栏收录该内容

16 篇文章 0 订阅

订阅专栏

综合使用了Annotation，java反射以及jdbc技术，源码中包含的各种类为

Identity注解

package com.test.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
/**
 * 注释是否为主键，默认为true
 *
 */
public @interface Identity {
	
	boolean value() default true;
}

Table注解

package com.test.annotation;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

//该注解存活的时间，括号中的参数为表示时间为整个RUNTIME过程
@Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
//表示该注解作用的范围
@Target(java.lang.annotation.ElementType.TYPE)
public @interface Table {

	//注解的String类型的参数，默认值为tb_book,默认值可以不写
	//value为默认的属性名称，当只有一个属性且属性名为value时，在使用注解时可以省略value=?
	String value();
}

vo类

User类

package com.test.vo;

import java.sql.Timestamp;

import com.test.annotation.Identity;
import com.test.annotation.Table;

/**
 * 用户表格中包含的属性字段
 * @author dingshuangen
 *
 */
@Table("User")
public class User {
	//userid设置为主键
	@Identity()
	private int userid;//用户id
	private String account;//账户
	private String username;//用户名
	private String userpwd;//密码
	private int userbalance;//余额
	private Timestamp last_ModifiedTime;//最后修改时间
	@Override
	public String toString() {
		return "User [userid=" + userid + ", account=" + account + ", username=" + username + ", userbalance="
				+ userbalance + ", last_ModifiedTime=" + last_ModifiedTime + "]";
	}
	public User(String username, String userpwd) {
		super();
		this.username = username;
		this.userpwd = userpwd;
	}
	public String getAccount() {
		return account;
	}
	public void setAccount(String account) {
		this.account = account;
	}
	public Timestamp getLast_ModifiedTime() {
		return last_ModifiedTime;
	}
	public void setLast_ModifiedTime(Timestamp last_ModifiedTime) {
		this.last_ModifiedTime = last_ModifiedTime;
	}
	public int getUserid() {
		return userid;
	}
	public void setUserid(int userid) {
		this.userid = userid;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getUserpwd() {
		return userpwd;
	}
	public void setUserpwd(String userpwd) {
		this.userpwd = userpwd;
	}
	
	public int getUserbalance() {
		return userbalance;
	}
	public void setUserbalance(int userbalance) {
		this.userbalance = userbalance;
	}
	public User() {
		super();
	}
	
	
}

Operator类

package com.test.vo;

import com.test.annotation.Identity;
import com.test.annotation.Table;
@Table("operator")
public class Operator {
	@Identity()
	private int oid;
	private String oname;
	private String opwd;
	
	public int getOid() {
		return oid;
	}
	public void setOid(int oid) {
		this.oid = oid;
	}
	public String getOname() {
		return oname;
	}
	public void setOname(String oname) {
		this.oname = oname;
	}
	public String getOpwd() {
		return opwd;
	}
	public void setOpwd(String opwd) {
		this.opwd = opwd;
	}
	public Operator(String oname, String opwd) {
		super();
		this.oname = oname;
		this.opwd = opwd;
	}
	public Operator() {
		super();
	}
	
}

Record类

package com.test.vo;

import java.sql.Timestamp;

import com.test.annotation.Identity;
import com.test.annotation.Table;

@Table("record")
public class Record {
	
	@Identity()
	private int record_id;
	private int userid;
	private String username;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	private int money;
	private int new_balance;
	private String type;
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	private Timestamp create_time;
	public int getRecord_id() {
		return record_id;
	}
	public void setRecord_id(int record_id) {
		this.record_id = record_id;
	}
	
	public int getUserid() {
		return userid;
	}
	public void setUserid(int userid) {
		this.userid = userid;
	}
	
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	public int getNew_balance() {
		return new_balance;
	}
	public void setNew_balance(int new_balance) {
		this.new_balance = new_balance;
	}
	public Timestamp getCreate_time() {
		return create_time;
	}
	public void setCreate_time(Timestamp create_time) {
		this.create_time = create_time;
	}
	public Record() {
		super();
	}
	

}

Dao类

BaseDao类

package com.test.dao;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import com.test.annotation.Identity;
import com.test.annotation.Table;

public class BaseDao {

	private static final String URL = "jdbc:mysql://localhost:3306/jdbc";
	private static final String USER = "root";
	private static final String PASSWORD = "";

	/**
	 * 获得数据库连接
	 * 
	 * @return
	 */
	public Connection getConnection() {
		Connection conn = null;
		try {
			conn = DriverManager.getConnection(URL, USER, PASSWORD);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return conn;
	}

	/**
	 * 关闭连接资源
	 * 
	 * @param auto
	 */
	public void close(AutoCloseable auto) {
		try {
			auto.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 获得表名
	 * 
	 * @param c
	 * @return
	 */
	protected String getTableName(Class<?> c) {
		String table_name = c.getSimpleName();
		// 判断c是否具有Table类型的Annotation
		if (c.isAnnotationPresent(Table.class)) {
			// 将表名更改为Annotation的注释值
			table_name = c.getAnnotation(Table.class).value();
		}
		return table_name;
	}

	protected Field getIdentifyField(Class<?> c) {
		// 获得所有的类属性信息；
		Field[] fs = c.getDeclaredFields();
		// 遍历查找主键属性
		for (Field f : fs) {
			if (f.isAnnotationPresent(Identity.class)) {
				return f;
			}
		}
		return null;
	}

	/**
	 * 执行数据库的插入操作
	 * 
	 * @param obj
	 */
	public void insert(Object obj) {

		// 获得对象的类
		Class<?> c = obj.getClass();
		// 获得主键属性
		Field keyField = this.getIdentifyField(c);
		// 获得类的所有属性
		Field[] fs = c.getDeclaredFields();
		// 获得表名
		String table_name = this.getTableName(c);
		// 拼凑插入sql语句
		StringBuffer sql = new StringBuffer();
		StringBuffer sql_val = new StringBuffer();
		sql.append("insert into " + table_name + " (");
		sql_val.append(" values(");
		for (int i = 0; i < fs.length; i++) {
			fs[i].setAccessible(true);
			if (i != fs.length - 1) {
				sql.append(fs[i].getName() + ",");
				sql_val.append("?,");
			} else {
				sql.append(fs[i].getName() + ")");
				sql_val.append("?)");
			}
		}
		// 合并成完整的sql语句
		sql.append(sql_val);
		// 获得连接，创建声明
		Connection conn = getConnection();
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			// 如果有主键则获得返回的主键值
			if (keyField != null) {
				ps = conn.prepareStatement(sql.toString(), Statement.RETURN_GENERATED_KEYS);
			} else {
				ps = conn.prepareStatement(sql.toString());
			}
			// 设置参数
			for (int i = 0; i < fs.length; i++) {
				// 设置属性的可访问性
				fs[i].setAccessible(true);
				// 主键位置不赋值,置为null
				if (fs[i] == keyField) {
					ps.setObject(i + 1, null);
				} else {
					// 给非主键位置赋值
					ps.setObject(i + 1, fs[i].get(obj));
				}
			}
			// 执行插入语句
			ps.execute();
			System.out.println("执行插入操作成功");

			// 获得自动生成的主键值
			if (keyField != null) {
				rs = ps.getGeneratedKeys();
				rs.next(); // 移动光标
				int key = rs.getInt(1); // 获得主键
				keyField.setAccessible(true);
				// 给ov对象的主键属性赋值
				keyField.set(obj, key);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			close(ps);
			close(conn);
		}
	}

	/**
	 * 查询所有记录
	 * 
	 * @param c
	 * @return
	 */
	public <T> List<T> getAll(Class<T> c) {
		List<T> list = new ArrayList<T>();
		Connection conn = getConnection();
		Field[] f = c.getDeclaredFields();
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {

			ps = conn.prepareStatement("select * from " + this.getTableName(c));
			rs = ps.executeQuery();
			while (rs.next()) {
				// 调用无参的构造方法创建一个对象
				T t = c.newInstance();
				for (Field fs : f) {
					// 设置访问权限
					fs.setAccessible(true);
					// 为t的每一个属性赋值
					fs.set(t, rs.getObject(fs.getName()));
				}
				// 将每一个对象数据存储到List中
				list.add(t);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			close(rs);
			close(ps);
			close(conn);
		}
		return list;
	}
	
}

UserDao类

package com.test.dao;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.util.Scanner;

import com.test.vo.Record;
import com.test.vo.User;

public class UserDao extends BaseDao {

	private static Scanner s=new Scanner(System.in);//全局类变量
	
	/**
	 * 登录成功之后才能进行操作
	 */
	public  void user_Login() {
		
		Connection conn=this.getConnection();
		PreparedStatement ps=null;
		ResultSet rs= null;
		try {
			//登录验证的标志
			boolean login=false;
			while(!login) {
				System.out.println("请输入用户名");
				String username=s.nextLine();
				System.out.println("请输入密码");
				String userpwd=s.nextLine();
				System.out.println("select * from "+this.getTableName(User.class)+"  where username= ? and userpwd= ?");
				ps=conn.prepareStatement("select * from "+this.getTableName(User.class)+" where username = ? and userpwd = ?");
				ps.setString(1,username);
				ps.setString(2,userpwd);
				rs=ps.executeQuery();
				if(rs.next()) {
					login=true;
					System.out.println("欢迎您："+username);
					User user=new User();
					//登录成功后将用户的所有信息赋给User
					Field[] f=user.getClass().getDeclaredFields();
					for(Field fs:f) {
						//设置访问权限
						fs.setAccessible(true);
						//为t的每一个属性赋值
						fs.set(user, rs.getObject(fs.getName()));
					}		
					this.fucation(user);
					
				}else {
					System.out.println("您输入的用户名或密码错误，请检查后重新输入");
				}
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			this.close(rs);
			this.close(ps);
			this.close(conn);
		}
	}
	/**
	 * 存钱操作
	 * @param user
	 */
	private void draw(User user) {
		
		System.out.println("请输入您要取出的金额");
		int money=s.nextInt();
		if(money>user.getUserbalance()) {
			System.out.println("您的余额不足！");
		}else {
			//更新余额信息，同时设置当前时间
			user.setUserbalance(user.getUserbalance()-money);
			user.setLast_ModifiedTime(new Timestamp(System.currentTimeMillis()));
			//对数据库表格信息进行修改
			this.updateAll(user);
			this.insertRecord(user, -money, "取款");
			
		}
	}
	
	/**
	 * 取钱操作，对数据库信息更新
	 * @param user
	 */
	private void deposit(User user) {

		System.out.println("请输入您要存入的金额");
		int m=s.nextInt();
		//更新余额信息，同时设置当前时间
		user.setUserbalance(user.getUserbalance()+m);
		user.setLast_ModifiedTime(new Timestamp(System.currentTimeMillis()));
		//对数据库表格信息进行修改
		this.updateAll(user);
		//记录用户操作记录
		this.insertRecord(user, m, "存钱");
	}
	
	/**
	 * 转账
	 * @param user
	 */
	private void transfer(User user) {
		System.out.println("请输入转账金额");
		int m=s.nextInt();
		if(m>user.getUserbalance()) {
			System.out.println("您的余额不足");
		}else {
			System.out.println("请输入转入账户的卡号");
			String account=s.nextLine();
			System.out.println("请输入转入账户的用户名");
			String name=s.nextLine();
			User t=this.get(User.class,name,account);
			if(t!=null) {
				System.out.println(t);
				t.setUserbalance(t.getUserbalance()+m);
				this.insertRecord(t, m, "他人转账");
				user.setUserbalance(user.getUserbalance()-m);
				this.insertRecord(user, -m, "转账");
				this.updateAll(t);
				this.updateAll(user);
			}else {
				System.out.println("您输入的用户名或者卡号错误");
			}
		}
		
		
	}
	/**
	 * 查询用户的信息
	 */
	private void selectInfo(User user) {
		System.out.println(user.toString());
	}
	
	/**
	 * 功能
	 * @param user
	 */
	private void fucation(User user) {
		System.out.println("----功能区----:\n1:取钱\n2:存钱\n3:转账\n4查询个人信息\n5:修改个人信息\n6:退出");
		while(true) {
			System.out.println("请输入功能区对应的数字选择您要进行的操作");
			int n=s.nextInt();
			if(n==1) {
				this.draw(user);
			}
			
			if(n==2) {
				this.deposit(user);
			}
			if(n==3) {
				this.transfer(user);
			}
			if(n==4) {
				this.selectInfo(user);
			}
			if(n==5) {
				this.updateAll(user);
			}
			if(n==6) {
				//退出时关闭所有资源连接
				s.close();
				System.out.println("退出成功");
				break;
			}
		}
	}
	
	/**
	 * 根据用户名和卡号查询用户信息
	 * @param c
	 * @param name
	 * @param account
	 * @return
	 */
	private <T> T get(Class<T> c,String name,String account) {
		T t =null;
		Connection conn = getConnection();
		Field[] f = c.getDeclaredFields();
		String sql="select * from " + this.getTableName(c)+" where username= ? and account = ?";
		System.out.println(sql);
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, name);
			ps.setString(2, account);
			rs = ps.executeQuery();
			while (rs.next()) {
				// 调用无参的构造方法创建一个对象
				t = c.newInstance();
				for (Field fs : f) {
					// 设置访问权限
					fs.setAccessible(true);
					// 为t的每一个属性赋值
					fs.set(t, rs.getObject(fs.getName()));
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			close(rs);
			close(ps);
			close(conn);
		}
		return t;
	}
	public void updateAll(User obj) {

		// 获得主键属性
		Field keyField = this.getIdentifyField(obj.getClass());
		// 获得类的所有属性
		Field[] fs = obj.getClass().getDeclaredFields();
		// 获得表名
		String table_name = this.getTableName(obj.getClass());
		// 拼凑更新sql语句
		StringBuffer sql = new StringBuffer();
		sql.append("update " + table_name + " set ");
		for (int i = 0; i < fs.length; i++) {
			fs[i].setAccessible(true);
			if (i != fs.length - 1) {
				sql.append(fs[i].getName() + " = ? , ");
			} else {
				keyField.setAccessible(true);
				sql.append(fs[i].getName() + " = ? where "+keyField.getName()+" = ?");
			}
		}
		System.out.println(sql.toString());
		Connection conn = this.getConnection();
		PreparedStatement ps = null;
		try {
			ps=conn.prepareStatement(sql.toString());
			//设置新的用户数据
			for(int i=0;i<fs.length;i++) {
				ps.setObject(i+1,fs[i].get(obj));
			}
			ps.setObject(fs.length+1, keyField.get(obj));
			//执行更新语句
			ps.execute();
			System.out.println("修改个人信息成功");
			this.insertRecord(obj, 0, "修改个人信息");
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			this.close(ps);
			this.close(conn);
		}
	}
	
	/**
	 * 用户操作记录
	 * @param user
	 * @param money
	 */
	private void insertRecord(User user,int money,String type) {
		Record rd=new Record();
		rd.setCreate_time(new Timestamp(System.currentTimeMillis()));
		rd.setMoney(money);
		rd.setType(type);
		rd.setNew_balance(user.getUserbalance());
		rd.setUserid(user.getUserid());
		rd.setUsername(user.getUsername());
		this.insert(rd);
		System.out.println("你的操作记录以保存");
	}
}

Operator类

package com.test.dao;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

import com.test.vo.Operator;
import com.test.vo.Record;
import com.test.vo.User;

public class OperatorDao extends BaseDao{

	private static Scanner s=new Scanner(System.in);//全局类变量
	public  void operator_Login() {
		
		Connection conn=this.getConnection();
		PreparedStatement ps=null;
		ResultSet rs= null;
		try {
			//登录验证的标志
			boolean login=false;
			while(!login) {
				System.out.println("请输入员工用户名");
				String oname=s.next();
				System.out.println("请输入密码");
				String opwd=s.next();
				System.out.println("select * from "+this.getTableName(Operator.class)+"  where oname= ? and opwd= ?");
				ps=conn.prepareStatement("select * from "+this.getTableName(Operator.class)+" where oname = ? and opwd = ?");
				ps.setString(1,oname);
				ps.setString(2,opwd);
				rs=ps.executeQuery();
				if(rs.next()) {
					login=true;
					System.out.println("---欢迎你："+oname+" 使用银行账户管理系统--");
					Operator operator=new Operator();
					//登录成功后将员工的所有信息赋给operator
					Field[] f=operator.getClass().getDeclaredFields();
					for(Field fs:f) {
						//设置访问权限
						fs.setAccessible(true);
						//为t的每一个属性赋值
						fs.set(operator, rs.getObject(fs.getName()));
					}		
					this.fucation(operator);
					
				}else {
					System.out.println("您输入的用户名或密码错误，请检查后重新输入");
				}
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			this.close(rs);
			this.close(ps);
			this.close(conn);
		}
	}
	
	/**
	 * 功能
	 * @param user
	 */
	private void fucation(Operator operator) {
		System.out.println("-·-·-·-|功能区|-·-·-·-:\n1:开户\n2:销户\n3:查询用户信息\n4:高级查询\n5:退出");
		while(true) {
			System.out.println("请输入功能区对应的数字选择您要进行的操作");
			int n=s.nextInt();
			if(n==1) {
				this.createNewAccount();
			}
			if(n==2) {
				this.delete();
			}
			if(n==3) {
				List<User> list=this.getAll(User.class);
				int i=0;
				for (User user : list) {
					System.out.println((i++)+":"+user.toString());
				}
			}
			if(n==4) {
				this.getAll(Record.class);
			}
			if(n==5) {
				System.out.println("退出当前系统成功");
				break;
			}else {
				System.out.println("输入的序号错误");
			}
		}
	}
	
	/**
	 * 生成16位随机卡号
	 */
	private String randomAccount() {
		Random ran=new Random();
		int a=ran.nextInt(99999999);
		int b=ran.nextInt(99999999);
		long l=a*10000000L+b; 
		return String.valueOf(l);
	}
	
	/**
	 * 开户
	 */
	private void createNewAccount() {
		User user=new User();
		System.out.println("请输入开户户名");
		user.setUsername(s.next());
		System.out.println("请输入开户密码");
		user.setUserpwd(s.next());
		user.setAccount(randomAccount());
		System.out.println("请输入开户的初始金额");
		user.setUserbalance(s.nextInt());
		user.setLast_ModifiedTime(new Timestamp(System.currentTimeMillis()));
		this.insert(user);
	}
	/**
	 * 销户
	 * @param user
	 */
	public void delete() {

		System.out.println("请输入要注销的用户id");
		int userid=s.nextInt();
		// 获得对象的类
		Class<?> c = User.class;
		// 获得主键属性
		Field keyField = this.getIdentifyField(c);
		// 获得表名
		String table_name = this.getTableName(c);
		String sql="delete from "+table_name+" where "+keyField.getName()+" = ?";
		// 获得连接，创建声明
		Connection conn = getConnection();
		PreparedStatement ps = null;
		try {
			ps = conn.prepareStatement(sql);
			ps.setObject(1, userid);
			// 执行删除语句
			ps.execute();
			System.out.println("执行删除操作成功");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			close(ps);
			close(conn);
		}
	}
}

Test类

package com.test.test;

import java.util.Scanner;

import com.test.dao.OperatorDao;
import com.test.dao.UserDao;

public class Test {

	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.println("·····欢迎使用银行账户管理系统·····\n请选择您的账户类型");
		System.out.println("A:普通用户\nB:银行员工");
		String n=scanner.nextLine();
		if(n.equals("A")) {
			UserDao dao= new UserDao();
			dao.user_Login();
		}
		if(n.equals("B")) {
			OperatorDao dao= new OperatorDao();
			dao.operator_Login();
		}else {
			scanner.close();
			System.out.println("输入有误，退出当前系统");
			System.exit(0);
		}
	}

}