使用javaweb项目实现对数据库的增、删、改、查操作

1、什么是javaweb

JavaWeb是指使用Java语言进行Web应用程序开发的技术，可以利用Java编写一些动态网页、交互式网页、企业级应用程序等。 JavaWeb技术主要包括Servlet、JSP、JDBC、JavaBean、JNDI、EJB、Web Services等。

Servlet是JavaWeb技术的核心组件之一，它是一个运行在Web服务器上的Java程序，可以接收HTTP请求并返回HTTP响应，常用于实现Web应用程序中的控制器或者中间件。通过Servlet，我们可以处理用户提交的表单数据、查询数据库、调用其他服务等操作，并将结果返回给客户端浏览器。

JSP（JavaServer Pages）是另一个重要的JavaWeb技术，它是一种在HTML页面内嵌入Java代码的技术，能够生成动态的Web页面。JSP文件会在Web服务器上编译成Servlet，并在客户端请求时被执行。在JSP中，我们可以使用Java代码、JSTL标签库和EL表达式等来处理数据和逻辑，从而实现动态页面的渲染。

JDBC（Java Database Connectivity）是Java提供的一种基于标准SQL语言访问关系型数据库的API，可以方便地进行数据库连接、查询、更新等操作。在JavaWeb应用程序中，我们通常使用JDBC与数据库进行交互，并获取所需的数据。

JavaBean是一种特殊的Java类，它通常包含一些属性和方法，并且遵循特定的命名规范。在JavaWeb应用程序中，我们可以定义JavaBean对象来封装数据和业务逻辑，并在JSP或Servlet中使用它们来实现模型层的功能。

总之，JavaWeb技术是基于Java语言的Web应用程序开发技术，提供了丰富的API和组件，能够方便地实现动态网页、企业级应用程序等功能。

2、如何使用javaweb

项目展示：

1、数据库的创建

#判断存在即删除数据库
drop database if exists mydb;
#创建数据库
create database mydb;
#使用数据库
use mydb;

#创建表
create table t_user
(
    uid int primary key auto_increment,
    username varchar(20),
    password varchar(20),
    phone varchar(11),
    address varchar(50)
);

insert into t_user(username,password,phone,address) values('张三','666','18965423548','南阳');
insert into t_user(username,password,phone,address) values('李四','333','18754263548','许昌');
insert into t_user(username,password,phone,address) values('小美','123','18565234759','信阳');

select * from t_user where username=? and password=?
select * from t_user;
select * from t_goods

create table t_goods
(
    gid int primary key auto_increment,
    gname varchar(20),
    price double,
    mark varchar(100)
);

DROP TABLE t_goods;

TRUNCATE TABLE t_goods;

insert into t_goods(gname,price,mark) values('泡面',4.5,'够香够辣就是这个味！');
insert into t_goods(gname,price,mark) values('火腿',8.5,'肉质细腻Q弹！');
insert into t_goods(gname,price,mark) values('雪碧',3.5,'清爽冰凉随心爽！');

select * from t_goods where gid=1

update t_goods set gname='3',price=4.3,mark='5'  where gid=1

select * from t_goods;

2、分层结构

导报

代码部分：

Bean层

商品实体类

package com.liu.Bean;

public class Goods {

    private Integer gid;
    private String gname;
    private Double price;
    private String mark;

    public Integer getGid() {
        return gid;
    }

    public void setGid(Integer gid) {
        this.gid = gid;
    }

    public String getGname() {
        return gname;
    }

    public void setGname(String gname) {
        this.gname = gname;
    }

    public Double getPrice() {
        return price;
    }

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

    public String getMark() {
        return mark;
    }

    public void setMark(String mark) {
        this.mark = mark;
    }

    @Override
    public String toString() {
        return "Good{" +
                "gid=" + gid +
                ", gname='" + gname + '\'' +
                ", price=" + price +
                ", mark='" + mark + '\'' +
                '}';
    }
}

用户实体类：

package com.liu.Bean;

