Java 11 + Maven + Spring Boot – Erro: Repackage failed: Unable to load the mojo ‘repackage’ in the plugin spring-boot-maven-plugin due to an API incompatibility

Depois de muito tempo sem postar, venho novamente trazer uma solução de um problema que me levou algumas boas horas pesquisando pra identificar o problema.

Trabalhando em um projeto maven com spring boot gerado a partir do THOR, o projeto compilava corretamente local, porém através do pipeline do GitLab tomávamos o seguinte erro:

[WARNING] Error injecting: org.springframework.boot.maven.RepackageMojo
java.lang.TypeNotPresentException: Type org.springframework.boot.maven.RepackageMojo not present
    at org.eclipse.sisu.space.URLClassSpace.loadClass (URLClassSpace.java:147)
    at org.eclipse.sisu.space.NamedClass.load (NamedClass.java:46)
    at org.eclipse.sisu.space.AbstractDeferredClass.get (AbstractDeferredClass.java:48)
    at com.google.inject.internal.ProviderInternalFactory.provision (ProviderInternalFactory.java:85)
    at com.google.inject.internal.InternalFactoryToInitializableAdapter.provision (InternalFactoryToInitializableAdapter.java:57)
    ...
    at org.codehaus.plexus.classworlds.launcher.Launcher.launch (Launcher.java:225)
    at org.codehaus.plexus.classworlds.launcher.Launcher.mainWithExitCode (Launcher.java:406)
    at org.codehaus.plexus.classworlds.launcher.Launcher.main (Launcher.java:347)
Caused by: java.lang.UnsupportedClassVersionError: org/springframework/boot/maven/RepackageMojo has been compiled by a more recent version of the Java Runtime (class file version 61.0), this version of the Java Runtime only recognizes class file versions up to 55.0
    at java.lang.ClassLoader.defineClass1 (Native Method)
    at java.lang.ClassLoader.defineClass (ClassLoader.java:1017)
    at java.security.SecureClassLoader.defineClass (SecureClassLoader.java:174)
    at java.net.URLClassLoader.defineClass (URLClassLoader.java:550)
    at java.net.URLClassLoader$1.run (URLClassLoader.java:458)
    at java.net.URLClassLoader$1.run (URLClassLoader.java:452)
    at java.security.AccessController.doPrivileged (Native Method)
    at java.net.URLClassLoader.findClass (URLClassLoader.java:451)
    at org.codehaus.plexus.classworlds.realm.ClassRealm.loadClassFromSelf (ClassRealm.java:425)
    at org.codehaus.plexus.classworlds.strategy.SelfFirstStrategy.loadClass (SelfFirstStrategy.java:42)
    at org.codehaus.plexus.classworlds.realm.ClassRealm.unsynchronizedLoadClass (ClassRealm.java:271)
    ...
    at org.codehaus.plexus.classworlds.launcher.Launcher.mainWithExitCode (Launcher.java:406)
    at org.codehaus.plexus.classworlds.launcher.Launcher.main (Launcher.java:347)
    ...
[ERROR] Failed to execute goal org.springframework.boot:spring-boot-maven-plugin:3.0.0-M1:repackage (default) on project cpb-ms-core-application: Execution default of goal org.springframework.boot:spring-boot-maven-plugin:3.0.0-M1:repackage failed: Unable to load the mojo 'repackage' in the plugin 'org.springframework.boot:spring-boot-maven-plugin:3.0.0-M1' due to an API incompatibility: org.codehaus.plexus.component.repository.exception.ComponentLookupException: org/springframework/boot/maven/RepackageMojo has been compiled by a more recent version of the Java Runtime (class file version 61.0), this version of the Java Runtime only recognizes class file versions up to 55.0

Analisando o pom do projeto identifiquei que a versão do spring-boot-maven-plugin não foi definida:

