Subsections of Linguagens de programação

Java

Note

Em construção

Subsections of Java

Utilidades

Comando uteis

# 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

Interfaces Funcionais

Streams

  • Metodos uteis - min / max
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);
	}
}

Protocolos de comunicação

Note

Em construção

Subsections of Protocolos de comunicação

GRPC

Note

Em construção

Subsections of GRPC

Compilador local

Instalando compilador do protobuf

link: Como posso instalar o protobuf no ubuntu 12.04?

ou

sudo apt-get install libprotobuf-java protobuf-compiler

Gerando codigo

protoc -I=$SRC_DIR --java_out=$DST_DIR $SRC_DIR/<file>.proto
  • I - diretorio raiz do projeto
  • java_out - Diretorio onde vai ser gerado o codigo
  • Diretorio do arquivo proto

Criando mensagens

link: https://developers.google.com/protocol-buffers/docs/proto3

Exemplo

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.
}
  • os numero servem para definir a ordem dos dado na serialização para binario
  • Caso remova um campo, e recomendado não usar o numero que ele pertecia, pois isso pode dar conflito no futuro, para garantir que isso o mesmo não seja usado vc pode marcalos como reserved (reservados / excluidos)
message Foo {
  reserved 2, 15, 9 to 11;
  reserved "foo", "bar";
}

Enums

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.

Tipos de Mensagem personalizados

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

Importando

import "myproject/other_protos.proto";

Criando metodos

Tipo de metodos GRPC

O gRPC permite definir quatro tipos de método de serviço:

RPCs unários

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);

RPCs de streaming de servidor

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);

RPCs de streaming de cliente

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);

RPCs de streaming bidirecional

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);