Developer Notes
Em construção
Paginas:
Em construção
Paginas:
Em construção
Paginas:
# hack para terminal
sudo apt install fonts-hack-ttf -y
# Fira code
sudo apt install fonts-firacode
cat /etc/apt/sources.conf
ls /var/cache/apt/archives
ls /var/lib/apt/lists
apt-get option nome_do_pacote
Options:
apt-cache search pacote
apt-cache depends pacote
O pré-carregamento é um daemon que é executado em segundo plano e analisa o comportamento do usuário e executa aplicativos com freqüência. Abra um terminal e use o seguinte comando para instalar o pré-carregamento
sudo apt-get install preload
link: https://wiki.archlinux.org/index.php/Installation_guide
Inicie o archlinux e:
loadkeys br-abnt2
ip link
ping google.com.br
wifi-menu
Abre um diálogo simples de escaneamento de rede, permitindo que você selecione com o teclado a rede desejada, digite a senha e pronto.
Use o comando para iniciar o particionamento do disco
# Para listar as partições existentes
lsblk
fdisk -l
# Para cira novas partições GPT, para a partição /dev/sda
cfdisk /dev/sda
Partição | Tipo de partirção | Sugestão de tamanho | Ponto de montagem |
---|---|---|---|
/dev/efi_system_partition | EFI system partition | 500MB | /mnt/boot |
/dev/swap_partition | Linux swap | 2G | [SWAP] |
/dev/root_partition | Linux x86-64 root (/) | O resto | /mnt |
#mkfs.fat -F32 /dev/boot_partition
mkfs.fat -F32 /dev/sda1
# mkswap /dev/swap_partition
mkswap /dev/sda2
# mkfs.ext4 /dev/root_partition
mkfs.ext4
mount /dev/sda3 /mnt
# mount /dev/root_partition/mnt
mount /dev/sda3 /mnt
mkdir /mnt/home
mkdir /mnt/boot
mkdir /mnt/boot/efi
# mount /dev/boot_partition/mnt
mount /dev/sda1 /mnt/boot/efi
# swapon /dev/swap_partition
swapon /dev/sda2
pacstrap /mnt base linux linux-firmware
Isso pode demorar um tempinho, vá tomar um chá
Vamos gerar a nossa tabela FSTAB, que vai dizer para o sistema onde estão montadas cada uma das partições, faremos isso usando este comando:
# Cria a tabela do fstab
genfstab -U -p /mnt >> /mnt/etc/fstab
# mostra o conteudo da tabela fstab
cat /mnt/etc/fstab
Esse “-U” ali “no meio da turma” é para que seja usados os IDs dos discos no FSTAB, ao invés dos rótulos
arch-chroot /mnt
Uma vez logado no seu sistema (repare que o terminal mudou de aparência), tudo o que você fizer agora, ficará em definitivo no seu Arch Linux.
Para alterar ajustar o fuso horario precisamos criar um link simbolivo
# ln -sf /usr/share/zoneinfo/Região/Cidade /etc/localtime
Ex:
ln -sf /usr/share/zoneinfo/America/Sao_Paulo /etc/localtime
hwclock --systohc
date
pacman -S nano
Para alterar para português
nano /etc/locale.gen
locale-gen
echo LANG=pt_BR.UTF-8 >> /etc/locale.conf
echo KEYMAP=br-abnt2 >> /etc/vconsole.conf
# coloquei uni_arch
nano /etc/hostname
Porem vc deve adicionalos na tabela hosts
nano /etc/hosts
# ADD
127.0.0.1 localhost.localdomain localhost
::1 localhost.localdomain localhost
127.0.1.1 uni_arch.localdomain uni_arch
passwd
senha: unisenha
# useradd -m -g users -G wheel nome_desejado_para_o_usuario
useradd -m -g users -G wheel uni_user
# pacman -S dosfstools os-prober mtools network-manager-applet networkmanager wpa_supplicant wireless_tools dialog sudo
# na vm
pacman -S dosfstools os-prober mtools systemd-networkd, systemd-resolved iwd sudo
nano /etc/sudoers
uni_user ALL=(ALL) ALL
pacman -S grub-efi-x86_64 efibootmgr
grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=arch_grub --recheck
cp /usr/share/locale/en@quot/LC_MESSAGES/grub.mo /boot/grub/locale/en.mo
grub-mkconfig -o /boot/grub/grub.cfg
Chegamos ao final da instalação padrão, digite “exit” ou pressione “Ctrl+D” e use o comando “reboot” para reiniciar o computador, remova o pen drive da máquina.
pacman -Sy
pacman -S xorg-server
pacman -S virtualbox-guest-utils virtualbox-guest-modules-arch mesa mesa-libgl
pacman -S gnome gnome-terminal nautilus gnome-tweaks gnome-control-center gnome-backgrounds adwaita-icon-theme
pacman -S firefox
systemctl enable gdm
Em construção
Paginas:
Em construção
Caso no windows crie via interface.
mkdir -p C:\opt\jetty
mkdir -p C:\opt\nexus-app
mkdir -p C:\opt\temp
Descrição
Os propósitos do diretório são os seguintes:
C:\opt\jetty - Onde a distribuição do cais será descompactada
C:\opt\nexus-app - Onde seu conjunto específico de aplicativos da web estará localizado, incluindo toda a configuração necessária do servidor para torná-los operacionais.
C:\opt\temp - Este é o diretório temporário designado a Java pela Camada de Serviço (é o que Java vê como java.io.tmpdir Propriedade do Sistema).
Isso é intencionalmente mantido separado do diretório temporário padrão de /tmp, pois esse local também funciona como o diretório de trabalho Servlet Spec. É nossa experiência que o diretório temporário padrão é frequentemente gerenciado por vários scripts de limpeza que causam estragos em um servidor Jetty de longa execução.
JETTY_HOME=C:\opt\jetty
JETTY_BASE=C:\opt\nexus-app
TMPDIR=C:\opt\temp
Edite o arquivo
%JETTY_HOME%\etc\webdefault.xml
, procure pordirAllowed
e mudar parafalse
<init-param> <param-name>dirAllowed</param-name> <param-value>false</param-value> </init-param>
Após configurar as variáveis de ambiente, use os comandos abaixo para criar o base dir:
cd %JETTY_BASE%
java -jar %JETTY_HOME%\start.jar --create-startd
java -jar %JETTY_HOME%\start.jar --add-to-start=http,deploy,jsp,console-capture # Caso sem https
java -jar %JETTY_HOME%\start.jar --add-to-start=https,ssl,deploy,jsp,console-capture # Caso https - Item https
Descrição dos arquivos criados
console-capture.ini - Onde fica as configurações de log. deploy.ini - Configurações dos path e arquivos do deploys. http.ini - Configuração do http (porta, host …)
https.ini - Configuração do http (porta, host …)
ssl.ini - Configuração de certificados
Crie um arquivo start.ini (caso não exista), para adicionar configurações personalizadas na inicialização do jetty, como debug, plugin do apm-server ….
touch %JETTY_BASE%\start.d\start.ini # touch serve pra criar arquivo, você pode criar na mão
Causa problema no banco, porque a maquina está em uma timezone diferente.
Edite o arquivo %JETTY_BASE%\start.ini e adicione:
Abra no editor de texto o arquivo
%JETTY_BASE%\start.ini
# Adiciona e as configurações ao final do arquivo
--exec
-Doracle.jdbc.timezoneAsRegion=false # Serve para descosiderar
Edite o arquivo %JETTY_BASE%\start.d\console-capture.ini e deixe:
## Para que cada novo log anexe ao arquivo existente
jetty.console-capture.append=true
## Quantos dias para reter arquivos de log antigos
jetty.console-capture.retainDays=30
Edite o arquivo %JETTY_BASE%\start.d\http.ini e defina em qual porta o jetty vai rodar.
jetty.http.port=8080
Caso não tenha executado o item de https no passo 4: Use o comando abaixo para adicionar o modulo ssl e https no jetty:
java -jar %JETTY_HOME%\start.jar --add-to-start=https,ssl,deploy,jsp,console-capture
Necessário pra segurança.
A senha deve ser a senha do certificado e do keystore. (veremos isso mais pra frente)
cd %JETTY_HOME%\lib
java -cp jetty-util-<versao>.jar org.eclipse.jetty.util.security.Password suaSenhaSuperSecreta
OBF:20ld1i9a1ysy1ri71x8c1bim1bhs1x8i1ri71yto1i6o20l9
MD5:f6440512900830666d40fbe12b88adaf
Esta é a nossa senha de exemplo: suaSenhaSuperSecreta. Sua representação ofuscada é OBF:20ld1i9a1ysy1ri71x8c1bim1bhs1x8i1ri71yto1i6o20l9.
Esse procedimento considera que você já tenha um certificado, do tipo pfx, caso seja diferente busque como criar um keystore do tipo JKS com o tipo do seu certificado.
Caso use linux use o comando abaixo:
keytool -importkeystore -srckeystore Wildkns.pfx -srcstoretype pkcs12 -destkeystore keystore -deststoretype JKS
Caso use windows us os passos abaixo:
Use o aplicativo key explore
Abra ele como administrador, e crie um certificado vazio.
# Entre na pasta onde salvou o keystore
cp keystore %JETTY_BASE%\etc
Adicione as linhas abaixo no arquivo
%JETTY_BASE%\start.d\ssl.ini
## Porta da https
jetty.ssl.port=8443
## Keystore password
jetty.sslContext.keyStorePassword=OBF:20ld1i9a1ysy1ri71x8c1bim1bhs1x8i1ri71yto1i6o20l9 # senha gerada anteriormente - passo 6.2
## KeyManager password
jetty.sslContext.keyManagerPassword=OBF:20ld1i9a1ysy1ri71x8c1bim1bhs1x8i1ri71yto1i6o20l9 # senha gerada anteriormente - passo 6.2
## Truststore password
jetty.sslContext.trustStorePassword=OBF:20ld1i9a1ysy1ri71x8c1bim1bhs1x8i1ri71yto1i6o20l9 # senha gerada anteriormente - passo 6.2
https://localhost:8443 # vai falar que esta inseguro
https://<url do dominio>:8443 # vai falar que esta seguro
Para ver os logs da aplicação
# abra a powershell
# entre na pasta %JETTY_BASE%\webapps
# digite o comando:
Get-Content nome_arquivo_log -Wait -Tail 100
# ou digite o comando com o caminho
# ex:
Get-Content c:\opt\nexus-app\logs\2020-11-02.log -Wait -Tail 100
Para ver os logs do serviço do Windows
# abra a powershell
# entre na pasta c:/opt/logs
# digite o comando:
Get-Content nome_arquivo_log -Wait -Tail 100
# ou digite o comando com o caminho
# ex:
Get-Content c:\opt\logs\2020-11-02.log -Wait -Tail 100
Caso queria redirecionar o que recebe em uma url crie um arquivo xml junto as aplicações
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Configure PUBLIC "-//Jetty//Configure//EN" "http://www.eclipse.org/jetty/configure_9_0.dtd">
<Configure class="org.eclipse.jetty.webapp.WebAppContext">
<Set name="contextPath">/</Set>
<Set name="war">/opt/jetty/webapps/<app>.war</Set>
</Configure>
@echo off
set SERVICE_NAME=JettyService
set JETTY_HOME=C:\opt\jetty
set JETTY_BASE=C:\opt\nexus-app
set STOPKEY=secret
set STOPPORT=50001
set PR_INSTALL=C:\opt\prunsrv.exe
@REM Service Log Configuration
set PR_LOGPREFIX=%SERVICE_NAME%
set PR_LOGPATH=C:\opt\logs
set PR_STDOUTPUT=auto
set PR_STDERROR=auto
set PR_LOGLEVEL=Debug
@REM Path to Java Installation
set JAVA_HOME=C:\Program Files\Java\jdk1.7.0_45
set PR_JVM=%JAVA_HOME%\jre\bin\server\jvm.dll
set PR_CLASSPATH=%JETTY_HOME%\start.jar;%JAVA_HOME%\lib\tools.jar
@REM JVM Configuration
set PR_JVMMS=128
set PR_JVMMX=512
set PR_JVMSS=4000
set PR_JVMOPTIONS=-Duser.dir="%JETTY_BASE%";-Djava.io.tmpdir="C:\opt\temp";-Djetty.home="%JETTY_HOME%";-Djetty.base="%JETTY_BASE%"
@REM Startup Configuration
set JETTY_START_CLASS=org.eclipse.jetty.start.Main
set PR_STARTUP=auto
set PR_STARTMODE=java
set PR_STARTCLASS=%JETTY_START_CLASS%
set PR_STARTPARAMS=STOP.KEY="%STOPKEY%";STOP.PORT=%STOPPORT%
@REM Shutdown Configuration
set PR_STOPMODE=java
set PR_STOPCLASS=%JETTY_START_CLASS%
set PR_STOPPARAMS=--stop;STOP.KEY="%STOPKEY%";STOP.PORT=%STOPPORT%;STOP.WAIT=10
"%PR_INSTALL%" //IS/%SERVICE_NAME% ^
--DisplayName="%SERVICE_NAME%" ^
--Install="%PR_INSTALL%" ^
--Startup="%PR_STARTUP%" ^
--LogPath="%PR_LOGPATH%" ^
--LogPrefix="%PR_LOGPREFIX%" ^
--LogLevel="%PR_LOGLEVEL%" ^
--StdOutput="%PR_STDOUTPUT%" ^
--StdError="%PR_STDERROR%" ^
--JavaHome="%JAVA_HOME%" ^
--Jvm="%PR_JVM%" ^
--JvmMs="%PR_JVMMS%" ^
--JvmMx="%PR_JVMMX%" ^
--JvmSs="%PR_JVMSS%" ^
--JvmOptions=%PR_JVMOPTIONS% ^
--Classpath="%PR_CLASSPATH%" ^
--StartMode="%PR_STARTMODE%" ^
--StartClass="%JETTY_START_CLASS%" ^
--StartParams="%PR_STARTPARAMS%" ^
--StopMode="%PR_STOPMODE%" ^
--StopClass="%PR_STOPCLASS%" ^
--StopParams="%PR_STOPPARAMS%"
if not errorlevel 1 goto installed
echo Failed to install "%SERVICE_NAME%" service. Refer to log in %PR_LOGPATH%
goto end
:installed
echo The Service "%SERVICE_NAME%" has been installed
:end
- Depois execute o arquivo, clicando duas vezes no install-jetty-service.bat.
- Abra o Service Local e inicie o serviço.
Supondo que você tenha seu aplicativo da web implantado no jetty, há duas maneiras diferentes de abordar isso:
java -Xdebug -agentlib:jdwp=transport=dt_socket,address=9999,server=y,suspend=n -jar start.jar
#===========================================================
# Configure JVM arguments.
# If JVM args are include in an ini file then --exec is needed
# to start a new JVM from start.jar with the extra args.
# If you wish to avoid an extra JVM running, place JVM args
# on the normal command line and do not use --exec
#-----------------------------------------------------------
--exec
-Xdebug
-agentlib:jdwp=transport=dt_socket,address=9999,server=y,suspend=n
# -Xmx2000m
# -Xmn512m
# -XX:+UseConcMarkSweepGC
# -XX:ParallelCMSThreads=2
# -XX:+CMSClassUnloadingEnabled
# -XX:+UseCMSCompactAtFullCollection
# -XX:CMSInitiatingOccupancyFraction=80
# -verbose:gc
# -XX:+PrintGCDateStamps
# -XX:+PrintGCTimeStamps
# -XX:+PrintGCDetails
# -XX:+PrintTenuringDistribution
# -XX:+PrintCommandLineFlags
# -XX:+DisableExplicitGC
Em construção
# nginx
nginx -s [ stop | quit | reopen | reload ]
# via system d
sudo systemctl [ stop | quit | reopen | reload ] nginx
## copiar site andre
sudo cp -r /home/uni/Downloads/andre-xbox-series-x/nexus-new-cadastro-front/distwar/src/main/webapp/* /usr/share/nginx/html
Ferramentas Windows
–
Documentação - 2.2. Configuração do NGINX
Virtual hosts - Como criar Virtual Hosts com Nginx
## Do site estatico
# mkdir -p /var/www/<nome-site>/public_html
mkdir -p /var/www/unisite.com/public_html
# mkdir /var/log/nginx/<nome-site>/
mkdir /var/log/nginx/unisite.com/
# sudo chown -R www-data:www-data /var/www/<nome-site>/public_html
sudo chown -R www-data:www-data /var/www/unisite.com/public_html
# todos estejam aptos a ler seus arquivos. Para isso, utilize o comando abaixo:
# sudo chmod 755 /var/www
# cp -r /<path-do-site>/* /var/www/<nome-site>/public_html
# sudo cp /etc/nginx/sites-available/default /etc/nginx/sites-available/<nome-site>
sudo cp /etc/nginx/sites-available/default /etc/nginx/sites-available/unisite.com
# code /etc/nginx/sites-available/<nome-site>
# sudo nano /etc/nginx/sites-available/<nome-site>
code /etc/nginx/sites-available/unisite.com
# Add os itens abaixo
server {
listen 80; ## listen for ipv4; this line is default and implied
#listen [::]:80 default ipv6only=on; ## listen for ipv6
# root /var/www/<nome-site>/public_html;
root /var/www/unisite.com/public_html;
index index.html index.htm;
# access_log /var/log/nginx/<nome-site>/access.log;
access_log /var/log/nginx/ unisite.com/access.log;
# error_log /var/log/nginx/<nome-site>/error.log;
error_log /var/log/nginx/ unisite.com/error.log;
# Make site accessible from http://localhost/
# server_name <nome-site>;
server_name unisite.com;
}
# sudo ln -s /etc/nginx/sites-available/<nome-site> /etc/nginx/sites-enabled/<nome-site>
sudo ln -s /etc/nginx/sites-available/unisite.com /etc/nginx/sites-enabled/ unisite.com
# Desabilite o Default Virtual Host
sudo unlink /etc/nginx/sites-enabled/default
systemctl restart nginx
# ou
sudo service nginx restart
nano /etc/hosts
#Virtual Hosts
localhost www.example.com
# Logs de acesso default
tail /var/log/nginx/access.log -f
# personalizado
# tail /var/log/nginx/<nome-site>/access.log -f
tail /var/log/nginx/unisite.com/access.log -f
# Erros default
tail /var/log/nginx/error.log
# personalizado
# tail /var/log/nginx/<nome-site>/error.log
tail /var/log/nginx/unisite.com/error.log
sudo unlink /etc/nginx/sites-enabled/default
# Criando arquivo
touch etc/nginx/sites-available/reverse-proxy.conf
# Edite
code etc/nginx/sites-available/reverse-proxy.conf
# sudo nano etc/nginx/sites-available/reverse-proxy.conf
# Adicione
server {
listen 80;
location / {
proxy_pass http://192.x.x.2; # redireciona o que vem para esse ip
}
}
sudo ln -s /etc/nginx/sites-available/reverse-proxy.conf /etc/nginx/sites-enabled/reverse-proxy.conf
service nginx configtest
systemctl restart nginx
# ou
sudo service nginx restart
Em construção
Paginas:
Em construção
# Lista as tasks
gradle tasks
# Mostrar o help
gradle help --taks init
# Inicia um projeto
gradle init
# Executar o projeto
gradle run
# Executa os testes
gradle test
# Installar as dependencias
gradle build --scan
# Builda3 o projeto
gradle build
# Ver cobertura de testes
/app/build/reports/tests/test/index.html
jar tf app.jar
# extrai manifest
jar xf app.jar META-INF/MANIFEST.MF
# exibe
cat META-INF/MANIFEST.MF
java -jar app.jar
tasks.register('teste') {
println 'Hello world'
}
tasks.register('hello') {
doLast {
println 'Hello world!'
}
}
gradle -q teste
-ou
gradle teste // mostra status da execução
link: https://docs.gradle.org/current/userguide/tutorial_using_tasks.html#sec:projects_and_tasks
tasks.register('upper') {
doLast {
String someString = 'mY_nAmE'
println "Original: $someString"
println "Upper case: ${someString.toUpperCase()}"
}
}
// exemplo de repetição
tasks.register('count') {
doLast {
4.times { print "$it " }
}
}
gradle upper
tasks.register('taskX') {
dependsOn 'taskY'
doLast {
println 'taskX'
}
}
tasks.register('taskY') {
doLast {
println 'taskY'
}
}
gradle taskX
# mostrar a execução das duas tasks, pois a taskX depende da taskY
tasks.register('hello') {
doLast { // definie a ordem de execução
println 'Hello Earth'
}
}
tasks.named('hello') {
doFirst { // defini a orde de execução
println 'Hello Venus'
}
}
tasks.named('hello') {
doLast {
println 'Hello Mars'
}
}
tasks.named('hello') {
doLast {
println 'Hello Jupiter'
}
}
gradle -q hello
#saida
#Olá Vênus
#Olá terra
#Olá marte
#Ola jupiter
https://docs.gradle.org/current/userguide/plugins.html#plugins | –> Aplicando plug-ins com o DSL de plug-ins
- As dependências pode ser de dois tipos:
- como configurações do tipo api - que serão expostas transitivamente aos consumidores da biblioteca e, como tal, aparecerão no classpath de compilação dos consumidores
- como configuração do tipo implementation que, por outro lado, não serão expostas aos consumidores e, portanto, não vazarão para o classpath de compilação dos consumidores
dependencies {
api 'org.apache.httpcomponents:httpclient:4.5.7'
implementation 'org.apache.commons:commons-lang3:3.5'
}
OBS: As configurações compile e runtime foram removidas com o Gradle 7.0. Consulte o guia de atualização como migrar para implementatione apiconfigurações. - compile –> implementation - runtime –> api
Prefira a configuração de implementation em vez de api quando possível.
Em construção
Paginas:
Em construção
# Lista o conteudo do jar
java -jar tf app.jar
# Mostra o conteudo do arquivo manifest
## extrai manifest
java -jar xf app.jar META-INF/MANIFEST.MF
## exibir conteudo
cat META-INF/MANIFEST.MF
# Executa aplicação
java -jar app.jar
package streams;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class MinMax {
public static void main(String[] args) {
Aluno a1 = new Aluno("Ana", 7.1);
Aluno a2 = new Aluno("Luna", 6.1);
Aluno a3 = new Aluno("Gui", 8.1);
Aluno a4 = new Aluno("Gabi", 10);
List<Aluno> alunos = Arrays.asList(a1, a2, a3, a4);
Comparator<Aluno> melhorNota = (aluno1, aluno2) -> {
if(aluno1.nota > aluno2.nota) return 1;
if(aluno1.nota < aluno2.nota) return -1;
return 0;
};
Comparator<Aluno> piorNota = (aluno1, aluno2) -> {
if(aluno1.nota > aluno2.nota) return -1;
if(aluno1.nota < aluno2.nota) return 1;
return 0;
};
System.out.println(alunos.stream().max(melhorNota).get());
System.out.println(alunos.stream().min(piorNota).get());
System.out.println(alunos.stream().min(melhorNota).get());
System.out.println(alunos.stream().max(piorNota).get());
}
}
Metodos uteis - limit / skip / distinct / takeWhile
package streams;
import java.util.Arrays;
import java.util.List;
public class Outros {
public static void main(String[] args) {
Aluno a1 = new Aluno("Ana", 7.1);
Aluno a2 = new Aluno("Luna", 6.1);
Aluno a3 = new Aluno("Gui", 8.1);
Aluno a4 = new Aluno("Gabi", 10);
Aluno a5 = new Aluno("Ana", 7.1);
Aluno a6 = new Aluno("Pedro", 9.1);
Aluno a7 = new Aluno("Gui", 8.1);
Aluno a8 = new Aluno("Maria", 10);
List<Aluno> alunos =
Arrays.asList(a1, a2, a3, a4, a5, a6, a7, a8);
System.out.println("distinct...");
// recuperar os valores distintos (precisa do equals e hash code)
alunos.stream().distinct().forEach(System.out::println);
System.out.println("\nSkip/Limit");
alunos.stream()
.distinct()
.skip(2) // pulo uma quantidade de itens
.limit(2) // limita a quantidade de retorno
.forEach(System.out::println);
System.out.println("\ntakeWhile");
alunos.stream()
.distinct()
.skip(2)
.takeWhile(a -> a.nota >= 7) // retorna ate achar a condição
.forEach(System.out::println);
}
}
Em construção
Em construção
link: Como posso instalar o protobuf no ubuntu 12.04?
ou
sudo apt-get install libprotobuf-java protobuf-compiler
protoc -I=$SRC_DIR --java_out=$DST_DIR $SRC_DIR/<file>.proto
link: https://developers.google.com/protocol-buffers/docs/proto3
message SearchRequest {
string query = 1;
int32 page_number = 2; // Which page number do we want?
int32 result_per_page = 3; // Number of results to return per page.
}
message Foo {
reserved 2, 15, 9 to 11;
reserved "foo", "bar";
}
message SearchRequest {
string query = 1;
int32 page_number = 2;
int32 result_per_page = 3;
enum Corpus {
UNIVERSAL = 0;
WEB = 1;
IMAGES = 2;
LOCAL = 3;
NEWS = 4;
PRODUCTS = 5;
VIDEO = 6;
}
Corpus corpus = 4;
}
// Usando alias para representar a mesma coisa
message MyMessage1 {
enum EnumAllowingAlias {
option allow_alias = true; // necessario deixar essa opção como true, senão vai dar erro, como abaixo
UNKNOWN = 0;
STARTED = 1;
RUNNING = 1;
}
}
message MyMessage2 {
enum EnumNotAllowingAlias {
UNKNOWN = 0;
STARTED = 1;
// RUNNING = 1; // Uncommenting this line will cause a compile error inside Google and a warning message outside.
}
}
//Observe que você não pode misturar nomes de campo e valores numéricos na mesma reservedinstrução.
message SearchResponse {
repeated Result results = 1; //o repeat dis que pode ser repetido os itens, semelhate a uma lista
}
message Result {
string url = 1;
string title = 2;
repeated string snippets = 3;
}
// Tipo aninhado
message SearchResponse {
message Result {
string url = 1;
string title = 2;
repeated string snippets = 3;
}
repeated Result results = 1;
}
// chamdando tipo aninhado
message SomeOtherMessage {
SearchResponse.Result result = 1;
}
// Exemplo de message aninhada
message Outer { // Level 0
message MiddleAA { // Level 1
message Inner { // Level 2
int64 ival = 1;
bool booly = 2;
}
}
message MiddleBB { // Level 1
message Inner { // Level 2
int32 ival = 1;
bool booly = 2;
}
}
}
caso a mensagem que queira colocar dentro da mensagem esteja em outro proto, vc pode importa-lo
import "myproject/other_protos.proto";
O gRPC permite definir quatro tipos de método de serviço:
Em que o cliente envia uma única solicitação ao servidor e obtém uma única resposta, exatamente como uma chamada de função normal.
rpc SayHello(HelloRequest) returns (HelloResponse);
Em que o cliente envia uma solicitação ao servidor e obtém um stream para ler uma sequência de mensagens de volta. O cliente lê a partir do fluxo retornado até que não haja mais mensagens. O gRPC garante a ordem das mensagens em uma chamada RPC individual.
rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);
Em que o cliente grava uma sequência de mensagens e as envia ao servidor, novamente usando um fluxo fornecido. Depois que o cliente termina de escrever as mensagens, ele espera que o servidor as leia e retorne sua resposta. Mais uma vez, o gRPC garante a ordem das mensagens em uma chamada RPC individual.
rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);
Em que ambos os lados enviam uma sequência de mensagens usando um fluxo de leitura e gravação. Os dois fluxos operam de forma independente, para que os clientes e servidores possam ler e escrever na ordem que quiserem: por exemplo, o servidor pode esperar para receber todas as mensagens do cliente antes de escrever suas respostas, ou pode alternativamente ler uma mensagem e depois escrever uma mensagem, ou alguma outra combinação de leituras e gravações. A ordem das mensagens em cada fluxo é preservada.
rpc BidiHello(stream HelloRequest) returns (stream HelloResponse);