Ignorando acentuação no Hibernate Search

hibernate

opa Pessoal,

Esses dias precisei fazer uma implementação com o Hibernate Search e passei aperto, pois precisava que acentuação fosse ignorado durante a pesquisa, iai ?

lets go…
Problema

É rapaz, parece que é trivial, mas nem tanto como é no Criteria. Olhando a documentação e fazendo uma pesquisa no velho Google acahei a solução, para que o Hibernate Search ignore acentuação durante as pesquisas.
Solução

O resultado é bem simples, apenas precisamos definir as seguintes anotações na classe de pesquisa veja:

@AnalyzerDef(name = "customAnalyzer",
tokenizer = @TokenizerDef(factory = StandardTokenizerFactory.class),
filters = {
@TokenFilterDef(factory = LowerCaseFilterFactory.class),
@TokenFilterDef(factory = ASCIIFoldingFilterFactory.class),
@TokenFilterDef(factory = SnowballPorterFilterFactory.class)
})
public class Professor{

}

E já ignora maiusculo/minusculo também.

Vou ficando por aqui e espero que tenham gostado do post de hoje.

abraços, see ya!!

Acessando atributos de outras classes no Hibernate search

hibernate

Olá Pessoal,

O post de hoje é bem simples, recentemente passei por um problema em como acessar os atributos de outra classe atraves do hibernate search.

Let go..
Problema

Você tem a classe Carro e essa classe tem um objeto Motor e vc precisa acessar o atributo versao que está na classe Motor. Como fazer isso com hibernate search? Parece que é simples né? Nem tanto gastei algumas horas até saber como fazer.
Solução

Vamos lá, você vai precisar na classe Carro fazer isso:

@Indexed
class Carro{

@IndexedEmbedded
private Motor motor;

}

E na classe Motor isso:

@Indexed
class Motor{

@Field(index=Index.YES, analyze=Analyze.YES, store=Store.NO) 
@ContainedIn
private String versao;
}

Agora na sua busca ficará assim:

QueryBuilder queryBuilder = fullTextSession.getSearchFactory().buildQueryBuilder().forEntity(Professor.class).get();

Query query = queryBuilder.keyword().onFields( "motor.nome")
.matching(descricao).createQuery();

FullTextQuery hibQuery = fullTextSession.createFullTextQuery(query, Carro.class, Motor.class);

Observe que o pulo do gato “motor.nome”.

Resolvido.

abraço, see ya!!!

Troubleshooting PersistenceExceptionTranslationInterceptor Spring

 

Olá Pessoal,

O troubleshooting de hoje é para qume está sobrendo com o Hibernate e Spring.  Vamos ver os erros e como podemos resolver. 

Caused by: java.lang.IllegalStateException: No persistence exception translators found in bean factory. Cannot perform exception translation.

                at org.springframework.dao.support.PersistenceExceptionTranslationInterceptor.detectPersistenceExceptionTranslators

Esse erro acontece normalmente quando estamos usando a versão do Hibernate 4 no Spring, porém usando as configurações do Hibernate 3. A resolução é simples, veja:

No hibernate 3 usamos o translation assim:

<bean class=”org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor”/>

No Hibernate 4.x deve ser assim:

<bean class=”org.springframework.orm.hibernate4.HibernateExceptionTranslator”/>

O sessionFactory também deve ser alterado, veja:

No Hibernate 3 é assim:

<bean id=”sessionFactory” class=”org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean”>

Mas no Hibernate 4 deve ser assim:

<bean id=”sessionFactory” class=”org.springframework.orm.hibernate4.LocalSessionFactoryBean”>

Pronto! Assim resolvemos a exception de translation com Hibernate. Fiquem espertos com esses detalhes para não gastar tanto tempo.

Abracos, see ya!!

Troubleshooting: Maven HSQLDB Exception Hibernate 4

 

Olá pessoal,

