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

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等依赖包

  <!--引入项目依赖的jar包 --><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.11</version><scope>test</scope></dependency><!-- 整合log4j --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>1.6.4</version></dependency><!-- SpringMVC、Spring --><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.2.4.RELEASE</version></dependency><!-- spring-jdbc --><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>4.3.8.RELEASE</version></dependency><!-- Spring面向切面编程 --><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.2.9.RELEASE</version></dependency><!--MyBatis --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.3</version></dependency><!-- MyBatis整合Spring的适配包 --><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><!-- （jstl，servlet-api，junit） --><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><!-- 返回json字符串的支持 --><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.9.9.3</version></dependency><!-- druid连接池 --><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

配置内容如下：

<?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.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsdhttp://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.xsdhttp://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"></beans>

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/mvchttp://www.springframework.org/schema/mvc/spring-mvc-4.0.xsdhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.0.xsd"><!-- 1.配置前端控制器放行静态资源(html/css/js等，否则静态资源将无法访问) --><mvc:default-servlet-handler/><!-- 2.配置注解驱动，用于识别注解（比如@Controller） --><mvc:annotation-driven></mvc:annotation-driven><!-- 3.配置需要扫描的包：spring自动去扫描 base-package 下的类，如果扫描到的类上有 @Controller、@Service、@Component等注解，将会自动将类注册为bean--><context:component-scan base-package="com.zhang.controller"></context:component-scan><!-- 4.配置内部资源视图解析器prefix:配置路径前缀suffix:配置文件后缀--><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><!-- 配置springmvc, 将所有请求交给springmvc来处理 --><servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><!-- 配置springmvc核心配置文件的位置，默认Springmvc的配置文件是在WEB-INF目录下，默认的名字为springmvc-servlet.xml，如果要放在其他目录，则需要指定如下配置： --><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:spring/*.xml</param-value></init-param>      </servlet><!-- 其中的斜杠（/）表示拦截所有请求（除JSP以外）, 所有请求都要经过springmvc前端控制器 --><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及相关依赖包

<!-- 整合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>
<!-- mysql驱动 -->
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.32</version>
</dependency>
<!-- druid连接池 -->
<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 configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><!-- MyBatis的全局配置文件 -->
<configuration ><!-- 1.配置开发环境 --><environments default="develop"><!-- 这里可以配置多个环境，比如develop，test等 --><environment id="develop"><!-- 1.1.配置事务管理方式：JDBC：将事务交给JDBC管理（推荐） --><transactionManager type="JDBC"></transactionManager><!-- 1.2.配置数据源，即连接池方式:JNDI/POOLED/UNPOOLED --><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><!-- 2.加载Mapper配置文件,路径以斜杠间隔: xx/xx/../xx.xml --><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 mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 门店表的映射文件    namespace值为对应接口的全路径 -->
<mapper namespace="com.zhang.dao.DoorDao"><!-- 1.查询所有门店信息，id值为对应接口中方法的名字resultType指定将查询的结果封装到哪个pojo对象中--><select id="findAll" resultType="com.zhang.pojo.Door">select * from tb_door</select></mapper>

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