...
  <profiles>
    <profile>
      <id>default</id>
      <activation>
        <activeByDefault>true</activeByDefault>
      </activation>			
      <build>
      <plugins>
        <plugin>
	  <groupId>org.springframework.boot</groupId>
	  <artifactId>spring-boot-maven-plugin</artifactId>
	  <executions>
	    <execution>
	      <goals>
	        <goal>repackage</goal>
	      </goals>
	    </execution>
	   </executions>
	  </plugin>
...

De alguma maneira durante a compilação ele estava pegando a versão 3.0.0-M1, que pela pesquisa que fiz, parece só ser possível compilar no java 17.

Para resolver esse problema foi necessário apenas definir explicitamente a versão que deveria ser utilizada para esse plugin:

...
  <profiles>
    <profile>
      <id>default</id>
      <activation>
        <activeByDefault>true</activeByDefault>
      </activation>			
      <build>
      <plugins>
        <plugin>
	  <groupId>org.springframework.boot</groupId>
	  <artifactId>spring-boot-maven-plugin</artifactId>
	  <version>2.6.4</version>
	  <executions>
	    <execution>
	      <goals>
	        <goal>repackage</goal>
	      </goals>
	    </execution>
	   </executions>
	  </plugin>
...

Simples assim, espero que tenha ajudado 😀 See ya!

Solução: java.lang.ClassNotFoundException: javax.xml.bind.JAXBException

E ai galera beleza, estava estudando um projeto Spring MVC com Hibernate que será colocado na AWS, porém estava apanhando pra subir o projeto no TomCat, estava tomando esse erro:

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'entityManagerFactory' defined in class br.com.casadocodigo.loja.configuration.JPAConfiguration: Invocation of init method failed; nested exception is org.hibernate.cfg.beanvalidation.IntegrationException: Error activating Bean Validation integration
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1568)
...
at org.hibernate.boot.registry.classloading.internal.ClassLoaderServiceImpl.withTccl(ClassLoaderServiceImpl.java:399)
at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.build(EntityManagerFactoryBuilderImpl.java:842)
at org.springframework.orm.jpa.vendor.SpringHibernateJpaPersistenceProvider.createContainerEntityManagerFactory(SpringHibernateJpaPersistenceProvider.java:60)
at org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean.createNativeEntityManagerFactory(LocalContainerEntityManagerFactoryBean.java:341)
at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.afterPropertiesSet(AbstractEntityManagerFactoryBean.java:318)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1627)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1564)
... 21 more
Caused by: java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException
at org.hibernate.validator.engine.ConfigurationImpl.parseValidationXml(ConfigurationImpl.java:252)
at org.hibernate.validator.engine.ConfigurationImpl.buildValidatorFactory(ConfigurationImpl.java:143)
...
at java.base/java.lang.reflect.Method.invoke(Method.java:567)
at org.hibernate.cfg.beanvalidation.BeanValidationIntegrator.integrate(BeanValidationIntegrator.java:150)
... 32 more
Caused by: java.lang.ClassNotFoundException: javax.xml.bind.JAXBException
at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1339)
at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1167)
... 42 more

Depois de tentar com TomCat 7, 8 e 8.5 descobri que as APIs do JAXB foram consideradas APIs do Java EE então não estão mais no classpath default do Java SE 9. Já no Java 11, elas foram completamente removidas do JDK. E eu estou com o JDK 12 na minha máquina… tsc tsc tsc…

Resolvi esse problema adicionando as seguintes dependências no pom.xml do maven:


<!-- API, java.xml.bind module -->
<dependency>
<groupId>jakarta.xml.bind</groupId>
<artifactId>jakarta.xml.bind-api</artifactId>
<version>2.3.2</version>
</dependency>

<!-- Runtime, com.sun.xml.bind module -->
<dependency>
<groupId>org.glassfish.jaxb</groupId>
<artifactId>jaxb-runtime</artifactId>
<version>2.3.2</version>
</dependency>

Simples, assim… é isso ai galera, lição aprendida! Abraços!

 

Fonte: Andy Guibert – Stackoverflow

Novidades do Java 8

Só alguns poucos (6) anos atrasado, venho publicar esse post com as principais novidades do Java 8 que foi lançado em Março de 2014 através da especificação JSR 337.

