/**
 * 数据库连接工具类。
 */
public class ConnectionUtils {

    // 数据库 URL
    private static final String URL= "jdbc:mysql://localhost:3306/java196";
    
    // 数据库用户名
    public static final String USERNAME = "root";
    
    // 数据库密码
    public static final String PASSWORD = "root";
    
    // 静态块加载 MySQL JDBC 驱动程序
    static {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            // 如果找不到 MySQL JDBC 驱动程序，则抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取数据库连接的方法。
     *
     * @return 表示数据库连接的 Connection 对象。
     * @throws Exception 如果建立数据库连接时出现错误。
     */
    public static Connection getConnection() throws Exception {
        // 使用 DriverManager 建立连接
        Connection connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
        return connection;
    }
}

public class T1entity {
 //只需要写入数据有多少个类型就行了
    //我这只写了两个所以说我只要写入id和f1
    private int id;
    private String f1;
    
//以下都是IDEA自动生成
    public T1entity(int id) {
        this.id = id;
    }

    public T1entity(String f1) {
        this.f1 = f1;
    }

    public T1entity() {

    }

    public int getId() {
        return id;
    }

    public String getF1() {
        return f1;
    }

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

    public void setF1(String f1) {
        this.f1 = f1;
    }

    @Override
    public String toString() {
        return "T1entity{" +
                "id=" + id +
                ", f1='" + f1 + '\'' +
                '}';
    }
}

List<T1Entity> list = new ArrayList<>();
// 创建一个空列表用于存储T1Entity对象

// 通过ConnectionUtils类获取数据库连接
Connection connection = ConnectionUtils.getConnection();

// 构建SQL查询语句
String sql = "select id,f1 from t1";

// 创建PreparedStatement对象
PreparedStatement pstmt = connection.prepareStatement(sql);

// 执行SQL查询，获取结果集
ResultSet rs = pstmt.executeQuery();

// 遍历结果集，将数据添加到列表中
while (rs.next()){
    T1Entity t1 = new T1Entity();
    t1.setId(rs.getInt(1));
    t1.setF1(rs.getString(2));
    list.add(t1);
}

// 关闭数据库连接
connection.close();

// 返回结果列表
return list;

public List<T1Entity> getAll() throws Exception {
        return  new T1DaoImpl().getAll();
    }

@WebServlet("/list")
public class T1ListServlet extends HttpServlet {
    // service方法用于处理HTTP请求
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 创建T1Service对象
        T1Service service = new T1Service();
        try {
            // 调用T1Service的getAll方法获取T1entity对象列表
            List<T1entity> list = service.getAll();
            // 将获取的对象列表设置为请求属性
            req.setAttribute("list", list);
            // 转发请求到"/WEB-INF/t1/list.jsp"页面
            req.getRequestDispatcher("/WEB-INF/t1/list.jsp").forward(req, resp);
        } catch (Exception e) {
            // 捕获异常并抛出RuntimeException
            throw new RuntimeException(e);
        }
    }
}

java
Copy code
@WebServlet("/detele")
public class T1LsitDetelelmpl extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 从请求中获取名为 "id" 的参数，该参数包含待删除对象的标识符
        String id = req.getParameter("id");
        // 将获取的 id 参数转换为整数类型
        int idVal = Integer.parseInt(id);
        // 创建 T1Service 的实例
        T1Service t1Service = new T1Service();
        try {
            // 调用 T1Service 的 delete 方法，删除指定 id 对应的对象
            t1Service.delete(idVal);
            // 将响应重定向到 "/Projact_war/list" 页面，以展示删除后的列表
            resp.sendRedirect("/Projact_war/list");
        } catch (Exception e) {
            // 捕获可能抛出的异常，并将其包装成 RuntimeException 抛出
            throw new RuntimeException(e);
        }
    }
}

/**
 * 根据给定的 id 删除数据库中的数据项。
 *
 * @param idVal 待删除数据项的标识符
 * @throws Exception 如果删除操作失败，抛出异常
 */
public void deleteById(int idVal) throws Exception { 
    // 构建 SQL 删除语句
    String sql = "delete from test1 where id=?";
    try (
        // 获取数据库连接
        Connection conn = ConnectionUtlil.getConnection();
        // 创建 PreparedStatement 对象，预编译 SQL 语句
        PreparedStatement stmt = conn.prepareStatement(sql)
    ) {
        // 设置 SQL 语句中的参数值
        stmt.setInt(1, idVal);
        // 执行 SQL 语句，删除数据项
        stmt.executeUpdate();
    }
}

@WebServlet("/insert")
public class T1insertlmpl extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 从请求中获取名为 "xxx" 的参数，即用户输入的内容
        String t1 = req.getParameter("xxx");

        // 创建 T1Service 的实例
        T1Service t1Service = new T1Service();
        try {
            // 调用服务类的 getAdd 方法，将用户输入的内容添加到相应的数据集中
            t1Service.getAdd(t1);
            // 将响应重定向到展示类，以便展示更新后的数据
            resp.sendRedirect("/Projact_war/list");
        } catch (SQLException e) {
            // 捕获可能的 SQL 异常并抛出 RuntimeException
            throw new RuntimeException(e);
        }
    }
}

/**
 * 将给定的内容添加到数据集中。
 *
 * @param t1 待添加的内容
 * @throws SQLException 如果添加操作失败，抛出 SQLException 异常
 */
public void getAdd(String t1) throws SQLException {
    // 将 t1 的内容传递给 dam 类的 getAdd 方法进行处理
    dam.getAdd(t1);
}

    public void getAdd(String t1) throws SQLException {
//        //写添加的sql语句
        String sql="Insert into test1(f1) values(?)";
//        //连接数据库
        try(Connection conn =ConnectionUtlil.getConnection();
//        //访问数据库
        PreparedStatement stmt = conn.prepareStatement(sql)){
//        //将t1放到sql语句中的问号(?)
        stmt.setString(1,t1);
//        //返回的一个集合
        stmt.executeUpdate();
        }
    }

