Java Web 入门项目 | 二手车交易平台（保姆级指导）

一、需求分析

本项目实现的功能是一个网上二手车交易平台，主要围绕二手车的交易进行开发。
在该系统，分为两个角色，一个是普通用户角色，即会员，另一个角色是管理员用户，两个角色分别有不同的权限。具体如下：
普通用户（会员）：

1. 注册、登录
2. 个人信息的查询
3. 个人信息及密码修改
4. 二手车的添加、修改、发布、删除
5. 查询并维护自己的出售信息并支持留言、同时支持对其他人的留言进行回复
6. 查看平台所有二手车信息并进行留言
7. 支持禁止他人对自己发布的车辆留言

管理员用户：

1. 登录
2. 个人信息及密码的修改
3. 车辆管理：能查看平台所有车辆，并进行留言操作、屏蔽操作
4. 会员管理：支持修改、删除会员的信息
5. 查询所有会员信息（支持模糊查询）
6. 可取消会员资格（使之可正常登录但无法浏览网站信息）

二、使用的技术

本系统是基于 MVC 模式搭建的，使用的技术包括

Servlet
JSP
JDBC
EL 表达式
JSTL
Filter 过滤器
等

三、系统的结构层次

本系统的代码结构逻辑清晰，具体的实现分为Web层(表示层)、业务层、数据访问层，利用MVC架构将JSP、Servlet、JavaBean分层操作并联系起来，形成一种弱耦合关系，在后期对系统的维护上少了很多麻烦，例如要增加一个功能，只需在Servlet进行逻辑的控制，并调用Service业务服务层的代码，业务层就去调用数据访问层的具体逻辑实现，完成对数据库项的增加操作，实现数据的持久化，在Servlet控制层里，只需完成2件事，一件是调用业务逻辑层的实现方法，另一件事是将相关属性放在request中，并转发给其他JSP页面去做显示或输入处理。代码逻辑条理十分清晰，具体的代码结构如下：

不同层次的实现放在不同的 package 中，将代码模块化，方便维护。
其中：

com.bean：主要放实体类
com.controller：主要放Servlet
com.dao：主要放接口
com.daoImpl：主要放接口的实现类
com.filter：主要放filter过滤器
com.service：主要是业务逻辑的实现
com.utils：主要放工具类（对数据库的连接和资源释放）

MVC 模式的逻辑图如下：

其中，JSP页面即MVC模式中的V（view），Servlet为MVC中的C（Controller），然后Service、Dao、MySql组成MVC中的M（model），每个层次每个模块的功能如下：
1. JSP：
（1）呈现数据：从request中获取Servlet放入的属性
（2）接收用户的输入
（3）编写前端页面显示代码给出对于的提示，参与用户交互

2. Servlet：
（1）获取请求信息：获取请求参数
（2）验证请求参数的合法性：验证失败需要返回页面，并给出提示
（3）把请求参数封装为一个JavaBean
（4）调用业务逻辑方法获取返回的结果
（5）把返回的结果放入request中
（6）响应页面：转发、重定向

3. Service：
（1）实现业务逻辑
（2）返回结果

4. Dao：
（1）执行增删改查操作（CRUD）
（2）返回结果

5. MySql：
（1）存储数据，对数据进行持久化操作

四、系统部分功能和逻辑分析

1. MySQL 数据库

该系统包含两个数据表，一个是 user 表，一个是 car 表。它们分别包含的属性如下
（1）user表

id：用户 id 号（主键）
name：用户登录名称
pwd：用户登录密码
limit：该用户的受限情况（int）
isadmin：该用户是否是管理员（int）

（2）car表

userid：用户 id 号（主键，同时是 user 表的 userid 属性的外键）
carid：二手车 id 号
brand：车辆品牌
model：车辆型号
price：车辆价格
color：车辆颜色
dateposted：发布日期（timestamp）
isrelease：发布状态（int）
canmessage：是否支持用户留言（int）
carcomment：留言板（text）
isfake：是否是虚假消息（该属性的操作属于管理员权限）（int）

2. Servlet 控制器部分

其中控制器，即 MVC 模式中的 C（Controller），我通过使用通配符，对Servlet进行配置，然后在doGet()方法利用反射机制分辨从JSP传过来的请求，并映射到相应的Servlet中。通过使用这一方法，可以将同一类型的Servlet放在一个.java文件中，不需要每个servlet写一个java文件进行配置。

其中
CarServlet 配置为：@WebServlet(".car")
UserServlet配置为：@WebServlet(".do")

通过.do或.car将车辆管理和用户管理这两个业务分离开，这样处理业务就变得非常方便，这一做法，可以让在编码过程中思路逻辑变得更加的清晰。而且采取上面所说的结构，在编码过程中遇到报错能更快的定位到bug，并进行更正。

3. JSP 视图部分

系统采取的JSP显示界面也进行了分类管理（结构如下图），使编程思路更加清晰。

这里关键的一点是登录页面，即首页，要放在WebContent下面，不能放在WEB-INF下面，因为WEB-INF属于保护目录，不能直接被访问，本项目的登录页面 login.jsp 放在 WebContent 下，并在 web.xml 配置为首页，如下图所示：

如果需要访问 WEB-INF 下的 jsp 文件，需要通过servlet转发，才能实现访问操作。这同时也能保证系统的安全性，保证用户权限得到有效的管理。

同时为保证系统代码结构各个层次各司其职，在JSP页面没有多余的Java代码，业务逻辑执行操作都在其他层次完成。

本系统在界面的显示上，虽然没有加入太多的样式使界面更加高级，但基本保证了界面的可读性和用户交互性。

4. Filter过滤器

Filter是一个实现了Filter接口的Java类，与Servlet相似，它由Servlet容器进行调用和执行，Filter需要在web.xml文件中进行注册和设置它所能拦截的资源。在注册之后，该Filter就可以对Servlet容器发送给Servlet程序的请求Servlet程序回送给Servlet容器的响应进行拦截，可以决定是否将请求继续传递给Servlet程序，以及对请求和响应信息是否进行修改。
该系统利用了Filter过滤器对Servlet容器调用Servlet的过程进行拦截，进行编码的转换，从而在Servlet进行响应处理的前后保证了编码的统一，统一为utf-8格式，如下图：

同时需要在web.xml进行配置，如下图：

5. EL表达式 和JSTL

在JSP页面获取request中的数据时并没有出现JAVA代码，而是采用EL表达式获取值，实现0 Java代码。让JSP页面的功能更加纯粹。利用点访问符访问对象的属性。
本系统采用JSTL与EL表达式结合使用，其中JSTL需要导入相应的jar包，并在JSP页面导入标签库

<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“c”%>

