Rede de Computadores: Design em Camadas da Estrutura HTML

计算机网络中的OSI七层模型

计算机网络中的OSI（Open Systems Interconnection）七层模型É um referencial teórico para descrever o processo de comunicação de dados em redes de computadores. O modelo OSI 计算机网络通信divide o processo em sete níveis, e cada nível tem suas funções e protocolos específicos. Essa estrutura em camadas é útil para pesquisa e compreensão em redes de computadores 通信原理. A seguir estão as várias camadas do modelo OSI de sete camadas e suas principais funções:

应用层É a sétima camada do modelo OSI e também é a interface entre 网络应用程序e . 网络协议A camada de aplicativo é responsável principalmente por fornecer aos usuários vários serviços de aplicativo, como transferência de arquivos, e-mail e navegação na Web.

表示层É a sexta camada do modelo OSI, que é a principal responsável por processar a representação dos dados transmitidos na rede, como data 加密、解密、压缩、解压缩. A camada de apresentação garante a comunicação entre diferentes sistemas 数据兼容性.

会话层É a quinta camada do modelo OSI e é a principal responsável por estabelecer, manter e encerrar as sessões de comunicação entre as aplicações. A camada de sessão fornece mecanismos de sincronização e confirmação para troca de dados.

传输层É a quarta camada do modelo OSI, responsável principalmente por fornecer serviços confiáveis ​​de transmissão de dados de ponta a ponta entre o host de origem e o host de destino. A camada de transporte alcança transmissão de dados confiável segmentando, encapsulando e remontando os dados. Os protocolos comuns da camada de transporte incluem TCP（传输控制协议）e UDP（用户数据报协议）.

网络层É a terceira camada do modelo OSI, responsável principalmente pelo 数据包从源主机路envio de hosts ao host de destino. A camada de rede é a principal responsável 逻辑寻址、路由选择和分组转发. Os protocolos comuns da camada de rede incluem IP（互联网协议）e ICMP（互联网控制报文协议）.

数据链路层É a segunda camada do modelo OSI, responsável principalmente por encapsular os pacotes de dados da camada de rede em quadros e transmiti-los na mesma LAN. A camada de enlace de dados é responsável principalmente pelo endereçamento físico, enquadramento de dados, detecção de erros e controle de fluxo. Os protocolos comuns da camada de enlace de dados incluem 以太网（Ethernet）、令牌环（Token Ring）和无线局域网（Wi-Fi）etc.

物理层É a primeira camada do modelo OSI e é a principal responsável pela transmissão transparente de fluxos de bits em mídia física. A camada física concentra-se principalmente em questões como interfaces de hardware, características elétricas, fibras ópticas e transmissão sem fio.

O modelo OSI de sete camadas fornece uma estrutura geral para ajudar a estudar e entender os princípios de comunicação em redes de computadores. Em aplicações práticas, costumamos usar TCP/IP四层模型, inclui 应用层、传输层、网络层和链路层, e tem certa correspondência com o modelo OSI.

A necessidade de um framework HTML

HTML框架A principal razão para o design em camadas é melhorar a legibilidade, manutenção e reutilização do código. As camadas HTML框架podem melhorar a estrutura e a lógica do projeto geral, tornando mais fácil para os desenvolvedores entender e modificar melhor o código. Um design em camadas tem as seguintes vantagens:

1. Melhorar a legibilidade: dividindo o quadro HTML em diferentes camadas, a estrutura do código pode ficar mais clara, o que ajuda os desenvolvedores a entender rapidamente a função do código.
2. Facilidade de manutenção: O design em camadas ajuda a modularizar as funções, para que um módulo possa ser facilmente modificado ou substituído sem afetar outras partes do código. Isso ajuda a melhorar a capacidade de manutenção do projeto.
3. Reutilização: a camada da estrutura HTML pode extrair partes comuns em componentes reutilizáveis, para que esses componentes possam ser reutilizados em diferentes projetos e melhorar a eficiência do desenvolvimento.
4. Adaptabilidade: o design em camadas pode facilitar a adaptação da estrutura HTML a diferentes dispositivos e tamanhos de tela, melhorando a compatibilidade do projeto.
5. Facilidade de colaboração: em grandes projetos, geralmente há vários desenvolvedores envolvidos. Por meio do design em camadas, os desenvolvedores podem se concentrar em seus próprios módulos, reduzindo conflitos de código e custos de comunicação.

HTML框架的组成

A estrutura HTML inclui Application层``middleware层``route层``codec层``transport层 Application层A camada de aplicativo geralmente inclui código relacionado à lógica de negócios, como o controlador (Controller), exibição (View) e modelo (Model) de um aplicativo da web. A principal função da camada de aplicação é processar as solicitações do usuário e retornar as respostas correspondentes.

