Série Spring: CRUD Spring 3 + Hibernate + Unit Tests

Olá Pessoal,

No post de hoje veremos como fazer um simples CRUD usando o Spring, integrando com Hibernate e testando via unit tests com JUNIT4. No último posts vimos apenas uma integração com o Hibernate e também um CRUD usando HibernateTemplate, esse aqui  veremos que na versão 3 do Spring não precisamos mais do HiberanteTemplate e vamos testar nosso código com unit test.

Lets go…

Starting…

Primeiro passo é que  estarei assumindo que você já tem .jars necessário  para o ambiente. Já que esse não é o primeiro post da série, caso contrário terá que baixar os .jars para: driver Mysql 5, Hibernate 3.6, AOP, AspectJ, Spring 3.x.

Antes de começarmos a desenvolver, vamos primeiro estruturar nosso projeto e packages conforme a imagem a seguir:

springrentcarproject

Nosso CRUD será o cadastro  de veículos  que serão alugados. Claro que há muito mais regras de negócios do que a que veremos no exemplo a seguir, porém o nosso objetivo é explorar o framework Spring e não tratar todas as regras de negócio em um post.

  1. Crie a estrutura conforme a imagem acima
  2. Crie o arquivo de configuração de Spring, o qual chamei de springconfiguration.xml, e coloque dentro do package config.
  3.    Agora vamos colocar a carne no nosso XML

Cabeçalho fica assim:

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns:context=“http://www.springframework.org/schema/context”

xmlns:tx=“http://www.springframework.org/schema/tx”

xmlns:aop=“http://www.springframework.org/schema/aop”

xsi:schemaLocation=“http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.2.xsd”>

 

Estarei comentando mais na frente ou in line apenas o que  ainda não foi abordado nos posts anteriores.

O cara que busca os beans: 

<context:component-scan base-package=“*”/>

 Colocando translation

<!– esse cara faz as traduções das exception checked para as unchecked do Spring –>

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

Data source

<!– pelo nome diz, data source para conexão com o DB –>

<bean id=“dataSource” class=“org.springframework.jdbc.datasource.DriverManagerDataSource”>

<property name=“driverClassName” value=“com.mysql.jdbc.Driver”/>

<property name=“url” value=“jdbc:mysql://localhost/test”/>

<property name=“username” value=“root”/>

<property name=“password” value=“camilo2593”/>

</bean>

 

Configurando a SessionFactory

<!– Aqui estamos definido como será a parte de persistêcia, e dizemos que faremos via annotation –>

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

<!– informando a quem estaremos conectado –>

<property name=“dataSource” ref=“dataSource”/>

<!– dizendo onde estão as classes dominio, ele saberá devido anotação @Entity  –>

<property name=“packagesToScan” value=“br.com.camilolopes.rentcar.domain.bean”/>

<!– configurando coisas especificas do Hibernate –>

<property name=“hibernateProperties”>

<props>

<prop key=“hibernate.dialect”>org.hibernate.dialect.MySQL5InnoDBDialect</prop>

<prop key=“hibernate.hbm2ddl.auto”>update</prop>

</props>

</property>

</bean>

 

Definindo Transaction

 <!– definindo quem vai gerenciar as transaction, ou seja, será o Hibernate –>

<bean id=“transactionManager” class=“org.springframework.orm.hibernate3.HibernateTransactionManager”>

<property name=“sessionFactory” ref=“sessionFactory”/>

</bean>

</beans>

Há duas formas de declararmos as transaction no Spring por XML ou Annotation.  Veremos as duas formas, no nosso caso de usarmos o XML faremos com AOP e você entenderá o  motivo:

Via XML

<!– todo medoto que começa com add é required uma transaction –>

<tx:advice id=“txAdvice”>

<tx:attributes>

<tx:method name=“add*” propagation=“REQUIRED”/>

<tx:method name=“update*” propagation=“REQUIRED”/>