本系统使用到的主要有 c:if、c:foreach 标签。

6. 弱耦合逻辑结构关联方式

其中的层层调用，除了类对象调用方法实现层层调用外，还有就是通过转发将数据放在request域内，在jsp页面可以通过requestScope去取到数据，在Servlet也可以接收jsp页面传过来的数据，通过request.getParameter( )可以获取。

7. 接口设计

该系统还有一个比较好的一点就是在对业务逻辑进行处理时，利用接口，然后再在接口的实现类进行操作。面向接口编程可以增加复用性和通用性。

其中
Dao和DaoImpl分别是通用接口和通用接口的实现类，
CarDao和CarDaoImpl是二手车车辆管理的接口和实现类
UserDao和UserDaoImpl是用户管理（包括管理员及普通用户）的接口和实现类

为了使接口更具通用性，这里采用了“泛型”，代码如下图：

8. 数据库操作和JDBC

使用JDBC可以直接访问数据库，JDBC是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API），定义了用来访问数据库的标准Java类库，使用这个类库可以以一种标准的方法、方便地访问数据库资源。JDBC为访问不同的数据库提供了一种统一的途径，方便开发（本系统采用的是MySql数据库）。
JDBC API 是一系列的接口，使应用程序能够进行数据库连接，执行SQL语句，并且得到返回结果。

基本的流程是：
（1）在Driver Manager中注册
（2）获取连接（Connection）
（3）调用相应的方法做增删改查
（4）获取处理结果数据

下面对这几个基本过程进行解析：
<1>注册
调用Class类的静态方法forName()，向其传递要加载的JDBC驱动的类名，代码如下：

String driverClass="com.mysql.cj.jdbc.Driver";
Class.forName(driverClass);

<2>建立连接
调用DriverManager类的getConnection()方法建立到数据库的连接。JDBC URL标识一个被注册的驱动程序，从而建立到数据库的连接。通俗来说，就是JDBC URL说明要连接数据库管理系统中的哪个数据库。代码如下：

String jdbcUrl="jdbc:mysql://localhost:3306/SecondCarTrade?serverTimezone=Hongkong";
Connection connection=DriverManager.getConnection(jdbcUrl, user, password);

<3>调用方法实现数据库永久化操作
调用数据库有3种方式，分别为：

Statement
PreparedStatement
CallableStatement

该系统使用的是PreparedStatement。
因为考虑到如果使用Statement的话，获取sql语句是通过字符串拼接的方式，所以就必须得考虑到它的拼写规则，并且得时刻注意不能和关键字和特殊字符进行冲突，这对编码来说不方便，且容易出错。
而PreparedStatement优势就比较凸显，使用PreparedStatement可以进行预编译，提高性能，同时还可以防止SQL注入，对sql语句也不需要进行字符串拼接，直接写sql语句就可以调用执行方法操作数据库。对于语句中的属性值，可以通过“?”作为占位符，可以传入参数。
以添加用户来举例，参数传递过来user对象，在方法内部获取user对象的所需的相应属性，通过问号占位符填入sql语句，然后调用update方法操作数据库，代码结构如下：

<4>获取返回数据
将对数据库操作的结果通过List或者ResultSet的方式返回，以“获取所有用户所有车辆”方法举例，代码如下：

五、代码解析和功能演示

下面对具体的逻辑结构和具体实现代码进行解析，JSP页面的显示代码就不一一演示了，具体查看源代码去看就行了，注释都写得很清晰。
首先从登录页面 login.jsp 启动，登录时会根据用户类型和账号密码进行身份验证：

//登录
	public void LoginUserServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		//得到jsp页面传过来的参数
				//（因为在同个request域中，所以可以用request获取其数据）
				String name=request.getParameter("name");
				String pwd=request.getParameter("pwd");
				int userType=Integer.parseInt(request.getParameter("userType"));// 会员0 /管理员1
				
				
				System.out.println("userType="+userType);
				/*这里id不能直接request.getParameter获取，因为在用户登录的时候没有填id，所以jsp页面没有传"id"信息过来，这里获取不到的*/
				int id=service.LoginFindId(name, pwd);//根据name和pwd查找id
				UserDao ud =new UserDaoImpl();//创建接口的实现类，ud对象可以操作UserDaoImpl类内容
				System.out.println("id="+id);	
				
				//service.LimitUser(id)执行成功，返回true，则该用户变为受限
				//service.isLimit(id)返回true，则该用户变为受限
				//userType==0  会员
				if(service.login(name, pwd) && (!service.isLimit(id)) && (userType==0) && !service.isAdmin(id)) {//如果登录通过,并且不受限
					//request.setAttribute("xiaoxi", "welcom "+name);//向request域中放置信息
					System.out.println("（会员）登录成功");
					String message="个人会员 登录成功";
					
					//注：个人用户登录成功，将他的id放在request域中，在jsp页面可以获取，然后通过jsp可以再把该id信息转到其他servlet中(比如下面的SearchUserSelfById() )
					request.setAttribute("id", id);//设置id到request域，在每个个人用户登录后分别显示他个人的信息（通过这个id去获取）
					request.setAttribute("message", message);
					//转发到个人用户主页UserHomePage.jsp
					request.getRequestDispatcher("/WEB-INF/user/UserHomePage.jsp").forward(request, response);//转发到成功页面
				}
				//userType==1  管理员
				else if(service.login(name, pwd) && (!service.isLimit(id)) && (userType==1) && service.isAdmin(id)) {//如果登录通过,并且不受限
					//request.setAttribute("xiaoxi", "welcom "+name);//向request域中放置信息
					System.out.println("（管理员）登录成功");
					String message="管理员登录成功";
					request.setAttribute("message", message);
					request.getRequestDispatcher("/WEB-INF/admin/AdminHomePage.jsp").forward(request, response);//转发到成功页面
				}
				//个人用户（受限用户）
				else if(service.login(name, pwd) && service.isLimit(id) && (userType==0) && !service.isAdmin(id)){//登录成功，但受限
					System.out.println("登录成功,但您的会员资格受限，无法访问汽车信息");
					String message="登录成功,但您的会员资格受限，无法访问汽车信息";
					request.setAttribute("ERRMESSAGE", message);
					request.getRequestDispatcher("/WEB-INF/admin/LimitedUser.jsp").forward(request, response);//转发到成功页面
				
				}
				//共用
				else {//登录不通过，重定向到失败界面(respnse 响应)
					System.out.println("登录失败,请确认账号密码以及身份是否正确");
					String message="登录失败,请确认账号密码以及身份是否正确";
					request.setAttribute("message", message);
					//response.sendRedirect("/WEB-INF/view/Fail.jsp"); 重定向不在一个request里面
					request.getRequestDispatcher("/WEB-INF/view/LoginFail.jsp").forward(request, response);//转发到失败页面
				}
	}