Esse post é o primeiro da série onde pretendo centralizar as melhorias de cada uma das versões que vieram após o Java 7.

Lambda Expression

Também conhecida como funções anônimas, acredito que essa seja maior mudança na versão 8, as expressões lambdas podem causar estranhesa a primeira vista por quem apenas programou utilizando Java. Mas elas já são bem comuns para programadores que tiveram contato com linguagens como C#, Clojure, Go, Groovy, Javascript, Kotlin, Ruby, Scala e muitas outras.

Essas expressões facilitam a implementação dos comportamentos de inferfaces funcionais, que são aquelas interfaces que possuem apenas um único método abstrato.

Como por exemplo a clássica interface java.util.Comparator, comumente utilizada para ordenar coleções. Anteriormente precisaríamos implementar essa interface em uma classe ou instância-la como classe anonima como no exemplo abaixo:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

Comparator<String> comparadorPorTamanho = new Comparator() {
	public int compare(String s1, String s2) {
		return Integer.compare(s1.length(), s2.length());
	}};

Collections.sort(linguagens, comparadorPorTamanho);

Agora abaixo um código equivalente ao de cima, substituindo a instanciação da classe anonima pela expressão lambda:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

Comparator<String> comparadorPorTamanho = (s1, s2) -> Integer.compare(s1.length(), s2.length());

Collections.sort(linguagens, comparadorPorTamanho);

Podemos fazer uma versão mais enxuta ainda, passando a expressão lambda direto como argumento para o método sort:

List <String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

Collections.sort(linguagens, (s1, s2) -> Integer.compare(s1.length(), s2.length()));

Detalhando um pouco mais a sintaxe da expressão lambda apresentada:

(s1, s2) -> Integer.compare(s1.length(), s2.length())

É iniciada com a declaração dos parametros do método que estamos implementando. O método da interface Comparator aguarda 2 parametros do tipo String, a tipagem dos parâmetros é opcional, já que temos apenas um único método na interface, o compilador ja sabe com quais tipos ele está lidando, por isso declaramos apenas o nome que desejamos para as variáveis:

(s1, s2) ...

Se o método aguardasse apenas 1 parametro, então declaramos somente o nome do parametro, sendo que neste cenário os parênteses passam a ser opcionais.

s1 ...

Caso o método não tivesse parametros, seria declarado com parenteses vazios:

() ...

Após a declaração dos parametros colocamos o arrow token, que é composto por um hífen, seguido por um sinal de maior (->):

(s1, s2) -> ...

Em seguida devemos colocar o conteúdo do nosso método, no exemplo que estamos utilizando é { return Integer.compare(s1.length(), s2.length()); }, como o nosso corpo é simples e tem apenas uma única linha (instrução), podemos suprimir as chaves, o return e o ponto e vírgula (;), pois nesse caso tornan-se opcionais:

(s1, s2) -> Integer.compare(s1.length(), s2.length())

Caso o nosso conteúdo fosse ‘mais complexo’, com mais de uma linha (instrução), necessitaríamos da utilização das chaves, do return (caso o método não seja void, claro :D) e do ponto e vírgula (;) no final de cada comando, como por exemplo:

(s1, s2) -> {
    // imagine qualquer comando aqui
    int resultado = Integer.compare(s1.length(), s2.length());
    // imagine qualquer comando aqui
    return resultado;
}

Ordenando Collections

Como vimos no exemplo acima, ordenavamos nossas coleções utilizando o método utiitário Collections.sort (Classe), agora no java 8 temos outra maneira mais simples de efetuar tal ação, temos o método Collection.sort (Interface), que espera como parâmetro apenas um Comparator compatível com o tipo da lista, o qual está disponível em todas as nossas coleções, como por exemplo na interface List.

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.sort((s1, s2) -> Integer.compare(s1.length(), s2.length()));

A interface Comparator ganhou um método estático (sim! agora é possível :D) Comparator.comparing, que facilitar a criação de uma instância de um comparador simples:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.sort(Comparator.comparing(s -> s.length()));

