javaweb之基本开发步骤之人员管理系统案例（文末有源码）很好的web开发步骤

在文末有整个项目的源码，供读者参考，本文的内容注重过程，有需要的再去了解相应代码的编写。

人员内管理系统的功能：

1.增删改查

2.条件查询

3.分页查询

实现效果：

第一步，创建一个数据库，等待使用

create database manager;

use manager;

create table t_custom(

id varchar(40) primary key,

username varchar(20),

gender varchar(10),

birthday varchar(20),

cellphone varchar(20),

email varchar(20),

love varchar(100),

type varchar(40)

);

第二步，导入相关的jar包

1.mysql驱动包

2.beanutils包

3.JSTL标签库

4.DButils

5.连接池c3p0

第三步，创建一个名字为OCmanager的web项目，开始创建一个合适的开发包结构

其中

mine.action用来存servlet的程序，属于web层

mine.dao用来存和数据库交互的java文件，属于dao层

mine.service用来存服务层的java文件，起到了连接dao层和web层的作用

mine.utils用来存一些工具方法

mine.vo用来存储一些封装的对象，内有get和set方法

第四步，设置连接池c3p0的配置文件，文件名字必须是c3p0-config.xml，文件在各个包的同级目录之下

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
	<!-- 文件名字是固定的，连接池会找到这个配置文件进行配置 -->
	<default-config>
		<!--第一条内容是固定的-->
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<!--最后一项改成你的项目名字即可-->
		<property name="jdbcUrl">jdbc:mysql:///OCmanager</property>
		<!--mysql的用户名和密码-->
		<property name="user">root</property>
		<property name="password">123456</property>
	</default-config>
</c3p0-config>

第五步，创建一些工具类，简化项目中的一些编程过程，文件创建在mine.utils下

MyJdbcUtil.java

package mine.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class MyJdbcUtil {
	//创建一个c3p0连接池对象
	public static ComboPooledDataSource dataSource = new ComboPooledDataSource();
	//将获取连接池链接对象封装为一个方法
	public static Connection getConnection() throws SQLException{
		return dataSource.getConnection();
	}
	//将获取c3p0连接池对象也封装为一个方法
	public static DataSource getDataSource(){
		return dataSource;
	}
	//写了两种不同参数的release方法，由于释放资源的过程比较繁琐，每次都是一样的，所以封装为了两个简单的方法
	public static void release(ResultSet rs,Statement stmt,Connection conn){
		if(rs != null){
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			rs = null;
		}
		if(stmt != null){
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			stmt = null;
		}
		if(conn != null){
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			conn = null;
		}
	}
	public static void release(Statement stmt,Connection conn){
		if(stmt != null){
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			stmt = null;
		}
		if(conn != null){
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			conn = null;
		}
	}
	
}

UUIDUtil.java

package mine.utils;

import java.util.UUID;

public class UUIDUtil {
	public static String getUUID(){
		//这个方法可以获取一个唯一的比较长的ID
		return UUID.randomUUID().toString().replace("-", "");
	}
}

第六步，创建需要封装的用户对象，分页对象，在mine.vo包下

Customer.java

