瑞吉外卖

数据库搭建

表结构

Maven项目

1. 创建Maven项目

2. 编写pom文件

3. 编写配置文件application.yml

4. 创建启动类ReggieApplication.java

前端静态资源的配置

将两个前端静态资源包导入到resource目录下方，由于Spring-MVC默认只能访问static和templete下面的文件，所以需要对其进行静态资源的映射，在reggie源目录下新建一个config目录，对其进行静态资源配置；

通过addResourceHandler添加映射路径，然后通过addResourceLocations来指定路径

@Slf4j
@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {
    /**
     * 设置静态资源的映射
     * @param registry
     */
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        log.info("开始进行静态资源映射....");
        //资源处理器
        registry.addResourceHandler("/backend/**").addResourceLocations("classpath:/backend/");
        registry.addResourceHandler("/front/**").addResourceLocations("classpath:/front/");
    }
}

后台登陆功能

需求分析

查询数据库employee表单，同时要构造统一的返回值格式JSON 。

创建实体类

实体类和数据库表中的字段一一对应

完善目录结构

创建contoller，service，mapper包

mapper

@Mapper
public interface EmployeeMapper extends BaseMapper<Employee> {
}

由于整个项目使用么MybatisPlus，可以直接继承BaseMapper写入对应的实体类，即可实现简单的增上改查

Service

public interface EmployeeService extends IService<Employee> {
}

@Service
public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper, Employee> implements EmployeeService {
}

controller

@RestController
@Slf4j
@RequestMapping("/employee")
public class EmployeeController {
    @Autowired
    private EmployeeService employeeService;
}

创建统一返会结果类R

此类是一个通用结果类，服务端响应的所有结果最终都会包装成此种类型返回给前端页面

登录方法

@RequestBody主要用来接收前端传递给后端的json字符串中的数据

HttpServletRequest 对象专门用于封装 HTTP 请求消息，简称 request 对象。

LambdaQueryWrapper不需要输入数据库字段名字，输入实体类的对应驼峰命名即可！！

    /**
     * 登录
     * @param request 用来获取session中存储的Employee的ID
     * @param employee 用来接收前端传递过来的employee对象
     * @return
     */
    @RequestMapping("/login")
    private R<Employee> login(HttpServletRequest request, @RequestBody Employee employee){
        /*
        1、将页面提交的密码password进行md5加密处理
        2、根据页面提交的用户名username:查询数据库
        3、如果没有查询到则返回登录失败结果
        4、密码比对，如果不一致则返回登录失败结果
        5、查看员工状态，如果为已禁用状态，则返回员工已禁用结果
        6、登录成功，将员工id存入Session并返回登录成功结果
         */
        //将前端传递过来的明文转换为MD5加密的方式
        String password = DigestUtils.md5DigestAsHex(employee.getPassword().getBytes());
        //根据页面传递过来的username，查询数据库中的密码
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Employee::getUsername,employee.getUsername());//等值查询
        Employee emp = employeeService.getOne(queryWrapper);//查询数据，封装为一个Employee对象
        if (emp == null){
            return R.error("没有此用户...");
        }
        if (!emp.getPassword().equals(password)) return R.error("密码输入错误....");
        if (emp.getStatus() == 0) return R.error("用户已禁用....");
        // 前面的验证都没有出错，证明用户存在且密码正确并没有被禁用，那么将用户的id存入到session中保存起来
        request.getSession().setAttribute("employee",emp.getId());
        return R.success(emp);
    }

通过debug的方式进行功能测试

退出登录功能

需求分析

员工登录成功后，页面跳转到后台系统首页面(backend/index.html),此时会显示当前登录用户的姓名；如果员工需要退出系统，直接点击右侧的退出按钮即可退出系统，退出系统后页面应跳转回登录页面

用户点击页面中退出按钮，发送请求，请求地址为/employee/logout,请求方式为POST。
我们只需要在Controller中创建对应的处理方法即可，具体的处理逻辑：
1、清理Session中的用户id
2、返回结果