<tx:method name=“*” propagation=“SUPPORTS” read-only=“true”/>

</tx:attributes>

</tx:advice>

<!– toda classe que extends a interface terá uma referência para o advisor –>

<aop:config>

<aop:advisor pointcut = “execution(* *..RentCar.*(..)))” advice-ref=“txAdvice”/>

</aop:config>

 

Em alguns contexto dessa forma é bem mais prático que usar Annotations.

 

Via annotation

Remove todo o código XML acima e apenas adiciona a seguinte linha:

<tx:annotation-driven/>

 

Claro que teremos que anotar nas classes/métodos como @Transaction e informar como esse deve se comportar , seguindo o exemplo do XML acima seria algo  assim:

@Transactional(readOnly=true,propagation=Propagation.SUPPORTS)

public class myClass{  }

 

Normalmente você colocaria isso na camada de serviço.Mas, se você está brincando  e não tem uma camada de serviço, pode colocar direto no DAO.

E o método que faria uma das operações de banco ficaria assim:

@Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED)

      public void save(Car car) {

            getCurrentSession().save(car);}

 

No nosso exemplo vamos não vamos usar Annotations e exploraremos o benefício de usar a versão do XML conforme acima, se vc deixar a tag para annotation no arquivo de configuração o Spring não vai se importar com isso.

Desenvolvimento

Após toda essa configuração, vamos agora desenvolver nossas classes .java. Começando pela classe de domínio:

@Entity

@Table(name=”CARS”)

public class Car implements Serializable{

private static final long serialVersionUID = -2896368465389020843L;

      @Id

      @GeneratedValue

      private Long id;

      private String manufacter;

      private String description;

      private BigDecimal marketValue;

                //getters/setters omitidos

Basicamente isso .

Interface DAO

public interface RentCarDAO {

      void save(Car car);

      List<Car> findAll();

      List<Car> findAllByDescription(String description);

      void update(Car car);

      void delete();

}

Implementação da Interface:

@Repository

public class RentCarDAOImpl implements RentCarDAO {

      @Autowired

      private SessionFactory sessionFactory;

      public Session getCurrentSession(){

            return sessionFactory.getCurrentSession();

      }

      @Override

      public void save(Car car) {

            getCurrentSession().save(car);

      }

      public void setSessionFactory(SessionFactory sessionFactory) {

            this.sessionFactory = sessionFactory;

      }

      @Override

      public List<Car> findAll() {

            return getCurrentSession().createCriteria(Car.class).list();

      }

      @Override

public List<Car> findAllByDescription(String description) {

Criteria createCriteria = getCurrentSession().createCriteria(Car.class);

createCriteria.add(Restrictions.ilike(“description”, description));

            return (List<Car>) createCriteria.list();

      }

      @Override

      public void update(Car car) {

            getCurrentSession().update(car);

      }

      @Override

      public void delete() {

Query query = getCurrentSession().createQuery(“delete from Car where id >0”);

            query.executeUpdate();

      }

Interface de Serviço

@Service

public interface RentCar {

      void addNewCar(Car car);

      List<Car> findAll();

      List<Car> findCarByDescription(String description);

      void updateCar(Car car);

      void delete();

}

Classe que implementa o Serviço

@Service

public class RentCarServiceImpl implements RentCar {

      @Autowired

      private RentCarDAO rentCarDAO;

      @Override

      public void addNewCar(Car car) {

            rentCarDAO.save(car);

      }

      public void setRentCarDAO(RentCarDAO rentCarDAO) {

            this.rentCarDAO = rentCarDAO;

      }

      @Override

      public List<Car> findAll() {           

            return rentCarDAO.findAll();

      }

      @Override

      public List<Car>findCarByDescription(String description) {

           return (List<Car>) rentCarDAO.findAllByDescription(description);

      }

      @Override

      public void updateCar(Car car) {

            rentCarDAO.update(car);

      }

      @Override