O troubleshooting de hoje é bem simples, pelo menos nesse aqui não levei mais que 20 min para achar a solução. Migrando de Hibernate 3.x para  4.x  tive um problema com os testes que rodam com HSQLDB ao executar mvn test. Vamos ver o problema.

Lets go…

O problema

Ao executar os testes localmente fora do maven pelo Eclipse, funcionava normalmente, claro tinham as libs corretas no meu classpath, mas ao rodar pelo maven, os testes que usavam HSQLDB falhavam e com a seguinte exceção:

org.hibernate.exception.GenericJDBCException: This function is not supported

Caused by: java.sql.SQLException: This function is not supported

 

O motivo

A dependência para o HSQLDB deve ser:

<dependency>

<groupId>org.hsqldb</groupId>

<artifactId>hsqldb</artifactId>

<version>2.2.8</version>

</dependency>

 

Porém é comum declararmos:

<dependency>

<groupId>hsqldb</groupId>

<artifactId>hsqldb</artifactId>

<version>1.8.0.10</version>

</dependency>

 

Não use essa última, pois ela não dá suporte ao Hibernate 4. Não cheguei a testar se no Hibernate 3 há o mesmo problema.

Feita a alteração, rode mvn test e veja que seus testes passarão normalmente.

É isso ai, vivendo e aprendendo. Vou ficando por aqui…

Abraços, see ya!! 

Criando GenericDAO e DAOFactory em poucos passos

Ola pessoal,

No post de hoje vamos ver como criar genericDAO e DAOFactory  em poucos passos. O objetivo maior aqui é colocar a mão na massa. Os conceitos DAO Design Pattern não serão abordados, pois o que não falta é explicação na internet sobre o assunto. Vou considerar que você sabe conceitualmente um DAO, mas que nunca implementou  de forma genérica.

Lets go…

 

Primeiro passo

Cria a interface GenericDAO :

public interface GenericDAO<T,Type extends Serializable> {

void beginTransaction();

void commitTransaction();

void save(T entity);

void delete (T entity);

List<T> listAll();

}

O código acima usa apenas o recurso de generics do Java 5, deixando a interface que extends dizer qual será o tipo para T e o para Type.

O que significa cada um?

Simples: o T será a classe, ou seja, a entidade. O Type representará o tipo que usaremos para o Id da entidade. Você pode estar se perguntando pq a letra T e a palavra type. Apenas segui uma convenção, mas poderia ser qualquer outra letra ou nome.

Agora precisamos criar a interface dos nossos DAO, que nesse caso teremos as seguintes interfaces: ClientDAO e AccountDAO.

public interface AccountDAO extends GenericDAO<Account, Long>{

}

public interface ClientDAO extends GenericDAO<Client, Long> {

}

Observe que nas nossas interfaces é que definimos para qual entidade ela está associada e qual será o tipo do nosso ID.

É nessa interface que colocamos os métodos específicos para o nosso DAO.

Abstract HibernateDAO

Criaremos uma classe abstract que vai implementar o métodos abstract da interface GenericDAO. E nossas classes concentras vão extends a HibernateDAO como veremos a seguir. Mas antes disso precisamos criar uma classe utilitária que chamei de HibernateUtil, que terá o método para obtermos a sessão, iniciar a transação, commit, etc.

public class HibernateUtil {

private static SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

private static ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();

public static Session getSession() {

Session session = threadLocal.get();

if (session == null) {

session = sessionFactory.openSession();

threadLocal.set(session);

}

return session;

}

public static void beginTransaction() {

getSession().beginTransaction();

}