登录成功会跳转到个人用户主页，如下图：

下面演示”显示个人信息“：

	/*根据个人id查询个人信息（个人用户）*/
	public void SearchUserSelfById(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	
		int id=Integer.parseInt(request.getParameter("id"));//从jsp页面传过来，用getParameter

		request.setAttribute("id", id);//把id放在request域中，然后在ShowUserInfoSelf可以获取到，显示用
		User user=service.getUser(id);
		
		/*转发提交到request,到相应jsp页面显示*/
		request.setAttribute("user", user);	/*将取出来的user对象保存在request域里面*/
		
		String message="个人信息查询成功";
		request.setAttribute("message", message);
		request.getRequestDispatcher("/WEB-INF/user/ShowUserInfoSelf.jsp").forward(request, response);
		
	}

我们可以对个人信息进行更新：

	//个人用户修改信息触发界面(跳转到修改的界面)
	public void editUserSelfInfo(HttpServletRequest request, HttpServletResponse response) throws Exception {
		int id=Integer.parseInt(request.getParameter("id"));
		User user=service.getUser(id);
		
		/*转发提交到request,到相应jsp页面显示*/
		request.setAttribute("user", user);	/*将取出来的user对象保存在request域里面*/
		request.getRequestDispatcher("/WEB-INF/update/UpdateUserInfoSelf.jsp").forward(request, response);//转发到jsp页面显示
	}

修改完成后提交，完成数据库持久化操作，如下：

	//个人用户信息修改成功后回到这里
	public void UpdateUserInfoSelfServlet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {	
		/*获取从 Update.jsp 页面输入的信息（用户修改后的信息）*/
		System.out.println("进入 UpdateUserInfoSelfServlet ");
		int id=Integer.parseInt(request.getParameter("id"));//从jsp页面传过来，用getParameter
		
		String name=request.getParameter("name");
		String pwd=request.getParameter("pwd");
		String sex=request.getParameter("sex");
		System.out.println("name="+name+"  pwd="+pwd+"  sex="+sex);
	
		User user=new User(id,name,pwd,sex,0,0);//User类必须有个带参构造方法(因为这是在个人信息修改的方法里，所以直接把limit和isAdmin默认0)
		service.UpdateUserServlet(user);//Userservice的同名方法
		System.out.println("update successfully");
		String message="个人信息修改成功";
		request.setAttribute("message", message);
		
		//修改成功回到显示个人信息的界面
		request.setAttribute("user",user);//传回ShowUserInfoSelf.jsp，不然那边无法显示更新后的信息
		request.getRequestDispatcher("/WEB-INF/user/ShowUserInfoSelf.jsp").forward(request, response);
		
	}

下面进行”二手车管理首页“进行二手车的相关操作：

	//二手车辆管理首页
	public void CarsManageHomePageServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		List<Car> cars=new ArrayList<Car>();
		int userid=Integer.parseInt(request.getParameter("userid"));//这里是userid，不是id
		
		User user = serviceOfUser.getUser(userid);//根据jsp传过来的用户id，定位到用户
		cars=serviceOfCar.getCarsListOfUserid(userid);//根据userid获取到
		//String message="-------二手车管理首页---------";
		request.setAttribute("user", user);//放在request，到CarsManageHomePage.jsp可以取出来用
		request.setAttribute("cars", cars);
		request.setAttribute("userid", userid);//单独传userid过去，因为CarsManageHomePageServlet不仅连接user，又连接对car的一系列操作
		//request.setAttribute("message", message);
		request.getRequestDispatcher("/WEB-INF/car/CarsManageHomePage.jsp").forward(request, response);
		
	}

来到了二手车管理首页

下面一一进行演示
添加二手车：

	//添加车辆 触发界面（编辑界面）
	public void AddCarPageServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		
		/*实现*/
		int userid=Integer.parseInt(request.getParameter("userid"));//通过 " ?userid " 传过来了
		System.out.println("AddCarServlet()---userid="+userid);
	
		User user = serviceOfUser.getUser(userid);//根据jsp传过来的用户id，定位到用户
		
		

		/*转发*/
		String message="添加车辆页面";		
		request.setAttribute("user", user);//user放在这个request里
		/*将消息message转到一个jsp页面success.jsp，在页面打印一个“成功”消息*/
		request.setAttribute("message", message);
		request.getRequestDispatcher("/WEB-INF/add/AddCarPage.jsp").forward(request, response);

	}

在AddCarPage.jsp页面进行车辆信息的添加后，来到AddCarServlet

//添加车辆
	//获取添加界面的信息
	public void AddCarServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		/*实现*/
		int userid=Integer.parseInt(request.getParameter("userid"));//userid:jsp页面作为?参数传过来的
		String brand=request.getParameter("brand");
		String model=request.getParameter("model");
		String price=request.getParameter("price");
		String color=request.getParameter("color");
		String carcomment=request.getParameter("carcomment");
		
		
		//默认设置的属性，这些直接写null(注意，id这些整型属性在Car类要定义成Integer，不能是int)
		Car car = new Car(userid,null,brand,model,price,color,null,null,null,carcomment,null);
		boolean result=serviceOfCar.AddCarServlet(car);
		
		/*转发*/
		if(result) {//成功添加
			String message="添加车辆成功";		
			/*将消息message转到一个jsp页面success.jsp，在页面打印一个“成功”消息*/
			request.setAttribute("car",car);//记得setAttribute过去成功页面，不然那边获取不到
			request.setAttribute("message", message);
			request.getRequestDispatcher("/WEB-INF/car/SuccessOfCar.jsp").forward(request, response);
		}
		else {	//添加失败
			String message="添加车辆失败";
			request.setAttribute("message", message);
			request.getRequestDispatcher("/WEB-INF/car/FailOfCar.jsp").forward(request, response);
		
		}
		
	}

显示我的二手车仓库：

	//显示我当前所有的车辆（本地仓库）
	public void ShowAllLocalCarSelfServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		
		/*实现*/
		int userid=Integer.parseInt(request.getParameter("userid"));	
		List<Car> cars=new ArrayList<Car>();
		cars=serviceOfCar.getCarsListOfUserid(userid);//根据userid获取到当前车主所有车辆
		
		/*转发*/
		String message="显示我当前所有的车辆 界面";		
		/*将消息message转到一个jsp页面success.jsp，在页面打印一个“成功”消息*/
		request.setAttribute("message", message);
		request.setAttribute("cars", cars);
		request.setAttribute("userid", userid);//!!
		request.getRequestDispatcher("/WEB-INF/user/ShowAllLocalCarSelf.jsp").forward(request, response);
	
	}