      public void delete() {

      rentCarDAO.delete();     

      }

}

 

Unit Test

Se não reparou quando criou o projeto, temos um source  apenas  para os unit tests, conforme a imagem a seguir:

springrentcarunittestssource

Agora crie a classe de teste. A seguir mostrarei apenas dois simples testes, você deve criar os demais para validar os cenários, não coloquei todos para não ficar mais longo ainda o post.

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations={“classpath:config/springconfiguration.xml”})

public class RentCarServicesTest {

      @Autowired

      private RentCar rentCarServicesImpl;

      private Car car;

      @Before

      public void setUp() throws Exception {

            car = new Car();

      }

      @Test

      public void testAddingNewCarWithSuccess(){

            try{

                  car.setDescription(“Civic”);

                  car.setManufacter(“Honda”);

                  car.setMarketValue(new BigDecimal(740000));

                  rentCarServicesImpl.addNewCar(car );

            }catch (Exception e) {

                  Assert.fail(“not expected result”);

            }

      }

      @Test

      public void testListAllCarIsNotEmpty(){

            assertFalse(rentCarServicesImpl.findAll().isEmpty());

      }

 Resultado

Lembre-se que seu BD precisa está rodando

springhibernateunittestresult

 

Ufa! Esse post foi longo heim, mas não tinha outra forma de mostrar tudo se não fosse assim, e olha que busquei resumir ao máximo possível. Enfim, vou ficando por aqui.

GitHub

Acesse o repositório no github com todos os projetos da série Spring:  https://github.com/camilolopes/workspacespring

Espero que tenham gostado do post.

Abraços, see ya!! 

Série Spring:Spring 3 com Hibernate 3.x

Olá Pessoal,

No post de hoje, veremos como integrar Spring com Hibernate. Ou seja, como podemos deixar tudo ao comando do Spring?  Deixar ele abrir ,fechar, commit , dar roll back nas transações? Diretamente o Spring não faz isso, mas ele delega para um cara que pode fazer isso. A moral da história que ao invés de nós programadores ter que dar beginTransaction, isso serrá feito nos bastidores. No exemplo a seguir fazeremos apenas um insert no banco de dados.

Lets go…

 

Requisitos

Antes de mais nada certifique que vc tem os .jars baixados:

  • – Mysql 5 .x
  • – Hibernate 3.6
  • – Spring 3.x
  • – AOP 1.x
  • – AspectJ
  • – commons-logging 1.x

Depois de garantir que você tem todos os .jars mãos na massa agora.

Starting…

Primeiro passo é que nosso exemplo será um Java Application, o objetivo é fazer a integração de maneira mais simples e funcional possível. Então crie seu Java Project e deixe conforme a imagem a seguir:

springwithhibernateproject

No final teremos os seguintes packages e classes:

 springhibernatepackages

Por onde começar?

Eu gosto sempre de iniciar pela parte de configuração, assim quando vou começar o desenvolvimento não preciso voltar para configurar, exceto quando é algo bem pontual. Então, iniciaremos pelo arquivo de configuração do Spring, no package config, crie um springconfiguration.xml.

Vou colocar o arquivo por partes e explicando, além disso coloquei uns comentários no .xml para facilitar o entendimento:

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns:context=“http://www.springframework.org/schema/context”

xmlns:tx=“http://www.springframework.org/schema/tx”

xsi:schemaLocation=“http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd”>

 

Se vc vem acompanhando os outros posts e já conhece o básico do Spring deve conhecer o beans. A única coisa de novo que adicionamos aqui foi o xmlns tx para as transaction, que veremos mais na frente a sua importância. Portanto deixe seu beans conforme o código acima.

<!– buscando os beans –>

<context:component-scan base-package=“*” />

<!– transaction via annotations –>

<tx:annotation-driven />

<!– Translate exception –>

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

