新手入门的SpringBoot+SSM企业级项目
①开发环境(development):开发人员在开发阶段使用的环境,一般外部用户无法访问
②测试环境(testing):专门给测试人员使用的环境,用于测试项目,
一般外部用户无法访问
③生产环境(production):即线上环境,正式提供对外服务的环境
本项目共分为3期进行开发:
①第一期主要实现基本需求,其中移动端应用通过H5实现,用户可以通过手机浏览器访问。
②第二期主要针对移动端应用进行改进,使用微信小程序实现,用户使用起来更加方便。
③第三期主要针对系统进行优化升级,提高系统的访问性能。
①产品经理在需求分析后制作,一般都是网页。
②产品原型主要用于展示项目的功能,并不是最终的页面效果。
后台系统管理员:登录后台管理系统,拥有后台系统中的所有操作权限
后台系统普通员工:登录后台管理系统,对菜品、套餐、订单等进行管理
C端用户:登录移动端应用,可以浏览菜品、添加购物车、设置地址、在线下单等
第一步
数据库环境搭建,导入sql文件
第二步
maven项目搭建:骨架创建maven。
pom.xml文件
4.0.0
org.springframework.boot
spring-boot-starter-parent
2.4.5
com.itheima
reggie_take_out
1.0-SNAPSHOT
1.8
org.springframework.boot
spring-boot-starter
org.springframework.boot
spring-boot-starter-test
test
org.springframework.boot
spring-boot-starter-web
compile
com.baomidou
mybatis-plus-boot-starter
3.4.2
org.projectlombok
lombok
1.18.20
com.alibaba
fastjson
1.2.76
commons-lang
commons-lang
2.6
mysql
mysql-connector-java
runtime
com.alibaba
druid-spring-boot-starter
1.1.23
org.springframework.boot
spring-boot-maven-plugin
2.4.5
第三步
导入SpringBoot配置文件applidation.yml
resources包下导入application.yml
server:
port: 8080 #tomcat端口号
spring:
application:
name: reggie_take_out #指定应用的名称 非必须
datasource:
druid:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/reggie?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
username: root
password: root
mybatis-plus:
configuration:
#address book---->AddressBook
#user_name---->userName
#在映射实体或者属性时,将数据库中表名和字段名中的下划线去掉,按照驼峰命名法映射
map-underscore-to-camel-case: true
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
global-config:
db-config:
id-type: ASSIGN_ID
第四步
编写启动类,可尝试启动
@Slf4j
//可以使用log方法,打印info级别日志
@SpringBootApplication
//引导类or启动类
@ServletComponentScan//扫描webFilter注解 进一步创建过滤器
public class ReggieApplication {
public static void main(String[] args) {
SpringApplication.run(ReggieApplication.class,args);
log.info("项目启动成功。。。。");//打印info级别日志
}
}
注意:静态资源一般放在webapp/static或者webapp/resources等目录下。默认寻找这个目录下的静态资源。不在直接报错。
解决::配置映射文件
@Slf4j
//可以使用log方法,打印info级别日志
@Configuration//声明该类是配置类
public class WebMvcConfig extends WebMvcConfigurationSupport {
/*
静态资源文件应该都在webapp目录下
本项目没有webapp目录
需要设置静态资源映射
*/
@Override
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
log.info("开始进行静态资源映射。。。");
registry.addResourceHandler("/backend/**").addResourceLocations("classpath:/backend/");
registry.addResourceHandler("/front/**").addResourceLocations("classpath:/front/");
/*
tomcat服务器访问路径映射到相应的静态文件下
pathPatterns:服务器访问路径
classpath:(指定类文件的路径)此处指读取静态资源的路径resources目录
*/
}
第一步:
创建实体类Employee,和employee表进行映射
开发习惯:数据库一张表对应一个实体类
从资料直接导入
第二步:
创建Controller、Service、 Mappe
//mapper接口
@Mapper
public interface EmployeeMapper extends BaseMapper {//泛型实体
}
//EmployeeService接口
@Mapper
public interface EmployeeService extends IService {//继承IService泛型实体
}
//EmployeeServiceImpl继承serviceImpl(对应mapper类,对应实体类)继承 EmployeeService接口
public class EmployeeServiceImpl extends ServiceImpl implements EmployeeService {
}
//EmployeeController类
@Slf4j
@RestController
@RequestMapping("/employee")//路径
public class EmployeeController {
//注入
@Autowired
private EmployeeService employeeService;
第三步:
导入返回类R
此类是一个通用结果类,服务端响应的所有结果最终都会包装成此种类型返回给前端页面
/*
通用返回结果,限务端响应的数据最终部会封装成此对练
*/
@Data
public class R {
private Integer code; //编码:1成功,0和其它数字为失败
private String msg; //错误信息
private T data; //数据
private Map map = new HashMap(); //动态数据
public static R success(T object) {
R r = new R();
r.data = object;
r.code = 1;
return r;
}
public static R error(String msg) {
R r = new R();
r.msg = msg;
r.code = 0;
return r;
}
public R add(String key, Object value) {
this.map.put(key, value);
return this;
}
}
第四步:
在Controller中创建登录方法
处理逻辑:
1、将页面提交的密码password进行md5加密处理
2、根据页面提交的用户名username查询数据库
3、如果没有查询到则返回登录失败结果
4、密码比对,如果不一致则返回登录失败结果
5、查看员工状态,如果为已禁用状态,则返回员工已禁用结果
6、登录成功,将员工id存入Session并返回登录成功结果
@Slf4j
@RestController
@RequestMapping("/employee")//路径
public class EmployeeController {
//注入
@Autowired
private EmployeeService employeeService;
/*
员工登录
*/
@PostMapping("/login")
//json在接收时,要有注解@RequestBody 分装成emplouee对象
public R login(HttpServletRequest request, @RequestBody Employee employee) {
//Employee的id存在Session中,表示成功。获取当前用户:request来get
/**
* 1、将页面提交的密码password进行md5加密处理,已经封装到Employee中
* 密码已经封装到employee中
*/
String password = employee.getPassword();//拿到密码
password = DigestUtils.md5DigestAsHex(password.getBytes());//md5加密处理
// 2、根据页面提交的用户名username查询数据库
//employee是泛型
LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Employee::getUsername, employee.getUsername());//指定sql语句条件
Employee emp = employeeService.getOne(queryWrapper);
//getOne 这个用户名是唯一的用getOne调用,调用后分装成employee对象
//3、如果没有查询到则返回登录失败结果
if (emp == null) {
//返回结果封装成R对象
return R.error("登录失败");
}
//4、密码比对,如果不一致则返回登录失败结果
//数据库查的密码和处理后的密码对比
if (!emp.getPassword().equals(password)) {
return R.error("登录失败");
}
// 5、查看员工状态,如果为已禁用状态,则返回员工已禁用结果
if (emp.getStatus() == 0) {
//1账户可用。0账号不可用
return R.error("账户已禁用");
}
// 6、登录成功,将员工id存入Session并返回登录成功结果
request.getSession().setAttribute("employee", emp.getId());
return R.success(emp);
}
直接点击右侧的退出按钮即可退出系统,退出系统后页面应跳转回登录页面
用户点击页面中退出按钮,发送请求,请求地址为/employee/logout,请求方式为POST。
我们只需要在Controller中创建对应的处理方法即可,具体的处理逻辑;
1、清理Session中的用户id
2、返回结果
/**
* 员工退出页面
*/
@PostMapping("/logout")
public R logout(HttpServletRequest request){
// 清理Session中保存的当前登录员工的id
request.getSession().removeAttribute("employee");
//把employee属性移除
return R.success("退出成功");
}
用户如果不登录,直接访问系统页面,可以直接访问
使用过滤器或者拦截器。没有登录跳转到登录界面
实现步骤
1、创建自定义过滤器LoginCheckFilter
2、在启动类上加入注解@Servletcomponentscan
3、完善过滤器的处理逻辑
创建filter包。给启动类添加扫描注解@ServletComponentScan
/*
检查用户是否已将登陆
*/
@WebFilter(filterName = "loginCheckFilter",urlPatterns = "/*")
@Slf4j
public class LoginCheckFilter implements Filter {
//路径匹配器 支持通配符
public static final AntPathMatcher PATH_MATCHER = new AntPathMatcher();
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) servletRequest;//强转
HttpServletResponse response = (HttpServletResponse) servletResponse;
//1、获取本次请求的URI
String requestURI = request.getRequestURI();
log.info("拦截到请求:{}",requestURI);//{}requestURI占位符
//不需要拦截的直接放行的
String[] urls = new String[]{
"/employee/login",//登录页面
"/employee/logout",//退出页面
"/backend/**",//静态资源
"/front/**"
};
//2、判断本次请求是否需要处理--》请求的页面是否在要放行的页面中
boolean check = check(urls,requestURI);
//3、如果不需要处理,则直接放行
if (check){
log.info("本次请求{}不需要处理",requestURI);
filterChain.doFilter(request,response);
return;
}
//4、判断登录状态,如果已登录,则直接放行
if (request.getSession().getAttribute("employee") != null){
log.info("用户已登录,用户id为:{}",request.getSession().getAttribute("employee"));
filterChain.doFilter(request,response);
return;
}
log.info("用户未登录");
// 5、如果未登录则返回未登录结果通,过输出流方式向客户端页面响应数据
response.getWriter().write(JSON.toJSONString(R.error("NOTLOGIN")));
return;
}
/**
* 路径匹配,检查本次请求是否需要放行
* @param urls
* 遍历要放行的数组。和请求的数组对比
* @param requestURL
* @return
*/
public boolean check(String[] urls,String requestURL) {
for (String url : urls){
boolean match = PATH_MATCHER.match(url,requestURL);
if (match){
return true;//放回true表示匹配上
}
}
return false;
}
}
@Slf4j
//可以使用log方法,打印info级别日志
@SpringBootApplication
//引导类or启动类
@ServletComponentScan//扫描webFilter注解 进一步创建过滤器
public class ReggieApplication {
public static void main(String[] args) {
SpringApplication.run(ReggieApplication.class,args);
log.info("项目启动成功。。。。");//打印info级别日志
}
}
将新增页面录入的员工数据插入到employee表。
需要注意,employee表中对username字段加入了唯一约束,因为username是员工的登录账号,必须是唯一的
整个程序的执行过程:
1、页面发送ajax请求,将新增员工页面中输入的数据以json的形式提交到服务端
2、服务端Controller接收页面提交的数据并调用Service将数据进行保存
3、Service调用Mapper操作数据库,保存数据
前面的程序还存在一个问题,就是当我们在新增员工时输入的账号已经存在,由于employee表中对该字段加入了唯
一约束,此时程序会抛出异常:
java sql.SQLIntegrityConstraintviolationException: Duplicate entry
zhangsan for key idx_username
此时需要我们的程序进行异常捕获,通常有两种处理方式
1、在Controller方法中加入try、catch进行异常捕获
2、使用异常处理器进行全局异常捕获
全局异常处理器
*关键在@@ControllerAdvice和@ExceptionHandler两个注解
详解看注释
/**
* 全局异常处理器
* 关键在@@ControllerAdvice和@ExceptionHandler两个注解
*/
//
//拦截 类上加restController和controllee类
@ControllerAdvice(annotations = {RestController.class, Controller.class})
@ResponseBody//封住成JSON数据
@Slf4j
public class GlobalExceptionHandler {
/**
* 异常处理方法
*/
//@ExceptionHandler声明要处理的类
//此处处理的是SQLIntegrityConstraintViolationException的异常
@ExceptionHandler(SQLIntegrityConstraintViolationException.class)
public R exceptionHamdler(SQLIntegrityConstraintViolationException ex){
log.error(ex.getMessage());
//异常有多种
//判断异常信息里边是否有需要的关键字
//用户名唯一,重复报一下错误
//Duplicate entry 'zhangsan' for key'idx username
//关键字=Duplicate entry
if (ex.getMessage().contains("Duplicate entry")){
//冬天截取重复的用户名 用空格隔开
String[] split = ex.getMessage().split(" ");
//split[2] “zhangsan的下标”
String msg = split[2] + "已经存在";
//通用返回结果
return R.error(msg);
}
return R.error("未知错误");
}
}
总结:
1、根据产品原型明确业务需求
2、重点份析数据的流转过程和数据格式
3、通过debug断点调试跟踪程序执行过程
+++++++++++++++++++++++++++++++++++++++
其他功能流程和新增功能流程相同。数据格式不同+
+++++++++++++++++++++++++++++++++++++++
1、页面发送ajax请求,将分页查询参数(page、pagesize、name)提交到服务端
2、服务端Controller接收页面提交的数据并调用Service查询数据
3、Service调用Mapper操作数据库,查询分页数据
4、Controller将查询到的分页数据响应给页面 5、页面接收到分页数据并通过Elementul的Table组件展示到页面上
第一步:
config包下MP分页插件配置类
/**
* 配置MP的分页插件
*/
@Configuration//声明这是配置类
public class MybatisPlusConfig {
@Bean//bean注解 spring来管理
//通过拦截器的方式把插件加载进来
public MybatisPlusInterceptor mybatisPlusConfigInterceptor(){
//创建拦截器对象
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
//加入插件
mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
return mybatisPlusInterceptor;
}
}
第二步:
controller层EmployeeController代码
/**
* 分页处理的数据 用page接受
* 员工信息查询
* @param page
* @param pageSize
* @param name
* @return
*/
@GetMapping("/page")//get请求 所以getmapping
//设置默认页数和单页数据条数 name:查询的用户
public R page(int page,int pageSize,String name){
log.info("page ={},pageSize = {},name = {}",page,pageSize,name);
//构造分页构造器
Page pageInfo = new Page(page,pageSize);
//构造条件构造器
LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
//添加过滤添条件
queryWrapper.like(StringUtils.isNotEmpty(name),Employee::getName,name);
//添加排序条件
queryWrapper.orderByDesc(Employee::getUpdateTime);
//执行查询
employeeService.page(pageInfo,queryWrapper);
return R.success(pageInfo);
}
只有管理员能进后台和设置账号的状态 。
某个员工账号状态为正常,则按钮显示为“禁用”,如果员工账号状态为已禁用,则按钮显示为“启用”
页面中是怎么做到只有管理员admin能够看到启用、禁用按钮的?
1、页面发送ajax请求,将参数(id、status)提交到服务端
2、服务端Controller接收页面提交的数据并调用Service更新数据
3、Service调用Mapper操作数据库
第一步:
controller层EmployeeController代码
/**
* 根据id修改员工信息
* @return
*/
@PutMapping
public R updata(HttpServletRequest request,@RequestBody Employee employee){
log.info(employee.toString());
//获取修改人信息
Long empId = (long)request.getSession().getAttribute("employee");
employee.setUpdateTime(LocalDateTime.now());//当前修改时间
employee.setUpdateUser(empId);//修改人信息。当前登录的人可以修改,所修改人=当前登陆人
employeeService.updateById(employee);
return R.success("员工信息修改成功");
}
第二步:
解决上述问题:
在服务端给页面响应json数据时进行处理,将long型数据统一转为String字符串
具体实现步骤:
1)提供对象转换器jacksonobjectMapper,基于jackson进行Java对象到json数据的转换(资料中已经提供,直接复制到项目中使用)。放common包
2)在WebMvcConfig配置类中扩展Springmvc的消息转换器,在此消息转换器中使用提供的对象转换器进行Java对象到json数据的转换
/**
* 扩展mve框架的消息转换器
*/
@Override
protected void extendMessageConverters(List> converters) {
//创建消息转换器对象
// 我们自己new 的转换器放入 converters中。默认8个转换器,现在+1
MappingJackson2CborHttpMessageConverter messageConverter = new MappingJackson2CborHttpMessageConverter();
//设置对象转换器,底层使用Jackson将java对象转为json
messageConverter.setObjectMapper(new JacksonObjectMapper());
// 将上面的消息转换器对象追加到mvc框架的转换器集合中
//注意add导入index类。 0:优先使用自己的转换器
converters.add(0,messageConverter );
}
1、点击编辑按钮时,页面跳转到add.html,并在url中携带参数[员工id]
http://localhost:8000/backend/page/member/add.htmlid=1644891700080074753
2、在add.html页面获取url中的参数员工id]
3、发送ajax请求,请求服务端,同时提交员工id参数
4、服务端接收请求,根据员工id查询员工信息,将员工信息以json形式响应给页面
5、页面接收服务端响应的json数据,通过VUE的数据绑定进行员工信息回显
6、点击保存按钮,发送ajax请求,将页面中的员工信息以json方式提交给服务端
7、服务端接收员工信息,并进行处理,完成后给页面响应
8、页面接收到服务端响应信息后进行相应处理
注意:add.html页面为公共页面,新增员工和编辑员工都是在此页面操作
controller层EmployeeController代码
/**
* 根据id查询员工信息
* 复用根据id修改员工信息
* @param id
* @return
*/
@GetMapping("/{id}")
public R getById(@PathVariable Long id){
log.info("根据id查询员工信息。。。");
Employee employee = employeeService.getById(id);
if (employee != null){
return R.success(employee);
}
return R.error("没有查询到对应员工信息");
}
员工管理功能开发时,在新增员工时需要设置创建时间、创建人、修改时间、修改人等字段,在编辑员工时需要设置修改时间和修改人等字段。这些字段属于公共字段
> 多张表都有的字段
MybatisPlus公共字段自动填充,也就是在插入或者更新的时候为指定字段赋予指定的值,使用它的好处就是可以统一对这些字段进行处理,避免了重复代码。
实现步骤:
1、在实体类的属性上加入***@TableField***注解,指定自动填充的策略
2、按照框架要求编写元数据对象处理器,在此类中统一为公共字段赋值,此类需要实现MetaObjectHandler接口
/**
第一步:1、在实体类的属性上加入***@TableField***注解,指定自动填充的策略
* 那些是公共字段
* 就加上@TableField注解
* fill :填充 =号后边是填充策略
* 详细策略看FieldFill类
*/
@TableField(fill = FieldFill.INSERT)//插入时填充字段
private LocalDateTime createTime;
@TableField(fill = FieldFill.INSERT_UPDATE)//插入和更新时填充字段
private LocalDateTime updateTime;
@TableField(fill = FieldFill.INSERT)//插入时填充字段
private Long createUser;
@TableField(fill = FieldFill.INSERT_UPDATE)//插入和更新时填充字段
private Long updateUser;
注意:①当前我们设置createUser和updateUser为固定值 后面我们需要进行改造,改为动态获得当前登录用户的id。
②可以使用ThreadLocal来解决此问题,它是DK中提供的一个类。
在学习ThreadLocal之前,先确认一个事情:客户端发送的每次http请求,对应的在服务端都会分配一个新的线程来处理,在处理过程中涉及到下面类中的方法都属于相同的一个线程:
1、LogincheckFilter的doFilter方法
2、EmployeeController的update方法
3、MyMetaObjectHandler的updateFi方法
/**
* 测试
* 可以在上面的三个方法中分别加入下面代码(获取当前线程id):
* long id = Thread。currentThread().getId();
* log.info("线程id:{}",id)
*/
什么是ThreadLocal?
ThreadLocal并不是一个Thread(线程),而是Thread的局部变量。当使用ThreadLocal维护变量时,Threadlocal为每个使用该
变量的线程提供独立的变量副本,所以每一个线程都可以独立地改变自己的副本,而不会影响其它线程所对应的副本。
ThreadLocal为每个线程提供单独一份存储空间,具有线程隔离的效果,只有在线程内才能获取到对应的值,线程外则不 能访问。
/**
* ThreadLocal常用方法:
* public void set(T value) 设置当前线程的线程局部变量的值
* public T get() 返回当前线程所对应的线程局部变量的值
*
我们可以在LogincheckFilter的doFilter方法中获取当前登录用户id,并调用ThreadLocal的set方法来设置当前线程的线
程局部变量的值(用户id),然后在MyMetaObjectHandler的updateFill方法中调用ThreadLocal的get方法来获得当前
线程所对应的线程局部变量的值(用户id)。
实现步骤:
1、编写Basecontext工具类,基于ThreadLocal封装的工具类
2、在LoginCheckFilter的doFilter方法中调用BaseContext来设置当前登录用户的id
3、在MyMetaobjectHandler的方法中调用BaseContext获取登录用户的id
package com.itheima.reggie.common;
/**
* 1、编写Basecontext工具类,基于ThreadLocal封装的工具类
* 基于ThreadLocal封装工具类,用户保存和获取当前登录用户id
*/
public class BaseContext {
//id 是lang类型 所以泛型是long
private static ThreadLocal threadLocal = new ThreadLocal<>();
public static void setCurrentId(Long id) {
threadLocal.set(id);//保存值
}
public static Long getCurrentId(){
return threadLocal.get();//取值
}
}
// 第二步:在LoginCheckFilter的doFilter方法中调用BaseContext来设置当前登录用户的id
//4、判断登录状态,如果已登录,则直接放行
if (request.getSession().getAttribute("employee") != null){
log.info("用户已登录,用户id为:{}",request.getSession().getAttribute("employee"));//获取id
//获取id
Long empId = (Long) request.getSession().getAttribute("employee");
BaseContext.setCurrentId(empId);
filterChain.doFilter(request,response);
return;
}
log.info("用户未登录");
3、在MyMetaobjectHandler的方法中调用BaseContext获取登录用户的id metaObject.setValue("updateUser",new Long(1));
metaObject.setValue("createUser",BaseContext.getCurrentId());
菜品分类和套餐分类。在后台系统中添加菜品时选择一个菜品分类
在开发业务功能前,先将需要用到的类和接口基本结构创建好
实体类Category(直接从课程资料中导入即可)
Mapper接口CategoryMapper
业务层接口Categorysenvice
业务层实现类Categoryservicelmpl
控制层Categorycontroller
1、页面(backend/page/category/list.html)发送ajax请求,将新增分类窗口输入的数据以json形式提交到服务端
2、服务端Controller接收页面提交的数据并调用Service将数据进行保存
3、Service调用Mapper操作数据库,保存数据
package com.itheima.reggie.controller;
/**
* 分类管理
*/
@RestController
@RequestMapping("/categoty")
@Slf4j
public class CategoryController {
@Autowired
private CaregoryService caregoryService;
/**
* 新增分类成功
*/
@PutMapping
public R save(@RequestBody Category category){
log.info("category:{}",category);
caregoryService.save(category);
return R.success("新增分类成功");
}
}
功能测试:可以新增菜品分类
1、页面发送ajax请求,将分页查询参数(page、pagesize)提交到服务端
2、服务端Controller接收页面提交的数据并调用Service查询数据
3、Service调用Mapper操作数据库,查询分页数据
4、Controller将查询到的分页数据响应给页面
5、页面接收到分页数据并通过Elementul的Table组件展示到页面上
package com.itheima.reggie.controller;
/**
* 分页查询
* @param page
* @param pageSize
* @return
*/
@GetMapping("/page")
public R page(int page, int pageSize){
//分页构造器
//页数和一页的条件
Page pageInfo = new Page<>(page,pageSize);
//条件构造器
LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
//添加排序条件,根据sort进行排序
queryWrapper.orderByAsc(Category::getSort);
//进行分页查询
categoryService.page(pageInfo,queryWrapper);
return R.success(pageInfo);
}
需求分析
在分类管理列表页面,可以对某个分类进行删除操作。需要注意的是当分类关联了菜品或者套餐时,此分类不允许删除。
代码开发
1、页面发送ajax请求,将参数(id)提交到服务端
2、服务端Controller接收页面提交的数据并调用Service删除数据
3、Service调用Mapper操作数据库
CategoryController层
/**
* 根据id删除分类
* @param id
* @return
*/
@DeleteMapping
public R delete(Long id){
log.info("删除分类,id为:{}",id);
categoryService.removeById(id);
return R.success("分类信息删除成功");
}
前面我们已经实现了根据id删除分类的功能,但是并没有检查删除的分类是否关联了菜品或者套餐,所以我们需要进行功
能完善。
要完善分类删除功能,需要先准备基础的类和接口:
1、实体类Dish(菜单实体类)和Setmeal(套餐实体类)(从课程资料中复制即可
2、Mapper接口DishMapper和SetmealMapper
3、Service接口DishService和Setmealservice
4、Service实现类DishServicelmpl和SetmealServicelmpl
service包下impl
@Service
public class CategoryServiceImpl extends ServiceImpl implements CaregoryService {
//注入,
//菜品分类id private Long categoryId;
@Autowired
private DishService dishService;
@Autowired
private SetmealService setmealService;
/**
* 根据id删除分类,删除之前需要经进行判断
* @param id
*/
@Override
public void remove(Long id) {
//构造查询条件
LambdaQueryWrapper dishLambdaQueryWrapper = new LambdaQueryWrapper<>();
//添加查询条件,根据分类categoryId 数据库是:category_Id 进行查询
dishLambdaQueryWrapper.eq(Dish::getCategoryId,id);
//count 统计数据量
int count1 = dishService.count(dishLambdaQueryWrapper);
// 查询当前分类是否关联了菜品,如果已经关联、抛出一个业务异常
if (count1 > 0){
//已经关联菜品,抛出一个业务异常
throw new CustomException("当前分类下关联了菜品,不能删除");
}
// 查询当前分类是否关联了套餐,如果已经关联,抛出一个业务异常
LambdaQueryWrapper setmealLambdQueryWrapper = new LambdaQueryWrapper<>();
//添加查询条件,根据分类id进行查询
setmealLambdQueryWrapper.eq(Setmeal::getCategoryId,id);
int count2= setmealService.count();
if (count2 > 0){
//已经关联套餐,抛出一个业务异常
throw new CustomException("当前分类下关联了套餐,不能删除");
}
//菜品和套餐都没有关联
//可以正常删除分类 调用删除方法
super.removeById(id);
}
}
common包下自定义异常类
/**
* 自定义业务异常
*/
public class CustomException extends RuntimeException{
public CustomException(String message){
super(message);
}
}
common包下全局异常类
/**
* 异常处理方法
*/
//@ExceptionHandler声明要处理的类
//此处处理的是SQLIntegrityConstraintViolationException的异常
@ExceptionHandler(CustomException.class)
public R exceptionHamdler(CustomException ex){
log.error(ex.getMessage());
return R.error(ex.getMessage());
}
service层impl下CategoryServiceImpl
/**
* 根据id修改分类信息
* @param category
* @return
*/
@PutMapping
public R update(@RequestBody Category category){
log.info("修改分类信息:{}",category);
categoryService.updateById(category);
return R.success("修改分类信息成功");
}
/**
* 文件上传
* Spring框架在spring-web包中对文件上传进行了封装,简化服务端代码
* 我们只需要在Controller的方法中声明
* 一个MultipartFile类型的参数即可接收上传的文件,如下:
* 本质还是上边的两种方式
* @param file
* @return
*/
@PostMapping(value = "/upload")
public R upload (MultipartFile file){
System.out.println(file);
return null;
}
}
文件下载介绍:
文件下载,download,指将文件从服务器传输到本地计算机的过程。
通过浏览器进行文件下载,通常有两种表现形式:
①以附件形式下载,弹出保存对话框,将文件保存到指定磁盘目录
②直接在浏览器中打开
第二步:controller层创建CommonController菜品管理类
/**
* 文件上传和下载
*/
@RestController
@RequestMapping("/common")
@Slf4j
public class CommonController {
//读取配置文件中转存位置
//application.yml文件
//reggie:
// path: D:\
@Value("${reggie.path}")
private String basePath;
/**
* 文件上传
* @return
*/
@PostMapping("/upload")
public R upload(MultipartFile file){
//file是一个临时文件,需要转存到指定位置,否则本次请求完成后临时文件会删除
log.info(file.toString());
/**
* 防止总是被拦截器拦截,在拦截器类设置不需要拦截直接放行
* String[] urls = new String[]{
* //菜品管理
* "/common"
* };
*/
//原始文件名
String originalFilename = file.getOriginalFilename();//abc.jpg
//动态截取文件后缀 suffix接受新的文件名 .之后的
String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
//使用UUID重新生成文件名,防止文件名称重复造成文件覆盖 新文件 + 后缀(.jpg)
String fileName = UUID.randomUUID().toString() + suffix;//qwertt.jpg
//判断application.yml设置的指定位置目录是否存在
File dir = new File(basePath);
//判断当前目录是否存在
if (!dir.exists()){
//目录不存在 ,需要创建
dir.mkdirs();
}
try {
//将临时文件转存到指定位置.
//转存位置可在application.ym中设置
file.transferTo(new File(basePath + fileName));
} catch (IOException e) {
e.printStackTrace();
}
//文件名称需要放在数据库中 返回fileaName
return R.success(fileName);
}
/**
* 文件下载
* @param name
* @param response
*/
//通过流写回数据 不需要返回值
// 输出流需要respinse获得
@GetMapping("/download")
public void download(String name , HttpServletResponse response){
try {
//输入流,通过输入流读取文件内容
FileInputStream fileInputStream = new FileInputStream(new File(basePath + name));
//输出流,通过输出流将文件写回浏览器,在浏览器展示图片了 输出流需要respinse获得
ServletOutputStream outputStream = response.getOutputStream();
// 设置想要返回什么类型文件
response.setContentType("image/jpeg");
// 将读到的内容,放到数组中去
int len = 0;
byte[] bytes = new byte[1024];
//-1 说明没有读完
while ((fileInputStream.read(bytes)) != -1){
// 用过输出流向浏览器写。从第一个写 写len这么长
outputStream.write(bytes,0,len);
outputStream.flush();//刷新
}
// 关闭资源
outputStream.close();
fileInputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
数据模型:
新增菜品,其实就是将新增页面录入的菜品信息插入到dish表,如果添加了口味做法,还需要向dish_flavor表插入数据
所以在新增菜品时,涉及到两个表:
o dish
菜品表
dish flavor
菜品口味表
准备工作:
实体类DishFlavor(直接从课程资料中导入即可,Dish实体前面课程中已经导入过了)
Mapper接口DishFlavorMapper
业务层接口DishFlavorService
业务层实现类DishFlavorservicelmpl
控制层Dishcontroller
1、Mapper接口DishFlavorMapper
@Mapper
public interface DishFlavorMapper extends BaseMapper {
}
2、业务层接口DishFlavorService
public interface DishFlavorService extends IService {
}
3、业务层实现类DishFlavorservicelmpl
public class DishFlavorServiceImpl extends ServiceImpl {
}
4、控制层Dishcontroller
/**
* 菜品管理
*/
@RestController
@RequestMapping("/dish")
public class DishController {
@Autowired
private DishService dishService;
@Autowired
private DishFlavorService dishFlavorService;
}
1、页面(backend/page/food/add.html)发送ajax请求,请求服务端获取菜品分类数据并展示到下拉框中
2、页面发送请求进行图片上传,请求服务端将图片保存到服务器
3、页面发送请求进行图片下载,将上传的图片进行回显
4、点击保存按钮,发送ajax请求,将菜品相关数据以json形式提交到服务端
开发新增菜品功能,其实就是在服务端编写代码去处理前端页面发送的这4次请求即可
代码开发
功能测试
菜品信息分页查询
修改菜品