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

谁践踏了优雅 2024-03-16 18:55 15阅读 0赞

### 一、项目介绍 ###

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

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

### 二、项目结构 ###

![c372531de157572087bb84ae1e0e2687.png][]

### 三、前期准备 ###

#### 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

![0b2f92f450606e437654cad359198e3f.png][]

(2)创建数据表的代码

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

#### 3.配置tocamt ####

![880b854649a6818c11419ac4f4a0162f.png][]

![9f4a8d303bcdce618b66975101d7f78c.png][]

![28bf7adba492a2a1e236187b38b2e637.png][]

### 四、代码实现 ###

#### 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页面，用于展示一个登录页面。下面是对这段代码的分析：

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

1.  标题：页面展示了一个标题"请登录"，用于提醒用户进行登录操作。
2.  表单：页面添加了一个表单，用于用户输入账号和密码信息。
3.  输入框：表单中包含了两个输入框，分别是用于输入账号和密码的文本框。
4.  提交按钮：表单中还包含了一个"登录"按钮，用于提交表单数据。
5.  错误提示：页面在表单下方添加了一个段落，颜色为红色。该段落使用了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>

##### 添加页面的代码分析 #####

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

1.  表单：页面添加了一个表单，用于用户输入商品的相关信息。
2.  输入框：表单中包含了三个输入框，分别是商品名称、商品价格和商品描述的文本框。
3.  提交按钮：表单中还包含了一个"添加商品"按钮，用于提交表单数据。
4.  错误提示：页面在表单下方添加了一个段落，颜色为红色。该段落使用了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>

##### 展示页面的代码分析 #####

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

1.  添加商品链接：页面中包含了一个超链接"添加商品"，用于跳转到添加商品页面。
2.  表格：页面中使用了一个HTML表格来展示商品列表的信息。
3.  表头：表格有一个表头，包括了"名称"、“价格”、"描述"和"操作"四个列的标题。
4.  商品数据循环：使用了JSTL的<c:forEach>标签来循环遍历名为"data"的数据集合。在每次循环中，通过![Image 1][]\{c.price\}和$\{c.describe\}来获取当前循环到的商品的名称、价格和描述。
5.  删除和修改操作链接：在每行的最后一列，使用超链接展示了"删除"和"修改"两个操作链接，并通过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>

##### 修改的页面代码分析 #####

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

1.  表单：页面添加了一个表单，用于用户修改商品的相关信息。
2.  隐藏域：表单中包含了一个隐藏域，用于存储需要修改的商品的ID信息。
3.  输入框：表单中包含了三个输入框，分别是商品名称、商品价格和商品描述的文本框。其中，输入框的值通过`${requestScope.commodity.X}`来获取，使用EL表达式填充。
4.  提交按钮：表单中还包含了一个"修改商品"按钮，用于提交表单数据。
5.  错误提示：页面在表单下方添加了一个段落，颜色为红色。该段落使用了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类，用于表示商品对象。商品对象包含了以下属性：

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

该类提供了以下方法：

1.  构造方法：提供了多个构造方法，用于创建Commodity对象。
2.  toString方法：重写了Object类的toString方法，用于以字符串形式返回Commodity对象的属性值。
3.  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 #####

这段代码是一个简单的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 #####

这段代码是一个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、用户名、密码，以及连接池中的一些参数，如初始连接数量、最大连接数量和最大等待时间等。这些参数的配置可以根据实际需求进行修改。

[c372531de157572087bb84ae1e0e2687.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/c4de3fcdc7404950b9ff1d453886c8b6.png
[0b2f92f450606e437654cad359198e3f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/5d36a064a077410d96faa8358cc6aff4.png
[880b854649a6818c11419ac4f4a0162f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/1630ac01b9f346dfacc42d1841cbf454.png
[9f4a8d303bcdce618b66975101d7f78c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/32ce92633cbb4b76b44a0f0c9b30b5a2.png
[28bf7adba492a2a1e236187b38b2e637.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/5da1845e40f64ab59f3c984baa00d72f.png
[Image 1]: