文章目录
- 一、创建数据库
- 二、创建JavaSE项目
- 新建实体类
- 新建Dao类
- 新建View类
- 三、模拟页面功能
一、创建数据库
数据库就像盖房子用的地基，所以数据库一定要建好
查看创建数据库及建表语句请点我
DROP TABLE IF EXISTS admin;
CREATE TABLE admin -- 管理员表
(
id int PRIMARY KEY auto_increment, -- 管理员ID
name VARCHAR(20) NOT NULL UNIQUE, -- 管理员姓名
password VARCHAR(20) NOT NULL -- 管理员密码
);
DROP TABLE IF EXISTS shop;
CREATE TABLE shop -- 商家表
(
shopId INT PRIMARY KEY auto_increment, -- 商家ID
shopName VARCHAR(40) NOT NULL, -- 商家名
shopAddress VARCHAR(50), -- 商家地址
shopExplain VARCHAR(40), -- 商品鞋子介绍
salePrice DECIMAL(7,2) DEFAULT 0.00, -- 所售价格
deliveryPrice DECIMAL(7,2) DEFAULT 0.00 -- 快递费
);
DROP TABLE IF EXISTS goods;
CREATE TABLE goods -- 商品鞋子表
(
goodsId INT PRIMARY KEY auto_increment, -- 鞋子ID
goodsName VARCHAR(30) NOT NULL, -- 鞋子名称
goodsExplain VARCHAR(30), -- 鞋子介绍
goodsPrice DECIMAL(7,2) NOT NULL, -- 鞋子价格
shopId INT NOT NULL, -- 所属商家编号
FOREIGN KEY(shopId) REFERENCES shop(shopId) -- 外键
);数据初始化，添加数据，给数据一个初值
-- 管理员数据初始化
INSERT INTO admin (name,PASSWORD)
VALUES('张三','123456'),
('admin','123456');
-- 商家数据初始化
INSERT INTO shop(shopName,shopAddress,shopExplain)
VALUES('鞋子专卖店','津海市邮局对过','二哈鞋店');
-- 商品鞋子数据初始化
INSERT INTO goods(goodsName,goodsExplain,goodsPrice,shopId)
VALUES('篮球鞋','一对一定制',2500.00,1),
('运动鞋','飞一般的感觉',2300.00,1),
('雪地靴','鞋子就是最好的代言人',2000.00,1);二、创建JavaSE项目
打开Java编程工具创建新项目，然后右键创建Model包、Dao包、View包和 util包（用到了JDBC连接，其中代码可以去其专栏查看），所以需要新建lib文件夹存放jar包并将jar包添加至构建路径。
此时应该看到项目的结构：
项目中各类之间的关系说明
新建实体类
这里实体类取名model
有几个表就新建几个实体类，右键Model包新建类，类名与表名一致，需要大写
实体类是简单的 java对象，用于封装数据
实体类类和数据库中的表对应
下面的四个方法要先写私有属性，其他的没有具体的先后顺序，都是系统自动生成，可以点击此链接查看实体类中快速生成各个方法
①、新建管理员类Admin
建类没有顺序，只要全建完即可，我这里是先新建的Admin类
- 先写私有属性，与表中列对应
private Integer id; //写包装类
private String name;
private String password;- 两个构造方法（有参、无参）
public Admin(Integer id, String name, String password) {
super();
this.id = id;
this.name = name;
this.password = password;
}
public Admin() {
super();
}- getter/setter方法
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}- 重写toString
下面代码是系统自动生成的，我们给它改成中文格式方便后续查看数据
@Override
public String toString() {
return "Admin [id=" + id + ", name=" + name + ", password=" + password + "]";
}开始的类名删掉，中括号删掉，冒号代替等号，Tab键【\t】代替逗号，字符串中的英文改对应的意思，最后的中括号也删掉
更改格式后：
@Override
public String toString() {
return "管理员id:" + id + "\t 管理员名字:" + name + "\t 管理员密码:" + password ;
}②、新建商家类Shop
public class Shop {
private Integer shopId;
private String shopName;
private String shopAddress;
private String shopExplain;
private Double salePrice;
private Double deliveryPrice;
public Shop(Integer shopId, String shopName, String shopAddress, String shopExplain, Double salePrice,
Double deliveryPrice) {
super();
this.shopId = shopId;
this.shopName = shopName;
this.shopAddress = shopAddress;
this.shopExplain = shopExplain;
this.salePrice = salePrice;
this.deliveryPrice = deliveryPrice;
}
public Shop() {
super();
// TODO 自动生成的构造函数存根
}
public Integer getShopId() {
return shopId;
}
public void setShopId(Integer shopId) {
this.shopId = shopId;
}
public String getShopName() {
return shopName;
}
public void setShopName(String shopName) {
this.shopName = shopName;
}
public String getShopAddress() {
return shopAddress;
}
public void setShopAddress(String shopAddress) {
this.shopAddress = shopAddress;
}
public String getShopExplain() {
return shopExplain;
}
public void setShopExplain(String shopExplain) {
this.shopExplain = shopExplain;
}
public Double getSalePrice() {
return salePrice;
}
public void setSalePrice(Double salePrice) {
this.salePrice = salePrice;
}
public Double getDeliveryPrice() {
return deliveryPrice;
}
public void setDeliveryPrice(Double deliveryPrice) {
this.deliveryPrice = deliveryPrice;
}
@Override
public String toString() {
return "商家编号:" + shopId + "\t 商家名称:" + shopName + "\t 商家地址:" + shopAddress + "\t 商家介绍:"
+ shopExplain + "\t 所售价格:" + salePrice + "\t 快递费:" + deliveryPrice ;
}
}③、新建商品鞋子类Goods
public class Goods {
private Integer goodsId;
private String goodsName;
private String goodsExplain;
private double goodsPrice;
private Integer shopId;
public Goods(Integer goodsId, String goodsName, String goodsExplain, double goodsPrice, Integer shopId) {
super();
this.goodsId = goodsId;
this.goodsName = goodsName;
this.goodsExplain = goodsExplain;
this.goodsPrice = goodsPrice;
this.shopId = shopId;
}
public Goods() {
super();
// TODO 自动生成的构造函数存根
}
public Integer getGoodsId() {
return goodsId;
}
public void setGoodsId(Integer goodsId) {
this.goodsId = goodsId;
}
public String getGoodsName() {
return goodsName;
}
public void setGoodsName(String goodsName) {
this.goodsName = goodsName;
}
public String getGoodsExplain() {
return goodsExplain;
}
public void setGoodsExplain(String goodsExplain) {
this.goodsExplain = goodsExplain;
}
public double getGoodsPrice() {
return goodsPrice;
}
public void setGoodsPrice(double goodsPrice) {
this.goodsPrice = goodsPrice;
}
public Integer getShopId() {
return shopId;
}
public void setShopId(Integer shopId) {
this.shopId = shopId;
}
@Override
public String toString() {
return "鞋子编号:" + goodsId + "\t 鞋子名称:" + goodsName + "\t 鞋子介绍:" + goodsExplain
+ "\t 鞋子价格:" + goodsPrice + "\t 所属鞋子编号:" + shopId ;
}
}新建Dao类
写完model层后写它的调用者dao
一个表对应一个dao类，一个dao类负责一个表的基本的增删改查操作
右键dao包新建dao类，采用驼峰式命名：表名+Dao
同样这里建类也没有顺序，只要全建完即可，我这里是先新建的AdminDao类
AdminDao类只考虑对admin管理员操作，这个项目中只考虑查询，用查询模拟登录
①、新建管理员dao类AdminDao
- 定义方法三要素
public boolean login (Admin admin) { //对应的model类封装
//登录就是个查询，结果只有成功或失败，查询用户名和密码是否正确
boolean result = false; //定义返回值，初始值false
}- 定义JDBC所需变量
Connection connection = null; //连接语句
PreparedStatement preparedStatement = null; //预编译语句
ResultSet resultSet = null; //查询语句
//1、通过工具类拿到连接
connection = JdbcUtil.createConnection();
try {
//2、创建语句 //3、写SQL查询语句，预编译语句中数据全换成?
preparedStatement = connection.prepareStatement("select * from admin where name = ? and password = ?"); //try...catch处理异常
//4、给?赋值 从1开始，从左到右 varchar类型
preparedStatement.setString(1, admin.getName()); //取出用get
preparedStatement.setString(2, admin.getPassword());
//5、把结果赋值给结果集 执行
resultSet=preparedStatement.executeQuery();
//不关注查到的数据，关注的是查没查到
//6、if语句判断查没查到resultSet.next()
if(resultSet.next()) {
result = true; //查到返回true
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} finally { //7、最终块关闭结果集、预编译语句、连接
JdbcUtil.close(resultSet, preparedStatement, connection);
}- 把结果返回
return result;下面是AdminDao类完整代码：
public class AdminDao {
//dao类一般不需要定义属性
//dao类一般只定义封装增删改查的数据的方法
public boolean login (Admin admin) {
//登录就是个查询，结果只有成功或失败，查询用户名和密码是否正确
boolean result = false;
Connection connection = null; //连接语句
PreparedStatement preparedStatement = null; //预编译语句
ResultSet resultSet = null; //查询语句
//通过工具类拿到连接
connection = JdbcUtil.createConnection();
try {
//创建语句
preparedStatement = connection.prepareStatement("select * from admin where name = ? and password = ?");
//给?赋值 varchar类型
preparedStatement.setString(1, admin.getName());
preparedStatement.setString(2, admin.getPassword());
//把结果赋值给结果集 执行
resultSet=preparedStatement.executeQuery();
//不关注查到的数据，关注的是查没查到
if(resultSet.next()) {
result = true;
}
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
JdbcUtil.close(resultSet, preparedStatement, connection);
}
return result;
}
}最后：AdminDao类单元测试
就是看看刚才的代码是否有误
右键项目名新建【源文件夹】，命名test，然后右键test建包建类TestAdminDao
public class TestAdminDao {
public static void main(String[] args) {
//定义类时如果没定义构造方法，默认提供一个无参空的方法
AdminDao dao = new AdminDao();
//测试login()方法，login()方法调用需要传一个Admin admin类型参数调用【AdminDao类第一行】
Admin admin = new Admin();
//用set方法放数据库中存在的用户名、密码
admin.setName("admin");
admin.setPassword("123456");
//调用login()方法测试，admin是前三行代码中封装好的对象
System.out.println(dao.login(admin));
}
} //返回true即为测试成功②、新建商品鞋子dao类GoodsDao
商品鞋子类要有增删改查
public class GoodsDao {
//增加
public boolean addGoods(Goods goods) {
boolean result = false;
Connection connection = null;
PreparedStatement preparedStatement = null;
connection = JdbcUtil.createConnection();
try {
preparedStatement = connection.prepareStatement("insert into goods(goodsName,goodsExplain,goodsPrice,shopId) value (?,?,?,?)");
preparedStatement.setString(1, goods.getGoodsName());
preparedStatement.setString(2, goods.getGoodsExplain());
preparedStatement.setDouble(3, goods.getGoodsPrice());
preparedStatement.setInt(4, goods.getShopId());
int rows = preparedStatement.executeUpdate();
result = rows>0?true:false; //三元运算符
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
JdbcUtil.close(preparedStatement, connection);
}
return result;
}
//删除 根据商品鞋子ID删除
public boolean deleteGoods(int id) {
boolean result = false;
Connection connection = null;
PreparedStatement preparedStatement = null;
connection = JdbcUtil.createConnection();
try {
preparedStatement = connection.prepareStatement("delete from goods where goodsId=?");
preparedStatement.setInt(1, id);
int rows = preparedStatement.executeUpdate();
if (rows>0) {
//result=true;
return true;
}
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} finally {
JdbcUtil.close(preparedStatement, connection);
}
return result;
}
//修改 根据商家ID修改
public boolean updateGoods(Goods goods) {
boolean result =false;
Connection connection = null;
PreparedStatement preparedStatement = null;
connection = JdbcUtil.createConnection();
try {
//鞋子的商家不能随便换
preparedStatement = connection.prepareStatement("update goods set goodsName=?,goodsExplain=?,goodsPrice=? where goodsId=?");
preparedStatement.setString(1, goods.getGoodsName());
preparedStatement.setString(2, goods.getGoodsExplain());
preparedStatement.setDouble(3, goods.getGoodsPrice());
preparedStatement.setInt(4, goods.getGoodsId());
int rows = preparedStatement.executeUpdate();
if (rows>0){
result = true;
}
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} finally {
JdbcUtil.close(preparedStatement, connection);
}
return result;
}
}增删改结构都差不多，代码步骤基本一致，下面是查询用到了集合，麻烦些
这里要把查询到的数据返回到view，用户
//查找 按照鞋子名字进行模糊查询
//集合类在使用时要使用泛型是model类型
//ArrayList适合查询遍历操作，查到一个显示一个
public ArrayList<Goods> queryGoods(String goodsName){
//创建集合
ArrayList<Goods> list = new ArrayList<>();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
connection = JdbcUtil.createConnection();
try {
preparedStatement = connection.prepareStatement("select * from goods where goodsName like ?");
preparedStatement.setString(1, "%"+goodsName+"%");
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
//查出数据→进行封装
Goods goods = new Goods();
//调用set方法封装——封装的是取出(get)查询到的真的goods数据
goods.setGoodsId(resultSet.getInt("goodsId"));
goods.setGoodsName(resultSet.getString("goodsName"));
goods.setGoodsExplain(resultSet.getString("goodsExplain"));
goods.setGoodsPrice(resultSet.getDouble("goodsPrice"));
goods.setShopId(resultSet.getInt("shopId"));
//再把它放到集合里
list.add(goods);
}
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
JdbcUtil.close(resultSet, preparedStatement, connection);
}
return list; //返回集合
}最后：GoodsDao类单元测试
单元测试在一个类中进行即可，这里取名是TestGoodsDao
添加测试
public static void main(String[] args) {
//创建Dao类对象
GoodsDao dao = new GoodsDao();
//创建model实体类对象
Goods goods = new Goods();
//把测试的数据封装到对象里
goods.setGoodsName("足球鞋");
goods.setGoodsExplain("尽享极致体验");
goods.setGoodsPrice(2800);
goods.setShopId(1); //ID必须是存在的
//调用方法测试并输出
System.out.println(dao.addGoods(goods));
}返回true，刷新数据库显示多了行数据
修改数据
修改数据中不修改商家ID
public static void main(String[] args) {
GoodsDao dao = new GoodsDao();
Goods goods = new Goods();
goods.setGoodsName("职业足球鞋");
goods.setGoodsExplain("一代人的青春，尽心去跑");
goods.setGoodsPrice(5000);
//这里修改的是新添加的4号数据
goods.setGoodsId(4);
System.out.println(dao.updateGoods(goods));
}运行后输出true，刷新数据库显示改了4号数据
查询数据
public static void main(String[] args) {
GoodsDao dao = new GoodsDao();
ArrayList<Goods> list = dao.queryGoods(""); //查询所有
for(Goods goods2:list) { //foreach遍历循环 输出
System.out.println(goods2);
}
}输出结果：
删除数据
public static void main(String[] args) {
GoodsDao dao = new GoodsDao();
//删完后再删除显示false
System.out.println(dao.deleteGoods(4)); //删除4号数据
}输出结果：
②、新建商家dao类ShopDao
public class ShopDao {
public boolean addShop(Shop shop) {
boolean result = false;
Connection connection = null;
PreparedStatement preparedStatement = null;
connection = JdbcUtil.createConnection();
try {
preparedStatement = connection.prepareStatement("insert into shop(shopName,shopAddress,shopExplain,salePrice,deliveryPrice) "
+ "values(?,?,?,?,?)");
preparedStatement.setString(1, shop.getShopName());
preparedStatement.setString(2, shop.getShopAddress());
preparedStatement.setString(3, shop.getShopExplain());
preparedStatement.setDouble(4, shop.getSalePrice());
preparedStatement.setDouble(5, shop.getDeliveryPrice());
int rows = preparedStatement.executeUpdate();
if (rows > 0 ) {
result=true;
}
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
JdbcUtil.close(preparedStatement, connection);
}
return result;
}
public boolean deleteShop(int id) {
boolean result = false;
Connection connection=null;
PreparedStatement preparedStatement = null;
connection = JdbcUtil.createConnection();
try {
preparedStatement = connection.prepareStatement("delete from shop where shopId = ?");
preparedStatement.setInt(1, id);
int rows = preparedStatement.executeUpdate();
result = rows>0?true:false;
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
JdbcUtil.close(preparedStatement, connection);
}
return result;
}
public boolean updateShop(Shop shop) {
boolean result = false;
Connection connection = null;
PreparedStatement preparedStatement = null;
connection = JdbcUtil.createConnection();
try {
preparedStatement = connection.prepareStatement("update shop set shopName=?, shopAddress=?,shopExplain=?,salePrice=?,deliveryPrice=? where shopId=?");
//如果表的列比较多的时候，赋值时序号就比较多，如果想之前的写法那数字部分容易写混
//单独定义一个整数变量在前面 index下标索引的意思
int index=1;
preparedStatement.setString(index++, shop.getShopName());
preparedStatement.setString(index++, shop.getShopAddress());
preparedStatement.setString(index++, shop.getShopExplain());
preparedStatement.setDouble(index++, shop.getSalePrice());
preparedStatement.setDouble(index++, shop.getDeliveryPrice());
preparedStatement.setInt(index++, shop.getShopId());
int rows = preparedStatement.executeUpdate();
result = rows>0?true:false;
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
JdbcUtil.close(preparedStatement, connection);
}
return result;
}
//查询
public ArrayList<Shop> queryShop (String name){
ArrayList<Shop> list = new ArrayList<>();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
connection=JdbcUtil.createConnection();
try {
preparedStatement = connection.prepareStatement("select * from shop where shopName like ?");
preparedStatement.setString(1, "%"+name+"%");
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Shop shop = new Shop();
shop.setShopId(resultSet.getInt("shopId"));
shop.setShopName(resultSet.getString("shopName"));
shop.setShopAddress(resultSet.getString("shopAddress"));
shop.setShopExplain(resultSet.getString("shopExplain"));
shop.setSalePrice(resultSet.getDouble("salePrice"));
shop.setDeliveryPrice(resultSet.getDouble("deliveryPrice"));
list.add(shop);
}
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
JdbcUtil.close(resultSet, preparedStatement, connection);
}
return list;
}
}最后：ShopDao类单元测试
单元测试在一个类中进行即可，这里取名是TestShopDao
添加测试
public static void main(String[] args) {
ShopDao dao = new ShopDao();
Shop shop = new Shop();
shop.setShopName("球星签名足球鞋");
shop.setShopAddress("粤江市津海区");
shop.setShopExplain("当红球星签名，收藏意义重大");
shop.setSalePrice(8888.0);
shop.setDeliveryPrice(198.0);
//增加
System.out.println(dao.addShop(shop));
}返回true，刷新数据库显示多了行数据
修改测试
public static void main(String[] args) {
ShopDao dao = new ShopDao();
Shop shop = new Shop();
shop.setShopName("签名鞋专卖");
shop.setShopAddress("粤江市津海西区");
shop.setShopExplain("收藏意义重大");
shop.setSalePrice(8888.0);
shop.setDeliveryPrice(198.0);
//修改
shop.setShopId(2);
System.out.println(dao.updateShop(shop));
}返回true，刷新数据库显示改了第二条数据
查询测试
public static void main(String[] args) {
ShopDao dao = new ShopDao();
//查询
ArrayList<Shop> list = dao.queryShop("");
for (Shop shop2 : list) {
System.out.println(shop2);
}
}输出结果：
删除测试
public static void main(String[] args) {
ShopDao dao = new ShopDao();
//删除 删完后显示false
System.out.println(dao.deleteShop(2));
}输出结果：
新建View类
视图类的方法和作用：
1、显示信息 输出语句
2、获得用户输入
暂时用输出语句显示内容，用scanner获得输入
①、新建商品鞋子视图GoodsView
public class GoodsView {
private GoodsDao dao=new GoodsDao();//方便Dao类使用
//视图类的方法和作用：
//1.显示信息 输出语句
//2.获得用户输入
public void showAddGoods()
{
System.out.println("增加鞋子信息");
Scanner scanner = new Scanner(System.in);
String name,explain;
double price;
int shopId;
System.out.println("请输入鞋子名称");
name = scanner.next();
System.out.println("请输入鞋子介绍");
explain = scanner.next();
System.out.println("请输入鞋子价格");
price = scanner.nextDouble();
System.out.println("请输入鞋子所属商家ID");
shopId = scanner.nextInt();
//将输入的数据封装到po对象中
Goods goods = new Goods();
goods.setGoodsName(name);
goods.setGoodsExplain(explain);
goods.setGoodsPrice(price);
goods.setShopId(shopId);
//调用Dao类方法，完成数据操作
boolean result = dao.addGoods(goods);
//将最终的处理结果显示给用户
if (result) {
System.out.println("增加鞋子信息成功");
} else {
System.out.println("增加鞋子信息失败");
}
}
public void showDeleteGoods () {
System.out.println("删除鞋子信息");
Scanner scanner = new Scanner(System.in);
int id;
System.out.println("请输入要删除的鞋子ID");
id = scanner.nextInt();
boolean result = dao.deleteGoods(id);
if (result) {
System.out.println("删除鞋子信息成功");
} else {
System.out.println("删除鞋子信息失败");
}
}
public void showUpdateGoods() {
System.out.println("修改鞋子信息");
Scanner scanner = new Scanner(System.in);
String name,explian;
double price;
int id;
System.out.println("请输入要修改的鞋子ID");
id = scanner.nextInt();
System.out.println("请输入修改后的鞋子名称");
name = scanner.next();
System.out.println("请输入要修改的鞋子信息说明");
explian = scanner.next();
System.out.println("请输入要修改的鞋子价格");
price = scanner.nextDouble();
Goods foods = new Goods();
foods.setGoodsId(id);
foods.setGoodsName(name);
foods.setGoodsExplain(explian);
foods.setGoodsPrice(price);
boolean result = dao.updateGoods(foods);
if (result) {
System.out.println("修改鞋子信息成功");
} else {
System.out.println("修改鞋子信息失败");
}
}
public void showQueryGoods() {
System.out.println("查询鞋子信息");
Scanner scanner = new Scanner(System.in);
String name;
System.out.println("请输入查询的鞋子名字(支持模糊查询)");
//name = scanner.next();
//next()方法输入的数据不允许空和空格
name = scanner.nextLine();
ArrayList<Goods> list = dao.queryGoods(name);
if (list.size()>0) {
System.out.println("查询到的鞋子信息如下");
for (Goods foods : list) {
System.out.println(foods);
}
} else {
System.out.println("未查到满足条件的数据");
}
}
}最后：对GoodsView类进行单元测试
单元测试在还是在test包中进行即可，这里取名是TestGoodsView
添加商品鞋子视图测试
public static void main(String[] args) {
GoodsView view = new GoodsView();
//增加
view.showAddGoods();
}输出结果并刷新数据库：
修改商品鞋子视图测试
public static void main(String[] args) {
GoodsView view = new GoodsView();
//修改
view.showUpdateGoods();
}输出结果并刷新数据库：
查询商品鞋子视图测试
public static void main(String[] args) {
GoodsView view = new GoodsView();
//查询
view.showQueryGoods();
}输出结果：
删除商品鞋子视图测试
public static void main(String[] args) {
GoodsView view = new GoodsView();
//删除
view.showDeleteGoods();
}输出结果并刷新数据库：
②、新建商家视图GoodsView
public class ShopView {
private ShopDao dao = new ShopDao();
public void showAddShop() {
System.out.println("添加商家信息");
Scanner scanner = new Scanner(System.in);
String name,address,explain;
double sprice,dprice;
System.out.println("请输入商家名称");
name=scanner.next();
System.out.println("请输入商家地址");
address=scanner.next();
System.out.println("请输入商家介绍");
explain=scanner.next();
System.out.println("请输入商家所售价格");
sprice=scanner.nextDouble();
System.out.println("请输入商家快递费");
dprice=scanner.nextDouble();
Shop shop = new Shop();
shop.setShopName(name);
shop.setShopAddress(address);
shop.setShopExplain(explain);
shop.setSalePrice(sprice);
shop.setDeliveryPrice(dprice);
boolean result = dao.addShop(shop);
if (result) {
System.out.println("添加商家信息成功");
} else {
System.out.println("添加商家信息失败");
}
}
public void showDeleteShop () {
System.out.println("删除商家信息");
Scanner scanner = new Scanner(System.in);
int id;
System.out.println("请输入要删除的商家ID");
id = scanner.nextInt();
boolean result = dao.deleteShop(id);
if (result) {
System.out.println("删除商家信息成功");
} else {
System.out.println("删除商家信息失败");
}
}
public void showUpdateShop() {
System.out.println("修改商家信息");
Scanner scanner = new Scanner(System.in);
String name,address,explain;
double sprice,dprice;
int id;
System.out.println("请输入要修改的商家ID");
id = scanner.nextInt();
System.out.println("请输入修改后的商家名字");
name=scanner.next();
System.out.println("请输入修改后的商家地址");
address=scanner.next();
System.out.println("请输入修改后的商家介绍");
explain=scanner.next();
System.out.println("请输入修改后的商家所售价格");
sprice=scanner.nextDouble();
System.out.println("请输入修改后的商家快递费");
dprice=scanner.nextDouble();
Shop shop = new Shop();
shop.setShopId(id);
shop.setShopName(name);
shop.setShopAddress(address);
shop.setShopExplain(explain);
shop.setSalePrice(sprice);
shop.setDeliveryPrice(dprice);
boolean result = dao.updateShop(shop);
if (result) {
System.out.println("修改商家信息成功");
} else {
System.out.println("修改商家信息失败");
}
}
public void showQueryShop() {
System.out.println("查询商品鞋子信息");
Scanner scanner = new Scanner(System.in);
String name;
System.out.println("请输入查询的名字(支持模糊查询)");
name = scanner.nextLine();
ArrayList<Shop> list = dao.queryShop(name);
if (list.size()>0) {
System.out.println("查询到的商品鞋子信息如下");
for (Shop shop : list) {
System.out.println(shop);
}
} else {
System.out.println("未查到满足条件的数据");
}
}
}最后：对ShopView类进行单元测试
单元测试在还是在test包中进行即可，这里取名是TestShopView
添加商家视图测试
public static void main(String[] args) {
ShopView view = new ShopView();
//增加
view.showAddShop();
}输出结果并刷新数据库：
修改商家视图测试
public static void main(String[] args) {
ShopView view = new ShopView();
//修改
view.showUpdateShop();
}输出结果并刷新数据库：
查询商家视图测试
public static void main(String[] args) {
ShopView view = new ShopView();
//查询
view.showQueryShop();
}输出结果：
删除商家视图测试
public static void main(String[] args) {
ShopView view = new ShopView();
//删除
view.showDeleteShop();
}输出结果并刷新数据库：
但是这里注意：
商家编号为1的那条数据不能被删除
解释：
因为那个商品表里的各个商品鞋子都有个所属商家编号，他是外键链接，得先把所有的1号商家编号的商品鞋子删掉或改掉，才能再删那个商家编号为1的那条数据
外键约束：FOREIGN KEY
- 外键是别的表中的主键
- 依赖别人的表称为子表，在这个项目中是商品表依赖的商家表，所以商品表是子表
- 被别的表依赖的表称为父表，对比下商家表是父表
- 子表数据增加或修改时，数据必须在父表中存在
- 父表数据删除或修改时，数据没有被子表使用
所以当删除商家编号为1的那条数据时（shopId=1），商品表（goods表、子表）的外键中不能存在所属商家编号为1的数据
所以当shopId（所属商家编号、商品表外键）=1时，商家编号为1的那条数据不能被删除
三、模拟页面功能
在src内的taobao包下新建一个类，与dao、model、view类同级
大致思路：
首先定义一个主方法，输出欢迎信息并且接收用户输入的用户名和密码。
然后通过AdminDao类调用login方法来验证用户是否存在并且密码是否正确。
如果验证通过，则输出欢迎信息和管理系统的菜单选项，管理员可以根据自己的需要选择对应的菜单选项进行商品鞋子或者商家管理。
如果输入的菜单选项不合法，则提示输入有误，没有此功能菜单，并且让管理员重新选择。
如果验证失败，则提示用户名或密码错误。
public class TaoBaoEntry {
public static void main(String[] args) {
System.out.println("欢迎使用淘宝卖鞋后端管理系统");
//接下来要输入用户名和密码
Scanner scanner = new Scanner(System.in);
String name,pwd; //定义两个变量接受
System.out.println("请输入用户名");
name = scanner.next(); //将输入数据赋给name
System.out.println("请输入密码");
pwd = scanner.next();
//通过AdminDao类调用login方法来验证用户是否存在、密码是否正确
AdminDao dao = new AdminDao();
//创建admin对象，因为public boolean login(Admin admin) model类admin
Admin admin = new Admin();
//调用两个set方法，把刚才输入的名字和密码封装到这对象里
admin.setName(name);
admin.setPassword(pwd);
//调用方法拿到结果，用这个方法验证是否登录成功
boolean result = dao.login(admin);
//根据结果作出不同的选择进行if else判断
if (result ) {
//登录成功
System.out.println("欢迎"+name+"使用淘宝卖鞋后端管理系统");
} else {
//登录失败
System.out.println("用户名或密码错误"); //防止恶意登录
}
}
}这时候可以先测试下，输入已有的用户名和密码查看是否登录成功
接下来为系统提供一个菜单选择，提示功能操作，这里在登陆成功的地方写输出语句
//1、写输出语句，提示选择
System.out.println("鞋子增加请输入1");
System.out.println("鞋子删除请输入2");
System.out.println("鞋子修改请输入3");
System.out.println("鞋子查询请输入4");
System.out.println("商家增加请输入5");
System.out.println("商家删除请输入6");
System.out.println("商家修改请输入7");
System.out.println("商家查询请输入8");
//2、让用户获得操作
int menu = scanner.nextInt();
//3、创建对象视图
GoodsView goodsView = new GoodsView();
ShopView shopView = new ShopView();
//4、做输入的判断
switch (menu) {
case 1: //功能对应
goodsView.showAddGoods();
break;
case 2:
goodsView.showDeleteGoods();
break;
case 3:
goodsView.showUpdateGoods();
break;
case 4:
goodsView.showQueryGoods();
break;
case 5:
shopView.showAddShop();
break;
case 6:
shopView.showDeleteShop();
break;
case 7:
shopView.showUpdateShop();
break;
case 8:
shopView.showQueryShop();
break;
default: //输入意外的提示
System.out.println("输入有误，没有此功能菜单");
}但是到这项目还有个问题
就是项目执行完后自动退出，要想进行下一个功能的实现需要重新登录比较麻烦那就把上面在登录成功内写的代码选中右键→包围方式→while循环
然后登录成功内的代码变成：
while (true) { //里面加true变成死循环可以一直运行
System.out.println("鞋子增加请输入1");
System.out.println("鞋子删除请输入2");
System.out.println("鞋子修改请输入3");
System.out.println("鞋子查询请输入4");
System.out.println("商家增加请输入5");
System.out.println("商家删除请输入6");
System.out.println("商家修改请输入7");
System.out.println("商家查询请输入8");
int menu = scanner.nextInt();
GoodsView goodsView = new GoodsView();
ShopView shopView = new ShopView();
switch (menu) {
case 1:
goodsView.showAddGoods();
break;
case 2:
goodsView.showDeleteGoods();
break;
case 3:
goodsView.showUpdateGoods();
break;
case 4:
goodsView.showQueryGoods();
break;
case 5:
shopView.showAddShop();
break;
case 6:
shopView.showDeleteShop();
break;
case 7:
shopView.showUpdateShop();
break;
case 8:
shopView.showQueryShop();
break;
default:
System.out.println("输入有误，没有此功能菜单");
}
}现在运行程序后无论使用哪个功能程序都能继续运行下去，而且不会停止，陷入死循环
接下来手动停止该程序，加一个退出功能：
System.out.println("退出系统请输入9");
//在对应的位置加一个静态块
case 9:
System.exit(0); //0代表正常退出
break;运行输出：
至此整个淘宝卖鞋后端管理系统结束，系统已有功能运行完整
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
