Utilities Blog by JuCa Cruz: May 2010

Like with our DTO's, later this code will be having some changes when Apache CXF is called to scene.

Now this is my implementation, as you see I'm becoming fan of the use of annotations. I feel like "NIÑO CHIQUITO" (child) with new toy.

package mx.com.mylibrary.core.business.service.impl;

import java.util.ArrayList;
import java.util.List;

import mx.com.mylibrary.core.business.dto.AuthorDTO;
import mx.com.mylibrary.core.business.dto.BookDTO;
import mx.com.mylibrary.core.business.dto.EditorDTO;
import mx.com.mylibrary.core.business.service.LibraryService;
import mx.com.mylibrary.core.persistence.dao.AuthorDAO;
import mx.com.mylibrary.core.persistence.dao.BookDAO;
import mx.com.mylibrary.core.persistence.dao.EditorDAO;
import mx.com.mylibrary.core.persistence.domain.Author;
import mx.com.mylibrary.core.persistence.domain.Book;
import mx.com.mylibrary.core.persistence.domain.Editor;
import mx.com.mylibrary.core.util.Transformer;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * Service implementation
 * 
 * @author Juan Carlos Cruz
 * @since May 02 2010
 */
public class LibraryServiceImpl implements LibraryService {

private static final Logger log = Logger
   .getLogger(LibraryServiceImpl.class);

@Autowired
 private AuthorDAO authorDAO;

@Autowired
 private EditorDAO editorDAO;

@Autowired
 private BookDAO bookDAO;

@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED, isolation = Isolation.READ_COMMITTED)
 public List<AuthorDTO> getAllAuthors() {
  log.debug("Get all Authors");
  List<AuthorDTO> result = new ArrayList<AuthorDTO>();

List<Author> authors = this.authorDAO.findByExample(new Author());

for (Author author : authors) {
   AuthorDTO authorDTO = Transformer.transformToDTO(author);
   
   List<Book> books = author.getBooks();
   List<BookDTO> bookDTOs = new ArrayList<BookDTO>();
   
   for(Book book: books){
    bookDTOs.add(Transformer.transformToDTO(book));
   }
   
   authorDTO.setListBooks(bookDTOs);
   result.add(authorDTO);
  }

log.debug(result.size() + " Items retrieved");
  return result;
 }

@Transactional(readOnly = false, propagation = Propagation.REQUIRED)
 public void addBook(AuthorDTO authorDTO, BookDTO bookDTO,
   EditorDTO editorDTO) {
  log.debug("Save Book " + authorDTO + "; " + bookDTO + "; " + editorDTO);
  
  Author author = Transformer.transformToPojo(authorDTO);
  Book book = Transformer.transformToPojo(bookDTO);
  Editor editor = Transformer.transformToPojo(editorDTO);  
  
  log.debug("Saving "+author);
  this.authorDAO.save(author);
  log.debug("Saving "+editor);
  this.editorDAO.save(editor);

book.setEditor(editor);
  log.debug("Saving "+book);
  this.bookDAO.save(book);
  
  List<Book> books = new ArrayList<Book>();
  books.add(book);
  log.debug("Saving AuthorBook");
  author.setBooks(books);  
  
  log.debug("addBook successfull");  
 }

@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED, isolation = Isolation.READ_COMMITTED)
 public List<BookDTO> getAllBooks() {
  log.debug("get All Books");
  List<BookDTO> result = new ArrayList<BookDTO>();

List<Book> books = this.bookDAO.findByExample(new Book());

for (Book book : books) {
   BookDTO bookDTO = Transformer.transformToDTO(book);
   Editor editor = book.getEditor();
   List<Author> authors = book.getAutores();
   
   List<AuthorDTO> authorDTOs = new ArrayList<AuthorDTO>();    
   for (Author author : authors) {
    AuthorDTO authorDTO = Transformer.transformToDTO(author);
    authorDTOs.add(authorDTO);
   }
   
   if(editor!=null){
    EditorDTO editorDTO = Transformer.transformToDTO(editor);
    bookDTO.setEditorDTO(editorDTO);
   }
   
   bookDTO.setListAutors(authorDTOs);
   
   result.add(bookDTO);
  }

log.debug(result.size() + " Items retrieved");
  return result;
 }

