py23tbguk
/
test
1
0
Fork 0
Code Issues Pull Requests 2 Packages Projects Releases Wiki Activity

代码注释

Browse Source
xhy_branch
xhy 8 months ago
parent 48346a59b6
commit 280d7a6f2e
11 changed files with 0 additions and 1862 deletions
Show Stats Download Patch File Download Diff File

164
action/buy_servlet.java
Unescape View File

@ -1,164 +0,0 @@
package com.itbaizhan.action;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import com.itbaizhan.orm.Tgoods;
import com.itbaizhan.orm.Torder;
import com.itbaizhan.orm.TorderItem;
import com.itbaizhan.orm.Tuser;
import com.itbaizhan.service.liuService;
import com.itbaizhan.util.Cart;
// 继承自HttpServlet类，这是一个典型的Servlet类，用于处理客户端请求
public class buy_servlet extends HttpServlet {
// service方法处理所有客户端请求
// req: HttpServletRequest请求对象，res: HttpServletResponse响应对象
public void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String type = req.getParameter("type"); // 获取URL传来的type参数，决定执行的操作
// 判断type的值，调用不同的操作方法
if (type.endsWith("addToCart")) {
addToCart(req, res); // 如果操作是添加到购物车
}
if (type.endsWith("orderSubmit")) {
orderSubmit(req, res); // 如果操作是提交订单
}
if (type.endsWith("myorder")) {
myorder(req, res); // 如果操作是查看我的订单
}
if (type.endsWith("orderDetail")) {
orderDetail(req, res); // 如果操作是查看订单明细
}
}
// 添加商品到购物车
public void addToCart(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String goods_id = req.getParameter("goods_id"); // 获取商品ID
int quantity = Integer.parseInt(req.getParameter("quantity")); // 获取商品数量
// 根据商品ID获取商品详情
Tgoods goods = liuService.getGoods(goods_id);
// 创建订单项对象，设置商品和商品数量
TorderItem orderItem = new TorderItem();
orderItem.setGoods(goods);
orderItem.setGoods_quantity(quantity);
// 获取session中的购物车对象
HttpSession session = req.getSession();
Cart cart = (Cart) session.getAttribute("cart");
// 将商品添加到购物车
cart.addGoods(goods_id, orderItem);
// 更新session中的购物车
session.setAttribute("cart", cart);
// 设置成功信息和跳转路径
req.setAttribute("message", "操作成功");
req.setAttribute("path", "site/cart/mycart.jsp"); // 跳转到购物车页面
// 跳转到成功页面
String targetURL = "/common/success.jsp";
dispatch(targetURL, req, res); // 跳转到目标页面
}
// 提交订单
public void orderSubmit(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String songhuodizhi = req.getParameter("songhuodizhi"); // 获取送货地址
String fukuanfangshi = req.getParameter("fukuanfangshi"); // 获取付款方式
// 从session中获取购物车对象和当前用户信息
HttpSession session = req.getSession();
Cart cart = (Cart) session.getAttribute("cart");
Tuser user = (Tuser) session.getAttribute("user");
// 创建订单对象并设置相关属性
Torder order = new Torder();
order.setId(String.valueOf(new Date().getTime())); // 设置订单ID（使用当前时间戳）
order.setBianhao(new SimpleDateFormat("yyyyMMddhhmmss").format(new Date())); // 设置订单编号
order.setShijian(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date())); // 设置下单时间
order.setZhuangtai("no"); // 订单状态，默认是“未支付”
order.setHuifu(""); // 订单回复信息
order.setSonghuodizhi(songhuodizhi); // 送货地址
order.setFukuanfangshi(fukuanfangshi); // 付款方式
order.setJine(cart.getTotalPrice()); // 总金额
order.setUser_id(user.getId()); // 用户ID
// 保存订单到数据库
liuService.saveOrder(order);
// 遍历购物车中的商品项，保存订单项信息
for (Iterator it = cart.getItems().values().iterator(); it.hasNext();) {
TorderItem orderItem = (TorderItem) it.next(); // 获取购物车中的每一项商品
String id = String.valueOf(new Date().getTime()); // 创建一个新的订单项ID
String order_id = order.getId(); // 获取订单ID
String goods_id = orderItem.getGoods().getId(); // 获取商品ID
int goods_quantity = orderItem.getGoods_quantity(); // 获取商品数量
// 保存订单项信息
liuService.saveOrderItem(id, order_id, goods_id, goods_quantity);
}
// 清空购物车
cart.getItems().clear();
session.setAttribute("cart", cart);
// 将订单信息传递到页面
req.setAttribute("order", order);
req.getRequestDispatcher("site/order/orderSubmit.jsp").forward(req, res); // 跳转到订单提交页面
}
// 查看我的订单
public void myorder(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
HttpSession session = req.getSession();
Tuser user = (Tuser) session.getAttribute("user");
// 从数据库获取当前用户的所有订单
req.setAttribute("orderList", liuService.orderList(user.getId()));
req.getRequestDispatcher("site/order/myorder.jsp").forward(req, res); // 跳转到我的订单页面
}
// 查看订单明细
public void orderDetail(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String order_id = req.getParameter("order_id"); // 获取订单ID
// 打印订单ID，调试用
System.out.println(order_id + "DD");
// 从数据库获取订单项信息
req.setAttribute("orderItemList", liuService.orderItemList(order_id));
req.getRequestDispatcher("site/order/orderDetail.jsp").forward(req, res); // 跳转到订单明细页面
}
// 跳转到目标页面
public void dispatch(String targetURI, HttpServletRequest request, HttpServletResponse response) {
RequestDispatcher dispatch = getServletContext().getRequestDispatcher(targetURI);
try {
dispatch.forward(request, response); // 转发请求到目标页面
} catch (ServletException | IOException e) {
e.printStackTrace(); // 异常处理
}
}
// 初始化Servlet配置
public void init(ServletConfig config) throws ServletException {
super.init(config);
}
// 销毁Servlet，通常用来释放资源
public void destroy() {
}
}

126
action/catelog_servlet.java
Unescape View File

