“烤鱼铺子”门店管理系统开发笔记
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%n6.在resources目录下创建jdbc.properties文件，配置内容如下:
db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql:///yonghedb?characterEncoding=utf-8
db.username=root
db.password=root3.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.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">
</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/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">
<!-- 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 configuration
PUBLIC "-//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 mapper
PUBLIC "-//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方法
@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">
<!-- 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.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>
<!-- 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=root4.新建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实体类，用于封装所有的门店信息（若上面已创建，直接跳过即可！）
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 + '\'' +
'}';
}
}2.创建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">
<!-- 门店表的映射文件 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 {
@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><!-- 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>
|
<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; //订单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
<?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">
<!-- 订单表的映射文件 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 mapper
PUBLIC "-//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 {
@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
<%@ 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>
|
<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){
//查询所有门店信息，将所有门店信息集合存入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"%>
<!-- 引入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);
//查询所有门店信息, 将所有门店信息集合存入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><!-- 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 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>
...
<!-- 配置全站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>
866
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