@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED, isolation = Isolation.READ_COMMITTED)
 public List<EditorDTO> getAllEditors() {
  log.debug("get All Editors");
  List<EditorDTO> result = new ArrayList<EditorDTO>();

List<Editor> editors = this.editorDAO.findByExample(new Editor());

for (Editor editor : editors) {
   
   EditorDTO editorDTO = Transformer.transformToDTO(editor);
   
   List<Book> books = editor.getBooks();
   List<BookDTO> bookDTOs = new ArrayList<BookDTO>();
   
   for(Book book: books){
    bookDTOs.add(Transformer.transformToDTO(book));
   }
   
   editorDTO.setListBooks(bookDTOs);
   
   result.add(editorDTO);
  }

log.debug(result.size() + " Items retrieved");
  return result;
 } 
 
 @Transactional(readOnly=true, propagation = Propagation.NOT_SUPPORTED, isolation = Isolation.READ_COMMITTED)
 public List<EditorDTO> getAllOnlyEditors() {
  log.debug("get All Editors");
  List<EditorDTO> result = new ArrayList<EditorDTO>();

List<Editor> editors = this.editorDAO.findByExample(new Editor());

for (Editor editor : editors) {   
   EditorDTO editorDTO = Transformer.transformToDTO(editor);  
   result.add(editorDTO);
  }

log.debug(result.size() + " Items retrieved");
  return result;
 }

@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED, isolation = Isolation.READ_COMMITTED)
 public BookDTO getBook(Integer bookId) {
  log.debug("get Book bookId ="+bookId);
  List<AuthorDTO> listAutorsDTO = new ArrayList<AuthorDTO>();
  BookDTO result = new BookDTO();
  
  Book book = this.bookDAO.findById(bookId);

result = Transformer.transformToDTO(book);
  
  result.setEditorDTO(Transformer.transformToDTO(book.getEditor()));
  List<Author> listAuthors = book.getAutores();
  for(Author author: listAuthors){
   listAutorsDTO.add(Transformer.transformToDTO(author));   
  }
  result.setListAutors(listAutorsDTO);
  
  return result;
 }

@Transactional(readOnly = false, propagation = Propagation.REQUIRED)
 public void saveAuthor(AuthorDTO authorDTO) {
  log.debug("Save Author " + authorDTO);
  this.authorDAO.save(Transformer.transformToPojo(authorDTO));
  log.debug("saveAuthor successfull");
 }

@Transactional(readOnly = false, propagation = Propagation.REQUIRED)
 public void saveBook(BookDTO bookDTO) {
  log.debug("Save Book " + bookDTO);
  Book book = Transformer.transformToPojo(bookDTO);
  if(bookDTO.getEditorDTO()!=null && bookDTO.getEditorDTO().getEditorId()!=null){
   book.setEditor(Transformer.transformToPojo(bookDTO.getEditorDTO()));
  }
  this.bookDAO.save(book);
  log.debug("saveBook successfull");
 }

@Transactional(readOnly = false, propagation = Propagation.REQUIRED)
 public void saveEditor(EditorDTO editorDTO) {
  log.debug("Save Editor " + editorDTO);
  this.editorDAO.save(Transformer.transformToPojo(editorDTO));
  log.debug("saveEditor successfull");
 }

@Transactional(readOnly = false, propagation = Propagation.REQUIRED)
 public void updateBook(BookDTO bookDTO) {
  log.debug("Update Book " + bookDTO);
  this.bookDAO.update(Transformer.transformToPojo(bookDTO));
  log.debug("updateBook successfull");
 }

}

In future entries I'll explain the configuration files involved to attach together Hibernate, Spring and Apache CXF.
But for now, let'f finish with Hibernate+Spring part and then we'll integrate with Apache CXF (then we'll talk about confuration files)

Hasta luego!

For your DTO's youmust apply the same rule like with every Java Bean (getter's & setter's, toString, hashCode, equals & Serialization)

My first step is creating a base DTO with all common fields and methods, then it's just extending from that class. I'll just put 2 examples, Ok?

Later we'll have to retake this objects, because we'll have add some extra lines (anotations) just to make them compatible with our WebServices framework, it will be fun.

Utilities Blog by JuCa Cruz

Sunday, May 23, 2010

WebServices with CXF - My Service interface & Impl

WebServices with CXF - My DTO's

Twitter