Middleware层A camada de middleware é uma camada entre a camada de aplicação e o framework subjacente, responsável por lidar com algumas funções comuns, como autenticação, autorização, caching, logging, etc. A camada de middleware ajuda a separar a lógica de negócios das funções comuns, tornando a camada de aplicativo mais concisa e fácil de manter.

Route层A camada de roteamento é responsável por processar URLs e métodos HTTP (como GET, POST, etc.) de solicitações HTTP e despachar solicitações para controladores e métodos correspondentes. A principal função da camada de roteamento é localizar códigos de função específicos de acordo com o mapeamento de URL.

Codec层A camada codec é responsável por codificar e decodificar dados. No desenvolvimento da Web, a codificação e a decodificação geralmente envolvem o processamento de tecnologias front-end, como HTML, CSS e JavaScript, bem como o processamento de formatos de troca de dados, como JSON e XML. A principal função da camada de codec é converter dados em um formato específico para transmissão e processamento entre diferentes camadas.

Transport层A camada de transporte é responsável por lidar com a comunicação de rede subjacente, como o uso de protocolos como TCP e UDP. No desenvolvimento web, a camada de transporte geralmente envolve o processamento do protocolo HTTP, incluindo a criação, envio e recebimento de solicitações e respostas. O principal papel da camada de transporte é garantir a transmissão confiável de dados e o roteamento correto na rede.

Essas camadas podem variar em diferentes frameworks e cenários em aplicações reais. No entanto, a julgar pela descrição que você forneceu, eles são respectivamente responsáveis ​​por lidar com diferentes funções no aplicativo da Web e, juntos, constituem uma estrutura completa de desenvolvimento da Web.

HTML框架和服务端客户端之间的通信对比

Application层design da camada de aplicação

O design da camada de aplicação é principalmente para definir vários tipos 接口de 路由uso.

Por exemplo, no grande projeto na versão avançada do byte backend 注册接口.

/douyin/user/register/ - interface de registro do usuário

Quando um novo usuário se registrar, basta fornecer um nome de usuário, senha e apelido, e o nome de usuário precisa ser exclusivo. Retorna o ID do usuário e o token de permissão após a criação ser bem-sucedida.

Tipo de interface

PUBLICAR

Definição de interface

go
复制代码
syntax = "proto2";
package douyin.core;

message douyin_user_register_request {
  required string username = 1; // 注册用户名，最长32个字符
  required string password = 2; // 密码，最长32个字符
}

message douyin_user_register_response {
  required int32 status_code = 1; // 状态码，0-成功，其他值-失败
  optional string status_msg = 2; // 返回状态描述
  required int64 user_id = 3; // 用户id
  required string token = 4; // 用户鉴权token
}

go
复制代码
func Register(username, password string) (id int64, token int64, err error) {
   if len(username) > 32 {
      return 0, 0, errors.New("用户名过长，不可超过32位")
   }
   if len(password) > 32 {
      return 0, 0, errors.New("密码过长，不可超过32位")
   }
   // 先查布隆过滤器，不存在直接返回错误，降低数据库的压力
   if userNameFilter.TestString(username) {
      return 0, 0, errors.New("用户名已经存在！")
   }
   //雪花算法生成token
   node, err := snowflake.NewNode(1) //这里的userIdInt64就是 User.Id(主键)
   if err != nil {
      log.Println("雪花算法生成id错误!")
      log.Println(err)
   }
   token1 := node.Generate().Int64()
   tokenStr := strconv.FormatInt(token1, 10)
   user := domain.User{}
   // 再查缓存
   data, err := dao.RedisClient.Get(context.Background(), tokenStr).Result()
   if err == redis.Nil {
      fmt.Println("token does not exist")
   } else if err != nil {
      fmt.Println("Error:", err)
   } else {
      num, err := strconv.ParseInt(data, 10, 64)
      if err != nil {
         fmt.Println("Error:", err)
         return num, 0, err
      }

      return num, token1, nil
   }
   //在查数据库
   user = domain.User{}
   dao.DB.Model(&domain.User{}).Where("name = ?", username).Find(&user)
   if user.Id != 0 {
      return 0, 0, errors.New("用户已存在")
   }
   user.Name = username
   // 加密存储用户密码
   user.Salt = randSalt()
   buf := bytes.Buffer{}
   buf.WriteString(username)
   buf.WriteString(password)
   buf.WriteString(user.Salt)
   pwd, err1 := bcrypt.GenerateFromPassword(buf.Bytes(), bcrypt.MinCost)
   if err1 != nil {
      return 0, 0, err
   }
   user.Pwd = string(pwd)

   //存在mysql里边
   dao.DB.Model(&domain.User{}).Create(&user)
   //再把用户id作为键 用户的所有信息作为值存在其中
   //用户信息的缓存是 保存在redis中 一个以id为键 user json为值
   jsonuser, err1 := MarshalUser(user)
   if err1 != nil {
      fmt.Println("err1", err1)
      return 0, 0, err1
   }
   err = dao.RedisClient.Set(context.Background(), strconv.FormatInt(user.Id, 10), jsonuser, 0).Err()
   if err != nil {
      fmt.Println("err", err)
      return 0, 0, err
   }
   // 布隆过滤器中加入新用户
   userIdFilter.AddString(strconv.FormatInt(user.Id, 10))
   userNameFilter.AddString(username)
   return user.Id, token1, nil
}