 public static void commitTransaction() {

getSession().getTransaction().commit();

public static void rollBackTransaction() {

getSession().getTransaction().rollback();

}

public static void closeSession() {

getSession().close();

}

}

E na classe HibernateDao temos o código a seguir:

public abstract class HibernateDAO<T, Type extends Serializable> implements GenericDAO<T, Type>{

private Class<T> persistentClass;

public HibernateDAO(Class persistentClass) {

super();

this.persistentClass = persistentClass;

}

@Override

public void beginTransaction() {

HibernateUtil.beginTransaction();

}

@Override

public void commitTransaction() {

HibernateUtil.commitTransaction();

}

@Override

public void save(T entity) {

HibernateUtil.getSession().saveOrUpdate(entity);

}

@Override

public void delete(T entity) {

HibernateUtil.getSession().delete(entity);

}

@Override

public List<T> listAll() {

HibernateUtil.beginTransaction();

Criteria criteria = HibernateUtil.getSession().createCriteria(persistentClass);

return criteria.list();

}

}

Observe que implementamos todos os métodos da GenericDAO, assim a classe que extends já tem a implementation done, ou seja, aquilo que é comum para qualquer  classe DAO já vai estar implementado e disponível na classe pai.

Concrete DAO

Agora vamos criar a classe concreta que terá a implementação específica para cada DAO.

class HibernateClientDAO extends HibernateDAO<Client, Long> implements  ClientDAO {

public HibernateClientDAO(){

//                           we passing the entity for super class

super(Client.class);

}

}

Como não temos nada de específico para implementar da interface ClientDAO deixaremos o código assim. Observe que no construtor passei qual será o tipo T, que nesse caso será a class do Client.

DAOFactory

Agora vamos criar um DAOFactory que será responsável por criar as instâncias das classes Hibernate. A classe DAOFactory será abstract e tendo apenas um método implementado que será o getFactory, o qual terá como objetivo simplesmente de retornar uma instância da classe.

public abstract class DAOFactory {

private static final Class FACTORY_CLASS = HibernateDAOFactory.class;

public static DAOFactory getFactory(){

try {

return (DAOFactory) FACTORY_CLASS.newInstance();

} catch (InstantiationException e) {

// TODO Auto-generated catch block

throw new RuntimeException();

} catch (IllegalAccessException e) {

// TODO Auto-generated catch block

throw new RuntimeException();

}

}

public abstract ClientDAO getClientDAO();

public abstract AccountDAO getAccountDAO();

}

Em seguida adicionamos os métodos que retornam a instância para as classes que implementam as interfaces ClientDAO e AccountDAO.

Agora teremos uma classe que implementa os métodos do DAOFactory, que será a classe HibernateDAOFactory.

public class HibernateDAOFactory  extends DAOFactory{

@Override

public ClientDAO getClientDAO() {

return new HibernateClientDAO();

}

@Override

public AccountDAO getAccountDAO() {

return new HibernateAccountDAO();

}

}

Observe que apenas instanciamos as classes para cada DAO. Agora vamos criar  HibernateAccountDAO

class HibernateAccountDAO extends HibernateDAO<Account, Long> implements AccountDAO {

public HibernateAccountDAO() {

super(Account.class);

}

}

E para testar, criaremos uma classe com o método main:

public class MainBank {

public static void main(String[] args) {

//                           getting instance of the factory

DAOFactory daoFactory = DAOFactory.getFactory();

//                           getting intance of clientDAO and starting transaction

daoFactory.getClientDAO().beginTransaction();

ClientDAO clientDAO = daoFactory.getClientDAO();

Client client = new Client();

client.setName(“Camilo Lopes”);

//                           creating object of the entity

Account checkigAccount = new Account();

checkigAccount.setAccountType(AccountType.CHECKING_ACCOUNT);

//                           associate acocunt with the client

checkigAccount.setClient(client);

//                           money available in account

checkigAccount.setBalance(BigDecimal.ONE);

client.getAccount().add(checkigAccount);

//                           saveing in hibernate session

clientDAO.save(client);

AccountDAO accountDAO = daoFactory.getAccountDAO();

accountDAO.save(checkigAccount);

//                           commit

clientDAO.commitTransaction();

}

}

Resultado

É isso ai pessoal, espero que tenham gostado. Vou ficando por aqui. 

See ya!!!