-
Notifications
You must be signed in to change notification settings - Fork 0
/
anotacoes.txt
143 lines (81 loc) · 9.69 KB
/
anotacoes.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
Package javax.persistence (JPA) - Define uma interface para frameworks de persistência de dados que usam mapeamento
objeto-relacional para objetos simples Java (POJOs)! Exemplo de framework objeto relacional é o Hibernate!
Nota:
O fetch nas anotações de relacionamentos e criação de relação de atributos multivalorados, possui dois tipo:
- FetchType.LAZY: Faz com que determinados objetos dentro de algum objeto, não sejam chamados até que você chame-os explicitamente
- FetchType.EAGER: Ao contrário do LAZY, carrega os objetos mesmo que você não vá usar
Lazy necessariamente é mais rápido que o Eager
Suas devidaa funções só são vista fazendo JPQL e colocando-o em um função de respositório
Anotações:
- @Entity: Define que a classe que se tornará uma entidade em um modelo relacional! E partir dela, será gerado uma relação com todas a entidades!
- @Id: Usada em atributo de classe, faz com que esse atributo se torne o id da entidade e sua chave primária
- @GeneratedValue(strategy = GenerationType.IDENTITY): Indica a como se dará a geração das chaves primarias, o GenerationType.IDENTITY indica que a geração se dará pelo banco de dados
- @OneToMany(mappedBy = "",fetch = ) e @ManyToOne: Indica uma relação uma para muitos com outra entidade! O mappedBy indica que o mapeamento do relacionameto foi feito pelo atributo da outra entidade!
- @ElementCollection(fetch = )
@CollectionTable(name = ""): Essas duas anotações criam uma nova relação com atributos de uma entidade que sejam multivalorados! O argumento name indica o nome da relação!
- @ManyToMany(mappedBy = "",fetch = ): Define uma relação muitos para muitos de uma entidade com outra entidade! O agumento mappedBy indica qual atributo da outra classe foi usado para fazer o mapeamento!
- @OneToOne(mappedBy = "",fetch = ): Define uma relação um para um com alguma classe! mappedBy contém o atributo da outra classe que fez o relacionameto! Na outra classe, fazer @OneToOne(cascade = CascadeType.ALL), tudo que for feito com objeto dessa classe, será replicado no outro objeto
- @MapsId: Essa anotação usada bastante com @OneToOne, faz com que os Ids de dois objetos sejam mapeados, ou seja, elesseram iguais!
- @JoinTable(
name = "",
joinColunm = @JoinColumn(name = ""),
inverseJoinColumn = @JoinColumn(name = "")
): Anotação usada com @ManyToMany para criar a relação desse relacionameto! Os argumentos name definem o nome da relação ou dos atributos! @JoinColumn é usado pra definir as colunas da relação, que viram das duas entidades! Nota, o inverseJoinColumn precisa ser o atributo que faz a o mapeamento muitos para muitos da classe que contém a anotação @JoinTable, se não, ocorrerá um erro na atribuição de nomes de atributos
- @JoinColumn(name = ""): Define a chave estrangeira para referência outra entidade! Atributo name diz que nome o atributo receberá na tabela! Essa anotação é bastante usada com @ManyToMany, @ManyToOne e @OneToOne!
- @EmbeddedId: Define que o ID será uma chave primária composta, e que essas chaves viram de um objeto!
- @Embeddable: Indica que a classe é imbutivél, ou seja, fará parte de outra classe! Essa anotação é na classe que se tornará uma chave primária composta! É usado com @EmbeddableId!
- @Inheritance(strategy = InheritanceType.JOINED): Define o tipo de criação de relações que contenha herança! Existem 3 tipos de criação de relações com herança:
- InheritanceType.JOINED: Tabela por subclasse, nessa implementação, haverá a classe pai e filhas no banco, mas as classes filhas teram atributos diferentes e vão referenciar o pai com sua chave primária como estrangeira
- InheritanceType.TABLE_PER_CLASS: Tabela por classes concretas, ou seja, só teremos tabelas das classes filhas
- InheritanceType.SINGLE_TABLE: Tabela única, será apenas uma tabela pra representar as classes filhas, alguns atributos podem ser null, o que pode acabar acarretando alguns erros
Packge javax.validation.constraints (Jakarta EE) - Contém anotações para fazer validação de atributos de
classe
Nota: Qualquer anotação quando acha o erro, joga MethodArgumentNotValidException!
Anotações:
- @NotEmpty(message = ""): Verifica se um campo é vazio! Se sim, uma excecão com a mensagem definida em message será
jogada!
- @Email(message = ""): Verifica se um email é válido!
Package javax.validation (Jakarta EE)
Anotações:
- @Valid: Indica que a requisição feita deve ser validada! Ex: @Valid @RequestBody Cliente cliente! Será verificado os campos na classe que possuem anotações de validações!
Package org.hibernate.validator.constraints (Hibernate) - Contém anotações de validação do Hibernate!
Nota: Qualquer anotação quando acha o erro, joga MethodArgumentNotValidException!
Anotações:
- @Length(min = 99, max = 99, message = ""): Valida um atributo por tamanho! Se o atributo não tiver tamanho entre min e max, uma exceção será jogada com a mensagem definida em message!
Package com.fasterxml.jackson.annotation (Jackson) - Contém algumas anotações da biblioteca JSON Jackson:
Anotações:
- @JsonIgnore: Anotação usada para previnir JSON cíclicos, que contenha recursividade infinita! A anotação é
colocada em algum get que dê início a recursividade!
- @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "@type"): Anotação que configura um campo que virá a mais em alguma requisição, e esse campo se chama @type! Isso tudo é feito para que classes filhas de uma classe pai, sejam, diferenciadas, e que a conversão JSON p/ objeto seja feita corretamente! Essa configuração precisa ser feita em uma classe que contenha o método objectMapperBuilder! Na classe filha, deve ser usado a anotação JsonTypeName("name") que contém o nome que vai referencia a classe, que virá no @type na requisição
- @JsonFormat(pattern = ""): Usado para padronizar datas no JSON em uma requisição! Em pattern, é passado um padrão a se seguido, que pode ser "dd/MM/yyyy HH:mm"
- @JsonTypeName(""): Indica o tipo da classe filha em um JSON!
Package org.springframework.beans.factory.annotation (Spring Framework)
Anotações:
- @Autowired: Faz com que a responsabilidade do ciclo de vida de uma classe seja gerida pelo Spring, na verdade será gerida pelo Spring IoC Container! Nesse caso a classe será um Bean, fará parte da parte backbone da aplicação! Uma classe Bean é instanciada definindo suas depêndencias sem cria-lás, conceito de inversão de controle(Inversion of Control - IoC)! As classes definidas, ou que são Beans, ficaram nesse IoC Container!
- @Value("${}"): Pega algum dado dos arquivos properties usado no ambiente
Package org.springframework.context.annotation (Spring Framework)
Anotações:
- @Configuration: Essa anotação indica que a classe é uma classe de configuração de ambiente! Nela podemos definir a persistência por exemplo!
- @Profile: Indica qual perfil ou ambiente a classe é usada! Geralmente, essa anotação é usada com @Configuration
- @Bean: Usado em métodos, faz com que os objetos desses métodos, as instâncias, sejam gerenciados pelo Spring IoC Container
Package Package org.springframework.stereotype (Spring Framework) - Define funções para classes em um níve de arquitetura
Anotações:
- @Service: Indica que a classe prestará serviços as outras partes da aplicação! É na classe de serviço que se encotra as regras de negócio da aplicação
- @Repository: Indica que a interface servirá com ponte ao acesso ao banco de dados! O repository é acessado pelo Service
Package org.springframework.web.bind.annotation (Spring Framework)
Anotações:
- @ControllerAdvice: Anotação que indica um classe que será manipuladora de exceções
- @ExceptionHandler(Class.class): Usado em métodos na classe que possuí a anotação anterior, denota qual classe esse método fará o tratamento da exceção
- @RestController: Indica que a classe será um controlador REST com endpoints
- @ResquestMapping(value = "", ResquestMethod.): Define o endpoint de uma classe(algo mais geral) ou de um método(esse endpoin dependo do endpoint da classe)! Usando em métodos, precisamos definir os métodos HTTPs deles! Usando ResquestMethod, temos alguns como: GET, DELETE, POST, PUT
- @PathVariable: Pega o variável de Path definida em ResquestMapping e coloca em um parâmetro de método! Ex: @PathVariable String nome
- @ResquestBody: Transforma o JSON de requisição em um Objeto! Ex: @RequestBody Cliente cliente
Package org.springframework.transaction.annotation (Spring Framework)
Anotações:
- @Transactional: Como próprio nome diz, essa anotação implementa uma transação no banco de dados! Uma transação contém um begin(), commit() e um rollback()! Em um transação, ou as modificações são feitas, ou nenhuma é feita Uma transação é um método atómico!
Package org.springframework.security.access.prepost (Spring Security)
Anotações:
- @PreAuthorize("hasAnyRole()"): Libera acesso de um endpoint para um tipo de usuário que é passado como argumento no hasAnyRole
Package org.springframework.security.config.annotation.method.configuration (Spring Security)
Anotações:
- @EnableGlobalMethodSecurity(prePostEnabled = ): Habilita checagem de acesso a endpoints