Gerenciamento de dependências Java: quantas linhas de código minha aplicação contém?

Há algumas semanas, tive a oportunidade de fazer uma apresentação na conferência holandesa de Java JSpring. A palestra foi sobre gerenciamento de dependências Java.

Durante a palestra, criei uma aplicação simples com Spring Boot e calculei quantas linhas de código vinham das dependências Java e quantas eu mesmo escrevi. A ideia era mostrar que as dependências ocupam uma parte significativa da aplicação e também precisam de atenção. Depois da apresentação, publiquei o tuíte a seguir, que chamou bastante atenção e me motivou a escrever este artigo:

Calculando quantas linhas de código vêm das minhas dependências Java

Etapa 1: gerar uma aplicação Spring Boot

Primeiro, criei uma aplicação Spring Boot usando o Spring Boot Initialzr, com web como única dependência.

Isso significa, basicamente, que o projeto contém spring-boot-starter-web como única dependência direta.

Etapa 2: criar um controlador REST

Em seguida, escrevi o endpoint REST mais simples que se possa imaginar, com apenas quatro linhas:

@RestController
public class Controller {

   @GetMapping("/hello")
   public String hello() {  return "hello"; }
}

Etapa 3: gerar o JAR para implantação

O arquivo JAR gerado a partir desse projeto Java é um JAR completo, que contém todos os JARs dos quais o projeto depende. Isso acontece porque o Spring Boot inclui o servidor de aplicações junto com a própria aplicação.

Etapa 4: analisar o JAR

Em seguida, criei uma aplicação simples que consome o JAR do Spring Boot gerado. Ela descompacta o arquivo JAR e todas as dependências incluídas nele. Os arquivos de classe contidos nos JARs são descompilados e as linhas de código são contabilizadas.

Etapa 5: reunir os resultados

• Linhas de código escritas: 4

• JARs: 33

• Arquivos de classe: 9.917

• Linhas de código: 518.772

Algumas observações sobre os números

Os números acima estão longe de ser precisos. Linhas em branco e linhas com apenas um colchete foram desconsideradas, por isso não aparecem na contagem final.

É discutível se precisamos analisar melhor essas linhas e excluir ainda mais para chegar a números mais precisos. Além disso, diferentes descompiladores podem apresentar resultados diferentes.

Considero isso uma espécie de pseudociência. Embora os números não sejam precisos, eles mostram o papel expressivo que as dependências desempenham nas nossas aplicações. Esse era o meu objetivo.

Cuide das suas dependências Java

Tudo bem, os números são altos, mas o que esse exemplo realmente nos diz? Primeiro, usar Spring Boot para uma aplicação de “Olá, mundo” é exagero. Segundo, o Spring Boot é um servidor de aplicações, então esses números altos são esperados, certo?

Todas essas observações são válidas. Concordo que este foi o endpoint REST mais inútil que alguém poderia escrever. Mas isso destaca o fato de que as dependências representam uma grande parcela do binário que colocamos em produção. Como o Spring Boot é um framework usado por inúmeros desenvolvedores Java, escolhi esse exemplo de propósito.

Pense nisso. Neste exemplo, as linhas de código que escrevi representam bem menos de 1% do total que enviamos para produção. Ainda assim, como equipe, somos responsáveis por tudo isso. Se algo der errado na aplicação, a equipe de desenvolvimento precisa resolver. Práticas como revisão de código, programação em pares e análise estática automatizada certamente ajudam a criar uma base de código melhor. Mas e os 99% do código que usamos e dos quais dependemos tanto?

É essencial cuidar das dependências e atualizá-las no momento certo. A inclusão de um pacote pode trazer muitas dependências e ampliar a superfície de ataque. Toda equipe de desenvolvimento deveria definir uma estratégia de gerenciamento de dependências Java, estabelecendo como elas serão selecionadas, atualizadas e removidas. Do ponto de vista da segurança, você deve, no mínimo, receber um alerta quando uma dependência direta ou transitiva tiver uma vulnerabilidade.

Analisar sua aplicação com o Snyk para detectar vulnerabilidades nas dependências de código aberto pode ajudar. Como o Snyk pode ser usado em todas as etapas do ciclo de vida de desenvolvimento de software (SDLC) e é altamente adaptável, ele é ideal para automação. O Snyk não apenas detecta vulnerabilidades: ele ajuda você a identificá-las o mais cedo possível.

Conclusão

Cuidar bem do nosso código nem sempre é suficiente: também precisamos ficar de olho nas dependências, que têm um papel enorme nas nossas aplicações.

Ao analisar suas dependências com ferramentas como o Snyk, você evita que vulnerabilidades passem despercebidas. Além disso, implementar uma estratégia sólida de gerenciamento de dependências Java é fundamental para manter sua aplicação fácil de manter, escalável, previsível e, acima de tudo, segura!