Arquivos de sites

JPA/Hibernate Static Metamodel Attributes não populados / nulos — Gerando NullPointerException

E ai galera, beleza?

Hoje tive um problema tentando utilizar os atributos metamodel estáticos do JPA/Hibernate,
sempre quando eu ia utilizá-los, eles estavam nulos… depois de um tempo quebrando a cabeça consegui achar o motivo!

Vamos exemplificar o cenário:

Entidade:

package com.mydomain.model.user;

public class User {

/** Número de identificação */
@Id
private Long id;

/** Nome de autenticação */
private String username;

//getters e setters
}

Metamodel:

package com.mydomain.metamodels;

import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.StaticMetamodel;

@StaticMetamodel(User.class)
public class User_ {
public static volatile SingularAttribute<User, String> username;
}

Uso do metamodel no predicado (predicate):


cb.equal(root.get(User_.username), “usuario_teste”);

Toda vez que eu tentava dar get(…) eu estava tomando nullpointerexception,
e a solução que encontrei foi colocar a classe User.class e a User_.class no mesmo pacote…
não sei o real motivo para precisarem estar, porém só assim funcionou pra mim..

Pesquisando descobri também que em futuros releases talvez essas classes possam ficar em pacotes diferentes,
segue algumas regras descritas na especificação do JPA 2:

  • Classes Metamodel devem estar no mesmo pacote das classes de entidade que elas descrevem;
  • Elas devem ter o mesmo nome das classes de entidade que elas descrevem, seguido por um traço-baixo (“_”, underline, underscore…).
    Exemplo: Produto.class é a classe de entidade e o Produto_.class é a classe metamodel.
  • Se uma entidade herdar de outra entidade ou de uma superclasse mapeada (mapped superclass) deve herdar da classe metamodel que descreve sua superclasse.
    Exemplo: Se ProdutoEspecial.class estende Product.class, que estende ObjetoPersistente.class, então ProdutoEspecial_.class deve estender Produto_.class, que deve estender ObjetoPersistente_.class.

É isso ai pessoal espero ter ajudado!
valeu!!!

Fonte: stackoverflow.com – debbie/Vítor E. Silva Souza

Anúncios

Como persistir LocalDate e LocalDateTime do Java 8 com JPA

E ai galera beleza? faz muito tempo que eu não postava nada novo, então bora com “novidade” do java 8 + JPA 😀

O Java 8 trouxe muitas grandes funcionalidades e uma das mais importantes e uma das antecipadas foi a nova API de data e hora. Haviam muitos problemas com a antiga API e não vou entrar em detalhes do porque nós precisamos de uma nova. Tenho certeza que você teve que lutar com ela com frequencia.

Todos esses problemas se foram com Java 8 \o/. A nova API de data e hora é bem desenhada, fácil de usar e (finalmente) imutável. O único problema que permanece é, que você não pode usava com JPA.

Bem, isso não totalmente verdade. Você pode usa-la, porém o JPA irá mapeá-la para BLOB ao invés de DATE ou TIMESTAMP. Que significa que a base de dados não está ciente do objeto de data e não pode aplicar nenhuma otimização para isso. E não é desse jeito que deveríamos ou gostaríamos de fazê-lo.

Porque o JPA não suporta LocalDate e LocalDateTime?

A resposta é simples, o JPA 2.1 foi liberado antes do Java 8 e a API de data e hora simplesmente não existia naquela época. Portanto a anotação @Temporal pode apenas ser aplicada a atributos do tipo java.util.Date e java.util.Calendar.

Se você deseja armazenar um atributo LocalDate em uma coluna Date ou uma LocalDateTime em uma coluna TIMESTAMP, você mesmo precisa definir o mapeamento para java.sql.Date ou java.sql.Timestamp. Graças ao conversor de atributo, uma das diversas novas funcionalidades do JPA 2.1, isso pode ser alcançado com apenas algumas linhas de código.