<!-- 2.加载Mapper配置文件,路径以斜杠间隔: xx/xx/../xx.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方法@Overridepublic 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开发环境@Testpublic 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 configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><!-- MyBatis的全局配置文件 -->
<configuration ><!-- 1.配置开发环境 --><!--<environments default="develop">--><!-- 这里可以配置多个环境，比如develop，test等 --><!--<environment id="develop">--><!-- 1.1.配置事务管理方式：JDBC：将事务交给JDBC管理（推荐） --><!--<transactionManager type="JDBC"></transactionManager>--><!-- 1.2.配置数据源，即连接池方式:JNDI/POOLED/UNPOOLED --><!--<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>--><!-- 2.加载Mapper配置文件,路径以斜杠间隔: xx/xx/../xx.xml --><!--<mappers><mapper resource="mybatis/mapper/DoorMapper.xml"/></mappers>-->
</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.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsdhttp://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.xsdhttp://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><!-- 1.加载jdbc.properties文件的位置 --><context:property-placeholder location="classpath:jdbc.properties"/><!-- 2.配置druid连接池 ，id是固定值，class是druid连接池类的全路径 --><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><!-- 3.整合spring和mybatis框架 将SqlSession等对象的创建交给Spring容器 id值(sqlSessionFactory)是固定值--><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><!-- 3.1.指定mybatis核心配置文件的位置 --><property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property><!-- 3.2.配置连接池(数据源) ref指向druid连接池bean对象的id值 --><property name="dataSource" ref="dataSource"></property><!-- 3.3、扫描所有的 XxxMapper.xml映射文件，读取其中配置的SQL语句 --><property name="mapperLocations" value="classpath:mybatis/mapper/*.xml"/></bean><!-- 4、定义mapper接口扫描器 --><bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"><!-- 扫描所有XxxDao接口，将接口实例的创建交给spring容器 --><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自动为属性赋值（对象）* */@AutowiredDoorDao 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实体类，用于封装所有的门店信息（若上面已创建，直接跳过即可！）

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方法@Overridepublic String toString() {return "Door{" +"id=" + id +", name='" + name + '\'' +", tel='" + tel + '\'' +", addr='" + addr + '\'' +'}';}
}

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

配置内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><!-- 门店表的映射文件 namespace值为对应接口的全路径 -->
<mapper namespace="com.zhang.dao.DoorDao"></mapper>

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

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

    <!-- 1.查询所有门店信息，id值为对应接口中方法的名字 resultType指定将查询的结果封装到哪个pojo对象中--><select id="findAll" resultType="com.zhang.pojo.Door">SELECT * FROM tb_door</select>

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

代码实现如下：

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

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 {@AutowiredDoorDao 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!*/@AutowiredDoorService 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><!-- body-start  --><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><!-- 是序号, 不是门店id --><td>${ door.name }</td><td>${ door.tel }</td><td>${ door.addr }</td><td><a href="doorDelete?id=${ door.id }">删除</a>&nbsp;|&nbsp;<a href="doorInfo?id=${ door.id }">修改</a></td></tr>
</c:forEach></table>
</body><!-- body-end  -->
</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删除门店信息

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);
}

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

    <!-- 2.根据id删除门店信息，id值为对应接口中方法的名字 --><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

 <!-- 3.新增门店信息 --><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

    <!-- 4.根据id查询门店信息 --><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中显示将要修改的门店信息:

<h2>修改门店</h2>
<hr/>
<form action="doorUpdate" method="POST"><!-- hidden隐藏域,在提交表单时连door.id一起提交 --><input type="hidden" name="id" value="${door.id}"/><table border="1"><tr><td width="30%">门店名称</td><td><input type="text" name="name" value="${door.name}"/></td></tr><tr><td>联系电话</td><td><input type="text" name="tel" value="${door.tel}"/></td></tr><tr><td>门店地址</td><td><input type="text" name="addr" value="${door.addr}"/></td></tr><tr><td colspan="2"><input type="submit" value="提交修改" /></td></tr></table>
</form>

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

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

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

    <!-- 5.根据id修改门店信息 --><update id="updateById">UPDATE tb_door SET name=#{name},tel=#{tel},addr=#{addr} WHERE id=#{id}</update>

2.更新com.zhang.dao.DoorDao接口，添加 updateById方法，根据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);//5.根据id修改门店信息public void updateById(Door door);
}

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; //订单idprivate 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方法@Overridepublic 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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 订单表的映射文件 namespace值为对应接口的全路径 -->
<mapper namespace="com.zhang.dao.OrderDao"></mapper>