public class User {
    private Integer uid;
    private String username;
    private String password;
    private String phone;
    private String address;

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", phone='" + phone + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

数据库操作部分

util层

package com.liu.util;

import java.sql.*;

public class JDBCUtil {
    static String driver = "com.mysql.cj.jdbc.Driver"; // 定义数据库驱动程序名称
    static String url = "jdbc:mysql:///mydb?useSSL=false&serverTimezone=UTC"; // 定义数据库连接URL
    static String username = "root"; // 定义数据库用户名
    static String password = "root"; // 定义数据库密码
    static Connection conn = null; // 声明Connection对象

    /**
     * 获取数据库连接对象
     * @return 数据库连接对象
     */
    public static Connection getCon(){
        try {
            Class.forName(driver); // 加载数据库驱动程序
            conn = DriverManager.getConnection(url,username,password); // 获取数据库连接对象
        } catch (Exception e) { // 处理异常
            throw new RuntimeException(e);
        }
        return conn; // 返回数据库连接对象
    }

    /**
     * 关闭ResultSet、PreparedStatement和Connection对象
     * @param rs ResultSet对象
     * @param pstm PreparedStatement对象
     * @param conn Connection对象
     * @throws SQLException SQL异常
     */
    public static void colse(ResultSet rs, PreparedStatement pstm,Connection conn) throws SQLException {
        if (rs != null) { // 判断ResultSet对象是否为null
            rs.close(); // 关闭ResultSet对象
        }
        if (pstm != null){ // 判断PreparedStatement对象是否为null
            pstm.close(); // 关闭PreparedStatement对象
        }
        if (conn != null){ // 判断Connection对象是否为null
            conn.close(); // 关闭Connection对象
        }
    }

