商品管理系统(javaWeb实训项目保姆级)

2024 年 8 月 12 日 7点热度 0人点赞 0条评论

一、项目介绍

该项目是基于JavaWeb实现的商品管理系统，使用maven进行管理jar包，能够对学生信息进行增删改查，分页查询，以及实现管理员的注册、登录

数据库：MySQL
开发工具：idea
开发环境：jdk 1.8 + tomcat

二、项目结构

三、前期准备

1.配置maven环境，在pom.xml配置文件中配置项目所依赖的jar包

<dependencies>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>1.1.2</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.8</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
    <dependency>
        <groupId>commons-dbutils</groupId>
        <artifactId>commons-dbutils</artifactId>
        <version>1.7</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.28</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
</dependencies>

2.在MySql数据库中，创建商品信息表commodity

(1)商品信息表commodity

(2)创建数据表的代码

create table commodity
(
    id         bigint auto_increment
        primary key,
    name       varchar(100) null,
    price      decimal      null,
    `describe` varchar(100) null
);

3.配置tocamt

四、代码实现

1.JSP界面实现

（1）首页-登录界面 (index.jsp)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ page isELIgnored="false"%>
<html>
<head>
    <title>登录</title>
</head>
    <body>
        <h3>请登录</h3>
        <form action="<c:url value="/login"/>" method="post">
            账号：<input type="text" name="username">
            密码：<input type="password" name="password">
            <input type="submit" value="登录">
        </form>
        <p style="color: red;">${requestScope.error}</p>
    </body>
</html>

index.jsp代码分析

这段代码是一个简单的JSP页面，用于展示一个登录页面。下面是对这段代码的分析：

这段代码实现了一个简单的登录页面的主体部分，具体的功能如下：

标题：页面展示了一个标题"请登录"，用于提醒用户进行登录操作。
表单：页面添加了一个表单，用于用户输入账号和密码信息。
输入框：表单中包含了两个输入框，分别是用于输入账号和密码的文本框。
提交按钮：表单中还包含了一个"登录"按钮，用于提交表单数据。
错误提示：页面在表单下方添加了一个段落，颜色为红色。该段落使用了EL表达式${requestScope.error}，用于展示请求作用域中名为"error"的属性值，通常用于显示登录失败的错误信息。

总的来说，该代码主要实现了一个简单的登录页面，用户可以输入账号和密码，并点击登录按钮进行登录操作。如果登录失败，页面会显示错误提示信息。具体的登录逻辑需要在后台的Servlet或者控制器中处理。

（2）添加商品页面 (add.jsp)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ page isELIgnored="false"%>
<html>
<head>
    <title>添加商品</title>
</head>
<body>

    <form action="<c:url value="/add"/>" method="post">
        商品名称：<input type="text" name="name">
        商品价格：<input type="text" name="price">
        商品描述：<input type="text" name="describe">
        <input type="submit" value="添加商品">
    </form>
    <p style="color:red;">${requestScope.error}</p>
</body>
</html>

添加页面的代码分析

这段代码实现了一个添加商品的表单页面，具体的功能如下：

表单：页面添加了一个表单，用于用户输入商品的相关信息。
输入框：表单中包含了三个输入框，分别是商品名称、商品价格和商品描述的文本框。
提交按钮：表单中还包含了一个"添加商品"按钮，用于提交表单数据。
错误提示：页面在表单下方添加了一个段落，颜色为红色。该段落使用了EL表达式${requestScope.error}，用于展示请求作用域中名为"error"的属性值，通常用于显示添加商品失败的错误信息。

总的来说，该代码实现了一个简单的添加商品的表单页面，用户可以输入商品的名称、价格和描述，并点击添加商品按钮进行提交操作。具体的添加商品逻辑需要在后台的Servlet或者控制器中处理。