@ -1,126 +0,0 @@
package com.itbaizhan.action;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.itbaizhan.dao.DB;
import com.itbaizhan.orm.Tcatelog;
// 继承HttpServlet类，处理关于菜品类别的增删改查操作
public class catelog_servlet extends HttpServlet {
// service方法是Servlet的核心方法，接收请求并分发到不同的功能方法
public void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String type = req.getParameter("type"); // 获取请求的type参数，判断要执行的操作类型
// 根据type值决定执行相应的功能
if (type.endsWith("catelogAdd")) {
catelogAdd(req, res); // 添加菜品类别
}
if (type.endsWith("catelogMana")) {
catelogMana(req, res); // 菜品类别管理
}
if (type.endsWith("catelogDel")) {
catelogDel(req, res); // 删除菜品类别
}
}
// 添加菜品类别
public void catelogAdd(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
// 获取请求参数，并设置类别的ID（使用当前时间戳）
String id = String.valueOf(new Date().getTime());
String name = req.getParameter("name").trim(); // 获取类别名称并去除空格
String del = "no"; // 设置删除标记，默认为“no”表示未删除
// 编写SQL插入语句，将菜品类别信息插入到数据库中
String sql = "insert into t_catelog(id,name,del) values(?,?,?)";
Object[] params = { id, name, del }; // 参数化SQL查询，防止SQL注入
// 创建DB对象并执行SQL语句
DB mydb = new DB();
mydb.doPstm(sql, params); // 执行SQL语句
mydb.closed(); // 关闭数据库连接
// 设置操作成功消息
req.setAttribute("msg", "操作成功");
String targetURL = "/common/msg.jsp"; // 跳转页面路径
dispatch(targetURL, req, res); // 跳转到成功提示页面
}
// 菜品类别管理，展示所有未删除的类别
public void catelogMana(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
List catelogList = new ArrayList(); // 存储所有菜品类别的列表
// 查询所有未删除的菜品类别
String sql = "select * from t_catelog where del='no'";
Object[] params = {}; // 查询没有参数
DB mydb = new DB(); // 创建DB对象用于执行查询操作
try {
mydb.doPstm(sql, params); // 执行SQL查询
ResultSet rs = mydb.getRs(); // 获取查询结果集
// 循环处理查询结果
while (rs.next()) { // 如果有更多数据，继续处理
Tcatelog catelog = new Tcatelog(); // 创建Tcatelog对象，用于存储每个类别的信息
catelog.setId(rs.getString("id")); // 设置类别ID
catelog.setName(rs.getString("name")); // 设置类别名称
catelogList.add(catelog); // 将类别对象添加到列表中
}
rs.close(); // 关闭结果集
} catch (Exception e) {
e.printStackTrace(); // 处理异常
}
mydb.closed(); // 关闭数据库连接
// 将类别列表传递到前端页面
req.setAttribute("catelogList", catelogList);
req.getRequestDispatcher("admin/catelog/catelogMana.jsp").forward(req, res); // 跳转到类别管理页面
}
// 删除菜品类别（将del字段设置为“yes”表示删除）
public void catelogDel(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
// 获取请求中传递的类别ID，并执行SQL更新语句
String sql = "update t_catelog set del='yes' where id=" + req.getParameter("id");
Object[] params = {}; // 删除操作没有额外的参数
DB mydb = new DB(); // 创建DB对象
mydb.doPstm(sql, params); // 执行更新操作
mydb.closed(); // 关闭数据库连接
// 设置操作成功消息
req.setAttribute("msg", "操作成功");
String targetURL = "/common/msg.jsp"; // 跳转页面路径
dispatch(targetURL, req, res); // 跳转到成功提示页面
}
// 跳转到指定页面
public void dispatch(String targetURI, HttpServletRequest request, HttpServletResponse response) {
RequestDispatcher dispatch = getServletContext().getRequestDispatcher(targetURI); // 获取RequestDispatcher对象
try {
dispatch.forward(request, response); // 将请求转发到目标页面
} catch (ServletException | IOException e) {
e.printStackTrace(); // 处理异常
}
}
// 初始化Servlet配置
public void init(ServletConfig config) throws ServletException {
super.init(config); // 调用父类的初始化方法
}
// 销毁Servlet，通常用来释放资源
public void destroy() {
// 可以进行资源释放的操作（此处为空）
}
}

312
action/goods_servlet.java
Unescape View File

