Spring Tool Suite

São opções relacionadas aos arquivos, como abrir pastas, salvar arquivos, criar novos arquivos, atualizar para receber alterações no filesystem, importar projetos e trocar de workspace.

Vamos selecionar a opção de Switch Workspace, selecionar a opção other, e criar um novo workspace simplesmente trocando o nome na tela que surge.

Quando o STS abrir o novo workspace, vamos selecionar a opção "Import…​", e verificar as opções que surgirão. Você verá alguns tipos de projetos velhos conhecidos, por exemplo git e maven, vamos utilizar a opção Existing Maven Projects e clicar em Next.

Precisamos definir a o diretório raiz do projeto, que no caso de um projeto Maven, você já conhece. Portanto selecione a opção Browse e, vá na pasta do repositório que estamos usando no treinamento e coloque a pasta treinamento_codigo_fonte como raiz e confirme em Finish.

Assim a IDE irá importar os projetos, e baixar as dependências do maven. Esse processo pode ser acompanhado na barra de tarefas do STS, que fica no canto inferior direito. Basta dar 2 cliques para abrir mais detalhes, que serão exibidos na aba Progress. Nessa aba fica todas as operações que estão sendo executadas ou aguardando, pela IDE.

Portanto é interessante aguardar que elas estejam finalizadas para prosseguir.

No menu Edit, temos algumas opções relacionada à edição que fazemos nos arquivos, e que normalmente utilizamos via atalhos. São elas:

Se vocês não conhece / utiliza todos os atalhos a seguir, sugiro fortemente que passe a usar, esses atalhos agilizam e facilitam muito a vida durante a edição de arquivos.

Vamos abrir o arquivo TreinamentoSuperiorApplication.java, para isso, vamos utilizar o atalho Ctrl + Shift + R, digitar as primeiras letras do nome do arquivo, ou colar o nome inteiro no campo de busca e teclar Enter. As setas do teclado servem para facilitar a escolha do arquivo na lista.

Dentro do arquivo, clique no nome da classe para editar e use o comando Alt + Shift + R. Assim podemos renomear o nome da classe, o arquivo da classe e todas suas referências seguir assim desejarmos. Podemos clicar no link Options para ver mais opções.

Dentro do options, troque o nome, adicionando qualquer letra no fim do nome do arquivo, selecione os checkboxes desmarcados e clique em next. Essa opção mais avançada serve para vermos um preview da alteração que estamos fazendo, clique em next novamente assim todos os arquivos afetados serão exibidos para avaliação da alteração.

Vamos cancelar e fazer direto, sem entrar no options, portanto novamente coloque o cursor de edição no nome da classe, execute o atalho, use a tecla end para chegar no fim do nome do arquivo, coloque qualquer letra e tecle enter.

Vemos o preview novamente, em alguns tipos de refactor, como nome de classes, a IDE força o preview. Clique em OK para confirmar a alteração, a IDE pode te perguntar se você deseja alterar arquivos com nome similar em outros pacotes, confirme essa opção nesse caso. Finalizado a operação, você verá que o nome do arquivo foi alterado assim como o nome da classe e inclusive a classe de teste que está dentro de src/test/java no mesmo pacote da classe principal.

Esse comando serve também para alterar nomes de métodos, variáveis e etc. Portanto é um comando bastante útil que precisamos nos acostumar.

Na esquerda, temos o Package Explorer, e nele temos os projetos importados no workspace corrente, bem como os arquivos dentro dele.

Dentro de uma classe qualquer, podemos clicar nas setas amarelas do Package Explorer para que ele nos indique o arquivo dentro da estrutura de pasta. Para compactar novamente os arquivos do projeto, pode usar a opção do - no checkbox.

Com o projeto expandido, vá em src/main/java, dentro dessa pasta estão os pacotes java da aplicação, vamos clicar com o botão direito sobre o pacote br.com.basis.treinamentosuperior.

Você verá várias opções relacionadas, por hora vamos em New, onde serão exibidas várias opções de estruturas / arquivos que podem ser criadas, e caso não encontre alguma pode usar a opção Other e fazer uma busca. Selecione a opção package.

Se você clicou em src/main/java, o nome do pacote virá em branco, portanto cancele. Clique com botão direito, no único pacote que está dentro de src/main/java e selecione a opção New ⇒ Package. Assim o nome já virá preenchido baseado no pacote selecionado.