A função de registro dessa interface é implementada: armazenar todas as informações no mysql, claro que o redis também tem essas informações e, claro, o nome de usuário também existe no filtro Bouillon, quando recebermos o nome de usuário do usuário, primeiro verificaremos se é no filtro Bouillon Se existir, retornará diretamente err, se não existir, então consulte no redis, porque o redis é mais leve que o mysql, então precisamos verificar no redis primeiro, e se não puder ser encontrei, depois verifique no mysql , não estou encontrando, indicando que não tenho cadastro, pode se cadastrar.

命名规范

Siga os princípios das convenções de nomenclatura.

Middleware层中间件

O middleware no framework gin é dividido em middleware global e middleware local. Então, o que é middleware? Middleware é um software que fornece serviços e funcionalidades comuns aos aplicativos. Gerenciamento de dados, serviço de aplicativos, mensagens, autenticação e gerenciamento de API geralmente passam por middleware. Na estrutura do gin, todas as nossas interfaces de API devem passar por nosso middleware e podemos fazer algum processamento de interceptação no middleware.

Modelos Comuns de Middleware

middleware global

Isso é registrado quando o serviço é iniciado e global significa que todas as interfaces da API passarão por aqui. O middleware do Gin é Useconfigurado através de um método, que recebe um parâmetro variável, para que possamos configurar vários middlewares ao mesmo tempo.

Primeiro defina da seguinte forma

go
复制代码
// 1.创建路由
r := gin.Default()  //默认带Logger(), Recovery()这两个内置中间件
r:= gin.New()      //不带任何中间件
// 注册中间件  
r.Use(MiddleWare())
r.Use(MiddleWare2())

Esteja ciente de

gin.Default()LoggerPor padrão, são usados ​​middlewares Recovery, entre os quais: O middleware Logger grava logs gin.DefaultWritermesmo se GIN_MODE=release estiver configurado. O middleware de recuperação fará recoverqualquer coisa panic. Se houver pânico, um código de resposta 500 será gravado. Se você não quiser usar os dois middlewares padrão acima, você pode criar gin.New()uma nova rota sem nenhum middleware padrão.

go
复制代码
// 定义中间
func MiddleWare() gin.HandlerFunc {
    return func(c *gin.Context) {
        t := time.Now()
        fmt.Println("中间件开始执行了")
        // 设置变量到Context的key中，可以通过Get()取
        c.Set("request", "这是中间件设置的值")
        status := c.Writer.Status()
        fmt.Println("中间件执行完毕", status)        
        t2 := time.Since(t)
        fmt.Println("time:", t2)
    }
}

Em seguida, inicie nosso serviço e acesse qualquer interface para ver a saída da seguinte maneira

Essa é a solicitação que chega primeiro ao middleware e depois chega à nossa interface de API. No middleware, você pode definir a variável para a chave do Context e, em seguida, obter o valor em nossa interface API.

go
复制代码
        r.GET("/", func(c *gin.Context) {
            // 取值
            req, _ := c.Get("request")
            fmt.Println("request:", req)
            // 页面接收
            c.JSON(200, gin.H{"request": req})
        })

Neste momento, você pode ver que o valor definido pelo middleware é