 Aqui  temos um cara novo que é o PersistenceExceptionTransalationPostProcessor que é responsável por  “traduzir” as exceções checked em unchecked do Spring, assim não precisamos ficar tratando na nossa application.  Habilitamos que as transaction serão via annotation, ou seja, o Spring vai procurar pela annotation @Transaction. E também informamos que todo bean do Spring será via annotation e base de package colocamos todos.

DataSource

Agora precisamos criar um DataSource assim vamos dizer a que banco estaremos conectado em qual url e com o usuário xxxx, com a senha yyyyy.

<bean id=“dataSource” class=“org.springframework.jdbc.datasource.DriverManagerDataSource”>

<property name=“driverClassName” value=“com.mysql.jdbc.Driver”/>

<property name=“url” value=“jdbc:mysql://localhost/test”/>

<property name=“username” value=“root”/>

<property name=“password” value=“bahia”/>

</bean>

 SessionFactory

Agora precisamos configurar nossa  sessionFactory, nesse caso estamos dizendo que vamos usar annotation  para persistência. Lembra que fazíamos isso diretamente no Hibernate na hora de criar a sessionFactory (new annotationXXX)?  Aqui há alguns pontos importantes:

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

<!– informando o datasource, de onde vem a conexão? –>

<property name=“dataSource” ref=“dataSource”/>

<!– onde estão as classes com annotation? informando aqui –>

<property name=“packagesToScan” value=“br.com.camilolopes.model.bean”/>

<!– as configs do ormhibernate –>

<property name=“hibernateProperties”>

      <props>

<prop key=“hibernate.dialect”>org.hibernate.dialect.MySQL5InnoDBDialect”</prop>

      <prop key=“hibernate.hbm2ddl.auto”>update</prop>

      </props>

</property>

</bean>

 

Agora precisamos criar o cara que vai gerenciar as transaction no nosso caso como estamos usando o Hibernate será o HibernateTransactionManager:

<!–  esse é o cara que gerencia as transactions –>

<bean id=“transactionManager” class=“org.springframework.orm.hibernate3.HibernateTransactionManager”>

<property name=“sessionFactory” ref=“sessionFactory”/>

</bean>

 Pronto terminamos a parte de configuração. Vamos agora para parte Java

Development

No package dao. Criaremos uma interface. Nossa aplicação vai salvar um produto apenas.

public interface ProductDAO {

      void save(ProductTech product);

}

 Agora vem a classe que implementa a interface:

@Repository

public class ProductDAOImpl implements ProductDAO {

      private SessionFactory sessionFactory;

      @Autowired

      public ProductDAOImpl(SessionFactory sessionFactory) {

            this.sessionFactory = sessionFactory;

      }

      private Session currentSession(){

            return sessionFactory.getCurrentSession();

      }

       @Override  //para execução deste método é requerido uma transação, é isso que estamos dizendo aqui

      @Transactional(propagation=Propagation.REQUIRED,readOnly=false)

      public void save(ProductTech product) {

            currentSession().save(product);

            System.out.println(“product saved with sucess”);

      }

}

 

E a nossa entidade:

@Entity

public class ProductTech implements Serializable{

      @Id

      @GeneratedValue

      private Long id;

      private String nameProduct;

                //getters/setters ommitidos

 

Testando

Vamos criar uma classe com método main para testar:

public class MainTestDAO {

      public static void main(String[] args) {

            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“config/springconfiguration.xml”);

            ProductDAO bean = (ProductDAO) applicationContext.getBean(“productDAOImpl”);

            ProductTech product= new ProductTech();

            product.setNameProduct(“tablet samsung galaxy”);

