Endereço do projeto https://gitee.com/zhang-zakcomy/cang-qiong-take-out/
1. Construção ambiental - visão geral do projeto Day01, construção ambiental
Introdução geral ao desenvolvimento de software
processo de desenvolvimento de software
- análise de demanda
Conclusão da especificação de requisitos e
redação do protótipo do produto A especificação de requisitos geralmente usa documentos do Word para descrever cada componente do projeto atual, tais como: definição do sistema, ambiente de aplicação, especificações funcionais, requisitos de desempenho, etc., serão descritos no documento.
Os protótipos de produtos geralmente mostram que tipo de dados a página atual exibe na forma de páginas da web (html), como é o layout da página, clique em um determinado menu, qual página abrir, clique em um determinado botão e o que quer que seja. efeito aparece. Veja através de protótipos de produtos.
- projeto
O conteúdo do design inclui design de UI, design de banco de dados e design de interface.
- Design de UI: o design da interface do usuário, o efeito de página do projeto de design principal, tão pequeno quanto um botão, tão grande quanto um layout de página e a personificação da lógica de interação humano-computador.
- Design do banco de dados: É necessário projetar quais bancos de dados estão envolvidos no projeto atual, quais tabelas estão contidas em cada banco de dados, qual é o relacionamento entre essas estruturas de tabelas e quais campos estão contidos na estrutura da tabela.
- Design de interface: ao analisar o diagrama de protótipo, primeiro analise quantas interfaces cada página possui de maneira granular e, em seguida, analise os parâmetros de entrada e os parâmetros de valor de retorno de cada interface de maneira granular e esclareça o caminho da interface e método de solicitação ao mesmo tempo.
Uma interface equivale a um determinado protocolo, o que permite que diferentes componentes ou módulos se comuniquem melhor entre si e trabalhem juntos na concepção de software ou projeto.
- Codificação: Esta etapa consiste principalmente em realizar cada módulo e função do software e escrever códigos específicos de acordo com os documentos de projeto. Nesta fase, você precisa estar atento à qualidade e legibilidade do código e, ao mesmo tempo, seguir as normas e padrões de codificação para garantir a confiabilidade e facilidade de manutenção do código.
- Teste: Esta etapa serve principalmente para testar o programa compilado, verificar se o programa atende aos requisitos e requisitos de design e, ao mesmo tempo, descobrir e corrigir possíveis defeitos e lacunas. Nesta fase, devem ser desenvolvidos planos de teste detalhados e casos de teste, e vários cenários e situações possíveis devem ser considerados para garantir a qualidade e estabilidade do programa.
- Operação e manutenção on-line: Esta etapa consiste principalmente na implantação do programa no ambiente de produção para operação e manutenção reais. Nesta fase, é necessário formular um plano de implantação e um plano de operação e manutenção razoáveis. Ao mesmo tempo, é necessário monitorar o status e a operação do programa em tempo real, e detectar e lidar com possíveis problemas e falhas. em tempo.
Divisão de papéis
Depois de estarmos familiarizados com todo o processo de desenvolvimento de software, também precisamos entender as funções envolvidas em todo o processo de desenvolvimento de software e a divisão de responsabilidades de cada função.
| posição/função | estágio correspondente | A divisão de responsabilidades |
|---|---|---|
| gestor de projeto | todas as etapas | Responsável por todo o projeto, atribuindo tarefas e controlando o andamento |
| gerente de produto | análise de demanda | Conduzir pesquisas de demanda, produzir documentos de pesquisa de demanda, protótipos de produtos, etc. |
| Designer de interface do usuário | projeto | Renderizações de interface de saída com base em protótipos de produtos |
| arquiteto | projeto | Design geral da arquitetura do projeto, seleção de tecnologia, etc. |
| Engenheiro de desenvolvimento | codificação | Implementação de código de função |
| Engenheiro de testes | teste | Escreva casos de teste e produza relatórios de teste |
| Engenheiro de Operação e Manutenção | Operação e manutenção on-line | Construa o ambiente de software e lance o projeto |
Em projetos reais, algumas equipes de projeto podem não ter arquitetos ou testadores dedicados devido à escassez de pessoal.Neste momento, os gerentes de projeto ou programadores podem ser obrigados a agir simultaneamente.
Ambiente de Software
Como engenheiro de desenvolvimento de software, você inevitavelmente entrará em contato com uma variedade de ambientes de software durante o processo de codificação. Analisamos principalmente os três conjuntos de ambientes que você frequentemente encontra em seu trabalho, a saber: ambiente de desenvolvimento, ambiente de teste e ambiente de produção . A seguir apresentamos as funções e características desses três ambientes.
1) Ambiente de desenvolvimento (desenvolvimento)
Como desenvolvedor de software, o ambiente utilizado na fase de desenvolvimento é o ambiente de desenvolvimento, que geralmente é inacessível a usuários externos.
Por exemplo, o banco de dados MySQL e outros softwares comuns que usamos no desenvolvimento podem ser instalados localmente ou em um servidor dedicado. Esses softwares aplicativos são usados apenas no processo de desenvolvimento de software, quando o projeto for testado e lançado, não usaremos este ambiente mais, este ambiente é o ambiente de desenvolvimento.
2) Ambiente de teste (teste)
Como engenheiro de desenvolvimento de software, após desenvolver os módulos funcionais do projeto e passar no teste de unidade, o projeto precisa ser implantado no servidor de teste para que os testadores testem o projeto. Então este servidor de teste é um ambiente especialmente utilizado por testadores, ou seja, o ambiente de teste, que é utilizado para testes de projetos e geralmente não pode ser acessado por usuários externos.
3) Ambiente de produção (produção)
Quando o projeto é desenvolvido e aprovado no teste pelos testadores, o projeto pode ser lançado, implantado no ambiente online e fornecido oficialmente serviços externos. Esse ambiente online também é chamado de ambiente de produção.
Em primeiro lugar, o desenvolvimento do projeto será realizado no ambiente de desenvolvimento. Muitas vezes, o ambiente de desenvolvimento é principalmente o ambiente do computador local e o ambiente na LAN. Após a conclusão do desenvolvimento, o projeto será implantado no ambiente de teste. O teste O ambiente geralmente é um ambiente de teste independente O ambiente do servidor, após a aprovação no teste do projeto, finalmente implanta o projeto no ambiente de produção.O ambiente de produção pode ser um ambiente on-line, como uma sala de computadores ou um servidor em nuvem.
Introdução ao projeto Sky Takeaway
Introdução ao Projeto
Este projeto (Kongqiong Takeaway) é um produto de software especialmente customizado para empresas de catering (restaurantes, restaurantes), incluindo duas partes: o histórico de gerenciamento do sistema e o aplicativo de terminal de pequeno programa. Entre eles, o histórico de gestão do sistema é fornecido principalmente para funcionários internos de empresas de catering, podendo gerenciar e manter categorias de restaurantes, pratos, refeições fixas, pedidos, funcionários, etc., e pode realizar estatísticas sobre diversos dados de restaurantes. O mini terminal de programa é fornecido principalmente aos consumidores, que podem navegar pelos pratos online, adicionar carrinhos de compras, fazer pedidos, pagar e lembrar pedidos, etc.
protótipo de produto
O protótipo do produto é usado para demonstrar as funções de negócios do projeto e geralmente é projetado pelo gerente de produto.
Nota: O protótipo do produto é usado principalmente para demonstrar a função do projeto, não o efeito da página final.
Na pasta de protótipo de produto da pasta "data", são fornecidos dois protótipos de produto.
1) O terminal de gestão
é utilizado por funcionários internos de empresas de restauração. As principais funções são:
| módulo | descrever |
|---|---|
| entrar sair | Os funcionários internos devem fazer login antes de acessar o histórico de gerenciamento do sistema |
| gestão de funcionários | Os administradores podem gerenciar as informações dos funcionários em segundo plano do sistema, incluindo consultar, adicionar, editar, desabilitar e outras funções |
| Gerenciamento de categoria | Gerencia e mantém principalmente a classificação dos pratos ou refeições fixas operadas pelo restaurante atual, incluindo funções como consulta, adição, modificação e exclusão |
| Gestão de pratos | Mantenha principalmente as informações do prato em cada categoria, incluindo consultar, adicionar, modificar, excluir, começar a vender, parar de vender, etc. |
| gerenciamento de pacotes | Manter principalmente as informações do pacote no restaurante atual, incluindo consultar, adicionar, modificar, excluir, começar a vender, parar de vender, etc. |
| gerenciamento de pedidos | Manter principalmente as informações do pedido feitas pelo usuário no terminal móvel, incluindo funções como consulta, cancelamento, entrega, conclusão e download do relatório do pedido |
| Estatisticas | Preencha principalmente diversas estatísticas de restaurantes, como volume de negócios, número de usuários, pedidos, etc. |
2) Lado do cliente
As aplicações móveis são fornecidas principalmente para consumidores. As principais funções são:
| módulo | descrever |
|---|---|
| entrar sair | Os usuários precisam fazer login e usar o miniprograma para pedir comida após autorização através do WeChat |
| menu de pedidos | Na interface de pedidos é necessário exibir a categoria de pratos/conjuntos, e carregar as informações dos pratos de acordo com a categoria atualmente selecionada para o usuário consultar e escolher |
| carrinho de compras | Os pratos selecionados pelo usuário serão adicionados ao carrinho de compras do usuário, que inclui principalmente funções como consultar o carrinho de compras, adicionar ao carrinho de compras, excluir o carrinho de compras e limpar o carrinho de compras. |
| é | Após o usuário selecionar os pratos/conjuntos, ele pode liquidar e pagar os pratos no carrinho de compras, e então precisa pagar o pedido |
| informações pessoais | As informações básicas do usuário atual serão exibidas na página central pessoal, o usuário poderá gerenciar o endereço de entrega e também consultar dados históricos do pedido |
Seleção de Tecnologia
1) Camada de usuário
Neste projeto, usaremos H5, Vue.js, ElementUI, apache echarts (exibição de gráfico) e outras tecnologias para construir a página front-end do background de gerenciamento do sistema. Ao construir aplicativos móveis, usaremos miniaplicativos WeChat.
2) Camada de gateway
Nginx é um servidor usado principalmente como servidor Http para implantar recursos estáticos e possui alto desempenho de acesso. Existem duas funções mais importantes no Nginx: proxy reverso e balanceamento de carga.Durante a implantação do projeto, para obter o balanceamento de carga do Tomcat, ele pode ser alcançado por meio do Nginx.
3) Camada de aplicação
SpringBoot: Construa projetos Spring rapidamente, adote a ideia de "convenção é melhor que configuração" e simplifique a configuração e o desenvolvimento de projetos Spring.
SpringMVC: SpringMVC é um módulo da estrutura Spring, Springmvc e Spring não precisam ser integrados por meio de uma camada de integração intermediária e podem ser integrados perfeitamente.
Tarefa Spring: Estrutura de tarefas de temporização fornecida pelo Spring.
httpclient: Realiza principalmente o envio de solicitações http.
Spring Cache: uma estrutura de cache de dados fornecida pelo Spring
JWT: um token usado para autenticar usuários em um aplicativo.
Alibaba Cloud OSS: serviço de armazenamento de objetos, que armazena principalmente arquivos, como imagens, no projeto.
Swagger: pode ajudar automaticamente os desenvolvedores a gerar documentos de interface e testar as interfaces.
POI: encapsula operações comuns em tabelas do Excel.
WebSocket: Protocolo de rede de comunicação que simplifica a troca de dados entre o cliente e o servidor, e é utilizado para realizar as funções de recebimento de pedidos e lembrete do projeto.
4) Camada de dados
MySQL: Banco de dados relacional, os principais dados de negócios deste projeto serão armazenados em MySQL.
Redis: Um banco de dados na memória baseado em armazenamento em formato de valor-chave, com alta velocidade de acesso e frequentemente usado como cache.
Mybatis: A camada de persistência deste projeto será desenvolvida usando Mybatis.
pagehelper: plugin de paginação.
spring data redis: API que simplifica o código java para operar o Redis.
5) Ferramenta
git: ferramenta de controle de versão, em colaboração em equipe, utilize esta ferramenta para gerenciar o código do projeto.
maven: ferramenta de construção de projeto.
junit: uma ferramenta de teste de unidade. Depois que as funções do desenvolvedor são implementadas, ele precisa testar a unidade das funções por meio do junit.
carteiro: Uma ferramenta de teste de interface que simula várias solicitações HTTP iniciadas por usuários e obtém resultados de resposta correspondentes.
Construa o ambiente de desenvolvimento
Construção de ambiente front-end
- Engenharia front-end baseada em nginx
Em "Informações":
será 
colocado em uma pasta sem chinês no endereço do diretório, chamada "CangqiongTakeout"
Certifique-se de colocar esta pasta no diretório com caracteres chineses, caso contrário a inicialização não será bem-sucedida
- Inicie o nginx, teste de acesso
Clique duas vezes nginx.exeno serviço Qidong nginx, o número da porta de acesso é 80
http://localhost:80
Se a inicialização for bem-sucedida, a interface será a seguinte:
Construção de ambiente back-end
Familiarizado com a estrutura do projeto
O projeto back-end é baseado em maven para criação de projetos e desenvolvimento de submódulos
- Encontre o projeto inicial de back-end em "Dados"
- Copie o projeto inicial para o diretório "CangqiongTakeout" recém-criado
Abra o projeto inicial com IDEA para entender a estrutura do projeto
Caso o projeto não possua .imlarquivo gerado, será necessário realizar as seguintes configurações:
- Abra o terminal em ideia neste projeto
- .Insira o módulo correspondente, insira o comando mvn idea:module e pressione Enter
- Após BUILD SUCCESS, você pode ver que o arquivo .iml é gerado no módulo correspondente
Após a configuração, a estrutura inicial do projeto é a seguinte
Descrição da função de cada módulo do projeto:
| número de série | nome | ilustrar |
|---|---|---|
| 1 | retirada do céu | Projeto pai Maven, gerenciamento unificado de versões de dependência, agregação de outros submódulos |
| 2 | céu-comum | Submódulo, armazenando classes públicas, como classes de ferramentas, classes constantes, classes de exceção, etc. |
| 3 | céu-pojo | Submódulo, armazenando classes de entidade, VO, DTO, etc. |
| 4 | servidor sky | Submódulos, serviços de back-end, arquivos de configuração de armazenamento, controlador, serviço, mapeador, etc. |
Depois de compreender a estrutura geral do projeto, cada um dos submódulos acima será analisado detalhadamente:
-
sky-common: 模块中存放的是一些公共类，可以供其他模块使用 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BAv4c5lv-1690964505677)(assets/image-20221107093606590.png#id=cHOSd&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)]
| 名称 | 说明 |
| — | — |
| constant | 存放相关常量类 |
| context | 存放上下文类 |
| enumeration | 项目的枚举类存储 |
| exception | 存放自定义异常类 |
| json | 处理json转换的类 |
| properties | 存放SpringBoot相关的配置属性类 |
| result | 返回结果类的封装 |
| utils | 常用工具类 | -
sky-pojo: 模块中存放的是一些 entity、DTO、VO [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bCSk9iUm-1690964505677)(assets/image-20221107094611987.png#id=UKsvk&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)]
| 名称 | 说明 |
| — | — |
| Entity | 实体，通常和数据库中的表对应 |
| DTO | 数据传输对象，通常用于程序中各层之间传递数据 |
| VO | 视图对象，为前端展示数据提供的对象 |
| POJO | 普通Java对象，只有属性和对应的getter和setter | -
sky-server: 模块中存放的是 配置文件、配置类、拦截器、controller、service、mapper、启动类等 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dV8g7ErE-1690964505677)(assets/image-20221107094852361.png#id=z1ASu&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)]
| 名称 | 说明 |
| — | — |
| config | 存放配置类 |
| controller | 存放controller类 |
| interceptor | 存放拦截器类 |
| mapper | 存放mapper接口 |
| service | 存放service类 |
| SkyApplication | 启动类 |
git版本控制
使用Git进行项目代码的版本控制，具体操作：
- 创建git仓库
当IDEA中出现
时创建成功
- 创建git远程仓库
登录链接gitee.com,新建仓库
点击“创建”后如下图：
- 提交文件至本地仓库
开始提交：
点击此处
- 添加至git远程仓库
- 复制远程地址
- 点击此处
推送完成
刷新gitee页面:
数据库环境搭建
将数据库中sky.sql文件导入MySQL，间脚本代码复制到MySQL运行即可
创建出11张表
修改idea后端代码 的数据库 的配置信息
前后端联调
后端的初始工程中已经实现了登录功能，直接进行前后端联调测试即可
意思就是，在后端已经有了登录功能的代码了，前端也有了页面实现的代码了，现在需要将前后端联结起来
首先，先编译一下，能够保证项目能够正常运行
登录一下：
双击nginx.exeqidong nginx服务，访问端口号为80
http://localhost:80
要保证前面数据库idea中将相关配置信息根据实际情况配制成自己数据库的信息
点击登录：
右上角的“错误”先不用管，后面会解决
nginx反向代理和负载均衡
对登录功能测试完毕后，接下来，思考一个问题：前端发送的请求，是如何请求到后端服务的？
在使用Nginx作为反向代理的Java项目中，前端发送的请求会被Nginx接收并处理，然后转发给后端服务。以下是一些基本步骤：
- 客户端（前端）发送请求到Nginx服务器。
- Nginx服务器接收请求，并根据配置的规则进行处理。
- Nginx根据配置的规则将请求转发给后端服务。
- 后端服务接收到请求并处理，然后返回响应。
- Nginx接收后端服务的响应，并将其返回给客户端。
在这个过程中，Nginx扮演了反向代理的角色，接收客户端的请求并转发给后端服务，同时也将后端服务的响应返回给客户端。通过Nginx，可以实现对请求的负载均衡、缓存、安全过滤等处理，提高系统的性能和安全性。
当你在浏览器中输入一个网站地址并发送请求时，这个请求首先会被Nginx服务器接收。Nginx服务器会根据你发送的请求类型、请求头、参数等来进行处理，然后决定将请求转发给哪个后端服务。这个后端服务可以是应用程序服务器、数据库服务器或其他类型的服务。
一旦后端服务接收到请求并处理完成，它会将响应返回给Nginx服务器。Nginx服务器再将这些响应返回给你所在的浏览器。在这个过程中，Nginx还可以对请求和响应进行一些处理，例如提供缓存功能、防止DDoS攻击、拦截恶意请求等，从而提高系统的性能和安全性。
在实际情况中，前端请求地址和后端接口地址通常是不一致的，这是因为前端通常只需要知道如何将请求发送到后端，而不需要知道后端的具体实现细节，包括端口、上下文路径等。
在nginx服务器中，可以通过配置反向代理来实现前后端请求的映射。具体来说，可以在nginx配置文件中添加以下配置：
location /api {
proxy_pass http://localhost:8080/admin;
}
这样，当有请求发送到nginx服务器的/api路径时，nginx会将请求转发到后端服务器的/admin路径。
在SpringBoot项目中，也可以使用Spring Cloud Gateway等反向代理框架来实现前后端请求的映射。例如，可以配置Spring Cloud Gateway的路由规则，将/api/_路由到后端服务器的/admin/_路径。
总之，无论使用nginx还是Spring Cloud Gateway等反向代理框架，都可以实现前后端请求的映射，使得前端请求能够正确地请求到后端服务。
导入接口文档
接下来，就要进入到项目的业务开发了，而我们的开发方式就是基于当前企业主流的前后端分离开发方式，那么这种方式就要求我们之前需要先将接口定义好，这样前后端人员才能并行开发，所以，这个章节就需要将接口文档导入到管理平台，为我们后面业务开发做好准备。其实，在真实的企业开发中，接口设计过程其实是一个非常漫长的过程，可能需要多次开会讨论调整，甚至在开发的过程中才会发现某些接口定义还需要再调整，这种情况其实是非常常见的，但是由于项目时间原因，所以选择一次性导入所有的接口，在开发业务功能过程当中，也会带着大家一起来分析一下对应的接口是怎么确定下来的，为什么要这样定义，从而培养同学们的接口设计能力。
前后端分离开发流程
第一步：定义接口，确定接口的路径、请求方式、传入参数、返回参数。
第二步：前端开发人员和后端开发人员并行开发，同时，也可自测。
第三步：前后端人员进行连调测试。
第四步：提交给测试人员进行最终测试
操作步骤
- 找到“资料”中的接口文件
- 导入到Yapi平台
登录Yapi
两个操作步骤相同
Swagger
介绍
Swagger 是一个规范和完整的框架，用于生成、描述、调用和可视化 RESTful 风格的 Web 服务(https://swagger.io/)。 它的主要作用是：
- 使得前后端分离开发更加方便，有利于团队协作
- 接口的文档在线自动生成，降低后端开发人员编写接口文档的负担
- 功能测试
Spring已经将Swagger纳入自身的标准，建立了Spring-swagger项目，现在叫Springfox。通过在项目中引入Springfox ，即可非常简单快捷的使用Swagger。
knife4j是为Java MVC框架集成Swagger生成Api文档的增强解决方案,前身是swagger-bootstrap-ui,取名kni4j是希望它能像一把匕首一样小巧,轻量,并且功能强悍!
目前，一般都使用knife4j框架。
使用步骤
- 导入 knife4j 的maven坐标
在pom.xml中添加依赖
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>knife4j-spring-boot-starter</artifactId>
</dependency>
- 在配置类中加入 knife4j 相关配置
WebMvcConfiguration.java
/**
* 通过knife4j生成接口文档
* @return
*/
@Bean
public Docket docket() {
ApiInfo apiInfo = new ApiInfoBuilder()
.title("苍穹外卖项目接口文档")
.version("2.0")
.description("苍穹外卖项目接口文档")
.build();
Docket docket = new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo)
.select()
.apis(RequestHandlerSelectors.basePackage("com.sky.controller"))
.paths(PathSelectors.any())
.build();
return docket;
}
- 设置静态资源映射，否则接口文档页面无法访问
WebMvcConfiguration.java
/**
* 设置静态资源映射
* @param registry
*/
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
}
- 访问测试
接口文档访问路径为 http://ip:port/doc.html —> http://localhost:8080/doc.html
**思考：**通过 Swagger 就可以生成接口文档，那么我们就不需要 Yapi 了？
1、Yapi 是设计阶段使用的工具，管理和维护接口
2、Swagger 在开发阶段使用的框架，帮助后端开发人员做后端的接口测试
常用注解
通过注解可以控制生成的接口文档，使接口文档拥有更好的可读性，常用注解如下：
| 注解 | 说明 |
|---|---|
| @Api | 用在类上，例如Controller，表示对类的说明 |
| @ApiModel | 用在类上，例如entity、DTO、VO |
| @ApiModelProperty | 用在属性上，描述属性信息 |
| @ApiOperation | 用在方法上，例如Controller的方法，说明方法的用途、作用 |
Em seguida, use as anotações acima para modificar o código original da seguinte forma: Gere um documento de interface mais legível em EmployeeLoginDTO.java
no módulo sky-pojo
package com.sky.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
@Data
@ApiModel(description = "员工登录时传递的数据模型")
public class EmployeeLoginDTO implements Serializable {
@ApiModelProperty("用户名")
private String username;
@ApiModelProperty("密码")
private String password;
}
FuncionárioLoginVo.java
package com.sky.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(description = "员工登录返回的数据格式")
public class EmployeeLoginVO implements Serializable {
@ApiModelProperty("主键值")
private Long id;
@ApiModelProperty("用户名")
private String userName;
@ApiModelProperty("姓名")
private String name;
@ApiModelProperty("jwt令牌")
private String token;
}
No módulo sky-server
EmployeeController.java
package com.sky.controller.admin;
import com.sky.constant.JwtClaimsConstant;
import com.sky.dto.EmployeeLoginDTO;
import com.sky.entity.Employee;
import com.sky.properties.JwtProperties;
import com.sky.result.Result;
import com.sky.service.EmployeeService;
import com.sky.utils.JwtUtil;
import com.sky.vo.EmployeeLoginVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
/**
* 员工管理
*/
@RestController
@RequestMapping("/admin/employee")
@Slf4j
@Api(tags = "员工相关接口")
public class EmployeeController {
@Autowired
private EmployeeService employeeService;
@Autowired
private JwtProperties jwtProperties;
/**
* 登录
*
* @param employeeLoginDTO
* @return
*/
@PostMapping("/login")
@ApiOperation(value = "员工登录")
public Result<EmployeeLoginVO> login(@RequestBody EmployeeLoginDTO employeeLoginDTO) {
//..............
}
/**
* 退出
*
* @return
*/
@PostMapping("/logout")
@ApiOperation("员工退出")
public Result<String> logout() {
return Result.success();
}
}
Inicie o serviço: visite http://localhost:8080/doc.html
uma hora duas horas
- Este projeto começou como o chamado "projeto inicial" dos programadores azarões importados diretamente
- É realizar a estrutura, dependências, configuração, etc.
- Siga o processo do tutorial em vídeo para concluir este projeto primeiro
- Alguns lugares podem não ser adequados para mastigar e compreender, mas engolir
- Talvez quando todo o projeto estiver concluído, algumas partes serão compreendidas naturalmente
- Pode haver alguns lugares que eu não entendo depois de concluir este projeto, mas entenderei depois de concluí-lo
- Parar na conclusão de um projeto ou em uma determinada etapa de um projeto
- Veja se você consegue mastigar o que engoliu inteiro agora