“烤鱼铺子”门店管理系统开发笔记

it2023-10-24 77

“烤鱼铺子”门店管理系统开发笔记

1.项目开发说明

利用之前学过的MySQL、JSP、JSTL、html、css等技术，以及目前市面上最流行的企业级Java开发框架SSM实现一个《“烤鱼铺子”门店管理系统》，其中包括门店管理模块和订单管理模块，两个模块中，实现了对门店和订单信息的增删改查功能...

2.数据库及表设计

门店表结构：

订单表结构：

执行SQL语句，创建库和所需表：

create database if not exists kaoyudoor charset utf8; use kaoyudoor; drop table if exists tb_order; drop table if exists tb_door; -- 创建门店表 create table tb_door( id int PRIMARY KEY auto_increment, name VARCHAR(100), tel VARCHAR(100), addr VARCHAR(255) ); -- 在门店表中插入记录 INSERT INTO tb_door VALUES('1','烤鱼铺子（康庄店）','023-86818282','重庆市渝北区康庄'); INSERT INTO tb_door VALUES('2','烤鱼铺子（大竹林店）','023-76642334','重庆市渝北区大竹林'); INSERT INTO tb_door VALUES('3','烤鱼铺子（冉家坝店）','023-32233234','重庆市渝北区冉家坝'); INSERT INTO tb_door VALUES('4','烤鱼铺子（光电园店）','023-86818282','重庆市渝北区光电园'); INSERT INTO tb_door VALUES('5','烤鱼铺子（江与城店）','023-86818282','重庆市渝北区江与城'); -- 删除订单表（如果存在） DROP TABLE IF EXISTS tb_order; -- 创建订单表 CREATE TABLE tb_order( id int(11) PRIMARY KEY auto_increment, door_id int(11), order_no VARCHAR(50), order_type VARCHAR(50), -- 订单类型（堂食/外卖/打包） pnum INT, -- 用餐人数 cashier VARCHAR(50), -- 收银员 order_time TIMESTAMP NOT NULL DEFAULT '0000-00-00 00:00:00', -- 下单时间 pay_time TIMESTAMP NOT NULL DEFAULT '0000-00-00 00:00:00', -- 支付时间 pay_type VARCHAR(50), -- 支付类型（微信支付/支付宝支付） price double, FOREIGN KEY(door_id) REFERENCES tb_door(id) -- tb_door表中的id是这个表的外键 ); -- 往订单表中插入记录 INSERT INTO tb_order VALUES('1','1','P001','堂食','2','张仅','2020-05-22 13:35:07','2020-05-22 13:36:21','支付宝支付','78.88'); INSERT INTO tb_order VALUES('2','1','P005','打包','4','张仅','2020-05-22 14:01:02','2020-05-22 14:01:34','微信支付','108.08'); INSERT INTO tb_order VALUES('3','1','P006','外卖','1','张仅','2020-05-22 14:11:23','2020-05-22 14:12:51','微信支付','98.03'); INSERT INTO tb_order VALUES('4','1','P009','堂食','5','刘念','2020-05-22 14:11:57','2020-05-22 14:47:16','支付宝支付','205.88'); INSERT INTO tb_order VALUES('5','1','P012','堂食','3','刘念','2020-05-22 14:15:43','2020-05-22 14:16:41','微信支付','98.37');

3.项目环境搭建(SSM整合)

3.1 项目环境搭建

1.IDEA创建Maven的简单web工程

2.在src/main下新建java文件夹标记为源码文件夹，新建resources文件夹标记为资源文件夹，新建test/java文件夹标记为测试源码文件夹，新建test/resources文件夹为测试资源文件夹

3.创建包和目录

4.在pom.xml文件中，引入junit、log4j、servlet等依赖包

<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency>  <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>1.6.4</version> </dependency>  <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.4.RELEASE</version> </dependency>  <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>4.3.8.RELEASE</version> </dependency>  <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.2.9.RELEASE</version> </dependency>  <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.3</version> </dependency>  <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.3</version> </dependency>  <dependency> <groupId>c3p0</groupId> <artifactId>c3p0</artifactId> <version>0.9.1.2</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.32</version> </dependency>  <dependency> <groupId>jstl</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jsp-api</artifactId> <version>2.0</version> </dependency>  <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.9.9.3</version> </dependency>  <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.1</version> </dependency> </dependencies>

5.在resources目录下创建log4j.properties文件，配置内容如下:

# Global logging configuration log4j.rootLogger=DEBUG, stdout # Console output... log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%5p [%t] %m%n

6.在resources目录下创建jdbc.properties文件，配置内容如下:

db.driverClassName=com.mysql.jdbc.Driver db.url=jdbc:mysql:///yonghedb?characterEncoding=utf-8 db.username=root db.password=root

3.2 整合spring框架

1.在pom.xml文件中，引入spring的依赖包

2.在src/main/resources/spring目录下，创建spring的核心配置文件：applicationContext.xml

配置内容如下：

3.3 整合springmvc框架

前面在添加spring的jar包同时,将springmvc的jar包也引入了，因此这里不再引入springmvc的jar包

1.在resources/spring目录下，创建springmvc的核心配置文件：springmvc-config.xml，内容配置如下：

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">  <mvc:default-servlet-handler/>  <mvc:annotation-driven></mvc:annotation-driven>  <context:component-scan base-package="com.zhang.controller"></context:component-scan>  <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/pages/"/> <property name="suffix" value=".jsp"/> </bean> </beans>

2.在web.xml中配置springmvc