@WebServlet("/edit")
public class T1EditServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 从请求参数中获取ID值，并转换为整数类型
        int id = Integer.parseInt(req.getParameter("id"));

        // 创建T1Service对象
        T1Service t1Service = new T1Service();
        T1entity t1Entity = null;

        try {
            // 根据ID从数据库中获取T1entity对象
            t1Entity = t1Service.getById(id);
            // 将获取的T1entity对象设置为请求属性
            req.setAttribute("t1", t1Entity);
            // 转发请求到"/WEB-INF/t1/edit.jsp"页面
            req.getRequestDispatcher("/WEB-INF/t1/edit.jsp").forward(req, resp);
        } catch (SQLException e) {
            // 捕获SQLException异常并抛出RuntimeException
            throw new RuntimeException(e);
        } catch (Exception e) {
            // 捕获其他异常并抛出RuntimeException
            throw new RuntimeException(e);
        }
    }
}

/**
 * 根据ID从数据库中获取T1entity对象
 * @param id 要获取的T1entity对象的ID
 * @return 返回获取到的T1entity对象
 * @throws Exception 如果获取过程中发生异常，则抛出异常
 */
public T1entity getById(int id) throws Exception {
    // 调用数据访问层(DAO)的getById方法，根据ID从数据库中获取T1entity对象并返回
    return dam.getById(id);
}

public T1entity getById(int id) throws SQLException {
    // 创建一个新的 T1entity 对象
    T1entity t1 = new T1entity();
    
    // 准备 SQL 查询语句，查询指定 ID 和字段 f1 的数据
    String sql = "select id, f1 from test1 where id=?";
    
    // 获取数据库连接
    Connection conn = ConnectionUtlil.getConnection();
    
    // 创建 PreparedStatement 对象，用于执行带参数的 SQL 语句
    PreparedStatement pstmt = conn.prepareStatement(sql);
    
    // 设置查询参数为传入的 ID
    pstmt.setInt(1, id);
    
    // 执行查询，获取结果集
    ResultSet rs = pstmt.executeQuery();
    
    // 遍历结果集，将查询到的数据设置到 T1entity 对象中
    while (rs.next()) {
        // 通过结果集获取 ID 并设置到 T1entity 对象中
        t1.setId(rs.getInt(1));
        
        // 通过结果集获取字段 f1 的值并设置到 T1entity 对象中
        t1.setF1(rs.getString(2));
    }
    
    // 关闭结果集、PreparedStatement 和连接
    rs.close();
    pstmt.close();
    conn.close();
    
    // 返回获取到的 T1entity 对象
    return t1;
}

// 根据ID从数据库中获取T1entity对象
           t1Entity = t1Service.getById(id);
           // 将获取的T1entity对象设置为请求属性
           req.setAttribute("t1", t1Entity);
           // 转发请求到"/WEB-INF/t1/edit.jsp"页面
           req.getRequestDispatcher("/WEB-INF/t1/edit.jsp").forward(req, resp);

<!-- 表单开始，提交到 "/Projact_war/update" 路径 -->
<form action="/Projact_war/update">

    <!-- 隐藏域，用于传递 T1entity 对象的 ID 值 -->
    <input type="hidden" name="id" value="<%=((T1entity)request.getAttribute("t1")).getId()%>">

    <!-- 文本框，用于显示和编辑 T1entity 对象的 f1 属性值 -->
    <input type="text" name="f1" value="<%=((T1entity)request.getAttribute("t1")).getF1()%>">

    <!-- 提交按钮，用于保存用户对 f1 属性的修改 -->
    <input type="submit" value="保存">

</form>

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("/update")
public class T1Updatelmpl extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 从请求参数中获取 ID 和字段 f1 的值
        int id = Integer.parseInt(req.getParameter("id"));
        String f1 = req.getParameter("f1");

        // 创建一个新的 T1entity 对象，并设置 ID 和字段 f1 的值
        T1entity t1entity = new T1entity();
        t1entity.setId(id);
        t1entity.setF1(f1);

        // 创建 T1Service 实例用于执行更新操作
        T1Service t1ServicE = new T1Service();

        try {
            // 调用 T1Service 的更新方法，传入 T1entity 对象
            t1ServicE.update(t1entity);
            
            // 更新成功后重定向到列表页面
            resp.sendRedirect("/Projact_war/list");
        } catch (SQLException e) {
            // 捕获并抛出运行时异常
            throw new RuntimeException(e);
        }

    }
}

public void update(T1entity t1entity) throws SQLException {
    // 调用 dam 的 update 方法来更新传入的 T1entity 对象
    dam.update(t1entity);
}

// 定义 SQL 更新语句，设置字段 f1 为指定值，根据 ID 进行更新
String sql = "update test1 set f1=? where id=?";

try (
    // 获取数据库连接
    Connection connection = ConnectionUtlil.getConnection();
    // 创建 PreparedStatement 对象，用于执行带参数的 SQL 更新语句
    PreparedStatement stmt = connection.prepareStatement(sql);
) {
    // 设置 SQL 语句中的参数，第一个参数为字段 f1 的值，第二个参数为 ID 的值
    stmt.setString(1, t1entity.getF1());
    stmt.setInt(2, t1entity.getId());
    
    // 执行更新操作
    stmt.executeUpdate();
} catch (SQLException e) {
    // 捕获并处理 SQL 异常
    e.printStackTrace();
}