@ -1,312 +0,0 @@
package com.itbaizhan.action;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.itbaizhan.dao.DB;
import com.itbaizhan.orm.Tgoods;
import com.itbaizhan.service.liuService;
public class goods_servlet extends HttpServlet {
// 处理所有的请求，根据type来区分不同的操作
public void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String type = req.getParameter("type");
// 判断type并调用相应的方法进行处理
if (type.endsWith("goodsAdd")) {
goodsAdd(req, res); // 添加商品
}
if (type.endsWith("goodsMana")) {
goodsMana(req, res); // 商品管理
}
if (type.endsWith("goodsDel")) {
goodsDel(req, res); // 删除商品
}
if (type.endsWith("goodsDetailHou")) {
goodsDetailHou(req, res); // 后台查看商品详细信息
}
if (type.endsWith("goodsPre")) {
goodsPre(req, res); // 商品信息添加前的准备工作
}
if (type.endsWith("goodsEdit")) {
goodsEdit(req, res); // 编辑商品信息
}
if (type.endsWith("goodsNew")) {
goodsNew(req, res); // 获取最新商品
}
if (type.endsWith("goodsByCatelog")) {
goodsByCatelog(req, res); // 按商品类别查看商品
}
if (type.endsWith("goodsDetailQian")) {
goodsDetailQian(req, res); // 前台查看商品详细信息
}
if (type.endsWith("goodsRes")) {
goodsRes(req, res); // 根据商品名称搜索商品
}
}
// 添加商品
public void goodsAdd(HttpServletRequest req, HttpServletResponse res) {
String id = String.valueOf(new Date().getTime()); // 使用当前时间戳作为商品 ID
String catelog_id = req.getParameter("catelog_id");
String bianhao = req.getParameter("bianhao");
String mingcheng = req.getParameter("mingcheng");
String jieshao = req.getParameter("jieshao");
String fujian = req.getParameter("fujian");
int shichangjia = Integer.parseInt(req.getParameter("shichangjia"));
int tejia = Integer.parseInt(req.getParameter("shichangjia")); // 可能是设置的特价，暂时设置为与市场价一样
String del = "no"; // 标记商品未删除
// SQL语句插入商品数据
String sql = "insert into t_goods(id, catelog_id, bianhao, mingcheng, jieshao, fujian, shichangjia, tejia, del) values(?,?,?,?,?,?,?,?,?)";
Object[] params = {id, catelog_id, bianhao, mingcheng, jieshao, fujian, shichangjia, tejia, del};
// 使用数据库操作类执行插入操作
DB mydb = new DB();
mydb.doPstm(sql, params); // 执行SQL插入
mydb.closed(); // 关闭数据库连接
// 返回操作成功信息并跳转至指定页面
req.setAttribute("msg", "操作成功");
String targetURL = "/common/msg.jsp";
dispatch(targetURL, req, res); // 转发到操作成功页面
}
// 商品管理，查看所有商品
public void goodsMana(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
List goodsList = new ArrayList();
String sql = "select * from t_goods where del='no'"; // 查询所有未删除的商品
Object[] params = {};
DB mydb = new DB();
try {
mydb.doPstm(sql, params); // 执行查询操作
ResultSet rs = mydb.getRs();
while (rs.next()) {
Tgoods goods = new Tgoods(); // 创建Tgoods对象并填充数据
goods.setId(rs.getString("id"));
goods.setCatelog_id(rs.getString("catelog_id"));
goods.setBianhao(rs.getString("bianhao"));
goods.setMingcheng(rs.getString("mingcheng"));
goods.setJieshao(rs.getString("jieshao"));
goods.setFujian(rs.getString("fujian"));
goods.setShichangjia(rs.getInt("shichangjia"));
goods.setTejia(rs.getInt("tejia"));
goods.setDel(rs.getString("del"));
goodsList.add(goods); // 将商品添加到列表中
}
rs.close();
} catch (Exception e) {
e.printStackTrace();
}
mydb.closed(); // 关闭数据库连接
// 将商品列表传递到前端页面
req.setAttribute("goodsList", goodsList);
req.getRequestDispatcher("admin/goods/goodsMana.jsp").forward(req, res);
}
// 删除商品
public void goodsDel(HttpServletRequest req, HttpServletResponse res) {
String id = req.getParameter("id");
String sql = "update t_goods set del='yes' where id=" + id; // 更新商品的del字段为'yes'表示删除
Object[] params = {};
DB mydb = new DB();
mydb.doPstm(sql, params); // 执行删除操作
mydb.closed();
req.setAttribute("msg", "操作成功");
String targetURL = "/common/msg.jsp";
dispatch(targetURL, req, res); // 转发到操作成功页面
}
// 后台查看商品详细信息
public void goodsDetailHou(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String id = req.getParameter("id");
req.setAttribute("goods", liuService.getGoods(id)); // 从服务层获取商品详细信息
req.getRequestDispatcher("admin/goods/goodsDetailHou.jsp").forward(req, res);
}
// 商品信息添加前的准备工作
public void goodsPre(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
Tgoods goods = new Tgoods();
String sql = "select * from t_goods where id=?";
Object[] params = {req.getParameter("id")};
DB mydb = new DB();
try {
mydb.doPstm(sql, params); // 执行查询操作
ResultSet rs = mydb.getRs();
while (rs.next()) {
goods.setId(rs.getString("id"));
goods.setCatelog_id(rs.getString("catelog_id"));
goods.setBianhao(rs.getString("bianhao"));
goods.setMingcheng(rs.getString("mingcheng"));
goods.setJieshao(rs.getString("jieshao"));
goods.setFujian(rs.getString("fujian"));
goods.setShichangjia(rs.getInt("shichangjia"));
goods.setTejia(rs.getInt("tejia"));
goods.setDel(rs.getString("del"));
}
rs.close();
} catch (Exception e) {
e.printStackTrace();
}
mydb.closed();
req.setAttribute("goods", goods); // 将商品信息传递到前端页面
req.getRequestDispatcher("admin/goods/goodsPre.jsp").forward(req, res);
}
// 编辑商品信息
public void goodsEdit(HttpServletRequest req, HttpServletResponse res) {
String id = req.getParameter("id");
String catelog_id = req.getParameter("catelog_id");
String bianhao = req.getParameter("bianhao");
String mingcheng = req.getParameter("mingcheng");
String jieshao = req.getParameter("jieshao");
String fujian = req.getParameter("fujian");
int shichangjia = Integer.parseInt(req.getParameter("shichangjia"));
int tejia = Integer.parseInt(req.getParameter("shichangjia"));
// 更新商品信息
String sql = "update t_goods set catelog_id=?, bianhao=?, mingcheng=?, jieshao=?, fujian=?, shichangjia=?, tejia=? where id=?";
Object[] params = {catelog_id, bianhao, mingcheng, jieshao, fujian, shichangjia, tejia, id};
DB mydb = new DB();
mydb.doPstm(sql, params); // 执行更新操作
mydb.closed();
req.setAttribute("msg", "操作成功");
String targetURL = "/common/msg.jsp";
dispatch(targetURL, req, res); // 转发到操作成功页面
}
// 获取最新商品
public void goodsNew(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
List goodsList = new ArrayList();
String sql = "select * from t_goods where del='no' order by id desc"; // 按商品ID降序排列，查询所有未删除的商品
Object[] params = {};
DB mydb = new DB();
try {
mydb.doPstm(sql, params); // 执行查询操作
ResultSet rs = mydb.getRs();
while (rs.next()) {
Tgoods goods = new Tgoods(); // 创建Tgoods对象并填充数据
goods.setId(rs.getString("id"));
goods.setCatelog_id(rs.getString("catelog_id"));
goods.setBianhao(rs.getString("bianhao"));
goods.setMingcheng(rs.getString("mingcheng"));
goods.setJieshao(rs.getString("jieshao"));
goods.setFujian(rs.getString("fujian"));
goods.setShichangjia(rs.getInt("shichangjia"));
goods.setTejia(rs.getInt("tejia"));
goods.setDel(rs.getString("del"));
goodsList.add(goods); // 将商品添加到列表中
}
rs.close();
} catch (Exception e) {
e.printStackTrace();
}
mydb.closed(); // 关闭数据库连接
// 限制最新商品显示数量最多为4个
if (goodsList.size() > 4) {
goodsList = goodsList.subList(0, 4); // 截取前4个商品
}
// 将商品列表传递到前端页面
req.setAttribute("goodsList", goodsList);
req.getRequestDispatcher("site/goods/goodsNew.jsp").forward(req, res); // 转发到前端页面显示最新商品
}
// 根据商品类别查看商品
public void goodsByCatelog(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String catelog_id = req.getParameter("catelog_id");
// 从服务层获取指定类别的商品列表
req.setAttribute("goodsList", liuService.goodsByCatelog(catelog_id));
req.getRequestDispatcher("site/goods/goodsByCatelog.jsp").forward(req, res); // 转发到前端页面显示商品类别
}
// 前台查看商品详细信息
public void goodsDetailQian(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String id = req.getParameter("id");
// 从服务层获取商品的详细信息
req.setAttribute("goods", liuService.getGoods(id));
req.getRequestDispatcher("site/goods/goodsDetailQian.jsp").forward(req, res); // 转发到前端页面显示商品详细信息
}
// 根据商品名称搜索商品
public void goodsRes(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String mingcheng = req.getParameter("mingcheng");
List goodsList = new ArrayList();
String sql = "select * from t_goods where del='no' and mingcheng like '%" + mingcheng.trim() + "%'"; // 根据商品名称进行模糊查询
Object[] params = {};
DB mydb = new DB();
try {
mydb.doPstm(sql, params); // 执行查询操作
ResultSet rs = mydb.getRs();
while (rs.next()) {
Tgoods goods = new Tgoods(); // 创建Tgoods对象并填充数据
goods.setId(rs.getString("id"));
goods.setCatelog_id(rs.getString("catelog_id"));
goods.setBianhao(rs.getString("bianhao"));
goods.setMingcheng(rs.getString("mingcheng"));
goods.setJieshao(rs.getString("jieshao"));
goods.setFujian(rs.getString("fujian"));
goods.setShichangjia(rs.getInt("shichangjia"));
goods.setTejia(rs.getInt("tejia"));
goods.setDel(rs.getString("del"));
goodsList.add(goods); // 将商品添加到列表中
}
rs.close();
} catch (Exception e) {
e.printStackTrace();
}
mydb.closed(); // 关闭数据库连接
// 将商品列表传递到前端页面
req.setAttribute("goodsList", goodsList);
req.getRequestDispatcher("site/goods/goodsRes.jsp").forward(req, res); // 转发到前端页面显示搜索结果
}
// 转发请求到指定页面
public void dispatch(String targetURI, HttpServletRequest request, HttpServletResponse response) {
RequestDispatcher dispatch = getServletContext().getRequestDispatcher(targetURI);
try {
dispatch.forward(request, response); // 转发请求到目标页面
} catch (ServletException e) {
e.printStackTrace(); // 捕获并打印异常
} catch (IOException e) {
e.printStackTrace(); // 捕获并打印异常
}
}
// 初始化方法，初始化Servlet时调用
public void init(ServletConfig config) throws ServletException {
super.init(config); // 调用父类的init()方法进行初始化
}
// 销毁方法，在Servlet销毁时调用
public void destroy() {
// 在Servlet销毁时执行清理工作，如果有的话
}
}

76
action/index_servlet.java
Unescape View File

@ -1,76 +0,0 @@
package com.itbaizhan.action;
import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.itbaizhan.service.liuService;
public class index_servlet extends HttpServlet
// 导航页面服务端小程序
{
/**
* service方法是处理请求的核心方法
* 这个方法会接收客户端的请求，并做出响应。
* 1. 从服务层获取商品分类数据
* 2. 将数据保存到session中，以便前端页面使用
* 3. 转发请求到首页（index.jsp）
*/
public void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException
{
// 从liuService类中获取商品分类数据，并将其保存到session中
req.getSession().setAttribute("catelogList", liuService.catelogList());
// 转发请求到首页index.jsp页面，这个页面会使用“catelogList”来展示商品分类
req.getRequestDispatcher("site/index.jsp").forward(req, res);
}
/**
* dispatch方法用于请求的转发
* 用于将请求转发到指定的目标URI。
* 这里传入的目标URI通常是JSP页面，用于显示数据。
*/
public void dispatch(String targetURI, HttpServletRequest request, HttpServletResponse response)
{
RequestDispatcher dispatch = getServletContext().getRequestDispatcher(targetURI); // 获取请求转发器
try
{
// 转发请求到目标页面
dispatch.forward(request, response);
return;
}
catch (ServletException e)
{
e.printStackTrace(); // 捕获并打印ServletException
}
catch (IOException e)
{
e.printStackTrace(); // 捕获并打印IOException
}
}
/**
* init方法用于Servlet初始化时的设置
* 在Servlet创建时调用，用于做一些必要的初始化工作。
* 这里调用了父类的init()方法，但没有额外的初始化逻辑。
*/
public void init(ServletConfig config) throws ServletException
{
super.init(config); // 调用父类的init()方法进行初始化
}
/**
* destroy方法在Servlet销毁时调用
* 可以用来释放资源，如关闭数据库连接、清理内存等。
* 这里没有特别的销毁逻辑，留作将来扩展使用。
*/
public void destroy()
{
// 销毁时执行清理工作，如果需要
}
}