nextO método é usado no middleware, o que 后续中间件significa executar o processamento da solicitação (incluindo o middleware não executado e o processamento do método GET que definimos, se vários middlewares forem cadastrados continuamente, eles serão executados na ordem do primeiro a entrar, o último a sair. next就去执行下一个中间件里的next前面方法.

go
复制代码
        // 执行函数
        c.Next()
        // 中间件执行完后续的一些事情

middleware parcial

Middleware parcial significa que algumas interfaces terão efeito e serão usadas apenas localmente. Neste momento, visite http:127.0.0.1:8000/ para ver a impressão de log do middleware, e outras interfaces de API não aparecerão.

go
复制代码
   //局部中间件使用
    r.GET("/", MiddleWare(), func(c *gin.Context) {
        // 取值
        req, _ := c.Get("request")
        fmt.Println("request:", req)
        // 页面接收
        c.JSON(200, gin.H{"request": req})
    })

gin middleware embutido

go
复制代码

func BasicAuth(accounts Accounts) HandlerFunc

func BasicAuthForRealm(accounts Accounts, realm string) HandlerFunc

func Bind(val interface{}) HandlerFunc

func ErrorLogger() HandlerFunc

func ErrorLoggerT(typ ErrorType) HandlerFunc

func Logger() HandlerFunc

func LoggerWithConfig(conf LoggerConfig) HandlerFunc

func LoggerWithFormatter(f LogFormatter) HandlerFunc

func LoggerWithWriter(out io.Writer, notlogged ...string) HandlerFunc

func Recovery() HandlerFunc

func RecoveryWithWriter(out io.Writer) HandlerFunc

func WrapF(f http.HandlerFunc) HandlerFunc

func WrapH(h http.Handler) HandlerFunc

Resumir

Por meio de um middleware personalizado, podemos facilmente interceptar solicitações para fazer algumas coisas que precisamos fazer, como registro, verificação de autorização, vários filtros e assim por diante.

Digressão

Neste primeiro ano de tecnologia em rápido crescimento, a programação é como uma passagem para um mundo de infinitas possibilidades para muitas pessoas. Na linha de estrelas das linguagens de programação, o Python é como a superestrela líder. Com sua sintaxe concisa e fácil de entender e funções poderosas, ele se destaca e se torna uma das linguagens de programação mais populares do mundo.

A rápida ascensão do Python é extremamente benéfica para toda a indústria , mas " 人红是非多" fez com que ele adicionasse muitas críticas, mas ainda não pode parar seu ímpeto de desenvolvimento quente.

O Python permanecerá relevante e intacto pelo resto da próxima década? Hoje, vamos analisar os fatos e desfazer alguns equívocos.

Se você está interessado em Python e deseja obter um salário mais alto aprendendo Python, o seguinte conjunto de materiais de aprendizado de Python deve ser útil para você!

Os materiais incluem: pacote de instalação Python + código de ativação, desenvolvimento web Python, rastreador Python, análise de dados Python, inteligência artificial, aprendizado de máquina e outros tutoriais de aprendizado. Mesmo iniciantes com 0 básico podem entender e entender. Siga o tutorial e leve você a aprender Python sistematicamente do zero básico!
​

1. Rotas de aprendizado em todas as direções do Python

A rota de todas as direções no Python é organizar os pontos técnicos comumente usados ​​do Python para formar um resumo dos pontos de conhecimento em vários campos. Sua utilidade reside no fato de que você pode encontrar recursos de aprendizado correspondentes de acordo com os pontos de conhecimento acima para garantir que você aprenda de forma mais abrangente.

2. Software de aprendizagem Python

Se um trabalhador quer fazer um bom trabalho, ele deve primeiro afiar suas ferramentas. O software de desenvolvimento comumente usado para aprender Python está aqui!

3. Vídeo de aprendizado introdutório ao Python

Há também muitos vídeos de aprendizado adequados para começar com o básico 0. Com esses vídeos, você pode começar facilmente com o Python~

4. Exercícios de Python

Após cada videoaula, há questões práticas correspondentes, você pode testar os resultados do aprendizado haha!

Cinco, caso de combate real do Python

A teoria óptica é inútil. Você tem que aprender a codificar junto com ela e fazer você mesmo, para que possa aplicar o que aprendeu na prática. Neste momento, você pode aprender com alguns casos práticos. Esta informação também está incluída~

6. Materiais de entrevista do Python

Depois de aprendermos Python, podemos sair e encontrar um emprego com as habilidades! As perguntas da entrevista a seguir são todas de empresas de Internet de primeira linha, como Alibaba, Tencent e Byte, e há respostas confiáveis ​​dos chefes da Ali. Depois de ler este conjunto de materiais de entrevista, acredito que todos podem encontrar um emprego satisfatório.


7. Coleta de informações

A versão completa mencionada acima do conjunto completo de materiais de aprendizado do Python foi carregada no CSDN oficial, e os pequenos parceiros que precisam dele podem escanear o código QR da certificação oficial do CSDN abaixo no WeChat para obtê-lo gratuitamente
​