    /**
     * 关闭PreparedStatement和Connection对象
     * @param pstm PreparedStatement对象
     * @param conn Connection对象
     * @throws SQLException SQL异常
     */
    public static void colse(PreparedStatement pstm,Connection conn) throws SQLException {
        if (pstm != null){ // 判断PreparedStatement对象是否为null
            pstm.close(); // 关闭PreparedStatement对象
        }
        if (conn != null){ // 判断Connection对象是否为null
            conn.close(); // 关闭Connection对象
        }
    }
}

dao层

package com.liu.dao.impl;

import com.liu.Bean.Goods;
import com.liu.util.JDBCUtil;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class GoodsDao {
    Goods goods = null; // 定义Goods对象
    Connection con = null; // 数据库连接对象
    PreparedStatement pstm = null; // 预编译语句对象
    ResultSet rs = null; // 结果集对象
    int twe = 0; // 操作结果

    /**
     * 查询所有商品信息
     * @return 商品列表
     */
    public List<Goods> shopping() {
        List<Goods> goodsList =new ArrayList<>(); // 创建商品列表
        try {
            con = JDBCUtil.getCon(); // 获取数据库连接
            String sql = "select  * from t_goods"; // SQL查询语句
            pstm = con.prepareStatement(sql); // 建立预编译语句
            rs = pstm.executeQuery(); // 执行查询操作
            while (rs.next()) { // 遍历结果集
                Goods goods = new Goods(); // 创建商品对象
                goods.setGid(rs.getInt("gid")); // 设置商品ID
                goods.setGname(rs.getString("gname")); // 设置商品名称
                goods.setPrice(rs.getDouble("price")); // 设置商品价格
                goods.setMark(rs.getString("mark")); // 设置商品备注
                goodsList.add(goods); // 将商品添加到列表中
            }
            for (Goods goods1 : goodsList) { // 遍历商品列表
                System.out.println(goods1); // 输出商品信息
            }

        } catch (Exception e) { // 处理异常
            e.printStackTrace();
        } finally { // 关闭资源
            try {
                JDBCUtil.colse(rs, pstm, con);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return goodsList; // 返回商品列表
    }

    /**
     * 添加商品信息
     * @param goods 商品对象
     * @return 操作结果
     */
    public int tianjia(Goods goods){
        con = JDBCUtil.getCon(); // 获取数据库连接
        String sql = "insert into t_goods(gname,price,mark)values(?,?,?)"; // SQL插入语句
        try {
            pstm = con.prepareStatement(sql); // 建立预编译语句
            pstm.setObject(1,goods.getGname()); // 设置商品名称
            pstm.setObject(2,goods.getPrice()); // 设置商品价格
            pstm.setObject(3,goods.getMark()); // 设置商品备注
            twe = pstm.executeUpdate(); // 执行插入操作
        } catch (Exception e) { // 处理异常
            e.printStackTrace();
        }finally { // 关闭资源
            try {
                JDBCUtil.colse(pstm,con);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return twe; // 返回操作结果
    }

    /**
     * 删除商品信息
     * @param id 商品ID
     * @return 操作结果
     */
    public int shanchu(int id){
        con = JDBCUtil.getCon(); // 获取数据库连接
        String sql = "delete from t_goods where gid = ?"; // SQL删除语句
        try {
            pstm = con.prepareStatement(sql); // 建立预编译语句
            pstm.setObject(1,id); // 设置商品ID
            twe = pstm.executeUpdate(); // 执行删除操作
        } catch (Exception e) { // 处理异常
            e.printStackTrace();
        }finally { // 关闭资源
            try {
                JDBCUtil.colse(pstm,con);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println(twe);
        return twe; // 返回操作结果
    }

    /**
     * 查询指定商品信息
     * @param gid 商品ID
     * @return 商品对象
     */
    public Goods xiugai1(int gid){
        Goods goods = null; // 创建商品对象
        con = JDBCUtil.getCon(); // 获取数据库连接
        String sql = "select  * from t_goods where gid = ?"; // SQL查询语句
        try {
            pstm = con.prepareStatement(sql); // 建立预编译语句
            pstm.setObject(1,gid); // 设置商品ID
            con = JDBCUtil.getCon();
            // 获取数据库连接
            rs = pstm.executeQuery(); // 执行查询操作
            if (rs.next()) { // 判断结果集是否有数据
                goods = new Goods(); // 创建商品对象
                goods.setGid(rs.getInt("gid")); // 设置商品ID
                goods.setGname(rs.getString("gname")); // 设置商品名称
                goods.setPrice(rs.getDouble("price")); // 设置商品价格
                goods.setMark(rs.getString("mark")); // 设置商品备注
            }
            System.out.println(goods); // 输出商品信息
        } catch (Exception e) { // 处理异常
            e.printStackTrace();
        } finally { // 关闭资源
            try {
                JDBCUtil.colse(rs, pstm, con);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return goods; // 返回商品对象
    }

    /**
     * 修改商品信息
     * @param goods 商品对象
     * @return 操作结果
     */
    public int xiugai2(Goods goods){
        System.out.println(goods); // 输出商品信息
        con = JDBCUtil.getCon(); // 获取数据库连接
        String sql = "update t_goods set gname=?,price=?,mark=? where gid = ?"; // SQL更新语句
        try {
            pstm = con.prepareStatement(sql); // 建立预编译语句
            pstm.setObject(1,goods.getGname()); // 设置商品名称
            pstm.setObject(2,goods.getPrice()); // 设置商品价格
            pstm.setObject(3,goods.getMark()); // 设置商品备注
            pstm.setObject(4,goods.getGid()); // 设置商品ID
            twe = pstm.executeUpdate(); // 执行更新操作
        } catch (Exception e) { // 处理异常
            e.printStackTrace();
        }finally { // 关闭资源
            try {
                JDBCUtil.colse(pstm,con);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return twe; // 返回操作结果
    }

    /**
     * 模糊查询商品信息
     * @param n 商品名称关键字
     * @return 商品列表
     */
    public List<Goods> mohuchaxun(String n){
        List<Goods> goodsList =new ArrayList<>(); // 创建商品列表
        try {
            con = JDBCUtil.getCon(); // 获取数据库连接
            String sql = "select  * from t_goods where gname like concat('%',?,'%')"; // SQL模糊查询语句
            pstm = con.prepareStatement(sql); // 建立预编译语句
            pstm.setObject(1,n); // 设置商品名称关键字
            rs = pstm.executeQuery(); // 执行查询操作
            while (rs.next()) { // 遍历结果集
                Goods goods = new Goods(); // 创建商品对象
                goods.setGid(rs.getInt("gid")); // 设置商品ID
                goods.setGname(rs.getString("gname")); // 设置商品名称
                goods.setPrice(rs.getDouble("price")); // 设置商品价格
                goods.setMark(rs.getString("mark")); // 设置商品备注
                goodsList.add(goods); // 将商品添加到列表中
            }
            for (Goods goods1 : goodsList) { // 遍历商品列表
                System.out.println(goods1); // 输出商品信息
            }

        } catch (Exception e) { // 处理异常
            e.printStackTrace();
        } finally { // 关闭资源
            try {
                JDBCUtil.colse(rs, pstm, con);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return goodsList; // 返回商品列表
    }
}

package com.liu.dao.impl;

import com.liu.Bean.User;
import com.liu.dao.UserDao;
import com.liu.util.JDBCUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class UserDaolmpl implements UserDao {
    Connection con = null; // 数据库连接对象
    User user = null; // 用户对象
    PreparedStatement pstm = null; // 预编译语句对象
    ResultSet rs = null; // 结果集对象
    int row = 0; // 操作结果

    // 实现用户登录功能
    public User Login(String username,String password){
        con = JDBCUtil.getCon(); // 获取数据库连接
        String sql = "select * from t_user where username = ? and password = ?"; // SQL查询语句
        try {
            pstm = con.prepareStatement(sql); // 建立预编译语句
            pstm.setObject(1,username); // 设置第一个占位符的值为用户名
            pstm.setObject(2,password); // 设置第二个占位符的值为密码

            rs = pstm.executeQuery(); // 执行查询操作
            if (rs.next()) { // 如果存在用户，则将查询结果存放到User对象中
                user = new User();
                user.setUid(rs.getInt("uid")); // 设置User对象的id属性
                user.setUsername(rs.getString("username")); // 设置User对象的用户名属性
                user.setPassword(rs.getString("password")); // 设置User对象的密码属性
                user.setPhone(rs.getString("phone")); // 设置User对象的电话号码属性
                user.setAddress(rs.getString("address")); // 设置User对象的地址属性

            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                JDBCUtil.colse(rs,pstm,con); // 关闭ResultSet、PreparedStatement和Connection对象
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return user; // 返回User对象
    }

    // 实现用户注册功能
    public int register(User user){
        con = JDBCUtil.getCon(); // 获取数据库连接
        String sql = "insert into t_user(username,password,phone,address)value(?,?,?,?)"; // SQL插入语句
        try {
            pstm = con.prepareStatement(sql); // 建立预编译语句
            pstm.setObject(1,user.getUsername()); // 设置第一个占位符的值为用户名
            pstm.setObject(2,user.getPassword()); // 设置第二个占位符的值为密码
            pstm.setObject(3,user.getPhone()); // 设置第三个占位符的值为电话号码
            pstm.setObject(4,user.getAddress()); // 设置第四个占位符的值为地址
            row = pstm.executeUpdate(); // 执行插入操作
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                JDBCUtil.colse(pstm,con); // 关闭PreparedStatement和Connection对象
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return row; // 返回操作结果
    }
}

dao层接口：

package com.liu.dao;

import com.liu.Bean.User;

public interface UserDao {
    User Login(String username,String password);
    int register(User user);
}

Filter层（过滤器）

package com.liu.Filter;

import com.liu.Bean.User;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

@WebFilter("/*")
public class Filters implements Filter {
    // 初始化方法
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化.........");
    }

    // 过滤方法
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest; // 转换ServletRequest为HttpServletRequest对象
        HttpServletResponse response = (HttpServletResponse) servletResponse; // 转换ServletResponse为HttpServletResponse对象

        String servletPath = request.getServletPath(); // 获取Servlet路径
        System.out.println(servletPath);

        HttpSession session = request.getSession(); // 获取Session对象
        User user = (User)session.getAttribute("user"); // 从Session中获取User对象
        System.out.println(user);

        if (servletPath.equals("/index.jsp") || servletPath.equals("/login.jsp") || servletPath.equals("/login") ||
                servletPath.equals("/register.jsp") || servletPath.equals("/register")){ // 允许访问的页面
            filterChain.doFilter(servletRequest,servletResponse); // 放行请求
        } else if (user != null) { // 如果用户已登录，则放行请求
            filterChain.doFilter(servletRequest,servletResponse);
        }else { // 否则重定向到登录页面
            response.sendRedirect("login.jsp");
        }
    }

    // 销毁方法
    @Override
    public void destroy() {
        System.out.println("销毁.........");
    }
}

servlet层

package com.liu.servlet;

import com.liu.Bean.User;
import com.liu.dao.impl.UserDaolmpl;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;

@WebServlet("/long")
public class Login extends HttpServlet {
    // 处理GET请求
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }

    // 处理POST请求
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setCharacterEncoding("utf-8"); // 设置响应编码
        request.setCharacterEncoding("utf-8"); // 设置请求编码

        response.setContentType("text/html;charset = utf-8"); // 设置响应类型

        String username = request.getParameter("username"); // 获取用户名
        String password = request.getParameter("password"); // 获取密码

        UserDaolmpl userDaolmpl = new UserDaolmpl(); // 创建UserDaoImpl对象
        User loging = userDaolmpl.Login(username,password); // 调用Login()方法进行登录校验，并返回User对象
        System.out.println(loging);

        if (loging != null){ // 如果登录成功，则将User对象存储到Session中，并重定向到商品列表Servlet
            HttpSession session = request.getSession();
            session.setAttribute("user",loging);
            request.getRequestDispatcher("ServletAllGoods").forward(request,response);
        }else { // 否则重定向到错误页面
            response.sendRedirect("error.jsp");
        }
    }
}

该类实现了HttpServlet接口，提供了用户登录功能。在doPost()方法中，首先设置请求编码、响应编码和响应类型，然后获取用户名和密码，创建UserDaoImpl对象，并调用Login()方法进行登录校验。如果登录成功，则将User对象存储到Session中，并重定向到商品列表Servlet；否则，重定向到错误页面。在实现该Servlet时，需要注意设置请求编码、响应编码和响应类型等信息，以及处理Login()方法返回的User对象和Session对象。

package com.liu.servlet;

import com.liu.Bean.Goods;
import com.liu.dao.impl.GoodsDao;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
import java.util.List;

@WebServlet("/mohu")
public class Mohu extends HttpServlet {
    // 处理GET请求
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }

    // 处理POST请求
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setCharacterEncoding("utf-8"); // 设置响应编码
        request.setCharacterEncoding("utf-8"); // 设置请求编码

        GoodsDao goodsDao = new GoodsDao(); // 创建GoodsDao对象
        String sousuo = request.getParameter("sousuo"); // 获取查询关键字
        System.out.println(sousuo);
        List<Goods> goodsList = goodsDao.mohuchaxun(sousuo); // 调用模糊查询方法进行查询，并返回查询结果列表
        System.out.println(goodsList);
        HttpSession session = request.getSession(); // 获取Session对象
        session.setAttribute("shopping",goodsList); // 将查询结果存储到Session中
        response.sendRedirect("goods.jsp"); // 重定向到商品列表页面
    }
}

该类实现了HttpServlet接口，提供了商品模糊查询功能。在doPost()方法中，首先设置请求编码和响应编码，然后创建GoodsDao对象并获取查询关键字，调用模糊查询方法进行查询，并将查询结果存储到Session中，最后重定向到商品列表页面。在实现该Servlet时，需要注意设置请求编码、响应编码和查询关键字等信息，以及处理模糊查询方法返回的查询结果列表和Session对象。

package com.liu.servlet;

import com.liu.Bean.User;
import com.liu.dao.impl.UserDaolmpl;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;

@WebServlet("/register")
public class Register extends HttpServlet {
    // 处理GET请求
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }

    // 处理POST请求
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        User user = new User(); // 创建User对象
        String username = request.getParameter("username"); // 获取用户名
        String password = request.getParameter("password"); // 获取密码
        String phone = request.getParameter("phone"); // 获取电话号码
        String address = request.getParameter("address"); // 获取地址
        user.setUsername(username); // 设置用户名
        user.setPassword(password); // 设置密码
        user.setPhone(phone); // 设置电话号码
        user.setAddress(address); // 设置地址
        System.out.println(user);

        UserDaolmpl userDaolmpl = new UserDaolmpl();  // 创建 UserDaoImpl 对象
        int row = userDaolmpl.register(user);  // 调用 UserDaoImpl 中的 register() 方法进行注册，返回受影响行数
        System.out.println(row);  // 输出注册结果

        if (row > 0){ // 如果注册成功，则重定向到登录页面
            request.getRequestDispatcher("login.jsp").forward(request,response);
        }else{ // 否则重定向到注册页面
            response.sendRedirect("register.jsp");
        }
    }
}

该类实现了HttpServlet接口，提供了用户注册功能。在doPost()方法中，首先创建User对象并获取用户名、密码、电话号码和地址等信息，然后设置User对象属性并输出到控制台，创建UserDaoImpl对象，并调用register()方法进行注册，返回受影响行数。如果注册成功，则重定向到登录页面；否则，重定向到注册页面。在实现该Servlet时，需要注意设置User对象属性、处理register()方法返回值以及重定向到正确的页面等信息。

package com.liu.servlet;

import com.liu.Bean.Goods;
import com.liu.dao.impl.GoodsDao;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
import java.util.List;

@WebServlet("/ServletAllGoods")
public class ServletAllGoods extends HttpServlet {
    // 处理GET请求
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }

    // 处理POST请求
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        GoodsDao goodsDao = new GoodsDao(); // 创建GoodsDao对象
        List<Goods> shopping = goodsDao.shopping(); // 调用查找所有商品方法，返回查询结果列表
        System.out.println(shopping);
        HttpSession httpSession = request.getSession(); // 获取Session对象
        httpSession.setAttribute("shopping",shopping); // 将查询结果存储到Session中
        response.sendRedirect("goods.jsp"); // 重定向到商品列表页面
    }
}

该类实现了HttpServlet接口，提供了查找所有商品功能。在doPost()方法中，首先创建GoodsDao对象并调用查找所有商品方法，获取商品列表；然后将商品列表存储到Session对象中，最后重定向到商品列表页面。在实现该Servlet时，需要注意处理查询结果列表和Session对象等信息。

package com.liu.servlet;

import com.liu.Bean.Goods;
import com.liu.dao.impl.GoodsDao;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;

@WebServlet("/shanchu")
public class Shanchu extends HttpServlet {
    // 处理GET请求
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }

    // 处理POST请求
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        int gid = Integer.parseInt(request.getParameter("gid")); // 获取商品ID
        GoodsDao goodsDao =new GoodsDao(); // 创建GoodsDao对象
        int i = goodsDao.shanchu(gid); // 调用删除商品方法，返回受影响行数
        if (i>0){ // 如果删除成功，则重定向到商品列表Servlet
            request.getRequestDispatcher("ServletAllGoods").forward(request,response);
        }else { // 否则转发到错误页面并输出错误信息
            request.setAttribute("error_msg","删除失败！！！");
            request.getRequestDispatcher("error.jsp").forward(request,response);
        }
    }
}

该类实现了HttpServlet接口，提供了商品删除功能。在doPost()方法中，首先获取商品ID，创建GoodsDao对象并调用删除商品方法，返回受影响行数。如果删除成功，则重定向到商品列表Servlet；否则，转发到错误页面并输出错误信息。在实现该Servlet时，需要注意处理商品ID和删除结果等信息，以及重定向或转发到正确的页面。

package com.liu.servlet;

import com.liu.Bean.Goods;
import com.liu.dao.impl.GoodsDao;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;

@WebServlet("/Tianjia")
public class Tianjia extends HttpServlet {
    // 处理GET请求
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }

    // 处理POST请求
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setCharacterEncoding("utf-8"); // 设置响应编码
        request.setCharacterEncoding("utf-8"); // 设置请求编码
        response.setContentType("text/html;charset = utf-8"); // 设置响应类型

        Goods goods = new Goods(); // 创建Goods对象
        goods.setGname(request.getParameter("gname")); // 获取商品名称并设置到Goods对象中
        goods.setPrice(Double.parseDouble(request.getParameter("price"))); // 获取商品价格并设置到Goods对象中
        goods.setMark(request.getParameter("mark")); // 获取商品描述并设置到Goods对象中

        GoodsDao goodsDao = new GoodsDao(); // 创建GoodsDao对象
        int row = goodsDao.tianjia(goods); // 调用添加商品方法，返回受影响行数

        if (row>0){ // 如果添加成功，则重定向到商品列表Servlet
            request.getRequestDispatcher("ServletAllGoods").forward(request,response);
        }else{ // 否则转发到错误页面并输出错误信息
            request.setAttribute("error_msg","添加失败！！！");
            request.getRequestDispatcher("error.jsp").forward(request,response);
        }
    }
}

该类实现了HttpServlet接口，提供了商品添加功能。在doPost()方法中，首先设置响应编码、请求编码和响应类型，然后创建Goods对象并获取商品名称、价格和描述信息，并将这些信息设置到Goods对象中。接着创建GoodsDao对象并调用添加商品方法，返回受影响行数。如果添加成功，则重定向到商品列表Servlet；否则，转发到错误页面并输出错误信息。在实现该Servlet时，需要注意处理请求参数、添加结果等信息，以及重定向或转发到正确的页面。

package com.liu.servlet;

import com.liu.Bean.Goods;
import com.liu.dao.impl.GoodsDao;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;

@WebServlet("/xiugai")
public class Xiugai extends HttpServlet {
    // 处理GET请求
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }

    // 处理POST请求
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setCharacterEncoding("utf-8"); // 设置响应编码
        request.setCharacterEncoding("utf-8"); // 设置请求编码
        int gid = Integer.parseInt(request.getParameter("gid")); // 获取商品ID并转换为整型

        GoodsDao goodsDao = new GoodsDao(); // 创建GoodsDao对象
        Goods goods = goodsDao.xiugai1(gid); // 调用查找商品方法，返回查询结果对象

        if (goods!=null){ // 如果查询结果不为空，则将查询结果存储到request中，并转发到修改页面
            request.setAttribute("goods",goods);
            request.getRequestDispatcher("xiugai.jsp").forward(request,response);
        }else { // 否则转发到错误页面并输出错误信息
            request.setAttribute("error_msg","修改错误！！！");
            request.getRequestDispatcher("error.jsp").forward(request,response);
        }
    }
}

