瑞吉外卖知识点总结_吉瑞外卖实践项目知识点总结

用到的注解:

@RestController:
结合了@Controller和@ResponseBody注解的功能,作用是将一个类标记为控制器(Controller)，并且该类中的方法默认返回JSON格式的数据。它常用于构建RESTful风格的Web服务

@RequestMapper
是一个用于处理请求地址映射的注解，表示类中的所有响应请求的方法都以该地址作为父路径。

@RequestBody
它用于处理来自 HTTP 请求体的 JSON 数据,只能用于处理 POST 和 PUT 请求。

@PathVariable
用于从请求的URL中提取参数值并传递给处理程序方法的参数。要是/user/id这种,而不是/user?id

HttpServletRequest
提供了一种处理HTTP请求的方式,可以获取客户端发送过来的请求参数

@Transactional
保证事务的一致性,比如新增菜品时,菜品添加进了数据库,而菜品口味因为异常而没有添加进,处理起来就比较麻烦,加入此注解后,有一个没添加进数据库,全部都不会被添加进数据库

@EnableTransactionManagement
用于启用事务管理功能,需要加在启动类上

@Configuration
用于定义配置类,只要是配置类就需要写它,Spring会自动扫描并加载这个类中的Bean定义。

@WebFilter
用于标识一个类作为Web过滤器（Filter）的组件,其中filterName是过滤器的名称，通常用于标识过滤器的功能或用途。urlPatterns用于指定过滤器应该被应用到哪些URL模式上,例如，"/api/"将匹配以"/api/"开头的所有URL。

@ServletComponentScan
自动扫描和注册应用程序中的servlet、filter和listener组件。这样就不需要手动注册和配置每个servlet组件。

@Component
用于将普通Java类声明为Bean的注解，从而不需要手动注册和配置每个Bean。

@ControllerAdvice
主要用于处理全局异常和全局数据预设。其中的annotations参数是一个数组，代表@ControllerAdvice注解可以应用于带有数组里面注释的类和方法。

@ResponseBody
表示Controller的方法返回的结果直接写入HTTP response body中，通常用来返回JSON数据或XML数据

@ExceptionHandler
当Spring MVC应用程序在处理HTTP请求时出现错误或异常时，可以用我们自己自定义的异常处理行为。()里面填遇到哪种错误时

@Bean
这是Spring的注解，表示这个方法会返回一个Bean，这个Bean会被Spring容器管理。

@Data
可以自动生成get,set,tostring,hashcode,equals方法,简化开发

1.项目配置类

内容:过滤器,公共字段自动填充,全局异常处理器,MP分页插件配置,统一返回类型R,文件上传下载

①过滤器

作用:用来判断用户是否登录,否则可以直接通过网址进入,所以要拦截

所用注解:@WebFilter,@ServletComponentScan

使用方法:
(1).首先接口Filter,重写doFilter方法
(2).把ServletRequest和ServletResponse两个参数强转为HttpServletRequest,并request方法get本次请求到的URL
(3).创建一个不需要过滤的url地址的集合,然后检查这里面的地址是否和本次的URL是一个,是就放行,不是就再判断是否已经登录,已经登录就放行,没有就返回未登录结果
(4).在启动类上加@ServletComponentScan注解

@WebFilter(filterName = "loginCheckFilter", urlPatterns = "/*")
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();
 
        //2.判断本次请求是否需要处理,先创一个检查方法
        String[] urls = new String[]{
                "/backend/**",
                "/front/**",
                "/employee/login",
                "/employee/logout",
                "/common/**"
        };
 
        boolean check = check(urls, requestURI);
 
        //3.如果本次是不需要过滤的地址,直接放行
        if (check){
            filterChain.doFilter(request,response);
            return;
        }
 
        //4.如果已登录,那直接放行
        if (request.getSession().getAttribute("employee") != null){
           //是为了自动填充所以到这里来获取当前进程的id,并保存
            Long id =(Long) request.getSession().getAttribute("employee");
            BaseContext.setCurrentId(id);
 
            filterChain.doFilter(request,response);
            return;
        }
 
        //5.如果未登录则通过输出流来返回未登录结果,""里的内容根据前端来写
        response.getWriter().write(JSON.toJSONString(R.error("NOTLOGIN")));
        return;
    }
    //自定义检查方法
    public boolean check(String[] urls, String requestURI) {
        for (String url : urls) {
            boolean match = PATH_MATCHER.match(url, requestURI);
            if (match) {
                return true;
            }
        }
        return false;
    }
    }