Nos exemplos abaixo, eu vou mostrar pra vocês como criar um conversor de atributos para LocalDate e LocalDateTime. Se você quer aprender mais sobre conversor de atributo, dê uma olhada aqui (inglês).

O exemplo

Antes de nós criar os conversores de atributo, vamos dar uma olhada na entidade de exemplo para esse post:

@Entity
public class MyEntity {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = “id”, updatable = false, nullable = false)
private Long id;

@Column
private LocalDate date;

@Column
private LocalDateTime dateTime;

}

O conversor de atributo faz parte da especificação do JPA 2.1 e pode portanto ser usado com qualquer implementação de JPA 2.1, ex.: Hibernate ou EclipseLink. Eu usei Wildfly 8.2 com Hibernate 4.3 para os seguintes exemplos.

Convertendo LocalDate

Como você pode ver no seguinte pedaço de código, não é necessário muita coisa para criar um conversor de atributo para LocalDate.

@Converter(autoApply = true)
public class LocalDateAttributeConverter implements AttributeConverter<LocalDate, Date> {

@Override
public Date convertToDatabaseColumn(LocalDate locDate) {
return (locDate == null ? null : Date.valueOf(locDate));
}

@Override
public LocalDate convertToEntityAttribute(Date sqlDate) {
return (sqlDate == null ? null : sqlDate.toLocalDate());
}
}

Você precisa implementar a interface AttributeConverter<LocalDate, Date> e seus 2 métodos convertToDatabaseColumn e convertToEntityAttribute. Como você pode ver nos nomes dos métodos, um deles define a conversão do tipo do atributo da entidade (LocalDate) para o tipo de coluna da base de dados (Date) e o outro é a conversão inversa. A conversão em si é simples porque java.sql.Date ja nos provê o método para fazer a conversão “de” e “para” um LocalDate.

Adicionalmente o conversor de atributo precisa ser anotado com a anotação @Converter. Devido a propriedade opcional autoApply=true, o conversor será aplicado a todos os atributos do tipo LocalDate. Dê uma olhada aqui (inglês), se você quer definir o uso de cada conversor para cada atributo individualmente.

A conversão do atributo é transparente para o desenvolvedor e o atributo LocalDate pode ser usado como qualquer outro atributo da entidade. Você pode usa-lo como parâmetro de query por exemplo.

LocalDate date = LocalDate.of(2015, 8, 11);
TypedQuery<MyEntity> query = this.em.createQuery(“SELECT e FROM MyEntity e WHERE date BETWEEN :start AND :end”, MyEntity.class);
query.setParameter(“start”, date.minusDays(2));
query.setParameter(“end”, date.plusDays(7));
MyEntity e = query.getSingleResult();

Convertendo LocalDateTime

O conversor de atributo para LocalDateTime é basicamente o mesmo. Você precisa implementar a interface attributeConverter<LocalDateTime, Timestamp> e o conversor precisa ser anotado com a anotação @Converter. Assim como o LocalDateConverter, a conversão entre LocalDateTime e um java.sql.Timestamp é feita através dos métodos de conversão do Timestamp.

@Converter(autoApply = true)
public class LocalDateTimeAttributeConverter implements AttributeConverter<LocalDateTime, Timestamp> {

@Override
public Timestamp convertToDatabaseColumn(LocalDateTime locDateTime) {
return (locDateTime == null ? null : Timestamp.valueOf(locDateTime));
}

@Override
public LocalDateTime convertToEntityAttribute(Timestamp sqlTimestamp) {
return (sqlTimestamp == null ? null : sqlTimestamp.toLocalDate());
}
}

Conclusão

O JPA 2.1 foi liberado antes do Java 8 e portanto não suporta a nova API de data e hora. Se você quer usar as novas classes (do jeito certo), você mesmo precisa definir a conversão para java,sql.Date e java.sql.Timestamp. Isso pode ser feito facilmente implementando a interface AttributeConverter<EntityType, DatabaseType> e anotando a classe com a anotação @Converter(autoApply=true). Setando autoApply=true, a conversão será aplicada a todos os atributos do EntityType e nenhuma alteração na entidade é necessária.

