使用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>
效果展示
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
THE END
二维码