• 【JavaWeb】-- Servlet获取网页数据并传入到数据库

    Servlet（Server Applet）是Java Servlet的简称，称为小服务程序或服务连接器，用Java编写的服务器端程序，具有独立于平台和协议的特性，主要功能在于交互式地浏览和生成数据，生成动态Web内容。

    web获取参数到数据库的原理：

    Web（用户）首先请求http页面，web服务器对其响应显示页面；

    用户点击表单提交按钮，调用（request）服务器端的add（表单中定义的action），add调用java类；

    java类中包括获取用户发送的数据操作、调用DAO中的方法添加到数据库、控制台打印。

    下面使用idea2022企业版+mysql8。

    代码实现

    下面以以下表格为题示例。

     

    一、创建数据库表

    1. CREATE TABLE 't_fruit' (
    2.   'fid' INT(11) NOT NULL AUTO_INCREMENT,
    3.   'fname' VARCHAR(20) NOT NULL,
    4.   'price' INT(11) DEFAULT NULL,
    5.   'fcount' INT(11) DEFAULT NULL,
    6.   'remark' VARCHAR(50) DEFAULT NULL,
    7.   PRIMARY KEY ('fid')
    8. ) ENGINE=INNODB AUTO_INCREMENT=33 DEFAULT CHARSET=utf8;

    二、实现操作数据库

    1、加载驱动

    创建lib文件，将驱动文件复制进去并将文件添加为库。

     2、DAO

    使用DAO对数据库操作。

    文件结构：

     BaseDAO类

    其中，URL   3306/ 后面为数据库名字；

    USER 为用户名；

    PWD为密码；

    注意修改！

    1. package com.fruit.dao.base;
    2. import java.lang.reflect.Field;
    3. import java.lang.reflect.ParameterizedType;
    4. import java.lang.reflect.Type;
    5. import java.sql.*;
    6. import java.util.ArrayList;
    7. import java.util.List;
    8. public abstract class BaseDAO {
    9.     public final String DRIVER = "com.mysql.jdbc.Driver" ;
    10.     public final String URL = "jdbc:mysql://localhost:3306/javaweb?useUnicode=true&characterEncoding=utf-8&useSSL=false";
    11.     public final String USER = "root";
    12.     public final String PWD = "ad" ;
    13.  
    14.     protected Connection conn ;
    15.     protected PreparedStatement psmt ;
    16.     protected ResultSet rs ;
    17.  
    18.     //T的Class对象
    19.     private Class entityClass ;
    20.  
    21.     public BaseDAO(){
    22.         //getClass() 获取Class对象，当前我们执行的是new FruitDAOImpl() , 创建的是FruitDAOImpl的实例
    23.         //那么子类构造方法内部首先会调用父类（BaseDAO）的无参构造方法
    24.         //因此此处的getClass()会被执行，但是getClass获取的是FruitDAOImpl的Class
    25.         //所以getGenericSuperclass()获取到的是BaseDAO的Class
    26.         Type genericType = getClass().getGenericSuperclass();
    27.         //ParameterizedType 参数化类型
    28.         Type[] actualTypeArguments = ((ParameterizedType) genericType).getActualTypeArguments();
    29.         //获取到的中的T的真实的类型
    30.         Type actualType = actualTypeArguments[0];
    31.         try {
    32.             entityClass = Class.forName(actualType.getTypeName());
    33.         } catch (ClassNotFoundException e) {
    34.             e.printStackTrace();
    35.         }
    36.     }
    37.  
    38.     protected Connection getConn(){
    39.         try {
    40.             //1.加载驱动
    41.             Class.forName(DRIVER);
    42.             //2.通过驱动管理器获取连接对象
    43.             return DriverManager.getConnection(URL, USER, PWD);
    44.         } catch (ClassNotFoundException | SQLException e) {
    45.             e.printStackTrace();
    46.         }
    47.         return null ;
    48.     }
    49.  
    50.     protected void close(ResultSet rs , PreparedStatement psmt , Connection conn){
    51.         try {
    52.             if (rs != null) {
    53.                 rs.close();
    54.             }
    55.             if(psmt!=null){
    56.                 psmt.close();
    57.             }
    58.             if(conn!=null && !conn.isClosed()){
    59.                 conn.close();
    60.             }
    61.         } catch (SQLException e) {
    62.             e.printStackTrace();
    63.         }
    64.     }
    65.  
    66.     //给预处理命令对象设置参数
    67.     private void setParams(PreparedStatement psmt , Object... params) throws SQLException {
    68.         if(params!=null && params.length>0){
    69.             for (int i = 0; i < params.length; i++) {
    70.                 psmt.setObject(i+1,params[i]);
    71.             }
    72.         }
    73.     }
    74.  
    75.     //执行更新，返回影响行数
    76.     protected int executeUpdate(String sql , Object... params){
    77.         boolean insertFlag = false ;
    78.         insertFlag = sql.trim().toUpperCase().startsWith("INSERT");
    79.         try {
    80.             conn = getConn();
    81.             if(insertFlag){
    82.                 psmt = conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);
    83.             }else {
    84.                 psmt = conn.prepareStatement(sql);
    85.             }
    86.             setParams(psmt,params);
    87.             int count = psmt.executeUpdate() ;
    88.  
    89.             rs = psmt.getGeneratedKeys();
    90.             if(rs.next()){
    91.                 return ((Long)rs.getLong(1)).intValue();
    92.             }
    93.             return count ;
    94.         } catch (SQLException e) {
    95.             e.printStackTrace();
    96.         }finally {
    97.             close(rs,psmt,conn);
    98.         }
    99.         return 0;
    100.     }
    101.  
    102.     //通过反射技术给obj对象的property属性赋propertyValue值
    103.     private void setValue(Object obj ,  String property , Object propertyValue){
    104.         Class clazz = obj.getClass();
    105.         try {
    106.             //获取property这个字符串对应的属性名 ， 比如 "fid"  去找 obj对象中的 fid 属性
    107.             Field field = clazz.getDeclaredField(property);
    108.             if(field!=null){
    109.                 field.setAccessible(true);
    110.                 field.set(obj,propertyValue);
    111.             }
    112.         } catch (NoSuchFieldException | IllegalAccessException e) {
    113.             e.printStackTrace();
    114.         }
    115.     }
    116.  
    117.     //执行复杂查询，返回例如统计结果
    118.     protected Object[] executeComplexQuery(String sql , Object... params){
    119.         try {
    120.             conn = getConn() ;
    121.             psmt = conn.prepareStatement(sql);
    122.             setParams(psmt,params);
    123.             rs = psmt.executeQuery();
    124.  
    125.             //通过rs可以获取结果集的元数据
    126.             //元数据：描述结果集数据的数据 , 简单讲，就是这个结果集有哪些列，什么类型等等
    127.  
    128.             ResultSetMetaData rsmd = rs.getMetaData();
    129.             //获取结果集的列数
    130.             int columnCount = rsmd.getColumnCount();
    131.             Object[] columnValueArr = new Object[columnCount];
    132.             //6.解析rs
    133.             if(rs.next()){
    134.                 for(int i = 0 ; i
    135.                     Object columnValue = rs.getObject(i+1);     //33    苹果      5
    136.                     columnValueArr[i]=columnValue;
    137.                 }
    138.                 return columnValueArr ;
    139.             }
    140.         } catch (SQLException e) {
    141.             e.printStackTrace();
    142.         } finally {
    143.             close(rs,psmt,conn);
    144.         }
    145.         return null ;
    146.     }
    147.  
    148.     //执行查询，返回单个实体对象
    149.     protected T load(String sql , Object... params){
    150.         try {
    151.             conn = getConn() ;
    152.             psmt = conn.prepareStatement(sql);
    153.             setParams(psmt,params);
    154.             rs = psmt.executeQuery();
    155.  
    156.             //通过rs可以获取结果集的元数据
    157.             //元数据：描述结果集数据的数据 , 简单讲，就是这个结果集有哪些列，什么类型等等
    158.  
    159.             ResultSetMetaData rsmd = rs.getMetaData();
    160.             //获取结果集的列数
    161.             int columnCount = rsmd.getColumnCount();
    162.             //6.解析rs
    163.             if(rs.next()){
    164.                 T entity = (T)entityClass.newInstance();
    165.  
    166.                 for(int i = 0 ; i
    167.                     String columnName = rsmd.getColumnName(i+1);            //fid   fname   price
    168.                     Object columnValue = rs.getObject(i+1);     //33    苹果      5
    169.                     setValue(entity,columnName,columnValue);
    170.                 }
    171.                 return entity ;
    172.             }
    173.         } catch (SQLException e) {
    174.             e.printStackTrace();
    175.         } catch (IllegalAccessException e) {
    176.             e.printStackTrace();
    177.         } catch (InstantiationException e) {
    178.             e.printStackTrace();
    179.         } finally {
    180.             close(rs,psmt,conn);
    181.         }
    182.         return null ;
    183.     }
    184.  
    185.  
    186.     //执行查询，返回List
    187.     protected List executeQuery(String sql , Object... params){
    188.         List list = new ArrayList<>();
    189.         try {
    190.             conn = getConn() ;
    191.             psmt = conn.prepareStatement(sql);
    192.             setParams(psmt,params);
    193.             rs = psmt.executeQuery();
    194.  
    195.             //通过rs可以获取结果集的元数据
    196.             //元数据：描述结果集数据的数据 , 简单讲，就是这个结果集有哪些列，什么类型等等
    197.  
    198.             ResultSetMetaData rsmd = rs.getMetaData();
    199.             //获取结果集的列数
    200.             int columnCount = rsmd.getColumnCount();
    201.             //6.解析rs
    202.             while(rs.next()){
    203.                 T entity = (T)entityClass.newInstance();
    204.  
    205.                 for(int i = 0 ; i
    206.                     String columnName = rsmd.getColumnName(i+1);            //fid   fname   price
    207.                     Object columnValue = rs.getObject(i+1);     //33    苹果      5
    208.                     setValue(entity,columnName,columnValue);
    209.                 }
    210.                 list.add(entity);
    211.             }
    212.         } catch (SQLException e) {
    213.             e.printStackTrace();
    214.         } catch (IllegalAccessException e) {
    215.             e.printStackTrace();
    216.         } catch (InstantiationException e) {
    217.             e.printStackTrace();
    218.         } finally {
    219.             close(rs,psmt,conn);
    220.         }
    221.         return list ;
    222.     }
    223. }

    FruitDAOImpl类

    1. package com.fruit.dao.impl;
    2. import com.fruit.dao.FruitDAO;
    3. import com.fruit.dao.base.BaseDAO;
    4. import com.fruit.pojo.Fruit;
    5.  
    6. import java.util.List;
    7.  
    8. public class FruitDAOImpl extends BaseDAO<Fruit> implements FruitDAO {
    9.     @Override
    10.     public List<Fruit> getFruitList() {
    11.         return super.executeQuery("select * from t_fruit");
    12.     }
    13.  
    14.     @Override
    15.     public boolean addFruit(Fruit fruit) {
    16.         String sql = "insert into t_fruit values(0,?,?,?,?)";
    17.         int count = super.executeUpdate(sql,fruit.getFname(),fruit.getPrice(),fruit.getFcount(),fruit.getRemark()) ;
    18.         //insert语句返回的是自增列的值，而不是影响行数
    19.         //System.out.println(count);
    20.         return count>0;
    21.     }
    22.  
    23.     @Override
    24.     public boolean updateFruit(Fruit fruit) {
    25.         String sql = "update t_fruit set fcount = ? where fid = ? " ;
    26.         return super.executeUpdate(sql,fruit.getFcount(),fruit.getFid())>0;
    27.     }
    28.  
    29.     @Override
    30.     public Fruit getFruitByFname(String fname) {
    31.         return super.load("select * from t_fruit where fname like ? ",fname);
    32.     }
    33.  
    34.     @Override
    35.     public boolean delFruit(String fname) {
    36.         String sql = "delete from t_fruit where fname like ? " ;
    37.         return super.executeUpdate(sql,fname)>0;
    38.     }
    39. }

    FruitDAO抽象类

    1. import com.fruit.pojo.Fruit;
    2. import java.util.List;
    3. public interface FruitDAO {
    4.     //查询库存列表
    5.     List getFruitList();
    6.  
    7.     //新增库存
    8.     boolean addFruit(Fruit fruit);
    9.  
    10.     //修改库存
    11.     boolean updateFruit(Fruit fruit);
    12.  
    13.     //根据名称查询特定库存
    14.     Fruit getFruitByFname(String fname);
    15.  
    16.     //删除特定库存记录
    17.     boolean delFruit(String fname);
    18. }

    Fruit类

    1. package com.fruit.pojo;
    2. public class Fruit {
    3.     private Integer fid ;
    4.     private String fname ;
    5.     private Integer price ;
    6.     private Integer fcount ;
    7.     private String remark ;
    8.  
    9.     public Fruit(){}
    10.  
    11.     public Fruit(Integer fid, String fname, Integer price, Integer fcount, String remark) {
    12.         this.fid = fid;
    13.         this.fname = fname;
    14.         this.price = price;
    15.         this.fcount = fcount;
    16.         this.remark = remark;
    17.     }
    18.  
    19.     public Integer getFid() {
    20.         return fid;
    21.     }
    22.  
    23.     public void setFid(Integer fid) {
    24.         this.fid = fid;
    25.     }
    26.  
    27.     public String getFname() {
    28.         return fname;
    29.     }
    30.  
    31.     public void setFname(String fname) {
    32.         this.fname = fname;
    33.     }
    34.  
    35.     public Integer getPrice() {
    36.         return price;
    37.     }
    38.  
    39.     public void setPrice(Integer price) {
    40.         this.price = price;
    41.     }
    42.  
    43.     public Integer getFcount() {
    44.         return fcount;
    45.     }
    46.  
    47.     public void setFcount(Integer fcount) {
    48.         this.fcount = fcount;
    49.     }
    50.  
    51.     public String getRemark() {
    52.         return remark;
    53.     }
    54.  
    55.     public void setRemark(String remark) {
    56.         this.remark = remark;
    57.     }
    58.  
    59.     @Override
    60.     public String toString() {
    61.         return fid + "\t\t" + fname + "\t\t" + price +"\t\t" + fcount +"\t\t" + remark ;
    62.     }
    63. }

    三、使用TomCat新建项目

    见前一文章。

    四、Servlet获取参数

    web文件结构

    hello.html文件

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>Titletitle>
    6. head>
    7. <body>
    8. <form action="add" method="post">
    9.     名称:<input type="text" name="fname"/><br/>
    10.     价格:<input type="text" name="price"/><br/>
    11.     库存:<input type="text" name="fcount"/><br/>
    12.     备注:<input type="text" name="remark"/><br/>
    13.     <input type="submit" value="添加"/>
    14. form>
    15. body>
    16. html>

    web.xml文件

    此文件用于通过html中表单的action找到对应的类。

    此文件执行步骤：

            1、用户发请求，（action=add）
            2、项目中，web.xml中找到url-pattern = /add
            3、找servlet-name=com.fruit.servlets.AddServlet
            4、找和servlet-mapping中servlet-name一致的servlet
            5、找servlet-class
            6、用户发送的是post请求，tomcat会执行AddServlet中的doPost方法

    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
    5.          version="4.0">
    6.     <servlet>
    7.         <servlet-name>AddServletservlet-name>
    8.         <servlet-class>com.servlets.AddServletservlet-class>
    9.     servlet>
    10.     <servlet-mapping>
    11.         <servlet-name>AddServletservlet-name>
    12.         <url-pattern>/addurl-pattern>
    13.     servlet-mapping>
    14.  
    15. web-app>

    AddServlet类

    此类分为两部分：接收客户端数据和向数据库发送数据。

    可能存在HttpServlet不存在问题，往下看。

    1. package com.servlets;
    2. import javax.servlet.ServletException;
    3. import javax.servlet.http.HttpServlet;
    4. import javax.servlet.http.HttpServletRequest;
    5. import javax.servlet.http.HttpServletResponse;
    6. import java.io.IOException;
    7. import com.fruit.dao.FruitDAO;
    8. import com.fruit.dao.impl.FruitDAOImpl;
    9. import com.fruit.pojo.Fruit;
    10.  
    11. public class AddServlet extends HttpServlet {
    12.     @Override
    13.     /**接收客户端发送数据*/
    14.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    15.         request.setCharacterEncoding("utf-8");//解决输入中文乱码问题
    16.         String fname = request.getParameter("fname");
    17.         String priceStr = request.getParameter("price");
    18.         Integer price = Integer.parseInt(priceStr);
    19.         String fcountStr = request.getParameter("fcount");
    20.         Integer fcount = Integer.parseInt(fcountStr);
    21.         String remark = request.getParameter("remark");
    22.  
    23.         /**向数据库发送数据*/
    24.         FruitDAO fruitDAO = new FruitDAOImpl();
    25.         boolean flag = fruitDAO.addFruit(new Fruit(0,fname,price,fcount,remark));
    26.         System.out.println(flag ? "添加成功":"添加失败");
    27.     }
    28. }

    HttpServlet不存在解决：

    选择库中的Tomcat并确定。

    此时，外部库中有了servlet-api

     其他问题：

    打开项目结构，查看是否还有问题，如有直接修复

     五、测试

    输入信息，点击添加，数据库中出现数据信息，表示成功。

     

     

     

  • 相关阅读:
    SpringBoot和SpringCloud的区别，使用微服务的好处和缺点
    发明专利快速预审多久出结果？
    1.13.C++项目：仿muduo库实现并发服务器之TcpServer模块的设计
    中缀表达式转后缀表达式详细思路及代码实现
    自定义类型：结构体（内存对齐），枚举，联合
    解决chrome extension popup最大宽高限制（800x600）
    JavaOOP-类、对象、方法、变量作用域及JavaDoc注释
    day04_java基础
    【SpringCloud-学习笔记】Nacos配置管理
    什么是副业思维，副业应该怎么做，用创业思维分析副业的可行性
  • 原文地址：https://blog.csdn.net/Tir_zhang/article/details/126101192