Spring MVC sem uso de XML

Fala galera!

Após um período de férias do blog (bem longo por sinal rsrsrs), convido vocês a acompanhar este post, que já faz um bom tempo que queria fazer. Mas agora com o tempo oportuno estou deixando com vocês. Bom, vamos lá!

Quando comecei a estudar programação utilizando a linguagem Java, fiquei muito empolgado, pois antes só havia programado utilizando as linguagens C e C++. Confesso que as facilidades que a linguagem proporcionava eram extremamente animadoras - e ainda são.

Porém, com o passar do tempo, percebi que existem alguns frameworks como o Spring, que exigem a configuração utilizando arquivos xml. Era até interessante no começo, mas de acordo que precisava iniciar projetos novos em alguns trabalhos freelancer, vi que estava ficando chato essas configurações.

Bem, com esses "problemas" em mãos resolvi fazer uma pesquisa e encontrei alguns sites que ensinam como organizar seu projeto utilizando o Spring sem o uso de xml. Então, vamos ao código.

Utilizarei o IDE Eclipse Luna com o Spring 4.3.5.

Vamos criar um novo projeto web e configurá-lo para o uso do Maven, onde adicionaremos as seguintes dependências:

        <properties>
  <!-- spring version -->
  <spring.version>4.3.5.RELEASE</spring.version>
 </properties>
 <dependencies>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-core</artifactId>
   <version>${spring.version}</version>
  </dependency>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-web</artifactId>
   <version>${spring.version}</version>
  </dependency>
  <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
   <version>${spring.version}</version>
  </dependency>
 </dependencies>

Agora, no pacote com.deviscoming.config, vamos criar a classe de configuração que será equivalente ao web.xml. Analise o código:

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = {"com.deviscoming"})
public class AppConfig extends WebMvcConfigurerAdapter{
 
 @Bean
 public ViewResolver internalResourceViewResolver(){
  InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
  viewResolver.setPrefix("/WEB-INF/views/");
  viewResolver.setSuffix(".jsp");
  return viewResolver;
 }

}

@Configuration: esta annotation informa ao Spring que a nossa classe AppConfig será a classe de configuração do projeto;

@EnableWebMVC: aqui informamos ao Spring que vamos usar o Spring MVC;

@ComponentScan: para não precisarmos criar nossos beans, o Spring nos fornece esta annotation para fazer todo este trabalho para nós :). Na propriedade basePackges é informado qual pacote do projeto será escaneado pelo Spring. 

Lembram daquele trecho de código que existia no DispatcheServlet?

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
 <property name="prefix" value="/WEB-INF/views/" />
 <property name="suffix" value=".jsp" />
</bean>

Pois bem, adicionaremos em nossa classe conforme abaixo:

@Bean public InternalResourceViewResolver internalResourceViewResolver(){
  InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
  viewResolver.setPrefix("/WEB-INF/views/");
  viewResolver.setSuffix(".jsp");
       return viewResolver;
}

A classe InternalResourceViewResolver mostra ao Spring onde estão nossas páginas, então instanciamos a classe e 'setamos' o prefixo e sefixo usando os métodos setPrefix() e setSuffix().

Beleza, já temos a primeira classe para executar nosso projeto. Vamos agora criar outra classe no mesmo pacote da AppConfig e nomearemos de WebAppInitializer. Confira abaixo:

public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer{

 @Override
 protected Class[] getRootConfigClasses() {
  return null;
 }

 @Override
 protected Class[] getServletConfigClasses() {
  return new Class[] {AppConfig.class};
 }

 @Override
 protected String[] getServletMappings() {
  return new String[]{"/"};
 }
 
}

Depois estendemos a classe AbstractAnnotationConfigDispatcherServletInitializer e implementamos seus métodos. 

Preste atenção nos métodos getServletConfigClasses() e getServletMappings(). O primeiro você deve informar a classe de configuração, no nosso caso AppConfig.

Pronto! pode executar seu projeto que ele irá funcionar perfeitamente.

É isso aí pessoal, até mais!

;)

[Debug] Comparar/Listar Strings acentuadas usando Collactor

Fala galera que acompanha o blog...   

   

Quando estamos trabalhando com strings, sempre nos deparamos com problemas clássicos, como por exemplo, comparar strings maiúsculas com minúsculas, acentuadas, com codificação diferente e até mesmo na hora de listar essas strings ordenando de forma crescente ou decrescente e por ai em diante.  

   

Nesse post eu vou estar ensinando uma forma de comparar strings acentuadas utilizando o Collactor. Acredite ou não, no Java existe uma classe que realiza essa comparação ignorando os acentos.   

Vamos utilizar como exemplo o meu nome Luíz Fágner Zordan, mas é claro que a forma original é sem acento algum. Veja essas premissas:   

 

Luíz Fágner Zordan e Luiz Fagner Zordan são as mesmas pessoas, o que difere são os acentos;   

Luiz Fágner Zordan e LUÍZ FÁGNER ZORDAN são as mesmas pessoas, o que difere são os acentos e as letras maiúsculas;   

Luiz Fágner Zordan e Luiz Vagner Zordan não são as mesmas pessoas;   

   

Veja esse código:   

 

class CollatorEmAcao { 

    public static void main(String[] args) { 

        // Compara Strings, ignorando os acentos 

        String st1 = "Luíz Fágner Zordan"; 

        String st2 = "Luiz Fagner Zordan "; 

        String st3 = "LUÍZ FÁGNER ZORDAN"; 

        String st4 = "Luiz Vagner Zordan"; // Perceba que o nome está escrito errado 
  

        Collator collator = Collator.getInstance (new Locale ("pt", "BR")); 

        collator.setStrength(Collator.PRIMARY);     

        if (collator.compare (st1, st2) == 0) { 

            System.out.println ("Os dois Fagner são as mesmas pessoas, o que difere são os acentos"); 

        } 

        if (collator.compare (st1, st3) == 0) { 

            System.out.println ("Os dois Fagner são as mesmas pessoas, o que difere são os acentos e as letras maiúsculas"); 

        } 

        if (collator.compare (st1, st4) != 0) { 

            System.out.println ("Os dois Fagner não são as mesmas pessoas"); 

        } 

} 

Bom, vimos como comparar strings ignorando os acentos, agora vamos ordenar as strings, ignorando os acentos. Para essa segunda parte vejam o seguinte exemplo:   

 

class CollactorEmAcao{ 

    public static void main(String[] args) { 

        // Ordena String, ignorando os acentos. 

        String[] nomes = { 

            "José Aparecido", 

            "João Simões", 

            "Jó Abedenego"   

        };   

        // Sem o uso de "collator" o resultado deve ser: 

       //  [José Aparecido, João Simões, Jó Abedenego] 

       //  que é o contrário da língua portuguesa 

        SortedSet<String> st1 = new TreeSet<String>(); 

        for (String nome : nomes) { 

            st1.add (nome); 

        } 

        System.out.println (st1); 

        // Usando "collator", o resultado deve ser: 

        // [Jó Abedenego, João Simões, José Aparecido] 

        final Collator coll = Collator.getInstance (new Locale ("pt", "BR")); 

  
        SortedSet<String> st2 = new TreeSet<String>(new Comparator<String>() { 

            public int compare (String s1, String s2) { 

                return coll.compare (s1, s2); 

            } 

        }); 

        for (String nome : nomes) { 

            st2.add (nome); 

        } 

        System.out.println (st2); 

    } 

}

Sem o uso do Collactor, não é respeitada as normas corretas de ordenação, por isso a ordenação acaba ficando "errada".

É isso ai pessoal, até a próxima