<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5"> <welcome-file-list> <welcome-file>index.html</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.jsp</welcome-file> <welcome-file>default.html</welcome-file> <welcome-file>default.htm</welcome-file> <welcome-file>default.jsp</welcome-file> </welcome-file-list>  <servlet> <servlet-name>springmvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring/*.xml</param-value> </init-param> </servlet>  <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>  <filter> <filter-name>encodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  <init-param> <param-name>encoding</param-name> <param-value>utf-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>encodingFilter</filter-name>  <url-pattern>/*</url-pattern> </filter-mapping> </web-app>

3.测试springmvc框架:

（1）在WEB-INF/pages/目录下，创建test.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>TEST</title> </head> <body> <h1>TEST</h1> </body> </html>

(2)创建测试Controller: DoorController

/** 测试类：测试springmvc开发环境 */ @Controller public class DoorController { @RequestMapping("/testmvc") public String testmvc(){ return "test"; } }

（2）测试访问

3.4 整合mybatis框架

1.在pom.xml文件中，引入mybatis及相关依赖包

<dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.2.8</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>1.2.2</version> </dependency>  <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.32</version> </dependency>  <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.6</version> </dependency>

2.在resources/mybatis目录下，创建mybatis的核心配置文件：mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">  <configuration >  <environments default="develop">  <environment id="develop">  <transactionManager type="JDBC"></transactionManager>  <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/kaoyudoor"/> <property name="username" value="root"/> <property name="password" value="root"/> </dataSource> </environment> </environments>  <mappers> <mapper resource="mybatis/mapper/DoorMapper.xml"/> </mappers> </configuration>

3.在src/main/resources/mybatis/mapper目录下，创建Door实体类的映射文件：DoorMapper.xml

配置内容如下：

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  <mapper namespace="com.zhang.dao.DoorDao">  <select id="findAll" resultType="com.zhang.pojo.Door"> select * from tb_door </select> </mapper>

4.在mybatis的全局配置文件中引入DoorMapper.xml映射文件

<mappers> <mapper resource="mybatis/mapper/DoorMapper.xml"/> </mappers>

5.创建实体类Door，用于封装所有的门店信息