Até onde eu sei, a próxima versão do JPA suportará a nova API de data e hora e as diferentes implementações provavelmente irão suporta-la ainda mais cedo. O Hibernate 5 por exemplo irá suporta-la como uma funcionalidade proprietária.

É isso ai galera, espero tê-los ajudado 😀

Fonte: thoughts-on-java.org – Thorben Janssen

jQuery – Introdução ao AJAX

AJAX, abreviação para Asynchronous JavaScript And XML (XML e JavaScript Assíncronos), permite você carregar dados em background e mostra-lo na sua página web. Isso lhe permite criar websites com funcionalidade mais rica.Aplicações web populares como Gmail, Outlook Web Access, e Google Maps usam AJAX e extensivamente, para fornecer a você uma experiência mais responsiva, como desktop.

Usar AJAX pode ser um pouco complicado, porque os vários navegadores tem diferentes implementações para suportar AJAX. Normalmente isso irá lhe forçar a escrever código para responder de forma diferente, dependendo do navegador, mas felizmente, jQuery fez isso pra gente, que nos permite escrever AJAX funcionalmente com tão pouco quanto uma única linha de código.

Você deve estar ciente do fato que existe ambas vantagens e desvantagens ao usar AJAX na sua página, que significa que você deve sempre considerar cuidadosamente antes de decidir usar isso ao invés de fazer uma chamada comum de volta ao servidor. Aqui está um resumo:

Vantagens:

  • Sua página será mais prazerosa de usar, quando você pode atualizar partes dela sem um refresh, que faz o navegador piscar e rodar a barra de status.
  • Porque você apenas carrega o dado que você precisa para atualizar a página, ao invés de  atualizar a página inteira, você salva largura de banda.

Desvantagens:

  • Porque as atualizações são feitas pelo JavaScript no cliente, o estado não irá registrar no histórico do navegador, fazendo isso impossível de usar os botões Voltar e Avançar do navegador entre os vários estados da página.
  • Pelo mesmo motivo, um estado específico não pode ser favoritado pelo usuário.
  • Dado carregado através do AJAX não será indexado por qualquer dos maiores motores de busca.
  • Pessoas usando navegadores sem suporte JavaScript, ou com JavaScript desabilitado, não será capaz de usar a funcionalidade que você fornece através do AJAX.
    Os dois primeiros itens da lista podem ser contornados embora, tipicamente através do uso de um iframe e lendo e escrevendo dado de uma parte da URL depois do caractere “#”.

Nos capítulos seguintes, você irá aprender como usar várias funções AJAX relacionadas ao jQuery.

Fonte: jquery-tutorial.net

SQL – Como inserir Date / Timestamp

E ai galera beleza?

Hoje segue um exemplo de como inserir Date / Timestamp no banco de dados…
possibilitando vc adicionar uma data, hora, minuto, segundo ou todos eles em uma
tabela do banco de dados (testado no Oracle XE) !!!

Para isso utilizamos o método/função:

TO_TIMESTAMP()

Segue abaixo alguns exemplos de utilização!!!

Utilizando uma variável:

INSERT INTO sua_tabela(sua_coluna) VALUES (TO_TIMESTAMP(:variavel_string,'YYYY-MM-DD HH24:MI:SS'));

Utilizando uma string de Hora/Minuto:

INSERT INTO sua_tabela(sua_coluna) VALUES (TO_TIMESTAMP('23:59','HH24:MI'));

Utilizando uma string de Data:

INSERT INTO sua_tabela(sua_coluna) VALUES (TO_TIMESTAMP('2014-06-13','YYYY-MM-DD'));

Utilizando a Data atual:

INSERT INTO sua_tabela(sua_coluna) VALUES (CURRENT_TIMESTAMP);

