前言
经过一段时间的学习（java基础、数据库基础），选择来个小项目实战一下。使用MVC开发模型，将代码进行分类管理。
一、项目结构
lib ：项目相关的jar包
c3p0-config.xml：c3p0配置文件
bean：实体类（数据封装）
dao：持久层（每个类对应方法，sql语句的使用）
service：业务层（业务处理）
view：视图展示
util：封装工具包
二、整体架构思路
有用户登录、用户注册、话费充值、使用嗖嗖、资费说明、退出系统、本月账单查询、套餐余量查询、打印消费详单、套餐变更、办理退网等功能
分为6个功能区，使用switch case结构包围，分别是：
-
用户登录
输入正确的手机号码和密码进入二级菜单列表
如果存在：调用用户登录的方法：
此时有5个业务分支，用switch case结构：-
本月账单查询
可查询该卡号的套餐费用,实际消费金额,账户余额 -
套餐余量查询
分别判断用户属于三种套餐的哪一种，然后输出套餐余量 -
打印消费详单
输入正确的卡号和密码后,可打印当前卡号用户的消费详单, 使用输出流把用户信息输出到文件
判断是否存在消费记录，如果不存在，则提示不存在此卡的消费记录；
如果存在，则利用Filewriter字符流写出记录 -
套餐变更
判断用户是哪个套餐，如果是本套餐：提示用户已经是本套餐，不需要换；
如果是其他套餐：
判断用户余额是否大于要换的套餐，如果余额不够，提示用户余额不足以支付新套餐的费用，需要给出信息提示，让其充值。
如果余额够，费余额需减去变更后的套餐费用，后变更套餐。套餐变更后重新统计卡中实际消费数据以及当月消费金额 -
办理退网
判断卡号是否存在，如果不存在，提示用户卡号不存在！
如果存在移除卡号对应的用户对象，并把tb_card表对应的status设为可用
如果不存在：输入：对不起您输入的信息有误
-
-
用户注册
录入信息并开卡,用户输入的信息包括:选择卡号,选择套餐类型,输入用户名和密码,预存话费金额(预存话费金额必须满足以支付所选套餐的一个月的费用) -
使用嗖嗖
输入正确的手机号码和密码之后,随机进入本号码所属套餐可以支持的一个场景,消费套餐余量或者话费余额,并记录消费信息.当话费余额不足时,抛出异常提醒用户充值 -
话费充值
输入正确的用户名和密码之后,可为该卡号充值 -
资费说明
提供各品牌套餐所包含的通话时长,上网流量,短信条数,月费用等 -
退出系统
输出“退出嗖嗖移动业务大厅”
三、代码实现
1.bean
Card
/* 电话号码类 */
public class Card {
private int id; // ID
private String cardNumber; // 手机号码
private int status; // 状态：0：可用 1：禁用
public Card() {
}
public Card(int id, String cardNumber, int status) {
this.id = id;
this.cardNumber = cardNumber;
this.status = status;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCardNumber() {
return cardNumber;
}
public void setCardNumber(String cardNumber) {
this.cardNumber = cardNumber;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
@Override
public String toString() {
return "Card{" +
"id=" + id +
", cardNumber='" + cardNumber + '\'' +
", status=" + status +
'}';
}
}
ConsumInfo
/* 消费信息类 */
public class ConsumInfo {
private int id; // ID
private String card_number; // 手机号码
private String type; // 消费类型
private int consum_data; // 消费数据
private Date consume_date; // 消费日期
public ConsumInfo() {
}
public ConsumInfo(int id, String card_number, String type, int consum_data, Date consume_date) {
this.id = id;
this.card_number = card_number;
this.type = type;
this.consum_data = consum_data;
this.consume_date = consume_date;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCard_number() {
return card_number;
}
public void setCard_number(String card_number) {
this.card_number = card_number;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getConsum_data() {
return consum_data;
}
public void setConsum_data(int consum_data) {
this.consum_data = consum_data;
}
public Date getConsume_date() {
return consume_date;
}
public void setConsume_date(Date consume_date) {
this.consume_date = consume_date;
}
@Override
public String toString() {
return "ConsumInfo{" +
"id=" + id +
", card_number='" + card_number + '\'' +
", type='" + type + '\'' +
", consum_data=" + consum_data +
", consume_date=" + consume_date +
'}';
}
}
MoboleCard
/* 嗖嗖移动卡类 */
public class MoboleCard {
private int id; //ID
private String card_number; // 手机号码
private String username; // 用户名
private String password; // 密码
private int ser_package; // 所属套餐
private double money; // 账户余额
private int status; // 状态：0：正常 1：冻结
public MoboleCard() {
}
public MoboleCard(int id, String card_number, String username, String password, int ser_package, double money, int status) {
this.id = id;
this.card_number = card_number;
this.username = username;
this.password = password;
this.ser_package = ser_package;
this.money = money;
this.status = status;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCard_number() {
return card_number;
}
public void setCard_number(String card_number) {
this.card_number = card_number;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getSer_package() {
return ser_package;
}
public void setSer_package(int ser_package) {
this.ser_package = ser_package;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
@Override
public String toString() {
return "MoboleCard{" +
"id=" + id +
", card_number='" + card_number + '\'' +
", username='" + username + '\'' +
", password='" + password + '\'' +
", ser_package=" + ser_package +
", money=" + money +
", status=" + status +
'}';
}
}
MonthlyConsumptionRecords
/* 月消费记录类 */
public class MonthlyConsumptionRecords {
private int id; // ID
private String card_number; // 手机号码
private double consum_amount;// 当月消费金额
private int real_talk_time; // 当月实际通话时长(单位:分钟)
private int real_SMS_count; // 当月实际发送短信条数
private int real_flow; // 当月实际上网流量
private Date consume_date; // 日期
public MonthlyConsumptionRecords() {
}
public MonthlyConsumptionRecords(int id, String card_number, double consum_amount, int real_talk_time, int real_SMS_count, int real_flow, Date consume_date) {
this.id = id;
this.card_number = card_number;
this.consum_amount = consum_amount;
this.real_talk_time = real_talk_time;
this.real_SMS_count = real_SMS_count;
this.real_flow = real_flow;
this.consume_date = consume_date;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCard_number() {
return card_number;
}
public void setCard_number(String card_number) {
this.card_number = card_number;
}
public double getConsum_amount() {
return consum_amount;
}
public void setConsum_amount(double consum_amount) {
this.consum_amount = consum_amount;
}
public int getReal_talk_time() {
return real_talk_time;
}
public void setReal_talk_time(int real_talk_time) {
this.real_talk_time = real_talk_time;
}
public int getReal_SMS_count() {
return real_SMS_count;
}
public void setReal_SMS_count(int real_SMS_count) {
this.real_SMS_count = real_SMS_count;
}
public int getReal_flow() {
return real_flow;
}
public void setReal_flow(int real_flow) {
this.real_flow = real_flow;
}
public Date getConsume_date() {
return consume_date;
}
public void setConsume_date(Date consume_date) {
this.consume_date = consume_date;
}
@Override
public String toString() {
return "MonthlyConsumptionRecords{" +
"id=" + id +
", card_number='" + card_number + '\'' +
", consum_amount=" + consum_amount +
", real_talk_time=" + real_talk_time +
", real_SMS_count=" + real_SMS_count +
", real_flow=" + real_flow +
", consume_date=" + consume_date +
'}';
}
}
RechargeRecord
/* 充值记录类 */
public class RechargeRecord {
private int id; // ID
private double amount; // 充值金额
private Date recharge_date; // 充值时间
private String card_number; // 手机号
public RechargeRecord() {
}
public RechargeRecord(int id, double amount, Date recharge_date, String card_number) {
this.id = id;
this.amount = amount;
this.recharge_date = recharge_date;
this.card_number = card_number;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public double getAmount() {
return amount;
}
public void setAmount(double amount) {
this.amount = amount;
}
public Date getRecharge_date() {
return recharge_date;
}
public void setRecharge_date(Date recharge_date) {
this.recharge_date = recharge_date;
}
public String getCard_number() {
return card_number;
}
public void setCard_number(String card_number) {
this.card_number = card_number;
}
@Override
public String toString() {
return "RechargeRecord{" +
"id=" + id +
", amount=" + amount +
", recharge_date=" + recharge_date +
", card_number='" + card_number + '\'' +
'}';
}
}
Scene
/* 使用场景类 */
public class Scene {
private int id; // ID
private String type; // 场景类型
private int data; // 场景消费数据
private String description; // 场景描述
public Scene() {
}
public Scene(int id, String type, int data, String description) {
this.id = id;
this.type = type;
this.data = data;
this.description = description;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
@Override
public String toString() {
return "Scene{" +
"id=" + id +
", type='" + type + '\'' +
", data=" + data +
", description='" + description + '\'' +
'}';
}
}
SerPackage
/* 套餐类 */
public class SerPackage {
private int id; // ID
private int talk_time; // 通话时长
private int sms_count; // 短信条数
private double price; // 套餐月资费
private int flow; // 上网流量
private int type; // 套餐类型
private String name; // 套路类型名称
public SerPackage() {
}
public SerPackage(int id, int talk_time, int sms_count, double price, int flow, int type, String name) {
this.id = id;
this.talk_time = talk_time;
this.sms_count = sms_count;
this.price = price;
this.flow = flow;
this.type = type;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getTalk_time() {
return talk_time;
}
public void setTalk_time(int talk_time) {
this.talk_time = talk_time;
}
public int getSms_count() {
return sms_count;
}
public void setSms_count(int sms_count) {
this.sms_count = sms_count;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getFlow() {
return flow;
}
public void setFlow(int flow) {
this.flow = flow;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "SerPackage{" +
"id=" + id +
", talk_time=" + talk_time +
", sms_count=" + sms_count +
", price=" + price +
", flow=" + flow +
", type=" + type +
", name='" + name + '\'' +
'}';
}
}
2.dao
有可能一些方法会涉及事务，所以我们在dao层不处理异常，统一在service对其处理。
impl
CardDaoImpl
public class CardDaoImpl implements CardDao {
private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());
@Override
public List<Card> queryAllCard() throws SQLException {
String sql = "select * from tb_card where status = 0";
return qr.query(sql, new BeanListHandler<Card>(Card.class));
}
@Override
public boolean updateCardStatus(String cardNumber, int status) throws SQLException {
String sql = "update tb_card set status = ? where cardNumber = ?";
Object params[] = {status,cardNumber};
return qr.update(JdbcUtil.getConnection(),sql, params) > 0 ? true : false;
}
}
ConsumInfoDaoImpl
public class ConsumInfoDaoImpl implements ConsumInfoDao {
private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());
@Override
public List<ConsumInfo> queryConsumInfoByCardNumberAndMonth(String cardNumber, int month) throws SQLException {
String sql = "select * from tb_consuminfo where card_number = ? and Month(consume_date) = ?";
Object params[] = {cardNumber,month};
return qr.query(sql, new BeanListHandler<ConsumInfo>(ConsumInfo.class),params);
}
@Override
public boolean addConsumInfo(ConsumInfo consumInfo) throws SQLException {
String sql = "insert into `tb_consuminfo` (`card_number`,`type`,`consum_data`,`consume_date`) values(?,?,?,?)";
Object params[] = {consumInfo.getCard_number(),consumInfo.getType(),consumInfo.getConsum_data(),consumInfo.getConsume_date()};
return qr.update(JdbcUtil.getConnection(), sql, params) > 0 ? true : false;
}
}
MoboleCardDaoImpl
public class MoboleCardDaoImpl implements MoboleCardDao {
private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());
@Override
public MoboleCard queryMoboleCardByCardNumber(String cardNumber) throws SQLException {
String sql = "select * from tb_mobole_card where card_number = ?";
Object params[] = {cardNumber};
return qr.query(sql, new BeanHandler<MoboleCard>(MoboleCard.class), params);
}
@Override
public boolean addMpboleCard(MoboleCard mc) throws SQLException {
String sql = "insert into tb_mobole_card (card_number,username,password,ser_package,money,status)" +
" values(?,?,?,?,?,?)";
Object params[] = {mc.getCard_number(),mc.getUsername(),mc.getPassword(),
mc.getSer_package(),mc.getMoney(),mc.getStatus()};
return qr.update(JdbcUtil.getConnection(),sql, params) > 0 ? true : false;
}
@Override
public boolean deleteMpboleCardByCardNumber(String cardNumber) throws SQLException {
String sql = "delete from tb_mobole_card where card_number = ?";
return qr.update(JdbcUtil.getConnection(),sql,cardNumber) > 0 ? true : false;
}
@Override
public boolean updateMoneyByCardNumber(String cardNumber, double money) throws SQLException {
String sql = "update tb_mobole_card set money = ? where card_number = ?";
Object params[] = {money,cardNumber};
return qr.update(JdbcUtil.getConnection(),sql,params) > 0 ? true : false;
}
@Override
public boolean updateMoboleCard(MoboleCard moboleCard) throws SQLException {
StringBuffer sql = new StringBuffer("update tb_mobole_card set ");
sql.append("card_number = ?, username = ?, password = ?,");
sql.append("ser_package = ?,money = ?, status = ? ");
sql.append("where id = ?");
Object params[] = {moboleCard.getCard_number(),moboleCard.getUsername(),moboleCard.getPassword(),
moboleCard.getSer_package(),moboleCard.getMoney(),moboleCard.getStatus(),
moboleCard.getId()
};
return qr.update(JdbcUtil.getConnection(), sql.toString(), params) > 0 ? true : false;
}
}
MonthlyConsumptionRecordsDaoImpl
public class MonthlyConsumptionRecordsDaoImpl implements MonthlyConsumptionRecordsDao {
private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());
@Override
public List<MonthlyConsumptionRecords> queryAllMonthRecord(String cardNumber) throws SQLException {
String sql = "select * from tb_monthly_consumption_records where card_number = ?";
return qr.query(sql, new BeanListHandler<MonthlyConsumptionRecords>(MonthlyConsumptionRecords.class), cardNumber);
}
@Override
public MonthlyConsumptionRecords queryMonthRecord(String cardNumber, int month) throws SQLException {
String sql = "select * from tb_monthly_consumption_records where card_number = ? and month(consume_date) = ? and year(consume_date) = ?";
String time = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
Object params[] = {cardNumber,month,time};
return qr.query(sql, new BeanHandler<MonthlyConsumptionRecords>(MonthlyConsumptionRecords.class), params);
}
@Override
public boolean addMonthlyConsumptionRecords(MonthlyConsumptionRecords mcr) throws SQLException {
StringBuffer sql = new StringBuffer("insert into tb_monthly_consumption_records ");
sql.append("(card_number,consum_amount,real_talk_time,real_SMS_count,real_flow,consume_date) ");
sql.append("values(?,?,?,?,?,?)");
Object params[] = {mcr.getCard_number(),mcr.getConsum_amount(),mcr.getReal_talk_time(),
mcr.getReal_SMS_count(),mcr.getReal_flow(),mcr.getConsume_date()
};
return qr.update(JdbcUtil.getConnection(), sql.toString(),params) > 0 ? true : false;
}
@Override
public boolean updateMonthlyConsumptionRecords(MonthlyConsumptionRecords mcr) throws SQLException {
StringBuffer sql = new StringBuffer("update tb_monthly_consumption_records set card_number = ?,");
sql.append("consum_amount = ?, real_talk_time = ?, real_SMS_count = ?, real_flow = ?, consume_date = ? ");
sql.append("where id = ?");
Object params[] = {mcr.getCard_number(),mcr.getConsum_amount(),mcr.getReal_talk_time(),
mcr.getReal_SMS_count(),mcr.getReal_flow(),mcr.getConsume_date(),
mcr.getId()
};
return qr.update(JdbcUtil.getConnection(), sql.toString(),params) > 0 ? true : false;
}
@Override
public Map<String, Object> findTotalConsumptionRecords(String card_number) throws SQLException {
StringBuffer sql = new StringBuffer();
sql.append("SELECT card_number,ifnull(SUM(real_talk_time),0) totalTime,");
sql.append(" ifnull(SUM(real_SMS_count),0) totalSMS,ifnull(SUM(real_flow),0) totalFlow,");
sql.append(" ifnull(SUM(consum_amount),0) totalAmount");
sql.append(" FROM `tb_monthly_consumption_records`");
sql.append(" WHERE `card_number` = ? ");
sql.append(" AND MONTH(consume_date) = MONTH(?)");
sql.append(" AND YEAR(consume_date) = YEAR(?)");
String time = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
Object params[] = {card_number,time,time};
return qr.query(sql.toString(),new MapHandler(),params);
}
}
RechargeRecordDaoImpl
public class RechargeRecordDaoImpl implements RechargeRecordDao {
private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());
@Override
public boolean addRechargeRecord(RechargeRecord rechargeRecord) throws SQLException {
String sql = "insert into tb_recharge_record (amount,recharge_date,card_number) values(?,?,?)";
Object params[] = {rechargeRecord.getAmount(),rechargeRecord.getRecharge_date(),rechargeRecord.getCard_number()};
return qr.update(JdbcUtil.getConnection(),sql, params) > 0 ? true : false;
}
}
SceneDaoImpl
public class SceneDaoImpl implements SceneDao {
private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());
@Override
public List<Scene> queryAllScene() throws SQLException {
String sql = "select * from tb_scene";
return qr.query(sql,new BeanListHandler<Scene>(Scene.class) );
}
@Override
public List<Scene> queryTalkType() throws SQLException {
String sql = "select * from tb_scene where type = ?";
return qr.query(sql, new BeanListHandler<Scene>(Scene.class), "通话");
}
@Override
public List<Scene> querySMSType() throws SQLException {
String sql = "select * from tb_scene where type = ?";
return qr.query(sql, new BeanListHandler<Scene>(Scene.class), "短信");
}
@Override
public List<Scene> queryNetPlay() throws SQLException {
String sql = "select * from tb_scene where type = ?";
return qr.query(sql, new BeanListHandler<Scene>(Scene.class), "上网");
}
}
SerPackageDaoImpl
public class SerPackageDaoImpl implements SerPackageDao {
private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());
@Override
public SerPackage querySerPacksgeByType(int type) throws SQLException {
String sql = "select * from tb_serpackage where type = ?";
return qr.query(sql, new BeanHandler<SerPackage>(SerPackage.class), type);
}
@Override
public List<SerPackage> queryAllSerPacksge() throws SQLException {
String sql = "select * from tb_serpackage";
return qr.query(sql, new BeanListHandler<SerPackage>(SerPackage.class) );
}
}
CardDao
public interface CardDao {
public List<Card> queryAllCard() throws SQLException;
/* 修改卡状态 */
public boolean updateCardStatus(String cardNumber,int status) throws SQLException;
}
ConsumInfoDao
public interface ConsumInfoDao {
/* 根据卡号查询具体月份消费详情 */
public List<ConsumInfo> queryConsumInfoByCardNumberAndMonth(String cardNumber, int month) throws SQLException;
/* 添加消费记录 */
public boolean addConsumInfo(ConsumInfo consumInfo) throws SQLException;
}
MoboleCardDao
public interface MoboleCardDao {
/* 根据用卡号查询用户信息 */
public MoboleCard queryMoboleCardByCardNumber(String cardNumber) throws SQLException;
/* 添加嗖嗖移动卡用户对象 */
public boolean addMpboleCard(MoboleCard moboleCard) throws SQLException;
/* 根据卡号删除嗖嗖移动卡用户对象 */
public boolean deleteMpboleCardByCardNumber(String cardNumber) throws SQLException;
/* 根据卡号和金额进行充值 */
public boolean updateMoneyByCardNumber(String cardNumber, double money) throws SQLException;
/* 修改用户信息 */
public boolean updateMoboleCard(MoboleCard moboleCard) throws SQLException ;
}
MonthlyConsumptionRecordsDao
public interface MonthlyConsumptionRecordsDao {
/* 通过手机号查询消费记录 */
public List<MonthlyConsumptionRecords> queryAllMonthRecord(String cardNumber) throws SQLException;
/* 通过手机号查询当月消费记录 */
public MonthlyConsumptionRecords queryMonthRecord(String cardNumber,int month) throws SQLException;
/* 添加月消费记录 */
public boolean addMonthlyConsumptionRecords(MonthlyConsumptionRecords monthlyConsumptionRecords) throws SQLException;
/* 修改月消费记录 */
public boolean updateMonthlyConsumptionRecords(MonthlyConsumptionRecords monthlyConsumptionRecords) throws SQLException;
/* 查询月总消费记录 */
public Map<String, Object> findTotalConsumptionRecords(String card_number) throws SQLException;
}
RechargeRecordDao
public interface RechargeRecordDao {
/* 添加充值记录 */
public boolean addRechargeRecord(RechargeRecord rechargeRecord) throws SQLException;
}
SceneDao
public interface SceneDao {
/* 查询所有场景 */
public List<Scene> queryAllScene() throws SQLException;
/* 查询通话场景 */
public List<Scene> queryTalkType() throws SQLException;
/* 查询短信场景 */
public List<Scene> querySMSType() throws SQLException;
/* 查询上网场景 */
public List<Scene> queryNetPlay() throws SQLException;
}
SerPackageDao
public interface SerPackageDao {
/* 通过类型查询套餐 */
public SerPackage querySerPacksgeByType(int type) throws SQLException;
/* 查询所有套餐 */
public List<SerPackage> queryAllSerPacksge() throws SQLException;
}
3. service
对业务进行处理，通过调用dao层方法业务逻辑。实现有些业务涉及事务，对dao层抛出的异常进行try…catch…处理，涉及事务的进行回滚。确保事务的特性：原子性、一致性、隔离性、持久性。
impl
CardServiceImpl
public class CardServiceImpl implements CardService {
private CardDao dao = new CardDaoImpl();
@Override
public List<Card> queryAllCard() {
List<Card> list = null;
try {
list = dao.queryAllCard();
return list;
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
}
ConsumInfoServiceImpl
public class ConsumInfoServiceImpl implements ConsumInfoService {
private ConsumInfoDao dao = new ConsumInfoDaoImpl();
private SerPackageDao serPackageDao = new SerPackageDaoImpl();
@Override
public List<ConsumInfo> queryConsumInfo(MoboleCard moboleCard, int month) {
List<ConsumInfo> consumInfoList = null;
try {
consumInfoList = dao.queryConsumInfoByCardNumberAndMonth(moboleCard.getCard_number(), month);
// 当前消费数据打印到文件数据里
if (consumInfoList!=null && consumInfoList.size()!=0){
printConsumData(consumInfoList,moboleCard);
}
return consumInfoList;
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
private void printConsumData(List<ConsumInfo> consumInfoList, MoboleCard moboleCard){
// C:\Users\ch\Desktop
// 打印的数据文件路径
Date date = consumInfoList.get(0).getConsume_date();
String time = new SimpleDateFormat("yyyyMMdd").format(date);
File file = new File("C:/Users/ch/Desktop/Soso/consuminfo/"+time);
// 创建消费记录目录
file.mkdirs();
file = new File(file, consumInfoList.get(0).getCard_number()+".txt");
PrintWriter pw = null;
try {
// 1.打印用户信息
pw = new PrintWriter(file);
SerPackage serPackage = serPackageDao.querySerPacksgeByType(moboleCard.getSer_package());
String consuminfo = "卡号："+moboleCard.getCard_number()+"\n用户名："+moboleCard.getUsername()+"\n套餐："
+serPackage.getName()+"\n余额："+moboleCard.getMoney()+"\n";
pw.println(consuminfo);
consuminfo = "序号\t类型\t数据\t日期\n";
pw.append(consuminfo);
// 2.打印消费记录
for(ConsumInfo info : consumInfoList){
pw.append(info.getId()+"\t"+info.getType()+"\t"+info.getConsum_data()+"\t"+info.getConsume_date()+"\n");
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
} finally {
if(pw != null){
pw.close();
}
}
}
}
MoboleCardSericeImpl
public class MoboleCardSericeImpl implements MoboleCardService {
private MoboleCardDao dao = new MoboleCardDaoImpl();
private CardDao cardDao = new CardDaoImpl();
private RechargeRecordDao rechargeRecordDao = new RechargeRecordDaoImpl();
@Override
public String login(String cardNumber, String password) {
MoboleCard mc = null;
try {
mc = dao.queryMoboleCardByCardNumber(cardNumber);
if(mc == null || !(mc.getPassword()+"").equals(password)){
return "【友情提示】 :卡号或者密码错误";
}
if(mc.getStatus() == 1){
return "【友情提示】 :该卡号已被禁用";
}
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
@Override
public String rigster(MoboleCard moboleCard) {
MoboleCard mc = null;
try {
mc = dao.queryMoboleCardByCardNumber(moboleCard.getCard_number());
if(mc != null){
return "账号已注册！";
}
// 插入数据
boolean result = dao.addMpboleCard(moboleCard);
if(result == true){
cardDao.updateCardStatus(moboleCard.getCard_number(), 1);
}else{
System.out.println("注册失败！");
}
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
@Override
public MoboleCard queryMobole(String cardNumber) {
try {
return dao.queryMoboleCardByCardNumber(cardNumber);
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
@Override
public String deleteMobole(String cardNumber) {
try {
// 开启事务
JdbcUtil.beginTransaction();
boolean f1 = dao.deleteMpboleCardByCardNumber(cardNumber);
boolean f2 = cardDao.updateCardStatus(cardNumber, 0);
// 提交事务
JdbcUtil.commitTransaction();
if(f1==false || f2==false){
return "未查询到对应卡信息";
}
} catch (SQLException e) {
try {
// 事务回滚
JdbcUtil.rollBackTransaction();
return "办理退网失败！";
} catch (Throwable throwable) {
throwable.printStackTrace();
}
} catch (Throwable throwable) {
try {
// 事务回滚
JdbcUtil.rollBackTransaction();
return "办理退网失败！";
} catch (Throwable e) {
e.printStackTrace();
}
}
return null;
}
@Override
public String updateMoney(RechargeRecord rechargeRecord, MoboleCard moboleCard, double money) {
try {
JdbcUtil.beginTransaction();
money += moboleCard.getMoney();
// 更新卡余额
dao.updateMoneyByCardNumber(moboleCard.getCard_number(), money);
// 添加充值记录
rechargeRecordDao.addRechargeRecord(rechargeRecord);
JdbcUtil.commitTransaction();
} catch (SQLException e) {
try {
JdbcUtil.rollBackTransaction();
return "【友情提示】：充值失败！";
} catch (SQLException ex) {
ex.printStackTrace();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
} catch (Throwable throwable) {
throwable.printStackTrace();
}
return "【友情提示】：充值成功，卡上余额：" + money + "元";
}
}
MonthlyConsumptionRecordsServiceImpl
public class MonthlyConsumptionRecordsServiceImpl implements MonthlyConsumptionRecordsService {
private MonthlyConsumptionRecordsDao dao = new MonthlyConsumptionRecordsDaoImpl();
@Override
public MonthlyConsumptionRecords queryThisMonthRecord(String cardNumber,int month) {
try {
return dao.queryMonthRecord(cardNumber,month);
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
}
RechargeRecordServiceImpl
public class RechargeRecordServiceImpl implements RechargeRecordService {
private RechargeRecordDao rechargeRecordDao = new RechargeRecordDaoImpl();
private MoboleCardDao moboleCardDao = new MoboleCardDaoImpl();
@Override
public MoboleCard addRechargeRecord(String cardNumber, double money) {
MoboleCard moboleCard = null;
RechargeRecord rechargeRecord = null;
try {
// 1.查询卡号对象
moboleCard = moboleCardDao.queryMoboleCardByCardNumber(cardNumber);
if(moboleCard == null){
return null;
}
// 开启事务
JdbcUtil.beginTransaction();
// 2.添加充值记录
rechargeRecord = new RechargeRecord();
rechargeRecord.setAmount(money);
rechargeRecord.setRecharge_date(new Date());
rechargeRecord.setCard_number(cardNumber);
rechargeRecordDao.addRechargeRecord(rechargeRecord);
// 3.更新余额
moboleCard.setMoney(moboleCard.getMoney()+money);
moboleCardDao.updateMoboleCard(moboleCard);
// 提交事务
JdbcUtil.commitTransaction();
} catch (SQLException e) {
try {
JdbcUtil.rollBackTransaction();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
e.printStackTrace();
} catch (Throwable throwable) {
try {
JdbcUtil.rollBackTransaction();
} catch (Throwable e) {
e.printStackTrace();
}
throwable.printStackTrace();
}
return moboleCard;
}
}
SceneServiceImpl
public class SceneServiceImpl implements SceneService {
private SceneDao sceneDao = new SceneDaoImpl();
private MoboleCardDao moboleCardDao = new MoboleCardDaoImpl();
private SerPackageDao serPackageDao = new SerPackageDaoImpl();
private MonthlyConsumptionRecordsDao monthlyConsumptionRecordsDao = new MonthlyConsumptionRecordsDaoImpl();
private ConsumInfoDao consumInfoDao = new ConsumInfoDaoImpl();
@Override
public String simScene(MoboleCard moboleCard) {
SerPackage serPackage = null;
ConsumInfo consumInfo = null;
//套餐支持的场景
List<Scene> supportScene = new ArrayList<>();
//随机场景的索引
int index = - 1;
//场景
Scene scene = null;
try {
//1.查询该卡号的套餐
serPackage = serPackageDao.querySerPacksgeByType(moboleCard.getSer_package());
//3.判断套餐支持的场景
if(serPackage.getTalk_time() > 0){
supportScene.addAll(sceneDao.queryTalkType());
}
if(serPackage.getSms_count() > 0){
supportScene.addAll(sceneDao.querySMSType());
}
if(serPackage.getFlow() > 0 ){
supportScene.addAll(sceneDao.queryNetPlay());
}
//生成随机数
Random rd = new Random();
index = rd.nextInt(supportScene.size());
// 获取随机场景
scene = supportScene.get(index);
//开启事务
JdbcUtil.beginTransaction();
//1.统计当月该用户通话时间，流量，短信数据信息
Map<String,Object> datas = monthlyConsumptionRecordsDao.findTotalConsumptionRecords(moboleCard.getCard_number());
// 获取当前月份
int month = Calendar.getInstance().get(Calendar.MONTH) + 1;
MonthlyConsumptionRecords records = monthlyConsumptionRecordsDao.queryMonthRecord(moboleCard.getCard_number(), month);
// 未查询到当月消费记录
if(records == null){
records = new MonthlyConsumptionRecords();
records.setCard_number(moboleCard.getCard_number());
records.setConsum_amount(serPackage.getPrice());
records.setReal_talk_time(0);
records.setReal_SMS_count(0);
records.setReal_flow(0);
}
// 更新日期
records.setConsume_date(new Date());
int surplusData = 0 , nowData = 0;
double conMoney = 0;
//判断场景类型
if(scene.getType().equals("通话")){
// Object totalTime = datas.get("totalTime");
int totalTime = Integer.parseInt(datas.get("totalTime").toString());
// 计算月总消费数据（之前消费的 + 随机场景的）
nowData = totalTime + scene.getData();
// 计算超出套餐部分数据
surplusData = serPackage.getTalk_time() - nowData;
records.setReal_talk_time(nowData);
// 超出套餐部分，判断余额是否足够
if( surplusData < 0 ){
//本次消费金额
conMoney = 0.2 * Math.abs(surplusData);
if(moboleCard.getMoney() - conMoney < 0){
return "余额不足";
}
}
}else if(scene.getType().equals("短信")){
// Object totalSMS = datas.get("totalSMS");
int totalSMS = Integer.parseInt(datas.get("totalSMS").toString());
nowData = totalSMS + scene.getData();
surplusData = serPackage.getSms_count() - nowData;
records.setReal_SMS_count(nowData);
if( surplusData < 0 ){
//本次消费金额
conMoney = 0.1 * Math.abs(surplusData);
if(moboleCard.getMoney() - conMoney < 0){
return "余额不足";
}
}
}else{
// Object totalFlow = datas.get("totalFlow");
int totalFlow = Integer.parseInt(datas.get("totalFlow").toString());
nowData = totalFlow + scene.getData();
surplusData = serPackage.getFlow() - nowData;
records.setReal_flow(nowData);
if( surplusData < 0 ){
//本次消费金额
conMoney = 0.1 * Math.abs(surplusData);
if(moboleCard.getMoney() - conMoney < 0){
return "余额不足";
}
}
}
// 超出套餐部分，需要扣除卡余额
if(conMoney != 0 ){
// 更新月消费金额
records.setConsum_amount(records.getConsum_amount() + conMoney);
// 更新卡余额
moboleCard.setMoney(moboleCard.getMoney() - conMoney);
moboleCardDao.updateMoboleCard(moboleCard);
}
if (datas.get("card_number") == null){
// 插入当月消费记录
monthlyConsumptionRecordsDao.addMonthlyConsumptionRecords(records);
}else{
// 更新当月消费记录
monthlyConsumptionRecordsDao.updateMonthlyConsumptionRecords(records);
}
// 添加消费记录
consumInfo = new ConsumInfo();
consumInfo.setCard_number(moboleCard.getCard_number());
consumInfo.setType(scene.getType());
consumInfo.setConsume_date(new Date());
consumInfo.setConsum_data(scene.getData());
consumInfoDao.addConsumInfo(consumInfo);
// 提交事务
JdbcUtil.commitTransaction();
} catch (SQLException throwables) {
try {
JdbcUtil.rollBackTransaction();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
throwables.printStackTrace();
} catch (Throwable throwable) {
try {
JdbcUtil.rollBackTransaction();
} catch (Throwable e) {
e.printStackTrace();
}
throwable.printStackTrace();
}
return scene.getDescription();
}
}
SerPackageServiceImpl
public class SerPackageServiceImpl implements SerPackageService {
private SerPackageDao dao = new SerPackageDaoImpl();
private MoboleCardDao moboleCardDao = new MoboleCardDaoImpl();
private ConsumInfoDao consumInfoDao = new ConsumInfoDaoImpl();
private MonthlyConsumptionRecordsDao monthlyConsumptionRecordsDao = new MonthlyConsumptionRecordsDaoImpl();
@Override
public SerPackage querySerPacksgeByType(int type) {
SerPackage serPackage = null;
try {
serPackage = dao.querySerPacksgeByType(type);
return serPackage;
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
@Override
public List<SerPackage> queryAllSerPacksge() {
List<SerPackage> list = null;
try {
list = dao.queryAllSerPacksge();
return list;
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
@Override
public String SerPackageChange(MoboleCard moboleCard, int money) {
try {
JdbcUtil.beginTransaction();
// 1.修改嗖嗖移动用户信息数据
moboleCard.setMoney(moboleCard.getMoney()-money);
moboleCardDao.updateMoboleCard(moboleCard);
// 2.实际消费数据以及当月消费金额
// 添加消费记录
ConsumInfo consumInfo = new ConsumInfo();
consumInfo.setCard_number(moboleCard.getCard_number());
consumInfo.setType("套餐变更");
consumInfo.setConsum_data(money);
consumInfo.setConsume_date(new Date());
// 插入消息信息
consumInfoDao.addConsumInfo(consumInfo);
// 修改月消费记录
// 获取当前月份
int month = Calendar.getInstance().get(Calendar.MONTH)+1;
MonthlyConsumptionRecords monthlyConsumptionRecords = monthlyConsumptionRecordsDao.queryMonthRecord(moboleCard.getCard_number(),month);
// 判断有无当月消费记录
if(monthlyConsumptionRecords == null){
// 插入
MonthlyConsumptionRecords mc = new MonthlyConsumptionRecords();
mc.setCard_number(moboleCard.getCard_number());
mc.setConsum_amount(money);
mc.setConsume_date(new Date());
monthlyConsumptionRecordsDao.addMonthlyConsumptionRecords(mc);
} else{
// 修改
double value = monthlyConsumptionRecords.getConsum_amount() + money;
monthlyConsumptionRecords.setConsum_amount(value);
monthlyConsumptionRecords.setConsume_date(new Date());
monthlyConsumptionRecordsDao.updateMonthlyConsumptionRecords(monthlyConsumptionRecords);
}
JdbcUtil.commitTransaction();
} catch (Throwable throwable) {
try {
JdbcUtil.rollBackTransaction();
} catch (Throwable e) {
e.printStackTrace();
}
throwable.printStackTrace();
return "变更失败";
}
return null;
}
}
CardService
public interface CardService {
public List<Card> queryAllCard();
}
ConsumInfoService
public interface ConsumInfoService {
/* 查询消费详情 */
public List<ConsumInfo> queryConsumInfo(MoboleCard moboleCard, int month);
}
MoboleCardService
public interface MoboleCardService {
public String login(String cardNumber,String password);
public String rigster(MoboleCard moboleCard);
/* 根据卡号查询移动卡对象 */
public MoboleCard queryMobole(String cardNumber);
/* 根据卡号删除移动卡对象 */
public String deleteMobole(String cardNumber);
/* 更新卡上的金额 */
public String updateMoney(RechargeRecord rechargeRecord, MoboleCard moboleCard, double money);
}
MonthlyConsumptionRecordsService
public interface MonthlyConsumptionRecordsService {
public MonthlyConsumptionRecords queryThisMonthRecord(String cardNumber,int month);
}
RechargeRecordService
public interface RechargeRecordService {
/* 添加充值记录 */
public MoboleCard addRechargeRecord(String cardNumber, double money);
}
SceneService
public interface SceneService {
/* 场景模拟 */
public String simScene(MoboleCard moboleCard);
}
SerPackageService
public interface SerPackageService {
public SerPackage querySerPacksgeByType(int type);
public List<SerPackage> queryAllSerPacksge();
public String SerPackageChange(MoboleCard moboleCard,int money);
}
4.util
JdbcUtil
public class JdbcUtil {
// 创建c3p0连接池对象
private static ComboPooledDataSource poll = new ComboPooledDataSource("mysql");
// 提供线程局部变量，每个线程（通过其get或set方法）都有自己独立初始化的变量副本
// ThreadLocal是根据当前线程对象取值，所以多线程各自的Connection对象不会受到影响
// cons：仅仅保存事务相关的Connection
private static ThreadLocal<Connection> cons = new ThreadLocal<>();
public static DataSource getDataSource(){
return poll;
}
/* 连接数据库 */
public static Connection getConnection(){
Connection con = cons.get();
// 1.非事务Connection
if(con == null){
// 目前没有涉及事务
try {
return poll.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
}
// 2.涉及事务Connection
return cons.get();
}
/* 开启事务 */
public static void beginTransaction() throws Throwable {
Connection con = cons.get();
if(con != null){
// 事务已经开启过
throw new Throwable("事务已经开启过，不能重复开启");
}
con = poll.getConnection();
// 开启事务
con.setAutoCommit(false);
cons.set(con);
}
/* 提交事务 */
public static void commitTransaction() throws Throwable {
Connection con = cons.get();
if(con == null){
throw new Throwable("事务还未开启，不能提交事务");
}
con.commit();
cons.remove();
}
/* 回滚事务 */
public static void rollBackTransaction() throws Throwable {
Connection con = cons.get();
if(con == null){
throw new Throwable("事务还未开启，不能回滚事务");
}
con.rollback();
cons.remove();
}
/* 释放资源 */
public static void release(Connection con) throws SQLException {
if(con == null)
return;
// 当前线程无事务
if(cons.get() == null)
con.close();
// 非事务的Connection
if(con != cons.get())
con.close();
}
}
5.view
SosoView
public class SosoView {
static Scanner input = new Scanner(System.in);
private static MoboleCardService moboleCardSerice = new MoboleCardSericeImpl();
private static CardService cardService = new CardServiceImpl();
private static SerPackageService serPackageService = new SerPackageServiceImpl();
private static MonthlyConsumptionRecordsService monthlyConsumptionRecordsService = new MonthlyConsumptionRecordsServiceImpl();
private static ConsumInfoService consumInfoService = new ConsumInfoServiceImpl();
private static RechargeRecordService rechargeRecordService = new RechargeRecordServiceImpl();
private static SceneService sceneService = new SceneServiceImpl();
public static void main(String[] args) {
mainMenu();
}
/* 主菜单 */
private static void mainMenu() {
boolean flag = true;
while(flag){
System.out.println("*************欢迎使用嗖嗖移动业务大厅***************");
System.out.println("1.用户登录 2.用户注册 3.使用嗖嗖 4.话费充值 5.资费说明 6.退出系统");
System.out.print("请选择：");
char choose = input.next().charAt(0);
switch (choose){
case '1':
// 用户登录
loginMenu();
break;
case '2':
// 用户注册
rigisterMenu();
break;
case '3':
// 使用嗖嗖
useSosoMenu();
break;
case '4':
// 话费充值
rechargeMenu();
break;
case '5':
// 资费说明
packageDescriptionMenu();
break;
case '6':
// 退出系统
flag = false;
System.out.println("退出嗖嗖移动业务大厅");
break;
default:
System.out.println("无此选项，请重新输入！");
break;
}
// System.out.println();
}
}
/* 使用嗖嗖 */
private static void useSosoMenu() {
input.nextLine();
while(true) {
System.out.println("请输入手机卡号：");
String cardNumber = input.nextLine();
MoboleCard moboleCard = moboleCardSerice.queryMobole(cardNumber);
if(moboleCard == null){
System.out.println("【友情提示】：未查询到该卡号！");
continue;
}
String msg = sceneService.simScene(moboleCard);
if (msg.equals("余额不足")) {
System.out.println("【友情提示】;" + msg + "，请充值后使用！");
return;
}
System.out.println(msg);
break;
}
}
/* 话费充值 */
private static void rechargeMenu() {
System.out.println("*******话费充值*******");
input.nextLine();
while(true) {
System.out.println("请输入要充值卡号：");
String cardNumber = input.next();
if(cardNumber.length() != 11){
System.out.println("【友情提示】：卡号输入错误，请重新输入");
continue;
}
System.out.println("请输入充值金额：");
if(!input.hasNextDouble()){
input.nextLine();
System.out.println("【友情提示】：充值金额输入错误，请重新输入");
continue;
}
double money = input.nextDouble();
if(money <= 0){
System.out.println("【友情提示】：充值金额输入错误，请重新输入");
continue;
}
// 移动卡对象
MoboleCard moboleCard = rechargeRecordService.addRechargeRecord(cardNumber, money);
if (moboleCard == null) {
System.out.println("【友情提示】：未查询到卡信息！");
return;
}
System.out.println("【友情提示】：充值成功，卡上余额：" + moboleCard.getMoney() + "元");
break;
}
}
/* 登录菜单 */
private static void loginMenu() {
String cardNumber;
String password;
System.out.println("请输入手机卡号：");
// 吃掉上一个输入的回车符
input.nextLine();
cardNumber = input.nextLine();
/* 结束id的输入必须按回车符，而回车符会留在缓冲区，这样便被下一次的name的输入读取，
导致name读到了此回车符，一个可行的解决方法是在其中间吃掉回车符 */
System.out.println("请输入密码：");
password = input.nextLine();
//System.out.println(cardNumber+" "+password);
String msg = moboleCardSerice.login(cardNumber, password);
if(msg == null){
//System.out.println("登录成功，进入嗖嗖移动用户菜单");
// 登录成功，进入嗖嗖移动用户菜单
userMenu(cardNumber);
}else{
System.out.println(msg);
return;
}
}
/* 嗖嗖移动用户菜单 */
private static void userMenu(String cardNumber) {
MoboleCard moboleCard = moboleCardSerice.queryMobole(cardNumber);
boolean flag = true;
while(flag) {
System.out.println("*********嗖嗖移动用户菜单*********");
System.out.println("1.本月账单查询");
System.out.println("2.套餐余量查询");
System.out.println("3.打印消费详单");
System.out.println("4.套餐变更");
System.out.println("5.办理退网");
System.out.println("请选择(1-5选择功能，其他键返回上一级):");
String s = input.next();
if(s.length()>1){
break;
}
char select = s.charAt(0);
switch (select) {
case '1':
// 本月账单查询
monthBill(moboleCard);
break;
case '2':
// 套餐余量查询
querySerPackageBalance(moboleCard);
break;
case '3':
// 打印消费详单
queryConsumInfo(moboleCard);
break;
case '4':
// 套餐变更
changeSerPackage(moboleCard);
break;
case '5':
// 办理退网
handlingWithdrawal(moboleCard);
break;
default:
flag = false;
break;
}
// System.out.println();
}
}
/* 本月账单查询 */
private static void monthBill(MoboleCard moboleCard) {
SerPackage serPackage = serPackageService.querySerPacksgeByType(moboleCard.getSer_package());
// 获取当前月份
int month = Calendar.getInstance().get(Calendar.MONTH)+1;
MonthlyConsumptionRecords monthlyConsumptionRecords = monthlyConsumptionRecordsService.queryThisMonthRecord(moboleCard.getCard_number(),month);
double total = serPackage.getPrice() + monthlyConsumptionRecords.getConsum_amount();
System.out.println("您的卡号：" + moboleCard.getCard_number()+",当月账单：");
System.out.println("套餐资费：" + serPackage.getPrice() + "元");
System.out.println("合计：" + total + "元");
System.out.println("账户余额：" + moboleCard.getMoney() + "元");
}
/* 套餐余量查询 */
private static void querySerPackageBalance(MoboleCard moboleCard) {
SerPackage serPackage = serPackageService.querySerPacksgeByType(moboleCard.getSer_package());
// 获取当前月份
int month = Calendar.getInstance().get(Calendar.MONTH)+1;
MonthlyConsumptionRecords monthlyConsumptionRecords = monthlyConsumptionRecordsService.queryThisMonthRecord(moboleCard.getCard_number(),month);
if (monthlyConsumptionRecords == null){
monthlyConsumptionRecords = new MonthlyConsumptionRecords();
}
System.out.println("您的卡号：" + moboleCard.getCard_number()+",套餐内剩余：");
System.out.print("通话时长：");
// 判断通话时长是否超出
int t = serPackage.getTalk_time() - monthlyConsumptionRecords.getReal_talk_time();
if(t<0){
System.out.println("现已超出" + (-t) + "分钟");
}else {
System.out.println(t + "分钟");
}
System.out.print("短信条数：");
// 判断短信条数是否超出
t = serPackage.getSms_count() - monthlyConsumptionRecords.getReal_SMS_count();
if(t<0){
System.out.println("现已超出" + (-t) + "条");
}else {
System.out.println(t + "条");
}
System.out.print("上网流量：");
// 判断上网流量是否超出
t = serPackage.getFlow() - monthlyConsumptionRecords.getReal_flow();
if(t<0){
System.out.println("现已超出" + (-t) + "GB");
}else {
System.out.println(t + "GB");
}
}
/* 消费详情查询 */
private static void queryConsumInfo(MoboleCard moboleCard) {
input.nextLine();
while (true) {
System.out.println("请输入本年需要查询的月份(1-12):");
if (!input.hasNextInt()) {
System.out.println("输入不合法");
input.nextLine();
continue;
}
int month = input.nextInt();
if (month < 1 || month > 12) {
System.out.println("输入区间不合法！请重新输入");
continue;
}
List<ConsumInfo> list = consumInfoService.queryConsumInfo(moboleCard, month);
if (list == null || list.size() == 0) {
System.out.println("【友情提示】：对不起，不存在本卡号" + month + "月消费记录");
return;
}
System.out.println("序号\t类型\t数据\t日期");
for (int i = 0; i < list.size(); i++) {
ConsumInfo consumInfo = list.get(i);
System.out.println((i + 1) + "\t\t" + consumInfo.getType() + "\t" + consumInfo.getConsum_data() + "\t\t" + consumInfo.getConsume_date());
}
return;
}
}
/* 套餐变更 */
private static void changeSerPackage(MoboleCard moboleCard) {
input.nextLine();
System.out.println("******套餐变更******");
List<SerPackage> serPackageList = serPackageService.queryAllSerPacksge();
for(SerPackage serPackage : serPackageList){
System.out.print(serPackage.getId()+"."+serPackage.getName()+"\t");
}
System.out.println();
while(true) {
System.out.println("请选择(序号)：");
if(!input.hasNextInt()){
System.out.println("【友情提示】：序号输入错误，请重新输入！");
input.nextLine();
continue;
}
int id = input.nextInt();
SerPackage serPackage = serPackageService.querySerPacksgeByType(id);
if(serPackage == null){
System.out.println("【友情提示】：无此序号套餐，请重新输入！");
continue;
}
// 判断变更套餐id是否是当前套餐
if (id == moboleCard.getSer_package()) {
System.out.println("【友情提示】：您已经是该套餐的用户，无需更换！");
break;
}
// 判断套餐余额是否足够变更套餐
if (moboleCard.getMoney() < serPackage.getPrice()) {
System.out.println("【友情提示】：对不起，您的余额不足以支付新套餐本月资费，请充值后重新办理变更套餐业务！");
break;
}
// 套餐变更
moboleCard.setSer_package(id);
String msg = serPackageService.SerPackageChange(moboleCard, (int) serPackage.getPrice());
if(msg == null){
// 变更成功
System.out.print("【友情提示】：变更套餐成功！" + serPackage.getName() + "：通话时长：" + serPackage.getTalk_time() + "分钟/月，");
System.out.println("短信条数：" + serPackage.getSms_count() + "条/月，上网流量：" + serPackage.getFlow() + "GB/月，月租：" + serPackage.getPrice() + "元/月");
} else{
// 变更失败
System.out.println("【友情提示】："+msg);
}
break;
}
}
/* 办理退网 */
private static void handlingWithdrawal(MoboleCard moboleCard){
String msg = moboleCardSerice.deleteMobole(moboleCard.getCard_number());
if(msg == null){
System.out.println("【友情提示】：卡号："+moboleCard.getCard_number()+"办理退网成功！");
}else{
System.out.println("【友情提示】：卡号："+moboleCard.getCard_number()+msg);
}
}
/* 注册菜单 */
private static void rigisterMenu() {
System.out.println("*****可选择的卡号*****");
List<Card> cardList = cardService.queryAllCard();
for(int i=0; i<cardList.size(); i++){
if(i%3==0){
System.out.println();
}
Card card = cardList.get(i);
System.out.print(card.getId()+"."+card.getCardNumber()+"\t");
}
System.out.println();
System.out.println("请选择您选择的卡号：");
/* 卡号ID */
String cid = input.next();
cardList = cardList.stream().filter(card -> (card.getId()+"").equals(cid)).collect(Collectors.toList());
if(cardList == null || cardList.size()==0){
System.out.println("卡号输入错误，无此卡号！");
return;
}
Card card = cardList.get(0);
List<SerPackage> serPackageList = serPackageService.queryAllSerPacksge();
for(SerPackage serPackage : serPackageList){
System.out.print(serPackage.getId()+"."+serPackage.getName()+"\t");
}
System.out.println();
System.out.println("请选择您的套餐：");
/* 套餐ID */
String tid = input.next();
serPackageList = serPackageList.stream().filter(type -> (type.getId()+"").equals(tid)).collect(Collectors.toList());
if (serPackageList == null || serPackageList.size()==0){
System.out.println("套餐编号输入错误，无此套餐！");
return;
}
SerPackage serPackage = serPackageList.get(0);
input.nextLine();
System.out.println("请输入姓名：");
String username = input.nextLine();
System.out.println("请输入密码：");
String password = input.nextLine();
// 拿套餐价格和预存价格比较判断
boolean flag = true;
double money = 0;
while(flag){
System.out.println("请输入预存话费：");
if(!input.hasNextDouble()){
System.out.println("预存话费输入不合法！");
}
money = input.nextDouble();
if(money < serPackage.getPrice()){
System.out.println("您预存话费不足以支付本月套餐资费，请重新输入！");
continue;
}
flag = false;
money -= serPackage.getPrice();
}
MoboleCard moboleCard = new MoboleCard();
moboleCard.setCard_number(card.getCardNumber());
moboleCard.setUsername(username);
moboleCard.setPassword(password);
moboleCard.setSer_package(serPackage.getId());
moboleCard.setMoney(money);
moboleCard.setStatus(0);
String msg = moboleCardSerice.rigster(moboleCard);
if(msg == null){
System.out.println("注册成功！");
System.out.println("卡号："+moboleCard.getCard_number()+",用户名："+moboleCard.getUsername()+",当前余额："+moboleCard.getMoney()+"元");
}else{
System.out.println(msg);
return;
}
}
/* 资费说明 */
private static void packageDescriptionMenu() {
System.out.println("*******套餐说明*******");
List<SerPackage> list = serPackageService.queryAllSerPacksge();
System.out.println("序号\t套餐名称\t通话时长(分/月)\t短信条数(条/月)\t上网流量(GB/月)");
for(int i=0; i<list.size(); i++){
SerPackage serPackage = list.get(i);
System.out.print(serPackage.getType()+"\t\t"+serPackage.getName()+"\t"+serPackage.getTalk_time()+"\t\t\t\t");
System.out.println(serPackage.getSms_count()+"\t\t\t\t"+serPackage.getFlow());
}
}
}
6.c3p0-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
<default-config>
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/soso?useSSL=false</property>
<property name="user">root</property>
<property name="password">root</property>
<!-- 初始连接数 -->
<property name="initialPoolSize">10</property>
<!-- 最大等待时间 -->
<property name="maxIdleTime">30</property>
<!-- 最大连接数 -->
<property name="maxPoolSize">100</property>
<!-- 最少连接数 -->
<property name="minPoolSize">10</property>
<property name="maxStatements">200</property>
</default-config>
<!-- 名称配置 -->
<named-config name="mysql">
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/soso?useUnicode=true&characterEncoding=UTF8&useSSL=false</property>
<property name="user">root</property>
<property name="password">root</property>
<property name="initialPoolSize">10</property>
<property name="maxIdleTime">30</property>
<property name="maxPoolSize">100</property>
<property name="minPoolSize">10</property>
<property name="maxStatements">200</property>
</named-config>
<named-config name="oracle">
</named-config>
<named-config name="SqlServer">
</named-config>
</c3p0-config>
四、数据库
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for tb_card
-- ----------------------------
DROP TABLE IF EXISTS `tb_card`;
CREATE TABLE `tb_card` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`cardNumber` char(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '手机号码',
`status` int(0) NULL DEFAULT 0 COMMENT '状态: 0:可用 1:禁用',
PRIMARY KEY (`id`) USING BTREE,
UNIQUE INDEX `uk_card`(`cardNumber`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 12 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tb_card
-- ----------------------------
INSERT INTO `tb_card` VALUES (1, '13652363333', 1);
INSERT INTO `tb_card` VALUES (2, '15812346677', 1);
INSERT INTO `tb_card` VALUES (3, '18890985868', 1);
INSERT INTO `tb_card` VALUES (4, '13677478866', 1);
INSERT INTO `tb_card` VALUES (5, '13666557788', 1);
INSERT INTO `tb_card` VALUES (6, '13612476521', 1);
INSERT INTO `tb_card` VALUES (7, '13609087438', 0);
INSERT INTO `tb_card` VALUES (8, '13689011047', 0);
INSERT INTO `tb_card` VALUES (9, '13698674344', 0);
INSERT INTO `tb_card` VALUES (10, '13678239812', 0);
INSERT INTO `tb_card` VALUES (11, '13677411438', 0);
-- ----------------------------
-- Table structure for tb_consuminfo
-- ----------------------------
DROP TABLE IF EXISTS `tb_consuminfo`;
CREATE TABLE `tb_consuminfo` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`card_number` char(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '手机号码',
`type` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '消费类型',
`consum_data` int(0) NULL DEFAULT NULL COMMENT '消费数据',
`consume_date` datetime(0) NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP(0) COMMENT ' 消费日期',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 26 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tb_consuminfo
-- ----------------------------
INSERT INTO `tb_consuminfo` VALUES (6, '15812346677', '通话', 90, '2022-09-13 00:00:00');
INSERT INTO `tb_consuminfo` VALUES (7, '15812346677', '短信', 5, '2022-09-13 00:00:00');
INSERT INTO `tb_consuminfo` VALUES (12, '18890985868', '短信', 5, '2022-09-14 00:00:00');
INSERT INTO `tb_consuminfo` VALUES (13, '13652363333', '短信', 50, '2022-09-14 00:00:00');
INSERT INTO `tb_consuminfo` VALUES (22, '13612476521', '套餐变更', 68, '2023-05-16 21:28:09');
INSERT INTO `tb_consuminfo` VALUES (23, '13666557788', '通话', 30, '2023-05-17 16:32:17');
INSERT INTO `tb_consuminfo` VALUES (24, '13677478866', '短信', 5, '2023-05-17 16:32:59');
INSERT INTO `tb_consuminfo` VALUES (25, '13677478866', '短信', 5, '2023-05-17 16:33:06');
-- ----------------------------
-- Table structure for tb_mobole_card
-- ----------------------------
DROP TABLE IF EXISTS `tb_mobole_card`;
CREATE TABLE `tb_mobole_card` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`card_number` char(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '手机号码',
`username` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '用户名',
`password` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '密码',
`ser_package` int(0) NOT NULL COMMENT '所属套餐',
`money` double(7, 2) NULL DEFAULT NULL COMMENT '账户余额',
`status` int(0) NULL DEFAULT 0 COMMENT '状态:0:正常 1:冻结',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 10 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tb_mobole_card
-- ----------------------------
INSERT INTO `tb_mobole_card` VALUES (1, '13677478866', 'zhangsan', '123', 1, 100.00, 0);
INSERT INTO `tb_mobole_card` VALUES (2, '13666557788', 'lisi', '123456', 3, 10.00, 1);
INSERT INTO `tb_mobole_card` VALUES (7, '15812346677', '李四', '123456', 1, 60.00, 0);
INSERT INTO `tb_mobole_card` VALUES (8, '18890985868', '王五', '123', 2, 31.50, 0);
INSERT INTO `tb_mobole_card` VALUES (9, '13612476521', '张三', '123', 2, 101.00, 0);
-- ----------------------------
-- Table structure for tb_monthly_consumption_records
-- ----------------------------
DROP TABLE IF EXISTS `tb_monthly_consumption_records`;
CREATE TABLE `tb_monthly_consumption_records` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`card_number` char(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '手机号码',
`consum_amount` double(7, 2) NULL DEFAULT 0.00 COMMENT '当月消费金额',
`real_talk_time` int(0) NULL DEFAULT 0 COMMENT '当月实际通话时长(单位:分钟)',
`real_SMS_count` int(0) NULL DEFAULT 0 COMMENT '当月实际发送短信条数',
`real_flow` int(0) NULL DEFAULT 0 COMMENT '当月实际上网流量',
`consume_date` datetime(0) NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP(0) COMMENT '日期',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 26 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tb_monthly_consumption_records
-- ----------------------------
INSERT INTO `tb_monthly_consumption_records` VALUES (1, '13677478866', 0.00, 590, 80, 0, '2022-09-01 00:00:00');
INSERT INTO `tb_monthly_consumption_records` VALUES (12, '15812346677', 0.00, 90, 5, 0, '2022-09-01 00:00:00');
INSERT INTO `tb_monthly_consumption_records` VALUES (13, '13677478866', 10.00, 650, 50, 0, '2022-08-01 00:00:00');
INSERT INTO `tb_monthly_consumption_records` VALUES (17, '18890985868', 0.00, 0, 0, 0, '2022-09-01 00:00:00');
INSERT INTO `tb_monthly_consumption_records` VALUES (18, '13652363333', 5.00, 0, 50, 0, '2022-09-01 00:00:00');
INSERT INTO `tb_monthly_consumption_records` VALUES (23, '13612476521', 68.00, 0, 0, 1, '2023-05-17 16:20:35');
INSERT INTO `tb_monthly_consumption_records` VALUES (24, '13666557788', 78.00, 120, 0, 1, '2023-05-17 16:32:17');
INSERT INTO `tb_monthly_consumption_records` VALUES (25, '13677478866', 58.00, 0, 10, 0, '2023-05-17 16:33:06');
-- ----------------------------
-- Table structure for tb_recharge_record
-- ----------------------------
DROP TABLE IF EXISTS `tb_recharge_record`;
CREATE TABLE `tb_recharge_record` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`amount` double(7, 2) NOT NULL COMMENT '充值金额',
`recharge_date` timestamp(0) NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP(0) COMMENT '充值时间',
`card_number` char(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '手机号',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 14 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tb_recharge_record
-- ----------------------------
INSERT INTO `tb_recharge_record` VALUES (1, 50.00, '2022-08-30 18:19:28', '13666557788');
INSERT INTO `tb_recharge_record` VALUES (5, 100.00, '2022-09-09 17:04:05', '13652363333');
INSERT INTO `tb_recharge_record` VALUES (6, 100.00, '2022-09-09 17:10:05', '15812346677');
INSERT INTO `tb_recharge_record` VALUES (7, 100.00, '2022-09-13 15:51:50', '18890985868');
INSERT INTO `tb_recharge_record` VALUES (8, 10.00, '2023-05-15 19:42:45', '13612476521');
INSERT INTO `tb_recharge_record` VALUES (11, 123.00, '2023-05-15 20:34:42', '13612476521');
INSERT INTO `tb_recharge_record` VALUES (12, 50.00, '2023-05-17 15:28:15', '15812346677');
INSERT INTO `tb_recharge_record` VALUES (13, 10.00, '2023-05-17 15:33:28', '13612476521');
-- ----------------------------
-- Table structure for tb_scene
-- ----------------------------
DROP TABLE IF EXISTS `tb_scene`;
CREATE TABLE `tb_scene` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`type` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '场景类型',
`data` int(0) NULL DEFAULT NULL COMMENT '场景消费数据',
`description` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '场景描述',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tb_scene
-- ----------------------------
INSERT INTO `tb_scene` VALUES (1, '通话', 90, '问候客户,谁知其如此难缠,通话90分钟');
INSERT INTO `tb_scene` VALUES (2, '通话', 30, '询问妈妈身体状况,本地通话30分钟');
INSERT INTO `tb_scene` VALUES (3, '短信', 5, '参与环境保护实施方案问卷调查,发送短信5条');
INSERT INTO `tb_scene` VALUES (4, '短信', 50, '告诉朋友本人已换手机号码,发送短信50条');
INSERT INTO `tb_scene` VALUES (5, '上网', 1, '和女朋友微信视频聊天,使用流量1GB');
INSERT INTO `tb_scene` VALUES (6, '上网', 2, '晚上手机在线追剧,一不留神睡着了,使用流量2GB');
-- ----------------------------
-- Table structure for tb_serpackage
-- ----------------------------
DROP TABLE IF EXISTS `tb_serpackage`;
CREATE TABLE `tb_serpackage` (
`id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
`talk_time` int(0) NULL DEFAULT NULL COMMENT '通话时长',
`sms_count` int(0) NULL DEFAULT NULL COMMENT '短信条数',
`price` double(7, 2) NULL DEFAULT NULL COMMENT '套餐月资费',
`flow` int(0) NULL DEFAULT NULL COMMENT '上网流量',
`type` int(0) NULL DEFAULT NULL COMMENT '套餐类型',
`name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '套餐类型名称',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tb_serpackage
-- ----------------------------
INSERT INTO `tb_serpackage` VALUES (1, 600, 100, 58.00, 0, 1, '话痨套餐');
INSERT INTO `tb_serpackage` VALUES (2, 0, 0, 68.00, 20, 2, '网虫套餐');
INSERT INTO `tb_serpackage` VALUES (3, 300, 50, 78.00, 10, 3, '超人套餐');
SET FOREIGN_KEY_CHECKS = 1;
总结
在经历了一周时间的代码编写，我收获到了很多。这个项目作为我们第一个练习的项目，内容涉及之前所学习的知识点，包括一些数据库的知识，增删查改。还有JDBC操作数据库。还用到了java中的属性，方法，集合，接口，随机数，if语句，switch语句，while循环等，涉及到的知识面相当广泛。也使自己对之前所学的知识有了更好的理解。同时，命名规范对于自己查看代码和别人阅读你的代码带来很大帮助，在后续的学习应该养成好的代码规范。总的来说，这次项目经历让我收获颇丰。
689
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