可以对自己的二手车进行修改、发布、删除、留言回复以及禁止其他用户留言的操作
下面直接贴出这个操作涉及的相关Servlet的代码：

修改信息：

	//修改车辆信息（编辑界面）
	public void EditCarServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		/*实现*/
		System.out.println("进入EditCarServlet");
		//定位到用户
		int userid=Integer.parseInt(request.getParameter("userid"));
		User user=serviceOfUser.getUser(userid);//这里不用new User，因为service.getUser()方法中有了。
		System.out.println("userid="+userid);
		//定位到车辆
		int carid=Integer.parseInt(request.getParameter("carid"));
		Car car = serviceOfCar.getCarOfCarid(carid);
		System.out.println("carid="+carid);

		if(car.getIsrelease()==0) {//未发布，可进行修改
			/*转发*/
			String message="进入修改界面";		
			/*将消息message转到一个jsp页面success.jsp，在页面打印一个“成功”消息*/
			
			request.setAttribute("message", message);
			request.setAttribute("car", car);//to UpdateCarSelf.jsp
			request.getRequestDispatcher("/WEB-INF/update/UpdateCarSelf.jsp").forward(request, response);
		}
		else {
			System.out.println("该车辆已发布，不可修改");
			String message="该车辆已发布，不可修改";
			request.setAttribute("message", message);
			
			/*//这里直接转到这个servlet比较好，如果转到FailOfCar的话，还要在request域放参数，才能正常跳转到首页，
			 * 还不如这里直接转过去，但是这样缺少交互
			 * 所以还是转到jsp -> servlet -> 首页 
			 * 
				ShowAllLocalCarSelfServlet(request,response);
			*/		
			
			request.setAttribute("car", car);
			request.getRequestDispatcher("/WEB-INF/update/UpdateCarFail.jsp").forward(request, response);
			
		}
	}

在修改界面完成修改并且提交之后，来到UpdateCarSelfServlet调用方法进行数据库的持久化操作

//更新车辆信息（实现）
	public void UpdateCarSelfServlet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {	
		
		/*实现*/
		//userid和carid是通过这句传过来的 " <form action="... .car?userid=${requestScope.car.userid}&carid=${requestScope.car.carid}" ...> "
		int userid=Integer.parseInt(request.getParameter("userid"));
		int carid=Integer.parseInt(request.getParameter("carid"));
		System.out.println("carid="+carid);
		System.out.println("userid="+userid);
		
		String brand=request.getParameter("brand");
		String model=request.getParameter("model");
		String price=request.getParameter("price");
		String color=request.getParameter("color");
		String carcomment=request.getParameter("carcomment");
		
		
		//报错，注意这里的carid的位置不能写null，因为写null，就不知道更新哪一辆车了
		Car car = new Car(userid,carid,brand,model,price,color,null,null,null,carcomment,null);
		
		serviceOfCar.UpdateCarSelfServlet(car);//同名方法
		System.out.println("车辆信息修改成功");
		
		System.out.println("ShowAllLocalCarSelfServlet------userid="+userid);
		
		//List<Car> cars=new ArrayList<Car>();
		//cars=serviceOfCar.getCarsListOfUserid(userid);//根据userid获取到当前车主所有车辆
		
		//根据carid获取到要更新那样车的car信息
		//car=serviceOfCar.getCarOfCarid(carid);
		
		System.out.println("根据carid="+carid+" 更新该车信息成功");
		
		/*转发*/
		String message="车辆信息修改成功";
		request.setAttribute("message", message);
		
		//ShowAllLocalCarSelf.jsp显示需要，所以这里要再用userid获取一次该车主所有信息（放到request域中）
		List<Car> cars=new ArrayList<Car>();
		cars=serviceOfCar.getCarsListOfUserid(userid);
		request.setAttribute("cars", cars);//本地仓库那边要根据这里穿过去的userid判断是谁的仓库，然后显示用户自己的本地仓库
		request.setAttribute("userid", userid);//!!
		request.getRequestDispatcher("/WEB-INF/user/ShowAllLocalCarSelf.jsp").forward(request, response);
	}

发布车辆：:

//发布该车辆
	//发布成功，到ShowAllLocalCarSelf可以看到"发布状态"的属性更新
	//对已发布的汽车点击"发布"按钮，会跳到失败界面并发message，然后可点击跳回显示主页
	public void ReleaseCarServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		
		/*实现*/
		int carid=Integer.parseInt(request.getParameter("carid"));	
		
		int isrelease=Integer.parseInt(request.getParameter("isrelease"));
		
		int userid=Integer.parseInt(request.getParameter("userid"));
		
		
		if(isrelease==0) {//未发布
			serviceOfCar.ReleaseCarServlet(carid);
			System.out.println("车辆发布成功");
			
			/*转发*/
			//String message="message:车辆发布成功";		
			/*将消息message转到一个jsp页面success.jsp，在页面打印一个“成功”消息*/
			//request.setAttribute("message", message);
			request.setAttribute("userid", userid);
			
			ShowAllLocalCarSelfServlet(request,response);//再次显示（最新）页面(需要传userid过去)
		}
		else {
			request.setAttribute("userid", userid);
			String message="车辆已发布，请勿重复发布";
			request.setAttribute("message", message);
			request.getRequestDispatcher("/WEB-INF/car/ReleaseCarFail.jsp").forward(request, response);
			
		}
	}

删除车辆：

	//删除该车辆
	//根据carid删除车辆信息
	public void DeleteCarServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		
		/*实现*/
		int carid=Integer.parseInt(request.getParameter("carid"));
		//int userid=Integer.parseInt(request.getParameter("userid"));
		serviceOfCar.DeleteCarServlet(carid);//调用方法实现删除
		ShowAllLocalCarSelfServlet(request,response);//再次显示（最新）页面
		
	}

留言回复：