Fonte: Stackoverflow – reggie

jQuery – Os métodos append() e prepend()

Adicionar novos objetos a um element existente é muito fácil com jQuery. Aqui estão métodos para anexar ou prefixar, recebendo HTML em formato string, elementos DOM e ojbetos jQuery como parâmetros. No próximo exemplo, você verá como é fácil inserir novos elementos em uma lista, usando ambos os métodos append() e prepend():

<a href="javascript:void(0);" onclick="$('#olTestList1').append('<li>Appended item</li>');">Append</a>   
<a href="javascript:void(0);" onclick="$('#olTestList1').prepend('<li>Prepended item</li>');">Prepend</a>
<ol id="olTestList1">
        <li>Existing item</li>
        <li>Existing item</li>
</ol>

Nós temos dois links: O primeiro irá anexar um item a lista, significando que o novo item será inserido como último item. O outro link irá prefixar um link a lista, o que significa que o novo item será inserido como o primeiro item da lista. Neste exemplo, nós simplesmente inserimos um pedaço de HTML, mas nós poderíamos  ter gerado os novos itens com jQuery também, ou criado eles através do código JavaScript padrão e elementos DOM. De fato, ambos os métodos append() e prepend() recebem uma quantidade infinita de novos elementos como parâmetros. No próximo exemplo, nós vamos demonstrar isso também como a habilidade para adicionar elementos de várias formas:

<a href="javascript:void(0);" onclick="AppendItemsToList();">Append items</a>   
<ol id="olTestList2"></ol>
<script type="text/javascript">
function AppendItemsToList()
{
        var item1 = $("<li></li>").text("Item 1");
        var item2 = "<li>Item 2</li>";
        var item3 = document.createElement("li");
        item3.innerHTML = "Item 3";
        
        $("#olTestList2").append(item1, item2, item3);
}
</script>

Como você pode ver, o item1 é um elemento gerado por jQuery, o item2 é uma simples string HTML e o item3 é um elemento gerado por JavaScript DOM.Todos eles foram anexado a lista usando a mesma chamada e claro isso deveria funcionar para o método prepend() também.

Existem variações dos métodos append() e prepend(), chamados appendTo() e prependTo(). Eles fazem praticamente a mesma coisa, mas eles fazem isso ao contrário, então em invés de os chamarem nos elementos que você deseja anexar/prefixar, com um parâmetro do que é para ser anexado/prefixado, você faz exatamente o oposto. Qual usar obviamente depende da situação, mas aqui está um exemplo mostrando a você como usar ambos:

<a href="javascript:void(0);" onclick="PrependItemsToList();">Prepend items</a>   
<ol id="olTestList3"></ol>
<script type="text/javascript">
function PrependItemsToList()
{       
        $("#olTestList3").prepend($("<li></li>").text("prepend() item"));
        $("<li></li>").text("prependTo() item").prependTo("#olTestList3");
}
</script>

Neste exemplo, nós prefixamos os itens, mas você poderia com certeza fazer a mesma coisa usando append() e appendTo(). Como você pode ver, o resultado é o mesmo – apenas a ordem do que nós fazemos difere.

Fonte: jquery-tutorial.net

Como pegar tempo em milisegundos no Java

No java temos 2 jeitos de pegar o tempo em milisegundos:

Utilizando a classe Date – pelo método getTime();

 Utilizando a classe Calendar – pelo método getTimeInMillis().

___________________________________________________________________

import java.util.Calendar;
import java.util.Date;

public class TimeMilisecond {
  public static void main(String[] argv) {

      long lDateTime = new Date().getTime();
      System.out.println("Date() - Tempo em milisegundos: " + lDateTime);

      Calendar lCDateTime = Calendar.getInstance();
      System.out.println("Calender - Tempo em milisegundos :" + lCDateTime.getTimeInMillis());
  }
}

___________________________________________________________________

Fonte: Mkyong