该类实现了HttpServlet接口，提供了查找商品信息功能。在doPost()方法中，首先设置响应编码、请求编码和获取商品ID，并将商品ID转换为整型。然后创建GoodsDao对象并调用查找商品方法，返回查询结果对象。如果查询结果不为空，则将查询结果存储到request中，并转发到修改页面；否则，转发到错误页面并输出错误信息。在实现该Servlet时，需要注意处理请求参数、查询结果等信息，以及重定向或转发到正确的页面。

package com.liu.servlet;

import com.liu.Bean.Goods;
import com.liu.dao.impl.GoodsDao;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;

@WebServlet("/xiugai2")
public class Xiugai2 extends HttpServlet {
    // 处理GET请求
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }

    // 处理POST请求
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setCharacterEncoding("utf-8"); // 设置响应编码
        request.setCharacterEncoding("utf-8"); // 设置请求编码

        Goods goods = new Goods(); // 创建Goods对象
        goods.setGid(Integer.parseInt(request.getParameter("gid"))); // 获取商品ID并设置到Goods对象中
        goods.setGname(request.getParameter("gname")); // 获取商品名称并设置到Goods对象中
        goods.setPrice(Double.parseDouble(request.getParameter("price"))); // 获取商品价格并设置到Goods对象中
        goods.setMark(request.getParameter("mark")); // 获取商品描述并设置到Goods对象中

        GoodsDao goodsDao = new GoodsDao(); // 创建GoodsDao对象
        int row = goodsDao.xiugai2(goods); // 调用修改商品方法，返回受影响行数

        if (row > 0 ){ // 如果修改成功，则重定向到商品列表Servlet
            request.getRequestDispatcher("ServletAllGoods").forward(request,response);
        }else { // 否则转发到错误页面并输出错误信息
            request.setAttribute("error_msg","修改错误！！！");
            request.getRequestDispatcher("error.jsp").forward(request,response);
        }
    }
}

