[Post Rápido] Classes utilitárias do Spring

Erros acontecem em qualquer tipo de software que seja desenvolvido. Por mais que o sistema possua testes, e eu espero que os desenvolvidos por você possuam, ainda acabamos recebendo várias exceptions durante a execução da aplicação. Nesse cenário, um detalhe que me incomoda é que acabamos várias vezes tomando exceptions do tipo NullPointerException ou até um ArrayIndexOutOfBoundsException, que geralmente vem associadas a valores que não foram definidos nas variáveis ou a coleções que estão vazias.

Claro que se o erro ocorrer, você pode adicionar um teste para cobrir o cenário e tudo vai estar resolvido. Dentro do SetupMyProject temos várias situações dessas, segue um exemplo.

    private ViewPartProcessor findHtmlPartProcessor(ViewElement viewElement) {
         List<ViewPartProcessor> filteredPartsProcessor = //findPartProcessors(viewElement)

         if (filteredPartsProcessor.isEmpty()) {
            throw new IllegalArgumentException(
              "Não foi encontrado nenhum processador de html para "
              + viewElement.getClass());
         }

         if (filteredPartsProcessor.size() > 1) {
             throw new IllegalStateException(
              "Tem mais de um processador de html para "
               + viewElement.getClass());
          }

       ViewPartProcessor choosedHtmlProcessor = filteredPartsProcessor.get(0);
       return choosedHtmlProcessor;
    }

A verificação foi feita com um if  e, associado a ele, lançamos uma exception do tipo IllegalArgumentException com uma mensagem descritiva, para ajudar o desenvolvedor do time que receba tal exception. Nesse caso específico ainda temos um estado inválido sendo verificado.

O legal é que como o SetupMyProject usa o Spring como framework base, podemos ir um pouco além e tirar proveito de outras classes que não estão nos holofotes do framework. Ele possui um pacote chamado org.springframework.util que possui um monte de classe que pode ser útil para o seu projeto. Por exemplo, para fazermos a checagem de parâmetros e estado acima, podemos usar a classe Assert, presente no pacote.

       private ViewPartProcessor findHtmlPartProcessor(ViewElement viewElement) {
		List<ViewPartProcessor> filteredPartsProcessor =    //findPartProcessors(viewElement)

		Assert.notEmpty(filteredPartsProcessor,
				"Não foi encontrado nenhum processador de html para "
						+ viewElement.getClass());

		Assert.state(filteredPartsProcessor.size() == 1,
				"Tem mais de um processador de html para "
						+ viewElement.getClass());

		ViewPartProcessor choosedHtmlProcessor = filteredPartsProcessor.get(0);
		return choosedHtmlProcessor;
	}

Essa classe possui vários métodos de checagem, seguem alguns outros exemplos:

     Assert.hasText(text);
     Assert.notNull(object);
     Assert.isTrue(expression);

Apenas para ilustrar um pouco mais. Estamos no meio do desenvolvimento de uma nova feature do SetupMyProject e foi necessário gerar um pouco de HTML a partir de código JAVA. Em partes do código era necessário colocar uns textos entre aspas simples e, independente do tipo concatenação, ela sempre é chata e muito propensa a erros.

     "<form:textarea path='"+textAreaHtmlElement.getName()+"'>"

No pacote org.springframework.util do Spring também existe a classe StringUtilsque já possui um método chamado quote responsável por fazer justamente o que precisamos.

     "<form:textarea path="+StringUtils.quote(textAreaHtmlElement.getName())+">";

Esse é um ponto que eu defendo bastante. Para mim faz bastante sentido se acoplar a solução que você escolheu para servir de alicerce para o seu projeto. O problema de acoplamento gerado por essa decisão só vai ser sentido se você realmente precisar trocar esse alicerce, o que é não é nada comum. E você, vê algum problema em se acoplar ao framework?

 

Advertisements

4 thoughts on “[Post Rápido] Classes utilitárias do Spring

  1. Mais um post bacana, Alberto. Parabéns!

    O Spring tem umas classes utils para fazer scanning de classes e anotações muito úteis, além de outras coisinhas com generics também. Vale a pena dar uma olhada!

    Agora sobre a concatenação eu evitaria. Na minha opinião o código fica pouco legível e acaba dificultando a manutenção, mesmo com o método .quote(). O que costumo fazer é usar placeholders e fazer o replace (semelhante ao que frameworks de template fazem). Algo como abaixo:


    String tag = """;" // repare que continuamos com as aspas-simples no código
    tag = tag.replace("{customPath}", textAreaHtmlElement.getName());

    O que acha? Eu considero mais simples e dá para ver o template como um todo em vez de várias concatenações!

    Um abraço!

    Liked by 1 person

  2. Opa Ponte, concordo com o template! Inclusive a classe StrSubstitutor, do CommonsLang, inclui justamente esse comportamento que você comentou.

    		Map<String, Object> map = new HashMap<>();
    		map.put("name", "Alberto");
    		System.out.println(StrSubstitutor.replace("The variable ${name} must be used.", map));
    

    Like

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s