8.2 dao层代码实现

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 订单表的映射文件 namespace值为对应接口的全路径 -->
<mapper namespace="com.zhang.dao.OrderDao"><!-- 数据表列字段与pojo类属性映射关系，type:指定将查询的结果封装到哪个类pojo对象中，id:指定一个唯一表示resultMap的值--><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><!-- 1.查询所有订单信息，id值为对应接口中方法的名字，resultMap:指定为resultMap标签的id值 --><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 {@AutowiredOrderDao 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 {@AutowiredDoorService doorService;@AutowiredOrderService orderService;//1.查询所有订单@RequestMapping("/orders")public String orderList(Model model){//查询所有订单信息, 将查询到的订单集合存入Model中List<Order> oList = orderService.findAll();model.addAttribute( "oList", oList );//查询所有门店信息, 将所有门店信息集合存入ModelList<Door> dList = doorService.getAll();model.addAttribute( "dList", dList );//跳转到订单列表页面,显示所有订单信息return "order_list";}}

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

实现order_list.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;}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-50{ width: 50px; }th.width-64{ width: 64px; }th.width-80{ width: 80px; }th.width-120{ width: 100px; }hr{ margin-bottom:20px; border:1px solid #aaa; }#add-order{text-align:center;font-size:20px;}
</style><script type="text/javascript"></script>
</head>
<body>
<h2>订单管理</h2>
<div id="add-order"><!-- 点击后查询所有门店信息后再跳转到订单新增页面 --><a href="toOrderAdd" target="rightFrame">新增订单</a>
</div>
<hr/>
<table border="1"><tr><th class="width-40">序号</th><th class="width-120">所属门店</th><th class="width-50">订单号</th><th class="width-40">类型</th><th class="width-40">人数</th><th class="width-50">收银员</th><th class="width-120">下单时间</th><th class="width-120">结账时间</th><th class="width-50">支付方式</th><th class="width-50">金额</th><th class="width-80">操 作</th></tr><!-- 模版数据 -->
<c:forEach items="${oList}" var="order" varStatus="sta"><tr><td>${sta.count}</td><!-- 遍历门店集合(List<Door>),拿着订单中记录的门店编号(order.doorId)和 每一个门店的编号(door.id)进行比较, 如果相等, 就将这个门店的名称显示在td中--><td><c:forEach items="${dList}" var="door">${ order.doorId == door.id ? door.name : "" }</c:forEach></td><td>${order.orderNo}</td><td>${order.orderType}</td><td>${order.pnum}</td><td>${order.cashier}</td><td><fmt:formatDate value="${order.orderTime}"pattern="yyyy/MM/dd HH:mm:ss"/></td><td><fmt:formatDate value="${order.payTime}"pattern="yyyy/MM/dd HH:mm:ss"/></td><td>${order.payType}</td><td>${order.price}</td><td><a href="orderDelete?id=${order.id}">删除</a>&nbsp;|&nbsp;<a href="orderInfo?id=${order.id}">修改</a></td></tr>
</c:forEach></table></body><!-- body-end  -->
</html>

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

    <!-- 2、根据id删除订单信息 --><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

    <!-- 3.新增订单信息 --><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){//查询所有门店信息，将所有门店信息集合存入modelList<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"%>
<!-- 引入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;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><!-- body-start  --><h2>新增订单</h2>
<hr/>
<form action="orderAdd" method="POST"><table border="1"><tr><td width="30%">所属门店</td><td><select name="doorId"><!-- 遍历所有的门店信息, 将门店信息作为option显示在下拉选框中!! --><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><!-- body-end  -->
</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

    <!-- 4.1 根据id查询订单信息 --><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);//查询所有门店信息, 将所有门店信息集合存入ModelList<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><!-- body-start  --><h2>修改订单</h2>
<hr/>
<form action="orderUpdate" method="POST"><!-- hidden隐藏域,在提交表单时连order.id一起提交 --><input type="hidden" name="id" value="${order.id}"/><table border="1"><tr><td width="30%">所属门店</td><td><select id="doorId" name="doorId"><!-- 遍历门店集合,将每一个门店作为一个option选项显示在下拉选框中所属门店的回显: 在遍历的同时,让订单中记录的门店id和当前门店的id进行比较, 如果两者相等, 就将当前门店所在的option设置为默认被选中就可以做到门店的回显!--><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><!-- body-end  -->
</html>

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

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

    <!-- 4.2 更新订单信息 --><update id="updateOrder">UPDATE tb_order SETdoor_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>...<!-- 配置全站500异常跳转页面 --><error-page><error-code>500</error-code><location>/500.jsp</location></error-page><!-- 配置全站404跳转页面 --><error-page><error-code>404</error-code><location>/404.jsp</location></error-page>...</web-app>