            bean.save(product);

      }

}

Antes de rodar garanta que o Banco está rodando.  Ao executar:

springhibernateresultado

Fácil não? Nos preocupamos mais com a parte de negócio, toda aquela parte chata de transação por exemplo está sendo cuidada nos bastidores.

Bom, vou ficando por aqui. E espero que tenham gostado do post.

Abraços see ya!! 

Série Spring: CRUD com Hibernate e Spring framework

olá Pessoal,

O post de hoje vamos fazer um CRUD usando Spring com Hibernate. Nós últimos posts vimos as coisas de forma separada para entendermos o funcionamento bem especifico. Vou considerar que leu nossos posts anteriores e aquilo que já foi explicado não estarei repetindo,para evitar que o post fique longo, apenas estarei ressaltando o que for importante e relevante para que você entenda.

Lets go..

O nosso Cenário

Será bem simples e funcional e o mais direto possível. O cenário é bem trivial uma livraria tem vários e um livro está para uma categoria, e em uma categoria pode ter vários livros.Dai vamos exercitar o relancionamento @OneToMany do hibernate e a integração do Hibernate com Spring. E para completar faremos a injeção de dependência usando Annotations.

 

Desenvolvimento

A seguir como ficará o nosso projeto

 springcrudbookproject

1. Crie um java project e os respectivos packages 

2. Adicione as bibliotecas do Spring Framework 3.x, Hibernate 3.x e MySql 5.x 

3. Crie a interface que terá o CRUD:

public interface BookStore {

                void saveOrUpdate(Book book);

                void delete(Book book);

                Book findById(Long id);

} 

4. Agora criaremos a classe que vai implementar a Interface:

@Repository

public class BookStoreDAO implements BookStore {               

                @Autowired

                private HibernateTemplate hibernateTemplate; 

                @Override

                public Book findById(Long id) {

                               return hibernateTemplate.get(Book.class, id);

                } 

                public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {

                               this.hibernateTemplate = hibernateTemplate;

                } 

                public HibernateTemplate getHibernateTemplate() {

                               return hibernateTemplate;

                } 

                @Override

                public void saveOrUpdate(Book book) {

                               hibernateTemplate.saveOrUpdate(book);

                } 

                @Override

                public void delete(Book book) {

                               hibernateTemplate.delete(book);

                }}

 

 Até aqui nada de especial, exceto anotação @Autowired que colocamos para informar ao Spring que aquele atributo é dependecy injection que é controlado por ele. Quando criarmos o nosso arquivo de configuração do Spring vamos dizer para ele como olhar para as annotations. E anotação @Repository é para dizer ao Spring que essa classe é um DAO.

Agora vamos criar a classe CategoryDAO que vai persistir as categorias

@Repository

public class CategoryDAO {

                @Autowired

                private HibernateTemplate hibernateTemplate;               

                public void saveOrUpdate(Category category){

                               hibernateTemplate.saveOrUpdate(category);

                }}

Por enquanto essa classe não vai compilar, pq ainda não criamos a classe Category que criamos daqui a pouco, aguarde mais uns minutinhos. Bom,  até agora temos nossos DAOs prontos. Vamos criar nossos beans.

 

Book .java 

@Entity

public class Book implements Serializable{

                private static final long serialVersionUID = 888299914160143622L;               

                @Id

                @GeneratedValue

                private Long id;

                private Long isbn;

                private String title;

                private String author;

                @ManyToOne

                @JoinColumn(name=”category_id”)

                @Autowired

                private Category category;

//getters/setters omitidos

 

Category.java 

@Entity

public class Category implements Serializable { 

                private static final long serialVersionUID = 6469382724082923338L;

                @Id

                @GeneratedValue

                private Long id;

                private String categoryName;

                @OneToMany(mappedBy=”category”,targetEntity=Book.class,

fetch=FetchType.LAZY,cascade=CascadeType.ALL)

                @Autowired

                private List<Book> books = new ArrayList<Book>();

//getters/setters omitidos

 

Nada de especial aqui, apenas um relacionamento @OneToMany/@ManyToOne e o famoso @AutoWired que fará injeção de dependência.

 

Configurando o Spring 

1. Crie um arquivo xml e coloque no package conf,o meu chamei de springconfiguration.xml

 

O cabeçalho fica assim para dar suporte aos annotations: 

<beans xmlns=”http://www.springframework.org/schema/beans”

xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”

xmlns:context=”http://www.springframework.org/schema/context”

xsi:schemaLocation=”http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.1.xsd”>

 

Agora vamos criar os beans:

<!– beans  –>

