本案例的处理过程：
客户端发送一个请求给服务器，服务器把这个请求给Servlet，Servlet 获取请求信息，根据请求信息的情况去调用 model （在这里是一个普通的 Java 类），然后把返回结果给 Servlet ，然后Servlet 根据返回结果 转向一个 JSP，JSP是用来呈现数据的 （这里用的是Java 代码），生成一个HTML 页面显给客户。
使用到的技术：
MVC 设计模式：JSP、Servlet、POJO
数据库：MySQL
连接数据库使用 c3p0 数据库连接池
JDBC 工具使用 DBUtils
页面上的提示操作使用 jQuery
具体实现步骤：
1、建立数据表
代码：
Create table customer(
id int(10) primary key auto_increment,
name varchar(30) not null unique,
address varchar(30),
phone varchar(30)
);
为 name 字段添加唯一约束：
alter table customers add constraint name_uk unique(name);
2、底层实现
①、加入c3p0 数据源：导入两个 jar 包（c3p0 和 数据库驱动），在 src 下新建配置文件：c3p0-config.xml ,修改一下要有连接数据库的基本信息（driverClass、jdbcUrl、user、password）。
c3p0-config.xml 代码：
<?xml version="1.0" encoding="UTF-8" ?>
<c3p0-config>
<named-config name="mvcapp">
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql:///javawebdb</property>
<property name="user">root</property>
<property name="password">root</property>
<property name="acquireIncrement">5</property>
<property name="initialPoolSize">10</property>
<property name="minPoolSize">10</property>
<property name="maxPoolSize">50</property>
<property name="maxStatements">20</property>
<property name="maxStatementsPerConnection">5</property>
</named-config>
</c3p0-config>
②、编写DAO 工具类、JdbcUtils 工具类和 CustomerDao 接口（以下有具体说明和代码）
DAO 工具类：封装了基本的增删改查的方法，以供子类继承使用。当前DAO 没有事务，直接在方法中获取数据库连接。导入了DBUtils 的 jar 包，整个 DAO 采取 DBUtils 的解决方案。
DAO.java 代码：
package com.hnust.mvcapp.dao;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
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 com.hnust.mvcapp.utils.JdbcUtils;
/**
* 封装了基本的增删改查的方法，以供子类继承使用。
* 当前DAO 直接在方法中获取数据库连接。
* 整个DAO 采取DBUtils 解决方案。
* @author User
*
* @param <T> 当前 DAO 处理的实体类的类型是什么
*/
public class Dao<T> {
private QueryRunner queryRunner = new QueryRunner();
private Class<T> clazz;
/**
* 需要确定 clazz
*/
public Dao(){
//由得到子类的 Class得到父类 带泛型的那个类型。
Type superClass = getClass().getGenericSuperclass();
//先判断是不是那个类型
if(superClass instanceof ParameterizedType){
//是的话，强转一下
ParameterizedType parameterizedType = (ParameterizedType) superClass;
//获取真正的泛型的参数
Type[] typeArgs = parameterizedType.getActualTypeArguments();
if(typeArgs != null && typeArgs.length >0){
if(typeArgs[0] instanceof Class){
clazz = (Class<T>) typeArgs[0];
}
}
}
}
/**
* 查询，返回某一个字段的值
*/
public <E> E getForValue(String sql, Object...args){
Connection connection = null;
try {
connection = JdbcUtils.getConnection();
return (E) queryRunner.query(connection, sql, new ScalarHandler(), args);
} catch (SQLException e) {
e.printStackTrace();
}finally{
JdbcUtils.releaseConnection(connection);
}
return null;
}
/**
* 查询，返回T 所对应的 List
*/
public List<T> getForList(String sql, Object...args){
Connection connection = null;
try {
connection = JdbcUtils.getConnection();
return queryRunner.query(connection, sql, new BeanListHandler<>(clazz), args);
} catch (SQLException e) {
e.printStackTrace();
}finally{
JdbcUtils.releaseConnection(connection);
}
return null;
}
/**
* 查询,返回一个T 的实体类对象
*/
public T get(String sql, Object...args){
Connection connection = null;
try {
connection = JdbcUtils.getConnection();
return queryRunner.query(connection, sql, new BeanHandler<>(clazz), args);
} catch (SQLException e) {
e.printStackTrace();
}finally{
JdbcUtils.releaseConnection(connection);
}
return null;
}
/**
* 通用的 insert 、delete、update 方法
*/
public void update(String sql, Object...args){
Connection connection = null;
try {
connection = JdbcUtils.getConnection();
queryRunner.update(connection, sql, args);
} catch (Exception e) {
e.printStackTrace();
}finally{
JdbcUtils.releaseConnection(connection);
}
}
}
JdbcUtils 工具类：JDBC 操作的工具类。
注意：数据源的初始化一定要放在静态代码块中，数据源被创建一次就够了。写完一个可以用单元测试检验以下。
JdbcUtils.java 代码：
package com.hnust.mvcapp.utils;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
/**
* JDBC 操作的工具类
* @author User
*
*/
public class JdbcUtils {
/**
* 关闭连接
*/
public static void releaseConnection(Connection connection){
try {
if(connection != null){
connection.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
private static DataSource dataSource = null;
static{
dataSource = new ComboPooledDataSource("mvcapp"); //传入的是 configName
}
/**
* 获取连接
* @throws SQLException
*/
public static Connection getConnection() throws SQLException{
return dataSource.getConnection();
}
}
CustomerDao 接口：
CustomerDao.java 代码：
package com.hnust.mvcapp.dao;
import java.util.List;
import com.hnuct.mvcapp.entity.Customer;
public interface CustomerDao {
/**
* 模糊查询 返回满足条件的List
* @param cc ：封装了查询条件
* @return
*/
public List<Customer> getForListWithCriteriaCustomer(CriteriaCustomer cc);
/**
* 查询 返回 List
*/
public List<Customer> getAll();
/**
* 增加
*/
public void save(Customer customer);
/**
* 修改 更新时候的查询（根据id）显示
*/
public Customer get(Integer id);
/**
* 删除
*/
public void delete(Integer id);
/**
* 返回和name 相同的记录数
*/
public long getCountWithName(String name);
}
实体类 Customer：
Customer.java 代码：
package com.hnuct.mvcapp.entity;
public class Customer {
private Integer id;
private String name;
private String address;
private String phone;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public Customer(Integer id, String name, String address, String phone) {
super();
this.id = id;
this.name = name;
this.address = address;
this.phone = phone;
}
public Customer() {
super();
}
@Override
public String toString() {
return "Customers [id=" + id + ", name=" + name + ", address="
+ address + ", phone=" + phone + "]";
}
}
Dao 接口的实现：（这里每个功能都写了，但占时完成了模糊查询的功能）
CustomerDaoJdbcImpl.java 代码：
package com.hnuct.mvcapp.dao.impl;
import java.util.List;
import com.hnuct.mvcapp.entity.Customer;
import com.hnust.mvcapp.dao.CriteriaCustomer;
import com.hnust.mvcapp.dao.CustomerDao;
import com.hnust.mvcapp.dao.Dao;
public class CustomerDaoJdbcImpl extends Dao<Customer> implements CustomerDao{
@Override
public List<Customer> getAll() {
String sql = "select * from customer";
return getForList(sql);
}
@Override
public void save(Customer customer) {
String sql = "insert into customer(name,address,phone) values (?,?,?)";
update(sql, customer.getName(), customer.getAddress(), customer.getPhone());
}
@Override
public Customer get(Integer id) {
String sql = "select * from customer where id = ?";
return get(sql, id);
}
@Override
public void delete(Integer id) {
String sql = "delete from customer where id = ? ";
update(sql, id);
}
@Override
public long getCountWithName(String name) {
String sql = "select count(id) from customer where name = ?";
return getForValue(sql, name);
}
@Override
public List<Customer> getForListWithCriteriaCustomer(CriteriaCustomer cc) {
String sql = "SELECT id,name,address,phone FROM customer WHERE name LIKE ? AND "
+ "address LIKE ? AND phone LIKE ?";
//注意：修改了 CriteriaCustomer 的 getter 方法，使其返回的字符串中有 "%%",
//若返回值为 null 则返回 "%%" ,若不为 null， 则返回 "% " + 字段本身的值 + " %"
return getForList(sql, cc.getName(), cc.getAddress(), cc.getPhone());
}
}
ps：注意因为查询条件很多时候 和 实体类 并不相同，所以要做成一个单独的类，这里是 CriteriaCustomer 类，其中里面的getter 方法做了修改，是为了正确的填充占位符。
CriteriaCustomer.java 代码：
package com.hnust.mvcapp.dao;
public class CriteriaCustomer {
private String name;
private String address;
private String phone;
public String getName() {
if(name == null)
name = "%%";
else
name = "%" + name + "%";
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
if(address == null)
address = "%%";
else
address = "%" + address + "%";
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPhone() {
if(phone == null)
phone = "%%";
else
phone = "%" + phone + "%";
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public CriteriaCustomer() {
super();
}
public CriteriaCustomer(String name, String address, String phone) {
super();
this.name = name;
this.address = address;
this.phone = phone;
}
}
3、Servlet 的实现：获取请求信息的参数，根据请求信息调用 DAO 的对应的方法。
先写了一个 test.jsp 页面 放了三个超链接。
test.jsp 代码：
<a href="addCustomer.do">add</a>
<br><br>
<a href="query.do">query</a>
<br><br>
<a href="delete.do">delete</a>
<br><br>
然后 创建了CustomerServlet
CustomerServlet.java 代码：
package com.hnust.mvcapp.servlet;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.hnuct.mvcapp.dao.impl.CustomerDaoJdbcImpl;
import com.hnuct.mvcapp.entity.Customer;
import com.hnust.mvcapp.dao.CriteriaCustomer;
import com.hnust.mvcapp.dao.CustomerDao;
public class CustomerServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private CustomerDao customerDao = new CustomerDaoJdbcImpl();
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doPost(request, response);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//1、获取servletPath
String servletPath = req.getServletPath();
//System.out.println(servletPath); //得到的是 /addCustomer.do 或 /query.do 或 /delete.do
//2、去除 / 和 .do ,得到 addCustomer 这样的字符串
String methodName = servletPath.substring(1);
methodName = methodName.substring(0, methodName.length() - 3);
//System.out.println(methodName); // 得到的是 addCustomer 或 query 或 delete
try {
//3、利用反射，根据获取的 方法名，获取对应的方法。
Method method = getClass().getDeclaredMethod(methodName, HttpServletRequest.class,
HttpServletResponse.class);
//4、利用反射调用对应的方法
method.invoke(this, req, resp);
} catch (Exception e) {
e.printStackTrace();
//可以有一些响应
resp.sendRedirect("error.jsp");
}
}
private void query(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//1、获取模糊查询的请求参数
String name = request.getParameter("name");
String address = request.getParameter("address");
String phone = request.getParameter("phone");
//2、把请求参数封装为 CriteriaCustomer 对象
CriteriaCustomer cc = new CriteriaCustomer(name, address, phone);
//3、再调用CustomerDao 的 getForListWithCriteriaCustomer() 方法
List<Customer> customers = customerDao.getForListWithCriteriaCustomer(cc);
//调用CustomerDao 的 getAll() 方法 查询。
//List<Customer> customers = customerDao.getAll();
//4、把查询到的结果集放入 request 中
request.setAttribute("customers", customers);
//5、请求的转发
request.getRequestDispatcher("/index.jsp").forward(request, response);
}
}
4、返回结果 的 JSP 页面：获取返回结果，遍历显示。
index.jsp 代码：
<body>
<form action="query.do" method="post">
<table>
<tr>
<td>name:</td>
<td><input type="text" name="name"/></td>
</tr>
<tr>
<td>address:</td>
<td><input type="text" name="address"/></td>
</tr>
<tr>
<td>phone:</td>
<td><input type="text" name="phone"/></td>
<tr>
<td><input type="submit" value="Query"/></td>
<td><a href="">Add new Customer</a></td>
</tr>
</table>
</form>
<br><br>
<%
List<Customer> customers = (List<Customer>) request.getAttribute("customers");
if(customers != null && customers.size() > 0){
%>
<hr>
<br><br>
<table border="1" cellpadding="10" cellspacing="0">
<tr>
<th>ID</th>
<th>NAME</th>
<th>ADDRESS</th>
<th>PHONE</th>
<th>UPDATE/DELETE</th>
</tr>
<% for(Customer cust : customers){
%>
<tr>
<td><%= cust.getId() %></td>
<td><%= cust.getName() %></td>
<td><%= cust.getAddress() %></td>
<td><%= cust.getPhone() %></td>
<td>
<a href="">Update</a>
<a href="">Delete</a>
</td>
</tr>
<%
}
%>
</table>
<%
}
%>
</body>
最后结果：
点击query
可以实现模糊查询。
原文：http://www.cnblogs.com/daoxiaobai/p/6267464.html