package mine.vo;
public class Customer {
	//正好是数据库里面创建的8个对象，并在这里设置他们的get和set方法，等待着被封装
	private String id;
	private String username;
	private String gender;
	private String birthday;
	private String cellphone;
	private String email;
	private String love;
	private String type;
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public String getBirthday() {
		return birthday;
	}
	public void setBirthday(String birthday) {
		this.birthday = birthday;
	}
	public String getCellphone() {
		return cellphone;
	}
	public void setCellphone(String cellphone) {
		this.cellphone = cellphone;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getLove() {
		return love;
	}
	public void setLove(String love) {
		this.love = love;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public String toString() {
		return "Customer [id=" + id + ", username=" + username + ", gender="
				+ gender + ", birthday=" + birthday + ", cellphone="
				+ cellphone + ", email=" + email + ", love=" + love + ", type="
				+ type + "]";
	}
	
}

PageBean.java

package mine.vo;

import java.util.List;

public class PageBean<T> {
	/*这是一个分页功能实现的对象，在这个对象里有多个变量
	 * pagecode当前页，从页面获取
	 * totalpage总页数，通过计算可以得出
	 * totalcount总记录数，从数据库中查询可得
	 * pagesize每页显示的条数，由自己设定
	 * beanlist每页的数据，存储在beanlist当中
	 * 
	*/
	private int pageCode;
	private int totalCount;
	private int pageSize;
	private List<T> beanList;
	//URL的封装，当分页查询和条件查询相结合的时候，会出现一个问题，就是条件查找之后，在进行分页的跳转
	//会使得条件消失，所以，需要采用一种拼接字符串的方式，将url返回给jsp页面。
	private String url;
	//设置get和set方法，但这里有些是需要设置的，有些是要自己计算的，所以与普通封装的get和set方法有些许不同
	public int getPageCode() {
		return pageCode;
	}
	public void setPageCode(int pageCode) {
		this.pageCode = pageCode;
	}
	//获取总页数的方法，如果总条数除以每页条数余数为0，那么结果就是totalpage
	//如果有余数，那么就让页数再加上1来显示剩下的内容
	public int getTotalPage() {
		int totalPage = totalCount / pageSize;
		if(totalCount % pageSize == 0){
			return totalPage;
		}else{
			return totalPage + 1;
		}
	}
	/*不需要设置的方法，因为是计算的，所以只需要获取就可以了
	 * public void setTotalPage(int totalPage) {
		this.totalPage = totalPage;
	}*/
	
	
	public int getTotalCount() {
		return totalCount;
	}
	public void setTotalCount(int totalCount) {
		this.totalCount = totalCount;
	}
	public int getPageSize() {
		return pageSize;
	}
	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}
	public List<T> getBeanList() {
		return beanList;
	}
	public void setBeanList(List<T> beanList) {
		this.beanList = beanList;
	}
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	
}

第七步，写出相应的jsp页面，并添加相应的反应的servlet程序，在servlet中调用service中的方法，service中的方法再调用dao中的方法，也就是jsp页面需要一个功能，然后这个功能发到这个功能的servlet中，在这里获取数据，然后把数据封装为对象，也就是上面的vo中的对象，然后只在这里调用sevice中的方法，service其实就算是一个中继作用的层，然后再调用dao层中的方法，与数据库进行交互。

mine.service中的CustomerService.java

package mine.service;

import java.util.List;

import mine.dao.CustomerDao;
import mine.utils.UUIDUtil;
import mine.vo.Customer;
import mine.vo.PageBean;
//这里面的方法，都在servlet中得到调用，然后，他也会调用dao中的方法
public class CustomerService {
	//通过条件和页码进行查询
	public PageBean<Customer> findAllByConditionPage(String username,String type,int pageCode,int pageSize){
		CustomerDao dao = new CustomerDao();
		return dao.findAllByConditionPage(username,type,pageCode,pageSize);
	}
	//通过页码进行查询
	public PageBean<Customer> findAllByPage(int pageCode,int pageSize){
		CustomerDao dao = new CustomerDao();
		return dao.findAllByPage(pageCode,pageSize);
	}
	//通过条件名字进行查询
	public List<Customer> findAllByName(String username,String type){
		CustomerDao dao = new CustomerDao();
		return dao.findAllByName(username,type);
	}
	//更新用户，也就是实现对用户实现编辑修改的功能
	public void updateCustomer(Customer c){
		CustomerDao dao = new CustomerDao();
		dao.update(c);
	}
	//加一个用户
	public void addCustomer(Customer c){
		//为用户获取一个唯一的ID
		String id = UUIDUtil.getUUID();
		c.setId(id);
		CustomerDao dao = new CustomerDao();
		dao.save(c);
	}
	//找到所有的用户，不用分页的功能
	public List<Customer> findAll(){
		CustomerDao dao = new CustomerDao();
		return dao.findAll();
	}
	//通过ID找到相应的用户
	public Customer findById(String id){
		CustomerDao dao = new CustomerDao();
		return dao.findById(id);
	}
	//删除一个用户数据
	public void deleteCustomer(String id) {
		CustomerDao dao = new CustomerDao();
		dao.deleteCustomer(id);
	}

}

mine.dao中的CustomerDao.java

package mine.dao;
import java.sql.SQLException;
import java.util.ArrayList;
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 mine.utils.MyJdbcUtil;
import mine.vo.Customer;
import mine.vo.PageBean;
public class CustomerDao {
	//找到所有用户的方法，返回一个List
	public List<Customer> findAll(){
		//DButils的方法，创建一个QueryRunner类，传入的参数是c3p0连接池对象
		QueryRunner runner = new QueryRunner(MyJdbcUtil.getDataSource());
		try {
			//DButils的特定的增删查方法，一共有九个实现类，可以查询我的CSDN的DButils的那一篇
			//返回一个List
			return runner.query("select * from t_customer", new BeanListHandler<Customer>(Customer.class));
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException("查询全部结果失败");
		}
	}
	//该方法在addCustomer得到调用
	public void save(Customer c){
		try {
			/**
			 * id varchar(40) primary key,
			username varchar(20),
			gender varchar(10),
			birthday varchar(20),
			cellphone varchar(20),
			email varchar(40),
			love varchar(100),
			type varchar(40)
			 */
			QueryRunner runner = new QueryRunner(MyJdbcUtil.getDataSource());
			// 先写出sql语句
			String sql  = "insert into t_customer values (?,?,?,?,?,?,?,?)";
			// custom对象已经传过来了，我们可以获取它的参数
			Object [] params = {c.getId(),c.getUsername(),c.getGender(),c.getBirthday(),c.getCellphone(),c.getEmail(),c.getLove(),c.getType()};
			// 将custom的内容作为参数的内容传到上面的？当中，位置是相对应的
			runner.update(sql, params);
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException("添加失败");
		}
	}
	//通过ID来进行查找用户
	public Customer findById(String id) {
		QueryRunner runner = new QueryRunner(MyJdbcUtil.getDataSource());
		try {
			return runner.query("select * from t_customer where id = ?", new BeanHandler<Customer>(Customer.class) ,id);
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException("通过ID查询失败");
		}
	}
	//编辑用户，更新用户的信息
	public void update(Customer c) {
		QueryRunner runner = new QueryRunner(MyJdbcUtil.getDataSource());
		try {
			String sql = "update t_customer set username = ? , gender = ? , birthday = ? , cellphone=? ,email = ?, love = ?, type=? where id = ?";
			Object [] params = {c.getUsername(),c.getGender(),c.getBirthday(),c.getCellphone(),c.getEmail(),c.getLove(),c.getType(),c.getId()};
			runner.update(sql, params);
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException("编辑失败");
		}
	}
	//不分页的条件查找
	public List<Customer> findAllByName(String username, String type) {
		QueryRunner runner = new QueryRunner(MyJdbcUtil.getDataSource());
		try {
			// 创建一个StringBuffer对象进行字符串的拼接
			StringBuffer sb = new StringBuffer("select * from t_customer where 1=1 ");
			//这个List用来存参数，在下面赋值给？
			List<Object> list = new ArrayList<Object>();
			// 如果查询条件username不为空或者去掉空格后仍然不为空，则将查询username的语句拼接到后面
			if(username != null && !username.trim().isEmpty()){
				sb.append(" and username = ? ");
				list.add(username);
			}
			if(type != null && !type.trim().isEmpty()){
				sb.append(" and type = ? ");
				list.add(type);
			}
			return runner.query(sb.toString(), new BeanListHandler<Customer>(Customer.class),list.toArray());
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException("条件查找失败");
		}
	}
	//删除用户的操作
	public void deleteCustomer(String id) {
		QueryRunner runner = new QueryRunner(MyJdbcUtil.getDataSource());
		try {
			runner.update("delete from t_customer where id = ?", id);
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException("删除失败");
		}
	}
	//分页查找到所有的记录，目标，pagebean中所有的参数求出来，也就是pagecode等
	public PageBean<Customer> findAllByPage(int pageCode, int pageSize) {
		// 获取封装的pagebean对象
		PageBean<Customer> page = new PageBean<Customer>();
		// 将前面得到的当前页码和每页显示的条数传到里面
		page.setPageCode(pageCode);
		page.setPageSize(pageSize);
		QueryRunner runner = new QueryRunner(MyJdbcUtil.getDataSource());
		try {
			// 将单个值进行封装，求数据的条数，返回给count
			long count = (Long) runner.query("select count(*) from t_customer", new ScalarHandler());
			// count就是总的条数，也就是TotalCount
			page.setTotalCount((int)count);
			//limit后第一个问号的位置，从哪里开始
			//limit后第二个问号的位置，有多少条
			// a = (pageCode - 1)*pageSize, b = pageSize
			String selSql = "select * from t_customer limit ? , ?";
			List<Customer> beanList = runner.query(selSql, new BeanListHandler<Customer>(Customer.class), (pageCode - 1)*pageSize,pageSize);
			//将查询到的用户存到beanlist中
			page.setBeanList(beanList);
			
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException("分页查找所有失败");
		}
		
		return page;
	}
	//条件分页查找，最复杂的一个
	public PageBean<Customer> findAllByConditionPage(String username,
			String type, int pageCode, int pageSize) {
		PageBean<Customer> page = new PageBean<Customer>();
		page.setPageCode(pageCode);
		page.setPageSize(pageSize);
		StringBuffer whereSb = new StringBuffer(" where 1 = 1 ");
		List<Object> params = new ArrayList<Object>();
		if(username != null && !username.trim().isEmpty()){
			whereSb.append(" and username = ?");
			params.add(username);
		}
		if(type != null && !type.trim().isEmpty()){
			whereSb.append(" and type = ?");
			params.add(type);
		}
		QueryRunner runner = new QueryRunner(MyJdbcUtil.getDataSource());
		try {
			
			StringBuffer countSb = new StringBuffer("select count(*) from t_customer ");
			String countSql = countSb.append(whereSb).toString();
			long count = (Long) runner.query(countSql, new ScalarHandler(),params.toArray());
			page.setTotalCount((int)count);
			StringBuffer selSb = new StringBuffer("select * from t_customer ");
			StringBuffer limitSb = new StringBuffer(" limit ? , ?");
			String selSql = selSb.append(whereSb).append(limitSb).toString();
			params.add((pageCode - 1)*pageSize);
			params.add(pageSize);
			List<Customer> beanList = runner.query(selSql, new BeanListHandler<Customer>(Customer.class), params.toArray());
			page.setBeanList(beanList);
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException("分页条件查找失败");
		}
		return page;
	}

}

然后就是相应的JSP对应相应的servlet，再调用相应的方法，由于内容比较多，所以在此不在赘述了，在文末会附上整个项目的内容，读者可以根据自己的需要进行获取。