 <bean  id=”category” class=”br.com.camilolopes.domain.classes.Category”/>

 <bean  id=”book”/>

 <bean  id=”bookstoredao” class=”br.com.camilolopes.dao.BookStoreDAO”/>

 <bean  id=”categorydao” class=”br.com.camilolopes.dao.CategoryDAO”/>

 

O dataSource, vou usar o MySql 

<!– DataSource –>

<bean id=”dataSource”>

                <property name=”driverClassName” value=”com.mysql.jdbc.Driver”/>

                <property name=”url” value=”jdbc:mysql://localhost/test”/>

                <property name=”username” value=”root”/>

                <property name=”password” value=”camilo2593″/>

</bean>

 <!– Using Annotations for mapping –>

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

 <!– property for DataBase –>

                <property name=”dataSource” ref=”dataSource”/>

                <!– informing the annotated classes –>

                 <property name=”annotatedClasses”>

                <list>

                               <value>br.com.camilolopes.domain.classes.Book</value>

                               <value>br.com.camilolopes.domain.classes.Category</value>

                </list>

                </property>

                <!– Property of Hibernate –>

                <property name=”hibernateProperties”>

                               <props>

                               <prop key=”hibernate.dialect”>org.hibernate.dialect.MySQLDialect</prop>

                <prop key=”hibernate.show_sql”>true</prop>

                <prop key=”hibernate.hbm2ddl.auto”>update</prop>

                               </props>

                </property>

 </bean> 

 <!– using HibernateTemplate from Spring –>

 <bean  id=”hibernateTemplate” class=”org.springframework.orm.hibernate3.HibernateTemplate”>

                <property name=”sessionFactory” ref=”sessionFactory”/>

 </bean>

 

E definindo o uso de annotations para o Spring:

<context:annotation-config/>

E não esqueça de fechar o arquivo com:

</beans>

 

Agora criaremos uma classe com método main para realizar o CRUD: 

 

bdcrudspring

Esse é o nosso banco, com um cara já persistido: 

Crie a classe Main 

public class Main {

                public static void main(String[] args) {

//                           essa classe é o container

                               ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

                                                               “conf/springconfiguration.xml”);

                               BookStoreDAO bookStoreDAO = (BookStoreDAO) applicationContext.getBean(“bookstoredao”);

                               CategoryDAO categoryDAO = (CategoryDAO) applicationContext.getBean(“categorydao”);                              

//                           Book

                               Book book = new Book();

                               book.setAuthor(“Camilo Lopes”);

                               book.setIsbn(1235L);

                               book.setTitle(“Guia JEE c/ Frameworks”);                              

                               //Category

                               Category category = new Category();

                               category.getBooks().add(book);

                               category.setBooks(category.getBooks());

                               category.setCategoryName(“Development”);

                               book.setCategory(category );

//                           DAO

                                categoryDAO.saveOrUpdate(category);

                               bookStoreDAO.saveOrUpdate(book);                              

                               findBookById(bookStoreDAO, 1L);

                               deleteBook(bookStoreDAO,1L);

                }               

                private static void deleteBook(BookStoreDAO bookStoreDAO, long id) {

                               Book bookFound = bookStoreDAO.findById(id);

                               bookStoreDAO.delete(bookFound);

                               System.out.println(“Book deleted with sucess ” + bookFound.getTitle());                              

                }