299
action/liuyan_servlet.java
Unescape View File

@ -1,299 +0,0 @@
package com.itbaizhan.action;
import java.io.IOException;
import java.sql.ResultSet;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import com.itbaizhan.dao.DB;
import com.itbaizhan.orm.TLiuyan;
import com.itbaizhan.orm.Tuser;
public class liuyan_servlet extends HttpServlet
{
/**
* service方法用于处理客户端请求，区分不同的请求类型，
* 并调用相应的方法来处理留言的增、删、查、改操作。
*/
public void service(HttpServletRequest req,HttpServletResponse res)throws ServletException, IOException
{
// 获取请求的type参数来确定操作类型
String type = req.getParameter("type");
// 根据请求的操作类型，调用相应的方法
if(type.endsWith("liuyanAdd"))
{
liuyanAdd(req, res); // 留言添加
}
if(type.endsWith("liuyanMana"))
{
liuyanMana(req, res); // 留言管理
}
if(type.endsWith("liuyanDel"))
{
liuyanDel(req, res); // 留言删除
}
if(type.endsWith("liuyanHuifu"))
{
liuyanHuifu(req, res); // 留言回复
}
if(type.endsWith("liuyanAll"))
{
liuyanAll(req, res); // 获取所有留言
}
if(type.endsWith("liuyanDetail"))
{
liuyanDetail(req, res); // 留言详细信息
}
}
/**
* liuyanAdd方法用于处理添加留言的操作。
* 获取留言内容，保存到数据库，并跳转到提示页面。
*/
public void liuyanAdd(HttpServletRequest req,HttpServletResponse res)
{
HttpSession session = req.getSession();
Tuser user = (Tuser)session.getAttribute("user"); // 从session中获取当前登录用户
// 获取留言内容
String neirong = req.getParameter("neirong");
String liuyanshi = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(new Date()); // 当前时间
String user_id = user.getId(); // 获取用户ID
String huifu = ""; // 默认无回复
String huifushi = ""; // 默认无回复时间
// 构建SQL插入语句
String sql = "insert into t_liuyan(neirong, liuyanshi, user_id, huifu, huifushi) values(?,?,?,?,?)";
Object[] params = {neirong, liuyanshi, user_id, huifu, huifushi};
DB mydb = new DB(); // 创建DB对象
mydb.doPstm(sql, params); // 执行SQL语句
mydb.closed(); // 关闭数据库连接
req.setAttribute("msg", "留言完毕"); // 设置提示信息
String targetURL = "/common/msg.jsp"; // 定义跳转页面
dispatch(targetURL, req, res); // 请求转发到提示页面
}
/**
* liuyanMana方法用于管理留言。
* 从数据库获取所有留言，并将其显示在管理页面。
*/
public void liuyanMana(HttpServletRequest req,HttpServletResponse res) throws ServletException, IOException
{
List liuyanList = new ArrayList();
String sql = "select * from t_liuyan order by liuyanshi"; // 获取所有留言的SQL语句
Object[] params = {};
DB mydb = new DB(); // 创建DB对象
try
{
mydb.doPstm(sql, params); // 执行SQL查询
ResultSet rs = mydb.getRs(); // 获取结果集
while(rs.next()) // 遍历结果集
{
TLiuyan liuyan = new TLiuyan(); // 创建留言对象
liuyan.setId(rs.getInt("id"));
liuyan.setNeirong(rs.getString("neirong"));
liuyan.setLiuyanshi(rs.getString("liuyanshi"));
liuyan.setUser_id(rs.getString("user_id"));
liuyan.setHuifu(rs.getString("huifu"));
liuyan.setHuifushi(rs.getString("huifushi"));
liuyanList.add(liuyan); // 将留言添加到列表中
}
rs.close(); // 关闭结果集
}
catch(Exception e)
{
e.printStackTrace(); // 打印异常
}
mydb.closed(); // 关闭数据库连接
req.setAttribute("liuyanList", liuyanList); // 将留言列表设置到请求属性中
req.getRequestDispatcher("admin/liuyan/liuyanMana.jsp").forward(req, res); // 转发到留言管理页面
}
/**
* liuyanDel方法用于删除指定ID的留言。
* 从数据库删除对应留言数据，并跳转到提示页面。
*/
public void liuyanDel(HttpServletRequest req,HttpServletResponse res)
{
String sql = "delete from t_liuyan where id=" + Integer.parseInt(req.getParameter("id")); // 删除留言的SQL语句
Object[] params = {};
DB mydb = new DB(); // 创建DB对象
mydb.doPstm(sql, params); // 执行删除操作
mydb.closed(); // 关闭数据库连接
req.setAttribute("msg", "留言信息删除完毕"); // 设置删除成功的提示信息
String targetURL = "/common/msg.jsp"; // 定义跳转页面
dispatch(targetURL, req, res); // 请求转发到提示页面
}
/**
* liuyanHuifu方法用于回复留言。
* 获取回复内容，并将其更新到数据库中，同时跳转到提示页面。
*/
public void liuyanHuifu(HttpServletRequest req,HttpServletResponse res)
{
String huifu = req.getParameter("huifu"); // 获取回复内容
String huifushi = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(new Date()); // 回复时间
int id = Integer.parseInt(req.getParameter("id")); // 获取留言ID
// 更新留言的回复内容和时间
String sql = "update t_liuyan set huifu=?, huifushi=? where id=?";
Object[] params = {huifu, huifushi, id};
DB mydb = new DB(); // 创建DB对象
mydb.doPstm(sql, params); // 执行更新操作
mydb.closed(); // 关闭数据库连接
req.setAttribute("msg", "回复完毕"); // 设置回复成功的提示信息
String targetURL = "/common/msg.jsp"; // 定义跳转页面
dispatch(targetURL, req, res); // 请求转发到提示页面
}
/**
* liuyanAll方法用于获取所有留言。
* 从数据库获取所有留言数据并显示在前端页面。
*/
public void liuyanAll(HttpServletRequest req,HttpServletResponse res) throws ServletException, IOException
{
List liuyanList = new ArrayList();
String sql = "select * from t_liuyan order by liuyanshi"; // 获取所有留言的SQL语句
Object[] params = {};
DB mydb = new DB(); // 创建DB对象
try
{
mydb.doPstm(sql, params); // 执行SQL查询
ResultSet rs = mydb.getRs(); // 获取结果集
while(rs.next()) // 遍历结果集
{
TLiuyan liuyan = new TLiuyan(); // 创建留言对象
liuyan.setId(rs.getInt("id"));
liuyan.setNeirong(rs.getString("neirong"));
liuyan.setLiuyanshi(rs.getString("liuyanshi"));
liuyan.setUser_id(rs.getString("user_id"));
liuyan.setHuifu(rs.getString("huifu"));
liuyan.setHuifushi(rs.getString("huifushi"));
liuyanList.add(liuyan); // 将留言添加到列表中
}
rs.close(); // 关闭结果集
}
catch(Exception e)
{
e.printStackTrace(); // 打印异常
}
mydb.closed(); // 关闭数据库连接
req.setAttribute("liuyanList", liuyanList); // 将留言列表设置到请求属性中
req.getRequestDispatcher("site/liuyan/liuyanAll.jsp").forward(req, res); // 转发到留言展示页面
}
/**
* liuyanDetail方法用于查看指定ID的留言详细信息。
* 从数据库中查询特定ID的留言，并将其显示在详细信息页面。
*/
public void liuyanDetail(HttpServletRequest req,HttpServletResponse res) throws ServletException, IOException
{
int id = Integer.parseInt(req.getParameter("id")); // 获取留言ID
// 获取留言的详细信息
req.setAttribute("liuyan", get_liuyan(id));
// 转发到留言详细页面显示内容
req.getRequestDispatcher("site/liuyan/liuyanDetail.jsp").forward(req, res);
}
/**
* get_liuyan方法用于根据留言ID从数据库中查询并返回该留言对象。
* @param id 留言ID
* @return 返回查询到的留言对象
*/
public TLiuyan get_liuyan(int id)
{
TLiuyan liuyan = new TLiuyan(); // 创建留言对象
// 查询特定ID的留言数据
String sql = "select * from t_liuyan where id=?";
Object[] params = {id};
DB mydb = new DB(); // 创建DB对象
try
{
mydb.doPstm(sql, params); // 执行SQL查询
ResultSet rs = mydb.getRs(); // 获取结果集
while(rs.next()) // 遍历结果集
{
liuyan.setId(rs.getInt("id"));
liuyan.setNeirong(rs.getString("neirong"));
liuyan.setLiuyanshi(rs.getString("liuyanshi"));
liuyan.setUser_id(rs.getString("user_id"));
liuyan.setHuifu(rs.getString("huifu"));
liuyan.setHuifushi(rs.getString("huifushi"));
}
rs.close(); // 关闭结果集
}
catch(Exception e)
{
e.printStackTrace(); // 打印异常
}
mydb.closed(); // 关闭数据库连接
return liuyan; // 返回留言对象
}
/**
* dispatch方法用于将请求转发到指定的目标页面。
* @param targetURI 目标页面的URI
* @param request 请求对象
* @param response 响应对象
*/
public void dispatch(String targetURI, HttpServletRequest request, HttpServletResponse response)
{
// 获取目标URI的RequestDispatcher
RequestDispatcher dispatch = getServletContext().getRequestDispatcher(targetURI);
try
{
dispatch.forward(request, response); // 请求转发
}
catch (ServletException e)
{
e.printStackTrace(); // 打印异常
}
catch (IOException e)
{
e.printStackTrace(); // 打印异常
}
}
/**
* init方法用于初始化Servlet配置。
* @param config Servlet配置对象
*/
public void init(ServletConfig config) throws ServletException
{
super.init(config); // 调用父类的初始化方法
}
/**
* destroy方法用于销毁Servlet实例。
* 在Servlet销毁时清理资源，通常不需要在此类中做额外处理。
*/
public void destroy()
{
// 在此方法中可以释放一些资源，如数据库连接等。
}
}