代码实现

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

完善登录功能

问题分析

前面我们已经完成了后台系统的员工登录功能开发，但是还存在一个问题：用户如果不登录，直接访问系统首页面，照样可以正常访问。
这种设计并不合理，我们希望看到的效果应该是，只有登录成功后才可以访问系统中的页面，如果没有登录则跳转到登录页面？
那么，具体应该怎么实现呢？

答案就是使用过滤器或者拦截器，在过滤器或者拦截器中判断用户是否已经完成登录，如果没有登录则跳转到登录页面。

代码实现

实现步骤：

1. 创建自定义过滤器LoginCheckFilter
2. 在启动类上加入注解@ServletComponentScan
3. 完善过滤器的处理逻辑

/**
 * 登陆拦截器
 */
@Slf4j
@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;
        // 获取到请求的地址
        log.info("已经拦截到：{}",request.getRequestURI());
        String requestURI = request.getRequestURI();
        String[] urls = new String[]{
                "/employee/login",
                "/employee/logout",
                "/backend/**",
                "/front/**"
        };
        boolean check = check(urls, requestURI);

        //  如果匹配，那么直接放行
        if (check){
            log.info("不需要处理:{}",requestURI);
            filterChain.doFilter(request,response);
            return;
        }

        // 如果session中有employee对象，那么已经登录直接方法
        if (request.getSession().getAttribute("employee") != null) {
            log.info("已经登录：{}",request.getSession().getId());
            filterChain.doFilter(request,response);
            return;
        }
        // 否则跳转到登录页面，根据JS中的代码写出其状态码
        response.getWriter().write(JSON.toJSONString(R.error("NOTLOGIN")));
        return;

    }

    /**
     * 检查路径是否匹配
     * @param urls
     * @param requestURI
     * @return
     */
    public boolean check(String[] urls,String requestURI){
        for (String url : urls) {
            if (PATH_MATCHER.match(url,requestURI)) {
                return true;
            }
        }
        return false;
    }
}

新增员工功能

需求分析

数据模型

开发代码

代码实现

@PostMapping
public R<String> save(HttpServletRequest request,@RequestBody Employee employee){
    employee.setPassword(DigestUtils.md5DigestAsHex("123456".getBytes()));
    employee.setCreateTime(LocalDateTime.now());
    employee.setUpdateTime(LocalDateTime.now());
    employee.setCreateUser((Long)request.getSession().getAttribute("employee"));
    employee.setUpdateUser((Long) request.getSession().getAttribute("employee"));

    employeeService.save(employee);
    log.info("获取添加员工信息：{}",employee.toString());
    return R.success("添加成功");
}

当前问题

创建一个全局异常处理类

SQLIntegrityConstraintViolationException：其实就是违反了数据库的唯一约束条件，也就是插入数据时，具有唯一约束条件的列值重复了

/**
 * 全局异常处理
 */
// controller加入了这两个注解，那么就会被全局异常处理类处理
@ControllerAdvice(annotations = {RestController.class, Controller.class})
@ResponseBody
@Slf4j
public class GlobalExceptionHandler {
    /**
     * 异常处理方法
     * @return
     */
    @ExceptionHandler(SQLIntegrityConstraintViolationException.class)
    public R<String> exceptionHandler(SQLIntegrityConstraintViolationException exception){
        log.error(exception.getMessage());
        if (exception.getMessage().contains("Duplicate entry")){
            String message = exception.getMessage();
            String[] strings = message.split(" ");
            String msg = strings[2]+"已存在";
            return R.error(msg);
        }
        return R.error("未知错误");
    }
}

员工信息分页查询功能

需求分析

代码开发

配置分页插件

/**
 * 配置分页插件
 */
@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

分页代码

 /**
 * 员工信息的分页查询
 * @param page
 * @param pageSize
 * @param name
 * @return
 */