                private static void findBookById(BookStoreDAO bookStoreDAO, Long id){

                               Book book = bookStoreDAO.findById(id);

                               System.out.println(“Title: “+ book.getTitle());

                               System.out.println(“Author: ” + book.getAuthor());

                }}

 

O código é bem simples somente para testarmos. Observe que salvamos um novo livro, em seguida buscamos o mesmo pelo Id e imprimos usando  o console do Java e depois deletamos o livro pelo Id.

Ao rodar teremos o resultado a seguir: 

resultcrudspring

Se formos no banco esperamos ter apenas o livro mais recente adicionado com o id igual 2 e o livro com o id = 1 deve ter sido deletado, com a imagem acima já vimos isso, pq temos o sql do hibernate habilitado, mas vamos ver na tabela do banco:

resultspringbd

 

resultcategoryspringbd

 

GitHub

Acesse o repositório no github com todos os projetos da série Spring:  https://github.com/camilolopes/workspacespring

Bom vou ficando por aqui, espero que tenham gostado do post.

abracos, see ya!!!

Série Spring: Hibernate com Spring Framework

olá pessoal,

No post de hoje vamos ver como integrar o Hibernate com Spring, faremos um exemplo muito simples que irá persistir um dado no banco. Vou considerar que você já tem o Hibernate 3.x e o Spring 3.x na sua máquina.

Lets go… 

Starting

Para o exemplo vou usar o Mysql, caso não tenha o driver de conexão vá no site do fabricante  e faça o download.

Desenvolvendo

Crie um java project, o meu será chamado de SpringHibernate.

springhibernateproject

Agora crie o bean:

@Entity

public class Spring {

@Id

@GeneratedValue

private Long id;

private String name;

//getters/setters omitidos

}

 

E agora vamos criar o DAO:

@Repository

public class SpringDAO {

/*

* esse é o cara que cuida de tudo, obter a transação, iniciar

* fechar e persistir

*/

private HibernateTemplate hibernateTemplate;

public HibernateTemplate getHibernateTemplate() {

return hibernateTemplate;

}

public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {

this.hibernateTemplate = hibernateTemplate;

}

public long save(Spring spring){

long cod =          (Long) hibernateTemplate.save(spring);

return cod;

}

}

 

Note: Observe que o método save retorna um valor do tipo long, que é o id do objeto inserido. Fiz isso somente para vermos qual foi o ID que o registro recebeu.

 

Feito isso precisamos passar umas informações para o Spring, tudo será feito no xml de configuração do Srping framework que criamos, fiz comentário in line para facilitar o entendimento:

<!– DataSource –>

<bean id=”dataSource” class=”org.springframework.jdbc.datasource.DriverManagerDataSource”>

<property name=”driverClassName” value=”com.mysql.jdbc.Driver”/>

<property name=”url” value=”jdbc:mysql://localhost/test”/>

<property name=”username” value=”root”/>

<property name=”password” value=”123456″/>

</bean>

<bean id=”hibernateTemplate” class=”org.springframework.orm.hibernate3.HibernateTemplate”>

<property name=”sessionFactory” ref=”sessionFactory”/>

</bean>

<!– usando annotation para mapeamento do bean –>

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

<property name=”dataSource” ref=”dataSource” />

<property name=”annotatedClasses”>

<!– passando a bean anotado –>

<list>

<value>br.com.camilolopes.classes.Spring</value>

</list>

</property>

<!– configurações para o hibernate properties –>

<property name=”hibernateProperties”>

<props>

<prop key=”hibernate.dialect”>org.hibernate.dialect.MySQLDialect</prop>

<prop key=”hibernate.show_sql”>true</prop>

<prop key=”hibernate.hbm2ddl.auto”>update</prop>

</props>

</property>

</bean>

<!– classe dao que faz a persistencia e tem uma referencia para o hiberanteTemplate –>

<bean id=”springDAO”>

<property name=”hibernateTemplate” ref=”hibernateTemplate”/>

</bean>

 

Agora criamos uma classe main para testar:

public class Main {

public static void main(String[] args) {

//                           essa classe é o container

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

“conf/springconfiguration.xml”);

SpringDAO bean = (SpringDAO) applicationContext.getBean(“springDAO”);

Spring spring = new Spring();

spring.setName(“teste 1”);

System.out.println(bean.save(spring));

}}

springhibernateresultdb

É isso ai pessoal, vou ficando por aqui!! Há uma forma ainda melhor e mais fácil de trabalhar com o Hibernate no Spring que é a partir da versão 3.x do framework Spring quer veremos em um dos nossos posts a seguir. Mas, a forma via template é bastante usada em versões pré-Spring 3.

Os projetos

GitHub: http://github.com/camilolopes

see ya!!

Série Spring:Rodando Unit Test com Spring Framework

Olá Pessoal,

Nesse post veremos como rodar nossos unit tests com o Spring framework, ou seja, aproveitar tudo de bom que tem o Spring e fazer nossos unit test funcionar normalmente. É bastante simples.

lets go…

Começando

Bem não vou entrar nos detalhes do que  é unit test, Spring, JUnit etc. Vamos direto ao ponto de maneira prática. Primeiro Crie um Java Project, o meu será SpringExampleUnitTest

note: claro que você precisa ter baixado o Spring framework core versão 3.x.

 

springexampleunittestproject

Note: adicione o arquivo commons-logging-1.1.1.jar  caso não tenha só baixar esse arquivo, basta digitar o nome no Google .

Desenvolvendo

Como bom baiano e pensando no carnaval de salvador vamos de chicletão. Temos uma interface que tem um método e uma classe que vai implementar:

 

package br.com.camilolopes;

public interface Competidor {

public void apresentar();

}

public class Chicletao implements Competidor {

