MySQL部分
在业务中，用户数据都是存储在数据库里
#判断存在即删除数据库
drop database if exists mydb;
#创建数据库
create database mydb;
#使用数据库
use mydb;
#创建表
create table t_user
(
uid int primary key auto_increment,
username varchar(20),
password varchar(20),
phone varchar(11),
address varchar(50)
);
insert into t_user(username,password,phone,address) values('张三','666','18965423548','南阳');
insert into t_user(username,password,phone,address) values('李四','333','18754263548','许昌');
insert into t_user(username,password,phone,address) values('小美','123','18565234759','信阳');
create table t_goods
(
gid int primary key auto_increment,
gname varchar(20),
price double,
mark varchar(100)
);
insert into t_goods(gname,price,mark) values('泡面',4.5,'够香够辣就是这个味！');
insert into t_goods(gname,price,mark) values('火腿',8.5,'肉质细腻Q弹！');
insert into t_goods(gname,price,mark) values('雪碧',3.5,'清爽冰凉随心爽！');
Java部分
首先在IDEA上部署web项目，具体步骤参考上篇博客，
部署文件如下：
下面是首页的页面效果：
实现代码如下：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>主页</title>
</head>
<body>
<h2>欢迎来到主页</h2>
<a href="login.jsp">登录</a>
<a href="register.jsp">注册</a>
</body>
</html>
我们点击登录，进入登录页面，
实现代码如下：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>登录</title>
</head>
<body>
<form action="denglu" method="get">
请输入账号：<input type="text" name="username"><br>
请输入密码：<input type="password" name="password"><br>
<input type="submit" value="确定">
<a href="register.jsp">没有账户？点击注册</a>
</form>
</body>
</html>后面会用到在这个项目中常用的类GoodsDao,UserDaoImpl，JDBCUtil类代码先放在下面，后面很多操作需要用到这两个类的方法
GoodsDao类：
package com.wang.dao.impl;
import com.wang.Bean.Goods;
import com.wang.Bean.User;
import com.wang.util.JDBCUtil;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class GoodsDao {
Goods goods=null; // 声明一个 Goods 对象，初值为 null
Connection con=null; // 声明一个 Connection 对象，初值为 null
PreparedStatement pstm=null; // 声明一个 PreparedStatement 对象，初值为 null
ResultSet rs = null; // 声明一个 ResultSet 对象，初值为 null
List<Goods> goodslist=null; // 声明一个 List<Goods> 对象，初值为 null
int row =0;
// 定义一个方法 shopping，返回一个 List<Goods> 对象
public List<Goods> shopping(){
try {
con = JDBCUtil.getCon(); // 调用 JDBCUtil 的静态方法，获取数据库连接
String sql ="select * from t_goods"; // 定义 SQL 语句，查询所有商品
pstm = con.prepareStatement(sql); // 创建 PreparedStatement 对象，执行 SQL 语句
rs = pstm.executeQuery(); // 执行 SQL 查询，获取查询结果集
goodslist= new ArrayList<>(); // 创建 ArrayList 对象，存储查询结果
while (rs.next()){ // 遍历查询结果集
goods=new Goods(); // 创建一个新的 Goods 对象
goods.setGid(rs.getInt("gid")); // 从查询结果中获取 gid 值，设置给 Goods 对象
goods.setGname(rs.getString("gname")); // 从查询结果中获取 gname 值，设置给 Goods 对象
goods.setPrice(rs.getDouble("price")); // 从查询结果中获取 price 值，设置给 Goods 对象
goods.setMark(rs.getString("mark")); // 从查询结果中获取 mark 值，设置给 Goods 对象
goodslist.add(goods); // 将 Goods 对象添加到 ArrayList 中
}
} catch (Exception e) { // 捕获所有异常
e.printStackTrace(); // 打印异常信息
}finally {
try {
JDBCUtil.colse(rs,pstm,con); // 调用 JDBCUtil 的静态方法，关闭 ResultSet、PreparedStatement 和 Connection 对象
} catch (Exception e) {
e.printStackTrace(); // 打印异常信息
}
}
return goodslist; // 返回查询结果，即 ArrayList<Goods> 对象
}
public int add(Goods goods){
con = JDBCUtil.getCon();
String sql = "insert into t_goods(gname,price,mark) values(?,?,?);";
try {
pstm=con.prepareStatement(sql);
pstm.setObject(1,goods.getGname());
pstm.setObject(2,goods.getPrice());
pstm.setObject(3,goods.getMark());
row = pstm.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
JDBCUtil.colse(pstm,con);
} catch (Exception e) {
e.printStackTrace();
}
}
return row;
}
public int delete(int gid){
con = JDBCUtil.getCon();
String sql = "delete from t_goods where gid=?";
try {
pstm=con.prepareStatement(sql);
pstm.setObject(1,gid);
row = pstm.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
JDBCUtil.colse(pstm,con);
} catch (Exception e) {
e.printStackTrace();
}
}
return row;
}
public Goods selectById(int gid){
Goods goods=null;
try{
con= JDBCUtil.getCon();
String sql="select * from t_goods where gid=?";
pstm=con.prepareStatement(sql);
pstm.setObject(1,gid);
rs=pstm.executeQuery();
if (rs.next()){
//从结果集中获取数据，封装到Goods对象中
goods=new Goods();
goods.setGid(rs.getInt("gid"));
goods.setGname(rs.getString("gname"));
goods.setPrice(rs.getDouble("price"));
goods.setMark(rs.getString("mark"));
}
} catch (Exception e){
e.printStackTrace();
} finally {
try{
JDBCUtil.colse(pstm,con);
} catch (Exception e){
e.printStackTrace();
}
}
return goods;
}
public int update( Goods goods){
try {
con = JDBCUtil.getCon();
String sql="update t_goods set gname=?,price=?,mark=? where gid=?";
pstm=con.prepareStatement(sql);
pstm.setObject(1,goods.getGname());
pstm.setObject(2,goods.getPrice());
pstm.setObject(3,goods.getMark());
pstm.setObject(4,goods.getGid());
row = pstm.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
JDBCUtil.colse(pstm,con);
} catch (Exception e) {
e.printStackTrace();
}
}
return row;
}
}
UserDaoImpl类：
package com.wang.dao.impl;
import com.wang.Bean.User;
import com.wang.dao.UserDao;
import com.wang.util.JDBCUtil;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class UserDaoImpl implements UserDao {
// 数据库连接、用户信息、数据库操作等相关变量的声明
Connection con = null; // 数据库连接
User user = null; // 用户信息
PreparedStatement pstm = null; // 数据库操作
ResultSet rs = null; // 数据库查询结果
int row = 0; // 数据库受影响行数
@Override
public User Login(String username, String password) {
// 获取数据库连接
con = JDBCUtil.getCon();
// 定义 SQL 查询语句
String sql = "select * from t_user where username = ? and password =?";
try {
// 准备预处理 SQL 语句
pstm = con.prepareStatement(sql);
// 设置预处理参数，防止 SQL 注入攻击
pstm.setObject(1, username);
pstm.setObject(2, password);
// 执行 SQL 查询，并获取查询结果
ResultSet rs = pstm.executeQuery();
// 处理查询结果
if (rs.next()) {
user = new User();
user.setUid(rs.getInt("uid"));
user.setUsername(rs.getString("username"));
user.setPassword(rs.getString("password"));
user.setPhone(rs.getString("phone"));
user.setAddress(rs.getString("address"));
}
} catch (Exception e) {
// 处理异常
e.printStackTrace();
} finally {
try {
// 关闭数据库连接、释放资源
JDBCUtil.colse(rs, pstm, con);
} catch (Exception e) {
e.printStackTrace();
}
}
// 返回用户信息
return user;
}
@Override
public int register(User user) {
// 获取数据库连接
con = JDBCUtil.getCon();
// 定义 SQL 插入语句
String sql = "insert into t_user(username,password,phone,address) values(?,?,?,?)";
try {
// 准备预处理 SQL 语句
pstm = con.prepareStatement(sql);
// 设置预处理参数，防止 SQL 注入攻击
pstm.setObject(1, user.getUsername());
pstm.setObject(2, user.getPassword());
pstm.setObject(3, user.getPhone());
pstm.setObject(4, user.getAddress());
// 执行 SQL 插入操作，并获取操作结果
row = pstm.executeUpdate();
} catch (Exception e) {
// 处理异常
e.printStackTrace();
} finally {
try {
// 关闭数据库连接、释放资源
JDBCUtil.colse(pstm, con);
} catch (Exception e) {
e.printStackTrace();
}
}
// 返回插入结果
return row;
}
}
JDBCUtil类：
package com.wang.util; // 定义类所在的包
import java.sql.*; // 导入 Java SQL 相关的类
public class JDBCUtil { // 定义 JDBCUtil 类
static String driver = "com.mysql.cj.jdbc.Driver"; // 定义数据库驱动类名
static String url = "jdbc:mysql:///mydb?useSSL=false&serverTimezone=UTC"; // 定义数据库连接 URL
static String username = "root"; // 定义数据库用户名
static String password = "123"; // 定义数据库密码
static Connection conn = null; // 定义连接对象，初始值为 null
public static Connection getCon() { // 定义获取连接对象的方法
try {
Class.forName(driver); // 加载数据库驱动程序
conn = DriverManager.getConnection(url, username, password); // 获取连接对象
} catch (Exception e) { // 处理异常
e.printStackTrace();
}
return conn; // 返回连接对象
}
//资源回收方法
public static void colse(ResultSet rs, PreparedStatement pstm, Connection con) throws SQLException { // 定义关闭 ResultSet、PreparedStatement 和 Connection 对象的方法
if (rs != null) { // 如果 ResultSet 对象不为空
rs.close(); // 关闭 ResultSet 对象
}
if (pstm != null) { // 如果 PreparedStatement 对象不为空
pstm.close(); // 关闭 PreparedStatement 对象
}
if (con != null) { // 如果 Connection 对象不为空
con.close(); // 关闭 Connection 对象
}
}
public static void colse(PreparedStatement pstm, Connection con) throws SQLException { // 定义关闭 PreparedStatement 和 Connection 对象的方法
if (pstm != null) { // 如果 PreparedStatement 对象不为空
pstm.close(); // 关闭 PreparedStatement 对象
}
if (con != null) { // 如果 Connection 对象不为空
con.close(); // 关闭 Connection 对象
}
}
}
我们输入账号密码，点击确定时，我们要获取页面数据向Java发送Servlet请求进行判断，操作代码如下：
package com.wang.servlet;
import com.wang.Bean.User;
import com.wang.dao.impl.UserDaoImpl;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
// 使用@WebServlet注解标记该类为Servlet，指定了Servlet的请求路径
@WebServlet("/denglu")
public class Login extends HttpServlet {
UserDaoImpl userDao = null; // 用户DAO实现类对象
User login = null; // 登录用户对象
// 处理Get请求
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp); // 将Get请求转发给doPost()方法处理
}
// 处理Post请求
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的编码格式
req.setCharacterEncoding("UTF-8");
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型
resp.setContentType("text/html;charset=utf-8");
// 获取用户提交的用户名和密码
String username = req.getParameter("username");
String password = req.getParameter("password");
// 创建用户DAO实现类对象，通过该对象调用登录方法验证用户身份
userDao = new UserDaoImpl();
login = userDao.Login(username, password);
// 根据登录结果进行不同的响应
if (login != null) { // 登录成功
HttpSession session = req.getSession();
session.setAttribute("login",login);
req.getRequestDispatcher("SelectAllGoods").forward(req,resp); //请求别的servlet做后续操作
} else { // 登录失败
req.setAttribute("error_msg","用户名或密码错误！");
req.getRequestDispatcher("error.jsp").forward(req,resp);
}
}
}
登录效果如下动图
当用户输入错误的密码或账号时，跳转错误页面,错误页面代码如下
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title></title>
</head>
<body>
<h2>${error_msg}</h2>
<a href="login.jsp">返回登录</a>
</body>
</body>
</html>
效果如下
点击返回登录重新返回登录页面。
用户需要注册时点击注册链接进入到注册页面，页面代码如下：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="register" method="get">
请输入注册账号：<input type="text" name="username"><br>
请输入注册密码：<input type="password" name="password"><br>
请输入电话：<input type="text" name="phone"><br>
请输入地址：<input type="text" name="address"><br>
<input type="submit" value="确定">
<a href="login.jsp">已有账号？点击登录</a>
</form>
</body>
</html>
效果如图：
我们输入账号等信息，点击确定，前端返回登录页面，向后端发送前端数据并向数据库表插入数据，或用户已有账号可以在进行点击链接返回登录页面
代码如下:
package com.wang.servlet; // 定义类所在的包
import com.wang.Bean.User; // 导入 User 类
import com.wang.dao.UserDao; // 导入 UserDao 接口
import com.wang.dao.impl.UserDaoImpl; // 导入 UserDaoImpl 类
import com.wang.util.JDBCUtil; // 导入 JDBCUtil 类
import javax.servlet.ServletException; // 导入 ServletException 类
import javax.servlet.annotation.WebServlet; // 导入 WebServlet 注解
import javax.servlet.http.HttpServlet; // 导入 HttpServlet 类
import javax.servlet.http.HttpServletRequest; // 导入 HttpServletRequest 类
import javax.servlet.http.HttpServletResponse; // 导入 HttpServletResponse 类
import java.io.IOException; // 导入 IOException 类
import java.sql.Connection; // 导入 Connection 类
import java.sql.PreparedStatement; // 导入 PreparedStatement 类
@WebServlet("/register") // 注解，指定该 Servlet 的 URL 路径
public class Register extends HttpServlet { // 定义 Register 类，继承 HttpServlet 类
Connection con = null; // 定义 Connection 对象，初始值为 null
PreparedStatement pstm = null; // 定义 PreparedStatement 对象，初始值为 null
User user = null; // 定义 User 对象，初始值为 null
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 处理 GET 请求
doPost(req,resp); // 调用 doPost() 方法
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // 处理 POST 请求
user = new User(); // 创建 User 对象
String username = req.getParameter("username"); // 获取用户名参数
String password = req.getParameter("password"); // 获取密码参数
String phone = req.getParameter("phone"); // 获取电话号码参数
String address = req.getParameter("address"); // 获取地址参数
user.setUsername(username); // 设置用户名
user.setPassword(password); // 设置密码
user.setPhone(phone); // 设置电话号码
user.setAddress(address); // 设置地址
System.out.println(user); // 输出 User 对象
UserDaoImpl userDao = new UserDaoImpl(); // 创建 UserDaoImpl 对象
int row = userDao.register(user); // 调用 UserDaoImpl 中的 register() 方法进行注册
System.out.println(row); // 输出注册结果
if (row > 0) { // 如果注册成功
resp.sendRedirect("login.jsp"); // 重定向到登录页面
System.out.println(row);
} else { // 如果注册失败
resp.sendRedirect("register.jsp"); // 重定向到注册页面
}
}
}
数据库中有此数据
我们请求转发给SelectAllGoods ,重新查看展示数据
package com.wang.servlet;
import com.mysql.cj.Session;
import com.wang.Bean.Goods;
import com.wang.dao.impl.GoodsDao;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
import java.util.List;
@WebServlet("/SelectAllGoods") // 设置Servlet的访问路径
public class SelectAllGoods extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doPost(request,response); // 如果是GET请求，则将其转发到doPost方法处理
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
GoodsDao goodsDao = new GoodsDao(); // 创建一个GoodsDao对象
List<Goods> shopping = goodsDao.shopping(); // 调用GoodsDao的shopping方法获取所有商品信息
System.out.println(shopping); // 在控制台输出查询结果，以便调试
HttpSession session = req.getSession(); // 获取当前会话的Session对象
session.setAttribute("shopping",shopping); // 将查询结果保存到Session中，便于在其他页面中访问
resp.sendRedirect("goods.jsp"); // 重定向到商品页面，显示查询结果
}
}
回到登录页面登录商品页面
页面代码如下：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>购物</title>
</head>
<body>
<h2>欢迎来自${login.address}的${login.username}商品页面</h2>
<a href="add.jsp">添加</a>
<table>
<thead>
<tr>
<th>商品编号</th>
<th>商品名字</th>
<th>商品价格</th>
<th>商品广告</th>
</tr>
</thead>
<tbody id="list">
<c:forEach items="${shopping}" var="sp">
<tr>
<td>${sp.gid}</td>
<td>${sp.gname}</td>
<td>${sp.price}</td>
<td>${sp.mark}</td>
<td><a href="del?gid=${sp.gid}">删除</a></td>
<td><a href="findById?gid=${sp.gid}">修改</a></td>
</tr>
</c:forEach>
</tbody>
</table>
</body>
</html>
下面来处理商品添加的操作
首先时添加时跳转的页面，代码如下
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>添加商品信息</title>
</head>
<body>
<h2>添加商品信息</h2>
<table>
<form action="add" method="get">
<tr>
<td>商品名称:</td>
<td><input type="text" name="gname"></td>
</tr>
<tr>
<td>商品价格:</td>
<td><input type="text" name="gprice"></td>
</tr>
<tr>
<td>商品广告:</td>
<td><input type="text" name="gmark"></td>
</tr>
<tr>
<td><input type="submit"></td>
</tr>
</form>
</table>
</body>
</html>效果如图：
实现功能代码如下：
package com.wang.servlet;
import com.wang.Bean.Goods;
import com.wang.dao.impl.GoodsDao;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
@WebServlet("/add")
public class add extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doPost(request,response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 设置请求和响应的编码格式
request.setCharacterEncoding("UTF-8");
response.setCharacterEncoding("utf-8");
// 设置响应的内容类型
response.setContentType("text/html;charset=utf-8");
String gname = request.getParameter("gname");
String gprice = request.getParameter("gprice");
Double price = Double.parseDouble(gprice);
String gmark = request.getParameter("gmark");
Goods goods = new Goods();
goods.setGname(gname);
goods.setPrice(price);
goods.setMark(gmark);
GoodsDao goodsDao = new GoodsDao();
int add = goodsDao.add(goods);
if (add>0){
request.getRequestDispatcher("SelectAllGoods").forward(request,response);
}else {
request.setAttribute("error_msg","添加失败请重试！");
request.getRequestDispatcher("error.jsp").forward(request,response);
}
}
}
效果如下图
修改操作
我们点击对应商品修改链接，根据当前商品id可以获取该商品的信息，并跳转页面展示数据提供用户修改
跳转页面如下：
页面代码如下：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h2>商品修改</h2>
<form action="updateGoods" method="post">
商品编号：<input type="text" name="gid" value="${goods.gid}" placeholder="商品编号" readonly="readonly" /> <br/>
商品名称：<input type="text" name="gname" value="${goods.gname}" placeholder="商品名称" /> <br/>
商品价格：<input type="number" step="0.01" name="price" value="${goods.price}" placeholder="商品价格" /> <br/>
商品说明：<input type="text" name="mark" value="${goods.mark}" placeholder="商品说明" /> <br/>
<input type="submit" value="修改">
</form>
</body>
</html>
获取当前点击修改商品信息的id，向页面传输id
package com.wang.servlet;
import com.wang.Bean.Goods;
import com.wang.dao.impl.GoodsDao;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
@WebServlet("/findById")
public class FindGoodsById extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doPost(request,response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
int gid = Integer.parseInt(request.getParameter("gid"));
GoodsDao goodsDao = new GoodsDao();
Goods goods = goodsDao.selectById(gid);
System.out.println(goods);
if(goods!=null){
//把数据存储到request域对象中，然后请求转发到页面
request.setAttribute("goods",goods);
request.getRequestDispatcher("revise.jsp").forward(request,response);
} else{
//登录失败，跳转到错误页
request.setAttribute("error_msg","修改出现异常");
request.getRequestDispatcher("error.jsp").forward(request,response);
}
}
}
实现代码如下：
package com.wang.servlet;
import com.wang.Bean.Goods;
import com.wang.dao.impl.GoodsDao;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
@WebServlet("/updateGoods")
public class updateGoods extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doPost(request,response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
//获取表单请求的数据，封装到goods对象中
Goods goods=new Goods();
goods.setGid(Integer.parseInt(request.getParameter("gid")));
goods.setGname(request.getParameter("gname"));
goods.setPrice(Double.parseDouble(request.getParameter("price")));
goods.setMark(request.getParameter("mark"));
//执行JDBC
GoodsDao goodsDao = new GoodsDao();
int row =goodsDao.update(goods);
if(row>0){
request.getRequestDispatcher("SelectAllGoods").forward(request,response);
} else{
request.setAttribute("error_msg","修改数据出现了异常！");
request.getRequestDispatcher("error.jsp").forward(request,response);
}
}
}
删除操作：也是获取当前商品id，根据id进行修改操作
实现代码如下：
package com.wang.servlet;
import com.wang.dao.impl.GoodsDao;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
@WebServlet("/del")
public class Del extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doPost(request,response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
int gid = Integer.parseInt(request.getParameter("gid"));
GoodsDao goodsDao = new GoodsDao();
int delete = goodsDao.delete(gid);
if(delete>0){
request.getRequestDispatcher("SelectAllGoods").forward(request,response);
}else {
request.setAttribute("error_msg","删除出现了问题");
request.getRequestDispatcher("error.jsp").forward(request,response);
}
}
}
效果如下：
以上就是整个项目的功能代码展示，感谢观看
844
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
