将数据库查询结果打印到网页上，数据库连接基于Druid

首先编写一个EmpDao接口，里面有一个查询所有数据的方法

package com.sun.test;
 
import java.util.List;
 
public interface EmpDao {
    public List<Emp> findAll(String name,String sex);
}

写一个实现类，实现这个接口，并且继承我们的BaseDao,里面全是封装好的数据库中的增删改查语句。

package com.sun.test;
 
import java.util.ArrayList;
import java.util.List;
 
public class EmpDaoImpl  extends BaseDao<Emp> implements EmpDao{
    @Override
    public List<Emp> findAll(String name,String sex) {
        StringBuilder sql=new StringBuilder("select * from emp where 1=1");
       List objects = new ArrayList<>();
        if(name!=null&&!name.equals("")){
            sql.append(" and name like ?");
            objects.add('%'+name+'%');
        }
        if(sex!=null&&!sex.equals("")!sex.equals("--请选择--")){
            sql.append("and gender=?");
            objects.add(sex);
        }
        List beanList = super.getBeanList(sql.toString(),objects.toArray());
        return beanList;
    }
}

数据库封装好的增删改查代码

package com.sun.test;
 
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
 
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
 
/**
 * 定义一个用来被继承的对数据库进行基本操作的Dao
 * @param <T> 泛型 -> bean类型
 */
public abstract class BaseDao<T>{
    private QueryRunner queryRunner ;
    // 定义一个变量来接收泛型的类型
    private Class<T> type;
 
    // 获取T的Class对象，获取泛型的类型，泛型是在被子类继承时才确定
    public BaseDao() {
        queryRunner = new QueryRunner(JDBCUtils.getDataSource());
        // 获取子类的类型
        Class clazz = this.getClass();
        // 获取父类的类型
        // getGenericSuperclass()用来获取当前类的父类的类型
        // ParameterizedType表示的是带泛型的类型
        ParameterizedType parameterizedType =
                (ParameterizedType) clazz.getGenericSuperclass();
        // 获取具体的泛型类型 getActualTypeArguments获取具体的泛型的类型
        // 这个方法会返回一个Type的数组
        Type[] types = parameterizedType.getActualTypeArguments();
        // 获取具体的泛型的类型·
        this.type = (Class<T>) types[0];
    }
 
 
    /**
     * 获取所有对象
     *
     * @param sql
     * @param params
     * @return
     */
    public List<T> getBeanList(Connection conn, String sql, Object... params) {
        List<T> list = null;
        try {
            list = queryRunner.query(conn, sql, new BeanListHandler<T>(type), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }
 
    /**
     * 获取一个对象
     *
     * @param sql
     * @param params
     * @return
     */
    public T getBean(Connection conn,String sql, Object... params) {
        T t = null;
        try {                                              //type == String.class
            t = queryRunner.query(conn, sql, new BeanHandler<T>(type), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return t;
    }
 
    /**
     * 通用的增删改操作(事务有关)
     *
     * @param sql
     * @param params
     * @return
     */
    public int update(Connection conn, String sql, Object... params) {
        int count = 0;
        try {
            count = queryRunner.update(conn, sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }
 
    /**
     * 通用的增删改操作(没有办法使用事务)
     *
     * @param sql
     * @param params
     * @return
     */
    public int update(String sql, Object... params) {
        int count = 0;
        try {
            count = queryRunner.update(sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }
 
    /**
     * 添加数据后返回主键id(事务有关)
     * @param sql
     * @param params
     * @return
     */
    public int insert(Connection conn ,String sql, Object... params){
        try {
            return queryRunner.insert(conn,sql , new ScalarHandler<Long>() , params).intValue();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }
 
    /**
     * 添加数据后返回主键id(没有办法使用事务)
     * @param sql
     * @param params
     * @return
     */
    public int insert(String sql, Object... params){
        try {
            return queryRunner.insert(sql , new ScalarHandler<Long>() , params).intValue();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }
 
    /**
     * 获取单行单列值得方法，专门用来执行像 select count(*)...这样的sql语句
     *
     * @param sql
     * @param params
     * @return
     */
    public int getValue(Connection conn,String sql, Object... params) {
        int count = 0;
        try {
            // 调用queryRunner的query方法获取一个单一的值
            count = queryRunner.query(conn, sql, new ScalarHandler<Long>(), params).intValue();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }
 
    /**
     * 获取所有对象
     *
     * @param sql
     * @param params
     * @return
     */
    public List<T> getBeanList( String sql, Object... params) {
        List<T> list = null;
        try {
            list = queryRunner.query(sql, new BeanListHandler<T>(type), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }
 
    /**
     * 获取一个对象
     *
     * @param sql
     * @param params
     * @return
     */
    public T getBean(String sql, Object... params) {
        T t = null;
        try {                                              //type == String.class
            t = queryRunner.query(sql, new BeanHandler<T>(type), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return t;
    }
 
 
 
 
 
 
    /**
     * 获取单行单列值得方法，专门用来执行像 select count(*)...这样的sql语句
     *
     * @param sql
     * @param params
     * @return
     */
    public int getValue(String sql, Object... params) {
        int count = 0;
        try {
            // 调用queryRunner的query方法获取一个单一的值
            count = queryRunner.query( sql, new ScalarHandler<Long>(), params).intValue();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return count;
    }
}

编写servlet类用于请求和响应

package com.sun.test;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
 
@WebServlet("/EmpServlet")
public class EmpServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");
        EmpDao empDao=new EmpDaoImpl();
        String username = req.getParameter("username");
        String sex = req.getParameter("sex");
        List<Emp> list = empDao.findAll(username,sex);
        PrintWriter writer = resp.getWriter();
        writer.println("<table border='1'>");
        for (Emp emp : list) {
            writer.println("<tr>");
            writer.println("<td>"+emp.getId()+"</td>");
            writer.println("<td>"+emp.getName()+"</td>");
            writer.println("<td>"+emp.getGender()+"</td>");
            writer.println("<td>"+emp.getJoin_date()+"</td>");
            writer.println("<td>"+emp.getDept_id()+"</td>");
            writer.println("<td>"+emp.getSalary()+"</td>");
            writer.println("</tr>");
        }
        writer.println("</table>");
    }
}

编写一个前端html网页

<form action="EmpServlet" method="post">
  <label>员工姓名:</label><input type="text" name="username"><br>
  <label>员工性别:</label><select name="sex">
    <option>--请选择--</option>
    <option>男</option>
    <option>女</option>
  </select>
  <input type="submit" value="查询">
</form>

总结:使用上面方法的好处就是代码便于扩展，可以多条件查询，并且使用StringBuilder的好处是拼接效率高，还使用到了数组语法糖，通过这个小实训，我们对servlet有了更深的了解。