@GetMapping("/page")
public R<Page> page(int page,int pageSize,String name){
    log.info("page={},pageSize={},name={}",page,pageSize,name);
    // 构造分页构造器
    Page pageInfo = new Page(page,pageSize);

    // 构造条件构造器
    LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper();
    // 添加条件
    queryWrapper.like(StringUtils.isNotEmpty(name),Employee::getUsername,name);
    queryWrapper.orderByDesc(Employee::getUpdateTime);
    // 执行查询
    employeeService.page(pageInfo,queryWrapper);//在service层进行分页，page会在内部直接进行封装
    return R.success(pageInfo);
}

启用/禁用员工账号

需求分析

在员工管理列表页面，可以对某个员工账号进行启用或者禁用操作。账号禁用的员工不能登录系统，启用后的员工可以正常登录。
需要注意，只有管理员(admi用户)可以对其他普通用户进行启用、禁用操作，所以普通用户登录系统后启用、禁用按钮不显示。

代码开发

    /**
     * 员工信息的分页查询
     * @param page
     * @param pageSize
     * @param name
     * @return
     */
    @GetMapping("/page")
    public R<Page> page(int page,int pageSize,String name){
        log.info("page={},pageSize={},name={}",page,pageSize,name);
        // 构造分页构造器
        Page pageInfo = new Page(page,pageSize);

        // 构造条件构造器
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper();
        // 添加条件
        queryWrapper.like(StringUtils.isNotEmpty(name),Employee::getUsername,name);
        queryWrapper.orderByDesc(Employee::getUpdateTime);
        // 执行查询
        employeeService.page(pageInfo,queryWrapper);//在service层进行分页，page会在内部直接进行封装
        return R.success(pageInfo);
    }

代码实现

本质上就是对数据库中的status字段进行更新

出现的问题

对象转换器

/**
 * 对象映射器:基于jackson将Java对象转为json，或者将json转为Java对象
 * 将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象]
 * 从Java对象生成JSON的过程称为 [序列化Java对象到JSON]
 */
public class JacksonObjectMapper extends ObjectMapper {

    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

    public JacksonObjectMapper() {
        super();
        //收到未知属性时不报异常
        this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

        //反序列化时，属性不存在的兼容处理
        this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);


        SimpleModule simpleModule = new SimpleModule()
                .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)))

                .addSerializer(BigInteger.class, ToStringSerializer.instance)
                .addSerializer(Long.class, ToStringSerializer.instance)
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));

        //注册功能模块 例如，可以添加自定义序列化器和反序列化器
        this.registerModule(simpleModule);
    }
}

将上方的对象转换器添加到MVC中，并设置其优先级，优先使用新加的转换器

    /**
     * 扩展MVC框架的消息转换器
     * @param converters
     */
    @Override
    protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        log.info("扩展消息转换器");
        // 创建消息转换器
        MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
        // 设置对象转换器，底层使用Jackson将java转换为JSON
        messageConverter.setObjectMapper(new JacksonObjectMapper());
        // 将上面的消息转换器对象追加到MVC框架转换器集合当中
        converters.add(0,messageConverter);//将新建的转换器设置为优先使用
    }

在MVC的配置文件中添加扩展MVC的消息转换器方法

    /**
     * 根据id修改员工信息
     * @param employee
     * @return
     */
    @PutMapping
    public R<String> update(HttpServletRequest request,@RequestBody Employee employee){
        log.info(employee.toString());
        employee.setUpdateTime(LocalDateTime.now());
        employee.setUpdateUser((Long)request.getSession().getAttribute("employee"));
        employeeService.updateById(employee);
        return R.success("员工信息修改成功");
    }

编辑员工信息

需求分析

代码开发

代码实现

    /**
     * 根据id查询员工信息
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public R<Employee> getById(@PathVariable Long id){
        log.info("根据id查询员工信息..");
        Employee employee = employeeService.getById(id);
        if (employee != null) return R.success(employee);
        return R.error("未查询到.");
    }

点击保存按钮，根据add.html中的逻辑，会到editEmployee方法中，实际该方法会调用后端的update方法，即可完成更新操作。