//对留言进行回复（个人用户）
	public void RespondCommentServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		/*实现*/
		int carid=Integer.parseInt(request.getParameter("carid"));
		int userid=Integer.parseInt(request.getParameter("userid"));
		String carcomment=request.getParameter("carcomment");	
		int canmessage=Integer.parseInt(request.getParameter("canmessage"));
		
		//留言权限设置
		if(canmessage==0) {//可留言:0
			/*转发*/
			String message="留言板";		
			/*将消息message转到一个jsp页面success.jsp，在页面打印一个“成功”消息*/
			request.setAttribute("message", message);
			//request.setAttribute("carid", carid);

			
			if(request.getParameter("respondid")!=null) {
				int respondid=Integer.parseInt(request.getParameter("respondid"));
				request.setAttribute("respondid", respondid);//对“是哪个用户”留言进行标注
			}
			
			//User user=serviceOfUser.getUser(userid);//获取到当前是哪个登录用户
			
			//这里必须setAttribute(car)，不然无法做留言的回显
			//需要把userid传过去，不然在留言板的“只读”显示那里没办法显示userid出来
			Car car = new Car(userid,carid,null,null,null,null,null,null,canmessage,carcomment,null);
			request.setAttribute("car", car);
			
			request.getRequestDispatcher("/WEB-INF/car/RespondComment.jsp").forward(request, response);
		}
		else {//canmessage为1则不可留言
			String message="该车辆已被车主禁止留言";
			request.setAttribute("message", message);
			Car car = new Car(userid,carid,null,null,null,null,null,null,canmessage,carcomment,null);
			request.setAttribute("car", car);
			request.getRequestDispatcher("/WEB-INF/car/RespondFail.jsp").forward(request, response);
		}
	}
	





//把留言更新到数据库中（个人用户）
	public void AddResondComment(HttpServletRequest request, HttpServletResponse response) throws Exception {
		/*实现*/
		int carid=Integer.parseInt(request.getParameter("carid"));
		int userid=Integer.parseInt(request.getParameter("userid"));
		String carcomment=request.getParameter("carcomment");
		

		int respondid=Integer.parseInt(request.getParameter("respondid"));
		request.setAttribute("respondid", respondid);//对“是哪个用户”留言进行标注
	
		
		/*
		//不需要更新的属性写null即可
		Car car = new Car(null,carid,null,null,null,null,null,null,null,carcomment);
		serviceOfCar.UpdateCarSelfServlet(car);//同名方法
		*/
		User user=serviceOfUser.getUser(userid);
		//直接传入carid和carcomment作为参数也行，但是这样需要再写一个update方法
		serviceOfCar.UpdateCarComment(carcomment,carid);
		
		
		System.out.println("留言更新成功");
				
		String message="留言成功";
		request.setAttribute("message", message);
		request.setAttribute("userid", userid);
		request.setAttribute("user", user);
		
		//转发到留言成功界面
		request.getRequestDispatcher("/WEB-INF/car/SuccessOfRespond.jsp").forward(request, response);
		
	}

对个人车库车辆的管理大概就以上几个功能，接下来返回上一层，我们来查看平台所有已发布车辆信息

相关的代码为：

//显示所有用户二手车
	public void ShowAllCarsServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		
		/*实现*/	
		int respondid;
		int userid=Integer.parseInt(request.getParameter("userid"));//!!
		List<Car> cars=new ArrayList<Car>();
		//cars=serviceOfCar.getAllCarsList();//获取到所有车主所有车辆(这个会把未发布的汽车也获取到)
		cars=serviceOfCar.getAllReleaseCarsList();//获取已发布车辆
		
		respondid=userid;
		
		/*转发*/
		String message="所有用户的二手车信息页面";		
		/*将消息message转到一个jsp页面success.jsp，在页面打印一个“成功”消息*/
		request.setAttribute("message", message);
		request.setAttribute("cars", cars);
		request.setAttribute("userid", userid);//!!
		request.setAttribute("respondid", respondid);
		request.getRequestDispatcher("/WEB-INF/car/ShowAllCars.jsp").forward(request, response);
	
	}

---

个人用户相关的操作大概就是这些了，下面我们来看看 管理员用户 的相关操作：

管理员可以显示所有用户信息并进行修改等操作，也可以对平台的二手车辆进行管理，下面贴出部分功能的代码：
显示所有用户信息：

	public void ShowAllUserServlet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		java.util.List<User> users=service.getAllUsers();//获取UserService中查询结果
		request.setAttribute("users",users);//把获取到的users放到request里	
		System.out.println("进入ShowAllUserServlet");
		/*转交给jsp页面显示*/
		request.getRequestDispatcher("/WEB-INF/admin/ShowAllUser.jsp").forward(request, response);
	}

并且支持对用户进行模糊查询，比如Name栏什么都不输入，在Sex栏输入”女“，系统就会自动查询到性别是女的所有用户信息，如下图：

显示所有二手车信息：

//（管理员）显示所有车辆信息（比普通用户多了“屏蔽”功能，即 “留言+屏蔽” ）
	//管理员可以看到所有车辆信息，包括未发布的
	public void ShowAllCarForAdminServlet(HttpServletRequest request, HttpServletResponse response) throws Exception {
		System.out.println("进入ShowAllCarForAdminServlet()");
		List<Car> cars=new ArrayList<Car>();
		cars=serviceOfCar.getAllCarsList();//获取到所有车主所有车辆
		String message="所有用户的二手车信息页面";		//(管理员页面)
		
		request.setAttribute("message", message);
		request.setAttribute("cars", cars);
		request.getRequestDispatcher("/WEB-INF/admin/ShowAllCarForAdmin.jsp").forward(request, response);
	
	}

其他剩余的功能这里就不一一演示了。

上面的Servlet调用的业务逻辑实现方法放在CarService和UserService里，下面直接贴出代码：
UserService：

package com.service;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.bean.User;
import com.bean.UserSearchConditions;
import com.dao.UserDao;
import com.daoImpl.UserDaoImpl;
import com.utils.JdbcTools;


public class UserService {
private UserDao dao;
	
	/*获取dao（/初始化）*/
	public UserService() {
		this.dao=new UserDaoImpl();
	}
	
	
	