Podemos simplificar ainda mais com outra novidade, o Method Reference, que nos permite fazer referência a um método específico de uma classe:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.sort(Comparator.comparing(String::length));

Novos métodos nas Collections

Nas nossas coleções tivemos algumas mudanças, ganhamos diversos métodos novos como o Collection.sort visto acima, muitos deles esperam com parâmetro implementações de interfaces funcionais (assunto que veremos a seguir), segue mais alguns:

Iterable.forEach(Consumer)
Iterator.forEachRemaining(Consumer)
Collection.removeIf(Predicate)
Collection.spliterator()
Collection.stream()
Collection.parallelStream()
List.sort(Comparator)
List.replaceAll(UnaryOperator)
Map.forEach(BiConsumer)
Map.replaceAll(BiFunction)
Map.putIfAbsent(K, V)
Map.remove(Object, Object)
Map.replace(K, V, V)
Map.replace(K, V)
Map.computeIfAbsent(K, Function)
Map.computeIfPresent(K, BiFunction)
Map.compute(K, BiFunction)
Map.merge(K, V, BiFunction)
Map.getOrDefault(Object, V)

Interface

Ocorreram melhorias também nas interfaces, como a possibilidade de declarar métodos concretos, chamados de Default Method, fazendo com que as interfaces tenham uma grande similaridade com as classes abstratas, que até então eram um meio termo entre interfaces e classes concretas. Esse tipo de método necessita do operador default em sua declaração.

Solução criada para possibilitar a evolução das interfaces já existentes, assim quando criarmos novos métodos em interfaces que já estão em uso, essas alterações não irão causar erros de compilação nas outras interfaces e/ou classes que as implementam.

Por exemplo, o novo método sort da interface List:

default void sort(Comparator<? super E> c) {
    Collections.sort(this, c);
}

Outra novidade também, como vimos na interface Comparator.comparing, agora podemos declarar métodos estáticos, o que não era possível anteriormente:

Interfaces funcionais

Como ja vimos no começo do post, inferfaces funcionais, que são aquelas interfaces que possuem apenas um único método abstrato.

Antes dessa nova versão ja tinhamos outras interfaces funcionais, é isso mesmo! Um exemplo seria a interface Runnable, que é implementada pela famosa classe Thread.

Agora as interfaces funcionais ganharam mais destaque, e também novas interfaces localizadas no pacote java.util.function:

Function<T, R> − recebe T como entrada, retorna R como saída;
Predicate<T> − recebe T como entrada, retorna um valor booleano como saída;
Consumer<T> − recebe T como entrada, não retorna nada como saída;
Supplier<T> − não recebe entrada, retorna T como saída;
BinaryOperator<T> − recebe duas entradas T, retorna um T como saída.

Também temos uma nova anotação @FunctionalInterface, que deve ser utilizada para indicar que uma interface é funcional. O que obriga o compilador a verificar se existe apenas um método declarado na interface. Em caso negativo, ocorrerá um erro de compilação. Todas as antigas interfaces que são consideradas funcionais, receberam essa anotação.

Optional

Nova classe que nos ajuda a evitar a má prática de retornar null em nosso métodos, e espalhar comparações do tipo if (resultado != null), deixando o nosso código muito mais elegante. Estamos falando da classe java.util.Optional que usufrui de Generics, possibilitando uma codificação tipada. Segue algumas maneira de aplica-la:

Retornando resutado não-nulo:

public Optional<String> buscar() {
    String resultado = "XPTO";
    return Optional.of(resultado);
}

Retornando resutado que é vazio, antigo return null:

public Optional<String> buscar() {
    return Optional.empty();
}

Retornando resultado que tem a possibilidade de ser nulo:

public Optional<String> buscar() {
    String resultado = null;
    return Optional.ofNullable(resultado);
}

Internamente o método acima verifica o parametro passado e decide se prossegue com o método of ou empty.

Agora segue alguns exemplos do lado de quem recebeu o Optional como retorno, como o utilizamos:

Verificando se temos um resultado preenchido:

Optional<String> opt = buscar();
boolean preenchido = opt.isPresent();

Obtendo o resultado encapsulado, devemos verificar com o método isPresent para evitar receber uma exceção:

Optional<String> opt = buscar();
String resultadoEsperado = opt.get();

Se o resultado estiver presente, você pode ja passar uma função para consumi-lo:

Optional<String> opt = buscar();
opt.ifPresent(r -> System.out.println(r));

Você ja pode deixar seu código preparado para receber outro valor caso o resutado não esteja presente:

Optional<String> opt = buscar();
String outroResultado = opt.orElse("Vazio!");

Lançando exceção caso o resutado não esteja presente:

Optional<String> opt = buscar();
opt.orElseThrow(IllegalStateException::new);

Stream

Uma grande novidade que nos ajuda muito no dia a dia, é o pacote java.util.stream, que nos possibilita uma programação no estilo funcional. Simplificando a forma de iterar, filtrar, transformar, consolidar e coletar os dados.

A forma mais comum de ter acesso a uma instância de Stream é através de collections já populadas, através do método Collection.stream, que nos devolve uma instância de java.util.stream.Stream, possibilitando o uso de uma infinidade de métodos que esperam como parâmetro a implementação de diversas interfaces funcionais (ex.: as que mostramos acima) de acordo com o tipo de operação.

Iterando (ex.: Imprimindo as linguagens):

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.stream()
    .forEach( l -> System.out.println("Imprimindo linguagem "+l ));

Obs.: Também podemos ter acesso a esse método de forma mais prática, diretamente na coleção com Iterable.forEach.

Transformando (ex.: Obtendo as iniciais de cada linguagem):

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

List<Character> iniciais = linguagens.stream()
    .map(l -> l.charAt(0))
    .collect(Collectors.toList());

Nesse exemplo fizemos chamadas sequenciais/encadeadas de 2 métodos, o map e o collect, onde um faz a transformação de cada objeto e o outro é responsável por obter o resultado da operação anterior.

Ordenando (ex.: Ordem alfabetica)

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

List<String> novaListaOrdenada = linguagens.stream()
    .sorted(Comparator.comparing(String::toString))
    .collect(Collectors.toList());

Nesse exemplo ordenamos com sorted e em seguida obtivemos a lista ordenada com o collect.

Removendo duplicados

List<Integer> numeros = Arrays.asList(1, 1, 2, 3, 4, 4, 5);

numeros.stream()
    .distinct()
    .forEach(n -> System.out.println(n));

Removemos os duplicados através do distinct, o qual se utiliza do método equals do objeto para distinguir os valores, e para variar, não coletamos o resutado, e sim, imprimimos cada um deles com o forEach.

Filtrando (ex.: Linguagens que começam com “J”)

List<String> linguagens = Arrays.asList("Java", "C#", "JavaScript", "Html");

linguagens.stream()
    .filter(l -> l.startsWith("J"))
    .forEach(l -> System.out.println(l));

Filtramos utilizando o filter e imprimimos utilizando forEach.

Temos muitas outras possibilidades para trabalhar com Stream, para descobrir todas elas, basta dar uma olhada na documentação oficinal 😀

Também temos Streams para trabalhar com tipos primitivos, como IntStream, LongStream e DouleStream, que nos oferecem métodos específicos para trabalhar com números, como average, sum, reduce e muito mais.

Além de tudo isso, podemos efetuar esses processamentos de forma paralela de maneira bem simples, com o uso do método Collection.parallelStream ao invés de Collection.stream, possibilitando um possível ganho de performance.

Datas e horas

Finalmente ganhamos uma nova API para trabalhar com data e hora, baseada no JodaTime, o JodaTime ja era uma biblioteca bastante utilizada pelos desenvolvedores, agora nossa vida será muito mais fácil quando o assunto for lidar com data e hora.

As antigas classes java.util.Date, java.sql.Date, java.util.GregorianCalendar e cia, dão espaço para as classes dos pacotes java.time, como por exemplo LocalDate para trabalhar apenas com data, LocalTime para trabalhar apenas com horas, LocalDateTime para trabalhar com data e hora. Também temos a classe java.time.format.DateTimeFormatter para ajudar na formatação e muitas outras.