Complete o nome para ficar br.com.basis.treinamentosuperior.beans e confirme. Você verá um pacote vazio no package explorer, clique nele com botão direito, e selecione a opção New ⇒ Class. A interface de criação de classe irá se abrir, coloque o nome TreinamentoDTO e confirme.

Algumas opções estão disponíveis ali como já definir as superclasses ou interfaces a implementar, bem como já solicitar a criação do método main ou até mesmo do construtor.

Outra opção para criar arquivos é usar o Atalho Ctrl + N, que abrirá a mesma interface do menu New ⇒ Other.

Clicando com o botão direito nos arquivos do package explorer, temos outras opções como:

O nome do pacote br.com.basis.treinamentosuperior.beans está errado, as classes DTO são colocadas no package web.dto, portanto renomeie o pacote, conforme você já aprendeu.

Outras opções iremos ver mais para frente. Esse menu de opções é o mesmo que aparece quando clicamos em um arquivo em edição com o botão direito.

Acesse a classe que criamos (use o atalho que você já aprendeu), entre no menu Source, você verá algumas novas opções úteis como:

Na nossa classe criada, vamos declarar os atributos id (Long) e nome (String) da classe:

Logo que adicionarmos os atributos, a IDE os marcará em amarelo, pois não estão sendo utilizados. Passando o cursor sobre eles serão exibidas, as opções de quick fix como: Remoção, criação de getter / setter entre outras de acordo com o tipo de warning / error em questão.

No caso, vamos usar o menu Source (pode ser pela barra de tarefas ou clicando com botão direito no meio da classe) para gerar os getters e setters.

Na interface de criação de getters / setters temos as opções de selecionar quais atributos estão envolvidos na geração, o posicionamento do novo código a ser criado, se antes ou depois de determinado método ou atributo, alterar modificadores de acesso e também a geração de comentários.

Vamos manter o padrão, apenas selecione os campos e confirme. Assim o código estará gerado e os warnings irão desaparecer.

Vamos criar também um construtor, acessando essa opção, altere a opção Insertion Point para After nome, certifique de que os atributos id e nome estão selecionados e confirme. Você verá que o construtor irá aparecer entre os atributos e os métodos. Todas as classes costumam seguir essa ordem de organização: No topo atributos, após eles os construtores (quando houver necessidade) e por fim métodos.

Crie também, da mesma forma, um construtor vazio, que não utiliza os atributos.

Finalizado o passo anterior, salve a classe com Ctrl + S, e nossa classe estará conforme:

Dando sequencia, vamos criar o pacote equivalente junto com as classes de teste em src/test/java br.com.basis.treinamentosuperior.web.dto e dentro dele criar a classe de testes TreinamentoDTOTest.java.

Vamos criar um método public void com nome test1 e colocar nele a anotação @Test do pacote org.junit.jupiter.api.Test.

Dentro desse método, vamos declarar e instanciar um objeto do tipo TreinamentoDTO, e usar os setters da classe para setar id (1) e nome (NOME1).

Lembrando que você pode começar a escrever o nome da classe, e utilizar o atalho Ctrl + Espaço para acionar o autocomplete do STS e com a tecla enter você pode confirmar a opção a completar.

Finalizado, vamos selecionar as 3 linhas que escrevemos, e utilizar a opção Source ⇒ Surround With usando Shift + Alt + Z.

Serão exibidas várias opções de código para colocar em volta do que selecionamos, como, while, for, do, try / catch entre outros. Inclusive há a possibilidade de customizar o template dessas opções e adicionar novos. Portanto caso perceba comportamentos repetitivos que possam estar tomando tempo, é uma opção interessante a ser utilizada. Vamos escolher a opção for (iterate over array) e fazer as seguintes alterações:

Instancie um objeto list (java.util.list de implementação java.util.ArrayList) antes do for, e na última linha dentro dele, coloque a lista para adicionar o objeto que estamos preenchendo.

Caso seu objeto do tipo TreinamentoDTO esteja com nome diferente de treinamento, use o rename para alterar para esse nome.

No fim do for, vamos fazer uma verificação se existe algum dos objetos que colocamos na lista com id ou nome nulo, utilizando os getters da classe.