194
action/order_servlet.java
Unescape View File

@ -1,194 +0,0 @@
package com.itbaizhan.action;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.itbaizhan.dao.DB;
import com.itbaizhan.orm.Torder;
public class order_servlet extends HttpServlet {
/**
* service方法根据请求的类型(type)来决定调用哪个处理方法。
* @param req HttpServletRequest对象，包含请求参数和数据
* @param res HttpServletResponse对象，用于返回响应数据
* @throws ServletException Servlet异常
* @throws IOException I/O异常
*/
public void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
// 获取请求的type参数来判断要执行的操作
String type = req.getParameter("type");
if (type.endsWith("orderMana")) {
orderMana(req, res); // 订单管理
}
if (type.endsWith("orderDel")) {
orderDel(req, res); // 订单删除
}
if (type.endsWith("orderShouli")) {
orderShouli(req, res); // 受理订单
}
if (type.endsWith("huifuAdd")) {
huifuAdd(req, res); // 添加回复
}
}
/**
* orderMana方法用于查询所有订单并展示在管理页面。
* 查询数据库中所有订单，并将其保存到request中供JSP页面显示。
* @param req HttpServletRequest对象
* @param res HttpServletResponse对象
* @throws ServletException Servlet异常
* @throws IOException I/O异常
*/
public void orderMana(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
List orderList = new ArrayList(); // 用来保存订单列表
String sql = "select * from t_order order by zhuangtai desc"; // 查询所有订单，按状态倒序排列
Object[] params = {}; // SQL语句参数，当前查询没有参数
DB mydb = new DB(); // 创建DB对象来操作数据库
try {
mydb.doPstm(sql, params); // 执行SQL查询
ResultSet rs = mydb.getRs(); // 获取查询结果集
while (rs.next()) {
Torder order = new Torder(); // 创建Torder对象来封装每一条订单数据
// 从结果集中提取每个字段的值，并设置到Torder对象中
order.setId(rs.getString("id"));
order.setBianhao(rs.getString("bianhao"));
order.setShijian(rs.getString("shijian"));
order.setZhuangtai(rs.getString("zhuangtai"));
order.setHuifu(rs.getString("huifu"));
order.setSonghuodizhi(rs.getString("songhuodizhi"));
order.setFukuanfangshi(rs.getString("fukuanfangshi"));
order.setJine(rs.getInt("jine"));
order.setUser_id(rs.getString("user_id"));
// 将订单添加到订单列表
orderList.add(order);
}
rs.close(); // 关闭结果集
} catch (Exception e) {
e.printStackTrace(); // 捕获异常并打印堆栈信息
}
mydb.closed(); // 关闭数据库连接
// 将订单列表保存到request中，以便JSP页面进行展示
req.setAttribute("orderList", orderList);
req.getRequestDispatcher("admin/order/orderMana.jsp").forward(req, res); // 请求转发到订单管理页面
}
/**
* orderDel方法用于删除指定ID的订单。
* @param req HttpServletRequest对象
* @param res HttpServletResponse对象
* @throws ServletException Servlet异常
* @throws IOException I/O异常
*/
public void orderDel(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String id = req.getParameter("id"); // 获取要删除订单的ID
// 编写SQL语句删除指定ID的订单
String sql = "delete from t_order where id=?";
Object[] params = { id }; // 设置参数为订单ID
DB mydb = new DB(); // 创建DB对象
mydb.doPstm(sql, params); // 执行删除操作
mydb.closed(); // 关闭数据库连接
// 设置删除成功的消息，并转发到消息页面显示
req.setAttribute("msg", "信息删除完毕");
String targetURL = "/common/msg.jsp";
dispatch(targetURL, req, res);
}
/**
* orderShouli方法用于受理订单，将订单状态更改为已受理。
* @param req HttpServletRequest对象
* @param res HttpServletResponse对象
* @throws ServletException Servlet异常
* @throws IOException I/O异常
*/
public void orderShouli(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String id = req.getParameter("id"); // 获取要受理的订单ID
// 编写SQL语句更新订单的状态为"yes"（已受理）
String sql = "update t_order set zhuangtai='yes' where id=?";
Object[] params = { id }; // 设置参数为订单ID
DB mydb = new DB(); // 创建DB对象
mydb.doPstm(sql, params); // 执行更新操作
mydb.closed(); // 关闭数据库连接
// 设置受理成功的消息，并转发到消息页面显示
req.setAttribute("msg", "订单受理完毕");
String targetURL = "/common/msg.jsp";
dispatch(targetURL, req, res);
}
/**
* huifuAdd方法用于为订单添加回复信息。
* @param req HttpServletRequest对象
* @param res HttpServletResponse对象
* @throws ServletException Servlet异常
* @throws IOException I/O异常
*/
public void huifuAdd(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String id = req.getParameter("id"); // 获取订单ID
String huifu = req.getParameter("huifu"); // 获取回复内容
// 编写SQL语句更新订单的回复内容
String sql = "update t_order set huifu=? where id=?";
Object[] params = { huifu, id }; // 设置参数为回复内容和订单ID
DB mydb = new DB(); // 创建DB对象
mydb.doPstm(sql, params); // 执行更新操作
mydb.closed(); // 关闭数据库连接
// 设置回复成功的消息，并转发到消息页面显示
req.setAttribute("msg", "操作成功");
String targetURL = "/common/msg.jsp";
dispatch(targetURL, req, res);
}
/**
* dispatch方法用于将请求转发到指定的目标页面。
* @param targetURI 目标页面的URI
* @param request 请求对象
* @param response 响应对象
*/
public void dispatch(String targetURI, HttpServletRequest request, HttpServletResponse response) {
// 获取目标URI的RequestDispatcher
RequestDispatcher dispatch = getServletContext().getRequestDispatcher(targetURI);
try {
dispatch.forward(request, response); // 执行请求转发
} catch (ServletException e) {
e.printStackTrace(); // 捕获并打印异常
} catch (IOException e) {
e.printStackTrace(); // 捕获并打印异常
}
}
/**
* init方法用于初始化Servlet配置。
* @param config Servlet配置对象
*/
public void init(ServletConfig config) throws ServletException {
super.init(config); // 调用父类的初始化方法
}
/**
* destroy方法用于销毁Servlet实例。
* 在Servlet销毁时清理资源，通常不需要在此类中做额外处理。
*/
public void destroy() {
// 在此方法中可以释放一些资源，如数据库连接等
}
}