该类实现了HttpServlet接口，提供了商品修改功能。在doPost()方法中，首先设置响应编码、请求编码，然后创建Goods对象并获取商品ID、名称、价格和描述信息，并将这些信息设置到Goods对象中。接着创建GoodsDao对象并调用修改商品方法，返回受影响行数。如果修改成功，则重定向到商品列表Servlet；否则，转发到错误页面并输出错误信息。在实现该Servlet时，需要注意处理请求参数、修改结果等信息，以及重定向或转发到正确的页面。

页面代码

web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>Login</servlet-name>
        <servlet-class>com.liu.servlet.Login</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Login</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>
</web-app>

页面文件

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>欢迎光临</title>
</head>
<body>
    <h2>${error_msg}</h2>
    <a href="login.jsp">返回重试</a>
</body>
</html>

<%@ page import="com.liu.Bean.Goods" %>
<%@ page import="java.util.List" %><%--
  Created by IntelliJ IDEA.
  User: pai'meng
  Date: 2023/2/22
  Time: 11:51
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri ="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
    <title>购物</title>
</head>
<body>
    <h2>欢迎来自${user.address}的${user.username}访问主页</h2>

        <table>
            <form action="mohu" method="get">
                <input type="text" name="sousuo" value="" >
                <input type="submit" name="搜索2" value="搜索">
            </form>
            <thead>
                <tr>
                    <th>商品编号</th>
                    <th>商品名字</th>
                    <th>商品价格</th>
                    <th>商品介绍</th>
                </tr>
            </thead>
            <tbody id="list">
            <c:forEach items="${shopping}" var="sho">
                <tr>
                    <td>${sho.gid}</td>
                    <td>${sho.gname}</td>
                    <td>${sho.price}</td>
                    <td>${sho.mark}</td>
                    <td><a href="shanchu?gid=${sho.gid}">删除</a></td>
                    <td><a href="xiugai?gid=${sho.gid}">修改</a></td>
                </tr>

            </c:forEach>
            <a href="tianjia.jsp">添加</a>
            </tbody>