(3）展示商品页面 (show.jsp)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ page isELIgnored="false"%>
<html>
<head>
    <title>商品列表页</title>
</head>
<body>
    <a href="/add">添加商品</a>
    <table>
        <tr>
            <th>名称</th>
            <th>价格</th>
            <th>描述</th>
            <th>操作</th>
        </tr>
        <c:forEach items="${requestScope.data}" var="c" varStatus="s">
        <tr>
            <td>${c.name}</td>
            <td>${c.price}</td>
            <td>${c.describe}</td>
            <td><a href="/delete?id=${c.id}">删除</a>|<a href="/update?id=${c.id}">修改</a></td>
        </tr>
        </c:forEach>
    </table>
</body>
</html>

展示页面的代码分析

这段代码实现了一个商品列表的展示页面，具体的功能如下：

添加商品链接：页面中包含了一个超链接"添加商品"，用于跳转到添加商品页面。
表格：页面中使用了一个HTML表格来展示商品列表的信息。
表头：表格有一个表头，包括了"名称"、“价格”、"描述"和"操作"四个列的标题。
商品数据循环：使用了JSTL的<c:forEach>标签来循环遍历名为"data"的数据集合。在每次循环中，通过{c.price}和${c.describe}来获取当前循环到的商品的名称、价格和描述。
删除和修改操作链接：在每行的最后一列，使用超链接展示了"删除"和"修改"两个操作链接，并通过URL参数传递了商品的ID信息。用户可以点击这些链接进行删除和修改商品的操作。

总的来说，该代码实现了一个商品列表的展示页面，页面上展示了商品的名称、价格和描述信息，并提供了删除和修改商品的操作链接。具体的删除和修改商品的逻辑需要在后台的Servlet或者控制器中处理。

(4)修改页面的代码(update.jsp)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ page isELIgnored="false"%>
<html>
<head>
    <title>添加商品</title>
</head>
<body>

    <form action="<c:url value="/update"/>" method="post">
        <input type="hidden" name="id" value="${requestScope.commodity.id}">
        商品名称：<input type="text" name="name" value="${requestScope.commodity.name}">
        商品价格：<input type="text" name="price" value="${requestScope.commodity.price}">
        商品描述：<input type="text" name="describe" value="${requestScope.commodity.describe}">
        <input type="submit" value="修改商品">
    </form>
    <p style="color:#ff0000;">${requestScope.error}</p>
</body>
</html>

修改的页面代码分析

这段代码实现了一个修改商品的表单页面，具体的功能如下：

表单：页面添加了一个表单，用于用户修改商品的相关信息。
隐藏域：表单中包含了一个隐藏域，用于存储需要修改的商品的ID信息。
输入框：表单中包含了三个输入框，分别是商品名称、商品价格和商品描述的文本框。其中，输入框的值通过${requestScope.commodity.X}来获取，使用EL表达式填充。
提交按钮：表单中还包含了一个"修改商品"按钮，用于提交表单数据。
错误提示：页面在表单下方添加了一个段落，颜色为红色。该段落使用了EL表达式${requestScope.error}，用于展示请求作用域中名为"error"的属性值，通常用于显示修改商品失败的错误信息。

总的来说，该代码实现了一个修改商品的表单页面，用户可以修改商品的名称、价格和描述，并点击修改商品按钮进行提交操作。具体的修改商品逻辑需要在后台的Servlet或者控制器中处理。

2.JavaBean实体类封装数据

(1)商品信息类(Commodity)

public class Commodity {
    private Long id;
    private String name;
    private BigDecimal price;
    private String describe;

    public Commodity() {
    }

    public Commodity(Long id, String name, BigDecimal price, String describe) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.describe = describe;
    }

    public Commodity(String name, BigDecimal price, String describe) {
        this.name = name;
        this.price = price;
        this.describe = describe;
    }

    @Override
    public String toString() {
        return "Commodity{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", price=" + price +
                ", describe='" + describe + ''' +
                '}';
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public BigDecimal getPrice() {
        return price;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    public String getDescribe() {
        return describe;
    }

    public void setDescribe(String describe) {
        this.describe = describe;
    }
}

实体类的代码分析(跟数据库的字段和属性保持一致)

这段代码定义了一个名为"Commodity"的Java类，用于表示商品对象。商品对象包含了以下属性：

id：商品的唯一标识符，类型为Long。
name：商品名称，类型为String。
price：商品价格，类型为BigDecimal，用于处理精确的金额计算。
describe：商品描述，类型为String，用于描述商品的详细信息。

该类提供了以下方法：

构造方法：提供了多个构造方法，用于创建Commodity对象。
toString方法：重写了Object类的toString方法，用于以字符串形式返回Commodity对象的属性值。
getter和setter方法：用于获取和设置Commodity对象的属性值。

这个Commodity类可以用于在应用程序中表示商品对象，包含了商品的基本属性和相关的方法，方便在代码中操作和处理商品数据。

（2）JDBC工具类 (CommodityDao.java)

package com.example;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;

public class CommodityDao {
    private final static QueryRunner queryRunner;

    static {
        try (InputStream dbProfile = CommodityDao.class.getResourceAsStream("/druid.properties")) {
            Properties pro = new Properties();
            pro.load(dbProfile);
            DataSource dataSource = DruidDataSourceFactory.createDataSource(pro);
            queryRunner = new QueryRunner(dataSource);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        } catch (Exception e) {
            throw new IllegalArgumentException(e);
        }
    }

    public List<Commodity> findAll() {
        String sql = "SELECT * FROM commodity";
        ResultSetHandler<List<Commodity>> resultSetHandler = new BeanListHandler<>(Commodity.class);
        try {
            return queryRunner.query(sql, resultSetHandler);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public void add(Commodity commodity){
        String sql = "insert into commodity values(null, ?,?,?)";
        ResultSetHandler<Commodity> resultSetHandler = new BeanHandler<>(Commodity.class);
        try {
            queryRunner.insert(sql, resultSetHandler,commodity.getName(),commodity.getPrice(),commodity.getDescribe());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void delete(String id) {
        try {
            queryRunner.execute("delete from commodity where id = ?", id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public Commodity findByid(String id) {
        String sql = "select * from commodity where id = ?";
        ResultSetHandler<Commodity> resultSetHandler = new BeanHandler<>(Commodity.class);
        try {
            return queryRunner.query(sql, resultSetHandler,Long.parseLong(id));
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    public void update(Commodity commodity) {
        try {
            queryRunner.update("update commodity set commodity.name = ?,commodity.price = ?,commodity.describe = ? where id = ?", commodity.getName(),commodity.getPrice(),commodity.getDescribe(),commodity.getId());
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}

这段代码是一个静态初始化块，用于初始化QueryRunner对象。

首先，它尝试读取位于类路径下的"druid.properties"文件，并将其转换为InputStream对象。

然后，创建一个Properties对象，并通过load()方法将读取到的配置文件内容加载到Properties对象中。

接下来，使用DruidDataSourceFactory.createDataSource()方法根据Properties对象中的配置信息创建一个Druid连接池（DataSource）。

最后，通过创建的Druid连接池来实例化QueryRunner对象，并将其赋值给静态的queryRunner变量。

注意：在try语句块中使用了try-with-resources语法，确保资源在使用完后自动关闭。另外，在异常处理中，IOException被包装成了UncheckedIOException，所以外部代码可能需要进行适当的异常处理。

这个方法用于查询数据库中的所有商品数据，并将查询结果封装成一个Commodity对象的List集合进行返回。

首先，定义了一个SQL语句，用于查询所有商品数据。然后，创建了一个ResultSetHandler对象，用于将结果集中的数据转换为Commodity对象的List集合。

接下来，通过QueryRunner对象的query()方法执行查询操作，并将SQL语句、ResultSetHandler对象传入。方法内部会根据SQL语句执行查询，并将查询结果通过ResultSetHandler对象进行处理，最终返回一个Commodity对象的List集合。

如果查询过程中发生异常，会打印异常信息，并返回null。

需要注意的是，这段代码中存在一些潜在的风险。例如，如果数据库连接或查询操作出现异常，会导致返回null，使用时需要对返回结果进行适当的处理来避免空指针异常。另外，如果查询结果很大，可能会对内存产生压力，建议做好分页查询等优化措施。

这个方法用于向数据库中添加一个新的商品记录。

首先，定义了一个SQL语句，用于向"commodity"表中插入数据。其中，“null"表示自增的商品ID，后面的占位符”? "表示待插入的具体值。

然后，创建了一个ResultSetHandler对象，用于将插入后的结果转换为Commodity对象。

接下来，通过QueryRunner对象的insert()方法执行插入操作。传入SQL语句、ResultSetHandler对象和具体的参数值，queryRunner会根据SQL语句和参数值执行插入操作，并将插入后的结果通过ResultSetHandler对象进行处理。

如果插入过程中发生SQLException异常，会打印异常信息。

需要注意的是，这段代码中的插入操作使用了queryRunner的insert()方法，而不是query()方法。这是因为插入操作会返回插入后的自增ID值，如果使用query()方法，则会将插入语句的结果集封装为Commodity对象，而不是自增ID值。

另外，具体的参数值从传入的Commodity对象中获取。这里假设Commodity类有对应的getName()、getPrice()和getDescribe()方法。

使用时，可以先创建一个Commodity对象，并设置相应的属性值，然后调用add()方法进行插入操作。

这个方法用于根据商品ID从数据库中删除对应的商品记录。

首先，利用queryRunner对象的execute()方法执行删除操作。execute()方法接收两个参数，第一个参数是待执行的SQL语句，第二个参数是占位符的具体值。在这里，SQL语句是"delete from commodity where id = ?“，其中的占位符”?"表示待删除的商品ID。

如果执行删除操作过程中发生SQLException异常，会打印异常信息。

需要注意的是，这段代码中的删除操作使用了queryRunner的execute()方法，而不是update()方法。这是因为删除操作不会返回结果集，只需要执行SQL语句即可。

使用时，可以调用delete()方法，传入待删除的商品ID进行删除操作。

这个方法用于根据商品对象的ID更新数据库中对应商品的记录。

首先，定义了一个SQL语句，使用"update"语句更新"commodity"表中的记录。通过"set"关键字指定需要更新的列及其对应的值，使用"where"关键字指定更新的条件。其中，占位符"?"表示待更新的具体值。

接下来，通过QueryRunner对象的update()方法执行更新操作。传入SQL语句和具体的参数值，queryRunner会根据SQL语句和参数值执行更新操作。

如果更新过程中发生SQLException异常，会打印异常信息。

需要注意的是，这段代码中的更新操作使用了queryRunner的update()方法。update()方法会执行更新操作，不返回结果集。

另外，具体的参数值从传入的Commodity对象中获取。通过调用commodity对象的getName()、getPrice()、getDescribe()、getId()方法分别获取对应的名称、价格、描述和ID值。

使用时，可以调用update()方法，传入待更新的商品对象进行更新操作。

(3)IndexServlet.java类

@WebServlet(name = "index",urlPatterns = "/")
public class IndexServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.getRequestDispatcher("/jsp/index.jsp").forward(req, resp);
    }
}

这段代码是一个简单的Servlet类，用于处理GET请求并转发到index.jsp页面。

@WebServlet注解用于声明该类是一个Servlet，并指定其名称为"index"，URL模式为"/"，即根目录。当用户请求根目录时，该Servlet类会被调用。

IndexServlet类继承自HttpServlet类，并重写了doGet()方法。当有GET请求到达时，就会执行doGet()方法中的代码。

在doGet()方法中，通过HttpServletRequest的getRequestDispatcher()方法获取用于转发请求的RequestDispatcher对象。这里的参数"/jsp/index.jsp"指定了需要转发到的页面路径。

然后，调用RequestDispatcher的forward()方法，将请求和响应对象作为参数传入。forward()方法会将请求和响应转发到目标页面，此处是index.jsp页面。

总结起来，这段代码的作用是，当用户访问根目录时，会将请求转发到index.jsp页面进行处理。

(4)LoginServlet.java

package com.example;

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 java.io.IOException;


@WebServlet(name = "login",urlPatterns = "/login")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        if("123456".equals(username) && "123456".equals(password)){
            resp.sendRedirect("/commodity");
        }else{
            req.setAttribute("error","用户名或密码错误,默认用户名123456，默认密码123456");
            req.getRequestDispatcher("/jsp/index.jsp").forward(req, resp);
        }
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }
}

这段代码是一个简单的LoginServlet类，用于处理用户的登录请求。

@WebServlet注解用于声明该类是一个Servlet，并指定其名称为"login"，URL模式为"/login"。当用户请求/login路径时，该Servlet类会被调用。

LoginServlet类继承自HttpServlet类，并重写了doPost()方法。当有POST请求到达时，就会执行doPost()方法中的代码。

在doPost()方法中，首先通过req.setCharacterEncoding()方法设置请求的字符编码为UTF-8，以防止中文乱码。

然后，通过req.getParameter()方法获取请求参数"username"和"password"的值，即用户输入的用户名和密码。

接下来，通过判断用户名和密码是否正确来决定如何进行响应。如果用户名和密码都等于"123456"，则通过resp.sendRedirect()方法将响应重定向到"/commodity"路径。重定向会向浏览器发送一个新的请求，跳转到指定的页面。

如果用户名和密码不正确，通过req.setAttribute()方法设置一个名为"error"的属性，值为"用户名或密码错误,默认用户名123456,默认密码123456"。然后，通过req.getRequestDispatcher().forward()方法将请求和响应转发到index.jsp页面，以便在页面上显示错误消息。

总结起来，这段代码的作用是，当用户登录时，获取用户输入的用户名和密码，如果合法，重定向到一个商品页面，否则在登录页面显示错误消息。

(5)CommodityServlet.java

@WebServlet(name = "Commodity", urlPatterns = "/commodity")
public class CommodityServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        CommodityDao commodityDao = new CommodityDao();
        req.setAttribute("data", commodityDao.findAll());
        req.getRequestDispatcher("/jsp/show.jsp").forward(req,resp);
    }
}

这段代码是一个CommodityServlet类，用于处理商品页面的请求。

@WebServlet注解用于声明该类是一个Servlet，并指定其名称为"Commodity"，URL模式为"/commodity"。当用户请求/commodity路径时，该Servlet类会被调用。

CommodityServlet类继承自HttpServlet类，并重写了doGet()方法。当有GET请求到达时，就会执行doGet()方法中的代码。

在doGet()方法中，首先创建一个CommodityDao对象，用于获取商品数据。根据代码中的findAll()方法，可以推测CommodityDao类中有一个findAll()方法用于查询所有商品信息。

接下来，通过req.setAttribute()方法将商品数据设置为名为"data"的属性，属性值为通过CommodityDao对象查询得到的所有商品数据。

然后，通过req.getRequestDispatcher().forward()方法将请求和响应转发到show.jsp页面。该页面将接收到的商品数据展示给用户。

总结起来，这段代码的作用是，在用户请求商品页面时，查询所有商品数据并将其设置为请求中的属性，然后将请求和响应转发到show.jsp页面以显示商品数据。

(6)AddCommodityServlet.java

package com.example;

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 java.io.IOException;
import java.math.BigDecimal;

@WebServlet("/add")
public class AddCommodityServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.getRequestDispatcher("/jsp/add.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        String name = req.getParameter("name");
        String price = req.getParameter("price");
        BigDecimal b = null;
        try{
            b = new BigDecimal(price);
        }catch (Exception e){
            req.setAttribute("error","添加失败，价格必须是数字");
            req.getRequestDispatcher("/jsp/add.jsp").forward(req,resp);
            return;
        }
        String describe = req.getParameter("describe");
        Commodity commodity = new Commodity(name, b,describe);
        CommodityDao commodityDao = new CommodityDao();
        commodityDao.add(commodity);
        resp.sendRedirect("/commodity");
    }
}

这段代码是一个AddCommodityServlet类，用于处理添加商品的请求。

@WebServlet注解用于声明该类是一个Servlet，并指定其URL模式为"/add"。当用户请求/add路径时，该Servlet类会被调用。

AddCommodityServlet类继承自HttpServlet类，并重写了doGet()方法和doPost()方法。

在doGet()方法中，通过req.getRequestDispatcher().forward()方法将请求和响应转发到add.jsp页面。该页面用于展示添加商品的表单给用户填写。

在doPost()方法中，首先设置请求的字符编码为utf-8，以防止中文乱码。

然后，通过req.getParameter()方法获取用户在表单中输入的商品名称、价格和描述。

接下来，将价格字符串转换为BigDecimal类型，如果转换出现异常，则将错误信息设置为请求的属性，并将请求和响应转发到add.jsp页面，以便将错误信息展示给用户。

如果价格转换成功，则创建一个Commodity对象，将商品名称、价格和描述设置到该对象中。

然后，创建一个CommodityDao对象，用于操作数据库。

调用commodityDao的add()方法，将Commodity对象存储到数据库中。

最后，通过resp.sendRedirect()方法将响应重定向到/commodity路径，以显示添加商品后的商品列表页面。

总结起来，这段代码的作用是，在用户请求添加商品页面时，展示添加商品的表单；在用户提交添加商品的表单时，获取表单数据，进行数据校验和处理，并将商品信息存储到数据库中，然后重定向到商品列表页面显示添加后的结果。

(7)DeleteCommodityServlet.java

package com.example;

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 java.io.IOException;


/**
 * @author xing'chen
 */
@WebServlet(name = "delete",urlPatterns = "/delete")
public class DeleteCommodityServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        String id = req.getParameter("id");
        CommodityDao commodityDao = new CommodityDao();
        commodityDao.delete(id);
        resp.sendRedirect("/commodity");
    }
}

这段代码是一个DeleteCommodityServlet类，用于处理删除商品的请求。

@WebServlet注解用于声明该类是一个Servlet，并指定其URL模式为"/delete"。当用户请求/delete路径时，该Servlet类会被调用。

DeleteCommodityServlet类继承自HttpServlet类，并重写了doGet()方法。

在doGet()方法中，首先设置请求的字符编码为utf-8，以防止中文乱码。

然后，通过req.getParameter()方法获取请求参数中的商品id。

接下来，创建一个CommodityDao对象，用于操作数据库。

调用commodityDao的delete()方法，将商品id传入，从数据库中删除对应的商品。

最后，通过resp.sendRedirect()方法将响应重定向到/commodity路径，以显示删除商品后的商品列表页面。

总结起来，这段代码的作用是，在用户请求删除商品的操作时，获取请求参数中的商品id，并根据该id从数据库中删除对应的商品，然后重定向到商品列表页面显示删除后的结果。

(8)UpdateCommodityServlet.java

package com.example;

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 java.io.IOException;
import java.math.BigDecimal;


@WebServlet(name = "update", urlPatterns = "/update")
public class UpdateCommodityServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        String id = req.getParameter("id");
        CommodityDao commodityDao = new CommodityDao();
        Commodity commodity = commodityDao.findByid(id);
        req.setAttribute("commodity",commodity);
        req.getRequestDispatcher("/jsp/update.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        String id = req.getParameter("id");
        String name = req.getParameter("name");
        String price = req.getParameter("price");
        String describe = req.getParameter("describe");
        BigDecimal b = null;
        try{
            b = new BigDecimal(price);
        }catch (Exception e){
            Commodity commodity = new Commodity(Long.parseLong(id),name,null,describe);
            req.setAttribute("commodity",commodity);
            req.setAttribute("error","修改失败，价格必须是数字");
            req.getRequestDispatcher("/jsp/update.jsp").forward(req,resp);
            return;
        }
        Commodity commodity = new Commodity(Long.parseLong(id),name,b,describe);
        CommodityDao commodityDao = new CommodityDao();
        commodityDao.update(commodity);
        resp.sendRedirect("/commodity");
    }
}

这段代码是一个UpdateCommodityServlet类，用于处理更新商品的请求。

@WebServlet注解用于声明该类是一个Servlet，并指定其URL模式为"/update"。当用户请求/update路径时，该Servlet类会被调用。

UpdateCommodityServlet类继承自HttpServlet类，并重写了doGet()和doPost()方法。

在doGet()方法中，首先设置请求的字符编码为utf-8，以防止中文乱码。

然后，通过req.getParameter()方法获取请求参数中的商品id。

接下来，创建一个CommodityDao对象，用于操作数据库。

调用commodityDao的findByid()方法，将商品id传入，从数据库中查询对应的商品。

将查询到的商品对象设置到请求属性中，属性名为"commodity"。

最后，通过req.getRequestDispatcher()方法将请求转发到"/jsp/update.jsp"页面进行显示。

在doPost()方法中，也是首先设置请求的字符编码为utf-8。

然后，通过req.getParameter()方法获取请求参数中的商品id、名称、价格和描述等信息。

接着，创建一个BigDecimal对象b，用于存储价格信息，并尝试将请求参数中的价格转换为BigDecimal类型。

再接下来，通过commodityDao的update()方法，将商品id、名称、价格和描述等信息传入，更新对应的商品信息。

最后，重定向到商品列表页面，以显示更新商品后的结果。

总结起来，这段代码的作用是，在用户请求更新商品的操作时，根据商品id从数据库中查询对应的商品信息并显示在更新页面上，然后通过表单提交，获取新的商品信息，并通过数据库操作更新商品信息，最后重定向到商品列表页面显示更新后的结果。

(9)druid.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///test?characterEncoding=utf8
username=root
password=419520
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

这段代码是一段数据库连接池的配置信息，用于设置数据库连接的相关参数。具体解释如下：

driverClassName：指定数据库驱动的类名，这里是MySQL的驱动类名。
url：指定数据库的URL，以jdbc:mysql://开头，后面跟着数据库的地址、端口和数据库名。在这里，数据库地址是localhost，端口是默认的3306，数据库名是test。字符编码设置为utf8。
username和password：指定连接数据库的用户名和密码，这里是使用root用户和419520密码进行连接。
initialSize：初始化连接数量，指定连接池中初始连接的数量，默认为5个。
maxActive：最大连接数，指定连接池中最大连接的数量，默认为10个。
maxWait：最大等待时间，指定获取数据库连接的最大等待时间，单位是毫秒，默认为3000毫秒（也就是3秒）。

这些配置参数指定了连接数据库所需的驱动类、数据库的URL、用户名、密码，以及连接池中的一些参数，如初始连接数量、最大连接数量和最大等待时间等。这些参数的配置可以根据实际需求进行修改。

本作品采用知识共享署名 4.0 国际许可协议进行许可