                private Chicleteiro chicleteiroMusica;

                @Override

                public void apresentar() {

                               chicleteiroMusica.cantar();

                }

                public void setChicleteiroMusica(Chicleteiro chicleteiroMusica) {

                               this.chicleteiroMusica = chicleteiroMusica;

                }

}

 

public interface Musica {

void cantar();

}

public class Chicleteiro implements Musica {

                @Override

                public void cantar() {

                               System.out.println(“chicleteiro eu, chicleteira ela”);

                }

}

 

E no package conf, criamos um xml com as configurações do Spring:

<beans xmlns=”http://www.springframework.org/schema/beans”

xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”

xsi:schemaLocation=”http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd”>

 <!– classe normal –>

 <bean id=”chicleteiro” />

<!– classe que implementa a interface –>

 <bean id=”bell”>

                <property name=”chicleteiroMusica” ref=”chicleteiro”/>

 </bean>

</beans>

 

Pronto. Agora vamos criar a classe de teste.Porém, vamos entender o que acontece com a nossa aplicação. Quando o método apresentar() é invocado, a classe vai se apresentar com a musica que deseja, no caso da classe Chicleteiro, vai cantar: “chicleteiro eu, chicleteira ela”.

 

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations={“classpath:conf/idolos.xml”})

public class ChicletaoTest {

                @Autowired

                private Chicleteiro chicleteiro;

               

                @Test

                public void testCantar() {

                Chicletao chicletao = new Chicletao();

                chicletao.setChicleteiroMusica(chicleteiro);

                try{

                               chicletao.apresentar();

                }catch (NullPointerException e) {

                               Assert.fail(“not expected result”);

                }

                }

 

Com Spring precisamos usar anotação @RunWith e informar qual framework vamos usar, no nosso caso usamos o JUNIT.Em seguida com anotações @ContextConfiguration estamos dizendo qual o xml que tem as configurações do Spring que usaremos para os testes. Que é o mesmo da aplicação. Em seguida fizemos um teste que apenas chama o método apresentar, e esperamos que nunca tenhamos um NullPointerException, mas para isso acontecer é apenas se a instância que chama o método for null, ou seja, não for instanciada. E com esse teste estamos validando duas coisas, uma que o Spring realmente está instanciando o atributo e que o resultado é o que esperamos. Veja:

springexampleunitestgreenresult

 

E assim temos nosso unit test integrado com o Spring. Simples não?

GitHub

Acesse o repositório no github com todos os projetos da série Spring:  https://github.com/camilolopes/workspacespring

Vou ficando por aqui!!

See ya!