Segue um breve exemplo do uso das classes citadas:

System.out.println("Hoje: " + LocalDate.now());

System.out.println("Agora: " + LocalTime.now());

LocalDate nascimento = LocalDate.of(1989, Month.MAY, 22);
System.out.println("Nascimento: " + nascimento);

String nascimentoFormatado = nascimento.format(DateTimeFormatter.ofPattern("dd/MM/yy"));
System.out.println("Nascimento formatado: " + nascimentoFormatado);

A nova API tem muitas classes e muitos métodos, não irei abordar tudo aqui pois não é o intuito desse post. Para ver todas as funcionalidades dê uma olhadinha nesse post da oracle!

Essas classes ja são suportadas pelo JDBC e JPA, então você pode mapear seu modelo utilizando-as sem medo! 😀

Outras mudanças

Melhorias na própria JVM relacionado ao uso da memória disponível (Metaspace);
Melhorias na API de Concorrência;
Melhorias na API de IO/NIO;
Melhorias para trabalhar com Reflection;
Nova implementação para utilizar JavaScript dentro do Java: Nashhorn;
Nova implementações para unir Strings como o método String.join e a classe java.util.StringJoiner;
Conexão com Banco de dados via JDBC-ODBC foi removida;
Não roda no Windows XP;

Fontes:
Caelum, Matera, Feltex, Infoq, Oracle – Docs, Oracle – Specs, Wikipedia

ArrayIndexOutOfBoundsException ao utilizar NamedParameterJdbcTemplate + MapSqlParameterSource

Fala galera, bora tirar o pó do blog rs…

me deparei com o erro abaixo, nada intuitivo, utilizando NamedParameterJdbcTemplate e MapSqlParameterSource, onde eu tenho na minha query parâmetros opcionais/nullable, ou seja, parâmetros que podem vir ou não com valor (null):

java.lang.ArrayIndexOutOfBoundsException: 128
	at oracle.jdbc.driver.OracleParameterMetaDataParser.computeBasicInfo(OracleParameterMetaDataParser.java:327)
	at oracle.jdbc.driver.OracleParameterMetaDataParser.getParameterMetaDataSql(OracleParameterMetaDataParser.java:433)
	at oracle.jdbc.driver.OracleParameterMetaData.getParameterMetaData(OracleParameterMetaData.java:58)
	at oracle.jdbc.driver.OraclePreparedStatement.getParameterMetaData(OraclePreparedStatement.java:12861)
	at oracle.jdbc.driver.OraclePreparedStatementWrapper.getParameterMetaData(OraclePreparedStatementWrapper.java:1551)
	at org.springframework.jdbc.core.StatementCreatorUtils.setNull(StatementCreatorUtils.java:248)
	at org.springframework.jdbc.core.StatementCreatorUtils.setParameterValueInternal(StatementCreatorUtils.java:229)
	at org.springframework.jdbc.core.StatementCreatorUtils.setParameterValue(StatementCreatorUtils.java:147)
	at org.springframework.jdbc.core.PreparedStatementCreatorFactory$PreparedStatementCreatorImpl.setValues(PreparedStatementCreatorFactory.java:278)
	at org.springframework.jdbc.core.PreparedStatementCreatorFactory$PreparedStatementCreatorImpl.createPreparedStatement(PreparedStatementCreatorFactory.java:236)
	at org.springframework.jdbc.core.JdbcTemplate.execute(JdbcTemplate.java:603)
	at org.springframework.jdbc.core.JdbcTemplate.query(JdbcTemplate.java:657)
	at org.springframework.jdbc.core.JdbcTemplate.query(JdbcTemplate.java:682)
	at org.springframework.jdbc.core.JdbcTemplate.query(JdbcTemplate.java:736)
	at org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate.query(NamedParameterJdbcTemplate.java:212)
	...

