• 第一个servlet项目:pro07-javaweb-begin

    第一级目录：src包，web包，pro07-javaweb-begin.iml

     pro07-javaweb-begin.iml

    2. <module type="JAVA_MODULE" version="4">
    3.   <component name="FacetManager">
    4.     <facet type="web" name="Web">
    5.       <configuration>
    6.         <descriptors>
    7.           <deploymentDescriptor name="web.xml" url="file://$MODULE_DIR$/web/WEB-INF/web.xml" />
    8.         descriptors>
    9.         <webroots>
    10.           <root url="file://$MODULE_DIR$/web" relative="/" />
    11.         webroots>
    12.       configuration>
    13.     facet>
    14.   component>
    15.   <component name="NewModuleRootManager" inherit-compiler-output="true">
    16.     <exclude-output />
    17.     <content url="file://$MODULE_DIR$">
    18.       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
    19.     content>
    20.     <orderEntry type="inheritedJdk" />
    21.     <orderEntry type="sourceFolder" forTests="false" />
    22.     <orderEntry type="library" scope="PROVIDED" name="Tomcat 8.0.42" level="application_server_libraries" />
    23.     <orderEntry type="library" name="lib" level="project" />
    24.   component>
    25. module>

    pro07-javaweb-begin.src.com.atguigu.fruit

    pro07-javaweb-begin.src.com.atguigu.fruit.dao

    pro07-javaweb-begin.src.com.atguigu.fruit.dao.base.BaseDAO.java

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

    pro07-javaweb-begin.src.com.atguigu.fruit.dao.impl

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

    pro07-javaweb-begin.src.com.atguigu.fruit.dao.FruitDAO.java

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

    pro07-javaweb-begin.src.com.atguigu.fruit.pojo.Fruit.java

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

    pro07-javaweb-begin.src.com.atguigu.servlets.AddServlet.java

    1. package com.atguigu.servlets;
    2.  
    3. import com.atguigu.fruit.dao.FruitDAO;
    4. import com.atguigu.fruit.dao.impl.FruitDAOImpl;
    5. import com.atguigu.fruit.pojo.Fruit;
    6.  
    7. import javax.servlet.ServletException;
    8. import javax.servlet.annotation.WebServlet;
    9. import javax.servlet.http.HttpServlet;
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12. import java.io.IOException;
    13. @WebServlet(urlPatterns = "/Add")
    14. public class AddServlet extends HttpServlet {
    15.     @Override
    16.     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    17.         /*
    18.         //get方式目前不需要设置编码（基于tomcat8）
    19.         //如果是get请求发送的中文数据，转码稍微有点麻烦（tomcat8之前）
    20.         String fname = request.getParameter("fname");
    21.         //1.将得到的字符串打散成字节数组
    22.         byte[] bytes = fname.getBytes("ISO-8859-1");
    23.         //2.将字节数组按照设定的编码重新组装成字符串
    24.         fname = new String(bytes,"UTF-8");
    25.         */
    26.         //post方式下，设置编码，防止中文乱码
    27.         //需要注意的是，设置编码这一句代码必须在所有的获取参数动作之前
    28.         request.setCharacterEncoding("UTF-8");
    29.         String fname = request.getParameter("fname");
    30.         String priceStr = request.getParameter("price");
    31.         Integer price = Integer.parseInt(priceStr);
    32.         String fcountStr = request.getParameter("fcount");
    33.         Integer fcount = Integer.parseInt(fcountStr);
    34.         String remark = request.getParameter("remark");
    35.  
    36.         FruitDAO fruitDAO = new FruitDAOImpl();
    37.         boolean flag = fruitDAO.addFruit(new Fruit(0 , fname , price , fcount , remark));
    38.  
    39.         System.out.println(flag ? "添加成功！" : "添加失败！");
    40.     }
    41. }

    pro07-javaweb-begin.web.add.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>

    pro07-javaweb-begin.web.WEB-INF.web.xml

    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.  
    7.     
    8. web-app>
  • 相关阅读:
    vscode中运行脚手架项目报表
    VUE快速入门-1
    金九银十助力面试——手把手轻松读懂HashMap源码
    生成式 AI 如何释放开发者的生产力？
    Java中ArrayList集合中如何删除重复元素呢？
    下载指定版本的pytorch
    C/C++、Qt开发，跨平台CMake判断当前平台是Linux还是Windows，操作系统判断
    【Elasticsearch】ES选主流程分析
    圆锥曲线的分类
    MySQL基础-----可视化工具DataGrip安装与使用
  • 原文地址：https://blog.csdn.net/Mona_lxh/article/details/126235805