</table>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>主页</title>
  </head>
  <body>
  <h2>欢迎来到主页</h2>
  <a href="login.jsp">登录</a>
  <a href="register.jsp">注册</a>
  </body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
</head>
<body>
    <form action="login" method="get">
        请输入账号：<input type="text" name="username"><br>
        请输入密码：<input type="password" name="password"><br>

        <input type="submit" value="确定">
        <a href="register.jsp">没有账户？点击注册</a>

    </form>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>注册</title>
</head>
<body>
<form action="register" method="post">
    请输入注册账号：<input type="text" name="username"><br>
    请输入注册密码：<input type="password" name="password"><br>
    请输入电话：<input type="text" name="phone"><br>
    请输入地址：<input type="text" name="address"><br>
    <input type="submit" value="确定">
    <a href="login.jsp">已有账号？点击登录</a>
</form>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>添加商品</title>
</head>
<body>
<form action="Tianjia" method="post">
  请输入商品名称：<input type="text" name="gname"><br>
  请输入商品价格：<input type="number" name="price"><br>
  请输入商品介绍：<input type="text" name="mark"><br>
  <input type="submit" value="添加">
</form>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>修改页面</title>
</head>
<body>
    <form action="xiugai2" method="post">
<%--        <c:forEach items="goods" var="goods"></c:forEach>--%>
        商品编号：<input type="text" name="gid" value="${goods.gid}" placeholder="商品编号" readonly = readonly><br>
        商品名称：<input type="text" name="gname" value="${goods.gname}" placeholder="商品名称"><br>
        商品价格：<input type="number" name="price" value="${goods.price}" placeholder="商品价格"><br>
        商品介绍：<input type="text" name="mark" value="${goods.mark}" placeholder="商品介绍"><br>
        <input type="submit" value="确定">
    </form>
</body>
</html>

效果展示