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

评论 5 您还未登录,请先 登录 后发表或查看评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:数字20 设计师:CSDN官方博客 返回首页

打赏作者

啊泽泽泽zz

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值