├── LICENSE └── README.md /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright [yyyy] [name of copyright owner] 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![GitHub commit activity](https://img.shields.io/github/commit-activity/m/devmorfeu/spring-annotations?color=yellow)](https://github.com/devmorfeu/spring-annotations/graphs/commit-activity) 2 | [![GitHub stars](https://img.shields.io/github/stars/devmorfeu/spring-annotations?color=yellow)](https://github.com/devmorfeu/spring-annotations/stargazers) 3 | 4 | # Anotações do Framework Spring 5 | 6 | _Este documento descreve várias anotações disponíveis no Spring ‘Framework’, organizadas por módulos em ordem alfabética._ 7 | 8 | ## Índice 9 | 10 | - [Spring Beans 6.0.12](#spring-beans) 11 | - [Spring Boot 3.1.4](#spring-boot) 12 | - [Spring Cloud AWS 3.0.2](#spring-cloud-aws) 13 | - [Spring Cloud Openfeign 4.0.4](#spring-cloud-openfeign) 14 | - [Spring Context 6.0.12](#spring-context) 15 | - [Spring Core 6.0.12](#spring-core) 16 | - [Spring Data JPA 3.1.5](#spring-data-jpa) 17 | - [Spring Messaging 6.0.12](#spring-messaging) 18 | - [Spring Test 6.0.12](#spring-test) 19 | - [Spring Web 6.0.12](#spring-web) 20 | - [Spring JMS 6.0.12](#spring-jms) 21 | 22 | ## Spring-beans 23 | 24 | ${\color{yellow}@ Autowired}$ : _@Autowired é usada em Spring ‘Framework’ para indicar que uma dependência deve ser automaticamente injetada. Ela pode ser usada em construtores, campos, métodos ou parâmetros._ 25 | 26 | **Parâmetros:** 27 | 28 | - `required`: _valor booleano que define se a dependência anotada é obrigatória ou opcional._ 29 | 30 | ${\color{yellow}@Configurable}$ : _@Configurable é usada para marcar uma classe como elegível para configuração controlada pelo Spring._ 31 | 32 | **Parâmetros:** 33 | 34 | - `value`: _O nome da definição de bean que serve como modelo de configuração. Esse valor permite especificar o nome da definição de bean que deve ser usada para configurar a classe._ 35 | - `autowire`: _Define se as dependências devem ser injetadas via autowiring. Por padrão, autowire é definido como Autowire.NO, o que significa que as dependências não serão injetadas automaticamente. Você pode definir isso como **Autowire.BY_TYPE** ou **Autowire.BY_NAME** se desejar realizar a injeção automática de dependências._ 36 | - `dependencyCheck`: _Define se a verificação de dependências deve ser executada para objetos configurados. Se definido como true, o contêiner Spring verificará se todas as dependências estão satisfeitas. O padrão é false._ 37 | - `preConstruction`: _Define se as dependências devem ser injetadas antes da construção do objeto. Se definido como true, as dependências serão injetadas antes que o construtor seja chamado. O padrão é false._ 38 | 39 | ${\color{yellow}@Lookup}$ : _@Lookup é usada para criar métodos de pesquisa que permitem obter instâncias de beans gerenciados pelo Spring._ 40 | 41 | **Parâmetros:** 42 | 43 | - `value`: _Esse atributo permite sugerir o nome do bean de destino a ser pesquisado. Se não for especificado, o bean de destino será resolvido com base na declaração do tipo de retorno do método anotado._ 44 | 45 | ${\color{yellow}@Qualifier}$ : _@Qualifier é usada como um qualificador para beans candidatos durante a injeção de dependência._ 46 | 47 | **Parâmetros:** 48 | 49 | - `value`: _Atributo que permite especificar um valor que será usado para qualificar um bean durante a injeção de dependência._ 50 | 51 | ${\color{yellow}@ Value}$ : _@Value é usada para indicar um valor padrão ou expressão para um campo, método ou parâmetro de método/constructor anotado. Geralmente, essa anotação é usada para injetar valores por meio de expressões baseadas em SpEL._ 52 | 53 | **Parâmetros:** 54 | 55 | - `value`: _Usado para especificar a expressão real do valor que será injetado._ 56 | 57 | ## Spring-boot 58 | 59 | ${\color{yellow}@ AutoConfiguration}$ : _@AutoConfiguration é uma anotação do Spring Boot que permite configurar explicitamente o nome do bean associado a uma classe de autoconfiguração e especificar classes que devem ser aplicadas antes ou depois dela. Isso ajuda a controlar a ordem de configuração automática no contexto do aplicativo._ 60 | 61 | **Parâmetros:** 62 | 63 | - `value`: _Define explicitamente o nome do bean associado à classe **@AutoConfiguration**. Se não for especificado, um nome de bean será gerado automaticamente._ 64 | - `before`: _Especifica as classes de autoconfiguração que ainda não devem ser aplicadas antes da classe **@AutoConfiguration**._ 65 | - `beforeName`: _Define os nomes das classes de autoconfiguração que ainda não devem ser aplicadas antes da classe **@AutoConfiguration**._ 66 | - `after`: _Especifica as classes de autoconfiguração que já devem ter sido aplicadas antes da classe **@AutoConfiguration**._ 67 | - `afterName`: _Define os nomes das classes de autoconfiguração que já devem ter sido aplicadas antes da classe **@AutoConfiguration**._ 68 | 69 | ${\color{yellow}@ AutoConfigureAfter}$ : _@AutoConfigureAfter é uma anotação do Spring Boot que especifica classes de autoconfiguração que devem ser aplicadas depois de uma determinada classe de autoconfiguração, controlando a ordem de configuração automática._ 70 | 71 | **Parâmetros:** 72 | 73 | - `value`: _Especifica as classes de autoconfiguração que devem ser aplicadas antes da classe anotada, controlando a ordem de configuração automática._ 74 | - `name`: _Define os nomes das classes de autoconfiguração que devem ser aplicadas antes da classe anotada, também controlando a ordem de configuração automática. Esta opção foi adicionada na versão 1.2.2 do Spring Boot._ 75 | 76 | ${\color{yellow}@ AutoConfigureBefore}$ : _@AutoConfigureBefore é uma anotação do Spring Boot que especifica classes de autoconfiguração que devem ser aplicadas antes de uma determinada classe de autoconfiguração, controlando a ordem de configuração automática._ 77 | 78 | **Parâmetros:** 79 | 80 | - `value`: _Especifica as classes de autoconfiguração que devem ser aplicadas antes da classe anotada, controlando a ordem de configuração automática._ 81 | - `name`: _Define os nomes das classes de autoconfiguração que devem ser aplicadas antes da classe anotada, também controlando a ordem de configuração automática. Esta opção foi adicionada na versão 1.2.2 do Spring Boot._ 82 | 83 | ${\color{yellow}@ AutoConfigureOrder}$ : _@AutoConfigureOrder é uma anotação do Spring Boot que permite especificar a ordem de prioridade de classes de configuração automática, controlando a sequência de configuração durante a inicialização do aplicativo._ 84 | 85 | **Parâmetros:** 86 | 87 | - `value`: _permite definir a prioridade de configuração automática, onde o padrão é 0. Esse valor determina a ordem de execução das classes de configuração automática durante a inicialização do aplicativo Spring Boot. Quanto menor o valor, maior a prioridade._ 88 | 89 | ${\color{yellow}@ AutoConfigurationPackage}$ : _@AutoConfigurationPackage é uma anotação do Spring Boot que escaneia e registra automaticamente pacotes para configuração automática no contexto do aplicativo. Ela identifica o pacote da classe anotada e escaneia outros pacotes a partir dele._ 90 | 91 | **Parâmetros:** 92 | 93 | - `basePackages`: _Path de pacotes do projeto para verificar propriedades de configuração._ 94 | - `basePackageClasses`: _Alternativa ("Type-safe") especificando os pacotes para verificar as propriedades de configuração. O pacote de cada classe especificada será verificado._ 95 | 96 | ${\color{yellow}@BatchDataSource}$ : _@BatchDataSource é uma anotação do Spring Boot usada para configurar um **DataSource** específico para o processamento de lotes em aplicações Spring Batch, permitindo o isolamento dos recursos de banco de dados para tarefas de lote._ 97 | 98 | ${\color{yellow}@ConditionalOnBean}$ : _@ConditionalOnBean é uma anotação do Spring Boot que condiciona a ativação de um componente somente se um determinado bean estiver presente no contexto da aplicação. Isso permite controlar a inicialização de componentes com base na existência de outros beans._ 99 | 100 | **Parâmetros:** 101 | 102 | - `value`: _Especifica as classes de beans cuja presença no contexto da aplicação será verificada para a condição._ 103 | - `type`: _Especifica os nomes de classes de beans cuja presença no contexto da aplicação será verificada._ 104 | - `annotation`: _Especifica os tipos de anotações de classe que decoram os beans a serem verificados._ 105 | - `name`: _Especifica os nomes de beans cuja presença no contexto da aplicação será verificada._ 106 | - `search`: _Define a estratégia de pesquisa para determinar se o contexto de aplicação hierárquico (contexto pai) deve ser considerado._ 107 | - `parameterizedContainer`: _Especifica classes adicionais que podem conter tipos de beans específicos nos seus parâmetros genéricos._ 108 | 109 | ${\color{yellow}@ConditionalOnClass}$ : _@ConditionalOnClass é uma anotação do Spring Boot que condiciona a ativação de um componente somente se uma ou mais classes especificadas estiverem presentes no classpath da aplicação. Isso permite controlar a inicialização de componentes com base na disponibilidade de classes._ 110 | 111 | **Parâmetros:** 112 | 113 | - `value`: _Especifica as classes cuja presença no classpath é necessária para ativar a condição._ 114 | - `name`: _Especifica os nomes de classes cuja presença no classpath é necessária._ 115 | 116 | ${\color{yellow}@ConditionalOnCloudPlatform}$ : _@ConditionalOnCloudPlatform é uma anotação do Spring Boot que condiciona a ativação de um componente com base na plataforma em nuvem especificada, permitindo configurar componentes para diferentes ambientes de nuvem, como AWS, Google Cloud ou Azure._ 117 | 118 | **Parâmetros:** 119 | 120 | - `value`: _Especifica a plataforma em nuvem esperada para ativar a condição._ 121 | 122 | ${\color{yellow}@ConditionalOnDefaultWebSecurity}$ : _@ConditionalOnDefaultWebSecurity é uma anotação de condição usada no Spring Boot para ativar uma configuração específica de segurança web padrão quando nenhum outro mecanismo de segurança personalizado é configurado na aplicação. Isso fornece uma configuração de segurança web básica, como autenticação de formulário, se nenhum outro mecanismo de segurança estiver presente._ 123 | 124 | ${\color{yellow}@ConditionalOnEnabledResourceChain}$ : _@ConditionalOnEnabledResourceChain é uma anotação de condição usada no Spring Boot para verificar se a cadeia de recursos (Resource Chain) está habilitada na aplicação, permitindo a personalização de recursos, como arquivos estáticos e cache, em aplicativos da web. Isso permite a configuração avançada de recursos, como otimização de cache e versão de recursos._ 125 | 126 | ${\color{yellow}@ConditionalOnExpression}$ : _@ConditionalOnExpression é uma anotação do Spring Boot que condiciona a ativação de um componente com base numa expressão SpEL (Spring Expression Language) avaliada em tempo de execução, permitindo ativar componentes com base em regras lógicas definidas na expressão._ 127 | 128 | **Parâmetros:** 129 | 130 | - `value`: _Especifica a expressão SpEL a ser avaliada em tempo de execução. Se a expressão retornar **true**, a condição é ativada. Caso contrário, a condição é desativada. O valor padrão é "**true**"._ 131 | 132 | ${\color{yellow}@ConditionalOnGraphQLSchema}$ : _@ConditionalOnGraphQLSchema é uma anotação no Spring Boot que permite condicionar o carregamento de configurações com base na presença de um esquema GraphQL na aplicação, garantindo que as configurações sejam aplicadas somente quando o esquema estiver disponível._ 133 | 134 | ${\color{yellow}@ConditionalOnJava}$ : _@ConditionalOnJava é uma anotação do Spring Boot que condiciona a ativação de um componente com base na versão da plataforma Java, permitindo que os componentes sejam ativados apenas quando a versão Java especificada estiver presente._ 135 | 136 | **Parâmetros:** 137 | 138 | - `range`: _Configura se o valor especificado em **value()** é considerado um limite superior exclusivo ou um limite inferior inclusivo. O padrão é **Range.EQUAL_OR_NEWER** (igual ou mais recente)._ 139 | - `value`: _Especifica a versão da plataforma Java a ser verificada._ 140 | 141 | ${\color{yellow}@ConditionalOnJndi}$ : _@ConditionalOnJndi é uma anotação do Spring Boot que condiciona a ativação de um componente com base na disponibilidade de um recurso JNDI (Java Naming and Directory Interface), permitindo que componentes sejam ativados apenas quando o recurso JNDI especificado estiver disponível._ 142 | 143 | **Parâmetros:** 144 | 145 | - `value`: _Especifica os locais JNDI em que pelo menos um deve existir para ativar a condição. Se nenhum local for especificado, a condição será ativada apenas com base na presença de um **InitialContext**._ 146 | 147 | ${\color{yellow}@ConditionalOnMissingBean}$ : _@ConditionalOnMissingBean é uma anotação do Spring Boot que condiciona a ativação de um componente somente se não houver uma instância de bean do mesmo tipo já definida no contexto, permitindo substituir beans padrão com implementações personalizadas._ 148 | 149 | **Parâmetros:** 150 | 151 | - `value`: _Especifica os tipos de classes de beans a serem verificados quanto à ausência._ 152 | - `type`: _Especifica os nomes das classes de beans a serem verificados quanto à ausência._ 153 | - `ignored`: _Define os tipos de classes de beans a serem ignorados ao identificar beans correspondentes (desde a versão 1.2.5)._ 154 | - `ignoredType`: _Define os nomes das classes de beans a serem ignorados ao identificar beans correspondentes (desde a versão 1.2.5)._ 155 | - `annotation`: _Especifica as anotações de nível de classe a serem verificadas quanto à ausência._ 156 | - `name`: _Define os nomes de beans a serem verificados quanto à ausência._ 157 | - `search`: _Estratégia para considerar a hierarquia do contexto da aplicação._ 158 | - `parameterizedContainer`: _Classes adicionais que podem conter os tipos de beans especificados nos seus parâmetros genéricos (desde a versão 2.1.0)._ 159 | 160 | ${\color{yellow}@ConditionalOnMissingClass}$ : _@ConditionalOnMissingClass é uma anotação do Spring Boot que ativa um componente somente se uma ou mais classes especificadas não estiverem presentes no classpath._ 161 | 162 | **Parâmetros:** 163 | 164 | - `value`: _Especifica os tipos de classes a serem verificados quanto à ausência._ 165 | 166 | ${\color{yellow}@ConditionalOnMissingFilterBean}$ : _@ConditionalOnMissingFilterBean é uma anotação de condição no Spring Boot que verifica se não existe um bean de filtro específico no contexto da aplicação. Isso permite personalizar a configuração de filtros, garantindo que um filtro personalizado seja aplicado apenas se nenhum filtro com o mesmo nome estiver presente._ 167 | 168 | ${\color{yellow}@ConditionalOnNotWarDeployment}$ : _@ConditionalOnMissingClass ativa um componente somente se o app Spring não estiver a ser implantado como um arquivo **WAR**._ 169 | 170 | ${\color{yellow}@ConditionalOnNotWebApplication}$ : _@ConditionalOnNotWebApplication ativa um componente somente se o app Spring não for uma aplicação da web._ 171 | 172 | ${\color{yellow}@ConditionalOnProperty}$ : _@ConditionalOnProperty ativa um componente com base na presença ou valor de uma propriedade de configuração._ 173 | 174 | **Parâmetros:** 175 | 176 | - `prefix`: _Um prefixo que deve ser aplicado a cada propriedade._ 177 | - `name`: _O nome das propriedades a serem testadas, com suporte para notação de traço._ 178 | - `havingValue`: _A representação em string do valor esperado para as propriedades._ 179 | - `matchIfMissing`: _Especifica se a condição deve corresponder quando a propriedade está ausente._ 180 | 181 | ${\color{yellow}@ConditionalOnRepositoryType}$ : _@ConditionalOnRepositoryType é uma anotação que condiciona a configuração de beans com base no tipo de repositório especificado, como CASSANDRA, MONGODB ou Neo4j. Isso permite ajustar o comportamento com base no armazenamento de dados escolhido._ 182 | 183 | **Parâmetros:** 184 | 185 | - `store`: _Especifica o nome do armazenamento de dados, como "cassandra", "couchbase", "mongodb" ou "neo4j", que respalda os repositórios._ 186 | - `type`: _Define o tipo de repositório necessário, como RepositoryType.AUTO, RepositoryType.IMPERATIVE, RepositoryType.NONE ou RepositoryType.REACTIVE._ 187 | 188 | ${\color{yellow}@ConditionalOnResource}$ : _@ConditionalOnResource é uma anotação de condição no Spring que ativa uma configuração se um determinado recurso estiver no classpath._ 189 | 190 | **Parâmetros:** 191 | 192 | - `resources`: _Uma ou mais localizações de recursos que devem existir no classpath. A configuração só será ativada se pelo menos uma dessas localizações existir._ 193 | 194 | ${\color{yellow}@ConditionalOnSingleCandidate}$ : _@ConditionalOnSingleCandidate é uma anotação de condição do Spring que ativa a configuração se houver exatamente um candidato (bean) apropriado no contexto do aplicativo._ 195 | 196 | **Parâmetros:** 197 | 198 | - `type`: _O tipo do bean candidato._ 199 | - `search`: _Estratégia para considerar o contexto da hierarquia do aplicativo. Por default o valor utilizado é **SearchStrategy.ALL**._ 200 | 201 | ${\color{yellow}@ConditionalOnWarDeployment}$ : _@ConditionalOnWarDeployment é uma anotação do Spring Boot que ativa a configuração somente quando o aplicativo está sendo implantado como um arquivo **WAR** (Web Application Archive). Ela permite que a configuração seja condicional com base no tipo de implantação._ 202 | 203 | ${\color{yellow}@ConditionalOnWebApplication}$ : _@ConditionalOnWebApplication é uma anotação do Spring Boot que ativa a configuração apenas quando o aplicativo é uma aplicação web, como uma Servlet ou uma aplicação Spring MVC._ 204 | 205 | **Parâmetros:** 206 | 207 | - `type`: _Define o tipo de aplicação web, sendo **ANY** , **SERVLET** ou **REACTIVE**._ 208 | 209 | ${\color{yellow}@ConfigurationProperties}$ : _@ConfigurationProperties mapeia propriedades de configuração definidas em arquivos de propriedades ou YAML para objetos Java._ 210 | 211 | **Parâmetros:** 212 | 213 | - `prefix`: O prefixo das propriedades a serem vinculadas. 214 | - `ignoreInvalidFields`: Sinalizador para indicar que, ao vincular a este objeto, campos inválidos devem ser ignorados. 215 | - `ignoreUnknownFields`: Sinalizador para indicar que, ao vincular a este objeto, campos desconhecidos devem ser ignorados. 216 | 217 | ${\color{yellow}@ConfigurationPropertiesBinding}$ : _@ConfigurationPropertiesBinding é uma anotação do Spring Boot usada para criar conversores personalizados para propriedades de configuração._ 218 | 219 | ${\color{yellow}@ConfigurationPropertiesScan}$ : _@ConfigurationPropertiesScan é uma anotação do Spring Boot usada para escanear pacotes em busca de classes de propriedades de configuração._ 220 | 221 | **Parâmetros:** 222 | 223 | - `basePackages`: _Path de pacotes do projeto para verificar propriedades de configuração._ 224 | - `basePackageClasses`: _Alternativa ("Type-safe") especificando os pacotes para verificar as propriedades de configuração. O pacote de cada classe especificada será verificado._ 225 | 226 | ${\color{yellow}@ConstructorBinding}$ : _@ConstructorBinding é uma anotação do Spring Boot que indica a vinculação de propriedades de configuração a construtores, facilitando a criação de objetos imutáveis._ 227 | 228 | ${\color{yellow}@DefaultValue}$ : _@DefaultValue é uma anotação do Spring Boot que pode ser usada para especificar o valor padrão ao vincular a uma propriedade imutável. Essa anotação também pode ser usada com propriedades aninhadas para indicar que um valor deve sempre ser vinculado (em vez de vincular nulo). O valor desta anotação só será utilizado se a propriedade não for encontrada nas fontes de propriedades utilizadas pelo **Binder**._ 229 | 230 | **Parâmetros:** 231 | 232 | - `value`: _O valor padrão da propriedade. Pode ser uma matriz de valores para propriedades de coleção ou baseadas em matriz._ 233 | 234 | ${\color{yellow}@DataSizeUnit}$ : _@DataSizeUnit é uma anotação do Spring Boot que pode ser usada para alterar a unidade padrão usada ao converter um DataSize._ 235 | 236 | **Parâmetros:** 237 | 238 | - `value`: _O **DataUnit** a ser usado se nenhum for especificado._ 239 | 240 | ${\color{yellow}@DeprecatedConfigurationProperty}$ : _@DeprecatedConfigurationProperty é uma anotação do Spring Boot usada para marcar propriedades de configuração como obsoletas e fornecer uma mensagem de aviso quando são usadas._ 241 | 242 | **Parâmetros:** 243 | 244 | - `reason`: _O motivo da descontinuação._ 245 | - `replacement`: _O valor que deve ser usado (se houver)._ 246 | 247 | ${\color{yellow}@DependsOnDatabaseInitialization}$ : _@DependsOnDatabaseInitialization é uma anotação do Spring Boot que define que um bean depende da inicialização do banco de dados, garantindo que a inicialização do banco de dados seja concluída antes do bean ser criado._ 248 | 249 | ${\color{yellow}@Delimiter}$ : _@Delimiter é uma anotação do Spring Boot que permite definir um delimitador personalizado para valores de propriedades de configuração, especialmente útil ao lidar com listas em propriedades._ 250 | 251 | **Parâmetros:** 252 | 253 | - `value`: _O delimitador a ser usado ou **NONE** se todo o conteúdo precisar ser tratado como um único elemento._ 254 | 255 | ${\color{yellow}@DurationFormat}$ : _@DurationFormat é uma anotação do Spring Boot que permite personalizar o formato de durações, como as usadas em propriedades de configuração, para facilitar a leitura e escrita._ 256 | 257 | **Parâmetros:** 258 | 259 | - `value`: _O estilo do formato de duração._ 260 | 261 | ${\color{yellow}@EnableAutoConfiguration}$ : _@EnableAutoConfiguration é uma anotação do Spring Boot que ativa a configuração automática, permitindo que o Spring Boot configure automaticamente o aplicativo com base nas dependências e no ambiente._ 262 | 263 | **Parâmetros:** 264 | 265 | - `exclude`: _Especifica classes de configuração automática a serem excluídas._ 266 | - `excludeName`: _Especifica nomes de classes de configuração automática a serem excluídos. (Adicionado na versão 1.3.0)._ 267 | 268 | ${\color{yellow}@EnableConfigurationProperties}$ : _@EnableConfigurationProperties é uma anotação do Spring Boot usada para habilitar a vinculação automática de propriedades de configuração a classes de configuração._ 269 | 270 | **Parâmetros:** 271 | 272 | - `value`: _Maneira conveniente de registrar rapidamente beans anotados **@ConfigurationProperties** com Spring._ 273 | 274 | ${\color{yellow}@EntityScan}$ : _@EntityScan é uma anotação usada no Spring para escanear e identificar classes de entidade JPA em um pacote específico ou seus subpacotes, permitindo que o Spring Boot encontre e gerencie entidades persistentes._ 275 | 276 | **Parâmetros:** 277 | 278 | - `basePackages`: _Path de pacotes do projeto para verificar propriedades de configuração._ 279 | - `basePackageClasses`: _Alternativa ("Type-safe") especificando os pacotes para verificar as propriedades de configuração. O pacote de cada classe especificada será verificado._ 280 | 281 | ${\color{yellow}@FlywayDataSource}$ : _@FlywayDataSource é uma anotação no Spring Boot que permite configurar um data source separado exclusivamente para o Flyway, uma ferramenta de migração de banco de dados. Isso é útil para separar a fonte de dados usada para migrações de banco de dados da fonte de dados principal da aplicação._ 282 | 283 | ${\color{yellow}@ImportAutoConfiguration}$ : _@ImportAutoConfiguration é uma anotação do Spring Boot que permite importar classes de configuração automática personalizada para o aplicativo Spring Boot, estendendo as configurações padrão._ 284 | 285 | **Parâmetros:** 286 | 287 | - `value / classes`: _Especifica classes de configuração automática personalizada a serem importadas. Pode ser definido diretamente ou por meio de um arquivo no **META-INF/spring** que lista as classes a serem importadas._ 288 | - `exclude`: _Especifica classes de configuração automática a serem excluídas, garantindo que não sejam aplicadas._ 289 | 290 | ${\color{yellow}@JsonComponent}$ : _@JsonComponent é uma anotação do Spring Boot usada para registrar um componente como um manipulador de serialização e desserialização JSON, permitindo personalizar a forma como objetos são convertidos para JSON e vice-versa._ 291 | 292 | **Parâmetros:** 293 | 294 | - `value`: _Indica um nome lógico sugerido para o componente e pode ser convertido em um **bean**. Padrão é uma ‘string’ vazia._ 295 | - `type`: _Define os tipos que o componente manipula para serialização/desserialização. Essa configuração é especialmente importante para deserializadores de chaves (**KeyDeserializer**) e pode ser usada para limitar o tratamento a subclasses de tipos inferidos._ 296 | - `scope`: _Especifica o escopo sob o qual o serializador/desserializador deve ser registrado com o módulo. O valor padrão é **Scope.VALUES**, que se aplica a serializadores/desserializadores de conteúdo de valor. O escopo **Scope.KEYS** pode ser usado para serializadores/desserializadores de chaves._ 297 | 298 | ${\color{yellow}@JsonMixin}$ : _@JsonMixin é uma anotação que permite criar uma classe que define anotações personalizadas para controlar como objetos são convertidos em JSON ou de JSON para objetos, aplicando essas anotações a classes específicas. Isso facilita a personalização da serialização e desserialização JSON._ 299 | 300 | **Parâmetros:** 301 | 302 | - `value`: _Permite especificar as classes que serão usadas como classes de mistura (mixin classes) para controlar a serialização e desserialização de objetos JSON._ 303 | 304 | ${\color{yellow}@LiquibaseDataSource}$ : _@LiquibaseDataSource é uma anotação usada no Spring Boot para configurar um DataSource específico para o Liquibase, uma ferramenta de controle de versionamento de banco de dados. Isso permite que você defina um DataSource separado para as migrações do Liquibase em relação ao DataSource principal da aplicação._ 305 | 306 | ${\color{yellow}@Name}$ : _@Name é uma anotação do Spring Boot que pode ser usada para especificar o nome ao vincular a uma propriedade imutável._ 307 | 308 | **Parâmetros:** 309 | 310 | - `value`: _O nome da propriedade a ser usada para associação._ 311 | 312 | ${\color{yellow}@Nested}$ : _@Nested é uma meta-anotação do Spring Boot que deve ser adicionada às anotações que indicam que um campo é do tipo aninhado. Usado para garantir que as dicas de reflexão corretas sejam registradas._ 313 | 314 | ${\color{yellow}@NestedConfigurationProperty}$ : _@NestedConfigurationProperty é uma anotação do Spring Boot usada para indicar que uma propriedade de configuração complexa está aninhada dentro de outra propriedade de configuração._ 315 | 316 | ${\color{yellow}@PeriodFormat}$ : _@PeriodFormat é uma anotação do Spring Boot que permite personalizar o formato de períodos, como os usados em propriedades de configuração, para facilitar a leitura e escrita._ 317 | 318 | **Parâmetros:** 319 | 320 | - `value`: _O estilo de formato do período._ 321 | 322 | ${\color{yellow}@PeriodUnit}$ : _@PeriodUnit é uma anotação do Spring Boot que permite definir a unidade padrão para valores de período em propriedades de configuração, simplificando a configuração._ 323 | 324 | **Parâmetros:** 325 | 326 | - `value`: _A unidade de período a ser usada se nenhuma for especificada._ 327 | 328 | ${\color{yellow}@QuartzDataSource}$ : _@QuartzDataSource anotação de um DataSource a ser injetado na configuração automática do Quartz. Pode ser usado numa fonte de dados secundária, caso exista outra marcada como @Primary._ 329 | 330 | ${\color{yellow}@QuartzTransactionManager}$ : _@QuartzTransactionManager anotação de TransactionManager a ser injetado na configuração automática do Quartz. Pode ser utilizado em um gerenciador de transações secundário, caso exista outro marcado como @Primary._ 331 | 332 | ${\color{yellow}@ServletComponentScan}$ : _@ServletComponentScan é uma anotação do Spring Boot usada para escanear pacotes em busca de classes Servlet, Filter e Listener para configuração automática no contexto do aplicativo web._ 333 | 334 | **Parâmetros:** 335 | 336 | - `basePackages`: _Path de pacotes do projeto para verificar propriedades de configuração._ 337 | - `basePackageClasses`: _Alternativa ("Type-safe") especificando os pacotes para verificar as propriedades de configuração. O pacote de cada classe especificada será verificado._ 338 | 339 | ${\color{yellow}@SpringBootApplication}$ : _@SpringBootApplication diz ao Spring Boot que essa classe deverá ser usada como base para configurar toda nossa aplicação._ 340 | 341 | **Parâmetros:** 342 | 343 | - `exclude`: Uma matriz de classes de configuração para serem excluídas da configuração automática. 344 | - `excludeName`: Uma matriz de nomes de classes de configuração para serem excluídas da configuração automática. 345 | - `scanBasePackages`: Um ou mais pacotes para serem escaneados em busca de componentes anotados. 346 | - `scanBasePackageClasses`: Uma ou mais classes que servem como base para a varredura de pacotes em busca de componentes anotados. 347 | - `nameGenerator`: Uma classe para gerar nomes de beans automaticamente. 348 | - `proxyBeanMethods`: Uma configuração que controla se os métodos de bean devem ser proxy por CGLIB. 349 | 350 | ${\color{yellow}@SpringBootConfiguration}$ : _@SpringBootConfiguration é uma anotação do Spring Boot usada para marcar classes de configuração específicas do aplicativo. Ela estende a anotação @Configuration do Spring Framework._ 351 | 352 | **Parâmetros:** 353 | 354 | - `proxyBeanMethods`: _Sinalizador que controla se os métodos de bean devem ser proxy por CGLIB. Por padrão, ele é definido como true. Se definido como false, os métodos de bean não serão proxy._ 355 | 356 | ## Spring-cloud-aws 357 | 358 | ${\color{yellow}@ AutoConfigureSqs}$ : _@AutoConfigureSqs é usada para importar automaticamente as configurações do Amazon Simple Queue Service (SQS) em testes típicos. Ela simplifica a configuração de testes relacionados ao SQS no Spring Boot. É frequentemente usada em conjunto com @SqsTest para testes mais específicos relacionados ao SQS._ 359 | 360 | ${\color{yellow}@NotificationMessage}$ : _@NotificationMessage é usada para mapear o valor de notificação do Amazon Simple Notification Service (SNS) para uma variável anotada em métodos de controladores. Isso é comumente usado para lidar com a recepção de notificações do SNS em métodos de controle._ 361 | 362 | ${\color{yellow}@NotificationMessageMapping}$ : _@NotificationMessageMapping é uma anotação para mapear métodos que tratam notificações Amazon SNS em controladores Spring, permitindo que os métodos processem mensagens de notificação de forma eficiente em URLs mapeadas._ 363 | 364 | **Parâmetros:** 365 | 366 | - `path`: _Permite que você defina os caminhos que correspondem a esse mapeamento._ 367 | 368 | ${\color{yellow}@NotificationSubject}$ : _@NotificationSubject é usada para pegar o assunto de uma notificação enviada pelo Amazon Simple Notification Service (SNS) e vinculá-lo a uma variável em um método de um controlador. Isso permite que você acesse o assunto da notificação de forma direta e simples em seu código._ 369 | 370 | ${\color{yellow}@NotificationSubscriptionMapping}$ : _@NotificationSubscriptionMapping é usada para mapear um método de um controlador Spring para lidar com solicitações de confirmação de inscrição SNS (Simple Notification Service) quando o cabeçalho da solicitação x-amz-sns-message-type é definido como "SubscriptionConfirmation" e o método HTTP usado é o POST. Além disso, ele define que a resposta a ser enviada deve ter um status HTTP "NO_CONTENT"._ 371 | 372 | **Parâmetros:** 373 | 374 | - `path`: _Permite que você defina os caminhos que correspondem a esse mapeamento._ 375 | 376 | ${\color{yellow}@NotificationUnsubscribeConfirmationMapping}$ : _@NotificationUnsubscribeConfirmationMapping configura um método para receber notificações de cancelamento de inscrição em um endpoint Amazon SNS._ 377 | 378 | **Parâmetros:** 379 | 380 | - `path`: _Permite que você defina os caminhos que correspondem a esse mapeamento._ 381 | 382 | ${\color{yellow}@SqsListener}$ : _@SqsListener é usada para configurar métodos que processam mensagens em filas do Amazon Simple Queue Service (SQS)._ 383 | 384 | **Parâmetros:** 385 | 386 | - `value \ queueNames`: _Especifica os nomes das filas ou URLs que serão ouvidos por este método. Você pode definir uma ou mais filas separadas por vírgulas para que o método processe mensagens de várias filas._ 387 | - `factory`: _Permite especificar o nome de um bean que será usado para criar o MessageListenerContainer para lidar com esse endpoint. É útil se você deseja usar uma configuração personalizada para o contêiner. Por padrão, ele procurará um bean adequado no contexto._ 388 | - `id`: _Define um identificador para o MessageListenerContainer criado para lidar com esse endpoint. Se você não fornecer um, um identificador padrão será gerado automaticamente._ 389 | - `maxConcurrentMessages`: _Define o número máximo de mensagens que podem ser processadas simultaneamente para cada fila. Isso controla quantas mensagens o seu método pode lidar de uma só vez._ 390 | - `pollTimeoutSeconds`: _Especifica o tempo máximo em segundos que o método aguardará por mensagens numa chamada busca ao SQS._ 391 | - `maxMessagesPerPoll`: _Define o número máximo de mensagens que podem ser buscadas de uma só vez. Esse valor é útil ao trabalhar com filas SQS com mensagens agrupadas._ 392 | - `messageVisibilitySeconds`: _Controla o tempo de visibilidade das mensagens. Isso define quanto tempo as mensagens serão invisíveis após serem recebidas. Isso é útil para garantir que as mensagens não sejam processadas por vários consumidores ao mesmo tempo._ 393 | 394 | ${\color{yellow}@SqsTest}$ : _@SqsTest é usada para testar componentes que se concentram apenas em funcionalidades baseadas em SQS._ 395 | 396 | **Parâmetros:** 397 | 398 | - `useDefaultFilters`: _Define se os filtros padrão devem ser usados em conjunto com a anotação @SpringBootApplication. Você pode configurar essa opção para incluir ou excluir determinados beans ao testar suas funcionalidades SQS._ 399 | - `listeners`: _Especifica as classes de ouvintes a serem testadas. Isso permite que você se concentre nos ouvintes relevantes para o teste._ 400 | - `properties`: _Permite que você adicione propriedades no formato "chave=valor" ao ambiente do Spring antes da execução do teste._ 401 | - `includeFilters \ excludeFilters`: _Filtros que podem ser usados para incluir ou excluir beans do contexto de aplicação. Isso é útil para personalizar o ambiente de teste._ 402 | 403 | ## Spring-cloud-openfeign 404 | 405 | ${\color{yellow}@CollectionFormat}$ : _@CollectionFormat é usada para indicar qual formato de coleção deve ser usado ao processar um método anotado._ 406 | 407 | **Parâmetros:** 408 | 409 | - `value`: _Permite definir o formato de coleção a ser usado ao processar o método anotado. Você pode especificar o formato desejado, escolhendo entre as opções fornecidas no enum feign.CollectionFormat (ex: CSV ou SSV)_ 410 | 411 | ${\color{yellow}@EnableFeignClients}$ : _@EnableFeignClients é usada para ativar a varredura de interfaces que declaram ser clientes Feign._ 412 | 413 | **Parâmetros:** 414 | 415 | - `basePackages`: _Path de pacotes do projeto para verificar propriedades de configuração._ 416 | - `basePackageClasses`: _Alternativa ("Type-safe") especificando os pacotes para verificar as propriedades de configuração. O pacote de cada classe especificada será verificado._ 417 | - `defaultConfiguration`: _Permite definir uma configuração personalizada para todos os clientes Feign. Você pode incluir definições de bean de substituição, como decodificadores, codificadores e contratos, para cada cliente Feign. Veja FeignClientsConfiguration para as configurações padrão._ 418 | - `clients`: _Lista de classes anotadas com @FeignClient. Quando não estiver vazia, desabilita a varredura no classpath. É útil quando você deseja especificar explicitamente quais classes devem ser tratadas como clientes Feign, em vez de varrer todo o classpath._ 419 | 420 | ${\color{yellow}@FeignClient}$ : _@FeignClient é usada para declarar que uma interface representa um cliente REST Feign._ 421 | 422 | **Parâmetros:** 423 | 424 | - `name`: _Especifica o nome do serviço com um prefixo de protocolo opcional. Você deve especificar um nome para todos os clientes, independentemente de uma URL ser fornecida._ 425 | - `contextId`: _Define o nome do bean que será usado em vez de "name", mas não será usado como um ID de serviço._ 426 | - `qualifiers`: _Especifica os qualificadores @Qualifiers para o cliente Feign._ 427 | - `url`: _Permite especificar uma URL absoluta ou um nome de host resolvível (o protocolo é opcional)._ 428 | - `dismiss404`: _Indica se as respostas 404 devem ser decodificadas em vez de gerar exceções Feign._ 429 | - `configuration`: _Permite definir uma classe de configuração personalizada para o cliente Feign. Essa classe pode conter definições de beans de substituição, como decodificadores, codificadores e contratos._ 430 | - `fallback`: _Define a classe de fallback para a interface do cliente Feign especificada. A classe de fallback deve implementar a interface anotada com @FeignClient e ser um bean Spring válido._ 431 | - `fallbackFactory`: _Define uma fábrica de fallback para a interface do cliente Feign especificada. A fábrica de fallback deve produzir instâncias das classes de fallback que implementam a interface anotada com @FeignClient. Consulte FallbackFactory para obter detalhes._ 432 | - `path`: _Especifica um prefixo de caminho a ser usado por todas as correspondências de nível de método._ 433 | - `primary`: _Indica se o proxy Feign deve ser marcado como um bean primário. O valor padrão é verdadeiro, o que significa que o proxy Feign será o bean primário._ 434 | 435 | ${\color{yellow}@SpringQueryMap}$ : _@SpringQueryMap é a versão Spring MVC equivalente à anotação @QueryMap do OpenFeign. Ela é usada para mapear parâmetros de consulta de solicitação para um método de um controlador Spring. Isso é útil quando você deseja usar um objeto para representar os parâmetros de consulta em vez de anotar cada parâmetro individualmente. A anotação @SpringQueryMap é aplicada a um parâmetro do método e permite que você use um objeto para coletar todos os parâmetros de consulta da solicitação._ 436 | 437 | ## Spring-context 438 | 439 | ${\color{yellow}@ Async}$ : _@Async é usada para marcar um método como candidato à execução assíncrona._ 440 | 441 | **Parâmetros:** 442 | 443 | - `value`: _Usado para especificar um valor de qualificador para operações assíncronas específicas._ 444 | 445 | ${\color{yellow}@Bean}$ : _@Bean é usada para indicar que um método produz um bean a ser gerenciado pelo contêiner Spring._ 446 | 447 | **Parâmetros:** 448 | 449 | - `value \ name`: _Você pode especificar um nome ou vários nomes para o bean._ 450 | - `autowireCandidate`: _Permite determinar se o bean é um candidato para ser injetado em outros beans por padrão. O valor padrão é true._ 451 | - `initMethod`: _Permite especificar o nome de um método que será chamado no bean durante a inicialização._ 452 | - `destroyMethod`: _Permite especificar o nome de um método que será chamado no bean quando o contexto do aplicativo for fechado._ 453 | 454 | ${\color{yellow}@Cacheable}$ : _@Cacheable é usada para definir o comportamento de armazenamento em cache para os métodos anotados e permite que você ajuste o comportamento de armazenamento em cache com base em várias condições e configurações personalizadas._ 455 | 456 | **Parâmetros:** 457 | 458 | - `value \ cacheNames`: _Permite especificar o nome ou os nomes das caches onde os resultados das invocações do método serão armazenados._ 459 | - `key`: _Permite especificar uma expressão Spring Expression Language (SpEL) para calcular a chave dinamicamente para cada invocação do método._ 460 | - `keyGenerator`: _Permite especificar o nome de um KeyGenerator personalizado que será usado para gerar as chaves. É mutuamente exclusivo com o atributo key._ 461 | - `cacheManager`: _Permite especificar o nome de um CacheManager personalizado que será usado para criar um **CacheResolver** padrão se nenhum estiver configurado._ 462 | - `cacheResolver`: _Permite especificar o nome de um **CacheResolver** personalizado que será usado para determinar o cache para a invocação do método._ 463 | - `condition`: _Permite especificar uma expressão SpEL que determina se a invocação do método deve ser armazenada em cache ou não._ 464 | - `unless`: _Permite especificar uma expressão SpEL que veta o armazenamento em cache se a condição avaliada for true._ 465 | - `sync`: _Permite sincronizar a invocação do método se várias threads estiverem tentando carregar um valor para a mesma chave. A sincronização pode ser usada para evitar que várias threads executem a mesma invocação simultaneamente._ 466 | 467 | ${\color{yellow}@CacheConfig}$ : _@CacheConfig é usada para definir configurações padrão de cache em nível de classe._ 468 | 469 | **Parâmetros:** 470 | 471 | - `cacheNames`: _Permite especificar o nome ou os nomes das caches onde os resultados das invocações do método serão armazenados._ 472 | - `keyGenerator`: _Permite especificar o nome de um KeyGenerator personalizado que será usado para gerar as chaves. É mutuamente exclusivo com o atributo key._ 473 | - `cacheManager`: _Permite especificar o nome de um CacheManager personalizado que será usado para criar um **CacheResolver** padrão se nenhum estiver configurado._ 474 | - `cacheResolver`: _Permite especificar o nome de um **CacheResolver** personalizado que será usado para determinar o cache para a invocação do método._ 475 | 476 | ${\color{yellow}@CacheEvict}$ : _@CacheEvict é usada para indicar que um método ou todos os métodos numa classe acionam operações de esvaziamento da cache._ 477 | 478 | **Parâmetros:** 479 | 480 | - `cacheNames`: _Permite especificar o nome ou os nomes das caches onde os resultados das invocações do método serão armazenados._ 481 | - `key`: _Permite especificar uma expressão Spring Expression Language (SpEL) para calcular a chave dinamicamente para cada invocação do método._ 482 | - `keyGenerator`: _Permite especificar o nome de um KeyGenerator personalizado que será usado para gerar as chaves. É mutuamente exclusivo com o atributo key._ 483 | - `cacheManager`: _Permite especificar o nome de um CacheManager personalizado que será usado para criar um **CacheResolver** padrão se nenhum estiver configurado._ 484 | - `cacheResolver`: _Permite especificar o nome de um **CacheResolver** personalizado que será usado para determinar o cache para a invocação do método._ 485 | - `condition`: _Permite especificar uma expressão SpEL que determina se a invocação do método deve ser armazenada em cache ou não._ 486 | - `unless`: _Especifica se todas as entradas dentro do cache devem ser removidas._ 487 | - `beforeInvocation`: _Especifica se a operação de esvaziamento da cache deve ocorrer antes da invocação do método._ 488 | 489 | ${\color{yellow}@CachePut}$ : _@CachePut é usada para indicar que um método ou todos os métodos numa classe acionam operações de armazenamento em cache, que armazenam os resultados do método nas caches especificadas._ 490 | 491 | **Parâmetros:** 492 | 493 | - `cacheNames`: _Permite especificar o nome ou os nomes das caches onde os resultados das invocações do método serão armazenados._ 494 | - `keyGenerator`: _Permite especificar o nome de um KeyGenerator personalizado que será usado para gerar as chaves. É mutuamente exclusivo com o atributo key._ 495 | - `cacheManager`: _Permite especificar o nome de um CacheManager personalizado que será usado para criar um **CacheResolver** padrão se nenhum estiver configurado._ 496 | - `cacheResolver`: _Permite especificar o nome de um **CacheResolver** personalizado que será usado para determinar o cache para a invocação do método._ 497 | - `condition`: _Permite especificar uma expressão SpEL que determina se a invocação do método deve ser armazenada em cache ou não._ 498 | - `unless`: _Permite especificar uma expressão SpEL que veta o armazenamento em cache se a condição avaliada for true._ 499 | 500 | ${\color{yellow}@Caching}$ : _@Caching é uma anotação de agrupamento para várias anotações de cache, sejam elas do mesmo tipo (por exemplo, várias anotações @Cacheable) ou de tipos diferentes (por exemplo, @Cacheable, @CachePut e @CacheEvict). Essa anotação permite que você defina várias operações de cache em um único local._ 501 | 502 | **Parâmetros:** 503 | 504 | - `cacheable`: _Permite que você especifique uma ou mais anotações @Cacheable que descrevem as operações de cache de leitura (ou seja, quando um valor é buscado em uma cache)._ 505 | - `put`: _Permite que você especifique uma ou mais anotações @CachePut que descrevem as operações de cache de gravação (ou seja, quando um valor é armazenado em uma cache)._ 506 | - `evict`: _Permite que você especifique uma ou mais anotações @CacheEvict que descrevem as operações de evicção de cache (ou seja, quando um valor é removido de uma cache)._ 507 | 508 | ${\color{yellow}@Component}$ : _@Component é uma anotação do Spring ‘Framework’ que indica que uma classe anotada é um "componente". Os componentes são considerados candidatos para detecção automática quando se utiliza configuração baseada em anotações e digitalização do classpath._ 509 | 510 | **Parâmetros:** 511 | 512 | - `value`: _Permite fornecer uma sugestão para um nome lógico do componente._ 513 | 514 | ${\color{yellow}@ComponentScan}$ : _@ComponentScan é usada para configurar diretivas de varredura de componentes para classes anotadas com @Configuration._ 515 | 516 | **Parâmetros:** 517 | 518 | - `basePackages`: _Path de pacotes do projeto para verificar propriedades de configuração._ 519 | - `basePackageClasses`: _Alternativa ("Type-safe") especificando os pacotes para verificar as propriedades de configuração. O pacote de cada classe especificada será verificado._ 520 | - `nameGenerator`: _A classe **BeanNameGenerator** a ser usada para nomear os componentes detectados no contêiner Spring._ 521 | - `scopeResolver`: _A classe **ScopeMetadataResolver** a ser usada para resolver o escopo dos componentes detectados._ 522 | - `scopedProxy`: _Controla a geração de proxies para os componentes detectados, o que pode ser necessário quando se usam escopos no estilo de proxy._ 523 | - `resourcePattern`: _Controla quais arquivos de classe são elegíveis para a detecção de componentes._ 524 | - `useDefaultFilters`: _Indica se a detecção automática de classes anotadas com @Component, @Repository, @Service ou @Controller deve ser ativada._ 525 | - `includeFilters \ excludeFilters`: _Filtros que podem ser usados para incluir ou excluir beans do contexto de aplicação. Isso é útil para personalizar o ambiente de teste._ 526 | - `lazyInit`: _Especifica se os beans escaneados devem ser registrados para inicialização tardia. O padrão é false._ 527 | 528 | ${\color{yellow}@ComponentScans}$ : _@ComponentScans é uma anotação de contêiner que agrega várias anotações @ComponentScan. Ela pode ser usada para declarar várias anotações @ComponentScan agrupadas, permitindo que você configure várias diretivas de varredura de componentes em uma única classe de configuração._ 529 | 530 | **Parâmetros:** 531 | 532 | - `value`: _Usado para especificar uma ou mais anotações @ComponentScan que contêm as configurações de varredura de componentes._ 533 | 534 | ${\color{yellow}@Conditional}$ : _@Conditional é usada no Spring Framework para controlar a condição sob a qual um componente é registrado no contêiner de aplicativos. Isso permite que você registre componentes somente quando determinadas condições são atendidas._ 535 | 536 | **Parâmetros:** 537 | 538 | - `value`: _Permite que todas as classes de condição que devem corresponder para que o componente seja registrado. 539 | 540 | ${\color{yellow}@Configuration}$ : _@Configuration é usada no Spring Framework para marcar uma classe como uma classe de configuração._ 541 | 542 | **Parâmetros:** 543 | 544 | - `value`: _Atributo permite que você especifique explicitamente o nome da definição de bean do Spring associada à classe @Configuration._ 545 | - `proxyBeanMethods`: _(desde a versão 5.2) Este atributo controla se os métodos @Bean dentro da classe @Configuration devem ser proxy, a fim de garantir o comportamento do ciclo de vida do bean._ 546 | - `enforceUniqueMethods`: _(desde a versão 6.0) Controla se os métodos @Bean devem ter nomes de métodos exclusivos._ 547 | 548 | ${\color{yellow}@Controller}$ : _@Controller indica que a classe é um controlador, o que significa que ela lida com solicitações da web, processa as solicitações e fornece respostas apropriadas._ 549 | 550 | **Parâmetros:** 551 | 552 | - `value`: _Sugere um nome lógico para o componente que será registrado no contêiner Spring._ 553 | 554 | ${\color{yellow}@DependsOn}$ : _@DependsOn é usada para controlar explicitamente a ordem de inicialização e, para beans singleton, a ordem de destruição dos beans no contexto do Spring._ 555 | 556 | ${\color{yellow}@Description}$ : _@Description é usada no contexto do Spring Framework para adicionar uma descrição textual a definições de beans derivados de classes anotadas com @Component ou de métodos anotados com @Bean._ 557 | 558 | **Parâmetros:** 559 | 560 | - `value`: _Descrição textual que você deseja associar ao bean._ 561 | 562 | ${\color{yellow}@DateTimeFormat}$ : _@DateTimeFormat é usada no Spring Framework para declarar como um campo, parâmetro de método ou atributo de anotação deve ser formatado como data ou hora._ 563 | 564 | **Parâmetros:** 565 | 566 | - `style`: _Define o estilo de formatação da data ou hora. O valor padrão é "SS" para um estilo de data curto e hora curta._ 567 | - `iso`: _Define o formato ISO da data ou hora. Os formatos ISO suportados são definidos na enumeração ISO. O valor padrão é ISO.NONE, indicando que esse atributo deve ser ignorado._ 568 | - `pattern`: _Permite especificar um padrão de formato personalizado para a data ou hora. O padrão segue o estilo do **SimpleDateFormat**._ 569 | - `fallbackPatterns`: _Define um conjunto de padrões personalizados de fallback em caso de falha na conversão usando o padrão principal, ISO ou estilo. Isso é útil quando você deseja permitir formatações flexíveis para entrada de usuário._ 570 | 571 | ${\color{yellow}@EnableAsync}$ : _@EnableAsync é usada no Spring Framework para habilitar a capacidade de execução assíncrona de métodos._ 572 | 573 | **Parâmetros:** 574 | 575 | - `annotation`: _Permite indicar o tipo de anotação de "async" que deve ser detectada em nível de classe ou método. Por padrão, o Spring detectará tanto a anotação @Async do Spring._ 576 | - `proxyTargetClass`: _Controla se proxies baseados em classes (CGLIB) devem ser criados em oposição a proxies baseados em ‘interfaces’ padrão do Java._ 577 | - `mode`: _Indica como o conselho assíncrono deve ser aplicado. O padrão é AdviceMode.PROXY, que permite a interceptação de chamadas por meio do proxy._ 578 | - `order`: _Controla a ordem em que o AsyncAnnotationBeanPostProcessor deve ser aplicado. O padrão é **Ordered.LOWEST_PRECEDENCE**._ 579 | 580 | ${\color{yellow}@EnableAspectJAutoProxy}$ : _@EnableAspectJAutoProxy é usada para habilitar o suporte ao tratamento de componentes marcados com a anotação @Aspect do AspectJ._ 581 | 582 | **Parâmetros:** 583 | 584 | - `proxyTargetClass`: _Controla se proxies baseados em classes (CGLIB) devem ser criados em oposição a proxies baseados em ‘interfaces’ padrão do Java._ 585 | - `exposeProxy`: _Indica se o proxy deve ser exposto pelo ‘framework’ AOP como um ThreadLocal para recuperação por meio da classe AopContext do Spring._ 586 | 587 | ${\color{yellow}@EnableCaching}$ : _@EnableCaching é usada para habilitar o suporte à gestão de cache baseado em anotações no Spring._ 588 | 589 | **Parâmetros:** 590 | 591 | - `proxyTargetClass`: _Controla se proxies baseados em classes (CGLIB) devem ser criados em oposição a proxies baseados em ‘interfaces’ padrão do Java._ 592 | - `mode`: _Indica como o conselho assíncrono deve ser aplicado. O padrão é AdviceMode.PROXY, que permite a interceptação de chamadas por meio do proxy._ 593 | - `order`: _Indica como o aconselhamento de cache deve ser aplicado. O padrão é AdviceMode.PROXY._ 594 | 595 | ${\color{yellow}@EnableLoadTimeWeaving}$ : _@EnableLoadTimeWeaving é usada para ativar um carregador de tempo de execução (Load Time Weaver) para um contexto de aplicação Spring. Isso é útil quando se deseja realizar tecelagem (weaving) de aspectos, especialmente no contexto do AspectJ, durante o tempo de carregamento de classes._ 596 | 597 | **Parâmetros:** 598 | 599 | - `aspectjWeaving`: _Controla se a tecelagem AspectJ deve ser ativada. Os valores possíveis para aspectjWeaving são: **AspectJWeaving.ENABLED**, **AspectJWeaving.DISABLED**, **AspectJWeaving.AUTODETECT**_ 600 | 601 | ${\color{yellow}@EnableMBeanExport}$ : _@EnableMBeanExport é usada para habilitar a exportação de MBeans (Managed Beans) num contexto Spring, facilitando a exposição de beans gerenciados como MBeans em um servidor JMX (Java Management Extensions). Isso permite monitorar e gerenciar esses beans usando ferramentas de gerenciamento JMX._ 602 | 603 | **Parâmetros:** 604 | 605 | - `defaultDomain`: _Define o domínio padrão a ser usado ao gerar ObjectNames JMX. Um ObjectName JMX é uma identificação exclusiva usada para identificar um MBean. Se não for fornecido, o domínio padrão é usado._ 606 | - `server`: _Permite especificar o nome do bean MBeanServer ao qual os MBeans devem ser exportados. Por padrão, o servidor MBean padrão da plataforma é usado._ 607 | - `registration`: _Especifica a política a ser usada ao tentar registrar um MBean sob um ObjectName que já existe. Os valores possíveis para esse atributo são: **RegistrationPolicy.FAIL_ON_EXISTING**, **RegistrationPolicy.IGNORE_EXISTING** e **RegistrationPolicy.REPLACE_EXISTING**_ 608 | 609 | ${\color{yellow}@EnableScheduling}$ : _@EnableScheduling é usada em classes de configuração do Spring para habilitar a capacidade de execução de tarefas agendadas. Essas tarefas agendadas são definidas por meio de anotações @Scheduled._ 610 | 611 | ${\color{yellow}@EventListener}$ : _@EventListener é usada no Spring ‘Framework’ para marcar um método como um ouvinte de eventos da aplicação. Esse método será invocado quando o evento especificado ocorrer._ 612 | 613 | **Parâmetros:** 614 | 615 | - `value / classes`: _Especificar os tipos de eventos que o ouvinte deve manipular._ 616 | - `condition`: _Este atributo permite que você especifique uma expressão Spring Expression Language (SpEL) que controla condicionalmente se o método do ouvinte é chamado._ 617 | - `id`: _A partir do Spring 5.3.5, você pode usar o atributo ‘id’ para especificar um identificador exclusivo para o ouvinte. Isso é útil quando você precisa identificar ou remover o ouvinte posteriormente._ 618 | 619 | ${\color{yellow}@Import}$ : _@Import é usada para importar um ou mais componentes no contexto de aplicação._ 620 | 621 | **Parâmetros:** 622 | 623 | - `value`: _@Configuration, ImportSelector, ImportBeanDefinitionRegistrar ou classes de componentes regulares para importar._ 624 | 625 | ${\color{yellow}@ImportResource}$ : _@ImportResource é usada no Spring ‘Framework’ para importar definições de beans de recursos externos, como arquivos XML de configuração, para o contexto de aplicação. É semelhante à anotação @Import, mas é usada para importar recursos externos, enquanto @Import é usada para importar classes de configuração e outros componentes._ 626 | 627 | **Parâmetros:** 628 | 629 | - `locations`: _Pode usar os prefixos de carregamento de recursos, como classpath:, file:, etc._ 630 | - `reader`: _Você pode substituir o leitor padrão **BeanDefinitionReader**._ 631 | 632 | ${\color{yellow}@ImportRuntimeHints}$ : _@ImportRuntimeHints é usada no contexto do Spring ‘Framework’ para indicar que uma ou mais implementações da ‘interface’ RuntimeHintsRegistrar devem ser processadas._ 633 | 634 | **Parâmetros:** 635 | 636 | - `value`: _Onde você lista as classes que contêm dicas de tempo de execução para serem usadas na otimização do seu aplicativo._ 637 | 638 | ${\color{yellow}@Indexed}$ : _@Indexed é usada para indicar que o elemento anotado representa um estereótipo (stereotype) que deve ser indexado no contexto do Spring._ 639 | 640 | ${\color{yellow}@Lazy}$ : _@Lazy é usada para indicar se um bean deve ser inicializado de forma preguiçosa (lazy initialization) ou de forma imediata (eager initialization) em um contexto do Spring._ 641 | 642 | **Parâmetros:** 643 | 644 | - `value`: _Indica se a inicialização lenta deve ocorrer._ 645 | 646 | ${\color{yellow}@ManagedAttribute}$ : _@ManagedAttribute é usada para indicar que um determinado método de um bean deve ser exposto como um atributo JMX._ 647 | 648 | **Parâmetros:** 649 | 650 | - `defaultValue`: _Permite definir um valor padrão para o atributo no descritor JMX._ 651 | - `description`: _Usado para definir uma descrição para o atributo no descritor JMX._ 652 | - `currencyTimeLimit`: _Controla a duração de tempo em que o valor do atributo permanece válido._ 653 | - `persistPolicy`: _Usado para indicar como o valor do atributo deve ser persistido._ 654 | - `persistPeriod`: _Controla a frequência com que o valor do atributo é persistido._ 655 | 656 | ${\color{yellow}@ManagedMetric}$ : _@ManagedMetric é usada para indicar que um método de um bean deve ser exposto como um atributo JMX, com informações adicionais para indicar que se trata de uma métrica._ 657 | 658 | **Parâmetros:** 659 | 660 | - `category`: _Especifica a categoria à qual a métrica pertence. Pode ser usado para organizar as métricas em grupos relacionados._ 661 | - `currencyTimeLimit`: _Controla a duração de tempo em que o valor do atributo permanece válido._ 662 | - `description`: _Permite fornecer uma descrição da métrica, explicando o que ela representa._ 663 | - `displayName`: _Especifica um nome amigável para a métrica que pode ser exibido em ferramentas de gestão e monitoramento._ 664 | - `metricType`: _Define o tipo da métrica, que pode ser um dos seguintes: **MetricType.GAUGE** e **MetricType.COUNTER**._ 665 | - `persistPeriod`: _Controla a frequência com que o valor do atributo é persistido._ 666 | - `persistPolicy`: _Usado para indicar como o valor do atributo deve ser persistido._ 667 | - `unit`: _Define a unidade da métrica, indicando qual é a unidade de medida dos valores da métrica, como "bytes," "milissegundos," "solicitações," etc._ 668 | 669 | ${\color{yellow}@ManagedNotification}$ : _@ManagedNotification é usada para indicar que um bean num aplicativo JMX emite notificações JMX. Notificações JMX são mensagens que um bean envia para notificar eventos ou mudanças de estado._ 670 | 671 | **Parâmetros:** 672 | 673 | - `name`: _Especifica o nome da notificação JMX. O nome deve ser exclusivo dentro do contexto JMX. É usado para identificar a notificação e, portanto, deve ser exclusivo para evitar conflitos._ 674 | - `description`: _Permite fornecer uma descrição da métrica, explicando o que ela representa._ 675 | - `notificationTypes`: _Especifica os tipos de notificação que podem ser gerados por esta notificação. Os tipos de notificação são ‘strings’ que descrevem o tipo da notificação, como "error," "warning," "info," etc. Uma notificação pode ter vários tipos._ 676 | 677 | ${\color{yellow}@ManagedNotifications}$ : _@ManagedNotifications é um container de nível de tipo usada para agrupar uma ou mais declarações da anotação @ManagedNotification._ 678 | 679 | **Parâmetros:** 680 | 681 | - `value`: _Agrupamento de anotações @ManagedNotification._ 682 | 683 | ${\color{yellow}@ManagedOperation}$ : _@ManagedOperation é usada para indicar que um método deve ser exposto como uma operação JMX._ 684 | 685 | **Parâmetros:** 686 | 687 | - `description`: _Permite fornecer uma descrição da métrica, explicando o que ela representa._ 688 | - `currencyTimeLimit`: _Controla a duração de tempo em que o valor do atributo permanece válido._ 689 | 690 | ${\color{yellow}@ManagedOperationParameter}$ : _@ManagedOperationParameter é usada para fornecer metadados sobre os parâmetros de uma operação JMX._ 691 | 692 | **Parâmetros:** 693 | 694 | - `name`: _Permite especificar o nome do parâmetro da operação._ 695 | - `description`: _Permite fornecer uma descrição da métrica, explicando o que ela representa._ 696 | 697 | ${\color{yellow}@ManagedOperationParameters}$ : _@ManagedOperationParameters é um container de nível de tipo usada para agrupar uma ou mais declarações da anotação @ManagedOperationParameter._ 698 | 699 | **Parâmetros:** 700 | 701 | - `value`: _Agrupamento de anotações @ManagedOperationParameter._ 702 | 703 | ${\color{yellow}@ManagedResource}$ : _@ManagedResource é usada para registrar instâncias de uma classe com um servidor JMX._ 704 | 705 | **Parâmetros:** 706 | 707 | - `value / objectName`: _permite especificar o nome do objeto JMX sob o qual a instância da classe será registrada no servidor JMX._ 708 | - `description`: _Permite fornecer uma descrição da métrica, explicando o que ela representa._ 709 | - `currencyTimeLimit`: _Controla a duração de tempo em que o valor do atributo permanece válido._ 710 | - `log`: _permite especificar o nome do objeto JMX sob o qual a instância da classe será registrada no servidor JMX._ 711 | - `logFile`: _permite especificar o nome do objeto JMX sob o qual a instância da classe será registrada no servidor JMX._ 712 | - `persistPolicy`: _Usado para indicar como o valor do atributo deve ser persistido._ 713 | - `persistPeriod`: _Controla a frequência com que o valor do atributo é persistido._ 714 | - `persistName`: _Especifica um nome para os dados persistidos._ 715 | - `persistLocation`: _Especifica o local onde os dados persistidos serão armazenados._ 716 | 717 | ${\color{yellow}@NumberFormat}$ : _@NumberFormat é usada para declarar que um campo, método ou parâmetro de método deve ser formatado como um número._ 718 | 719 | **Parâmetros:** 720 | 721 | - `style`: _Especifica o estilo de formatação a ser usado para o campo._ 722 | - `pattern`: _Permite que você especifique um padrão de formatação personalizado._ 723 | 724 | ${\color{yellow}@Primary}$ : _@Primary é usada para indicar que um bean deve ser preferido quando existem vários candidatos qualificados para atender a uma dependência com um único valor._ 725 | 726 | **Parâmetros:** 727 | 728 | - `style`: _Especifica o estilo de formatação a ser usado para o campo._ 729 | - `pattern`: _Permite que você especifique um padrão de formatação personalizado._ 730 | 731 | ${\color{yellow}@Profile}$ : _@Profile é usada para indicar que um componente deve ser registrado e processado somente quando um ou mais perfis específicos estão ativos no aplicativo Spring._ 732 | 733 | **Parâmetros:** 734 | 735 | - `value`: _Aceita um array de strings representando os nomes dos perfis._ 736 | 737 | ${\color{yellow}@PropertySource}$ : _@PropertySource é usada para carregar propriedades a partir de arquivos de configuração, que podem ser arquivos .properties ou arquivos XML._ 738 | 739 | **Parâmetros:** 740 | 741 | - `name`: _Indica o nome exclusivo desta fonte de propriedades. Se omitido, o nome será gerado com base na origem subjacente._ 742 | - `value`: _Indica as localizações dos arquivos de propriedades a serem carregados. O padrão é suportado para diferentes formatos de arquivo, como *.properties ou *.xml._ 743 | - `ignoreResourceNotFound`: _Indica se uma falha ao encontrar um recurso de propriedades deve ser ignorada. Definir isso como true é apropriado se o arquivo de propriedades for completamente opcional. O padrão é false._ 744 | - `encoding`: _Especifica uma codificação de caracteres específica para os recursos fornecidos. Por exemplo, você pode definir UTF-8 como a codificação._ 745 | - `factory`: _Especifica uma fábrica personalizada de PropertySource a ser usada._ 746 | 747 | ${\color{yellow}@PropertySources}$ : _@PropertySources é uma anotação container que permite agregar várias anotações @PropertySource._ 748 | 749 | **Parâmetros:** 750 | 751 | - `value`: _Agrupamento de anotações @PropertySource._ 752 | 753 | ${\color{yellow}@Repository}$ : _@Repository é usada para marcar classes que desempenham o papel de repositórios de dados, geralmente para acesso a banco de dados._ 754 | 755 | **Parâmetros:** 756 | 757 | - `value`: _Pode indicar uma sugestão de nome de componente lógico._ 758 | 759 | ${\color{yellow}@Role}$ : _@Role é usada para indicar o "papel" (role) de um bean._ 760 | 761 | **Parâmetros:** 762 | 763 | - `value`: _Permite especificar um valor inteiro que representa o papel do bean no contexto da aplicação._ 764 | 765 | ${\color{yellow}@Scope}$ : _@Scope é usada para definir o escopo de uma instância gerenciada pelo Spring, afetando a vida útil da instância e como ela é compartilhada ou criada._ 766 | 767 | **Parâmetros:** 768 | 769 | - `scopeName`: _Permite especificar o nome do escopo a ser usado para as instâncias do tipo anotado. O escopo se refere à vida útil da instância do bean._ 770 | - `proxyMode`: _Permite especificar se o componente deve ser configurado como um proxy de escopo._ 771 | 772 | ${\color{yellow}@Scheduled}$ : _@Scheduled é usada no Spring ‘Framework’ para agendar a execução de um método de maneira programada._ 773 | 774 | **Parâmetros:** 775 | 776 | - `cron`: _Especifica uma expressão cron que define quando a tarefa será executada._ 777 | - `fixedDelay`: _Define um atraso fixo entre o término de uma invocação do método agendado e o início da próxima invocação. O atraso é especificado em milissegundos._ 778 | - `fixedRate`: _Define um intervalo fixo entre invocações consecutivas do método agendado, independentemente de quando o método anterior terminou. O intervalo é especificado em milissegundos._ 779 | - `initialDelay`: _Define um atraso inicial antes da primeira invocação do método agendado. O atraso é especificado em milissegundos._ 780 | - `zone`: _Especifica a zona de tempo na qual a expressão cron deve ser avaliada. Por padrão, ele usa a zona de tempo do servidor._ 781 | - `fixedDelayString / fixedRateString / initialDelayString`: _Versões alternativas dos atributos acima que permitem usar valores de ‘string’, incluindo suporte a expressões SpEL._ 782 | - `timeUnit`: _Permite especificar a unidade de tempo para os atributos fixedDelay, fixedRate, initialDelay, fixedDelayString, fixedRateString e initialDelayString._ 783 | 784 | ${\color{yellow}@Schedules}$ : _@Schedules é uma anotação de contêiner que permite agrupar várias anotações @Scheduled num único local._ 785 | 786 | **Parâmetros:** 787 | 788 | - `value`: _Agrupamento de anotações @Scheduled._ 789 | 790 | ${\color{yellow}@Service}$ : _@Service é usada para indicar que uma classe é um "Serviço" no contexto de um aplicativo Spring._ 791 | 792 | **Parâmetros:** 793 | 794 | - `value`: _Permite especificar um nome para o componente._ 795 | 796 | ${\color{yellow}@ Validated}$ : _@Validated é usada para indicar que uma classe, método ou argumento de método deve ser validado._ 797 | 798 | **Parâmetros:** 799 | 800 | - `value`: _Permite especificar grupos de validação personalizados que serão aplicados durante a validação._ 801 | 802 | ## Spring-core 803 | 804 | ${\color{yellow}@ AliasFor}$ : _@AliasFor é usada para declarar aliases (apelidos) para atributos em anotações._ 805 | 806 | **Parâmetros:** 807 | 808 | - `value / attribute`: _Indica qual atributo na anotação atual é um alias para outro atributo._ 809 | - `annotation`: _indica o tipo de anotação em que o atributo alvo (atributo especificado em attribute) é declarado._ 810 | 811 | ${\color{yellow}@Instantiator}$ : _@Instantiator é usada para indicar que a classe anotada é um instantiator (instanciador) de um tipo específico._ 812 | 813 | **Parâmetros:** 814 | 815 | - `value`: _Usado para especificar o tipo de instantiator que a classe representa, sendo: **STANDARD**, **SERIALIZATION**, **NOT_COMPLIANT** e **UNKNOWN**._ 816 | 817 | ${\color{yellow}@NonNull}$ : _@NonNull é uma anotação do Spring ‘Framework’ usada para declarar que os elementos anotados não podem ser nulos._ 818 | 819 | ${\color{yellow}@NonNullApi}$ : _@NonNullApi é usada no Spring ‘Framework’ para declarar que, por padrão, os parâmetros e valores de retorno devem ser considerados não nulos num determinado pacote._ 820 | 821 | ${\color{yellow}@NonNullFields}$ : _@NonNullFields é usada no Spring ‘Framework’ para declarar que, por padrão, os campos (fields) numa determinada classe ou pacote devem ser considerados não nulos._ 822 | 823 | ${\color{yellow}@Nullable}$ : _@Nullable é uma anotação do Spring ‘Framework’ usada para declarar que os elementos anotados podem ser nulos em algumas circunstâncias._ 824 | 825 | ${\color{yellow}@Order}$ : _@Order é usada no Spring ‘Framework’ para definir a ordem de classificação de um componente anotado._ 826 | 827 | **Parâmetros:** 828 | 829 | - `value`: _Definido como Ordered.LOWEST_PRECEDENCE. Valores menores têm prioridade mais alta. Isso significa que um componente com um valor de ordem menor terá uma prioridade mais alta na ordenação em relação a outros componentes com valores de ordem mais altos._ 830 | 831 | ${\color{yellow}@Reflective}$ : _@Reflective é usada para indicar que um elemento requer reflexão e permite especificar os processadores que serão usados para tratar esse elemento._ 832 | 833 | **Parâmetros:** 834 | 835 | - `value / processors`: _Permite especificar os processadores a serem usados para tratar o elemento anotado._ 836 | 837 | ${\color{yellow}@RegisterReflectionForBinding}$ : _@RegisterReflectionForBinding é usada para indicar que as classes especificadas nos atributos da anotação requerem algumas dicas de reflexão para fins de vinculação ou serialização baseada em reflexão._ 838 | 839 | **Parâmetros:** 840 | 841 | - `value / processors`: _Para cada classe especificada nos atributos value ou classes da anotação, são registradas dicas de reflexão em construtores, campos, propriedades e componentes de registro (caso seja uma classe de registro)._ 842 | 843 | ## Spring-data-jpa 844 | 845 | ${\color{yellow}@DisabledOnHibernate61}$ : _@DisabledOnHibernate61 é usada para sinalizar casos de teste do JUnit 5 que devem ser desativados (ignorados) quando a versão 6.1 do Hibernate está no classpath do projeto. Isso é útil quando você deseja evitar a execução de testes que podem não ser compatíveis com uma versão específica do Hibernate. Esses testes serão ignorados quando a versão do Hibernate 6.1 estiver presente no projeto._ 846 | 847 | ${\color{yellow}@DisabledOnHibernate62}$ : _@DisabledOnHibernate62 é usada para sinalizar casos de teste do JUnit 5 que devem ser desativados (ignorados) quando a versão 6.1 do Hibernate está no classpath do projeto. Isso é útil quando você deseja evitar a execução de testes que podem não ser compatíveis com uma versão específica do Hibernate. Esses testes serão ignorados quando a versão do Hibernate 6.2 estiver presente no projeto._ 848 | 849 | ${\color{yellow}@EnableEnversRepositories}$ : _@EnableEnversRepositories é usada para habilitar os repositórios do Envers. Ela funciona como uma anotação meta para @EnableJpaRepositories, substituindo a classe de fábrica padrão dos repositórios por EnversRevisionRepositoryFactoryBean._ 850 | 851 | **Parâmetros:** 852 | 853 | - `basePackages`: _Path de pacotes do projeto para verificar propriedades de configuração._ 854 | - `basePackageClasses`: _Alternativa ("Type-safe") especificando os pacotes para verificar as propriedades de configuração. O pacote de cada classe especificada será verificado._ 855 | - `includeFilters \ excludeFilters`: _Filtros que podem ser usados para incluir ou excluir beans do contexto de aplicação. Isso é útil para personalizar o ambiente de teste._ 856 | - `repositoryImplementationPostfix`: _Usado para configurar o sufixo que será anexado ao nome do repositório ao procurar por implementações personalizadas de repositórios. Por padrão, o sufixo é definido como "Impl"._ 857 | - `namedQueriesLocation`: _Usado para configurar a localização do arquivo de propriedades que contém as consultas nomeadas (named queries) para os repositórios. Por padrão, se esse atributo não for especificado, a localização padrão será META-INF/jpa-named-queries.properties._ 858 | - `queryLookupStrategy`: _Usado para configurar o mecanismo de busca de estratégia de consulta para os métodos de consulta dos seus repositórios. Por padrão, se esse atributo não for especificado, a estratégia padrão é Key.CREATE_IF_NOT_FOUND._ 859 | - `repositoryFactoryBeanClass`: _Usado para configurar a classe FactoryBean que será usada para criar instâncias de repositórios. Por padrão, se esse atributo não for especificado, a classe JpaRepositoryFactoryBean é usada como a classe de fábrica. Essa classe é responsável por criar proxies para os seus repositórios e gerenciar a injeção de dependência._ 860 | - `repositoryBaseClass`: _Usado para configurar a classe base dos repositórios a serem criados para uma configuração específica. A classe base dos repositórios é a ‘interface’ que estende a ‘interface’ JpaRepository e é usada como base para criar instâncias de repositórios._ 861 | - `entityManagerFactoryRef`: _Usado para configurar o nome da definição de bean do EntityManagerFactory que deve ser usado para criar os repositórios descobertos por meio dessa anotação. Por padrão, o nome da definição de bean do EntityManagerFactory é "entityManagerFactory"._ 862 | - `transactionManagerRef`: _Usado para configurar o nome da definição de bean do PlatformTransactionManager que deve ser usado para criar os repositórios descobertos por meio dessa anotação. Por padrão, o nome da definição de bean do PlatformTransactionManager é "transactionManager"._ 863 | - `considerNestedRepositories`: _Usado para configurar se as ‘interfaces’ de repositório aninhadas (por exemplo, definidas como classes internas) devem ser descobertas pela infraestrutura de repositórios. Por padrão, essa configuração é definida como false, o que significa que as interfaces de repositório aninhadas não são consideradas na descoberta de repositórios._ 864 | - `enableDefaultTransactions`: _ Usado para configurar se as transações padrão devem ser habilitadas para os repositórios Spring Data JPA. A configuração padrão é true, o que significa que as transações padrão estão habilitadas. Quando as transações padrão estão habilitadas, as operações realizadas nos métodos dos repositórios JPA são automaticamente envolvidas em transações gerenciadas pelo Spring, garantindo a consistência dos dados._ 865 | - `bootstrapMode`: _Usado para configurar quando os repositórios são inicializados durante o ciclo de vida de inicialização do aplicativo. Isso é relevante ao usar o Spring Data JPA e a anotação @EnableEnversRepositories em uma configuração._ 866 | - `escapeCharacter`: _Usado para configurar o caractere usado para escapar os caracteres curinga, como _ e %, em consultas derivadas no Spring Data JPA. Em consultas derivadas, você pode usar curingas para correspondência parcial de strings, mas, em alguns casos, você pode querer pesquisar literais que contêm esses caracteres curinga como parte da string em si._ 867 | 868 | ${\color{yellow}@EnableJpaAuditing}$ : _@EnableJpaAuditing é usada para habilitar a auditoria em JPA (Java Persistence API) por meio de configuração por anotações. A auditoria é o processo de rastreamento de ações em entidades JPA, como criação, modificação e exclusão, para fins de registro e monitoramento._ 869 | 870 | **Parâmetros:** 871 | 872 | - `auditorAwareRef`: _Este atributo permite configurar o nome do bean que implementa a ‘interface’ AuditorAware. Um AuditorAware é usado para procurar o princípio atual que executa a ação de auditoria. Por padrão, esse atributo está vazio, o que significa que o mecanismo padrão será usado para determinar o principal atual._ 873 | - `setDates`: _Este atributo configura se as datas de criação e modificação devem ser definidas. Se for true, as datas de criação e modificação serão definidas automaticamente ao criar ou modificar entidades. Se for false, as datas não serão definidas automaticamente. O valor padrão é true._ 874 | - `modifyOnCreate`: _Este atributo configura se a entidade deve ser marcada como modificada na criação. Se for true, a entidade será considerada modificada quando criada. Se for false, a entidade não será marcada como modificada na criação. O valor padrão é true._ 875 | - `dateTimeProviderRef`: _Este atributo permite configurar o nome do bean que implementa a ‘interface’ DateTimeProvider. Um DateTimeProvider é usado para personalizar o objeto TemporalAccessor usado para definir datas de criação e modificação. Se você não especificar um valor para este atributo, o mecanismo padrão será usado._ 876 | 877 | ${\color{yellow}@EnableJpaRepositories}$ : _@EnableJpaRepositories usada para habilitar a criação de repositórios JPA (Java Persistence API) num aplicativo Spring. Esses repositórios são usados para acessar e manipular entidades de banco de dados comuns em aplicativos Spring Data._ 878 | 879 | **Parâmetros:** 880 | 881 | - `basePackages`: _Path de pacotes do projeto para verificar propriedades de configuração._ 882 | - `basePackageClasses`: _Alternativa ("Type-safe") especificando os pacotes para verificar as propriedades de configuração. O pacote de cada classe especificada será verificado._ 883 | - `includeFilters \ excludeFilters`: _Filtros que podem ser usados para incluir ou excluir beans do contexto de aplicação. Isso é útil para personalizar o ambiente de teste._ 884 | - `repositoryImplementationPostfix`: _Usado para configurar o sufixo que será anexado ao nome do repositório ao procurar por implementações personalizadas de repositórios. Por padrão, o sufixo é definido como "Impl"._ 885 | - `namedQueriesLocation`: _Usado para configurar a localização do arquivo de propriedades que contém as consultas nomeadas (named queries) para os repositórios. Por padrão, se esse atributo não for especificado, a localização padrão será META-INF/jpa-named-queries.properties._ 886 | - `queryLookupStrategy`: _Usado para configurar o mecanismo de busca de estratégia de consulta para os métodos de consulta dos seus repositórios. Por padrão, se esse atributo não for especificado, a estratégia padrão é Key.CREATE_IF_NOT_FOUND._ 887 | - `repositoryFactoryBeanClass`: _Usado para configurar a classe FactoryBean que será usada para criar instâncias de repositórios. Por padrão, se esse atributo não for especificado, a classe JpaRepositoryFactoryBean é usada como a classe de fábrica. Essa classe é responsável por criar proxies para os seus repositórios e gerir a injeção de dependência._ 888 | - `repositoryBaseClass`: _Usado para configurar a classe base dos repositórios a serem criados para uma configuração específica. A classe base dos repositórios é a ‘interface’ que estende a ‘interface’ JpaRepository sendo usada como base para criar instâncias de repositórios._ 889 | - `entityManagerFactoryRef`: _Usado para configurar o nome da definição de bean do EntityManagerFactory que deve ser usado para criar os repositórios descobertos por meio dessa anotação. Por padrão, o nome da definição de bean do EntityManagerFactory é "entityManagerFactory"._ 890 | - `transactionManagerRef`: _Usado para configurar o nome da definição de bean do PlatformTransactionManager que deve ser usado para criar os repositórios descobertos por meio dessa anotação. Por padrão, o nome da definição de bean do PlatformTransactionManager é "transactionManager"._ 891 | - `considerNestedRepositories`: _Usado para configurar se as interfaces de repositório aninhadas (por exemplo, definidas como classes internas) devem ser descobertas pela infraestrutura de repositórios. Por padrão, essa configuração é definida como false, o que significa que as ‘interfaces’ de repositório aninhadas não são consideradas na descoberta de repositórios._ 892 | - `enableDefaultTransactions`: _ Usado para configurar se as transações padrão devem ser habilitadas para os repositórios Spring Data JPA. A configuração padrão é true, o que significa que as transações padrão estão habilitadas. Quando as transações padrão estão habilitadas, as operações realizadas nos métodos dos repositórios JPA são automaticamente envolvidas em transações gerenciadas pelo Spring, garantindo a consistência dos dados._ 893 | - `bootstrapMode`: _Usado para configurar quando os repositórios são inicializados durante o ciclo de vida de inicialização do aplicativo. Isso é relevante ao usar o Spring Data JPA e a anotação @EnableEnversRepositories numa configuração._ 894 | - `escapeCharacter`: _Usado para configurar o caractere usado para escapar os caracteres curinga, como _ e %, em consultas derivadas no Spring Data JPA. Em consultas derivadas, você pode usar curingas para correspondência parcial de ‘strings’, mas, em alguns casos, você pode querer pesquisar literais que contêm esses caracteres curinga como parte da ‘string’ em si._ 895 | 896 | ${\color{yellow}@EntityGraph}$ : _@EntityGraph é usada para configurar os grafos de entidades (EntityGraphs) que devem ser usados em métodos de repositório JPA no Spring Data. Os grafos de entidades permitem definir quais atributos das entidades associadas devem ser carregados com a entidade principal, evitando problema de carregamento preguiçoso (lazy loading) e melhorando o desempenho de consultas._ 897 | 898 | **Parâmetros:** 899 | 900 | - `type`: _Este atributo configura o tipo do EntityGraph a ser usado. O valor padrão é EntityGraphType.FETCH, que significa que os atributos listados no EntityGraph serão carregados como FetchType.EAGER. Outro valor disponível é EntityGraphType.LOAD, que trata atributos não listados como FetchType.EAGER e os demais conforme as suas configurações padrão de FetchType._ 901 | - `attributePaths`: _Este atributo permite personalizar o grafo de entidades definindo caminhos de atributos que devem ser carregados de forma ad-hoc. Se este atributo for especificado, o nome do EntityGraph (type()) será ignorado e o EntityGraph será considerado dinâmico. Isso permite que você defina atributos específicos para carregamento num método de repositório._ 902 | 903 | ${\color{yellow}@Lock}$ : _@Lock é usada para especificar o tipo de bloqueio (LockModeType) a ser usado ao executar uma consulta ou método de CRUD num repositório JPA no Spring Data. Os bloqueios são usados para controlar o acesso concorrente aos registros do banco de dados, permitindo que você defina como as transações devem travar os registros durante a execução da consulta._ 904 | 905 | **Parâmetros:** 906 | 907 | - `value`: _Este atributo especifica o tipo de bloqueio a ser usado ao executar a consulta ou método de CRUD. Ele deve ser uma constante do tipo LockModeType, que define o modo de bloqueio desejado. Alguns dos valores comuns incluem: 908 | LockModeType.NONE: Nenhum bloqueio é aplicado (padrão). 909 | LockModeType.OPTIMISTIC: Bloqueio otimista, onde as alterações no banco de dados são verificadas antes da gravação. 910 | LockModeType.OPTIMISTIC_FORCE_INCREMENT: Bloqueio otimista com forçar incremento, usado para forçar a atualização do número de versão. 911 | LockModeType.PESSIMISTIC_READ: Bloqueio pessimista de leitura. 912 | LockModeType.PESSIMISTIC_WRITE: Bloqueio pessimista de gravação._ 913 | 914 | ${\color{yellow}@Modifying}$ : _@Modifying usada em métodos de consulta para indicar que a consulta é uma consulta modificadora, o que significa que ela realiza operações que modificam os dados no banco de dados. Isso afeta a forma como a consulta deve ser executada e como o contexto de persistência deve ser gerenciado durante a execução da consulta. Essa anotação é geralmente usada em conjunto com a anotação @Query._ 915 | 916 | **Parâmetros:** 917 | 918 | - `flushAutomatically`: _Este atributo especifica se o contexto de persistência deve ser automaticamente descarregado (flushed) antes de executar a consulta modificadora._ 919 | - `clearAutomatically`: _Este atributo especifica se o contexto de persistência deve ser automaticamente limpo (cleared) após a execução da consulta modificadora._ 920 | 921 | ${\color{yellow}@Procedure}$ : _@Procedure é usada para declarar mapeamentos de procedimentos armazenados JPA 2.1 diretamente em métodos de repositório. Isso permite chamar procedimentos armazenados do banco de dados por meio de métodos de repositório JPA, simplificando a interação com procedimentos armazenados._ 922 | 923 | **Parâmetros:** 924 | 925 | - `procedureName`: _Este atributo também especifica o nome do procedimento no banco de dados. O valor padrão é uma ‘string’ vazia ("")._ 926 | - `name`: _Especifica o nome do procedimento no EntityManager. O valor padrão é uma ‘string’ vazia ("")._ 927 | - `outputParameterName`: _Este atributo especifica o nome do parâmetro de saída do procedimento armazenado. O valor padrão é uma ‘string’ vazia ("")._ 928 | - `refCursor`: _Especifica se o procedimento retorna um Ref Cursor do banco de dados. Um Ref Cursor é uma estrutura de dados que pode ser usada para percorrer conjuntos de resultados. O valor padrão é false._ 929 | 930 | ${\color{yellow}@Query}$ : _@Query é usada para declarar consultas personalizadas diretamente em métodos de repositório. Isso permite definir as consultas JPA que serão executadas quando um método anotado com @Query for chamado._ 931 | 932 | **Parâmetros:** 933 | 934 | - `value`: _Esse atributo define a consulta JPA a ser executada quando o método anotado é chamado. O valor padrão é uma ‘string’ vazia ("")._ 935 | - `countQuery`: _Esse atributo permite definir uma consulta especial de contagem que será usada para consultas de paginação de modo a obter o número total de elementos numa página._ 936 | - `countProjection`: _Este atributo define a parte de projeção da consulta de contagem gerada para consultas de paginação. Se nenhum countQuery() nem countProjection() estiver configurado, a consulta de contagem será derivada da consulta original._ 937 | - `nativeQuery`: _Esse atributo configura se a consulta é uma consulta nativa (SQL) em vez de uma consulta JPQL. O valor padrão é false._ 938 | - `name`: _Especifica o nome da consulta nomeada a ser usada. Se não for definido, uma @NamedQuery com o nome {$domainClass}.${queryMethodName} será usada._ 939 | - `countName`: _Especifica o nome da consulta nomeada a ser usada para executar consultas de contagem ao usar a paginação. O padrão é derivar o nome da consulta nomeada configurada, seguido de `.count`._ 940 | - `queryRewriter`: _Esse atributo permite definir um QueryRewriter que deve ser aplicado à string da consulta após a montagem completa da consulta. Isso é útil para modificar ou ajustar a consulta antes de ser executada._ 941 | 942 | ${\color{yellow}@QueryHints}$ : _@QueryHints são dicas para otimizar a execução de consultas no JPA. A anotação @QueryHints permite que essas dicas sejam aplicadas a consultas definidas em métodos de repositório ou derivadas a partir do nome do método._ 943 | 944 | **Parâmetros:** 945 | 946 | - `value`: _Esse atributo permite especificar um ou mais objetos @QueryHint. Os objetos @QueryHint são usados para configurar dicas específicas para a consulta, como hints de cache, dicas de busca, etc._ 947 | - `forCounting`: _Esse atributo define se as dicas de consulta configuradas também devem ser aplicadas a consultas de contagem durante a paginação. O valor padrão é true, o que significa que as dicas se aplicam a consultas de contagem._ 948 | 949 | ${\color{yellow}@Temporal}$ : _@Temporal é usada para declarar o tipo de data a ser usado em parâmetros de métodos de consulta. Ela é usada em conjunto com parâmetros de tipo Date para indicar o tipo de data que será usado em uma consulta._ 950 | 951 | **Parâmetros:** 952 | 953 | - `value`: _Este atributo permite definir o tipo de data a ser usado para o parâmetro anotado. O valor padrão é **TemporalType.DATE**, mas você pode especificar outros valores, como **TemporalType.TIME** ou **TemporalType.TIMESTAMP**._ 954 | 955 | ## Spring-messaging 956 | 957 | ${\color{yellow}@ConnectMapping}$ : _@ConnectMapping é usada para mapear a carga útil inicial ConnectionSetupPayload e subsequentes envios de metadados para um método de tratamento. Essa anotação é usada em métodos e pode ser combinada com a anotação @MessageMapping em nível de tipo para criar um padrão de rota combinado._ 958 | 959 | **Parâmetros:** 960 | 961 | - `value`: _Permite especificar um ou mais padrões de rota que devem ser correspondidos à rota a partir dos metadados do ConnectionSetupPayload ou de envios subsequentes de metadados._ 962 | 963 | ${\color{yellow}@DestinationVariable}$ : _@DestinationVariable é usada para indicar que um parâmetro de método deve ser vinculado a uma variável de modelo em uma string de modelo de destino._ 964 | 965 | **Parâmetros:** 966 | 967 | - `value`: _Permite especificar o nome da variável de modelo da qual o valor deve ser vinculado. Essa variável deve estar presente na string do modelo de destino que corresponde à mensagem sendo tratada._ 968 | 969 | ${\color{yellow}@Header}$ : _@Header é usada para indicar que um parâmetro de método deve ser vinculado a um cabeçalho de mensagem._ 970 | 971 | **Parâmetros:** 972 | 973 | - `value / name`: _Permite especificar o nome do cabeçalho da mensagem ao qual o parâmetro do método deve ser vinculado._ 974 | - `required`: _Determina se o cabeçalho é obrigatório. O valor padrão é true._ 975 | - `defaultValue`: _permite especificar um valor padrão para o parâmetro do método. Se um valor padrão for especificado, ele será usado como um valor de fallback quando o cabeçalho estiver ausente na mensagem. Definir um valor padrão automaticamente define required como false._ 976 | 977 | ${\color{yellow}@Headers}$ : _@Headers é usada para indicar que um parâmetro de método deve ser vinculado aos cabeçalhos de uma mensagem. A principal diferença em relação à anotação @Header é que @Headers permite vincular todos os cabeçalhos da mensagem a um parâmetro do método, desde que esse parâmetro seja do tipo Map._ 978 | 979 | ${\color{yellow}@MessageExceptionHandler}$ : _@MessageExceptionHandler é usada em métodos dentro de classes de manipulação de mensagens para lidar com exceções lançadas por métodos de manipulação de mensagens._ 980 | 981 | **Parâmetros:** 982 | 983 | - `value`: _Permite listar várias classes de exceção como valores para indicar que o método trata mais de um tipo de exceção._ 984 | 985 | ${\color{yellow}@MessageMapping}$ : _@MessageMapping é usada para mapear uma mensagem para um método de manipulação de mensagens em um controlador Spring. Ela define como as mensagens recebidas por meio de sistemas de mensagens, como STOMP sobre WebSocket e RSocket, devem ser manipuladas por um método específico._ 986 | 987 | **Parâmetros:** 988 | 989 | - `value`: _Usado para definir os padrões de destino que determinam quais mensagens devem ser manipuladas pelo método anotado._ 990 | 991 | ${\color{yellow}@Payload}$ : _@Payload é usada para indicar que um parâmetro de método deve ser vinculado ao payload de uma mensagem em um aplicativo Spring que lida com mensagens. O payload é a parte principal da mensagem que contém os dados que você deseja processar._ 992 | 993 | **Parâmetros:** 994 | 995 | - `value`: _Permite que você especifique um nome ou valor para o atributo, útil quando o payload é simples e não requer uma expressão._ 996 | - `expression`: _Permite que você especifique uma expressão Spring Expression Language (SpEL) usada para extrair o payload._ 997 | - `required`: _Especifica se o payload é obrigatório ou não. Se definido como true (o valor padrão), um erro será gerado se não houver payload na mensagem._ 998 | 999 | ${\color{yellow}@RSocketExchange}$ : _@RSocketExchange é usada para declarar um método em uma ‘interface’ de serviço RSocket como um ponto de extremidade RSocket. Essa anotação permite especificar o roteamento do ponto de extremidade com base no atributo da anotação e nos argumentos do método._ 1000 | 1001 | **Parâmetros:** 1002 | 1003 | - `value`: _Este atributo é usado para especificar o mapeamento de destino do ponto de extremidade._ 1004 | 1005 | ${\color{yellow}@SendTo}$ : _@SendTo é usada para indicar que o valor de retorno de um método deve ser convertido numa mensagem (do tipo Message) se necessário e enviada para o destino especificado. Essa anotação é comumente usada em cenários de comunicação assíncrona, onde um método pode gerar uma resposta que é enviada para um destino específico._ 1006 | 1007 | **Parâmetros:** 1008 | 1009 | - `value`: _Especifica o destino para o qual a mensagem criada a partir do valor de retorno do método deve ser enviada._ 1010 | 1011 | ${\color{yellow}@SendToUser}$ : _@SendToUser é usada para indicar que o valor de retorno de um método deve ser convertido numa mensagem (do tipo Message) e enviada para um ou mais destinos. A diferença principal entre @SendTo e @SendToUser é que a última adiciona um prefixo "/user/{username}" ao destino especificado. Além disso, @SendToUser é frequentemente usada em sistemas de mensagens onde as mensagens são direcionadas para usuários específicos._ 1012 | 1013 | **Parâmetros:** 1014 | 1015 | - `value / destinations`: _Estes atributos especificam um ou mais destinos para os quais a mensagem criada a partir do valor de retorno do método deve ser enviada. Se especificado, o prefixo "/user/{username}" é adicionado a cada destino._ 1016 | - `broadcast`: _Controla se as mensagens devem ser enviadas para todas as sessões associadas ao usuário (true) ou apenas para a sessão da mensagem de entrada sendo manipulada (false)._ 1017 | 1018 | ${\color{yellow}@SubscribeMapping}$ : _@SubscribeMapping é usada para mapear mensagens de assinatura (subscription messages) para métodos de manipulação com base no destino da assinatura. Ela é amplamente usada em sistemas que suportam o protocolo STOMP (Streaming Text Oriented Messaging Protocol) sobre WebSocket, como parte da arquitetura de mensagens em tempo real._ 1019 | 1020 | **Parâmetros:** 1021 | 1022 | - `value`: _Especifica o destino da mensagem de assinatura. A mensagem de assinatura é aquela em que um cliente se inscreve para receber atualizações em um determinado destino. O destino pode ser especificado como uma string. Você pode usar padrões estilo Ant (por exemplo, "/price.stock.*") ou variáveis de modelo de caminho (por exemplo, "/price.stock.{ticker}") no destino para fazer corresponder várias assinaturas a um único método._ 1023 | 1024 | ## Spring-test 1025 | 1026 | ${\color{yellow}@ ActiveProfiles}$ : _@ActiveProfiles é usada para declarar quais perfis de definição de beans ativos devem ser usados ao carregar um ApplicationContext._ 1027 | 1028 | **Parâmetros:** 1029 | 1030 | - `value / profiles`: _Ambos os atributos permitem especificar os perfis de definição de beans ativos a serem usados no contexto de aplicativo ao executar um teste._ 1031 | - `resolver`: _Permite que você especifique uma classe que implemente a ‘interface’ ActiveProfilesResolver para resolver os perfis de definição de beans ativos programaticamente._ 1032 | - `inheritProfiles`: _O valor padrão é true, o que significa que os perfis definidos numa classe de teste se acumulam com os perfis definidos nas classes de teste superiores._ 1033 | 1034 | ${\color{yellow}@ AfterTestClass}$ : _@AfterTestClass é usada para marcar métodos que devem ser invocados após a execução de uma classe de teste no Spring ‘Framework’._ 1035 | 1036 | **Parâmetros:** 1037 | 1038 | - `value`: _Expressão SpEL para que o método seja executado apenas se uma condição específica for atendida._ 1039 | 1040 | ${\color{yellow}@ AfterTestExecution}$ : _@AfterTestExecution é usada para marcar métodos que devem ser invocados após a execução de um método de teste no Spring Framework._ 1041 | 1042 | **Parâmetros:** 1043 | 1044 | - `value`: _Expressão SpEL para que o método seja executado apenas se uma condição específica for atendida._ 1045 | 1046 | ${\color{yellow}@ AfterTestMethod}$ : _@AfterTestMethod é usada para marcar métodos que devem ser invocados após a execução de um método de teste no Spring Framework._ 1047 | 1048 | **Parâmetros:** 1049 | 1050 | - `value`: _Expressão SpEL para que o método seja executado apenas se uma condição específica for atendida._ 1051 | 1052 | ${\color{yellow}@ AfterTransaction}$ : _@AfterTransaction usada em testes do Spring ‘Framework’ para indicar que um método void anotado deve ser executado após o término de uma transação para um método de teste configurado para ser executado em uma transação, normalmente usando a anotação @Transactional do Spring._ 1053 | 1054 | ${\color{yellow}@BeforeTestClass}$ : _@BeforeTestClass é usada em testes do Spring ‘Framework’ para indicar que um método void anotado deve ser executado antes que um conjunto de testes de classe seja executado._ 1055 | 1056 | **Parâmetros:** 1057 | 1058 | - `value`: _Expressão SpEL para que o método seja executado apenas se uma condição específica for atendida._ 1059 | 1060 | ${\color{yellow}@BeforeTestExecution}$ : _@BeforeTestExecution é usada em testes do Spring Framework para indicar que um método void anotado deve ser executado antes que um método de teste seja executado._ 1061 | 1062 | **Parâmetros:** 1063 | 1064 | - `value`: _Expressão SpEL para que o método seja executado apenas se uma condição específica for atendida._ 1065 | 1066 | ${\color{yellow}@BeforeTestMethod}$ : _@BeforeTestMethod é usada em testes do Spring ‘Framework’ para indicar que um método void anotado deve ser executado antes da execução de um método de teste específico._ 1067 | 1068 | **Parâmetros:** 1069 | 1070 | - `value`: _Expressão SpEL para que o método seja executado apenas se uma condição específica for atendida._ 1071 | 1072 | ${\color{yellow}@BeforeTransaction}$ : _@BeforeTransaction é usada em testes do Spring ‘Framework’ para indicar que um método void anotado deve ser executado antes de uma transação ser iniciada para um método de teste configurado para ser executado dentro de uma transação, geralmente por meio da anotação @Transactional do Spring._ 1073 | 1074 | ${\color{yellow}@BootstrapWith}$ : _@BootstrapWith é usada para definir metadados em nível de classe que determinam como inicializar o "Spring TestContext Framework" durante a execução de testes._ 1075 | 1076 | **Parâmetros:** 1077 | 1078 | - `value`: _Permite que você especifique a classe que implementa o TestContextBootstrapper._ 1079 | 1080 | ${\color{yellow}@Commit}$ : _@Commit é usada para definir explicitamente que a transação deve ser confirmada após o término do método de teste. Normalmente, num ambiente de teste, as transações são revertidas para garantir que os testes sejam independentes um do outro e não afetem o estado do banco de dados._ 1081 | 1082 | ${\color{yellow}@ContextConfiguration}$ : _@ContextConfiguration é usada em testes de integração no Spring ‘Framework’ para definir metadados em nível de classe que determinam como carregar e configurar um ApplicationContext para os testes._ 1083 | 1084 | **Parâmetros:** 1085 | 1086 | - `value / locations`: _Especifica as localizações dos recursos que serão usados para carregar o ApplicationContext._ 1087 | - `classes`: _Especifica classes de componentes que serão usadas para configurar o ApplicationContext._ 1088 | - `initializers`: _Permite especificar inicializadores do aplicativo, usados para personalizar a inicialização do ApplicationContext para testes._ 1089 | - `loader`: _Define o tipo de carregador de contexto a ser usado. O carregador de contexto determina como o ApplicationContext será criado._ 1090 | - `inheritLocations`: _Controla se as configurações de localização devem ser herdadas das classes pai. Se for definido como false, o teste substituirá as configurações das classes pai._ 1091 | - `inheritInitializers`: _Controla se as configurações de inicialização devem ser herdadas das classes pai. Se for definido como false, o teste substituirá as configurações das classes pai._ 1092 | - `name`: _Define o nome do nível de hierarquia de contexto. Isso é útil ao usar @ContextHierarchy para configurar hierarquias de contextos em classes de teste aninhadas._ 1093 | 1094 | ${\color{yellow}@ContextHierarchy}$ : _@ContextHierarchy é uma anotação de nível de classe usada para definir uma hierarquia de ApplicationContext para testes de integração no Spring Framework. Ela permite configurar vários níveis de contexto para testes complexos que envolvem diferentes partes de um aplicativo Spring._ 1095 | 1096 | **Parâmetros:** 1097 | 1098 | - `value`: _Especifica uma lista de instâncias @ContextConfiguration._ 1099 | 1100 | ${\color{yellow}@DirtiesContext}$ : _@DirtiesContext é uma anotação usada em testes do Spring ‘Framework’ para indicar que o ApplicationContext associado a um teste está "sujo" e, portanto, deve ser fechado e removido do cache de contexto. Ela é usada quando um teste modifica o contexto, como alterar o estado de um bean singleton, alterar o estado de um banco de dados incorporado, etc._ 1101 | 1102 | **Parâmetros:** 1103 | 1104 | - `methodMode`: _Determina o modo em que a anotação @DirtiesContext é interpretada quando usada para anotar um método de teste, sendo elas BEFORE_METHOD e AFTER_METHOD._ 1105 | - `classMode`: _Determina o modo em que a anotação @DirtiesContext é interpretada quando usada para anotar uma classe de teste, sendo elas BEFORE_CLASS, BEFORE_EACH_TEST_METHOD, AFTER_EACH_TEST_METHOD e AFTER_CLASS._ 1106 | - `hierarchyMode`: _Define o modo de limpeza do cache de contexto quando um contexto faz parte de uma hierarquia, especificada usando a anotação @ContextHierarchy._ 1107 | 1108 | ${\color{yellow}@DisabledIf}$ : _@DisabledIf é usada para desativar um teste com base na avaliação de uma expressão. Se a expressão avaliar como true, o teste será desativado, e a razão da desativação pode ser fornecida como um valor adicional. A anotação pode ser aplicada a nível de classe ou método e pode ser usada para criar anotações personalizadas para casos específicos._ 1109 | 1110 | **Parâmetros:** 1111 | 1112 | - `value / expression`: _Define a expressão que será avaliada para determinar se a classe ou método de teste anotado deve ser "desativado" (disabled)._ 1113 | - `reason`: _Define o motivo pelo qual o teste está desativado._ 1114 | - `loadContext`: _Define se o ApplicationContext associado ao teste deve ser carregado antecipadamente para avaliar a expression._ 1115 | 1116 | ${\color{yellow}@DynamicPropertySource}$ : _@DynamicPropertySource é usada em métodos de integração de teste para adicionar propriedades com valores dinâmicos ao conjunto de PropertySources do ambiente (Environment)._ 1117 | 1118 | ${\color{yellow}@EnabledIf}$ : _@EnabledIf é usada para indicar que a classe de teste ou o método de teste anotado está "habilitado" (enabled) e deve ser executado se a expressão fornecida avaliar para true._ 1119 | 1120 | **Parâmetros:** 1121 | 1122 | - `value / expression`: _Define a expressão que será avaliada para determinar se a classe ou método de teste anotado deve ser "desativado" (disabled)._ 1123 | - `reason`: _Define o motivo pelo qual o teste está desativado._ 1124 | - `loadContext`: _Define se o ApplicationContext associado ao teste deve ser carregado antecipadamente para avaliar a expression._ 1125 | 1126 | ${\color{yellow}@IfProfileValue}$ : _@IfProfileValue é usada com o ‘framework’ de teste JUnit 4 para indicar se um teste está habilitado ou desabilitado com base num perfil específico._ 1127 | 1128 | **Parâmetros:** 1129 | 1130 | - `name`: _Definição de um nome para o valor do perfil._ 1131 | - `value`: _Usado para definir um valor específico que o perfil deve ter para que o teste seja habilitado._ 1132 | - `values`: _Permite especificar uma lista de valores possíveis para o perfil. O teste será habilitado se o valor do perfil corresponder a qualquer um dos valores na lista._ 1133 | 1134 | ${\color{yellow}@NestedTestConfiguration}$ : _@NestedTestConfiguration é usada em conjunto com o Spring TestContext ‘Framework’ para configurar como as anotações de configuração de teste do Spring são processadas em classes de teste aninhadas._ 1135 | 1136 | **Parâmetros:** 1137 | 1138 | - `value`: _Define os modos de herança de configuração em classes de teste aninhadas, sendo elas INHERIT e OVERRIDE._ 1139 | 1140 | ${\color{yellow}@PrepareTestInstance}$ : _@PrepareTestInstance é usada em métodos que você deseja executar como parte da preparação da instância de teste no ciclo de vida do teste._ 1141 | 1142 | **Parâmetros:** 1143 | 1144 | - `value`: _Expressão SpEL para que o método seja executado apenas se uma condição específica for atendida._ 1145 | 1146 | ${\color{yellow}@ProfileValueSourceConfiguration}$ : _@ProfileValueSourceConfiguration é usada no contexto do Spring Test Framework com JUnit 4 para especificar o tipo de ProfileValueSource a ser usado ao recuperar os valores de perfil configurados por meio da anotação @IfProfileValue._ 1147 | 1148 | **Parâmetros:** 1149 | 1150 | - `value`: _Implementação padrão usada é SystemProfileValueSource. Isso significa que os valores de perfil serão recuperados a partir das propriedades de sistema Java._ 1151 | 1152 | ${\color{yellow}@RecordApplicationEvents}$ : _@RecordApplicationEvents é uma anotação de nível de classe usada para instruir o "Spring TestContext Framework" a registrar todos os eventos da aplicação que são publicados no ApplicationContext durante a execução de um único teste. Isso permite que você acesse e verifique esses eventos em seus testes._ 1153 | 1154 | ${\color{yellow}@Repeat}$ : _@Repeat é usada com o framework JUnit 4 para indicar que um método de teste deve ser invocado repetidamente. Ou seja, o método de teste e qualquer configuração ou limpeza (set up e tear down) associada a ele serão executados várias vezes._ 1155 | 1156 | **Parâmetros:** 1157 | 1158 | - `value`: _Número de repetições, por padrão o valir é 1._ 1159 | 1160 | ${\color{yellow}@Rollback}$ : _@Rollback é usada em testes no Spring ‘Framework’ para indicar se uma transação gerenciada pelo teste deve ser revertida (rollback) após a conclusão do método de teste. Essa anotação é geralmente usada para controlar o comportamento das transações em testes de integração ou testes de unidade que envolvem transações de banco de dados._ 1161 | 1162 | **Parâmetros:** 1163 | 1164 | - `value`: _Determina se a transação gerenciada pelo teste deve ser revertida (rollback) após a conclusão do método de teste, por padrão o valor é true._ 1165 | 1166 | ${\color{yellow}@SpringJUnitConfig}$ : _@SpringJUnitConfig é uma anotação composta que combina as anotações @ExtendWith(SpringExtension.class) do JUnit Jupiter com a anotação @ContextConfiguration do Spring TestContext Framework. Ela é usada para configurar classes de teste que usam o framework Spring em conjunto com o JUnit Jupiter._ 1167 | 1168 | **Parâmetros:** 1169 | 1170 | - `value / locations`: _Especifica as localizações dos recursos que serão usados para carregar o ApplicationContext._ 1171 | - `classes`: _Especifica classes de componentes que serão usadas para configurar o ApplicationContext._ 1172 | - `initializers`: _Permite especificar inicializadores do aplicativo, usados para personalizar a inicialização do ApplicationContext para testes._ 1173 | - `loader`: _Define o tipo de carregador de contexto a ser usado. O carregador de contexto determina como o ApplicationContext será criado._ 1174 | - `inheritLocations`: _Controla se as configurações de localização devem ser herdadas das classes pai. Se for definido como false, o teste substituirá as configurações das classes pai._ 1175 | - `inheritInitializers`: _Controla se as configurações de inicialização devem ser herdadas das classes pai. Se for definido como false, o teste substituirá as configurações das classes pai._ 1176 | - `name`: _Define o nome do nível de hierarquia de contexto. Isso é útil ao usar @ContextHierarchy para configurar hierarquias de contextos em classes de teste aninhadas._ 1177 | 1178 | ${\color{yellow}@SpringJUnitWebConfig}$ : _@SpringJUnitWebConfig é uma anotação composta que combina as anotações @ExtendWith(SpringExtension.class), @ContextConfiguration, e @WebAppConfiguration. Ela é usada para configurar classes de teste que usam o framework Spring e o JUnit Jupiter em conjunto e são destinadas a testes de aplicativos da web._ 1179 | 1180 | **Parâmetros:** 1181 | 1182 | - `value / locations`: _Especifica as localizações dos recursos que serão usados para carregar o ApplicationContext._ 1183 | - `classes`: _Especifica classes de componentes que serão usadas para configurar o ApplicationContext._ 1184 | - `initializers`: _Permite especificar inicializadores do aplicativo, usados para personalizar a inicialização do ApplicationContext para testes._ 1185 | - `loader`: _Define o tipo de carregador de contexto a ser usado. O carregador de contexto determina como o ApplicationContext será criado._ 1186 | - `inheritLocations`: _Controla se as configurações de localização devem ser herdadas das classes pai. Se for definido como false, o teste substituirá as configurações das classes pai._ 1187 | - `inheritInitializers`: _Controla se as configurações de inicialização devem ser herdadas das classes pai. Se for definido como false, o teste substituirá as configurações das classes pai._ 1188 | - `name`: _Define o nome do nível de hierarquia de contexto. Isso é útil ao usar @ContextHierarchy para configurar hierarquias de contextos em classes de teste aninhadas._ 1189 | - `resourcePath`: _Permite que você configure o local onde o aplicativo da ‘web’ deve ser procurado para os testes. Se você não fornecer um valor para resourcePath(), ele usará o valor padrão "src/main/webapp"._ 1190 | 1191 | - ${\color{yellow}@Sql}$ : _@Sql é usada para configurar scripts SQL a serem executados durante testes de integração._ 1192 | 1193 | **Parâmetros:** 1194 | 1195 | - `scripts`: _Permite especificar uma lista de caminhos para scripts SQL que serão executados durante os testes de integração._ 1196 | - `statements`: _permite adicionar diretamente instruções SQL a serem executadas durante os testes. Isso pode ser útil quando você precisa executar instruções SQL específicas que não estão em arquivos separados._ 1197 | - `executionPhase`: _Determina quando os scripts e instruções SQL devem ser executados, ou seja, se eles serão executados antes ou depois do método de teste._ 1198 | - `config`: _permite configurar opções específicas para os scripts e instruções SQL nesta anotação. Você pode definir coisas como delimitadores de scripts, comportamento em caso de erros, etc._ 1199 | 1200 | - ${\color{yellow}@SqlConfig}$ : _@SqlConfig é usada no contexto do Spring Framework para configurar metadados que determinam como os scripts SQL devem ser analisados e executados._ 1201 | 1202 | **Parâmetros:** 1203 | 1204 | - `dataSource`: _Define o nome do bean do javax.sql.DataSource no qual os scripts SQL devem ser executados._ 1205 | - `transactionManager`: _Define o nome do bean do PlatformTransactionManager que deve ser usado para gerir as transações ao executar os scripts SQL._ 1206 | - `transactionMode`: _Define o modo de transação a ser usado ao executar os scripts SQL. O padrão é TransactionMode.DEFAULT, que usa as regras de inferência para determinar o comportamento da transação. Pode ser configurado como TransactionMode.ISOLATED para executar os scripts em uma nova transação isolada que será imediatamente confirmada._ 1207 | - `encoding`: _Define a codificação a ser usada para os scripts SQL fornecidos, se diferir da codificação da plataforma._ 1208 | - `separator`: _Define o caractere ou sequência de caracteres que separa as instruções individuais nos scripts SQL. O padrão é ;, mas, se não estiver especificado, o mecanismo usará \n como último recurso._ 1209 | - `commentPrefix`: _Define o prefixo que identifica comentários de uma linha nos scripts SQL. O valor padrão é --._ 1210 | - `commentPrefixes`: _Uma alternativa ao commentPrefix, esse atributo permite definir uma matriz de prefixos que identificam comentários de uma linha. O valor padrão é ["--"]._ 1211 | - `blockCommentStartDelimiter`: _Define o delimitador de início que identifica comentários de bloco nos scripts SQL. O valor padrão é /*._ 1212 | - `blockCommentEndDelimiter`: _Define o delimitador de término que identifica comentários de bloco nos scripts SQL. O valor padrão é */._ 1213 | - `errorMode`: _Define o modo de tratamento de erros ao executar instruções SQL. O valor padrão é ErrorMode.DEFAULT, que segue as regras padrão. Pode ser configurado como ErrorMode.FAIL_ON_ERROR para fazer com que a execução do script falhe se ocorrer um erro, ErrorMode.CONTINUE_ON_ERROR para continuar a execução e registrar erros ou ErrorMode.IGNORE_FAILED_DROPS para ignorar erros em declarações SQL DROP._ 1214 | 1215 | ${\color{yellow}@SqlGroup}$ : _@SqlGroup é uma anotação de container que agrega várias anotações @Sql._ 1216 | 1217 | **Parâmetros:** 1218 | 1219 | - `value`: _Lista de anotações @Sql._ 1220 | 1221 | ${\color{yellow}@SqlMergeMode}$ : _@SqlMergeMode é usada para configurar como as declarações de anotação @Sql em nível de classe devem ser mescladas com as declarações de anotação @Sql em nível de método em testes de integração no contexto do Spring Framework._ 1222 | 1223 | **Parâmetros:** 1224 | 1225 | - `value`: _Indica se as anotações @Sql em nível de método devem ser mescladas com anotações @Sql em nível de classe ou substituí-las._ 1226 | 1227 | ${\color{yellow}@TestConstructor}$ : _@TestConstructor é usada em classes de teste para configurar como os parâmetros do construtor da classe de teste são injetados a partir dos componentes no contexto da aplicação do Spring._ 1228 | 1229 | **Parâmetros:** 1230 | 1231 | - `autowireMode`: _Indica como os parâmetros do construtor do teste devem ser injetados._ 1232 | 1233 | ${\color{yellow}@TestExecutionListeners}$ : _@TestExecutionListeners é usada em classes de teste para configurar quais ouvintes de execução de teste (TestExecutionListeners) devem ser registrados com um TestContextManager. Os ouvintes de execução de teste são usados para executar ações específicas em diferentes estágios da execução de testes, como configuração, inicialização, encerramento, etc._ 1234 | 1235 | **Parâmetros:** 1236 | 1237 | - `value / listeners`: _Permite que você forneça uma lista de classes que implementam a ‘interface’ TestExecutionListener._ 1238 | - `mergeMode`: _Especifica como os ouvintes locais devem ser tratados em relação aos ouvintes padrão._ 1239 | - `inheritListeners`: _Define se a classe irá ou não ocultar e substituir efetivamente quaisquer ouvintes definidos por uma superclasse ou classe envolvente._ 1240 | 1241 | ${\color{yellow}@TestPropertySource}$ : _@TestPropertySource é usada em testes de integração no contexto do Spring ‘Framework’ para configurar a carga de propriedades a serem adicionadas ao ambiente (Environment) do aplicativo durante a execução dos testes._ 1242 | 1243 | **Parâmetros:** 1244 | 1245 | - `value / locations`: _Especifica as localizações dos arquivos de propriedades a serem carregados no ambiente durante a execução dos testes._ 1246 | - `inheritLocations`: _Define se as localizações definidas em superclasses ou classes contendo essa anotação devem ser herdadas._ 1247 | - `properties`: _Permite definir propriedades in-line como pares chave-valor para serem adicionados ao ambiente de teste antes da inicialização do contexto do aplicativo._ 1248 | - `inheritProperties`: _Define se as propriedades in-line definidas em superclasses ou classes contendo essa anotação devem ser herdadas._ 1249 | 1250 | ${\color{yellow}@TestPropertySources}$ : _@TestPropertySources é um container para uma ou mais declarações de @TestPropertySource. O seu propósito é agrupar várias fontes de propriedades em um único lugar._ 1251 | 1252 | **Parâmetros:** 1253 | 1254 | - `value`: _Este atributo permite especificar uma matriz de uma ou mais declarações de @TestPropertySource._ 1255 | 1256 | ${\color{yellow}@Timed}$ : _@Timed é uma anotação de teste que pode ser usada com o ‘framework’ JUnit 4 para indicar que um método de teste deve ser concluído num período especificado._ 1257 | 1258 | **Parâmetros:** 1259 | 1260 | - `millis`: _Define o período máximo (em milissegundos) que a execução do teste pode levar antes de ser marcada como falha devido a um tempo limite excedido._ 1261 | 1262 | ${\color{yellow}@WebAppConfiguration}$ : _@WebAppConfiguration é uma anotação de nível de classe usada para declarar que o ApplicationContext carregado para um teste de integração deve ser um WebApplicationContext._ 1263 | 1264 | **Parâmetros:** 1265 | 1266 | - `value`: _Este atributo permite especificar o caminho para o diretório raiz da aplicação da ‘web’. O contexto da ‘web’ é uma parte importante de muitas aplicações da ‘web’ Spring e é necessário para testar funcionalidades relacionadas à web._ 1267 | 1268 | ## Spring-web 1269 | 1270 | ${\color{yellow}@ ApplicationScope}$ : _@ApplicationScope é usada para definir o escopo de um componente como "application", o que significa que o componente terá uma única instância por aplicação da ‘web’._ 1271 | 1272 | **Parâmetros:** 1273 | 1274 | - `proxyMode`: _Especifica o modo de proxy a ser usado para o escopo. O modo de proxy determina como os componentes gerenciados pelo Spring ‘Framework’ se comportam em relação à criação de proxies para o componente._ 1275 | 1276 | ${\color{yellow}@ControllerAdvice}$ : _@ControllerAdvice é usada em Spring Framework para declarar classes que atuam como conselheiros (advisors) para controladores (controllers). Essas classes podem conter métodos anotados com @ExceptionHandler, @InitBinder, ou @ModelAttribute para serem compartilhados entre vários controladores._ 1277 | 1278 | **Parâmetros:** 1279 | 1280 | - `value / basePackages`: _Permite especificar um ou mais pacotes de onde os controladores serão selecionados para serem aconselhados pela classe anotada com @ControllerAdvice._ 1281 | - `basePackageClasses`: _Alternativa ("Type-safe") especificando os pacotes para verificar as propriedades de configuração. O pacote de cada classe especificada será verificado._ 1282 | - `assignableTypes`: _Pode fornecer uma ou mais classes para esta propriedade. Controladores que sejam atribuíveis a pelo menos uma das classes fornecidas serão aconselhados pela classe anotada com @ControllerAdvice._ 1283 | - `annotations`: _Permite especificar uma ou mais anotações._ 1284 | 1285 | ${\color{yellow}@CookieValue}$ : _@CookieValue é usada em Spring ‘Framework’ para indicar que um parâmetro de método está vinculado a um ‘cookie’ HTTP. Essa anotação é frequentemente usada em métodos de controladores que lidam com solicitações da ‘web’ para acessar valores de ‘cookies’ enviados pelos clientes._ 1286 | 1287 | **Parâmetros:** 1288 | 1289 | - `value / name`: _Permite especificar o nome do cookie ao qual o parâmetro do método deve ser vinculado._ 1290 | - `required`: _Determina se o ‘cookie’ é obrigatório ou opcional._ 1291 | - `defaultValue`: _Esta propriedade permite fornecer um valor padrão para o caso em que o ‘cookie’ não está presente na solicitação._ 1292 | 1293 | ${\color{yellow}@CrossOrigin}$ : _@CrossOrigin é usada para permitir solicitações de origens cruzadas (CORS) em classes de controladores específicas e/ou métodos de controladores no contexto do Spring ‘Framework’. O CORS é um mecanismo de segurança que permite ou restringe solicitações de recursos da ‘web’ de um domínio diferente do domínio da página que faz a solicitação._ 1294 | 1295 | **Parâmetros:** 1296 | 1297 | - `value / origins`: _Permite especificar uma lista de origens a partir das quais as solicitações CORS serão permitidas._ 1298 | - `originPatterns`: _Alternativa para a propriedade origins que suporta padrões de origem mais flexíveis. Isso é útil quando você deseja permitir solicitações de várias origens com padrões comuns._ 1299 | - `allowedHeaders`: _Permite especificar uma lista de cabeçalhos de solicitação permitidos em solicitações reais. Você pode definir essa lista ou usar * para permitir todos os cabeçalhos._ 1300 | - `exposedHeaders`: _Pode listar os cabeçalhos que o navegador deve permitir que o cliente acesse na resposta real. Por padrão, nenhum cabeçalho é listado como exposto._ 1301 | - `methods`: _Permite especificar uma lista de métodos HTTP suportados para as solicitações CORS. Por padrão, os métodos suportados são os mesmos que os métodos mapeados para o método do controlador._ 1302 | - `allowCredentials`: _Controla se o navegador deve enviar credenciais (como ‘cookies’) com as solicitações CORS. Use essa propriedade com cuidado, pois permitir credenciais pode aumentar o risco de ataques. Por padrão, as credenciais não são permitidas._ 1303 | - `maxAge`: _Controla a duração em segundos em que os navegadores devem armazenar em cache as respostas preflight (solicitações de opções). Definir um valor razoável pode reduzir o número de interações preflight entre o navegador e o servidor. O valor padrão é de 30 minutos (1800 segundos)._ 1304 | 1305 | ${\color{yellow}@DeleteExchange}$ : _@DeleteExchange é uma anotação de atalho que simplifica a criação de um ponto de extremidade HTTP para requisições DELETE numa API ou aplicação ‘web’. Ela é usada para marcar métodos que devem ser acionados quando uma solicitação HTTP DELETE é feita para um recurso específico. Essa anotação é uma extensão do Spring Framework, introduzida na versão 6.0, e é útil para simplificar a configuração de controladores e métodos que lidam com requisições DELETE._ 1306 | 1307 | **Parâmetros:** 1308 | 1309 | - `value / url`: _Permite especificar o URL do ponto de extremidade do recurso, que é o mesmo que a propriedade value._ 1310 | - `contentType`: _Permite especificar o tipo de mídia do conteúdo da solicitação DELETE, se aplicável._ 1311 | - `accept`: _Permite especificar os tipos de mídia que o servidor aceita como resposta à solicitação DELETE. Isso pode ser útil para negociar o tipo de resposta desejado._ 1312 | 1313 | ${\color{yellow}@DeleteMapping}$ : _@DeleteMapping é uma anotação do Spring ‘Framework’ usada para mapear solicitações HTTP DELETE em métodos de controlador específicos. Essa anotação é uma forma concisa de definir um método de controlador que lida com solicitações DELETE para um recurso específico em uma aplicação web. A anotação @DeleteMapping é uma das anotações de mapeamento HTTP que simplifica a configuração do roteamento em aplicativos Spring MVC._ 1314 | 1315 | **Parâmetros:** 1316 | 1317 | - `value / name`: _É usado para especificar o URI do ponto de extremidade do recurso que deve corresponder à solicitação DELETE. O URI é uma ‘string’ que define o caminho relativo a partir do contexto da ‘web’._ 1318 | - `path`: _Também é usado para especificar o URI do ponto de extremidade do recurso._ 1319 | - `params`: _Permite especificar parâmetros de solicitação que devem estar presentes para que o método seja acionado._ 1320 | - `headers`: _Permite especificar cabeçalhos de solicitação que devem estar presentes para que o método seja acionado._ 1321 | - `consumes`: _Define os tipos de mídia que o método é capaz de consumir._ 1322 | - `produces`: _Define os tipos de mídia dos quais o método consegue produzir saídas._ 1323 | 1324 | ${\color{yellow}@ExceptionHandler}$ : _@ExceptionHandler é uma anotação do Spring ‘Framework’ usada para manipular exceções em classes ou métodos de controlador específicos. Essa anotação permite que você defina métodos de tratamento de exceção que serão acionados quando uma exceção específica for lançada durante a execução de uma solicitação. Os métodos anotados com @ExceptionHandler podem lidar com diferentes tipos de exceções e tomar medidas apropriadas, como retornar uma página de erro personalizada ou enviar uma resposta JSON._ 1325 | 1326 | **Parâmetros:** 1327 | 1328 | - `value / name`: _Define qual o tipo de exceção que o método de tratamento irá lidar._ 1329 | 1330 | ${\color{yellow}@GetExchange}$ : _@GetExchange usada para mapear métodos de manipulação de solicitações HTTP GET em um aplicativo Spring. Ela simplifica a configuração, especificando que um método é mapeado para solicitações HTTP GET._ 1331 | 1332 | **Parâmetros:** 1333 | 1334 | - `value / url`: _Define o caminho da URL da solicitação GET a ser manipulada pelo método._ 1335 | - `accept`: _Permite que você defina os tipos de mídia que o método aceitará como resposta._ 1336 | 1337 | ${\color{yellow}@GetMapping}$ : _@GetMapping é uma anotação do Spring ‘Framework’ usada para mapear solicitações HTTP GET em métodos de controlador específicos. Essa anotação é uma forma concisa de definir um método de controlador que lida com solicitações GET para um recurso específico em uma aplicação web. A anotação @GetMapping é uma das anotações de mapeamento HTTP que simplifica a configuração do roteamento em aplicativos Spring MVC._ 1338 | 1339 | **Parâmetros:** 1340 | 1341 | - `name`: _Alias para @RequestMapping.name. Especifica o nome da rota que será usada._ 1342 | - `value`: _Alias para @RequestMapping.value. Especifica o URI do ponto de extremidade do recurso que deve corresponder à solicitação GET. O URI é uma ‘string’ que define o caminho relativo a partir do contexto da ‘web’._ 1343 | - `path`: _Alias para @RequestMapping.path. Também é usado para especificar o URI do ponto de extremidade do recurso._ 1344 | - `params`: _Alias para @RequestMapping.params. Permite especificar parâmetros de solicitação que devem estar presentes para que o método seja acionado._ 1345 | - `headers`: _Alias para @RequestMapping.headers. Permite especificar cabeçalhos de solicitação que devem estar presentes para que o método seja acionado._ 1346 | - `consumes`: _Alias para @RequestMapping.consumes. Define os tipos de mídia que o método é capaz de consumir._ 1347 | - `produces`: _Alias para @RequestMapping.produces. Define os tipos de mídia dos quais o método consegue produzir saídas._ 1348 | 1349 | 1350 | ${\color{yellow}@HttpExchange}$ : _@HttpExchange é uma anotação do Spring ‘Framework’ usada para declarar um método em uma interface de serviço HTTP como um ponto de extremidade HTTP. Detalhes do ponto de extremidade são definidos estaticamente através dos atributos da anotação, bem como através dos tipos de argumentos do método de entrada._ 1351 | 1352 | **Parâmetros:** 1353 | 1354 | - `value / url`: _Alias para @HttpExchange.url. Especifica o URL para a solicitação, que pode ser um URL completo ou apenas um caminho relativo a um URL declarado em um nível de tipo @HttpExchange e/ou um URL base configurado globalmente. Por padrão, está vazio._ 1355 | - `method`: _Especifica o método HTTP a ser usado. Suportado tanto no nível de tipo quanto no nível de método. Quando usado no nível de tipo, todas as mapeamentos de nível de método herdam este valor. Por padrão, está vazio._ 1356 | - `contentType`: _Define o tipo de mídia para o cabeçalho "Content-Type". Suportado tanto no nível de tipo quanto no nível de método, caso em que os valores de nível de método substituem os valores de nível de tipo. Por padrão, está vazio._ 1357 | - `accept`: _Define os tipos de mídia para o cabeçalho "Accept". Suportado tanto no nível de tipo quanto no nível de método, caso em que os valores de nível de método substituem os valores de nível de tipo. Por padrão, está vazio._ 1358 | 1359 | Esta anotação também permite o uso de vários tipos de argumentos de método, como URI, UriBuilderFactory, HttpMethod, entre outros, para configurar dinamicamente o comportamento da solicitação. 1360 | 1361 | ${\color{yellow}@InitBinder}$ : _@InitBinder é uma anotação do Spring ‘Framework’ usada para identificar métodos que inicializam o `WebDataBinder`, que será usado para popular argumentos de objeto de comando e formulário de métodos de manipulador anotados. Essa anotação é importante para personalizar a vinculação de dados e registrar editores específicos do contexto._ 1362 | 1363 | **Parâmetros:** 1364 | 1365 | - `value`: _Os nomes dos atributos de comando/formulário e/ou parâmetros de solicitação aos quais este método init-binder deve ser aplicado. O padrão é aplicar a todos os atributos de comando/formulário e a todos os parâmetros de solicitação processados pela classe do manipulador anotado. Especificar nomes de atributos de modelo ou nomes de parâmetros de solicitação aqui restringe o método init-binder a esses atributos/parâmetros específicos, com diferentes métodos init-binder tipicamente aplicando a diferentes grupos de atributos ou parâmetros._ 1366 | 1367 | **Notas adicionais:** 1368 | 1369 | - _Métodos `@InitBinder` suportam todos os argumentos que os métodos `@RequestMapping` suportam, exceto objetos de comando/formulário e objetos de resultado de validação correspondentes._ 1370 | - _Métodos `@InitBinder` não devem ter um valor de retorno; eles são geralmente declarados como `void`._ 1371 | - _Argumentos típicos são `WebDataBinder` em combinação com `WebRequest` ou `Locale`, permitindo registrar editores específicos do contexto._ 1372 | 1373 | 1374 | ${\color{yellow}@Mapping}$ : _@Mapping é uma meta-anotação do Spring ‘Framework’ que indica uma anotação de mapeamento web. Essa meta-anotação é usada para marcar outras anotações que são responsáveis por mapear solicitações HTTP para métodos específicos em controladores._ 1375 | 1376 | Esta meta-anotação não possui parâmetros adicionais além dos padrões fornecidos pelo próprio Java para anotações. 1377 | 1378 | ${\color{yellow}@MatrixVariable}$ : _@MatrixVariable é uma anotação do Spring ‘Framework’ que indica que um parâmetro de método deve ser vinculado a um par nome-valor dentro de um segmento de caminho. Esta anotação é suportada para métodos manipuladores anotados com @RequestMapping._ 1379 | 1380 | **Parâmetros:** 1381 | 1382 | - `value / name`: _Alias para @MatrixVariable.name. Especifica o nome da variável de matriz. Se o tipo do parâmetro do método for java.util.Map e um nome de variável de matriz for especificado, o valor da variável de matriz será convertido em um java.util.Map, assumindo que uma estratégia de conversão apropriada está disponível. Se o tipo do parâmetro do método for Map ou MultiValueMap e nenhum nome de variável for especificado, o mapa será populado com todos os nomes e valores de variáveis de matriz._ 1383 | 1384 | - `pathVar`: _O nome da variável de caminho URI onde a variável de matriz está localizada, se necessário para desambiguação (por exemplo, uma variável de matriz com o mesmo nome presente em mais de um segmento de caminho)._ 1385 | 1386 | - `required`: _Define se a variável de matriz é obrigatória. Por padrão, é true, o que gera uma exceção se a variável estiver ausente na solicitação. Pode ser alterado para false para retornar null caso a variável esteja ausente. Alternativamente, pode-se fornecer um defaultValue, o que implicitamente define este flag como false._ 1387 | 1388 | - `defaultValue`: _O valor padrão a ser utilizado como fallback. Fornecer um valor padrão implicitamente define required como false._ 1389 | 1390 | Esta anotação é usada para vincular parâmetros de variáveis de matriz em URLs, permitindo que esses parâmetros sejam extraídos e utilizados nos métodos de controlador. 1391 | 1392 | ${\color{yellow}@ModelAttribute}$ : _@ModelAttribute é uma anotação do Spring ‘Framework’ que vincula um parâmetro de método ou o valor de retorno de um método a um atributo de modelo nomeado, exposto a uma visualização web. É suportado para classes de controlador com métodos @RequestMapping._ 1393 | 1394 | **Parâmetros:** 1395 | 1396 | - `value / name`: _Alias para @ModelAttribute.name. Especifica o nome do atributo de modelo ao qual vincular. O nome padrão do atributo de modelo é inferido a partir do tipo de atributo declarado (ou seja, o tipo do parâmetro do método ou o tipo de retorno do método), com base no nome da classe não qualificado: por exemplo, "orderAddress" para a classe "meupacote.EndereçoPedido", ou "orderAddressList" para "List"._ 1397 | 1398 | - `binding`: _Permite desativar o binding de dados diretamente em um parâmetro de método @ModelAttribute ou no atributo retornado de um método @ModelAttribute, o que impediria o binding de dados para esse atributo. Por padrão, isso é definido como true, aplicando o binding de dados. Defina isso como false para desativar o binding de dados._ 1399 | 1400 | Esta anotação é fundamental para expor objetos de comando (command objects) ou dados de referência para uma visualização web, facilitando a integração entre o modelo de dados e as visualizações renderizadas pelo Spring MVC. 1401 | 1402 | ${\color{yellow}@PatchMapping}$ : _@PatchMapping é uma anotação do Spring ‘Framework’ usada para mapear solicitações HTTP PATCH em métodos de controlador específicos._ 1403 | 1404 | **Parâmetros:** 1405 | 1406 | - `value / name`: _É usado para especificar o URI do ponto de extremidade do recurso que deve corresponder à solicitação PATCH. O URI é uma ‘string’ que define o caminho relativo a partir do contexto da ‘web’._ 1407 | - `path`: _Também é usado para especificar o URI do ponto de extremidade do recurso._ 1408 | - `params`: _Permite especificar parâmetros de solicitação que devem estar presentes para que o método seja acionado._ 1409 | - `headers`: _Permite especificar cabeçalhos de solicitação que devem estar presentes para que o método seja acionado._ 1410 | - `consumes`: _Define os tipos de mídia que o método é capaz de consumir._ 1411 | - `produces`: _Define os tipos de mídia dos quais o método consegue produzir saídas._ 1412 | 1413 | ${\color{yellow}@PathVariable}$ : _@PathVariable é uma anotação do Spring ‘Framework’ usada para vincular um parâmetro de método a uma variável de modelo de URI. Essa anotação é usada em métodos de controlador anotados com @RequestMapping para capturar valores de variáveis de caminho em uma solicitação HTTP. Ela simplifica a extração de dados de variáveis de URI em métodos de controle de Spring MVC._ 1414 | 1415 | **Parâmetros:** 1416 | 1417 | - `value / name`: _É usado para especificar o nome da variável de caminho na URI que será vinculada ao parâmetro do método._ 1418 | - `required`: _Define se a variável de caminho é obrigatória. O padrão é true, o que significa que uma exceção será lançada se a variável de caminho estiver ausente na solicitação. Altere para false se preferir permitir um valor nulo ou Optional do Java 8._ 1419 | 1420 | ${\color{yellow}@PostMapping}$ : _@PostMapping é uma anotação do Spring ‘Framework’ usada para mapear solicitações HTTP POST em métodos de controlador específicos. 1421 | 1422 | **Parâmetros:** 1423 | 1424 | - `value / name`: _É usado para especificar o URI do ponto de extremidade do recurso que deve corresponder à solicitação POST. O URI é uma ‘string’ que define o caminho relativo a partir do contexto da ‘web’._ 1425 | - `path`: _Também é usado para especificar o URI do ponto de extremidade do recurso._ 1426 | - `params`: _Permite especificar parâmetros de solicitação que devem estar presentes para que o método seja acionado._ 1427 | - `headers`: _Permite especificar cabeçalhos de solicitação que devem estar presentes para que o método seja acionado._ 1428 | - `consumes`: _Define os tipos de mídia que o método é capaz de consumir._ 1429 | - `produces`: _Define os tipos de mídia dos quais o método consegue produzir saídas._ 1430 | 1431 | ${\color{yellow}@PutMapping}$ : _@PutMapping é uma anotação do Spring ‘Framework’ usada para mapear solicitações HTTP PUT em métodos de controlador específicos._ 1432 | 1433 | **Parâmetros:** 1434 | 1435 | - `value / name`: _É usado para especificar o URI do ponto de extremidade do recurso que deve corresponder à solicitação PUT. O URI é uma ‘string’ que define o caminho relativo a partir do contexto da ‘web’._ 1436 | - `path`: _Também é usado para especificar o URI do ponto de extremidade do recurso._ 1437 | - `params`: _Permite especificar parâmetros de solicitação que devem estar presentes para que o método seja acionado._ 1438 | - `headers`: _Permite especificar cabeçalhos de solicitação que devem estar presentes para que o método seja acionado._ 1439 | - `consumes`: _Define os tipos de mídia que o método é capaz de consumir._ 1440 | - `produces`: _Define os tipos de mídia dos quais o método consegue produzir saídas._ 1441 | 1442 | ${\color{yellow}@PatchExchange}$ : _@PatchExchange é uma anotação do Spring ‘Framework’ usada para mapear solicitações HTTP PATCH em métodos de serviço específicos. Essa anotação é uma forma concisa de definir um método que lida com solicitações PATCH para um recurso específico em uma aplicação web. A anotação @PatchExchange é uma abreviação para a anotação @HttpExchange com método PATCH._ 1443 | 1444 | **Parâmetros:** 1445 | 1446 | - `value`: _Especifica o valor do recurso para o qual a solicitação PATCH deve ser feita._ 1447 | - `url`: _Especifica a URL do recurso para o qual a solicitação PATCH deve ser feita._ 1448 | - `contentType`: _Define o tipo de conteúdo da solicitação PATCH._ 1449 | - `accept`: _Define os tipos de mídia que o método é capaz de aceitar na resposta._ 1450 | 1451 | ${\color{yellow}@PostExchange}$ : _@PostExchange é uma anotação do Spring ‘Framework’ usada para mapear solicitações HTTP POST em métodos de serviço específicos. Essa anotação é uma forma concisa de definir um método que lida com solicitações POST para um recurso específico em uma aplicação web. A anotação @PostExchange é uma abreviação para a anotação @HttpExchange com método POST._ 1452 | 1453 | **Parâmetros:** 1454 | 1455 | - `value`: _Especifica o valor do recurso para o qual a solicitação POST deve ser feita._ 1456 | - `url`: _Especifica a URL do recurso para o qual a solicitação POST deve ser feita._ 1457 | - `contentType`: _Define o tipo de conteúdo da solicitação POST._ 1458 | - `accept`: _Define os tipos de mídia que o método é capaz de aceitar na resposta._ 1459 | 1460 | ${\color{yellow}@PutExchange}$ : _@PutExchange é uma anotação do Spring ‘Framework’ usada para mapear solicitações HTTP PUT em métodos de serviço específicos. Essa anotação é uma forma concisa de definir um método que lida com solicitações PUT para um recurso específico em uma aplicação web. A anotação @PutExchange é uma abreviação para a anotação @HttpExchange com método PUT._ 1461 | 1462 | **Parâmetros:** 1463 | 1464 | - `value`: _Especifica o valor do recurso para o qual a solicitação PUT deve ser feita._ 1465 | - `url`: _Especifica a URL do recurso para o qual a solicitação PUT deve ser feita._ 1466 | - `contentType`: _Define o tipo de conteúdo da solicitação PUT._ 1467 | - `accept`: _Define os tipos de mídia que o método é capaz de aceitar na resposta._ 1468 | 1469 | ${\color{yellow}@RequestScope}$ : _@RequestScope é uma anotação do Spring ‘Framework’ que especializa o escopo de {@link Scope @Scope} para um componente cujo ciclo de vida está vinculado à requisição web atual. Esta anotação atua como uma abreviação para {@code @Scope("request")} com {@link #proxyMode} padrão definido como {@link ScopedProxyMode#TARGET_CLASS TARGET_CLASS}._ 1470 | 1471 | **Parâmetros:** 1472 | 1473 | - `proxyMode`: _Define o modo de proxy para o escopo, onde {@link ScopedProxyMode#TARGET_CLASS TARGET_CLASS} é o padrão._ 1474 | 1475 | A anotação `@RequestScope` pode ser usada como uma meta-anotação para criar anotações compostas personalizadas. 1476 | 1477 | ${\color{yellow}@RequestAttribute}$ : _@RequestAttribute é uma anotação do Spring ‘Framework’ usada para vincular um parâmetro de método a um atributo de requisição. A principal motivação é fornecer acesso conveniente aos atributos de requisição a partir de um método de controlador com verificação opcional/necessária e conversão para o tipo de parâmetro de método alvo._ 1478 | 1479 | **Parâmetros:** 1480 | 1481 | - `value / name`: _É usado para especificar o nome do atributo de requisição ao qual se vincular. O nome padrão é inferido a partir do nome do parâmetro do método._ 1482 | - `required`: _Define se o atributo de requisição é obrigatório. Por padrão, é {@code true}, o que resulta em uma exceção se o atributo estiver ausente._ 1483 | 1484 | A anotação `@RequestAttribute` facilita o acesso aos atributos de requisição diretamente nos métodos de controlador do Spring. 1485 | 1486 | ${\color{yellow}@RequestBody}$ : _@RequestBody é uma anotação do Spring ‘Framework’ usada para vincular um parâmetro de método ao corpo da solicitação ‘web’. O corpo da solicitação é convertido através de um ${\color{blue}HttpMessageConverter}$ para resolver o argumento do método, dependendo do tipo de conteúdo da solicitação. Opcionalmente, a validação automática pode ser aplicada anotando o argumento com ${\color{blue}@Valid}$._ 1487 | 1488 | **Parâmetros:** 1489 | 1490 | - `value / name`: _Não aplicável nesta anotação._ 1491 | - `required`: _Indica se o conteúdo do corpo da solicitação é obrigatório. O padrão é ${\color{blue}true}$, o que resulta em uma exceção se o corpo estiver ausente. Mude para ${\color{blue}false}$ se preferir passar ${\color{blue}null}$ quando o corpo da solicitação for ${\color{blue}null}$._ 1492 | 1493 | 1494 | ${\color{yellow}@RequestHeader}$ : _@RequestHeader é uma anotação do Spring ‘Framework’ usada para vincular um parâmetro de método a um cabeçalho de solicitação ‘web’. Se o parâmetro do método for um ${\color{blue}Map}$, ${\color{blue}MultiValueMap}$ ou ${\color{blue}HttpHeaders}$, o mapa será populado com todos os nomes e valores dos cabeçalhos._ 1495 | 1496 | **Parâmetros:** 1497 | 1498 | - `value / name`: _O nome do cabeçalho de solicitação a ser vinculado._ 1499 | - `required`: _Indica se o cabeçalho é obrigatório. O padrão é ${\color{blue}true}$, o que resulta em uma exceção se o cabeçalho estiver ausente na solicitação. Mude para ${\color{blue}false}$ se preferir um valor ${\color{blue}null}$ se o cabeçalho não estiver presente._ 1500 | - `defaultValue`: _O valor padrão a ser usado como fallback. Fornecer um valor padrão implicitamente define ${\color{blue}required}$ como ${\color{blue}false}$._ 1501 | 1502 | ${\color{yellow}@RequestMapping}$ : _@RequestMapping é uma anotação do Spring ‘Framework’ usada para mapear solicitações ‘web’ para métodos em classes de manipulação de solicitações, com assinaturas de métodos flexíveis._ 1503 | 1504 | **Parâmetros:** 1505 | 1506 | - `value / path`: _URIs de mapeamento de caminho, por exemplo, "/perfil". Padrão para @RequestMapping. O padrão é aplicável ao nível do tipo e também ao nível do método!_ 1507 | - `method`: _Os métodos de solicitação HTTP para os quais mapear: GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE. Suportado no nível do tipo e do método!_ 1508 | - `params`: _Os parâmetros da solicitação mapeada, estreitando o mapeamento primário._ 1509 | - `headers`: _Os cabeçalhos da solicitação mapeada, estreitando o mapeamento primário._ 1510 | - `consumes`: _Restringe o mapeamento primário por tipos de mídia que podem ser consumidos pelo manipulador mapeado._ 1511 | - `produces`: _Restringe o mapeamento primário por tipos de mídia que podem ser produzidos pelo manipulador mapeado._ 1512 | 1513 | ${\color{yellow}@RequestParam}$ : _@RequestParam é uma anotação do Spring ‘Framework’ usada para vincular um parâmetro de método a um parâmetro de solicitação ‘web’._ 1514 | 1515 | **Parâmetros:** 1516 | 1517 | - `value / name`: _O nome do parâmetro de solicitação a ser vinculado._ 1518 | - `required`: _Se o parâmetro é obrigatório. O padrão é verdadeiro, levando a uma exceção se o parâmetro estiver ausente na solicitação._ 1519 | - `defaultValue`: _O valor padrão a ser usado se o parâmetro de solicitação não for fornecido ou tiver um valor vazio._ 1520 | 1521 | ${\color{yellow}@RequestPart}$ : _@RequestPart é uma anotação do Spring ‘Framework’ usada para associar uma parte de uma solicitação "multipart/form-data" a um argumento de método._ 1522 | 1523 | **Parâmetros:** 1524 | 1525 | - `value / name`: _O nome da parte na solicitação "multipart/form-data" a ser associada._ 1526 | - `required`: _Se a parte é obrigatória. O padrão é verdadeiro, levando a uma exceção se a parte estiver ausente na solicitação._ 1527 | 1528 | ${\color{yellow}@ResponseBody}$ : _@ResponseBody é uma anotação do Spring Framework usada para indicar que o valor de retorno de um método deve ser vinculado ao corpo da resposta da web._ 1529 | 1530 | ${\color{yellow}@ResponseStatus}$ : _@ResponseStatus é uma anotação do Spring Framework usada para marcar um método ou classe de exceção com um código de status e razão que devem ser retornados._ 1531 | 1532 | **Parâmetros:** 1533 | 1534 | - `value`: _O código de status HTTP a ser usado para a resposta._ 1535 | - `reason`: _Defina o motivo como um valor não vazio para que seja usado para enviar uma página de erro do contêiner do Servlet._ 1536 | 1537 | Esta anotação permite definir o código de status e a razão que devem ser retornados em resposta a uma solicitação, sendo aplicada quando o método de manipulação é invocado. No entanto, ela não substitui as informações de status definidas por outros meios, como ResponseEntity ou redirecionamentos. 1538 | 1539 | ${\color{yellow}@RestController}$ : _@RestController é uma anotação do Spring Framework que combina as anotações @Controller e @ResponseBody. Isso indica que os métodos marcados com @RequestMapping dentro dessa classe devem retornar diretamente o objeto e não uma visualização, permitindo a criação de APIs RESTful de maneira simplificada._ 1540 | 1541 | **Parâmetros:** 1542 | 1543 | - `value`: _Indica um nome sugerido para o componente lógico, que pode ser transformado em um bean do Spring quando o componente é detectado automaticamente._ 1544 | 1545 | Essa anotação é especialmente útil para criar controladores que respondem diretamente com objetos JSON ou XML, sem a necessidade de uma visualização intermediária. Ela é processada automaticamente pelo Spring se um par apropriado de `HandlerMapping` e `HandlerAdapter` estiver configurado, como o par padrão `RequestMappingHandlerMapping` e `RequestMappingHandlerAdapter`. 1546 | 1547 | ${\color{yellow}@ControllerAdvice}$ : _@ControllerAdvice é uma anotação do Spring ‘Framework’ que define um componente que intercepta os controllers para customizar o comportamento de exceções. Quando combinado com @ExceptionHandler, é usado para capturar exceções globais em toda a aplicação Spring MVC._ 1548 | 1549 | **Parâmetros:** 1550 | 1551 | - `name`: _Define um nome para o componente de advice._ 1552 | - `basePackages`: _Array de strings que define os pacotes base onde os controllers devem ser incluídos._ 1553 | - `basePackageClasses`: _Array de classes que define classes base que servem como ponto de referência para incluir controllers._ 1554 | - `assignableTypes`: _Array de classes que define tipos de classes aos quais os controllers devem ser atribuíveis para serem incluídos._ 1555 | - `annotations`: _Array de classes de anotações que define anotações que os controllers devem ter para serem incluídos._ 1556 | 1557 | 1558 | ${\color{yellow}@SessionScope}$ : _@SessionScope é uma especialização de @Scope para um componente cujo ciclo de vida está vinculado à sessão web atual. Esta anotação atua como um atalho para @Scope("session") com o modo de proxy padrão configurado como TARGET_CLASS._ 1559 | 1560 | **Parâmetros:** 1561 | 1562 | - `proxyMode`: _Define o modo de proxy por padrão utiliza o ScopedProxyMode.TARGET_CLASS._ 1563 | 1564 | 1565 | ${\color{yellow}@SessionAttribute}$ : _@SessionAttribute é uma anotação do Spring ‘Framework’ usada para vincular um parâmetro de método a um atributo de sessão. A principal motivação é fornecer acesso conveniente a atributos de sessão existentes e permanentes (por exemplo, objeto de autenticação do usuário) com uma verificação opcional/obrigatória e um cast para o tipo de parâmetro de método alvo. Para casos de uso que exigem adição ou remoção de atributos de sessão, considere injetar org.springframework.web.context.request.WebRequest ou jakarta.servlet.http.HttpSession no método do controlador. Para armazenamento temporário de atributos de modelo na sessão como parte do fluxo de trabalho para um controlador, considere usar SessionAttributes em vez disso._ 1566 | 1567 | **Parâmetros:** 1568 | 1569 | - `value / name`: _Alias para especificar o nome do atributo de sessão a ser vinculado. O nome padrão é inferido a partir do nome do parâmetro do método._ 1570 | - `required`: _Indica se o atributo de sessão é obrigatório. O padrão é true, o que resulta em uma exceção se o atributo estiver ausente na sessão ou se não houver sessão. Altere para false se preferir null ou Optional do Java 8 caso o atributo não exista na sessão._ 1571 | 1572 | ${\color{yellow}@SessionAttributes}$ : _@SessionAttributes é uma anotação do Spring ‘Framework’ que indica os atributos de sessão que um manipulador específico utiliza. Esta anotação geralmente lista os nomes dos atributos de modelo que devem ser armazenados de forma transparente na sessão ou em algum armazenamento de conversação, servindo como beans para preenchimento de formulários. Declarada no nível de tipo, aplica-se aos atributos de modelo com os quais a classe de manipulador anotada opera._ 1573 | 1574 | **Parâmetros:** 1575 | 1576 | - `value / names`: _Alias para especificar os nomes dos atributos de sessão no modelo que devem ser armazenados na sessão ou em algum armazenamento de conversação. Isso indica os nomes dos atributos de modelo. Os nomes dos atributos de sessão podem ou não corresponder aos nomes dos atributos de modelo. Portanto, as aplicações não devem depender dos nomes dos atributos de sessão, mas sim operar apenas no modelo._ 1577 | - `types`: _Os tipos de atributos de sessão no modelo que devem ser armazenados na sessão ou em algum armazenamento de conversação. Todos os atributos de modelo desses tipos serão armazenados na sessão, independentemente do nome do atributo._ 1578 | 1579 | ## Spring-jms 1580 | :warning: **CONTINUA** :warning: 1581 | --------------------------------------------------------------------------------