234
action/user_servlet.java
Unescape View File

@ -1,234 +0,0 @@
package com.itbaizhan.action;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import com.itbaizhan.dao.DB;
import com.itbaizhan.orm.Tuser;
import com.itbaizhan.service.liuService;
public class user_servlet extends HttpServlet {
/**
* service方法根据请求的类型(type)来决定调用哪个处理方法。
* @param req HttpServletRequest对象，包含请求参数和数据
* @param res HttpServletResponse对象，用于返回响应数据
* @throws ServletException Servlet异常
* @throws IOException I/O异常
*/
public void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
// 获取请求的type参数来判断要执行的操作
String type = req.getParameter("type");
if (type.endsWith("userReg")) {
userReg(req, res); // 会员注册
}
if (type.endsWith("userLogout")) {
userLogout(req, res); // 会员退出
}
if (type.endsWith("userMana")) {
userMana(req, res); // 会员管理
}
if (type.endsWith("userDel")) {
userDel(req, res); // 会员删除
}
if (type.endsWith("userDetail")) {
userDetail(req, res); // 会员详细信息
}
}
/**
* userReg方法用于会员注册。
* 该方法获取用户提交的注册信息，检查账号是否已被占用，如果没有被占用则执行注册操作。
* @param req HttpServletRequest对象
* @param res HttpServletResponse对象
*/
public void userReg(HttpServletRequest req, HttpServletResponse res) {
String id = String.valueOf(new Date().getTime()); // 使用当前时间戳作为用户ID
String loginname = req.getParameter("loginname"); // 获取用户名
String loginpw = req.getParameter("loginpw"); // 获取密码
String name = req.getParameter("name"); // 获取用户姓名
String del = "no"; // 设置删除标志为"no"表示用户没有被删除
// 检查账号是否已经被占用
String s = liuService.panduan_zhanghao(loginname);
if (s.equals("yizhan")) {
// 如果账号已经被占用，返回提示信息
req.setAttribute("message", "账号已被占用，请输入其他账号");
req.setAttribute("path", "site/userreg/userreg.jsp");
String targetURL = "/common/success.jsp";
dispatch(targetURL, req, res);
} else {
// 如果账号未被占用，则执行注册操作
String sql = "insert into t_user values(?,?,?,?,?)"; // 插入新用户的SQL语句
Object[] params = {id, loginname, loginpw, name, del}; // 设置SQL语句的参数
DB mydb = new DB();
mydb.doPstm(sql, params); // 执行插入操作
mydb.closed(); // 关闭数据库连接
// 注册成功，返回成功页面
req.setAttribute("message", "注册成功，请登录");
req.setAttribute("path", "site/default.jsp");
String targetURL = "/common/success.jsp";
dispatch(targetURL, req, res);
}
}
/**
* userLogout方法用于会员退出系统。
* @param req HttpServletRequest对象
* @param res HttpServletResponse对象
* @throws ServletException Servlet异常
* @throws IOException I/O异常
*/
public void userLogout(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
HttpSession session = req.getSession(); // 获取当前会话
session.setAttribute("userType", null); // 清除会话中的用户类型
session.setAttribute("user", null); // 清除会话中的用户信息
// 提示用户退出成功
req.setAttribute("message", "成功退出系统");
req.setAttribute("path", "site/default.jsp");
String targetURL = "/common/success.jsp";
dispatch(targetURL, req, res);
}
/**
* userMana方法用于会员管理，查询所有未删除的会员。
* @param req HttpServletRequest对象
* @param res HttpServletResponse对象
* @throws ServletException Servlet异常
* @throws IOException I/O异常
*/
public void userMana(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
List userList = new ArrayList(); // 用于保存用户信息的列表
String sql = "select * from t_user where del='no'"; // 查询所有未被删除的用户
Object[] params = {}; // SQL查询没有参数
DB mydb = new DB();
try {
mydb.doPstm(sql, params); // 执行查询操作
ResultSet rs = mydb.getRs(); // 获取查询结果集
while (rs.next()) {
Tuser user = new Tuser(); // 创建Tuser对象来封装每个用户的数据
user.setId(rs.getString("id"));
user.setLoginname(rs.getString("loginname"));
user.setLoginpw(rs.getString("loginpw"));
user.setName(rs.getString("name"));
userList.add(user); // 将用户添加到列表中
}
rs.close(); // 关闭结果集
} catch (Exception e) {
e.printStackTrace(); // 捕获异常并打印堆栈信息
}
mydb.closed(); // 关闭数据库连接
// 将用户列表传递给JSP页面
req.setAttribute("userList", userList);
req.getRequestDispatcher("admin/user/userMana.jsp").forward(req, res);
}
/**
* userDel方法用于删除指定ID的用户。
* 实际上是将用户的`del`字段更新为"yes"表示删除。
* @param req HttpServletRequest对象
* @param res HttpServletResponse对象
* @throws ServletException Servlet异常
* @throws IOException I/O异常
*/
public void userDel(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String id = req.getParameter("id"); // 获取要删除用户的ID
String sql = "update t_user set del='yes' where id=?"; // 更新SQL语句，将del字段设为"yes"
Object[] params = {id}; // 设置参数为用户ID
DB mydb = new DB();
mydb.doPstm(sql, params); // 执行更新操作
mydb.closed(); // 关闭数据库连接
// 返回删除成功的消息
req.setAttribute("msg", "用户信息删除完毕");
String targetURL = "/common/msg.jsp";
dispatch(targetURL, req, res);
}
/**
* userDetail方法用于查看指定用户的详细信息。
* @param req HttpServletRequest对象
* @param res HttpServletResponse对象
* @throws ServletException Servlet异常
* @throws IOException I/O异常
*/
public void userDetail(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String id = req.getParameter("id"); // 获取用户ID
List userList = new ArrayList(); // 用于保存用户信息的列表
String sql = "select * from t_user where id=?"; // 查询指定ID的用户
Object[] params = {id}; // 设置参数为用户ID
DB mydb = new DB();
try {
mydb.doPstm(sql, params); // 执行查询操作
ResultSet rs = mydb.getRs(); // 获取查询结果集
while (rs.next()) {
Tuser user = new Tuser(); // 创建Tuser对象来封装用户数据
user.setId(rs.getString("id"));
user.setLoginname(rs.getString("loginname"));
user.setLoginpw(rs.getString("loginpw"));
user.setName(rs.getString("name"));
userList.add(user); // 将用户添加到列表中
}
rs.close(); // 关闭结果集
} catch (Exception e) {
e.printStackTrace(); // 捕获异常并打印堆栈信息
}
mydb.closed(); // 关闭数据库连接
// 获取用户信用信息，并将数据传递给JSP页面
req.setAttribute("userList", userList);
req.setAttribute("xinyongList", liuService.getxinyongList(id));
req.getRequestDispatcher("admin/user/userDetail.jsp").forward(req, res);
}
/**
* dispatch方法用于将请求转发到指定的目标页面。
* @param targetURI 目标页面的URI
* @param request 请求对象
* @param response 响应对象
*/
public void dispatch(String targetURI, HttpServletRequest request, HttpServletResponse response) {
// 获取目标URI的RequestDispatcher
RequestDispatcher dispatch = getServletContext().getRequestDispatcher(targetURI); // 获取请求转发器
try {
dispatch.forward(request, response); // 执行请求转发
return;
} catch (ServletException e) {
e.printStackTrace(); // 捕获ServletException异常并打印堆栈信息
} catch (IOException e) {
e.printStackTrace(); // 捕获IOException异常并打印堆栈信息
}
}
/**
* init方法在Servlet初始化时调用，通常用于一些初始化操作。
* @param config ServletConfig对象，包含Servlet的配置参数
* @throws ServletException Servlet初始化异常
*/
public void init(ServletConfig config) throws ServletException {
super.init(config); // 调用父类的init方法进行初始化
}
/**
* destroy方法在Servlet销毁时调用，用于清理资源。
*/
public void destroy() {
// 在此方法中执行清理工作，例如关闭数据库连接等资源释放操作。
}
}

