IntelliJ IDEA: estilo de codificação e formatação de código

Uma linguagem de programação é muito semelhante a uma linguagem falada. A única diferença é que é uma linguagem especial cujo objetivo principal é facilitar a comunicação com um computador para explicar ao computador o que queremos que ele faça. Mas você não pode ter uma conversa pessoal com um computador. Quando você começou a aprender uma linguagem de programação, consultou livros ou algum recurso educacional como o CodeGym. E este recurso mostrou um código que o computador entende. Mas você também deve entendê-lo ao aprender sobre a linguagem Java. Como em qualquer linguagem, algumas convenções de formatação foram adotadas na programação. Por exemplo, na sociedade educada, escrever assim seria considerado falta de educação. E em Java, iniciar o nome de um método com letra maiúscula é uma violação grosseira das convenções de codificação. As regras para o código Java são fornecidas no documento Convenções de Código para a Linguagem de Programação Java . As convenções de codificação também podem regular detalhes menores, como indentação. Imagine o pesadelo absoluto que o controle de versão se tornaria se o recuo fosse inconsistente, algumas pessoas usando tabulações e outras pessoas usando espaços. Como seria para alguém que precisa fazer check-in de uma correção em apenas um método, mas encontra todo o arquivo alterado devido a diferenças de espaços e tabulações? É claro que, assim como ocorre com a linguagem comum, as convenções podem mudar dependendo de onde a linguagem é usada. Por exemplo, nas vastas extensões da web, você pode encontrar o Google Java Style Guide e o Twitter Java Style Guide. Para esta revisão, precisamos de uma cobaia. Usaremos o sistema de automação de compilação Gradle. Isso nos permitirá começar rapidamente criando um novo projeto a partir de um modelo. Gradle tem um ótimo plugin: Build Init Plugin . Vamos para um novo diretório e executar o seguinte comando lá: gradle init --type java-application Depois disso, inicie o IntelliJ IDEA. Se você vir uma janela com um projeto aberto (ou seja, você vê o editor de código e a árvore do projeto), feche esse projeto usando File -> Close Project. Agora, na janela de boas-vindas, execute " Import Project" e importe nosso novo projeto. Ao importar, defina a Use autoimportcaixa de seleção " ". Vamos descobrir se podemos usar ferramentas de desenvolvimento de última geração para simplificar a vida de alguma forma.

Formatação de código no IDEA

Após importar o projeto, pressione Ctrl+N e vá para a AppTestaula. Esta é a classe de teste padrão. Se parece com isso:

 import org.junit.Test;
 import static org.junit.Assert.*;
 
 public class AppTest {
     @Test public void testAppHasAGreeting() {
         App classUnderTest = new App();
         assertNotNull("app should have a greeting", classUnderTest.getGreeting());
     }
 }

O que imediatamente chama sua atenção? Uma anotação na mesma linha de uma declaração de método, que parece feia, certo? Como consertar isto? O IntelliJ IDEA tem uma Codeentrada de menu " " para várias manipulações de código. Uma dessas manipulações é " Reformat Code", que você pode aplicar usando Ctrl+L. Depois de fazer isso, a anotação estará em uma linha e a declaração do método em outra. Vale a pena notar imediatamente que esta operação é executada no código atualmente selecionado . Se não houver seleção, a operação de formatação será executada em tudo. Agora vamos adicionar um novo método de teste:

 @Test
 public void testSumOfOddNumbers() {
 	List<Integer> data = Arrays.asList(1, 4, 2, 3, 6, 7, 9);
 	Integer result = data.stream().filter(number -> number % 2 == 0).reduce((n1, n2) -> n1 + n2).get();
 	assertThat(result, is(12));
 }

E duas importações:

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

Como você pode ver, a operação no Stream é em uma linha. Mas e se quisermos garantir que as chamadas de método encadeadas sejam sempre divididas em novas linhas em cada operador de período? Poderíamos fazer isso manualmente. Mas lembre-se que queremos que tudo aconteça automaticamente. De fato, certamente esqueceremos a etapa manual de vez em quando, e então acabaremos com formatações diferentes em todos os lugares, e isso não é bom. Portanto, precisamos editar a regra que o IDEA usa para formatação. EscolherFile -> Settingsno menu IDEA (ou pressione Ctrl+Alt+S). Digite "estilo de código" no campo de pesquisa na janela de configurações. Na seção "Estilo de código", você pode especificar configurações para mais idiomas do que apenas Java. Mas Java é o que nos interessa agora. Como você pode ver, as configurações são divididas em várias guias. Um recurso super útil é que um exemplo da operação é mostrado na parte direita da janela: A captura de tela mostra que podemos definir "Chained method calls" para "wrap always", ou seja, sempre dividir chamadas de método chained em linhas separadas. Agora clique novamente no botão de formatação na aula de teste e vemos que realmente funciona! Mas às vezes você precisa formatar algum código fora das regras de formatação padrão. Configure a formatação da seguinte maneira: Para evitar a formatação, na seção "Estilo de código", ative os marcadores do formatador: Agora podemos alterar nossa classe de teste para que seu código não seja reformatado:

 @Test
 public void testSumOfOddNumbers() {
 	List<Integer> data = Arrays.asList(1, 4, 2, 3, 6, 7, 9);
 	// @formatter:off
 	Integer result = data.stream().filter(number -> number % 2 == 0)
                              .reduce((n1, n2) -> n1 + n2)
                              .get();
 	assertThat(result, is(12));
 	// @formatter:on
 }