②公共字段自动填充 

作用:可以把一些公共的字段(例如创建时间,修改时间,创建人,修改人等)自动设置好,能简化开发

所用注解:@Component

使用方法:
(1).首先创建一个配置类(填充)来接口MetaObjectHandler,重写insertFill和updateFill方法
(2).再创一个配置类(动态id),基于threadLocal用来保存和获取当前登录的id,在过滤器上获取当前id(注意去看过滤器第4个判断)
(3).最后填充配置类用本类的setValue方法来设置公共字段

填充配置类

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    //插入时自动填充
    @Override
    public void insertFill(MetaObject metaObject) {
      metaObject.setValue("createTime", LocalDateTime.now());
      metaObject.setValue("updateTime", LocalDateTime.now());
      metaObject.setValue("createUser", BaseContext.getCurrentId());
      metaObject.setValue("updateUser", BaseContext.getCurrentId());
    }
    //更新时自动填充
    @Override
    public void updateFill(MetaObject metaObject) {
      metaObject.setValue("updateTime", LocalDateTime.now());
      metaObject.setValue("updateUser", BaseContext.getCurrentId());
    }
}

动态id配置类

public class BaseContext {
    private static ThreadLocal<Long> threadLocal = new ThreadLocal<>();
 
    public static void setCurrentId(Long id) {
        threadLocal.set(id);
    }
 
    public static Long getCurrentId() {
        return threadLocal.get();
    }
}

 ③全局异常处理器

作用:用于对系统中出现的异常进行统一的处理,可以避免在每个业务方法中都使用try-catch语句,简化开发.

所用注解:@ControllerAdvice,@ResponseBody,@ExceptionHandler

使用方法:

@ControllerAdvice(annotations = {RestController.class, Controller.class})
@ResponseBody
public class GlobalExceptionHandler {
 
    //用于新增时用户名存在时报的异常
    @ExceptionHandler(SQLIntegrityConstraintViolationException.class)
    public R<String> exceptionHandler(SQLIntegrityConstraintViolationException ex){
        if (ex.getMessage().contains("Duplicate entry")){
           return R.error("已存在");
        }
        return R.error("不知道哪错了,别试了");
    }
 
   //当前分类是否关联菜品或套餐的异常
    @ExceptionHandler(CustomException.class)
    public R<String> exceptionHandler(CustomException ex){
        return R.error(ex.getMessage());
    }
}

④MP分页插件 

作用:用于查询页面数据,页面展示时的分页效果

所用注解:@Configuration,@Bean

使用方法:(1).先创建一个MP拦截器,并在拦截器上添加一个分页器

@Configuration
public class MybatisPlusConfig{
    @Bean
    public MybatisPlusInterceptor interceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

⑤统一返回类型R

作用:用来统一类型向前端返回数据的

所用注解:@Data

使用方法:(1)定义前端需要的状态码,返回信息,数据等(看前端代码,这三个是基本),并创建成功方法和失败方法

@Data
public class R<T> implements Serializable {
    private Integer code;//状态码,看前端可知1是成功,0或其他数是失败
    private String msg;//返回信息
    private T data;//数据
    private Map map = new HashMap(); //动态数据
//成功方法
    public static <T> R<T> success(T object) {
        R<T> r = new R<T>();
        r.data = object;
        r.code = 1;
        return r;
    }
//失败方法
    public static <T> R<T> error(String msg) {
        R r = new R();
        r.msg = msg;
        r.code = 0;
        return r;
    }
 
    public R<T> add(String key, Object value) {
        this.map.put(key, value);
        return this;
    }
}

⑥文件上传下载 

作用:上传和下载本地图片到网页

所用注解:@RestController,@RequestMapping,@Value,MultipartFile,HttpServletResponse

使用方法:
注意:此类方法不适用于nginx,nginx需要用OSS来存储图片
(1).先创建一个新的Controller类,然后分别创建上传的方法和下载的方法
(2).上传方法只需要用file的transferTo方法,把图片转存到我们指定的地方,这个地方最好在yml上配置好,然后用@Value调用这个地址,方便后期随时修改地址.图片名字也需要调用原始文件名,把"."后面的字母取出来,再用UUID随机一个名字加上我们取出来的后缀组成一个新的文件名,可以防止文件名因重复而覆盖,最后返回成功文件名

@Value("${it-sky.path}")
    private String basePath;
 
