Tag: jee

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

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: 

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: 

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:

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!!!