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