após perder alguns minutos pesquisando, não achei nada para resolver, então criei uma solução/tratamento simples:

public <T> void setOptionalParameter(MapSqlParameterSource parameters, String name, T value) {
   if (valor == null)
      parameters.addValue(name, value, Types.NULL);
   else
      parameters.addValue(name, value);
}

Forma de utilização:

MapSqlParameterSource parameters = new MapSqlParameterSource();
new MapSqlParameterSourceUtil().setOptionalParameter(parameters, "optionalParam", optionalParam);
parameters.addValue("mandatoryParam", mandatoryParam);
jdbcTemplate.query(...);

Espero ter ajudado, see ya! 😀

ActiveMQ + JMS – This class is not trusted to be serialized as ObjectMessage payload.

Galera estou estudando um pouco mais a fundo o ActiveMQ, e me deparei com essa mensagem de erro no momento de ‘deserializar’ uma instância de ObjectMessage, ele ocorre a partir da versão 5.12.2:

javax.jms.JMSException: Failed to build body from content. Serializable class not available to broker. Reason: java.lang.ClassNotFoundException: Forbidden class br.com.modelo.Pedido! This class is not trusted to be serialized as ObjectMessage payload. Please take a look at http://activemq.apache.org/objectmessage.html for more information on how to configure trusted classes.
at org.apache.activemq.util.JMSExceptionSupport.create(JMSExceptionSupport.java:36)
at org.apache.activemq.command.ActiveMQObjectMessage.getObject(ActiveMQObjectMessage.java:213)
at br.com.jms.ConsumidorTopicoComercial$1.onMessage(ConsumidorTopicoComercial.java:47)
at org.apache.activemq.ActiveMQMessageConsumer.dispatch(ActiveMQMessageConsumer.java:1404)
at org.apache.activemq.ActiveMQSessionExecutor.dispatch(ActiveMQSessionExecutor.java:131)
at org.apache.activemq.ActiveMQSessionExecutor.iterate(ActiveMQSessionExecutor.java:202)
at org.apache.activemq.thread.PooledTaskRunner.runTask(PooledTaskRunner.java:133)
at org.apache.activemq.thread.PooledTaskRunner$1.run(PooledTaskRunner.java:48)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at java.lang.Thread.run(Thread.java:748)
Caused by: java.lang.ClassNotFoundException: Forbidden class br.com.modelo.Pedido! This class is not trusted to be serialized as ObjectMessage payload. Please take a look at http://activemq.apache.org/objectmessage.html for more information on how to configure trusted classes.
at org.apache.activemq.util.ClassLoadingAwareObjectInputStream.checkSecurity(ClassLoadingAwareObjectInputStream.java:112)
at org.apache.activemq.util.ClassLoadingAwareObjectInputStream.resolveClass(ClassLoadingAwareObjectInputStream.java:57)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1868)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1751)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2042)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1573)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:431)
at org.apache.activemq.command.ActiveMQObjectMessage.getObject(ActiveMQObjectMessage.java:211)
… 9 more

Para ajudar quem possa vir a tomar esse erro, há duas opções para corrigir o problema alterando a classe consumidora.

Solução 1:

Adicionando o trecho:

System.setProperty("org.apache.activemq.SERIALIZABLE_PACKAGES","*");

Solução 2:

Substituindo o trecho:

ConnectionFactory factory = (ConnectionFactory) context.lookup("ConnectionFactory");


por

ActiveMQConnectionFactory factory = (ActiveMQConnectionFactory) context.lookup("ConnectionFactory");
factory.setTrustAllPackages(true);


Não sei se é a forma mais correta, porém resolveu. Se alguém tiver algum adendo, só postar aqui nos comentários 😉

See ya!

Como testar com Selenium sem abrir nenhum navegador

Boa noite galera,

Estou fazendo um projetinho, onde eu precisa executar o WebDriver do Selenium sem abrir o navegador, e achei uma maneira simples de resolver meu problema…

Basta substituir a criação padrão do WebDriver de:

WebDriver driver = new ChromeDriver();

Para:

