Introdução
Um mod de API é uma modificação de um aplicativo de software que usa uma interface de programação de aplicativo (API) para interagir com outros aplicativos ou serviços. Os mods de API podem aprimorar a funcionalidade, o desempenho ou a experiência do usuário de um aplicativo adicionando novos recursos, integrando-se a fontes de dados externas ou personalizando a interface.
api mod
Neste artigo, guiarei você pelas etapas de criação de um mod de API para um aplicativo da Web usando a API do Fabric, que é uma biblioteca central para os ganchos mais comuns e medidas de intercompatibilidade utilizadas pelos mods usando a cadeia de ferramentas do Fabric[^1]. As APIs do Fabric são leves e modulares, tornando a portabilidade mais rápida e as instâncias do jogo mais enxutas[^1]. O desenvolvimento do Fabric tem como alvo instantâneos, bem como versões de lançamento, permitindo atualizações de mod anteriores e planejamento da comunidade mais informado[^1]. A cadeia de ferramentas do Fabric está disponível para uso de todos - mesmo que você queira usar apenas parte dela[^1].
O aplicativo da web que modificaremos é um aplicativo meteorológico simples que exibe a temperatura atual e as condições meteorológicas de um determinado local. Usaremos a API do Fabric para adicionar um novo recurso que permite aos usuários gerar códigos QR para informações meteorológicas, que podem ser digitalizados com seus dispositivos móveis ou compartilhados com outras pessoas.
Pré-requisitos
Para criar um mod de API usando a API do Fabric, você precisará das seguintes ferramentas e bibliotecas:
Ir: Esta é a linguagem de programação que usaremos para escrever nosso mod. Você pode baixar e instalar o Go em .
API de malha: esta é a biblioteca principal que fornece os ganchos e as medidas de intercompatibilidade para mods usando a cadeia de ferramentas Fabric. Você pode baixar e instalar a API do Fabric em .
Gin: Este é um framework web que facilita a criação de manipuladores e rotas HTTP para nosso mod. Você pode baixar e instalar o Gin usando o comando vá buscar -u github.com/gin-gonic/gin.
APXS: Esta é uma ferramenta que nos permite compilar e instalar nosso mod como um objeto dinâmico compartilhado (DSO) no servidor web. Você pode baixar e instalar o APXS de .
API de código QR: Este é um serviço externo que usaremos para gerar códigos QR a partir dos dados meteorológicos. Você pode usar qualquer serviço de API de código QR de sua preferência, mas, para este exemplo, usaremos , que é gratuito e fácil de usar.
servidor web: é aqui que hospedaremos nosso aplicativo da web e nosso mod. Você pode usar qualquer servidor da Web que suporte módulos DSO, mas, para este exemplo, usaremos o Apache HTTP Server, que você pode baixar e instalar em .
navegador da web: É aqui que testaremos nosso mod e veremos os resultados. Você pode usar qualquer navegador da Web compatível com leitura de código QR, mas, neste exemplo, usaremos o Google Chrome, que você pode baixar e instalar em .
Crie uma pasta para o seu código
O primeiro passo é criar uma pasta para o seu código. É aqui que você armazenará seus arquivos de origem e dependências para seu mod. Você pode nomear a pasta como quiser, mas para este exemplo, vamos nomeá-la mod de tempo. Para criar a pasta, abra uma janela de terminal e navegue até o diretório onde deseja criar a pasta. Em seguida, execute o comando mkdir weather-mod. Isso criará uma nova pasta chamada mod de tempo em seu diretório atual. Para entrar na pasta, execute o comando cd weather-mod. Isso mudará seu diretório atual para mod de tempo.
Crie um módulo para o seu mod
O próximo passo é criar um módulo para o seu mod. Um módulo é uma coleção de pacotes Go que possuem um prefixo comum em seus caminhos de importação. Um arquivo de módulo é um arquivo chamado go.mod que define o caminho, a versão e as dependências do módulo. Para criar um arquivo de módulo, execute o comando go mod init weather-mod. Isso criará um novo arquivo chamado go.mod em seu diretório atual com o seguinte conteúdo:
módulo weather-mod go 1.16
A primeira linha especifica o caminho do módulo, que é o prefixo do caminho de importação para todos os pacotes no módulo. A segunda linha especifica a versão Go usada pelo módulo. Você pode editar essas linhas conforme necessário, mas, para este exemplo, vamos mantê-las como estão.
Para adicionar dependências ao seu módulo, você precisa especificá-las no exigir seção do arquivo do módulo. Para este exemplo, precisaremos adicionar duas dependências: Fabric API e Gin. Para adicionar a API do Fabric, execute o comando acesse github.com/FabricMC/fabric@v0.40.8+build.418-1.16. Isso fará o download e instalará a API do Fabric com a tag de versão v0.40.8+build.418-1.16, que é compatível com Minecraft 1.16. Para adicionar Gin, execute o comando acesse github.com/gin-gonic/gin@v1.7.4. Isso fará o download e instalará o Gin com a tag de versão v1.7.4, que é a versão estável mais recente no momento da redação deste artigo. Depois de executar esses comandos, seu arquivo de módulo deve se parecer com isto:
módulo weather-mod go 1.16 require ( github.com/FabricMC/fabric v0.40.8+build.418-1.16 github.com/gin-gonic/gin v1.7.4 )
O exigir A seção lista as dependências do seu módulo e suas versões. Você também pode usar o comando vá mod arrumado para adicionar ou remover dependências automaticamente com base em suas importações de código.
Crie os dados para o seu mod
O próximo passo é criar os dados para o seu mod. É aqui que você armazenará todos os dados ou recursos de que seu mod precisa, como imagens, sons ou arquivos de configuração. Para criar uma pasta de dados, execute o comando dados mkdir. Isso criará uma nova pasta chamada dados em seu diretório atual. Para entrar na pasta, execute o comando dados do cd. Isso mudará seu diretório atual para dados.
Para este exemplo, precisaremos armazenar dois arquivos em nossa pasta de dados: um modelo HTML e uma folha de estilo CSS.O modelo HTML é um arquivo que define a estrutura e o conteúdo da página da Web que exibe o código QR. A folha de estilo CSS é um arquivo que define o estilo e a aparência dos elementos da página da web. Para criar esses arquivos, execute os comandos toque em index.html e estilo de toque.css. Isso criará dois arquivos vazios chamados index.html e estilo.css em seu diretório atual.
Para editar esses arquivos, você pode usar qualquer editor de texto de sua preferência, mas, para este exemplo, usaremos o Nano, que é um editor de texto simples e fácil de usar que vem pré-instalado na maioria dos sistemas Linux. Para abrir o Nano, execute o comando nano nome do arquivo, onde nome do arquivo é o nome do arquivo que você deseja editar. Por exemplo, para editar index.html, execute o comando nano index.html. Isso abrirá o Nano com uma tela vazia.
Para escrever o modelo HTML, você precisa usar tags e elementos HTML para definir a estrutura e o conteúdo da página da web. Tags HTML são palavras-chave entre colchetes angulares () que indicam o início e o fim de um elemento. Elementos HTML são pedaços de conteúdo que possuem uma tag inicial, uma tag final e algum texto ou atributos intermediários. Por exemplo, <h1>Hello World</h1> é um elemento HTML que define um título com o texto "Hello World". Você pode aprender mais sobre tags e elementos HTML em .
Para escrever a folha de estilo CSS, você precisa usar regras e propriedades CSS para definir o estilo e a aparência dos elementos da página da web. As regras CSS são instruções que consistem em um seletor e um bloco de declaração. Um seletor é um padrão que corresponde a um ou mais elementos na página da web. Um bloco de declaração é um conjunto de declarações entre chaves (). Uma declaração é um par de uma propriedade e um valor, separados por dois pontos (:). Por exemplo, h1 cor: azul; é uma regra CSS que aplica a propriedade color com o valor blue a todos os elementos h1 na página da web. Você pode aprender mais sobre regras e propriedades CSS em .
Para escrever o modelo HTML e a folha de estilo CSS para nosso mod, você pode usar os seguintes exemplos de código como referência:
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Weather QR Code</title> <link rel="stylesheet" href="style.css"> </head> <body> <div > <h1>Weather QR Code</h1> <p>Scan this QR code to get the weather information for <span id="location"></span></p> <img id="qr-code" src="" alt="QR code"> < /div> <script src=" <script src="script.js"></script> </body> </html>
* box-sizing: border-box; margem: 0; preenchimento: 0; .container largura: 80%; largura máxima: 600px; margem: 0 automático; alinhamento de texto: centro; h1 font-family: Arial, sans-serif; tamanho da fonte: 36px; cor: #333333; margem superior: 20px; p font-family: Arial, sans-serif; tamanho da fonte: 18px; cor: #333333; margem inferior: 20px; #localização peso da fonte: negrito; #qr-code largura: 300px; altura: 300px;
Depois de escrever o código, você pode salvar e sair do Nano pressionando Ctrl+X, Y e Enter. Isso salvará as alterações no arquivo e retornará ao terminal. Para voltar para a pasta pai, execute o comando cd ... Isso mudará seu diretório atual para mod de tempo.
Escreva um manipulador para gerar códigos QR
A próxima etapa é escrever um manipulador para gerar códigos QR a partir dos dados meteorológicos usando um serviço API externo. Um manipulador é uma função que manipula uma solicitação HTTP e retorna uma resposta HTTP. Para escrever um manipulador, usaremos o Gin, que é um framework web que facilita a criação de manipuladores e rotas HTTP para nosso mod.
Para escrever um manipulador usando Gin, precisamos importar o pacote Gin e criar um motor Gin. Um mecanismo Gin é um objeto que fornece métodos e propriedades para criar e gerenciar manipuladores e rotas. Para criar um motor Gin, usamos o gin.Padrão() função, que retorna um novo mecanismo Gin com algumas configurações padrão. Para importar o pacote Gin e criar um motor Gin, podemos usar o seguinte código:
package main import ( "github.com/gin-gonic/gin" ) func main() // Cria um motor Gin r := gin.Default()
Para criar um manipulador usando Gin, precisamos definir uma função de manipulador e registrá-la com uma rota. Uma função de manipulador é uma função que recebe um contexto Gin como parâmetro e não retorna nada.Um contexto Gin é um objeto que fornece métodos e propriedades para acessar e manipular a solicitação e resposta HTTP. Para registrar uma função de manipulador com uma rota, usamos o r.GET() ou r.POST() métodos do mecanismo Gin, que usam um caminho e uma função de manipulador como argumentos. O caminho é uma string que especifica o padrão de URL que corresponde à solicitação. A função do manipulador é a função que manipula a solicitação.
Para escrever uma função de manipulador para gerar códigos QR a partir dos dados meteorológicos, precisamos fazer o seguinte:
Obtenha o parâmetro de localização da string de consulta da solicitação usando o c.Query() método do contexto Gin.
Chame o serviço de API do tempo usando o http.Get() função da biblioteca padrão Go, que usa uma URL como argumento e retorna uma resposta HTTP.
Analise os dados JSON da resposta da API do clima usando o método json.NewDecoder() e Decodificar() funções da biblioteca padrão Go, que usam um io.Reader e um ponteiro para uma estrutura como argumentos e decodificam os dados JSON na estrutura.
Crie um URL de código QR usando o serviço API de código QR e os dados meteorológicos usando concatenação de strings.
Retorne o URL do código QR como uma resposta HTTP usando o c.String() método do contexto Gin, que recebe um código de status e uma string como argumentos e escreve a string como o corpo da resposta.
Para escrever uma função de manipulador para gerar códigos QR a partir dos dados meteorológicos, podemos usar o seguinte exemplo de código como referência:
// Defina um struct para armazenar o tipo de dados meteorológicos Weather struct Temp float64 `json:"temp"` Cond string `json:"condition"` // Defina uma função de manipulador para gerar códigos QR a partir dos dados meteorológicos func generateQRCode(c *gin.Context) // Obtenha o parâmetro de localização da string de consulta location := c.Query("location") // Chame o serviço de API do clima com o parâmetro de localização resp, err := http.Get(" ather.com/v1/current?location=" + location + "&key=YOUR_API_KEY") if err != nil c.String(http.StatusInternalServerError, err.Error()) return defer resp.Body.Close() // Analisa os dados JSON da resposta da API do clima var weather Weather err = json.NewDecoder(resp.Body).Decode(&weather) if err != nil c.String(http.StatusInternalServerError, err.Error()) return // Crie um URL de código QR usando o serviço API de código QR e os dados meteorológicos qrCodeURL := " temperatura em " + location + " é " + fmt.Sprintf("%.1f", weather.Temp) + " graus Celsius e a condição é " + weather.Cond // Retorna o URL do código QR como uma resposta HTTP c.String(http.StatusOK, qrCodeURL)
Para registrar a função do manipulador com uma rota, precisamos usar o r.GET() do mecanismo Gin e passe o caminho e a função do manipulador como argumentos. O caminho é uma string que especifica o padrão de URL que corresponde à solicitação. Para este exemplo, usaremos o caminho "/gerar", o que significa que nossa função de manipulador manipulará qualquer solicitação GET que tenha "/gerar" como seu caminho. Para registrar a função handler com uma rota, podemos usar o seguinte código:
// Registra a função do manipulador com uma rota r.GET("/generate", generateQRCode)
Escreva um manipulador para exibir códigos QR
A próxima etapa é escrever um manipulador para exibir códigos QR na página da Web usando HTML e CSS. Para escrever um manipulador para exibir códigos QR, precisamos fazer o seguinte:
Obtenha o parâmetro de localização da string de consulta da solicitação usando o c.Query() método do contexto Gin.
Ligar para gerar QRCode() função que definimos anteriormente e obtenha o URL do código QR como um valor de retorno.
Renderize um modelo HTML com o URL do código QR usando o c.HTML() método do contexto Gin, que recebe um código de status, um nome de modelo e um objeto de dados opcional como argumentos e grava o HTML como o corpo da resposta.
Para escrever uma função de manipulador para exibir códigos QR, podemos usar o seguinte exemplo de código como referência:
// Definir uma função manipuladora para exibir códigos QR func displayQRCode(c *gin.Context) // Obter o parâmetro de localização da string de consulta location := c.Query("location") // Chamar a função generateQRCode() e obter a URL do código QR qrCodeURL := generateQRCode(location) // Renderizar um modelo HTML com a URL do código QR c.HTML(http.StatusOK, "index.html", gin.H "location": location, "qrCodeURL ": qrCodeURL, )
Para registrar a função do manipulador com uma rota, precisamos usar o r.GET() do mecanismo Gin e passe o caminho e a função do manipulador como argumentos. O caminho é uma string que especifica o padrão de URL que corresponde à solicitação. Para este exemplo, usaremos o caminho "/mostrar", o que significa que nossa função de manipulador manipulará qualquer solicitação GET que tenha "/mostrar" como seu caminho. Para registrar a função handler com uma rota, podemos usar o seguinte código:
// Registra a função do manipulador com uma rota r.GET("/display", displayQRCode)
Compile e instale seu mod
A etapa final é compilar e instalar seu mod no servidor web. Para compilar e instalar seu mod, usaremos o APXS, que é uma ferramenta que nos permite compilar e instalar nosso mod como um objeto compartilhado dinâmico (DSO) no servidor web. Um DSO é um arquivo que contém código executável que pode ser carregado e descarregado pelo servidor da Web em tempo de execução.
Para compilar e instalar seu mod usando APXS, precisamos fazer o seguinte:
Crie um Makefile que especifica como construir e instalar nosso mod usando APXS. Um Makefile é um arquivo que contém um conjunto de regras e comandos para criar e instalar software. Para criar um Makefile, execute o comando toque em Makefile. Isso criará um arquivo vazio chamado Makefile em seu diretório atual.
Edite o Makefile usando o Nano ou qualquer editor de texto de sua preferência. Para editar o Makefile usando o Nano, execute o comando nano makefile. Isso abrirá o Nano com uma tela vazia.
Escreva as regras e comandos para construir e instalar nosso mod usando APXS. Para escrever as regras e comandos para construir e instalar nosso mod usando APXS, podemos usar o seguinte exemplo de código como referência:
# Definir variáveis para APXS APXS=apxs APXS_CFLAGS=-Wc,-Wall APXS_LIBS=-Wl,-lm # Definir variáveis para Go GO=go GO_FLAGS=build -buildmode=c-shared # Definir variáveis para mod MOD_NAME=mod_weather.so MOD_SRC=mod_weather.go # Definir regra padrão para fazer tudo: $(MOD_NAME) # Definir regra para construir mod $(MOD_NAME): $( MOD_SRC) $(GO) $(GO_FLAGS) -o $@ $^ # Definir regra para instalar mod install: $(MOD_NAME) $(APXS) -i -a -n weather $^ # Definir regra para limpar mod clean: rm -f $(MOD_NAME) $(MOD_NAME:.so=.h)
As três primeiras linhas definem variáveis para APXS, como o nome do executável APXS, os sinalizadores do compilador e os sinalizadores do vinculador. As próximas três linhas definem variáveis para Go, como o nome do executável Go, os sinalizadores de construção e mod usando Fabric, você precisa seguir estas etapas:
Verifique o site da Fabric ou o repositório GitHub para obter as versões mais recentes do Fabric Loader, Fabric API, Fabric Loom e Fabric Language Kotlin.
Atualize seu build.gradle para usar as versões mais recentes do Fabric Loom e da API do Fabric.
Atualize seu gradle.properties arquivo para usar as versões mais recentes do Minecraft e mappings.
Atualize seu src/main/resources/fabric.mod.json arquivo para usar a versão mais recente do seu mod e quaisquer outras alterações nos metadados do mod.
Atualize seu src/main/java/net/fabricmc/example/ExampleMod.java arquivo para usar os recursos e ganchos mais recentes da API do Fabric e corrigir quaisquer problemas ou erros de compatibilidade.
Execute o comando compilação gradle para construir seu arquivo jar mod.
Copie o arquivo jar de build/libs para .minecraft/mods.
Execute o Minecraft com Fabric Loader e aproveite seu mod atualizado.
0517a86e26
Comments