JavaWeb02Servlet入门

BUZHIDAO52

已于 2023-08-03 20:49:40 修改

阅读量24

点赞数

分类专栏： JavaWeb 文章标签：前端

于 2022-12-11 19:16:57 首次发布

本文链接：https://blog.csdn.net/BUZHIDAO52/article/details/128271493

版权

JavaWeb 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

我们先在前端写一个水果商城提交表单

这个时候，我们from里的action写的是add.do，并且以post形式向服务器提交数据，这个add.do是什么？

前端提交的信息与后端交互的流程

1.前端请求访问服务器的add.html页面

2.服务器返回add.html页面，并且前端处理后形成网页

3.由于我们表单设置的action是add，用户点击提交按钮后，前端就会以add形式拿着用户输入的数据再次向后端发请求

后端拿到数据如何处理，又怎样与数据库交互？

1.后端现在收到了数据，由于前端的action是add，数据传入后端后add就会调用后端的一个叫addservlet的组件

2.这个addservlet组件会获取数据，并且调用DAO和DAOImpl里的各种方法，通过JDBC与数据库进行交互

所以add到底是个啥？

add本质上是一个java类，也是服务器的一个组件，主要实现的功能有

那这个addSert代码怎么实现？

我们只是新建一个类肯定不行，需要继承HttpServlet，但是jdk里没有这个类，需要导入servlet-api的jar包或者tomcat的包（我使用的jdk版本自动导入）

我们前端的传入方式是post，进入服务器后就会调用AddServlet的dopost方法

我们看到调用这个方法的时候里面有两个参数，req和resp，req就是前端传参进来后封装的一个对象，所以我们可以调用这个对象的方法获取前端传入的值

注意！！！！！：前端封装的对象调用获取参数后只能是字符串类型，我们如果想要进行数据计算就需要转换类型。

转换后我们可以对于获取的数据进行输出

那现在我们还有最后一个问题，这边的add怎么找到AddServlet呢？

我们需要在web-inf的xml里进行配置

这样子写的连接流程是什么？

测试：（记得改tomcat里url的值）

启动成功，进行输入测试

出现的问题

404：

修改：

输出结果为null，调用方法错误

修改：

成功：

此时我们查看网页源码

可以看到，向host8080请求，请求的url是localhost8080/add，请求方式为post，表单数据里也是我们输入的数据

实现数据数据库交互

新建表

这里出现问题，在其他地方数据库连接没有问题。但是在dopost方法里会

没有解决

解决好了！

问题：在web项目里找不到jar包，需要在web项目里导入

项目结构：

public class AddServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String fname = req.getParameter("fname");

        String priceStr = req.getParameter("price");
        Integer price = Integer.parseInt(priceStr);

        String fcountStr = req.getParameter("fcount");
        Integer fcount = Integer.parseInt(fcountStr);

        String remark = req.getParameter("remark");

        System.out.println(fname);
        System.out.println(price);
        System.out.println(fcount);
        System.out.println(remark);


        FruitDAOImpl fruitDAO = new FruitDAOImpl();
        Connection connection = null;
        try {
            connection = JDBCutil.getConnection();
            Fruit fruit = new Fruit(1,fname,price,fcount,remark);
            System.out.println(fruit);
            fruitDAO.insert(connection,fruit);
            System.out.println("insert success");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCutil.closeResource(connection,null);
        }

    }

}

连接数据库：

public class JDBCutil {
    //连接数据库
    public static Connection getConnection() throws Exception {
        //1.获取四个基本信息
        InputStream is = JDBCutil.class.getClassLoader().getResourceAsStream("jdbc.properties");
        Properties pros = new Properties();
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        String url = pros.getProperty("url");
        String driver = pros.getProperty("driver");

        //2.加载driver
        Class.forName(driver);

        //3.获取连接
        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println(connection);
        return  connection;
    }


//    //使用德鲁伊数据库连接池建造池子
//    public static DataSource source;
//    static{
//        try {
//            Properties properties = new Properties();
//            InputStream is = JDBCutil.class.getClassLoader().getResourceAsStream("druid.properties");
//
//            properties.load(is);
//            source= DruidDataSourceFactory.createDataSource(properties);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//
//    }
//    //用我们建造的这个池子获取连接
//    public static Connection getDruidConnection() throws SQLException {
//        Connection connection = source.getConnection();
//
//        return  connection;
//    }