160
action/xinyong_servlet.java
Unescape View File

@ -1,160 +0,0 @@
package com.itbaizhan.action;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.itbaizhan.dao.DB;
import com.itbaizhan.orm.Txinyong;
public class xinyong_servlet extends HttpServlet {
/**
* service方法，根据请求的type参数决定调用哪个功能方法。
* @param req HttpServletRequest 请求对象
* @param res HttpServletResponse 响应对象
* @throws ServletException Servlet异常
* @throws IOException IO异常
*/
public void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String type = req.getParameter("type"); // 获取请求参数 type
if (type.endsWith("xinyongAdd")) {
xinyongAdd(req, res); // 调用信用添加方法
}
if (type.endsWith("xinyongMana")) {
xinyongMana(req, res); // 调用信用管理方法
}
if (type.endsWith("xinyongDel")) {
xinyongDel(req, res); // 调用信用删除方法
}
}
/**
* 处理信用添加功能。
* @param req HttpServletRequest 请求对象
* @param res HttpServletResponse 响应对象
*/
public void xinyongAdd(HttpServletRequest req, HttpServletResponse res) {
String id = String.valueOf(new Date().getTime()); // 使用当前时间戳生成唯一ID
String shuxing = req.getParameter("shuxing").trim(); // 获取信用属性
String neirong = req.getParameter("neirong").trim(); // 获取信用内容
String shijian = req.getParameter("shijian").trim(); // 获取时间
String user_id = req.getParameter("user_id").trim(); // 获取用户ID
// 插入SQL语句
String sql = "insert into t_xinyong(id, shuxing, neirong, shijian, user_id) values(?,?,?,?,?)";
Object[] params = {id, shuxing, neirong, shijian, user_id};
DB mydb = new DB();
mydb.doPstm(sql, params); // 执行插入操作
mydb.closed(); // 关闭数据库连接
req.setAttribute("msg", "操作成功"); // 设置提示消息
String targetURL = "/common/msg.jsp"; // 跳转到提示页面
dispatch(targetURL, req, res); // 执行请求转发
}
/**
* 处理信用管理功能。
* @param req HttpServletRequest 请求对象
* @param res HttpServletResponse 响应对象
* @throws ServletException Servlet异常
* @throws IOException IO异常
*/
public void xinyongMana(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String user_id = req.getParameter("user_id").trim(); // 获取用户ID
List xinyongList = new ArrayList(); // 用于存储信用记录的列表
String sql = "select * from t_xinyong where user_id=?";
Object[] params = {user_id};
DB mydb = new DB();
try {
mydb.doPstm(sql, params); // 执行查询操作
ResultSet rs = mydb.getRs(); // 获取查询结果集
while (rs.next()) {
Txinyong xinyong = new Txinyong(); // 创建信用对象
// 设置信用对象的属性
xinyong.setId(rs.getString("id"));
xinyong.setShuxing(rs.getString("shuxing"));
xinyong.setNeirong(rs.getString("neirong"));
xinyong.setShijian(rs.getString("shijian"));
xinyong.setUser_id(rs.getString("user_id"));
xinyongList.add(xinyong); // 将信用对象添加到列表中
}
rs.close(); // 关闭结果集
} catch (Exception e) {
e.printStackTrace(); // 捕获异常并打印堆栈信息
}
mydb.closed(); // 关闭数据库连接
req.setAttribute("xinyongList", xinyongList); // 将信用列表传递到请求中
req.getRequestDispatcher("admin/xinyong/xinyongMana.jsp").forward(req, res); // 转发请求到管理页面
}
/**
* 处理信用删除功能。
* @param req HttpServletRequest 请求对象
* @param res HttpServletResponse 响应对象
* @throws ServletException Servlet异常
* @throws IOException IO异常
*/
public void xinyongDel(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
String id = req.getParameter("id").trim(); // 获取信用记录ID
String sql = "delete from t_xinyong where id=?";
Object[] params = {id};
DB mydb = new DB();
mydb.doPstm(sql, params); // 执行删除操作
mydb.closed(); // 关闭数据库连接
req.setAttribute("msg", "操作成功"); // 设置提示消息
String targetURL = "/common/msg.jsp"; // 跳转到提示页面
dispatch(targetURL, req, res); // 执行请求转发
}
/**
* 执行请求转发到指定页面。
* @param targetURI 目标页面的URI
* @param request HttpServletRequest 请求对象
* @param response HttpServletResponse 响应对象
*/
public void dispatch(String targetURI, HttpServletRequest request, HttpServletResponse response) {
RequestDispatcher dispatch = getServletContext().getRequestDispatcher(targetURI); // 获取请求转发器
try {
dispatch.forward(request, response); // 执行转发
return;
} catch (ServletException e) {
e.printStackTrace(); // 捕获并打印ServletException异常
} catch (IOException e) {
e.printStackTrace(); // 捕获并打印IOException异常
}
}
/**
* Servlet初始化方法，在Servlet实例化时调用。
* @param config ServletConfig对象，包含Servlet配置参数
* @throws ServletException Servlet异常
*/
public void init(ServletConfig config) throws ServletException {
super.init(config); // 调用父类的init方法进行初始化
}
/**
* Servlet销毁方法，在Servlet销毁时调用。
* 用于释放资源，如关闭数据库连接等。
*/
public void destroy() {
// 在此方法中执行清理工作，例如释放数据库连接等
}
}

124
dao/DB.java
Unescape View File