	//登录login（name+pwd）
		public boolean login(String name, String pwd) throws Exception {
			boolean flag=false;
			Connection connection = null;
			User user = new User(); 
			String sql="select * from user where name='"+name+"' and pwd='"+pwd+"'";
			try {
				
				/*获取连接*/
				connection=JdbcTools.getconnection();
				
				System.out.println("开始调用resultset");
			
				//将查询的结果放在一个ResultSet里面
			ResultSet rs =dao.selectSqlLogin(connection,sql);
			
			System.out.println("查询结果已封装到resultset中");
			
			//遍历ResultSet
			while(rs.next()) {
				
					if(rs.getString("name").equals(name) && rs.getString("pwd").equals(pwd)) {
						flag=true;
					}
					
				} 
				
			}catch (SQLException e) {
					e.printStackTrace();
			}finally {
				JdbcTools.releaseResource(null, connection);
			}
			
			return flag;//true即登录成功
		}
		
		
		//根据name和pwd查找id
		public int LoginFindId(String name, String pwd) throws Exception {
			Connection connection = null;
			User user = new User(); 
			//不能写select id ...，因为下面要用到name和pwd（异常：Column 'name' not found）
			String sql="select * from user where name='"+name+"' and pwd='"+pwd+"'";
			try {
				
				/*获取连接*/
				connection=JdbcTools.getconnection();
				
				System.out.println("开始调用resultset");
			
				//将查询的结果放在一个ResultSet里面
			ResultSet rs =dao.selectSqlLogin(connection,sql);
			System.out.println("查询结果已封装到resultset中");
			
			//遍历ResultSet
			while(rs.next()) {
				System.out.println("进入while(rs.next())");
					if(rs.getString("name").equals(name) && rs.getString("pwd").equals(pwd)) {
						System.out.println("匹配到用户");
						return rs.getInt("id");
					}
					
				} 
				
			}catch (SQLException e) {
					e.printStackTrace();
			}finally {
				JdbcTools.releaseResource(null, connection);
			}		
			return -1;//true即登录成功
		}
		
	
	/*模糊查询*/
	public java.util.List<User> SearchUsersByConditions(UserSearchConditions conditions){
		Connection connection = null;
		java.util.List<User> users=new java.util.ArrayList<User>();
		try {
			/*获取连接*/
			connection=JdbcTools.getconnection();
			/*通过dao将通用查询结果返回给名为user的List保存*/
			users=dao.SearchUsersByConditions(connection,conditions);
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		return users;
	}
	
	
	/*修改 之 实际的对数据库更新*/
	public void UpdateUserServlet(User user){
		Connection connection =null;
		try {
			System.out.println("进入Service的UpdateUserServlet()");
			connection=JdbcTools.getconnection();
			dao.updateUser(connection, user);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		
	}
	

	
	
	/*修改 之 根据id查询user对象*/
	public User getUser(int id){
		User user=new User();
		Connection connection =null;
		try {
			connection=JdbcTools.getconnection();
			user=dao.searchUserById(connection, id);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		return user;
	}
	
	
	
	/*将数据添加到数据库*/
	public boolean RegisterUserServlet(User user) throws Exception {
		boolean result=false;//因为IdCard具有唯一性约束，所以自定义输入数据时可能出错，用result指示
		Connection connection =null;
		try {
			connection=JdbcTools.getconnection();
			dao.addUser(connection,user);
			result=true;//当添加成功时，true
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		return result;
	}
	
	
	
	//删除
	public void DeleteUserServlet(int id) throws Exception {
		Connection connection =null;
		try {
			connection=JdbcTools.getconnection();
			dao.deleteUser(connection, id);
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
	}
	
	public java.util.List<User> getAllUsers(){
		Connection connection = null;
		java.util.List<User> users=new java.util.ArrayList<User>();
		try {
			/*获取连接*/
			connection=JdbcTools.getconnection();
			/*通过dao将通用查询结果返回给名为users的List保存*/
			users =dao.fetchAllUsers(connection);
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		return users;
	}
	
	
	

	
	/*受限用户管理--------更新表信息，将limit属性置为1*/
	//传入id
	public boolean LimitUser(int id) {
		Connection connection =null;
		try {
			
			connection=JdbcTools.getconnection();
			dao.updateLimit(connection, id);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		return false;
	}
	
	
	//根据id判断该用户是否受限(在登录的时候判断)
	public boolean isLimit(int id) throws Exception {
		Connection connection = null;
		User user = new User(); 
		
		//注意：sql不能写"select limit ... 应该写* （否则：数据库查询异常）
		String sql = "select * from user where id='"+id+"'";
		try {
			
			/*获取连接*/
			connection=JdbcTools.getconnection();
			
			System.out.println("开始调用resultset");
		
			//将查询的结果放在一个ResultSet里面
		ResultSet rs =dao.selectSqlLogin(connection,sql);
		
		System.out.println("查询结果已封装到resultset中");
		
		//遍历ResultSet
		while(rs.next()) {
			//rs.getInt("id")记得加引号（虽然id是int型，也要加）
				if(rs.getInt("id")==id) {
					System.out.println("定位到该用户（isLimit()）");
					if((rs.getInt("limit")==0)) {//==0正常用户
						return false;//isLimit=false
					}
				}
			} 
			
		}catch (SQLException e) {
				e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		
		return true;//true即受限用户
	}
	
	
	///
	
	
	
	//*用户角色判断--------判断是否为管理员(返回true为管理员)*/
	//传入id
	public boolean isAdmin(int id) throws Exception {
		Connection connection = null;
		User user = new User(); 

		//注意：sql不能写"select limit ... 应该写* （否则：数据库查询异常）
		String sql = "select * from user where id='"+id+"'";
		try {
			
			/*获取连接*/
			connection=JdbcTools.getconnection();
		
			//将查询的结果放在一个ResultSet里面
		ResultSet rs =dao.selectSqlLogin(connection,sql);
		
		System.out.println("查询结果已封装到resultset中");
		
		//遍历ResultSet
		while(rs.next()) {
			//rs.getInt("id")记得加引号（虽然id是int型，也要加）
				if(rs.getInt("id")==id) {
					System.out.println("定位到该用户（isAdmin()）");
					if((rs.getInt("isAdmin")==1)) {//==1为管理员
						return true;
					}
				}
			} 
			
		}catch (SQLException e) {
				e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		
		return false;//false为普通用户
	}
	
	
	
	
	
}

CarService:

package com.service;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.bean.Car;
import com.dao.CarDao;
import com.dao.UserDao;
import com.daoImpl.CarDaoImpl;
import com.daoImpl.UserDaoImpl;
import com.utils.JdbcTools;

public class CarService {

	private UserDao userdao;
	private CarDao cardao;
	
	/*获取dao（/初始化）*/
	public CarService() {
		this.cardao=new CarDaoImpl();
		this.userdao=new UserDaoImpl();
	}
	
	
	/*将车辆数据添加到数据库*/
	public  boolean AddCarServlet(Car car) throws Exception {
		boolean result=false;//因为IdCard具有唯一性约束，所以自定义输入数据时可能出错，用result指示
		Connection connection =null;
		try {
			connection=JdbcTools.getconnection();
			
			cardao.addCar(connection,car);//实现
			
			result=true;//当添加成功时，true
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		return result;
	}
	
	/*修改 之 根据carid定位到车辆*/
	public Car getCarOfCarid(int carid){
		Car car=new Car();
		Connection connection =null;
		try {
			connection=JdbcTools.getconnection();
			car=cardao.searchCarByCarId(connection, carid);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		return car;//返回car对象
	}
	
	
	/*get 根据userid定位到该车主的所有车辆*/
	public List<Car>getCarsListOfUserid(int userid){
		Connection connection =null;
		List<Car> cars=new ArrayList<Car>();
		try {
			connection=JdbcTools.getconnection();
			cars=cardao.fetchAllCarsByUserId(connection, userid);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		return cars;//返回car对象
	}
	
	
	
	//获取到所有车主所有车辆
	public List<Car> getAllCarsList(){
		Connection connection =null;
		List<Car> cars=new ArrayList<Car>();
		try {
			System.out.println("进入 getAllCarsList");
			connection=JdbcTools.getconnection();
			cars=cardao.fetchAllCars(connection);
		} catch (Exception e) {
			//System.out.println("获取所有车主所有车辆，获取失败");
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		return cars;//返回car对象
	}
	
	
	
	
	//获取已发布车辆
	public List<Car> getAllReleaseCarsList(){
		Connection connection =null;
		List<Car> cars=new ArrayList<Car>();
		try {
			connection=JdbcTools.getconnection();
			cars=cardao.fetchAllReleaseCars(connection);
		} catch (Exception e) {
			//System.out.println("获取所有车主所有车辆，获取失败");
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		return cars;
	}
	
	
	
	
	/*修改 之 实际的对数据库更新*/
	public void UpdateCarSelfServlet(Car car){
		Connection connection =null;
		try {
			connection=JdbcTools.getconnection();
			cardao.updateCar(connection, car);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		
	}
	
	
	
	//删除该用户的某一辆二手车（根据carid）
	public void DeleteCarServlet(int carid) throws Exception {
		Connection connection =null;
		try {
			connection=JdbcTools.getconnection();
			cardao.deleteCar(connection, carid);
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
	}
	
	
	//更新 留言 到数据库
	public void UpdateCarComment(String carcomment,int carid){
		Connection connection =null;
		try {
			connection=JdbcTools.getconnection();
			cardao.updateCarComment(connection,carcomment,carid);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		
	}
	
	
	//发布车辆
	public void ReleaseCarServlet(int carid){
		Connection connection =null;
		try {
			connection=JdbcTools.getconnection();
			cardao.updateRelease(connection,carid);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
		
	}
	
	//禁止该车辆留言功能（根据carid）
	public void RespondBan(int carid){
		Car car=new Car();
		Connection connection =null;
		try {
			connection=JdbcTools.getconnection();
			cardao.updateCanMessage(connection,carid);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcTools.releaseResource(null, connection);
		}
	}
	
	
	
	
}

在Service中调用的对数据库的方法，放在了下面这几个文件中：

这里通过接口的方式进行处理，在接口实现类CarDaoImpl、UserDaoImpl、DaoImpl对数据库进行处理，其中CarDaoImpl和UserDaoImpl都继承了DaoImpl，作为它的子类，在CarDaoImpl、UserDaoImpl中，可以直接调用父类的方法，下面是这几个接口实现类的代码：
（1）DaoImpl：

package com.daoImpl;

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.dao.Dao;

public class DaoImpl<T> implements Dao<T> {
	private QueryRunner queryRunner;//因为QueryRunner是线程安全的，所以可以写在所有方法的外面
	private Class<T> type;//成员变量
	
	/*利用“反射”机制，获取到 类的类型
	 * 下面这个函数本质是站在 DAOImpl 类的一个子类的对象 的角度上考虑
	 * */
	@SuppressWarnings("rawtypes")
	private Class getSuperClassGenricType(Class clazz, int index) {
		Type genType = clazz.getGenericSuperclass();
		if (!(genType instanceof ParameterizedType)) {
			return Object.class;
		}
		Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
		if (index >= params.length || index < 0) {
			return Object.class;
		}
		if (!(params[index] instanceof Class)) {
			return Object.class;
		}
		return (Class) params[index];
	}
	
	/*
	 * 构造器
	 * 1.创建QueryRunner对象
	 * 2.获取类的类型type
	 * */
	@SuppressWarnings("unchecked")
	public DaoImpl() {
		queryRunner = new QueryRunner();
		type = getSuperClassGenricType(getClass(), 0);
	}
	
	
	/*查询（获取）一行数据
	 * 注意：是向函数外抛出异常，而不是在函数内部处理
	 * */
	@Override
	public T fetch(Connection connection, String sql, Object... objects) throws SQLException {
		
		/*BeanHandler需要传入一个“类.class”参数，但是这里并不知道这个类是什么类型（/什么类）
		 * 这里利用到“反射”机制，实现了用于寻找类型type的方法
		 * */
		BeanHandler<T> rsh = new BeanHandler<T>(type);//返回一行数据，用到BeanHandler
		
		return queryRunner.query(connection, sql, rsh, objects);//直接返回这个对象
	}

	@Override
	public List<T> fetchList(Connection connection, String sql, Object... objects) throws SQLException {
		
		/*同上*/
		BeanListHandler<T> rsh = new BeanListHandler<T>(type);//返回一行数据，用到BeanHandler
		
		return queryRunner.query(connection, sql, rsh, objects);//直接返回这个对象
	}

	@Override
	public void update(Connection connection, String sql, Object... objects) throws SQLException {
		queryRunner.update(connection, sql, objects);	
	}

	@Override
	public <E> E fetchScaler(Connection connection, String sql, Object... objects) throws SQLException {
		ScalarHandler <E> rsh =new ScalarHandler<E>();//泛型
		return (E) queryRunner.query(connection, sql, rsh, objects);//强制转换为(E)
	}

}

（2）CarDaoImpl：

package com.daoImpl;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

import com.bean.Car;
import com.bean.CarSearchConditions;
import com.bean.User;
import com.dao.CarDao;

/*继承父类，这里实现的是Car表，类型是Car
 * 
 * 继承DaoImpl,可以直接使用里面的方法
 * */
public class CarDaoImpl extends DaoImpl<Car> implements CarDao {

	@Override
	public void addCar(Connection connection, Car car) throws SQLException {
		
		String sql = "INSERT INTO car (userid,brand,model,price,color,carcomment) VALUES (?,?,?,?,?,?)";//属性carid是递增，所以这里不用写(默认的属性也不用写)
	
		Object[] objs = {car.getUserid(),car.getBrand(),car.getModel(),car.getPrice(),car.getColor(),car.getCarcomment() };//用对象去类中获取数据
		//queryRunner.update(connection, sql, objs);//调用QueryRunner类中的方法
		update(connection,sql,objs);//更新数据库

	}

	@Override
	public void deleteCar(Connection connection, int carid) throws SQLException {
		String sql = "DELETE FROM car WHERE carid=?";
		update(connection, sql, carid);
	}

	@Override
	public void updateCar(Connection connection, Car car) throws SQLException {
		String sql = "UPDATE car set brand=?,model=?,price=?,color=?,carcomment=? WHERE carid=?";
		Object[] objs = {car.getBrand(),car.getModel(),car.getPrice(),car.getColor(),car.getCarcomment(),car.getCarid()};
		update(connection, sql, objs);
		
	}
	
	//更新留言
	public void updateCarComment(Connection connection,String carcomment,int carid) 
			throws SQLException{
		String sql = "UPDATE car set carcomment=? WHERE carid=?";
		update(connection, sql, carcomment,carid);
	}

	
	///更新发布信息
	public void updateRelease(Connection connection,int carid) 
			throws SQLException{
		String sql = "UPDATE car set isrelease=1 WHERE carid=?";
		update(connection, sql,carid);
	}
	
	
	@Override
	public Car searchCarByCarId(Connection connection, int carid) throws SQLException {
		String sql = "SELECT * FROM car WHERE carid=?";
		return fetch(connection, sql, carid);
	}
	

	
//获取所有用户所有车辆
	@Override
	public List<Car> fetchAllCars(Connection connection) throws SQLException {
		String sql = "SELECT * FROM car";
		return fetchList(connection, sql);
	}
	
	
	//获取已发布车辆
	@Override
	public List<Car> fetchAllReleaseCars(Connection connection) throws SQLException {
		String sql = "SELECT * FROM car where isrelease=1";
		return fetchList(connection, sql);
	}
	

	
	//根据userid找到该车主名下所有汽车
	public List<Car> fetchAllCarsByUserId(Connection connection,int userid) throws SQLException {
		String sql = "SELECT userid,carid,brand,model,price,color,datePosted,isrelease,CanMessage,carcomment FROM car where userid=?";
		System.out.println("在fetchAllCarsByUserId即将调用fetchList执行sql");

		return fetchList(connection, sql,userid);
	}
	
	
	@Override
	public List<Car> SearchCarsByConditions(Connection connection, CarSearchConditions conditions)
			throws SQLException {
		// TODO Auto-generated method stub
		return null;
	}
	
	
	//禁止该车辆留言功能
	public void updateCanMessage(Connection connection,int carid) 
			throws SQLException{
		String sql = "UPDATE car set canmessage=1 WHERE carid=?";
		update(connection, sql,carid);
	}

}

（3）UserDaoImpl：

package com.daoImpl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.apache.commons.dbutils.QueryRunner;

import com.bean.User;
import com.bean.UserSearchConditions;
import com.dao.UserDao;

/*继承父类，这里实现的是User表，类型是User
 * 
 * 继承DaoImpl,可以直接使用里面的方法
 * */
public class UserDaoImpl extends DaoImpl <User> implements UserDao {
	static ResultSet rs = null;
	static PreparedStatement ps =null;

		/*因为QueryRunner是线程安全的，所以可以写在所有方法的外面*/
		QueryRunner queryRunner=new QueryRunner();//QueryRunner类
		
		
		//登录验证（name+pwd）
		public ResultSet selectSqlLogin(Connection connection,String sql){
			try {
				ps=connection.prepareStatement(sql);
				rs=ps.executeQuery(sql);
			} catch (Exception e) {
				// TODO Auto-generated catch block
				System.out.println("数据库查询异常");
				e.printStackTrace();
			}
			return rs;//返回查询的数据集
	}
		
		
		public void addUser(Connection connection, User user) throws SQLException {
			String sql = "INSERT INTO user (name,pwd, sex) VALUES ( ?, ?, ?)";//属性id是递增，所以这里不用写
			Object[] objs = {user.getName(), user.getPwd(), user.getSex()};//用对象去类中获取数据
			//queryRunner.update(connection, sql, objs);//调用QueryRunner类中的方法
			update(connection,sql,objs);//更新数据库
		}

		public void deleteUser(Connection connection, int id) throws SQLException {
			String sql = "DELETE FROM user WHERE id=?";
			update(connection, sql, id);
		}

		public void updateUser(Connection connection, User user) throws SQLException {
			System.out.println("进入UserDaoImpl的updateUser");
			String sql = "UPDATE user set name=?, pwd=?, sex=? WHERE id=?";
			Object[] objs = {user.getName(), user.getPwd(), user.getSex(), user.getId()};
			update(connection, sql, objs);
		}

		public User searchUserById(Connection connection, int id) throws SQLException {
			String sql = "SELECT id,name,pwd,sex,isAdmin FROM user WHERE id=?";
			return fetch(connection, sql, id);
		}

		public List<User> fetchAllUsers(Connection connection) throws SQLException {
			String sql = "SELECT * FROM user";
			return fetchList(connection, sql);
		}
		

		
		
		//模糊查询
		public List<User> SearchUsersByConditions(Connection connection, UserSearchConditions conditions) throws SQLException {
			String sql = "SELECT name,sex FROM user " //这里换行时要加个空格，否则会与下面的where识别成一个单词
		+"WHERE name like ? AND sex like ?";
			Object[] objs= {conditions.getName(),conditions.getSex()};
			return fetchList(connection, sql,objs);
		}
	

		
		//受限用户管理（管理员权限）
		public void updateLimit(Connection connection, int id) 
				throws SQLException{
			System.out.println("进入updateLimit，下面创建sql");
			
			/*注意，limit在mysql是关键字，在这里要加符号圈起来*/
			String sql = "UPDATE user set `limit`=1 WHERE id=?";
			
			System.out.println("sql创建完成，下面开始执行sql");
//			ps=connection.prepareStatement(sql);
//			ps.executeQuery(sql);
			//queryRunner.update(connection, sql);
			update(connection, sql, id);
			System.out.println("limit更新成功");
		}
	
		
		//登录时查询该用户是否受限
		public ResultSet SearchIsLimit(Connection connection, String sql) 
				throws SQLException{
			try {
			ps=connection.prepareStatement(sql);
			rs=ps.executeQuery(sql);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			System.out.println("数据库查询异常");
			e.printStackTrace();
		}
			return rs;//返回查询的数据集
		}
		

	
}

六、结语

纵观整个项目，可以发现，在实现具体的功能时，方法都是大同小异，基于MVC模式让代码的逻辑结构变得清晰，在功能实现上也变得方便快捷，遇到报错也能够迅速定位到错误的地方，并且基于这种模式在后期系统扩容或更新时会让维护更加简单，不需要进行彻头彻尾的大变动。
这个项目所实现的功能并不复杂，只能作为一个入门项目，分析完这个项目，可以让你对该项目设计到的技术有个更加清晰的认识，并通过这个项目，作为一个敲门砖，打开你对这一方向的大门，为更加深入的学习各种框架以及更加深入的知识打下一个基础。作为一名学生，我也在不断地努力，也许这篇文章并不能给你的学习甚至工作带来帮助，但是只要我们有一颗爱学并且上进的心，一切都会变得美好。我也是第一次写这么长的文章，里面的不足之处肯定也体现的很明显，我很欢迎各位路过的大神对我这个项目进行批评指正，我会虚心接受您的意见，并不断学习。大家一起加油！