    //关闭连接与preparedStatement或者Statement
    public static void closeResource(Connection connection, Statement preparedStatement){
        try {
            if(connection!=null)
                connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if(preparedStatement!=null)
                preparedStatement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    //关闭连接与resultset和preparedStatement或者Statement
    public static void closeResource(Connection connection, Statement preparedStatement, ResultSet resultSet){
        try {
            if(connection!=null)
                connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if(preparedStatement!=null)
                preparedStatement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if(resultSet!=null)
                resultSet.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }


//    //使用DBUtils的jar包中的工具类，更方便的实现资源关闭
//    public static void closeDBUtilsResource(Connection connection, Statement preparedStatement, ResultSet resultSet){
//        DbUtils.closeQuietly(connection);
//        DbUtils.closeQuietly(preparedStatement);
//        DbUtils.closeQuietly(resultSet);
//    }




}

pojo：

public class Fruit {
    private int id;
    private String name;
    private int price;
    private int count;
    private String remark;


    public Fruit(int id, String name, int price, int count, String remark) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.count = count;
        this.remark = remark;
    }
}

BaseDAO：

package com.LALALA.fruit.dao.base;

import com.LALALA.util.JDBCutil;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public abstract class BaseDAO<T> {
    private Class<T> clazz = null;

    {
        Type genericSuperclass = this.getClass().getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        clazz = (Class<T>) actualTypeArguments[0];
    }

    //有事务版本的通用增删改方法
    public int newUpdate(Connection connection, String sql, Object ...args) {
        //com.mysql.jdbc.Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            //首先一定是与数据库取得连接
            //connection = JDBCutil.getConnection();
            //预编译sql语句，返回PreparedStatement的实例
            preparedStatement = connection.prepareStatement(sql);
            //填充占位符
            for(int i = 0;i<args.length;i++){
                preparedStatement.setObject(i+1,args[i]);
            }
            //执行sql
            return preparedStatement.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //资源关闭
            //JDBCutil.closeResource(connection,preparedStatement);
            JDBCutil.closeResource(null,preparedStatement);
        }
        return 0;
    }


    //有事务版本的通用的返回一个对象查询方法
    public  T getInstance(Connection connection,String sql, Object ...args){
        //Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            //connection = JDBCutil.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            //填充占位符
            for (int i = 0;i < args.length;i++){
                preparedStatement.setObject(i+1,args[i]);
            }
            //返回结果集
            resultSet = preparedStatement.executeQuery();
            //获取结果集元数据
            ResultSetMetaData metaData = resultSet.getMetaData();
            //获取结果集当前里面的列数
            int columnCount = metaData.getColumnCount();
            if (resultSet.next()){
                T t = (T) clazz.newInstance();
                //处理这一行数据的每一列
                for(int i = 0;i < columnCount;i++){
                    //获取这列的数值
                    Object object = resultSet.getObject(i + 1);
                    //获取这列的名字(数据库表中)
                    //String columnName = metaData.getColumnName(i + 1);
                    String columnLabel = metaData.getColumnLabel(i + 1);
                    //调用方法，通过列名查询到该字段，并且返回一个filed对象
                    Field declaredField = t.getClass().getDeclaredField(columnLabel);
                    //提高反射权限
                    declaredField.setAccessible(true);
                    //给当前根据列名字查询到的filed对象赋值
                    declaredField.set(t,object);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            //JDBCutil.closeResource(connection,preparedStatement,resultSet);

            JDBCutil.closeResource(null,preparedStatement,resultSet);

        }
        return null;

    }

    //有事务版本的通用的返回多个对象查询方法
    public List<T> getForList(Connection connection, String sql, Object ...args){
        //Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            //connection = JDBCutil.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            //填充占位符
            for (int i = 0;i < args.length;i++){
                preparedStatement.setObject(i+1,args[i]);
            }
            //返回结果集
            resultSet = preparedStatement.executeQuery();
            //获取结果集元数据
            ResultSetMetaData metaData = resultSet.getMetaData();
            //获取结果集当前里面的列数
            int columnCount = metaData.getColumnCount();
            ArrayList<T> list = new ArrayList<>();
            while (resultSet.next()){
                T t = (T) clazz.newInstance();
                //处理这一行数据的每一列
                for(int i = 0;i < columnCount;i++){
                    //获取这列的数值
                    Object object = resultSet.getObject(i + 1);
                    //获取这列的名字(数据库表中)
                    //String columnName = metaData.getColumnName(i + 1);
                    String columnLabel = metaData.getColumnLabel(i + 1);
                    //调用方法，通过列名查询到该字段，并且返回一个filed对象
                    Field declaredField = t.getClass().getDeclaredField(columnLabel);
                    //提高反射权限
                    declaredField.setAccessible(true);
                    //给当前根据列名字查询到的filed对象赋值
                    declaredField.set(t,object);
                }
                list.add(t);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            //JDBCutil.closeResource(connection,preparedStatement,resultSet);
            JDBCutil.closeResource(null,preparedStatement,resultSet);
        }
        return null;
    }


    //有事务版本的，根据用户sql语句查询的方法
    public <E> E getValue(Connection connection,String sql,Object ...args){
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            preparedStatement = connection.prepareStatement(sql);
            for (int i = 0;i < args.length;i++){
                preparedStatement.setObject(i,i+1);
            }

            resultSet = preparedStatement.executeQuery();

            if(resultSet.next()){
                return (E) resultSet.getObject(1);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCutil.closeResource(null,preparedStatement,resultSet);
        }
        return null;

    }
}

插入成功：