mapengpeng1999@163.com Dao买书程序

最新推荐文章于 2021-01-12 20:24:46 发布
最新推荐文章于 2021-01-12 20:24:46 发布
阅读量768 收藏
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ma1782072/article/details/110137103
版权 
有三张表：
账户表 ： 账户ID，账户名，密码，账户余额
图书信息表 ：图书编号，图书名称，图书单价 ，库存ID
图书库存表： 库存ID，图书编号，图书库存数量
1，编写登录程序，用户输入用户名和密码，和账户表进行匹配，匹配成功进入第2步，失败提示用户登录失败
2，显示所有图书信息，包括图书编号，书名，单价及图书库存，显示当前登录的账户名称和账户余额
3，用户输入所需要购买的图书编号，进行图书购买
(1)查询图书单价
(2)减少账户余额
(3)减少图书库存数量1
如果账户余额小于0或者图书库存小于0则不能够购买
库和表的设计：
CREATE DATABASE buybook;
CREATE TABLE IF NOT EXISTS account (
	acc_id INT PRIMARY KEY AUTO_INCREMENT,
	acc_name VARCHAR(20) NOT NULL,
	acc_pass VARCHAR(20) NOT NULL,
	acc_balance DOUBLE(10,2) DEFAULT 0
);
CREATE TABLE book_info(
	book_no INT PRIMARY KEY AUTO_INCREMENT,
	book_name VARCHAR(20) NOT NULL,
	book_price DOUBLE(10,2)  DEFAULT 0,
	stock_id INT
	);
CREATE TABLE book_stock(
	stock_id INT PRIMARY KEY AUTO_INCREMENT,
	stock_num INT DEFAULT 0,
	book_no INT,
	CONSTRAINT book_stock_fk FOREIGN KEY(book_no) REFERENCES book_info(book_no)
);
ALTER TABLE book_info ADD CONSTRAINT book_info_fk FOREIGN KEY(stock_id) REFERENCES book_stock(stock_id);

package com.wanbangee.util;

import java.sql.Connection;
import java.sql.DriverManager;

public class DBUtil {
	public static final String DRIVERCLASS = "com.mysql.jdbc.Driver";
	public static final String URL = "jdbc:mysql:///buybook";
	public static final String USER = "root";
	public static final String PASSWORD = "3306";
	
	public static Connection getConnection(){
		Connection conn = null;
		try {
			Class.forName(DRIVERCLASS);
			conn = DriverManager.getConnection(URL,USER,PASSWORD);
		}catch(Exception e) {
			e.printStackTrace();
		}
		return conn;
	}
}

package com.wanbangee.books;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

import com.wanbangee.util.DBUtil;

public class BooksDemo {
	public static void main(String[] args) {
		BooksManager bm = new BooksManager();
		Scanner sc = new Scanner(System.in);
		boolean flag = false;//判断是否登入
		int temp = 1;
		do {
			if(!flag) {//没有登入，则必须先登入
				System.out.println("请输入账户名：");
				String inputAccName = sc.next();
				System.out.println("请输入账户密码：");
				String inputAccPass = sc.next();
				flag = bm.login(inputAccName, inputAccPass);
				if(flag) {
					System.out.println("欢迎您：" + inputAccName + ",您的账户余额为：" + bm.getAccBalance());
				}else {
					System.out.println("登入失败：");
				}
			}else {
				bm.showBppksInfo();
				System.out.println("请输入购买图书的编号：");
				Integer bookNo = sc.nextInt();
				boolean f = bm.buyBook(bm.getAccId(), bookNo);
				if(f) {
					System.out.println("买书成功");
					bm.showBppksInfo();
					System.out.println("买书成功，继续购买请输入1，退出请输入0：");
					temp = sc.nextInt();
				}
			}
		}while(temp != 0);
	}
}

class BooksManager{
	private Integer accId;
	private String accName;
	private Double accBalance;
	public Integer getAccId() {
		return accId;
	}
	public void setAccId(Integer accId) {
		this.accId = accId;
	}
	public String getAccName() {
		return accName;
	}
	public void setAccName(String accName) {
		this.accName = accName;
	}
	public Double getAccBalance() {
		return accBalance;
	}
	public void setAccBalance(Double accBalance) {
		this.accBalance = accBalance;
	}
	