Vamos utilizar o método static Assertions.assertFalse (lembre-se se usar o autocomplete para encontrá-lo) da classe org.junit.jupiter.api.Assertions para isso. Como parâmetro desse método, vamos fazer um lambda sobre a lista conforme:

Da mesma forma, vamos fazer para o nome, copie a instrução anterior e altere apenas o método getId() para getNome().

Portanto com a classe salva, vamos executar os testes da classe que estamos implementando. Com botão direito clique no código, selecione a opção Run As ⇒ JUnit Test.

O teste deve executar de imediato e irá abrir a aba do JUnit para exibição dos testes bem como detalhes de log, erros e seu status. Nesse caso o teste estará com um check verde, significando que ele executou corretamente e que todas as verificações feitas foram obedecidas.

Portanto com o Loop que fizemos, todos os atributos id e nome dos 1000 objetos que instanciamos estão preenchidos.

Podemos ver na imagem a nossa classe de testes e se quisermos expandir basta clicar na seta logo antes do nome da classe para ver o status individual de cada teste dela.

O menu Refactor irá apresentar opções relacionadas a refatorações ou otimizações de código, dentre elas podemos destacas as opções:

Já que fizemos um trecho de código capaz de instanciar uma lista e preenchê-la com 1000 objetos, definindo inclusive os atributos id e nome vamos criar métodos a partir dessa lógica para que possamos reaproveitar.

Selecione a declaração da lista e o for, utilize a opção de Extrair método (Alt + Shift + M). Irá surgir a interface de extração de método, onde você pode alterar os modificadores de acesso entre outras opções incluindo a possibilidade de preview caso queira. Por hora dê o nome getListaTreinamentos e confirme.

Assim o método que queríamos estará pronto, vamos melhorá-lo selecionando o número 1000 e usar a opção de Extrair variável local (Alt + Shift + L) numeroTreinamentos e após a extração, recorte a declaração da variável, coloque como parâmetro desse método, e no método test1 adicione o parâmetro 1000 para corrigir o erro de compilação que geramos. Você pode inclusive transformá-lo em uma constante se desejar.

Execute novamente o teste e garanta que está tudo bem.

Vamos prosseguir nossas refatorações modularizando a parte que está dentro do Loop e que instancia um objeto da classe TreinamentoDTO.

Novamente selecione o trecho de código em questão, utilize o comando para criar o getTreinamento e confirme.

Da mesma forma, temos uma String fixa "NOME" no último método que criamos que devemos parametrizar conforme fizemos a pouco. Portanto vamos extrair a variável e criar o parâmetro nome.

É fácil perceber que o método getTreinamento, tem comportamento muito semelhante ao construtor da classe. Portanto vamos fazer ajustes para que a nossa list adicione diretamente o retorno do construtor.

Finalizadas as edições em nossa classe de testes, certifique-se de que os testes ainda estão executando sem erros. Ela deve estar semelhante à:

O menu navigate irá exibir algumas opções relacionadas à busca e localização de classes dentro do projeto. Algumas das opções mais importantes são:

Portanto, se você colocar o cursor na função anyMatch e acionar F3, iremos para a declaração do método dentro da classe Stream.class. Outra opção seria utilizar o Ctrl + Shift + T, digitar Stream e escolhê-la (do pacote java.util.stream), acionar Ctrl + O, encontrar o método e usar um Enter para visualizá-lo.

Ou por exemplo quando é necessário saber, que classes utilizam os métodos de alguma parte do código que estamos alterando. Vá na no nosso DTO, clique no getter do atributo id e execute Ctrl + Alt + H. Você verá que apenas a nossa classe de teste está utilizando aquele método.

Esse menu oferece várias opções relacionadas à procura nos arquivos do workspace.

Usando a opção search (Ctrl + H), na aba File Search, podemos definir o texto a ser localizado, marcar as opções de Case sensitive, Regular expression e Whole word. É possível também definir padrões de nomes de arquivo por exemplo: *, *.java, *.yml, *Resource.java, *Test.java entre outros.

Além disso é possível fazer working sets, grupos de um ou mais projetos ou partes deles.

No menu Project estão algumas opções relacionadas à construção dos projetos. Você pode solicitar a construção de todos os projetos ou de alguns, solicitar que seja feito um clean e builds já na sequencia.

Na barra de ferramentas podemos destacar algumas opções:

Lembrando que a barra de ferramentas pode ser customizada conforme sua necessidade e preferência.

No menu Window é possível fazer customizações nos editores, abas e perspectivas da IDE. Caso você feche alguma aba importante e queira abri-la novamente, basta ir em Window ⇒ Show View. Abra por exemplo a opção Console.

Vamos ver algumas opções importante na exibição de log das execuções:

Outra opção de extrema importância é o item Window ⇒Preferences. Nela estão todas as preferências e customizações a serem feitas na IDE relacionadas à editores, tipos de arquivo, ações, formatação de arquivos, encoding, servidores, funcionalidades da IDE entre outras. Recomendo que você explore as opções para conhecimento.

Por hora, digite save na barra de busca, na opção Java ⇒ Editor ⇒ Save Actions. Aqui podemos configurar as ações da IDE toda vez que for salvo um arquivo, vamos deixar as opções conforme:

Acione Apply and Close.

Craques do Maven que já somos, vamos fazer algumas acrobacias dentro do STS.

Vá no Run Configurations (Menu Run ⇒ Run Configurations ou na seta para baixo preta do lado do Run na barra de ferramentas ⇒ Run Configurations).

Nesse ponto temos muitas opções, escolha Maven Build, no menu acima do filtro (ou com botão direito) selecione New Configuration. A janela a seguir deverá ser exibida:

Na aba principal (Main) vemos as seguintes opções:

Embaixo delas alguns checkboxes relacionados à opções do maven.

Na aba JRE estão parâmetros relacionados ao java bem como qual JRE ou JDK (na maioria dos casos), ou para alternar entre builds, colocar parâmetros na VM do java. Portanto:

Confirme clicando em apply e você verá o script criado. Clique em run e acompanhe no console da IDE a execução do script.

Após o sucesso, veja que existe um warning no fim do script te informando que o profile dev não existe para esse pom.

Vá novamente em Run ⇒ Run Configurations (na barra de tarefas) e verá seu script de forma acessível. Você pode usar a opção Organize Favorites para torná-los mais acessíveis ainda caso tenha muitas execuções na IDE. Volte lá e vamos criar um novo script maven.

Na mesma tela que entramos, podemos economizar trabalho clicando com o botão direito no nosso script Clean Install, clicando na opção Duplicate. Altere o nome para Clean Install - Tests, desmarque a opção Skip Tests, confirme em Apply e na sequencia Run.

Acompanhe no console a execução do script e verifique a execução dos testes existentes.

Feito isso já sabemos como compilar e executar nossos projetos Maven pela IDE.

Nesse menu estão opções relacionadas à ajuda, informações da IDE, instalação de novos plugins. Acesse a opção Help ⇒ Eclipse Marketplace.

Nessa função é possível buscar plugins e instalar, são ferramentas adicionais que não fazem parte do kit básico da IDE. Algumas são desenvolvidas pelas equipes oficiais das ferramentas e algumas são da comunidade.

Vamos instalar um plugin para visualização da cobertura de código, na barra de busca digite coverage, escolha o plugin conforme a seguir e siga os passos da instalação.

Finalizando a instalação, vamos no project explorer, procure o pacote src/test/java e com o botão direito acesse o menu Coverage As ⇒ jUnit Test.

Assim os testes serão executados com o plugin que acabamos de instalar e no final ele irá exibir a cobertura do código para os testes que temos. Verifique a cobertura do DTO que fizemos e verá que algumas partes do código não estão sendo utilizadas.

Na seção de testes será possível ver mais detalhadamente as boas práticas na implementação de testes.

Acesse o boot dashboard na barra de ferramentas, irá aparecer o nó Local, clique para expandir. Dentro dele serão exibidos os projetos springboot importados na IDE, e por aqui fica bem fácil iniciá-los, pará-los, iniciar em modo debug, ver logs e editar configurações.

Portanto no treinamento-superior, aciona opção edit (lápis amarelo ou botão direito ⇒ Open Config), vemos as opções relacionadas ao Spring Boot como classe principal, projeto, profile ativo do spring entre outras opções.

Novamente no Boot Dashboard, execute o serviço e clique em Open Console para acompanhar sua execução. Finalizado o startup, acesse no seu browser localhost:8080 e irá ver a conhecida Whitelabel Error Page padrão do Spring, pois ainda não temos nada mapeado nessa URL em nosso projeto.