Você deve ter notado que quando você pressiona Tab, o IDEA o interpreta como um espaço (esse é o comportamento padrão). Mas você pode alterar isso na Code Styleseção " ": Como você pode ver, há muitas configurações lá. Você pode ler mais detalhes sobre " Code style" configurações aqui: " IDEA Help: Code Style ". Há outro recurso importante de formatação: formatar importações. Esta operação é executada separadamente e é chamada de " Optimize Imports". Ele está localizado em Code -> Optimize Imports(Ctrl+Alt+O). A otimização de importações remove importações desnecessárias e organiza as importações na ordem correta de acordo com as configurações na Importsguia " " das Code Styleconfigurações " " para Java. Além disso, se você deseja que essa formatação ocorra automaticamente, temos uma boa notícia:Salvar plug-in de ações.

Distribuindo configurações em um comando

Vimos acima que você pode personalizar seu estilo de formatação como quiser. Mas como você usa esse estilo dentro de uma equipe? Muito facilmente. Existem várias opções. O mais simples é salvar um esquema de estilo de código. Abra as configurações do IDEA usando File -> Settings(ou pressione Ctrl+Alt+S). Na Code Styleseção " ", podemos ver "Esquema". Este é o nosso esquema de formatação. Por padrão, o esquema "Padrão" é usado e rotulado como "IDE", o que significa que essa configuração se aplica apenas ao nosso IDE — não afeta mais ninguém. Para fazer um esquema "personalizado", use o botão à direita para fazer uma cópia e dar um nome, por exemplo: CodeGym Então podemos importar ou exportar as configurações: Outra opção é importar as configurações do IDEA: Uma terceira opção é o repositório de configurações. Para usar o Repositório de configurações, consulte a documentação de ajuda do IntelliJ IDEA para obter mais detalhes no seguinte link: Repositório de configurações ". Falando em empurrar um estilo unificado em uma equipe, também não posso deixar de mencionar o bom suporte para estilos do Eclipse IDE. Para fazer isso, você precisa instalar um plug-in separado: abra as configurações do IDEA em Arquivo -> Configurações (Ctrl+Alt+S) e vá para a seção "Plugins". Para encontrar novos plug-ins, clique no botão " ". Em seguida Browse Repositories, encontre o plug-in Eclipse Code Formatter na janela de pesquisa. Depois de instalá-lo, você terá que reiniciar o IDEA — este é o procedimento padrão. Agora tudo está feito. Há uma nova seção nas configurações do IDEA: "Eclipse Code Formatter".. Vai parecer algo assim:

Requisitos mais rigorosos

Além das ferramentas IDEA, você também pode usar plug-ins de automação de construção para restringir os requisitos. Não há como verificar manualmente se alguém usou a formatação adequada. Talvez você pudesse com 5 pessoas em uma equipe. Mas com 100 pessoas em uma empresa, não é realista. E até cinco serão difíceis de rastrear. E por que perder tempo com isso? Seria muito mais fácil impedir que o projeto fosse construído se as regras fossem violadas. Na verdade, este é um tópico totalmente separado chamado "Inspecionar código". Neste artigo, quero apenas mostrar como isso funciona. Um dos plugins Gradle mais populares (porque ele constrói nosso projeto, você deve se lembrar) é o pmd. Para ativá-lo, basta acessar o script de construção do nosso projeto Gradle (o arquivo build.gradle na raiz do nosso projeto) e adicionar pmd a ele ao lado do restante dos plugins:

 plugins {
     // Apply the java plugin to add support for Java
     id 'java'
     // Check source code
     id 'pmd'
     // Apply the application plugin to add support for building an application
     id 'application'
 }

Agora podemos inserir configurações mais detalhadas no mesmo local:

 pmd {
     ignoreFailures = false
     pmdTest.enabled = true
     ruleSets = [
             'java-basic',
             'java-braces',
             'java-clone',
             'java-codesize',
             'java-comments',
             'java-controversial',
             'java-coupling',
             'java-design',
             'java-empty',
             'java-finalizers',
             'java-imports',
             'java-optimizations',
             'java-strictexception',
             'java-strings',
             'java-typeresolution',
             'java-unnecessary',
             'java-unusedcode'
     ]
 }

Até nosso projeto está quebrado agora. Execute gradle builde obteremos um erro. O bom é que um relatório é gerado durante a construção. E se houver erros, recebemos uma mensagem como esta:

 BUILD FAILED in 35s
 6 actionable tasks: 6 executed
 7 PMD rule violations were found. See the report at: file:///C:/_study/codestyle/build/reports/pmd/main.html

Indo para o relatório, vemos algo assim: Além disso, a Problemcoluna " " fornece um link para uma descrição do problema no site do plug-in pmd. Por exemplo, para o headerCommentRequirement Requirederro " ", o link vai aqui: pmd — CommentRequired . Este erro é uma dica de que nossa classe não possui um JavaDoc. Podemos usar modelos para configurar um JavaDoc acima das classes: E especificar o conteúdo para o File Header: Depois disso, podemos transformar o comentário acima da classe App em um JavaDoc e ver se o erro desaparece em uma nova compilação.

A linha de fundo

O estilo de código é importante para maximizar a produtividade em um projeto. Um código bonito, escrito de acordo com regras compartilhadas, garante que seus colegas de trabalho o entendam com mais facilidade e rapidez e não lhe dêem uma bronca de críticas. Com ferramentas de desenvolvimento modernas, não é tão difícil seguir as regras de estilo. Espero que esta revisão tenha provado a você que isso é verdade. Seguindo a tradição, segue um pequeno material extra sobre o tema:

• Vídeo da JetBrainsTV: " Inspecionar código (IntelliJ IDEA) "
• Revisão de " Análise de código com plug-ins Gradle "
• Curso " Automatizar a qualidade do código "