	//登入，通过用户名和密码验证用户是否存在
	public boolean login(String accName,String accPass) {
		boolean flag = false;
		Connection conn =null;
		PreparedStatement pstate = null;
		ResultSet res = null;
		
		try {
			conn = DBUtil.getConnection();//获得数据库连接
			String sql = "select acc_id,acc_balance from account where acc_name = ? and acc_pass = ?";
			pstate = conn.prepareStatement(sql);
			pstate.setString(1, accName);
			pstate.setString(2, accPass);
			res = pstate.executeQuery();
			while(res.next()) {
				flag = true;
				this.accId = res.getInt(1);
				this.accName = accName;
				this.accBalance = res.getDouble(2);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				res.close();
				pstate.close();
				conn.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
		return flag;
	}


//显示图书信息
public void showBppksInfo() {
	Connection conn =null;
	PreparedStatement pstate = null;
	ResultSet res = null;
	
	try {
		conn = DBUtil.getConnection();//获得数据库连接
		String sql = "select a.book_no,a.book_name,a.book_price, b.stock_num from book_info a inner join book_stock b on a.book_no = b.book_no and a.stock_id = b.stock_id";
		pstate = conn.prepareStatement(sql);
		res = pstate.executeQuery();
		System.out.println("书号\t书名\t单价\t库存数量");
		while(res.next()) {
			System.out.println(res.getInt(1) + "\t" + res.getString(2) + "\t" +res.getDouble(3) + "\t" +res.getInt(4));
		}
	} catch (Exception e) {
		e.printStackTrace();
	}finally {
		try {
			res.close();
			pstate.close();
			conn.close();
		} catch (Exception e2) {
			e2.printStackTrace();
		}
	}
}

//购买图书,有3个步骤，要加事务
public boolean buyBook(Integer accId,Integer bookNo) {
	boolean flag = false;
	Connection conn =null;
	PreparedStatement pstate1 = null;
	PreparedStatement pstate2 = null;
	PreparedStatement pstate3 = null;
	ResultSet res = null;
	
	try {
		conn = DBUtil.getConnection();//获得数据库连接
		
		conn.setAutoCommit(false);//取消事务自动提交
		//1查询图书单价
		String sql = "select book_price from book_info where book_no = ?";
		pstate1 = conn.prepareStatement(sql);
		pstate1.setInt(1, bookNo);
		res = pstate1.executeQuery();
		double bookPrice = 0;
		while(res.next()) {
			bookPrice = res.getDouble(1);
		}
		//2减少账户余额，在原来余额上减掉图书价格
		sql = "update account set acc_balance = acc_balance - ? where acc_id = ?";
		pstate2 = conn.prepareStatement(sql);
		pstate2.setDouble(1, bookPrice);
		pstate2.setInt(2, accId);
		pstate2.execute();
		//3减少图书库存数量1
		sql = "update book_stock set stock_num = stock_num - 1 where book_no = ?";
		pstate3 = conn.prepareStatement(sql);
		pstate3.setInt(1, bookNo);
		pstate3.execute();
		
		flag = true;
		conn.commit();//没有异常提交事务
	} catch (Exception e) {
		try {
			conn.rollback();//有异常回滚事务
		} catch (SQLException e1) {
			e1.printStackTrace();
		}
		e.printStackTrace();
	}finally {
		try {
			res.close();
			pstate3.close();
			pstate2.close();
			pstate1.close();
			conn.close();
		} catch (Exception e2) {
			e2.printStackTrace();
		}
	}
	return flag;
}
}

Dao总结：先来三个包名，com.wanbangee.dao com.wanbangee.service com.wanbangee.controller
在dao包中先建entities实体类（一个表或视图就是一个实体类，set和get方法，有参和无参构造器），dao , daoimp, daoproxy（丢弃）, daofactory

package com.wanbangee.entities;

public class Account {
	private Integer accId;
	private String accName;
	private String accPass;
	private Double accBalance;
	public Integer getAccId() {
		return accId;
	}
	public void setAccId(Integer accId) {
		this.accId = accId;
	}
	public String getAccName() {
		return accName;
	}
	public void setAccName(String accName) {
		this.accName = accName;
	}
	public String getAccPass() {
		return accPass;
	}
	public void setAccPass(String accPass) {
		this.accPass = accPass;
	}
	public Double getAccBalance() {
		return accBalance;
	}
	public void setAccBalance(Double accBalance) {
		this.accBalance = accBalance;
	}
	public Account() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Account(Integer accId, String accName, String accPass, Double accBalance) {
		super();
		this.accId = accId;
		this.accName = accName;
		this.accPass = accPass;
		this.accBalance = accBalance;
	}
	
}

package com.wanbangee.entities;

public class BookInfo {
	private Integer bookNo;
	private String bookName;
	private Double bookPrice;
	private Integer stockId;
	//引用图书库存，每本书都有个库存对象，每本书引用一个库存对象
	private BookStock bookStock;
	public Integer getBookNo() {
		return bookNo;
	}
	public void setBookNo(Integer bookNo) {
		this.bookNo = bookNo;
	}
	public String getBookName() {
		return bookName;
	}
	public void setBookName(String bookName) {
		this.bookName = bookName;
	}
	public Double getBookPrice() {
		return bookPrice;
	}
	public void setBookPrice(Double bookPrice) {
		this.bookPrice = bookPrice;
	}
	public Integer getStockId() {
		return stockId;
	}
	public void setStockId(Integer stockId) {
		this.stockId = stockId;
	}
	public BookStock getBookStock() {
		return bookStock;
	}
	public void setBookStock(BookStock bookStock) {
		this.bookStock = bookStock;
	}
	public BookInfo() {
		super();
		// TODO Auto-generated constructor stub
	}
	public BookInfo(Integer bookNo, String bookName, Double bookPrice, Integer stockId) {
		super();
		this.bookNo = bookNo;
		this.bookName = bookName;
		this.bookPrice = bookPrice;
		this.stockId = stockId;
	}
	
}

package com.wanbangee.entities;

public class BookStock {
	private Integer stockId;
	private Integer stockNum;
	private Integer bookNo;
	public Integer getStockId() {
		return stockId;
	}
	public void setStockId(Integer stockId) {
		this.stockId = stockId;
	}
	public Integer getStockNum() {
		return stockNum;
	}
	public void setStockNum(Integer stockNum) {
		this.stockNum = stockNum;
	}
	public Integer getBookNo() {
		return bookNo;
	}
	public void setBookNo(Integer bookNo) {
		this.bookNo = bookNo;
	}
	public BookStock(Integer stockId, Integer stockNum, Integer bookNo) {
		super();
		this.stockId = stockId;
		this.stockNum = stockNum;
		this.bookNo = bookNo;
	}
	public BookStock() {
		super();
		// TODO Auto-generated constructor stub
	}
	
}

package com.wanbangee.dao;
import com.wanbangee.entities.Account;
public interface AccountDao {
//账户表有2个操作，即有2个方法，一个是登入方法，一个是买书减少账户余额方法
	//登入，查询操作，根据用户名和密码查询用户信息并返回用户对象
	//实体类的一个对象就是表中的一笔数据（含多个字段信息）
	public Account selectAccountByAccNameAndAccPass(String accName,String accPass);

//减少账户余额，减少的余额就是图书的单价
	public boolean updateAccBalanceByAccId(Double bookPrice,Integer accId);
	//两个参数，一个是减少金额，一个是减少账户ID
}

package com.wanbangee.dao;
import java.util.List;
import com.wanbangee.entities.BookInfo;
public interface BookInfoDao {
	//图书表的操作，查询所有图书信息，图书信息有多个，用集合存储
	//没有库存信息，只是针对图书表的操作
	public List<BookInfo> selectBookInfo();
	//查询图书单价（买书过程）,根据图书编号查询图书单价
	public double selectBookPriceByBookNo(Integer bookNo);
}

package com.wanbangee.dao;
import com.wanbangee.entities.BookStock;
public interface BookStockDao {
	//在图书表查不到图书库存信息
	//根据图书编号查询库存信息
	public BookStock selectBookStockByBookNo(Integer bookNo);
	//减少图书库存数量，根据图书编号
	public boolean updateStockNumByBookNo(Integer bookNo);
}

package com.wanbangee.dao.imp;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import com.wanbangee.dao.AccountDao;
import com.wanbangee.entities.Account;
import com.wanbangee.util.DBUtil;

public class AccountDaoImp implements AccountDao {
	private Connection conn;
	public AccountDaoImp(Connection conn) {
		this.conn = conn;
	}
	@Override
	public Account selectAccountByAccNameAndAccPass(String accName, String accPass) {
		Account account = null;
		PreparedStatement pstate = null;
		ResultSet res = null;
		
		try {
			String sql = "select acc_id,acc_balance from account where acc_name = ? and acc_pass = ?";
			pstate = this.conn.prepareStatement(sql);
			pstate.setString(1, accName);
			pstate.setString(2, accPass);
			res = pstate.executeQuery();
			while(res.next()) {
				//Integer accId, String accName, String accPass, Double accBalance
				account = new Account(res.getInt(1),accName,null,res.getDouble(2));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				res.close();
				pstate.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
		return account;
	}

	@Override
	public boolean updateAccBalanceByAccId(Double bookPrice, Integer accId) {
		boolean flag = false;
		PreparedStatement pstate = null;
		try {
			String sql = "update account set acc_balance = acc_balance - ? where acc_id = ?";
			pstate = conn.prepareStatement(sql);
			pstate.setDouble(1, bookPrice);
			pstate.setInt(2, accId);
			pstate.execute();
			flag = true;
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				pstate.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
		return flag;
	}

}

package com.wanbangee.dao.imp;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import com.wanbangee.dao.BookInfoDao;
import com.wanbangee.entities.BookInfo;

public class BookInfoDaoImp implements BookInfoDao {
	private Connection conn;
	public BookInfoDaoImp(Connection conn) {
		this.conn = conn;
	}
	@Override
	public List<BookInfo> selectBookInfo() {
		List<BookInfo> bookInfos = new ArrayList<>();//查询的信息以集合形式返回
		PreparedStatement pstate = null;
		ResultSet res = null;
		try {
			String sql = "select book_no,book_name,book_price,stock_id from book_info ";
			pstate = this.conn.prepareStatement(sql);
			res = pstate.executeQuery();
			while (res.next()) {
				// Integer bookNo, String bookName, Double bookPrice, Integer stockId
				BookInfo bookInfo = new BookInfo(res.getInt(1), res.getString(2), res.getDouble(3), res.getInt(4));
				bookInfos.add(bookInfo);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				res.close();
				pstate.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
		return bookInfos;
	}
	@Override
	public double selectBookPriceByBookNo(Integer bookNo) {
		PreparedStatement pstate = null;
		ResultSet res = null;
		double bookPrice = 0;
		try {
			String sql = "select book_price from book_info where book_no = ?";
			pstate = conn.prepareStatement(sql);
			pstate.setInt(1, bookNo);
			res = pstate.executeQuery();
			while (res.next()) {
				bookPrice = res.getDouble(1);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				res.close();
				pstate.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
		return bookPrice;
	}

}

package com.wanbangee.dao.imp;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import com.wanbangee.dao.BookStockDao;
import com.wanbangee.entities.BookStock;

public class BookStockDaoImp implements BookStockDao {
	private Connection conn ;
	public BookStockDaoImp(Connection conn) {
		this.conn  = conn;
	}
	@Override
	public BookStock selectBookStockByBookNo(Integer bookNo) {
		PreparedStatement pstate = null;
		ResultSet res = null;
		BookStock bookStock = null;
		try {
			String sql = "select stock_id,stock_num from book_stock where book_no = ?";
			pstate = conn.prepareStatement(sql);
			pstate.setInt(1, bookNo);
			res = pstate.executeQuery();
			while (res.next()) {
				//Integer stockId, Integer bookNo, Integer stockNum
				bookStock = new BookStock(res.getInt(1),bookNo,res.getInt(2));
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				res.close();
				pstate.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
		return bookStock;
	}

	@Override
	public boolean updateStockNumByBookNo(Integer bookNo) {
		PreparedStatement pstate = null;
		boolean flag = false;
		try {
			String sql = "update book_stock set stock_num = stock_num-1 where book_no = ?";
			pstate = conn.prepareStatement(sql);
			pstate.setInt(1, bookNo);
			pstate.execute();
			flag = true;
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				pstate.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
		return flag;
	}

}

package com.wanbangee.dao.proxy;

import java.sql.Connection;
import java.sql.SQLException;

import com.wanbangee.dao.AccountDao;
import com.wanbangee.dao.imp.AccountDaoImp;
import com.wanbangee.entities.Account;
import com.wanbangee.util.DBUtil;

public class AccountDaoProxy implements AccountDao {
//代理类要调用真实主题类，取得和关闭数据库连接
//之前数据库的连接和关闭放在代理实现类，
//加了事务后数据库的连接和关闭放在业务实现类层。	
//代理实现类阻碍了事务的操作，丢弃代理实现类
	@Override
	public Account selectAccountByAccNameAndAccPass(String accName, String accPass) {
		Connection conn = null;
		Account account = null;
		try {
			conn = DBUtil.getConnection();
			AccountDaoImp imp = new AccountDaoImp(conn);
			account = imp.selectAccountByAccNameAndAccPass(accName, accPass);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return account;
	}

	@Override
	public boolean updateAccBalanceByAccId(Double bookPrice, Integer accId) {
		Connection conn = null;
		boolean flag = false;
		try {
			conn = DBUtil.getConnection();
			AccountDaoImp imp = new AccountDaoImp(conn);
			flag = imp.updateAccBalanceByAccId(bookPrice, accId);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return flag;
	}

}

package com.wanbangee.dao.proxy;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

import com.wanbangee.dao.BookInfoDao;
import com.wanbangee.dao.imp.BookInfoDaoImp;
import com.wanbangee.entities.BookInfo;
import com.wanbangee.util.DBUtil;

public class BookInfoDaoProxy implements BookInfoDao {

	@Override
	public List<BookInfo> selectBookInfo() {
		Connection conn = null;
		List<BookInfo> bookInfos = null;
		try {
			conn = DBUtil.getConnection();
			BookInfoDaoImp imp = new BookInfoDaoImp(conn);
			bookInfos = imp.selectBookInfo();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return bookInfos;
	}

	@Override
	public double selectBookPriceByBookNo(Integer bookNo) {
		Connection conn = null;
		double bookPrice = 0;
		try {
			conn = DBUtil.getConnection();
			BookInfoDaoImp imp = new BookInfoDaoImp(conn);
			bookPrice = imp.selectBookPriceByBookNo(bookNo);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return bookPrice;
	}

}

package com.wanbangee.dao.proxy;

import java.sql.Connection;
import java.sql.SQLException;

import com.wanbangee.dao.BookStockDao;
import com.wanbangee.dao.imp.BookStockDaoImp;
import com.wanbangee.entities.BookStock;
import com.wanbangee.util.DBUtil;

public class BookStockDaoProxy implements BookStockDao {

	@Override
	public BookStock selectBookStockByBookNo(Integer bookNo) {
		Connection conn = null;
		BookStock bookStock = null;
		try {
			conn = DBUtil.getConnection();
			BookStockDaoImp imp = new BookStockDaoImp(conn);
			bookStock = imp.selectBookStockByBookNo(bookNo);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return bookStock;
	}

	@Override
	public boolean updateStockNumByBookNo(Integer bookNo) {
		Connection conn = null;
		boolean flag = false;
		try {
			conn = DBUtil.getConnection();
			BookStockDaoImp imp = new BookStockDaoImp(conn);
			flag = imp.updateStockNumByBookNo(bookNo);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return flag;
	}
}

package com.wanbangee.dao.factory;
import java.sql.Connection;
import com.wanbangee.dao.AccountDao;
import com.wanbangee.dao.imp.AccountDaoImp;

public class AccountDaoFactory {
	public static AccountDao getAccountDaoInstance(Connection conn) {
		return new AccountDaoImp(conn);
	}
}

package com.wanbangee.dao.factory;
import java.sql.Connection;
import com.wanbangee.dao.BookInfoDao;
import com.wanbangee.dao.imp.BookInfoDaoImp;

public class BookInfoDaoFactory {
	public static BookInfoDao getBookInfoDaoInstance(Connection conn) {
		return new BookInfoDaoImp(conn);
	}
}

package com.wanbangee.dao.factory;
import java.sql.Connection;
import com.wanbangee.dao.BookStockDao;
import com.wanbangee.dao.imp.BookStockDaoImp;

public class BookStockDaoFactory {
	public static BookStockDao getBookStockDaoInstance(Connection conn) {
		return new BookStockDaoImp(conn);
	}
}

package com.wanbangee.service;
import java.util.List;
import com.wanbangee.entities.Account;
import com.wanbangee.entities.BookInfo;

public interface BuyBookService {
	//业务层命名没有Dao那么规范
    public Account login(String accName,String accPass);
	
	public List<BookInfo> getBookInfo();//获得图书信息
	
	public  boolean buyBook(Integer accId,Integer bookNo);
}

package com.wanbangee.service.imp;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

import com.wanbangee.dao.factory.AccountDaoFactory;
import com.wanbangee.dao.factory.BookInfoDaoFactory;
import com.wanbangee.dao.factory.BookStockDaoFactory;
import com.wanbangee.entities.Account;
import com.wanbangee.entities.BookInfo;
import com.wanbangee.service.BuyBookService;
import com.wanbangee.util.DBUtil;

public class BuyBookServiceImp implements BuyBookService {

	//登录
		@Override
		public Account login(String accName, String accPass) {
			Connection conn = null;
			Account account = null;
			try {
				conn = DBUtil.getConnection();
				account = AccountDaoFactory.getAccountDaoInstance(conn).selectAccountByAccNameAndAccPass(accName, accPass);
			}catch(Exception e){
				e.printStackTrace();
			}finally {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			return account;
		}

		//获得图书信息
		@Override
		public List<BookInfo> getBookInfo() {
			Connection conn = null;
			List<BookInfo> bookInfos = null;
			try {
				conn = DBUtil.getConnection();
				bookInfos = BookInfoDaoFactory.getBookInfoDaoInstance(conn).selectBookInfo();
				/*
				 *  注意点：目前的bookInfos 中没有携带图书库存信息
				 * */
				for (BookInfo bookInfo : bookInfos) {
					// 查询图书的库存信息设置到bookInfos中
					bookInfo.setBookStock(BookStockDaoFactory.getBookStockDaoInstance(conn).selectBookStockByBookNo(bookInfo.getBookNo()));
				}
			}catch(Exception e){
				e.printStackTrace();
			}finally {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			return bookInfos;
		}

		//买书
		@Override
		public boolean buyBook(Integer accId, Integer bookNo) {
			Connection conn = null;
			boolean flag = false;
			try {
				conn = DBUtil.getConnection();
				conn.setAutoCommit(false);
				//1 查询图书单价
				double bookPrice = BookInfoDaoFactory.getBookInfoDaoInstance(conn).selectBookPriceByBookNo(bookNo);
				//2减少账户余额
				flag = AccountDaoFactory.getAccountDaoInstance(conn).updateAccBalanceByAccId(bookPrice, accId);
				if(flag) {
					//3 减少图书库存信息
					flag = BookStockDaoFactory.getBookStockDaoInstance(conn).updateStockNumByBookNo(bookNo);
				}
				if(flag) {
					conn.commit();
				}
				
				if(!flag){
					try {
						conn.rollback();
					} catch (SQLException e1) {
						e1.printStackTrace();
					}
				}
			}catch(Exception e){
				try {
					conn.rollback();
				} catch (SQLException e1) {
					e1.printStackTrace();
				}
				e.printStackTrace();
			}finally {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			return flag;
		}

	}

package com.wanbangee.controller;

import java.util.List;

import com.wanbangee.entities.Account;
import com.wanbangee.entities.BookInfo;
import com.wanbangee.service.BuyBookService;
import com.wanbangee.service.imp.BuyBookServiceImp;

public class BuyBookController {
//控制层：把业务层处理的数据响应给前端
//控制层 ：前端通过请求访问到控制层，控制调用业务层，业务层调用数据访问层
	public Account login(String accName,String accPass) {
		BuyBookService service = new BuyBookServiceImp();
		return service.login(accName, accPass);
	}
	
	public List<BookInfo> getBookInfo(){
		BuyBookService service = new BuyBookServiceImp();
		return service.getBookInfo();
	}
	
	public  boolean buyBook(Integer accId,Integer bookNo) {
		BuyBookService service = new BuyBookServiceImp();
		return service.buyBook(accId, bookNo);
	}
}

package com.wanbangee.controller.test;

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

import com.wanbangee.controller.BuyBookController;
import com.wanbangee.entities.Account;
import com.wanbangee.entities.BookInfo;

public class BuyBookControllerTest {
	public static void main(String[] args) {
		BuyBookController controller = new BuyBookController();
		Scanner sc = new Scanner(System.in);
		Account account = null;
		int temp = 1;
		do {
			if (account == null) { // 没有登录，则必须先登录
				System.out.print("请输入账户名：");
				String inputAccName = sc.next();
				System.out.print("请输入账户密码：");
				String inputAccPass = sc.next();
				account = controller.login(inputAccName, inputAccPass);
				if (null != account) {
					System.out.println("欢迎您：" + inputAccName + "，您的账户余额为：" + account.getAccBalance());
				} else {
					System.out.println("登录失败");
				}
			} else {
				printBookInfo(controller);
				System.out.print("请输入购买图书的编号：");
				Integer bookNo = sc.nextInt();
				boolean f = controller.buyBook(account.getAccId(), bookNo);
				if(f) {
					System.out.println("卖书成功");
					printBookInfo(controller);
					System.out.print("继续购买请输入1，退出请输入0 ： ");
					temp = sc.nextInt();
				}
		}
		
	}
	while(temp != 0);
	}
	
	public static void printBookInfo(BuyBookController controller) {
		List<BookInfo> bookInfos = controller.getBookInfo();
		System.out.println("图书编号\t\t图书名称\t\t图书单价\t\t图书库存");
		for (BookInfo bookInfo : bookInfos) {
			System.out.println(bookInfo.getBookNo() + "\t\t" + bookInfo.getBookName()+"\t\t" + bookInfo.getBookPrice() + "\t\t" + bookInfo.getBookStock().getStockNum());
		}
	}
}

package com.wanbangee.util;
import java.sql.Connection;
import java.sql.DriverManager;

public class DBUtil {
	public static final String DRIVERCLASS = "com.mysql.jdbc.Driver";
	public static final String URL = "jdbc:mysql:///buybook";
	public static final String USER = "root";
	public static final String PASSWORD = "3306";
	
	public static Connection getConnection(){
		Connection conn = null;
		try {
			Class.forName(DRIVERCLASS);
			conn = DriverManager.getConnection(URL,USER,PASSWORD);
		}catch(Exception e) {
			e.printStackTrace();
		}
		return conn;
	}
}
mpp__mvp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mapengpeng1999@163.com MyBatis的SQL映射文件
ma1782072的博客
01-12 1417
SQL映射文件 增删改查 在Dao接口中，定义增删改查方法。 public interface EmpDao { public Emp selectEmpByEmpId(Integer empId);//根据empId查询雇员信息，只有一笔数据。 public List<Emp> selectEmpByEmpNameLike(String empName);//根据empName模糊查询，可能有多笔数据。 public void insertEmp(Emp emp); public void u
mapengpeng1999@163.com Spring框架
ma1782072的博客
12-23 883
简介 Spring：春天—>给软件行业带来春天。去百度百科Spring框架历史知识，去Spring官网。 Spring理念 : 使现有技术更加实用 ， 本身就是一个大杂烩 , 整合现有的框架技术。 官网 : http://spring.io/ 官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/ GitHub : https://github.com/spring-projects 优点：
mapengpeng1999@163.com MyBatis的简介及HelloWorld程序
ma1782072的博客
01-08 398
MyBatis的简介及HelloWorld程序 MyBatis简介 MyBatis原本是Apache下的一个项目，但是在MyBatis2.0 及 1.0版本的时候，人家不叫MyBatis，而是叫做IBatis，所以以后大家不管是MyBatis还是IBatis，实际上是一回事。是因为在IBatis3.0版本即将推出的时候， 这个团队整体的转战到了谷歌旗下，3.0之后就叫做MyBatis了，MyBatis是一个非常优秀的持久化层的半自动框架， 和我们之前学习的JDBC，DBUtil，JdbcTemplate一样
163邮箱快速登陆(登录)
09-22
163邮箱快速登陆(登录) 可储存记录 如有要求，还可制作163 126 tom yahoo等快速登陆软件 本人初学VB，欲求代码程序，请加QQ：364924648，或邮箱：zhangqiang13131@163.com
JavaPrj_1-MySQL.rar_com.sanqing.dao.Dao_java swing mysql_图书 JAVA
09-24
2. **DAO（Data Access Object）模式**：在"com.sanqing.dao"包中，可以看到DAO设计模式的应用。DAO模式是数据库访问层的一种常见设计，它的主要作用是将业务逻辑与数据访问逻辑分离，提高代码的可维护性和可测试性...
DAO_ACCESS.rar_access dao_access使用DAO_com.dao.dao_dao access
09-21
3. **DAO接口与实现**：在Java中，`com.dao.dao`可能是DAO接口所在的包名，`dao_access`可能是具体的ACCESS数据库DAO实现类。这个实现类会包含一系列的方法，如增删改查，用于执行对ACCESS数据库的操作。 4. **使用...
9.DAO数据库操作演示（Visual C++编程 源代码）
06-26
9.DAO数据库操作演示（Visual C++编程 源代码）9.DAO数据库操作演示（Visual C++编程 源代码）9.DAO数据库操作演示（Visual C++编程 源代码）9.DAO数据库操作演示（Visual C++编程 源代码）9.DAO数据库操作演示...
ssh.rar_Action!_service dao_ssh action_ssh com.dao_ssh dao
09-24
SSH（Struts2 + Spring + Hibernate）是一种经典的Java Web开发框架组合，用于构建高效、可扩展的Web应用程序。在这个“ssh.rar”压缩包中，我们看到的“Action!”、“Service DAO SSH Action”以及“SSH Com DAO ...
iBATIS-DAO-2.3.4.726.rar_com.ibatis.dao_iBATIS dao 2_iBatis DAO_
09-20
iBATIS DAO是Java开发中的一个持久层框架，它提供了数据访问对象（DAO）的实现，使得数据库操作更加简单和灵活。在这个2.3.4.726版本的源码中，我们可以深入理解iBATIS DAO的工作原理，并通过添加注释来帮助我们更好...
【腾讯云】记录一次Could not connect to SMTP host: smtp.163.com, port: 25的解决办法
热门推荐
Yngz_Miao的博客
01-19 9万+
问题描述 最近准备将一个项目发布到腾讯云，在本地所有的功能都能够实现的很好，但是一到腾讯云上面就出现了一个问题： 错误报告内容：Could not connect to SMTP host: smtp.163.com, port: 25 翻译起来就是：不能连接到smtp.163.com，因为25号端口的原因。 问题解决 这是因为腾讯云（阿里云）基于安全考虑，会禁用25端口。 .........
mapengpeng1999@163.com DAO，数据访问层(持久化层)
ma1782072的博客
10-17 1364
DAO设计模式 DAO：DataBase Access Object，数据库访问对象，数据库表中的每一笔数据就是实体类的一个对象，实体类中的属性就是数据表中的字段。是数据访问层(持久化层)的标准模式，所有的开发组的程序员都必须遵循这个DAO设计模式。 DAO中会使用到的其他的设计模式有静态工厂模式和代理模式。DAO的组成： 1.实体类（entities）：数据库表中的每一笔数据就是实体类的一个对象，实体类的命名规则：表名的大驼峰命名。如果表名有_区分多个单词的话，实体类命名使用大驼峰命名规则 2.Dao接口
利用smtp.163.com 发送邮件(本地无需服务器)
anjichan4261的博客
02-08 3899
第一步：需要下载PHPMailer文件包phpmailer-1.73.tar.gz 来自开源社区: http://phpmailer.sourceforge.net/ 第二步：确认你的服务器系统已经支持socket 如下图，通过phpinfo();查看是否支持sockets 　　如果没有这一项就请注意： socket 是属于PHP扩展部分，编译时必须给定一个用于....
mapengpeng1999@163.com MyBatis的动态sql
ma1782072的博客
01-12 223
动态sql的介绍 需求：查询员工信息，要求传入的参数为Emp对象， 如果empName不为空，需要根据empName查询，如果empMail不为空，需要根据empMail查询， 如果empGender不为空，要求根据empGender查询，如果deptId不为空，要求根据deptId查询。 类似于以上的需求，四个需求都要满足的情况，必须使用MyBatis的动态sql，动态sql是MyBatis强大的特性之一， 能够极大的简化sql拼装的过程，动态sql使用标签完成动态sql，类似于我们用过的jstl，获取和
mapengpeng1999@163.com java之注解
ma1782072的博客
09-24 139
注解 一、注解介绍 编写注解类型对我们来说，不是重要的，重要的是如何使用注解，我们学习java就有三个Java提供的注解，学习JavaEE又有提供的一些注解，尤其是以后的框架开发，几乎都是以注解的形式取代配置。 二、JDK提供的三个注解 注解1：@Override package com.wanbangee.annotationdemo; public abstract class Employee { private int age; private String name; //.....省略
163Python数据分析师课程课堂项目1
WANG_Qing_qiu的博客
10-27 602
163Python数据分析师课程课堂项目1 按照指定方式清洗数据 将excel数据处理成每个导演对应一个演员，来体现出导演和演员之间的关系。 处理结果： 最后在通过gephi做数据可视化，显示出导演和演员之间的关系。 处理思路1： 读取数据，删除空值。 根据导演和主演的人名间隔是“/”，进行分列。 分别生成导演列表和演员列表。 将两个列表根据电影名字相同进行和并。 建立新的列表，将导演-演员填入...
vol.163 品质生活 · 吃冰自由
bluemouse的专栏
06-27 107
品质生活改版后复播了，每期会利用半小时左右的时间，给大家推荐一个最近遇到的小物件，希望能给大家一些参(fang)考(du)。 本期节目，给大家介绍了最近主播们都纷纷入手的制冰机，几百块的小东西，实现了不少吃冰爱好者的梦想 … 制作团队 主播 / 朱峰、姝琦嘉宾 / 粒粒、彭瘦瘦后期 / 朱峰 听友调查 为更好的提高节目品质，我们已启动新一轮听友调查...
mapengpeng1999@163.com Mybatis全局配置文件mybatis-config.xml
ma1782072的博客
01-08 431
全局配置文件 安装Oracle数据库 1.修改安装文件的兼容性，并退出所有的安全管家之类的软件 2.安装，双击即可安装，安装最好在无网络的情况下安装，勾选上空白框可执行,将其保存于一个空白目录下。 3.记住安装的全局数据库名称(默认的orcl)（service名称）和口令(ma123)，并且可以更改安装位置(D:/MyAPP/Oracle 4.等待安装成功，安装过程中一切的错误提示都忽略，强制继续执行 Oracle服务器安装成功之后，会有五个服务存在：（任务管理器，服务） Oracle服务一般都设置为首
mapengpeng1999@163.com Spring声明式事务管理
ma1782072的博客
12-29 1018
声明式事务管理配置 我们在开发中，一张表就会定义一个DAO操作，DAO中定义了许多对这张表的原子性的增删改查方法， 原子性表示每次操作执行一条sql，对于买书程序而言，步骤如下： - 查询图书价格 - 修改库存 - 修改账户余额 - 查询图书库存是否小于0 - 查询账户余额是否小于0 这些操作对应多张表，比如有账户表，图书表，图书库存表，在操作过程中，这些步骤都属于各个DAO中的方法， 也就意味着，一个买书的操作，会调用多个DAO，那么我门的事务写在哪里呢？写在DAO中显然不合适， 因为我们要操作多个DAO
@ComponentScan.Filter 如何使用
最新发布
09-13
例如，我们可以使用 @ComponentScan.Filter(type = FilterType.REGEX, value = ".*Dao") 来扫描以 "Dao" 结尾的组件。 当 type 属性为 FilterType.CUSTOM 时，我们可以通过 value 属性指定一个自定义的过滤器实现类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值