    @PostMapping("/upload")
    public Result<String> upload(MultipartFile file){
//这个file一定要看页面负载里面源的name是否是file,要保持一致
        
        //原始文件名
        String originalFilename = file.getOriginalFilename();
        String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
 
        //使用UUID重新生成文件名,繁殖文件名称重复造成文件覆盖
        String fileName = UUID.randomUUID().toString()+suffix;
 
        try {
            file.transferTo(new File(basePath+fileName));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return Result.success(fileName);
    }

(3).下载方法则是通过输入流读取图片内容,再用输出流把图片写回到浏览器上,显示图片.需要用response来设置文件类型,定义一个字节数量的整型变量,再创建一个字节数组,使用循环输入流读取数据,并把数据存储在整型变量中,如果read返回-1,则循环结束.在使用输出流把数据写入另一个地方
(4).关流

public void download(String name , HttpServletResponse response){
        try {
            //输入流,通过输入流读取文件内容
            FileInputStream fileInputStream = new FileInputStream(new File(basePath+name));
 
            //输出流,通过输出流将文件写回浏览器,在浏览器展示图片了
            ServletOutputStream outputStream = response.getOutputStream();
            //设置文件类型
            response.setContentType("image/jpeg");
            //初始化一个整型变量len，并赋值为0。这个变量将用于存储从输入流中读取的字节数量。
            int len = 0;
            //创建一个长度为1024的字节数组bytes。这个数组将用于存储从输入文件中读取的数据。
            byte[] bytes = new byte[1024];
            /*使用fileInputStream（一个文件输入流）来读取数据，并将读取的字节数量存储
            在len中。如果read方法返回-1，说明已经读取到文件的末尾，此时循环将结束。*/
            while ((len = fileInputStream.read(bytes)) != -1){
                /*使用outputStream（一个输出流）来将读取的数据写入到另一个地方。
                write方法的三个参数分别是：要写入的数据（bytes数组），开始写入的
                起始位置（0，表示从数组的开始位置写入），以及要写入的字节数量（len）。*/
                 outputStream.write(bytes,0,len);
                 outputStream.flush();
            }
            //关闭资源
            outputStream.close();
            fileInputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

2.登录接口

流程分析:
1.先判断账号数据库中是否存在
2.再判断密码是否正确
3.最后把数据发送到前端,并把id存入Session页面中

用到的注解:HttpServletRequest,@RequestBody

实际操作:
①用构造器查询所需要的数据库数据,记得LambdaQueryWrapper要加<>,<>里面是你要操作的表
②用eq来比较,第一个数据是被比较的表,第二个是你传过来要比较的数据
③用实现类查到的数据封装到实体类,好进行判断账号是否存在

LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Employee::getUsername, employee.getUsername());
Employee emp = employeeService.getOne(queryWrapper);
if (emp==null){
   return R.error("登陆失败");
}

注意:R是用来统一类型向前端返回数据的,一般有状态码(code),返回信息(msg),数据(data),里面一个成功方法一个失败方法,要继承Serializable,还要加@Data注解,这个R要自己创建.

④因为看数据库可知密码都是用md5加密的,所以在比较密码时需要把获取的密码数据先进行加密再进行比较

String password = employee.getPassword();
password = DigestUtils.md5DigestAsHex(password.getBytes());
if (!emp.getPassword().equals(password)){
    return R.error("登陆失败");
}

​

⑤这里用到了HttpServletRequest

request.getSession().setAttribute("employee",emp.getId());
return R.success(emp);

3.退出接口 

流程分析:删除页面保存的登录信息

用到的注解:HttpServletRequest

实际操作:

@PostMapping("logout")
public R<String> logout(HttpServletRequest request){
    request.getSession().removeAttribute("employee");
    return R.success("退出成功");
}

4.新增接口(一般用@PostMapping)

①普通新增:

用到的注解:HttpServletRequest,@Requestbody

流程分析:
1.用实体类设置好 密码(有的需要,有的还需要md5加密),创建时间,修改时间,创建人,修改人,人从Http拿.这四个也可以使用公共字段自动填充来设置.
2.用实现类直接.save就行,返回成功信息

实际操作:

public R<String> add(@RequestBody Employee employee){
  employee.setPassword(DigestUtils.md5DigestAsHex("12345".getBytes()));
  ...
  employeeService.save(employee);
  return R.success("添加成功");
}

②多表新增:

用到的注解:HttpServletRequest,@Requestbody,@Transactional,
@EnableTransactionManagement

流程分析:
(1)因为最开始的实体类有一些数据没有,所以需要创建对应DTO来新增那些数据,DTO要继承对应实体类,并且@Requestbody后面就需要改成DTO实体类.
(2)在service层创建新的save方法,并且自动注入要操作的另一个表的实现类
(3)首先用本类方法保存本来实体类有的数据,然后用注入进来的另一张表的实现类来保存要新增get出来的数据.
(4)还可以用stream流来完善DTO,比如要新增的是菜品口味,而菜品口味有了却没有对应的菜品id,就可以先获取菜品id,再获取菜品口味,然后用stream流给每一个菜品口味赋上id,最后返回给菜品口味,再保存.
(5)在实现类上加上事务管理,还有启动类上加上扫描事务管理的注解
(6)最后在Controller层调用我们新创建的save方法

实际操作:

Controller层的代码

@PostMapping
public R<String> save(@RequestBody DishDto dishDto){
    dishService.saveWithFlavor(dishDto);
    return R.success("新增成功");
}

ServiceImpl层的代码

public void saveWithFlavor(DishDto dishDto) {
  this.save(dishDto);
  Long dishId = dishDto.getId();
  List<DishFlavor> flavors = dishDto.getFlavors();
  flavors = flavors.stream().map((item)->{
       item.setDishId(dishId);
       return item;
   }).collect(Collectors.toList());
  dishFlavorService.saveBatch(flavors);
}

5.删除接口(一般用DeleteMapping)

①普通删除

用到的注解:无

流程分析:
(1)如果是单独删除,参数直接是Long id,不用@PathVariable是因为前端页面路径是?不是/
(2)是批量删除就用String[] ids,然后用增强for循环,把每一个id都用本实现类删除,并返回成功信息

实际操作:

@DeleteMapping
public R<String> delete(String[] ids){
    for (String id:ids) {
        dishService.removeById(id);
    }
return R.success("删除成功");
}

②有条件的删除

用到的注解:无

流程分析:
(1)如果是关联了其他条件导致不能删除的,我们在Service层新创建一个删除方法,并注入要查询的表
(2)用LambdaQueryWrapper在数据库中查询是否关联了,如果关联了就不能删除,抛异常(这里可以创建一个异常类集中处理项目中的异常,也方便向前端传递异常信息),如果没关联,就可以删除
(3)如果是因为商品的某个状态不能删除的,我们查询到那个状态并进行判断,如果状态不能删就返回错误信息,能删就返回成功信息

实际操作:

例1.

public void remove(Long id) {
  LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
  queryWrapper.eq(Dish::getCategoryId, id);
  int count1 = dishService.count(queryWrapper);
  if (count1 > 0) {
     throw new CustomException("当前分类下关联了菜品,兄弟换一个删");
}
super.removeById(id);
}

例2.

@DeleteMapping
public R<String> delete(String[] ids){
   int index=0;
   for(String id:ids) {
       Setmeal setmeal = setmealService.getById(id);
       if(setmeal.getStatus()!=1){
             setmealService.removeById(id);
       }else {
             index++;
       }
}
    if (index>0&&index==ids.length){
    return R.error("选中的套餐均为启售状态，不能删除");
  }else {
     return R.success("删除成功");
  }
}

6.修改接口(一般用PutMapping)

①普通修改

用到的注解:@RequestBody,@PathVariable,HttpServletRequest(有时需要)

流程分析:
(1).简单修改直接用实现类方法updateById,记得用Http参数设置修改时间和修改人(有公共字段自动填充的话就不用写)
(2).如果是修改状态这种,看前端页面路径是否改变,可以用@PathVariable获取路径状态,然后实现类用getById获取要改变的用户,setStatus设置获取的状态,最后实现类updateById修改

实际操作:

@PostMapping("/status/{status}")
    public R<String> sale(@PathVariable int status, String[] ids){
        for (String id:ids){
            Setmeal byId = setmealService.getById(id);
            byId.setStatus(status);
            setmealService.updateById(byId);
        }
        return R.success("修改状态成功");
    }

②多表修改

用到的注解:@RequestBody,HttpServletRequest(有时需要)

流程分析:
(1)因为最开始的实体类有一些数据没有,所以需要创建对应DTO来修改那些数据,DTO要继承对应实体类,并且@Requestbody后面就需要改成DTO实体类.(前面新增时一般都会创建)
(2)在service层创建新的update方法,并且自动注入要操作的另一个表的实现类
(3)首先用本类方法先修改本来实体类有的数据,然后我们需要删除当前数据实体类没有但已经保存了的数据,就比如新增菜品时我们通过多表新增方法新增了菜品口味,这时我们修改了菜品口味就需要先把菜品口味删除
(4)删除完后我们再调用前端传过来的菜品口味,用stream流一一为修改的菜品口味设置菜品id
(5)最后使用另一张表的实现类保存,并在Controller层调用我们新创建的update方法

实际操作:

ServiceImpl层代码

@Override
    public void updateWithFlavor(DishDto dishDto) {
        this.updateById(dishDto);
        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(DishFlavor::getDishId,dishDto.getId());
        dishFlavorService.remove(queryWrapper);
        List<DishFlavor> flavors = dishDto.getFlavors();
        flavors = flavors.stream().map((item)->{
            item.setDishId(dishDto.getId());
            return item;
        }).collect(Collectors.toList());
        dishFlavorService.saveBatch(flavors);
    }
}

7.查询接口(一般用GetMapping)

①普通查询

用到的注解:@Configuration(配置时需要)

流程分析:
(1).首先需要创建一个MP分页插件的配置类
(2).再构造一个分页查询器
(3).调用实现类的page方法把分页查询器传过去,并返回分页查询

实际操作:

配置类代码

@Configuration
public class MybatisPlusConfig{
    @Bean
    public MybatisPlusInterceptor interceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

 Controller层方法

@GetMapping("/page")
    public R<Page> list(int page,int pageSize){
        //分页构造器
        Page pageInfo = new Page(page,pageSize);
        employeeService.page(pageInfo);
        return R.success(pageInfo);
    }

②回显查询

用到的注解:@PathVariable

流程分析:
(1).如果是普通回显,则用@PathVariable获取页面路径传回来的id以及实现类getById来获取回显信息,判断不为空则返回成功信息,为空则返回错误信息
(2).如果是列表回显,则先创建条件构造器,eq查询需要回显的数据,orderByAsc设置排序条件,最后用实现类的list方法返回结果

实际操作:

普通回显代码

@GetMapping("/{id}")
    public R<Employee> getById(@PathVariable Long id){
        Employee byId = employeeService.getById(id);
        if (byId != null){
            return R.success(byId);
        }else {
            return R.error("没有查询到对应数据");
        }
    }

列表回显代码 

@GetMapping("/list")
    public R<List<Dish>> Getlist(Dish dish){
        LambdaQueryWrapper<Dish> queryWrapper =new LambdaQueryWrapper<>();
      queryWrapper.eq(dish.getCategoryId()!=null,Dish::getCategoryId,dish.getCategoryId());
        queryWrapper.eq(Dish::getStatus,1);
        queryWrapper.orderByAsc(Dish::getSort);
        List<Dish> listInfo = dishService.list(queryWrapper);
        return R.success(listInfo);
    }

③多表查询

用到的注解:@Configuration(配置时需要)

流程分析:
(1).首先需要创建一个MP分页插件的配置类(创建过就不需要再创)
(2).其次创建一个旧分页器(利用Dish表)和一个新分页器(利用DishDTO)
(3).用旧分页器利用实现类page方法把数据都查询出来,并把这些数据拷贝到新分页器上,除了records(这里面实际就是我们的页面展示的那些数据)
(4).用旧分页器把records查出来
(5).records用stream流先把旧分页器的数据拷贝到新分页器上,然后把和另一张表关联的id(例如分类id)取出来,然后把这个id用另一张表的实现类查询出对应名字(分类名字),最后把查询出的数据设置给DTO,并返回DTO.
(6)把stream流toList,最后设置给新分页器的records

实际操作:

@GetMapping("/page")
    public R<Page> list(int page,int pageSize,String name){
        //构造分页器
        Page<Dish> pageInfo = new Page<>(page,pageSize);
        //构造一个新的分页器,因为之前那个缺少某个类
        Page<DishDto> dishDtoPage = new Page<>(page,pageSize);
 
        dishService.page(pageInfo);
        BeanUtils.copyProperties(pageInfo,dishDtoPage,"records");
        List<Dish> records = pageInfo.getRecords();
 
        List<DishDto> list = records.stream().map((item)->{
            DishDto dishDto = new DishDto();
            BeanUtils.copyProperties(item,dishDto);
            Long categoryId = item.getCategoryId();
            Category byId = categoryService.getById(categoryId);
            String name = byId.getName();
            dishDto.setCategoryName(name);
            return dishDto;
        }).collect(Collectors.toList());
 
        dishDtoPage.setRecords(list1);
 
        return R.success(dishDtoPage);
    }