@ -1,124 +0,0 @@
package com.itbaizhan.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class DB {
private Connection con; // 用于数据库连接的Connection对象
private PreparedStatement pstm; // 用于执行SQL语句的PreparedStatement对象
private String user = "root"; // 数据库连接的用户名
private String password = "root"; // 数据库连接的密码
private String className = "com.mysql.cj.jdbc.Driver"; // MySQL数据库的JDBC驱动类名
private String url = "jdbc:mysql://localhost:3306/db_dingcan?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8"; // 数据库URL，包含数据库名、字符编码、时区等配置
/**
* 构造方法，加载数据库驱动
*/
public DB() {
try {
// 加载MySQL JDBC驱动程序
Class.forName(className);
} catch (ClassNotFoundException e) {
System.out.println("加载数据库驱动失败！");
e.printStackTrace();
}
}
/**
* 创建并返回数据库连接
* @return Connection 对象，代表数据库连接
*/
public Connection getCon() {
try {
// 通过DriverManager获取数据库连接
con = DriverManager.getConnection(url, user, password);
} catch (SQLException e) {
System.out.println("创建数据库连接失败！");
con = null; // 如果连接失败，设置con为null
e.printStackTrace();
}
return con;
}
/**
* 执行增、删、改操作的通用方法
* @param sql 执行的SQL语句
* @param params SQL语句的参数集合
*/
public void doPstm(String sql, Object[] params) {
// 如果SQL语句不为空
if (sql != null && !sql.equals("")) {
// 如果参数为空，则初始化为空数组
if (params == null) {
params = new Object[0]; // 初始化参数为空数组
}
// 获取数据库连接
getCon();
if (con != null) {
try {
System.out.println(sql); // 打印执行的SQL语句，方便调试
// 创建PreparedStatement对象，传入SQL语句
pstm = con.prepareStatement(sql,
ResultSet.TYPE_SCROLL_INSENSITIVE, // 结果集类型：不敏感，不会因为数据库的变化而更新
ResultSet.CONCUR_READ_ONLY); // 结果集：只读
// 设置SQL语句中的参数
for (int i = 0; i < params.length; i++) {
pstm.setObject(i + 1, params[i]); // 设定PreparedStatement对象的参数
}
// 执行SQL语句
pstm.execute(); // 执行语句，增、删、改操作
} catch (SQLException e) {
System.out.println("doPstm()方法出错！");
e.printStackTrace();
}
}
}
}
/**
* 获取查询操作的结果集
* @return ResultSet 返回查询结果集
* @throws SQLException SQL异常
*/
public ResultSet getRs() throws SQLException {
return pstm.getResultSet(); // 获取PreparedStatement对象的查询结果集
}
/**
* 获取最近一次操作（增、删、改）影响的记录条数
* @return int 返回更新影响的记录数
* @throws SQLException SQL异常
*/
public int getCount() throws SQLException {
return pstm.getUpdateCount(); // 获取更新操作影响的记录数（如插入、更新、删除的行数）
}
/**
* 关闭数据库连接和PreparedStatement对象，释放资源
*/
public void closed() {
try {
if (pstm != null) {
pstm.close(); // 关闭PreparedStatement对象
}
} catch (SQLException e) {
System.out.println("关闭pstm对象失败！");
e.printStackTrace();
}
try {
if (con != null) {
con.close(); // 关闭数据库连接
}
} catch (SQLException e) {
System.out.println("关闭con对象失败！");
e.printStackTrace();
}
}
}

95
util/Cart.java
Unescape View File

@ -1,95 +0,0 @@
package com.itbaizhan.util;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import com.itbaizhan.orm.Tgoods;
import com.itbaizhan.orm.TorderItem;
public class Cart {
// 购物车属性
// 使用一个 Map 存储购物项，Map 的 key 是商品的 id，value 是购物项 TorderItem
protected Map<String, TorderItem> items;
/**
* 构造函数，初始化购物车。
* 如果购物车的 items 为 null，创建一个新的 HashMap 实例。
*/
public Cart() {
if (items == null) {
items = new HashMap<String, TorderItem>(); // 初始化购物车，使用 HashMap 存储购物项
}
}
/**
* 将商品添加到购物车中。
* 如果购物车中已经存在该商品，则增加该商品的数量；如果不存在，则新建购物项并添加。
*
* @param goodsId 商品的 ID
* @param orderItem 购物项，即商品的详细信息，包括数量等
*/
public void addGoods(String goodsId, TorderItem orderItem) {
// 判断购物车中是否已经存在该商品
if (items.containsKey(goodsId)) { // 如果购物车中已存在该商品
// 获取原有的购物项，更新商品的数量
TorderItem _orderItem = items.get(goodsId); // 获取购物车中原有的购物项
_orderItem.setGoods_quantity(_orderItem.getGoods_quantity() + orderItem.getGoods_quantity()); // 更新数量
items.put(goodsId, _orderItem); // 更新购物车中的该商品项
} else { // 如果购物车中没有该商品
items.put(goodsId, orderItem); // 将新的购物项添加到购物车
}
}
/**
* 从购物车中删除指定商品。
* 根据商品的 ID 删除对应的购物项。
*
* @param goodsId 商品的 ID
*/
public void delGoods(String goodsId) {
items.remove(goodsId); // 从购物车中删除指定商品
}
/**
* 更新购物车中某个商品的数量。
*
* @param goodsId 商品的 ID
* @param quantity 新的商品数量
*/
public void updateCart(String goodsId, int quantity) {
// 获取购物车中的购物项，并更新数量
TorderItem orderItem = items.get(goodsId);
orderItem.setGoods_quantity(quantity); // 更新数量
items.put(goodsId, orderItem); // 更新购物车中的该商品项
}
/**
* 获取购物车中所有商品的总价。
* 遍历购物车中的所有商品，根据每个商品的特价和数量计算总价。
*
* @return 购物车中所有商品的总价
*/
public int getTotalPrice() {
int totalPrice = 0; // 初始化总价为 0
// 遍历购物车中的所有商品
for (Iterator it = items.values().iterator(); it.hasNext();) {
TorderItem orderItem = (TorderItem) it.next(); // 获取当前购物项
Tgoods goods = orderItem.getGoods(); // 获取商品信息
int quantity = orderItem.getGoods_quantity(); // 获取商品数量
totalPrice += goods.getTejia() * quantity; // 计算该商品的总价并累加到总价
}
return totalPrice; // 返回购物车中商品的总价
}
/**
* 获取购物车中的所有商品。
* 返回一个 Map，其中 key 是商品 ID，value 是购物项。
*
* @return 购物车中的所有商品
*/
public Map<String, TorderItem> getItems() {
return items; // 返回购物车中的所有商品
}
}

78
util/EncodingFilter.java
Unescape View File

@ -1,78 +0,0 @@
package com.itbaizhan.util;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class EncodingFilter implements Filter {
// 用于存储编码格式
protected String encoding = null;
// 用于存储 Filter 的配置信息
protected FilterConfig filterConfig = null;
/**
* 销毁方法。过滤器销毁时调用。清理资源。
*/
public void destroy() {
this.encoding = null; // 清空编码设置
this.filterConfig = null; // 清空过滤器配置
}
/**
* 过滤请求和响应。
* 在这个方法中，进行请求和响应的编码设置。
*
* @param request 请求对象，允许访问客户端请求的内容。
* @param response 响应对象，允许设置响应的内容。
* @param chain FilterChain 对象，允许将请求和响应传递到下一个过滤器或目标资源（例如 Servlet）。
* @throws IOException IO 异常
* @throws ServletException Servlet 异常
*/
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
// 获取请求的编码格式
String encoding = selectEncoding(request);
// 如果编码格式不为空，则设置请求和响应的编码格式
if (encoding != null) {
request.setCharacterEncoding(encoding); // 设置请求的编码
response.setCharacterEncoding(encoding); // 设置响应的编码
}
// 将请求和响应传递给下一个过滤器或目标资源
chain.doFilter(request, response);
}
/**
* 初始化方法。用于初始化过滤器配置。
* 在过滤器启动时调用，通常用于读取 web.xml 中的配置参数。
*
* @param filterConfig 过滤器的配置信息对象
* @throws ServletException 初始化时发生异常
*/
public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterConfig;
// 获取 web.xml 中配置的编码格式参数
this.encoding = filterConfig.getInitParameter("encoding");
}
/**
* 根据请求选择字符编码。
* 该方法可以进行扩展，以支持不同的编码选择机制。
*
* @param request 请求对象
* @return 选择的字符编码
*/
protected String selectEncoding(ServletRequest request) {
// 返回初始化时配置的编码格式
return (this.encoding);
}
}
Write Preview
Loading…
Cancel
Save