package com.zhang.pojo; public class Door { private int id; //门店号 private String name; //门店名称 private String tel; //门店电话 private String addr; //门店地址 //getter和setter方法 public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getTel() { return tel; } public void setTel(String tel) { this.tel = tel; } public String getAddr() { return addr; } public void setAddr(String addr) { this.addr = addr; } //重写toString方法 @Override public String toString() { return "Door{" + "id=" + id + ", name='" + name + '\'' + ", tel='" + tel + '\'' + ", addr='" + addr + '\'' + '}'; } }

6.创建com.zhang.dao.DoorDao接口，并根据DoorMapper.xml文件中的sql语句，提供findAll方法

package com.zhang.dao; import com.zhang.pojo.Door; import java.util.List; /* * DoorDao接口 * 声明增删改查方法，对门店信息进行操作 * */ public interface DoorDao { /* * 1.查询所有门店信息 * */ public List<Door> findAll(); }

7.创建测试com.zhang.controller.TestMybatis类，对mybatis开发环境进行测试

package com.test; import com.zhang.dao.DoorDao; import com.zhang.pojo.Door; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import org.junit.Test; import javax.annotation.Resource; import java.io.IOException; import java.io.InputStream; import java.util.List; /* 测试类 */ public class Tests { //测试mybatis开发环境 @Test public void testMybatis() throws Exception { //1.读取mybatis-config.xml核心文件 InputStream in = Resources.getResourceAsStream("mybatis/mybatis-config.xml"); //2.获取SqlSessionFactory工厂 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in); //3.获取SqlSession对象 SqlSession session = factory.openSession(); //4.获取DoorDao接口的实例 DoorDao mapper = session.getMapper(DoorDao.class); //5.调用findAll方法查找所有门店信息 List<Door> list = mapper.findAll(); //6.遍历所有门店信息 for (Door door : list){ System.out.println(door); } } }

执行结果：

3.5 整合spring和mybatis

1.修改mybatis-config.xml文件，将数据源等配置移除，在spring的配置文件中配置

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">  <configuration >           </configuration>

2.在applicationContext.xml中配置 druid连接池、SqlSession工厂等

由spring负责创建mybatis在运行过程中，所需要的一些对象。比如: SqlSession对象、SqlSession工程对象、连接池对象、Mapper接口的子类实例等都会交给spring容器创建

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">  <context:component-scan base-package="com.zhang"></context:component-scan>  <context:property-placeholder location="classpath:jdbc.properties"/>  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">  <property name="driverClassName" value="${db.driverClassName}"></property> <property name="url" value="${db.url}"></property> <property name="username" value="${db.username}"></property> <property name="password" value="${db.password}"></property> </bean>  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>  <property name="dataSource" ref="dataSource"></property>  <property name="mapperLocations" value="classpath:mybatis/mapper/*.xml"/> </bean>  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  <property name="basePackage" value="com.zhang.dao"/> </bean> </beans>

3.在resources目录下创建jdbc.properties文件，将连接数据库的基本信息提取到文件中

db.driverClassName=com.mysql.jdbc.Driver db.url=jdbc:mysql://localhost:3306/kaoyudoor db.username=root db.password=root

4.新建TestSSM测试类

package com.test.controller; import com.zhang.dao.DoorDao; import com.zhang.pojo.Door; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import java.util.List; /* * 测试类，测试SSM开发环境 * */ @Controller public class TestSSM { /* * 自动装配，由spring自动为属性赋值（对象） * */ @Autowired DoorDao doorDao; @RequestMapping("/testssm") public String testSSM(){ //1.调用findAll方法查询所有门店信息 List<Door> doors = doorDao.findAll(); //2.遍历查询出的所有门店信息 for (Door door : doors){ System.out.println(door); } return "test"; } }

4.查询所有门店

查询所有门店开发步骤：

1、点击【门店管理】，访问DoorController中的查询所有门店信息的方法【doorList】

2、在【doorList】方法中调用service层，service层再调用dao层查询所有门店信息，返回所有门店信息的List<Door>集合

3、在【doorList】方法中，将返回的所有门店信息集合（List<Door>）存入Model中，并转向door_list.jsp（即 return "door_list"），将所有门店信息带到jsp页面进行显示

4.1 准备工作（若上面已创建，直接跳过即可！）

1、创建Door实体类，用于封装所有的门店信息（若上面已创建，直接跳过即可！）

2.创建Door实体类的映射文件—DoorMapper.xml（若上面已创建，直接跳过即可！）

配置内容如下：

4.2 dao层代码实现（若上面已创建，直接跳过即可！）

1.更新resources/mybatis/mapper/DoorMapper.xml文件，添加“查询所有门店信息”SQL（若上面已创建，直接跳过即可！）

<select id="findAll" resultType="com.zhang.pojo.Door"> SELECT * FROM tb_door </select>

2.创建DoorDao接口, 添加查询所有门店方法（若上面已创建，直接跳过即可！）

代码实现如下：

4.4 service层代码实现

1.创建DoorService类，提供getAll方法，调用dao层的findAll方法，查询所有门店信息，返回list集合

package com.zhang.service; import com.zhang.dao.DoorDao; import com.zhang.pojo.Door; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.List; @Service public class DoorService { @Autowired DoorDao doorDao; //查询所有门店 public List<Door> getAll(){ return doorDao.findAll(); } }

4.3 controller层代码实现

1、创建DoorController类，提供doorList方法，处理"/doors"请求，跳转到door_list页面，调用service层的getAll方法，查询所有门店信息

package com.zhang.controller; import com.zhang.pojo.Door; import com.zhang.service.DoorService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.RequestMapping; import java.util.List; /* @Controller作用1：将当前对象的创建交给spring管理 * 作用2：作为控制层代码的标识 */ @Controller public class DoorController { /* 在spring的配置文件中配置过dao包扫描, 在程序执行时, 框架底层 * 会扫描dao包下的所有mapper接口, 为接口提供子类, 并根据子类 * 创建实例——即接口的子类实例, @Autowired可以根据接口的类型 * 到spring容器中获取接口的子类实例, 并赋值给dao! */ @Autowired DoorService doorService; //1.查询所有的门店信息 @RequestMapping("/doors") public String doorList(Model model){ //调用service层的getAll方法，查询所有的门店信息 List<Door> list = doorService.getAll(); // for(Door d : list){ // System.out.println(d); // } //将门店集合存入到Model中 model.addAttribute("doors", list); //跳转到门店列表(door_list.jsp)页面(在该页面中展示所有门店信息) return "door_list"; } }

4.4 在页面上显示所有门店列表

1.导入页面JSP

2、创建通用的页面跳转方法

@PathVariable 映射 URL 绑定的占位符

URL 中的 {xxx} 占位符可以通过@PathVariable(“xxx“) 绑定到操作方法的入参中

举例：现在要访问/WEB-INF/pages/index.jsp页面，按照之前的讲解，我们会在Controller中添加一个方法，例如：

@RequestMapping("/index") public String index(){ return "index"; }

如果有很多这样的jsp页面需要我们访问呢？每访问一个jsp都要在Controller中添加一个方法吗？毫无疑问，这样做太繁琐了

通过上面的观察，我们可以发现，@RequestMapping("/index") 中的"/" index" 和return "index"中的"index"名称是相同的，按照此规律，我们可以提供一个通用的页面跳转方法，访问路径中的名字是什么，就回/WEBINF/pages/下的什么JSP页面

因此，创建PageController类，代码实现如下：

package com.zhang.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; @Controller public class PageController { /* 声明一个通用的页面跳转方法: 通过访问jsp的名字 * 可以跳转到/WEB-INF/pages/下面指定名字的jsp页面 * 其中{}中的 jspName 用于接收访问的路径名, 例如: * 访问地址为: localhost/项目名称/index * 此时, jspName的值就是 index * 再将{}中jspName的值传递给方法上的形参jspName,值也为index * 最后再将jspName作为返回值返回, 也就是跳转到指定名称的jsp */ @RequestMapping("/{jspName}") public String toJsp(@PathVariable("jspName") String jspName) { return jspName; //可以跳转到任何的jsp } }

3.更新DoorController代码，将门店list集合存入model带到JSP显示（4.3.1已实现）

//1.查询所有的门店信息 @RequestMapping("/doors") public String doorList(Model model){ //调用service层的getAll方法，查询所有的门店信息 List<Door> list = doorService.getAll(); // for(Door d : list){ // System.out.println(d); // } //将门店集合存入到Model中 model.addAttribute("doors", list); //跳转到门店列表(door_list.jsp)页面(在该页面中展示所有门店信息) return "door_list"; }

4、完成door_list.jsp，实现门店展示

<%@ page pageEncoding="utf-8"%> <%-- 引入JSTL标签库 --%> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <!DOCTYPE HTML> <html> <head> <title>门店管理</title> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> <style type="text/css"> body{ font-family: "微软雅黑"; background-color: #EDEDED; } h2{ text-align: center;} table{ width:96%; margin: 0 auto; text-align: center; border-collapse:collapse; font-size:16px;} td, th{ padding: 5px;} th{ background-color: #DCDCDC; width:120px; } th.width-40{ width: 40px; } th.width-70{ width: 70px; } th.width-80{ width: 80px; } hr{ margin-bottom:20px; border:1px solid #aaa; } #add-door{text-align:center;font-size:20px;} </style> </head> <body> <h2>门店管理</h2> <div id="add-door"> <a href="door_add" target="rightFrame">新增门店</a> </div> <hr/> <table border="1"> <tr> <th class="width-40">序号</th> <th>门店名称</th> <th class="width-80">联系电话</th> <th>门店地址</th> <th class="width-80">操作</th> </tr>  <c:forEach items="${ doors }" var="door" varStatus="sta"> <tr> <td>${ sta.count }</td> <td>${ door.name }</td> <td>${ door.tel }</td> <td>${ door.addr }</td> <td> <a href="doorDelete?id=${ door.id }">删除</a>  |  <a href="doorInfo?id=${ door.id }">修改</a> </td> </tr> </c:forEach> </table> </body> </html>

5.删除门店信息

删除门店信息开发步骤：

1、在门店信息列表页面中，点击门店信息后的【删除】按钮，访问DoorController中的【doorDelete】方法，访问的同时将所要删除的门店id一同提交给服务器

2、在【doorDelete】方法中，通过参数接收门店id，调用service层，service层再调用dao层通过id删除指定的门店信息

3、删除成功后，重定向到门店列表页面，显示所有门店（即重定向到DoorController的【doorList】方法，先查询所有门店，再将所有门店信息带到JSP显示）

4、需要注意的是：因为门店表和订单表存在关联关系，并且在订单表中添加了外键，因此如果该门店下有订单，门店不能删除（可以设置级联删除，在删除门店的同时，将订单表中的对应订单也删除，详细参考mysql课程讲义中的扩展内容）

5.1 Dao层代码实现

1.更新com.zhang.dao.DoorDao接口，添加 deleteById方法，根据id删除门店信息

2.更新resources/mybatis/mapper/DoorMapper.xml文件，添加“删除门店信息”SQL

<delete id="deleteById"> DELETE FROM tb_door WHERE id=#{id} </delete>

5.2 Service层实现，Service层调用Dao层deleteById方法

//根据id删除指定门店 public void deleteById(Integer id){ doorDao.deleteById(id); }

5.3 Controller层代码实现

更新com.zhang.controller.DoorController类，添加并实现doorDelete方法：调用service层的deleteById方法删除门店信息

//2.根据id删除指定门店 @RequestMapping("/deldoor") public String delDoor(Integer id){ //调用DoorService的deleteById方法, 根据id删除门店信息 doorService.deleteById(id); //删除成功后,转发到查询门店的方法, 显示最新门店信息 return "forward:/doors"; }

6.新增门店信息

新增门店信息开发步骤：

1、在门店信息列表页面中，点击【新增门店】，跳转到门店新增页面【door_add.jsp】

2、用户在【door_add.jsp】中输入新增的门店信息，点击【提交】将门店信息提交给DoorController的【doorAdd】方法

3、在【doorAdd】方法中，通过参数接收浏览器提交过来的门店信息，调用service层，service层再调用dao层将门店信息保存到数据库中

4、新增成功后，重定向到门店列表页面，显示所有门店（即重定向到DoorController的【doorList】方法，先查询所有门店，再将所有门店信息带到JSP显示）

6.1 dao层代码实现

1.更新resources/mybatis/mapper/DoorMapper.xml文件，添加“新增门店信息”SQL

<insert id="addDoor"> INSERT INTO tb_door VALUE(null,#{name},#{tel},#{addr}) </insert>

2.更新com.zhang.dao.DoorDao接口，添加 addDoor方法，新增门店信息

public interface DoorDao { /** 1、查询所有的门店信息 */ public List<Door> findAll(); /** 2、根据id删除门店信息 */ public void deleteById(Integer id); /** 3、新增门店信息 */ public void addDoor(Door door); }

6.2 Service层代码实现

//新增门店信息 public void addDoor(Door door){ doorDao.addDoor(door); }

6.3 Controller层代码实现

更新com.zhang.controller.DoorController类，添加并实现doorAdd方法：调用service层的addDoor方法新增门店信息

/** 3、新增门店信息 * 接收客户端提交过来的门店信息(name,tel,addr) */ @RequestMapping("/doorAdd") public String doorAdd(Door door){ //调用DoorService的addDoor方法，新增门店信息 doorService.addDoor(door); //跳转到查询所有门店的方法，显示最新门店信息 return "forward:/doors"; }

7.更新门店信息

更新门店信息开发步骤：

1、在门店信息列表页面中，点击门店信息后的【修改】按钮，访问DoorController中的【doorInfo】方法，访问的同时将所要查询的门店id一同提交给服务器

2、在【doorInfo】方法中，通过参数接收门店id，调用service层，service层再调用dao层通过id查询指定的门店信息（Door）并返回

3、在【doorInfo】方法中，将返回的门店信息（Door）存入Model中，并转向door_update.jsp（即 return "door_update"），将门店信息带到jsp页面进行回显

4、在原有门店信息的基础上，对门店信息进行修改，点击【提交】将修改后的门店信息提交给DoorController的【doorUpdate】方法

5、在【doorUpdate】方法中，通过参数接收浏览器提交过来的门店信息，调用service层，service层再调用dao层根据id修改门店信息

6、修改成功后，重定向到门店列表页面，显示所有门店（即重定向到DoorController的【doorList】方法，先查询所有门店，再将所有门店信息带到JSP显示）

7.1 dao层代码实现（查询并回显门店）

修改门店信息需要在原有门店信息的基础上进行修改，因此在修改之前，需要先查询出原有门店信息，在原有门店信息的基础上修改后，再将修改后的门店信息提交给服务器端，服务器端将修改后的门店信息更新到数据库中

1.更新resources/mybatis/mapper/DoorMapper.xml文件，添加“根据id查询门店信息”SQL

<select id="findById" resultType="com.zhang.pojo.Door"> SELECT * FROM tb_door WHERE id=#{id} </select>

2.更新com.zhang.dao.DoorDao接口，添加 findById方法，根据id查询门店信息

package com.zhang.dao; import com.zhang.pojo.Door; import java.util.List; /* * DoorDao接口 * 声明增删改查方法，对门店信息进行操作 * */ public interface DoorDao { //1.查询所有门店信息 public List<Door> findAll(); //2.根据id删除门店信息 public void deleteById(Integer id); //3.新增门店信息 public void addDoor(Door door); //4.根据id查找门店信息 public Door findById(Integer id); }

7.2 Service层代码（查询并回显门店）

//根据id查询指定门店 public Door findById(Integer id){ return doorDao.findById(id); }

7.3 Controller层代码实现（查询并回显门店）

更新com.zhang.controller.DoorController类，添加并实现doorInfo方法：调用service层的findById方法根据id查询门店信息

/* * 4.根据id查寻指定门店信息 * 将查询到的门店信息带到门店修改页面, 进行数据的回显 * */ @RequestMapping("/doorInfo") public String findById(Model model, Integer id){ //调用DoorService的findById方法，根据id查询门店信息 Door door = doorService.findById(id); //将门店信息带回门店修改页面，进行回显 model.addAttribute("door", door); //转发到门店修改页面,在门店修改页面取出door回显数据 return "door_update"; }

7.4 修改页面门店回显

在door_update.jsp中显示将要修改的门店信息:

将要修改的门店信息回显至修改页面后，下面实现修改门店信息

7.5 dao层代码实现（更新并回显门店）

1.更新resources/mybatis/mapper/DoorMapper.xml文件，添加“根据id更新门店信息”SQL：

<update id="updateById"> UPDATE tb_door SET name=#{name},tel=#{tel},addr=#{addr} WHERE id=#{id} </update>

2.更新com.zhang.dao.DoorDao接口，添加 updateById方法，根据id更新门店信息

7.6 Service层代码实现

//根据id修改门店信息 public void updateDoor(Door door){ doorDao.updateDoor(door); }

7.7 Controller层代码实现（更新门店）

更新com.zhang.controller.DoorController类，添加并实现doorUpdate方法：调用service层的updaeDoor方法更新门店信息

/* * 5.根据id修改门店信息 * */ @RequestMapping("/doorUpdate") public String doorUpdate(Door door){ //调用DoorService的updateDoor方法，修改门店信息 doorService.updateDoor(door); //跳转到查询所有门店的方法, 显示最新门店信息 return "forward:/doors"; }

8.查询所有订单

查询所有订单开发步骤：

1、点击【订单管理】，访问OrderController中的查询所有订单信息的方法【doorList】

2、在【orderList】方法中调用service层，service层再调用dao层查询所有订单信息，返回所有订单信息的List<Order>集合

3、在【orderList】方法中，将返回的所有订单信息集合（List<Order>）存入Model中，并转向order_list.jsp（即 return "order_list"），将所有订单信息带到jsp页面进行显示

8.1 准备工作

1.创建com.zhang.pojo.Order实体类，用于封装所有的订单信息

package com.zhang.pojo; import java.util.Date; /* * 订单实体类 * */ public class Order { private Integer id; //订单id private Integer doorId; //门店编号 private String orderNo; //订单编号 private String orderType; //订单类型 private Integer pnum; //用餐人数 private String cashier; //收银员 private Date orderTime; //下单时间 private Date payTime; //结账时间 private String payType; //支付方式 private double price; //支付金额 //getter和setter方法 public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public Integer getDoorId() { return doorId; } public void setDoorId(Integer doorId) { this.doorId = doorId; } public String getOrderNo() { return orderNo; } public void setOrderNo(String orderNo) { this.orderNo = orderNo; } public String getOrderType() { return orderType; } public void setOrderType(String orderType) { this.orderType = orderType; } public Integer getPnum() { return pnum; } public void setPnum(Integer pnum) { this.pnum = pnum; } public String getCashier() { return cashier; } public void setCashier(String cashier) { this.cashier = cashier; } public Date getOrderTime() { return orderTime; } public void setOrderTime(Date orderTime) { this.orderTime = orderTime; } public Date getPayTime() { return payTime; } public void setPayTime(Date payTime) { this.payTime = payTime; } public String getPayType() { return payType; } public void setPayType(String payType) { this.payType = payType; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } 重写toString方法 @Override public String toString() { return "Order{" + "id=" + id + ", doorId=" + doorId + ", orderNo='" + orderNo + '\'' + ", orderType='" + orderType + '\'' + ", pnum=" + pnum + ", cashier='" + cashier + '\'' + ", orderTime=" + orderTime + ", payTime=" + payTime + ", payType='" + payType + '\'' + ", price=" + price + '}'; } }

2.在resources/mybatis/mapper目录下创建Order实体类的映射文件—OrderMapper.xml

8.2 dao层代码实现

1.更新resources/mybatis/mapper/OrderMapper.xml文件，添加“查询所有订单信息”SQL

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  <mapper namespace="com.zhang.dao.OrderDao">  <resultMap type="com.zhang.pojo.Order" id="orderRM"> <id column="id" property="id"/> <result column="door_id" property="doorId"/> <result column="order_no" property="orderNo"/> <result column="order_type" property="orderType"/> <result column="pnum" property="pnum"/> <result column="cashier" property="cashier"/> <result column="order_time" property="orderTime"/> <result column="pay_time" property="payTime"/> <result column="pay_type" property="payType"/> <result column="price" property="price"/> </resultMap>  <select id="findAll" resultMap="orderRM"> SELECT * FROM tb_order </select> </mapper>

2.创建com.zhang.dao.OrderDao接口, 添加查询所有订单方法，代码实现如下：

package com.zhang.dao; import com.zhang.pojo.Order; import java.util.List; /* * 订单模块的Dao接口 */ public interface OrderDao { //1、查询所有的订单信息 public List<Order> findAll(); }

8.3 Service层代码实现

package com.zhang.service; import com.zhang.dao.OrderDao; import com.zhang.pojo.Order; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.List; @Service public class OrderService { @Autowired OrderDao orderDao; //1.查询所有订单信息 public List<Order> findAll(){ return orderDao.findAll(); } }

8.4 controller层代码实现

1.创建OrderController类，提供orderList方法：调用service层的findAll方法，查询所有订单信息

package com.zhang.controller; import com.zhang.pojo.Door; import com.zhang.pojo.Order; import com.zhang.service.DoorService; import com.zhang.service.OrderService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.RequestMapping; import java.util.List; @Controller public class OrderController { @Autowired DoorService doorService; @Autowired OrderService orderService; //1.查询所有订单 @RequestMapping("/orders") public String orderList(Model model){ //查询所有订单信息, 将查询到的订单集合存入Model中 List<Order> oList = orderService.findAll(); model.addAttribute( "oList", oList ); //查询所有门店信息, 将所有门店信息集合存入Model List<Door> dList = doorService.getAll(); model.addAttribute( "dList", dList ); //跳转到订单列表页面,显示所有订单信息 return "order_list"; } }

8.5 在页面上显示所有订单列表

实现order_list.jsp

9.删除订单信息

删除订单信息开发步骤：

1、在订单信息列表页面中，点击订单信息后的【删除】按钮，访问OrderController中的【orderDelete】方法，访问的同时将所要删除的订单id一同提交给服务器

2、在【orderDelete】方法中，通过参数接收订单id，调用service层，service层再调用dao层通过id删除指定的订单信息

3、删除成功后，重定向到订单列表页面，显示所有订单（即重定向到OrderController的【orderList】方法，先查询所有订单，再将所有订单信息带到JSP显示）

9.1 dao层代码实现

1.更新resources/mybatis/mapper/OrderMapper.xml文件，添加“删除订单信息”SQL

<delete id="deleteById"> DELETE FROM tb_order WHERE id=#{id} </delete>

2、更新com.zhang.dao.OrderDao接口，添加 deleteById方法，根据id删除订单信息

//2.根据id删除指定订单信息 public void deleteById(Integer id);

9.2 Service层代码实现

//2.根据id删除指定订单信息 public void deleteById(Integer id){ orderDao.deleteById(id); }

9.3 Controller层代码实现

更新com.zhang.controller.OrderController类，添加并实现orderDelete方法：调用service层的deleteById方法删除订单信息

//2.根据id删除指定订单信息 @RequestMapping("/orderDelete") public String orderDelete(Integer id){ orderService.deleteById(id); //删除完后跳转到查询所有订单的方法, 显示最新的订单信息 return "forward:/orders"; }

10.新增订单信息

新增订单信息开发步骤：

1、在订单信息列表页面中，点击【新增订单】，查询所有门店，将所有门店信息带到订单新增页面【order_add.jsp】

2、在【order_add.jsp】中输入新增的订单信息，点击【提交】将订单信息提交给OrderController的【orderAdd】方法

3、在【orderAdd】方法中，通过参数接收浏览器提交过来的订单信息，调用service层，service层再调用dao层将订单信息保存到数据库中

4、新增成功后，重定向到订单列表页面，显示所有订单（即重定向到OrderController的【orderList】方法，先查询所有订单，再将所有订单信息带到JSP显示）

10.1 dao层代码实现

1.更新resources/mybatis/mapper/OrderrMapper.xml文件，添加“新增订单信息”SQL

<insert id="addOrder"> INSERT INTO tb_order VALUE(null,#{doorId},#{orderNo},#{orderType},#{pnum},#{cashier},#{orderTime},#{payTime},#{payType},#{price}) </insert>

2.更新com.zhang.dao.OrderDao接口，添加 addOrder方法，新增订单信息

//3.新增订单信息 public void addOrder(Order order);

10.2 Service层代码实现

//3.新增订单信息 public void addOrder(Order order){ orderDao.addOrder(order); }

10.2 Controller层代码实现

1.修改"新增订单"链接地址，点击链接访问 /toOrderAdd地址，查询所有门店信息存入model，将所有门店信息转发带到order_add.jsp页面中，并在下拉框中进行回显

2.1更新com.zhang.controller.OrderController类，添加并实现toDoorAdd方法来到添加页面：调用DoorService层的findAll方法查询所有门店信息回显在新增页面

3.更新com.zhang.controller.OrderController类，添加并实现orderAdd方法：调用service层的add方法新增订单信息

//3.1 负责查询所有门店信息，并带到新增订单页面 @RequestMapping("/toOrderAdd") public String toOrderAdd(Model model){ //查询所有门店信息，将所有门店信息集合存入model List<Door> dList = doorService.getAll(); model.addAttribute("dList", dList); //跳转到订单新增页面（order_add.jsp） return "order_add"; } //3.2 新增订单信息提交 @RequestMapping("/orderAdd") public String orderAdd(Order order){ //调用orderService的add方法，新增订单信息 orderService.addOrder(order); //添加完成后跳转到查询所有订单的方法，更新所有订单 return "forward:/orders"; }

4.编写对应的order_add.jsp页面

<%@ page pageEncoding="utf-8"%>  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <!DOCTYPE HTML> <html> <head> <title>新增订单</title> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> <style type="text/css"> body{ font-family: "微软雅黑"; background-color: #EDEDED; } h2{ text-align: center;font-size:26px; } table{ margin: 30px auto; text-align: center; border-collapse:collapse; width:50%; } td, th{ padding: 5px;font-size:18px;} hr{ margin-bottom:20px; border:1px solid #aaa; } input,select,textarea{ width:284px; height:30px; background:#EDEDED; border:1px solid #999; text-indent:5px; font-size:18px; } input[type='submit']{ width:130px; height:36px; cursor:pointer; border-radius:5px 5px 5px 5px; background:#ddd; } select{text-indent:0px;} textarea{height:100px;font-size:22px;} </style> </head> <body> <h2>新增订单</h2> <hr/> <form action="orderAdd" method="POST"> <table border="1"> <tr> <td width="30%">所属门店</td> <td> <select name="doorId">  <c:forEach items="${dList}" var="door"> <option value="${door.id}">${door.name}</option> </c:forEach> </select> </td> </tr> <tr> <td>订单编号</td> <td> <input type="text" name="orderNo" placeholder="请输入订单编号"/> </td> </tr> <tr> <td>订单类型</td> <td> <select name="orderType"> <option value="堂食" selected>堂食</option> <option value="外卖">外卖</option> <option value="打包">打包</option> </select> <%--<input type="text" name="orderType" value="堂食"/>--%> </td> </tr> <tr> <td>用餐人数</td> <td> <input type="text" name="pnum" placeholder="请输入用餐人数"/> </td> </tr> <tr> <td>收银员</td> <td> <input type="text" name="cashier" placeholder="请输入收银员姓名"/> </td> </tr> <tr> <td>支付方式</td> <td> <select name="payType"> <option value="微信支付">微信支付</option> <option value="支付宝支付">支付宝支付</option> <option value="银联支付">银联支付</option> <option value="现金结算" selected>现金结算</option> </select> <%--<input type="text" name="payType" value="微支付"/>--%> </td> </tr> <tr> <td>支付金额</td> <td> <input type="text" name="price" placeholder="￥00.00"/> </td> </tr> <tr> <td colspan="2"> <input type="submit" value="新增订单"/> </td> </tr> </table> </form> </body> </html>

11.修改（更新）订单信息

更新订单信息开发步骤：

1、在订单信息列表页面中，点击订单信息后的【修改】按钮，访问OrderController中的【orderInfo】方法，访问的同时将所要查询的订单id一同提交给服务器

2、在【orderInfo】方法中，通过参数接收订单id，调用service层，service层再调用dao层通过id查询指定的订单信息（Order）并返回

3、在【orderInfo】方法中，将返回的订单信息（Order）存入Model中，并转向order_update.jsp（即 return "order_update"），将订单信息带到jsp页面进行回显

4、在原有订单信息的基础上，对订单信息进行修改，点击【提交】将修改后的订单信息提交给OrderController的【orderUpdate】方法

5、在【orderUpdate】方法中，通过参数接收浏览器提交过来的订单信息，调用service层，service层再调用dao层根据id修改订单信息

6、修改成功后，重定向到订单列表页面，显示所有订单（即重定向到OrderController的【orderList】方法，先查询所有订单，再将所有订单信息带到JSP显示）

11.1 dao层代码实现（查询订单信息回显）

修改订单信息需要在原有订单信息的基础上进行修改，因此在修改之前，需要先查询出原有订单信息，在原有订单信息的基础上修改后，再将修改后的订单信息提交给服务器端，服务器端将修改后的订单信息更新到数据库中

1.更新resources/mybatis/mapper/OrderMapper.xml文件，添加“根据id查询订单信息”SQL

<select id="findById" resultMap="orderRM"> SELECT * FROM tb_order WHERE id=#{id} </select>

2.更新com.zhang.dao.OrderDao接口，添加 findById方法，根据id查询订单信息

//4.1 根据id查询指定订单信息 public Order findById(Integer id);

11.2 Service层实现（查询订单信息回显）

//4.1 根据id查询指定订单信息 public Order findById(Integer id){ return orderDao.findById(id); }

11.3 Controller层代码实现（查询订单信息回显）

更新com.zhang.controller.OrderController类，添加并实现orderInfo方法：

（1）调用DoorDao的findAll方法查询所有门店信息

（2）调用OrderDao的findById方法根据id查询订单信息

//4.1 修改订单--查询指定id的订单信息，来到修改页面进行回显 @RequestMapping("/orderInfo") public String orderInfo(Model model, Integer id){ //根据id查询订单信息,将订单信息存入Model中 Order order = orderService.findById(id); model.addAttribute("order", order); //查询所有门店信息, 将所有门店信息集合存入Model List<Door> dList = doorService.getAll(); model.addAttribute("dList", dList); //将订单信息带到订单修改页面, 进行数据的回显 return "order_update"; }

11.4 修改页面（order_update.jsp）设计

<%@ page pageEncoding="utf-8"%> <%-- 引入JSTL标签库 --%> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %> <!DOCTYPE HTML> <html> <head> <title>"烤鱼铺子"-修改订单</title> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> <style type="text/css"> body{ font-family: "微软雅黑"; background-color: #EDEDED; } h2{ text-align: center;font-size:26px; } table{ margin: 30px auto; text-align: center; border-collapse:collapse; width:50%; } td, th{ padding: 5px;font-size:18px;} hr{ margin-bottom:20px; border:1px solid #aaa; } input,select,textarea{ width:284px; height:30px; background:#EDEDED; border:1px solid #999; text-indent:5px; font-size:18px; } input[type='submit']{ width:130px; height:36px; cursor:pointer; border-radius:5px 5px 5px 5px; background:#ddd; } select{text-indent:0px;} textarea{height:100px;font-size:22px;} </style> </head> <body> <h2>修改订单</h2> <hr/> <form action="orderUpdate" method="POST">  <input type="hidden" name="id" value="${order.id}"/> <table border="1"> <tr> <td width="30%">所属门店</td> <td> <select id="doorId" name="doorId">  <c:forEach items="${dList}" var="door"> <c:if test="${order.doorId == door.id}"> <option selected="selected" value="${door.id}">${door.name}</option> </c:if> <c:if test="${order.doorId != door.id}"> <option value="${door.id}">${door.name}</option> </c:if> </c:forEach> </select> </td> </tr> <tr> <td>订单编号</td> <td> <input type="text" name="orderNo" value="${order.orderNo}" placeholder="请输入订单编号"/> </td> </tr> <tr> <td>订单类型</td> <td> <select name="orderType"> <option value="${order.orderType}">${order.orderType}</option> <option value="堂食">堂食</option> <option value="外卖">外卖</option> <option value="打包">打包</option> </select> <%--<input type="text" name="orderType" value="${order.orderType}"/>--%> </td> </tr> <tr> <td>用餐人数</td> <td> <input type="text" name="pnum" value="${order.pnum}" placeholder="请输入用餐人数"/> </td> </tr> <tr> <td>收银员</td> <td> <input type="text" name="cashier" value="${order.cashier}" placeholder="请输入收银员姓名"/> </td> </tr> <tr> <td>下单时间</td> <td> <input type="text" name="orderTime" value='<fmt:formatDate value="${order.orderTime}" pattern="yyyy/MM/dd HH:mm:ss"/>'/> </td> </tr> <tr> <td>结账时间</td> <td> <input type="text" name="payTime" value='<fmt:formatDate value="${order.payTime}" pattern="yyyy/MM/dd HH:mm:ss"/>'/> </td> </tr> <tr> <td>支付方式</td> <td> <select name="payType"> <option value="${order.payType}">${order.payType}</option> <option value="微信支付">微信支付</option> <option value="支付宝支付">支付宝支付</option> <option value="银联支付">银联支付</option> <option value="现金结算">现金结算</option> </select> <%--<input type="text" name="payType" value="${order.payType}"/>--%> </td> </tr> <tr> <td>支付金额</td> <td> <input type="text" name="price" placeholder="请输入支付金额" value="${order.price}"/> </td> </tr> <tr> <td colspan="2"> <input type="submit" value="修改订单"/> </td> </tr> </table> </form> </body> </html>

11.5 dao层代码实现（更新订单）

1.更新resources/mybatis/mapper/OrderMapper.xml文件，添加“根据id更新订单信息”SQL：

<update id="updateOrder"> UPDATE tb_order SET door_id=#{doorId},order_no=#{orderNo},order_type=#{orderType},pnum=#{pnum},cashier=#{cashier},order_time=#{orderTime},pay_time=#{payTime},pay_type=#{payType},price=#{price} WHERE id=#{id} </update>

2.更新com.zhang.dao.OrderDao接口，添加 updateOrder方法，根据id更新订单信息

//4.2 更新订单信息 public void updateOrder(Order order);

11.6 Service层代码实现（更新订单）

//4.2 更新订单信息 public void updateOrder(Order order){ orderDao.updateOrder(order); }

11.7 Controller层代码实现（更新订单）

更新com.zhang.controller.OrderController类，添加并实现orderUpdate方法：调用service层的updateOrder方法删除订单信息 //4.2 更新订单信息 @RequestMapping("/orderUpdate") public String orderUpdate(Order order){ //order是用于接收修改后的订单信息 //调用OrderService的updateOrder方法, 根据id修改订单信息 orderService.updateOrder(order); //添加完后跳转到查询所有订单的方法, 显示最新的订单信息 return "forward:/orders"; }

12.扩展内容

当通过浏览器访问服务器中不存在的资源时，浏览器的页面上会显示404

当服务器端程序出现错误时，浏览器的页面上会显示500异常信息

可以自己写更友好的404和500页面，代替默认的404和500页面

1.将404.jsp和500.jsp以及e.png拷贝到webapp目录下

2.在web.xml文件中配置全站404和500跳转页面

<web-app> ...  <error-page> <error-code>500</error-code> <location>/500.jsp</location> </error-page>  <error-page> <error-code>404</error-code> <location>/404.jsp</location> </error-page> ... </web-app>

最新回复(0)