ChromeOptions options = new ChromeOptions();
options.setHeadless(true);

WebDriver driver = new ChromeDriver(options);

Simples assim 😉 Espero ter ajudado! Até mais!

Fonte: Stackoverflow.com – NuOne T Attygalle

Apostila – Introdução ao Java 7

Boa noite galera,

Segue a apostila que eu montei e utilizo no curso de introdução ao java 7 lecionado para os estagiários da empresa em que trabalho:
Introdução ao Java 7 – v1.2

Abraços!

SQL – UPDATE a partir de um SELECT

E ai galera, beleza?

Hoje vamos aprender como efetuar UPDATE em registros obtidos a partir de um SELECT, temos duas formas e fazê-lo, para exemplificar vamos considerar o seguinte SELECT:

SELECT A.*
FROM TAB_A A JOIN TAB_B B ON (A.ID = B.ID)
WHERE <CONDIÇÕES...>

Opção 1 – Utilizar o SELECT desejado no lugar da tabela a ser alterada, no SET utilize as colunas da TAB_A que serão atualizadas:

UPDATE (
SELECT A.*
FROM TAB_A A JOIN TAB_B B ON (A.ID = B.ID)
WHERE <CONDIÇÕES...>
) SET <COL1 TAB_A> = <VAL1>, <COL2 TAB_A> = <VAL2>

A abordagem acima em algumas modelagem podem acarretar no erro ORA-01779: cannot modify a column which maps to a non key-preserved table, quando isso acontecer utilize a opção 2, abaixo.

Opção 2 – Utilizar a clausula EXISTS no WHERE do UPDATE tradicional:

UPDATE TAB_A TA
SET <COL1 TAB_A> = <VAL1>, <COL2 TAB_A> = <VAL2>
WHERE EXISTS (
SELECT A.*
FROM TAB_A A JOIN TAB_B B ON (A.ID = B.ID)
WHERE <CONDIÇÕES...>
AND A.ID = TA.ID
)

Espero que tenha ajudado! Qualquer dúvida, poste aqui nos comentários que eu responderei o mais breve possível 😉

See ya!

MongoDB – Erro: Can’t extract geo keys

E ai galera, estou me aventurando no mundo NoSQL com o sr. MongoDB…

E ao criar meu primeiro índice para fazer pesquisas por proximidade, tomei meu primeiro erro, e tive que ir atrás para resolve-lo 😦

Oque aconteceu, peguei latitudes e longitudades pelo google maps, lá pros lados da austrália…
type: "Point", coordinates: [ -33.91991, 151.257018 ]
adicionei ao meu documento e tentei gerar o índice e tomei o erro abaixo:

db.xxx.createIndex({ xxx : "2dsphere"})
…
“ok” : 0,
“errmsg” : “Can’t extract geo keys… longitude/latitude is out of bounds, lng: … lat: …”,
“code” : 16755,
“codeName” : “Location16755”

Dando uma pesquisada, descobri é que o google maps disponibiliza os valores na ordem diferente (latitude/longitude) da qual o MongoDB espera (longitude/latitude)… para resolver o problema apenas precisei inverter os valores inseridos e o índice foi criado sem problemas 😀

Os valores da Longitude deve estar entre -180° e +180° e a Latitude entre -90° e 90°!!! (Y)

Espero que tenha ajudado!

Fonte: go-oleg / Paul T. Rawkeen – Stackoverflow.com

Erro: web.xml is missing and is set to true

E ai galera, beleza?

Está tomando o erro “web.xml is missing and <failOnMissingWebXml> is set to true” no seu projeto maven dentro do eclipse???

Então vamos corrigir esse erro!

1. Clique com o botão direito no ‘Deployment Descriptor’ dentro do seu projeto no ‘Project Explorer’.
2. Selecione a opção ‘Generate Deployment Descriptor Stub’.
3. Pronto !!! 😀

Isso irá gerar a pasta ‘WEB-INF’ no src/main/webapp com o web.xml dentro.

Abraços!!!

Fonte: stackoverflow.com – Wojciechu