The evolution of scalable microservices

Today’s enterprise applications are deployed to everything from mobile devices to cloud-based clusters running thousands of multi-core processors. Users have come to expect millisecond response times and close to 100% uptime. And by “user” I mean both humans and machines. Traditional architectures, tools and products simply won’t cut it anymore. To paraphrase Henry Ford’s classic quote: we can’t make the horse any faster, we need cars for where we are going.

Continue reading

Getting INVALID_SESSION_ID using Salesforce's SOAP based API

For those of you consuming Salesforce SOAP API.

The more calls you make, the more errors you'll get (if you're using the same user to perform this calls)

This is a brief description of what happened to me:
I implemented a process to perform Realtime user provisioning by using Salesforce SOAP based API calls. In a few words this is my process:

1. Login
2. Generate User Account (Using Connection.upsert)
3. Verify if User already exists (query User) to determine if next step will be Update or Insert
4. Upsert (Insert or Update) User
5. Upsert (Using Connection.upsert) other related objects (custom)
6. Logout

This process gets invoked when performing SSO, therefore I get as many executions of this process as users try to access my portal.

There is no pattern on this issue.

This is the error I see in my PingFederate logs: [UnexpectedErrorFault [ApiFault exceptionCode='INVALID_SESSION_ID' exceptionMessage='Invalid Session ID found in SessionHeader: Illegal Session. Session not found, missing session key' ...

After login is been performed (could be before executing any step before Logout or during Logout) This error is generating incomplete user/accounts in Salesforce (Some objects are not created due to this error)


After a few calls and emails with salesforce Developer Support, I got a clear and simple answer:

"There is no implication by calling only login and no logout()"
"Client applications do not need to explicitly log out to end a session. Sessions expire automatically after a predetermined length of inactivity".

Then, instead of over-thingking this problem and design some complex solutions, just like: Implementing a connection pooling mechanism or making singleton my Connection object. The answer was easier than I thought. Don't call Logout and Login as many times as you need. You'll get the same Session_Id (your session will be refreshed on Salesforce and will remain active), letting Salesforce kill it when I'm not using it.

Cool!

WebServices with CXF - Configuration files - web.xml

<web-app version = "2.4" xmlns = "http://java.sun.com/xml/ns/j2ee" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <display-name>Archetype Created Web Application</display-name> <context-param> <param-name>webAppRootKey</param-name> <param-value>my-web-app</param-value> </context-param> <!--Log4J Configuration --> <context-param> <param-name>log4jConfigLocation</param-name> <param-value>/WEB-INF/conf/log4j/log4j-config.xml</param-value> </context-param> <!--Spring Context Configuration --> <context-param> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/conf/spring/daoApplicationContext.xml, /WEB-INF/conf/spring/serviceApplicationContext.xml, /WEB-INF/conf/cxf/cxf-services.xml </param-value> </context-param> <!--Log4J Listener --> <listener> <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class> </listener> <!--Spring Context Listener --> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!--Another Context Listener --> <listener> <listener-class>mx.com.mylibrary.web.listener.ContextListener</listener-class> </listener> <!--Servlet Declarations --> <servlet> <servlet-name>webApplicationServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/conf/spring/webApplicationContext.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet> <display-name>CXF Servlet</display-name> <servlet-name>CXFServlet</servlet-name> <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>CXFServlet</servlet-name> <url-pattern>/services/*</url-pattern> </servlet-mapping> <!--Servlet Mappings --> <servlet-mapping> <servlet-name>webApplicationServlet</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping> <!--Session Time-out in minutes --> <session-config> <session-timeout>30</session-timeout> </session-config> <!--Welcome file --> <welcome-file-list> <welcome-file>/index.jsp</welcome-file> </welcome-file-list> <!--Reference to a DB Conection --> <resource-ref> <description>DB Connection</description> <res-ref-name>jdbc/bookStoreDS</res-ref-name> <res-type>javax.sql.DataSource</res-type> <res-auth>Container</res-auth> <res-sharing-scope>Shareable</res-sharing-scope> </resource-ref> </web-app>

WebServices with CXF - Testing using JUnit

As you know JUnit is for Testing, so basically I'm going to test my running/deployed WebApplication by declaring this Test Cases:

This one is just a TestCase which tests my Spring Bean Service public void testGetAllBooks(){ List<BookDTO> books = null; try{ books = this.libraryService.getAllBooks(); }catch(Exception ex){ log.warn(ex); } for(BookDTO bookDTO: books){ log.debug(bookDTO); } assertNotNull(books); }
And this fellow tests our WebService public void testWebService(){ List<BookDTO> books = null; try{ JaxWsProxyFactoryBean factoryBean = new JaxWsProxyFactoryBean(); factoryBean.setDataBinding(new AegisDatabinding()); factoryBean.getInInterceptors().add(new LoggingInInterceptor()); factoryBean.getOutInterceptors().add(new LoggingOutInterceptor()); factoryBean.setAddress("http://127.0.0.1:9080/little-library/services/LibraryService"); factoryBean.setServiceClass(LibraryService.class); LibraryService libraryService = (LibraryService)factoryBean.create(); books = libraryService.getAllBooks(); }catch(Exception ex){ log.warn(ex); } for(BookDTO bookDTO: books){ log.debug(bookDTO); } Assert.assertNotNull(books); }

As you can see, we need to link using our Service Interface (LibraryService.class) to this JaxWsProxyFactoryBean instance

That was easy! Isn't it???

WebServices with CXF - Configuration files III

Now I'll cover my Apache CXF configuration file

<?xml version="1.0" encoding="UTF-8" ?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cxf="http://cxf.apache.org/core" xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd"> <!-- =========================== Useful Imports ===========================--> <import resource="classpath:META-INF/cxf/cxf.xml" /> <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" /> <import resource="classpath:META-INF/cxf/cxf-servlet.xml" /> <!-- =========================== Aegis data binding ===========================--> <bean id="AegisDatabindingBean" class="org.apache.cxf.aegis.databinding.AegisDatabinding" scope="prototype"/> <bean id="JaxWsServiceFactoryBean" class="org.apache.cxf.jaxws.support.JaxWsServiceFactoryBean" scope="prototype"> <property name="dataBinding" ref="AegisDatabindingBean"/> <property name="serviceConfigurations"> <list> <bean class="org.apache.cxf.jaxws.support.JaxWsServiceConfiguration"/> <bean class="org.apache.cxf.aegis.databinding.AegisServiceConfiguration"/> <bean class="org.apache.cxf.service.factory.DefaultServiceConfiguration"/> </list> </property> </bean> <!-- =========================== Web Services ===========================--> <jaxws:endpoint id="libraryService" implementorClass="mx.com.mylibrary.core.business.service.impl.LibraryServiceImpl" implementor="#LibraryService" address="/LibraryService"> <jaxws:serviceFactory> <ref bean='JaxWsServiceFactoryBean' /> </jaxws:serviceFactory> </jaxws:endpoint> </beans>

As I said before this is not rocket science. It follows the same logic used in every Spring configuration file, everything is based on Beans tags

If you remember my serviceApplicationContext, I declared a Bean called LibraryService

<!--================== Business Objects/Service Objects =============--> <bean id="LibraryService" class="mx.com.mylibrary.core.business.service.impl.LibraryServiceImpl"/>

Well, we're going to make reference to this particular Bean on our CXF configuration file, so we can expose it (We already changed our Interface & Implementation using annotations)

Now if you analyze carefully my CXF configuration file, this section links my Spring Bean (Service) with my endpoint on CXF through implementor & implementorClass attributes, which basically link my Java Code (implementorClass) and my Spring Bean (implementor);
The only thing you must add is "#" character before Spring's Bean name: #LibraryService

<!-- =========================== Web Services ===========================--> <jaxws:endpoint id="libraryService" implementorClass="mx.com.mylibrary.core.business.service.impl.LibraryServiceImpl" implementor="#LibraryService" address="/LibraryService"> <jaxws:serviceFactory> <ref bean='JaxWsServiceFactoryBean' /> </jaxws:serviceFactory> </jaxws:endpoint>

Finally, I'm using another attribute called address to declare the address for this WebService, by declaring it as address="/LibraryService", this will be my URI for this WebService: http://localhost:8080/little-library-lite/services/LibraryService

Why /services/LibraryService?? I declared on my web.xml that URL Pattern.

In my next and last entry I'll test this WebService using JUnit, if you want to see the WSDL file for all your available WebServices, you can do it by going to http://localhost:8080/little-library-lite/services

There you'll see a list of available WebServices and by clicking them you'll see each one's WSDL

WebServices with CXF - Configuration files II

I'll just include my Spring configuration files.
Why files? -I though Spring only needs an applicationConext??? Well... Because I prefer to split configuration files according to it's purpose:

• One will have everything related to the Persistence layer
• and the second one will have all my Business layer -services

Following this logic I should have another one for my Web layer

daoApplicationContext <?xml version="1.0" encoding="UTF-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xmlns:jee = "http://www.springframework.org/schema/jee" xsi:schemaLocation = " http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd"> <!--========================= Data Sources ============================= --> <jee:jndi-lookup id="myDataSource" jndi-name="java:comp/env/jdbc/bookStoreDS"/> <!--============================= SessionFactory ===============================--> <bean id = "sessionFactory" class = "org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"> <property name = "dataSource" ref = "myDataSource"/> <property name = "configLocation"> <value>/WEB-INF/conf/mapping/mapping.cfg.xml</value> </property> <property name = "hibernateProperties"> <props> <prop key = "hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</prop> <prop key = "hibernate.show_sql">true</prop> <prop key = "hibernate.format_sql">true</prop> <prop key = "hibernate.order_updates">true</prop> <prop key = "hibernate.generate_statistics">true</prop> <prop key = "hibernate.use_sql_comments">false</prop> <prop key = "hibernate.bytecode.use_reflection_optimizer">false</prop> <prop key = "hibernate.jdbc.batch_size">15</prop> <prop key = "hibernate.jdbc.batch_versioned_data">true</prop> <prop key = "hibernate.query.factory_class">org.hibernate.hql.ast.ASTQueryTranslatorFactory</prop> <prop key = "hibernate.connection.isolation">4</prop> </props> </property> </bean> <!--============================ DAOs ================================== --> <bean id = "AuthorDAO" class = "mx.com.mylibrary.core.persistence.dao.impl.AuthorDAOImpl"> <property name = "sessionFactory"> <ref bean = "sessionFactory"/> </property> </bean> <bean id = "BookDAO" class = "mx.com.mylibrary.core.persistence.dao.impl.BookDAOImpl"> <property name = "sessionFactory"> <ref bean = "sessionFactory"/> </property> </bean> <bean id = "EditorDAO" class = "mx.com.mylibrary.core.persistence.dao.impl.EditorDAOImpl"> <property name = "sessionFactory"> <ref bean = "sessionFactory"/> </property> </bean> </beans>

serviceApplicationContext <?xml version="1.0" encoding="UTF-8" ?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xmlns:aop = "http://www.springframework.org/schema/aop" xmlns:tx = "http://www.springframework.org/schema/tx" xsi:schemaLocation = " http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"> <!--=============== JTA ==========================================--> <bean id = "transactionManager" class = "org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name = "sessionFactory"> <ref bean = "sessionFactory"/> </property> </bean> <!--====================== Transaction Managers =====================--> <tx:annotation-driven transaction-manager = "transactionManager"/> <!--================== Business Objects/Service Objects =============--> <bean id = "LibraryService" class = "mx.com.mylibrary.core.business.service.impl.LibraryServiceImpl"/> </beans>

When I met Annotations, I just felt in love with them, because one of the main advantages you gain is small configuration files.

On my next entry I'll cover my Apache CXF configuration file and how it fits.

Don't forget to add @Autowired, in case that you want to use this feature by <beans ... xmlns:context="http://www.springframework.org/schema/context" ... http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"> ... <context:annotation-config /> ... </beans>

WebServices with CXF - Configuration files I

I'll show 2 basic configuration files: web.xml & my hibernate configuration file (mapping.cfg.xml)

<web-app version = "2.4" xmlns = "http://java.sun.com/xml/ns/j2ee" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <display-name>Archetype Created Web Application</display-name> <context-param> <param-name>webAppRootKey</param-name> <param-value>my-web-app</param-value> </context-param> <!--Log4J Configuration --> <context-param> <param-name>log4jConfigLocation</param-name> <param-value>/WEB-INF/conf/log4j/log4j-config.xml</param-value> </context-param> <!--Spring Context Configuration --> <context-param> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/conf/spring/daoApplicationContext.xml, /WEB-INF/conf/spring/serviceApplicationContext.xml, /WEB-INF/conf/cxf/cxf-services.xml </param-value> </context-param> <!--Log4J Listener --> <listener> <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class> </listener> <!--Spring Context Listener --> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!--Servlet Declarations --> <servlet> <servlet-name>webApplicationServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/conf/spring/webApplicationContext.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet> <display-name>CXF Servlet</display-name> <servlet-name>CXFServlet</servlet-name> <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>CXFServlet</servlet-name> <url-pattern>/services/*</url-pattern> </servlet-mapping> <!--Servlet Mappings --> <servlet-mapping> <servlet-name>webApplicationServlet</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping> <!--Session Time-out in minutes --> <session-config> <session-timeout>30</session-timeout> </session-config> <!--Welcome file --> <welcome-file-list> <welcome-file>/index.jsp</welcome-file> </welcome-file-list> <!--Reference to a my DB Conection --> <resource-ref> <description>DB Connection</description> <res-ref-name>jdbc/bookStoreDS</res-ref-name> <res-type>javax.sql.DataSource</res-type> <res-auth>Container</res-auth> <res-sharing-scope>Shareable</res-sharing-scope> </resource-ref> </web-app>

As you noticed I'm using Spring MVC (see webApplicationServlet), but for now let's focus on Spring and CXF:

My 3 main configuration files are listed here, where the 3rd one is for CXF (really obvious file name) and to enable Apache CXF is so simple, Did you remember XFire? <!--Spring Context Configuration --> <context-param> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/conf/spring/daoApplicationContext.xml, /WEB-INF/conf/spring/serviceApplicationContext.xml, /WEB-INF/conf/cxf/cxf-services.xml </param-value> </context-param> ... ... ... <servlet> <display-name>CXF Servlet</display-name> <servlet-name>CXFServlet</servlet-name> <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>CXFServlet</servlet-name> <url-pattern>/services/*</url-pattern> </servlet-mapping>

This is not rocket science! So simple :)


Now let's see my (small) Hibernate configuration file (which I just called mapping.cfg.xml) <hibernate-configuration> <session-factory> <mapping class="mx.com.mylibrary.core.persistence.domain.Author"/> <mapping class="mx.com.mylibrary.core.persistence.domain.Book"/> <mapping class="mx.com.mylibrary.core.persistence.domain.Editor"/> </session-factory> </hibernate-configuration> Instead of using resource=, I'm using class=, because I don't have any hbm.xml file. I'm mapping directly to the class (due to Java Annotations, my mapping it was declared on each POJO).

Now what do you think? Is not as complex as looks like.

WebServices with CXF - Integrating with CXF II

This is going to be a really small entry, because we're going to finish with my ServiceImplementation.
On the next entries we'll discuss configuration files & finally we'll see everything working (Obviously I'll need to test it).

But before that, let's analyze my implementation:

@WebService(serviceName="LibraryService", endpointInterface = "mx.com.mylibrary.core.business.service.LibraryService", targetNamespace="http://juca-cruz-utilities.blogspot.com") public class LibraryServiceImpl implements LibraryService { //Method's Implemented }

As I've been doing I'm using a lot of WebServices Annotations

What I did???

• Define service name of the Web Service
• Declare the complete name of the service endpoint interface defining the service's abstract Web Service contract (My Interface)
• And set my targetNamespace: the targetNamespace is used for the namespace for the wsdl:portType (and associated XML elements)

WebServices with CXF - Integrating with CXF I

As I said before on Service Interface & Implementation, somehow we'll have to retake that code to implement CXF, and that's what we're going to do.
I want to expose as WebService my LibraryService and as WebMethods these methods:

• public List getAllAuthors()
• public List getAllBooks()
• public List getAllEditors()
• public List getAllOnlyEditors()
• public BookDTO getBook(Integer bookId)

Ok, everything looks nice, but what happens if my client is asking for a "subService" (WebMethod) which returns AllAuthors, but he/she doesn't expect a WebMethod called getAuthors, retrieveAuthors or returnAuthors.

What can we do??? -We're done with our coding and that method (getAllAuthors) is being used in many places in our App.
Are you going to rename your code just because your client doesn't like your naming convention???. Later you'll see my answer.

Let's modify my code, first, Interface then Implementation;
By adding Java WebServices API Annotations @WebService @SOAPBinding(style=Style.DOCUMENT) public interface LibraryService And don't forget for every method we must declare it like a WebMethod @WebMethod(operationName="getAuthors", action="getAuthors") public List<AuthorDTO> getAllAuthors(); In this case I'm declaring a couple of additional attributes, which basically let me give another name to WebMethod, a different name to my original Java Method - this will be the name available on my WebService/WebMethod (this is the second option for my client)

And finally, what can I do if have logic on this interface that I don't want to make it public (available as WebMethod)???
This is the answer: "Just exclude it" @WebMethod(exclude=true) public void updateBook(BookDTO bookDTO);

WebServices with CXF - My Service interface & Impl

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

package mx.com.mylibrary.core.business.service; 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; /** * Service interface * * @author Juan Carlos Cruz * @since May 02 2010 */ public interface LibraryService { public List<AuthorDTO> getAllAuthors(); public List<BookDTO> getAllBooks(); public List<EditorDTO> getAllEditors(); public List<EditorDTO> getAllOnlyEditors(); public void saveAuthor(AuthorDTO authorDTO); public void saveBook(BookDTO bookDTO); public void saveEditor(EditorDTO editorDTO); public void addBook(AuthorDTO authorDTO, BookDTO bookDTO, EditorDTO editorDTO); public BookDTO getBook(@WebParam(name="bookIdentifier") Integer bookId); public void updateBook(BookDTO bookDTO); } 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!

WebServices with CXF - My DTO's

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?

package mx.com.mylibrary.core.business.dto; import java.io.Serializable; import java.util.Date; public abstract class BaseDTO implements Serializable { private static final long serialVersionUID = -2375424405198208312L; private Date createDate; public Date getCreateDate() { return createDate; } public void setCreateDate(Date createDate) { this.createDate = createDate; } @Override public abstract int hashCode(); @Override public abstract boolean equals(Object obj); } package mx.com.mylibrary.core.business.dto; import java.io.Serializable; import java.util.List; /** * * Data Transfer Object * * @author Juan Carlos Cruz * @since May 23 2010 */ public class AuthorDTO extends BaseDTO implements Serializable { private static final long serialVersionUID = -5573197656310571940L; private Integer authorId; private String name; private String email; private List<BookDTO> listBooks; //getter's and setter's } package mx.com.mylibrary.core.business.dto; import java.io.Serializable; import java.util.List; /** * * Data Transfer Object * * @author Juan Carlos Cruz * @since May 23 2010 */ @XmlType(name="Book") public class BookDTO extends BaseDTO implements Serializable { private static final long serialVersionUID = 3254611377962442345L; private Integer bookId; private String title; private EditorDTO editorDTO = new EditorDTO(); private List<AuthorDTO> listAutors; //getter's and setter's }

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.

WebServices with CXF - My Pojos & DAOs

First thing, is a good practice declaring methods equals and hashCode
You know what, I'll skip these methods on my code, eclipse can do it for you, don't be lazy!!!
And one more thing, as Architect it's a must declaring toString method, because when you're debugging these method it's going to be really helpful, and you know what... declare toString it's a must too.
package mx.com.mylibrary.core.persistence.domain; import java.io.Serializable; import java.util.ArrayList; import java.util.Date; import java.util.List; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.OneToMany; import javax.persistence.Table; /** * * Domain Object * * @author Juan Carlos Cruz * @since Sep 26 2009 */ @Entity @Table(name = "EDITOR") public class Editor implements Serializable { private static final long serialVersionUID = 5125858002922739070L; @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = "editor_id", unique = true) private Integer editorId; @Column(name = "title", length = 200, nullable = false) private String name; @Column(name = "url", length = 255, nullable = true) private String url; @Column(name = "create_date", insertable = false, updatable = false, columnDefinition = "Timestamp DEFAULT CURRENT_TIMESTAMP") private Date createDate; @OneToMany(mappedBy="editor", fetch=FetchType.LAZY) private List<Book> books = new ArrayList<Book>(0); //Setters & Getters } package mx.com.mylibrary.core.persistence.domain; import java.io.Serializable; import java.util.ArrayList; import java.util.Date; import java.util.List; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.JoinTable; import javax.persistence.ManyToMany; import javax.persistence.ManyToOne; import javax.persistence.Table; import javax.persistence.UniqueConstraint; /** * * Domain Object * * @author Juan Carlos Cruz * @since Sep 26 2009 */ @Entity @Table(name = "BOOK") public class Book implements Serializable { private static final long serialVersionUID = -5220399448304637221L; @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = "book_id", unique = true) private Integer bookId; @Column(name = "title", length = 200, nullable = false) private String title; @Column(name = "create_date", insertable = false, updatable = false, columnDefinition = "Timestamp DEFAULT CURRENT_TIMESTAMP") private Date createDate; @ManyToOne(optional = true, fetch = FetchType.EAGER) @JoinColumn(name = "editor_id", nullable = true, updatable = true) private Editor editor; @ManyToMany(fetch = FetchType.LAZY) @JoinTable(name = "AUTHOR_BOOK", joinColumns = @JoinColumn(name = "book_id", referencedColumnName = "book_id"), inverseJoinColumns = @JoinColumn(name = "author_id", referencedColumnName = "author_id"), uniqueConstraints = @UniqueConstraint( columnNames = {"book_id", "author_id"} ) ) private List<Author> autores = new ArrayList<Author>(0); //Setters & Getters } package mx.com.mylibrary.core.persistence.domain; import java.io.Serializable; import java.util.ArrayList; import java.util.Date; import java.util.List; import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.JoinTable; import javax.persistence.ManyToMany; import javax.persistence.Table; /** * * Domain Object * * @author Juan Carlos Cruz * @since Sep 26 2009 */ @Entity @Table(name = "AUTHOR") public class Author implements Serializable { private static final long serialVersionUID = 3065679411071650221L; @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = "author_id", unique = true) private Integer authorId; @Column(name = "name", length = 100, nullable = false) private String name; @Column(name = "email", length = 100, nullable = true) private String email; @Column(name = "create_date", insertable = false, updatable = false, columnDefinition = "Timestamp DEFAULT CURRENT_TIMESTAMP") private Date createDate; @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL) @JoinTable(name = "AUTHOR_BOOK", joinColumns = @JoinColumn(name = "author_id", referencedColumnName = "author_id"), inverseJoinColumns = @JoinColumn(name = "book_id", referencedColumnName = "book_id") ) private List<Book> books = new ArrayList<Book>(0); //Setters & Getters } The next step is explain what are those annotations, well they're Java 6 annotations, so we can skip some configurations and declare them into our code. I'll try to explain as simple as possible these annotations, let's analyze them: @Entity @Table(name = "EDITOR") public class Editor...

What I'm doing here is just declaring that this POJO will be an Entity which maps to a table called EDITOR

@Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = "editor_id", unique = true) private Integer editorId; @Column(name = "title", length = 200, nullable = false) private String name; @Column(name = "url", length = 255, nullable = true) private String url; @Column(name = "create_date", insertable = false, updatable = false, columnDefinition = "Timestamp DEFAULT CURRENT_TIMESTAMP") private Date createDate; @OneToMany(mappedBy="editor", fetch=FetchType.LAZY) private List<Book> books = new ArrayList<Book>(0);

Using Annotations, I declared that editorId is my PK which basically is AutoIncremental and to which column will be mapped. With columns is really easy.

But what about relations??? Like

BOOK >-- EDITOR

In this case I just declared what I needed to declare: One Editor has Many books using a List of Book, like in every mapping of Hibernate: the most common fetching strategy to be used will be LAZY; basically what I did was linking the current ENTITY by it's PK (mappedBy="editor") to Book

So in Book this is what we have to do (the inverse to OneToMany and define an Editor for each Book, so each child will have a reference to it's Dad):
@ManyToOne(optional = true, fetch = FetchType.EAGER) @JoinColumn(name = "editor_id", nullable = true, updatable = true) private Editor editor;

The last thing is just declare which column & attribute will be used to do the JOIN between child and father

You can get more details if you look for that topic in Hibernate official documentation.
And these are my DAO's (I just included 1 as example), others should be similar. Always code oriented to interfaces! Later you'll thank me. package mx.com.mylibrary.core.persistence.dao; import java.util.List; import mx.com.mylibrary.core.persistence.domain.Book; import org.springframework.dao.DataAccessException; /** * Data access object Interface (DAO) for domain model class Book. * * @author Juan Carlos Cruz * @since September 29 2009 */ public interface BookDAO { public void save(Book transientInstance) throws DataAccessException; public void delete(Book persistentInstance) throws DataAccessException; public Book findById(Integer id) throws DataAccessException; public List<Book> findByExample(Book instance) throws DataAccessException; public List<Book> findByProperty(String propertyName, Object value) throws DataAccessException; public void saveOrUpdate(Book instance) throws DataAccessException; public void update(Book instance) throws DataAccessException; } package mx.com.mylibrary.core.persistence.dao.impl; import java.util.List; import mx.com.mylibrary.core.persistence.dao.BookDAO; import mx.com.mylibrary.core.persistence.domain.Book; import org.hibernate.Criteria; import org.hibernate.SessionFactory; import org.hibernate.criterion.Example; import org.hibernate.criterion.MatchMode; import org.hibernate.criterion.Restrictions; import org.springframework.dao.DataAccessException; /** * Data access object Implementation (DAO) for domain model class Book. * * @author Juan Carlos Cruz * @since September 29 2009 */ public class BookDAOImpl implements BookDAO { private SessionFactory sessionFactory; public void setSessionFactory(SessionFactory sessionFactory) { this.sessionFactory = sessionFactory; } public void delete(Book persistentInstance) { this.sessionFactory.getCurrentSession().delete(persistentInstance); } @SuppressWarnings("unchecked") public List<Book> findByExample(Book instance) throws DataAccessException { Criteria criteria = this.sessionFactory.getCurrentSession().createCriteria(Book.class); Example example = Example.create(instance).ignoreCase(); example.enableLike(MatchMode.START); example.excludeZeroes(); criteria.add(example); return criteria.list(); } @SuppressWarnings("unchecked") public Book findById(Integer id) { Criteria criteria = this.sessionFactory.getCurrentSession().createCriteria(Book.class); criteria.add(Restrictions.eq("bookId", id)); List<Book> items = criteria.list(); return items.isEmpty()?null:items.get(0); } @SuppressWarnings("unchecked") public List<Book> findByProperty(String propertyName, Object value) throws DataAccessException { Criteria criteria = this.sessionFactory.getCurrentSession().createCriteria(Book.class); criteria.add(Restrictions.eq(propertyName, value)); return criteria.list(); } public void save(Book transientInstance) { this.sessionFactory.getCurrentSession().save(transientInstance); } public void saveOrUpdate(Book instance) { this.sessionFactory.getCurrentSession().saveOrUpdate(instance); } public void update(Book instance) { this.sessionFactory.getCurrentSession().update(instance); } } In my next entry I will explain my Services and we'll be ready for using CXF.

WebServices with CXF - Our Database

Too many times I tried to look for some good examples for my padawans, but as always, incomplete stuff or not really clear. Anyway, that's why I'm going to develop a small app using a bunch of useful things, and one of these it's going to be Apache CXF The first and most important step is what kind of problem I'm going to solve using the app? Well, let's create a scenario: I have a small Database on MySQL 5.1.37. this is my schema: +---------------------+ | Tables_in_bookstore | +---------------------+ | author | | author_book | | book | | editor | +---------------------+ mysql> desc author; +-------------+--------------+------+-----+-------------------+----------------+ | Field | Type | Null | Key | Default | Extra | +-------------+--------------+------+-----+-------------------+----------------+ | author_id | int(11) | NO | PRI | NULL | auto_increment | | create_date | timestamp | NO | | CURRENT_TIMESTAMP | | | email | varchar(100) | YES | | NULL | | | name | varchar(100) | NO | | NULL | | +-------------+--------------+------+-----+-------------------+----------------+ mysql> desc author_book; +-----------+---------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-----------+---------+------+-----+---------+-------+ | book_id | int(11) | NO | PRI | NULL | | | author_id | int(11) | NO | PRI | NULL | | +-----------+---------+------+-----+---------+-------+ mysql> desc book; +-------------+--------------+------+-----+-------------------+----------------+ | Field | Type | Null | Key | Default | Extra | +-------------+--------------+------+-----+-------------------+----------------+ | book_id | int(11) | NO | PRI | NULL | auto_increment | | create_date | timestamp | NO | | CURRENT_TIMESTAMP | | | title | varchar(200) | NO | | NULL | | | editor_id | int(11) | YES | MUL | NULL | | +-------------+--------------+------+-----+-------------------+----------------+ mysql> desc editor; +-------------+--------------+------+-----+-------------------+----------------+ | Field | Type | Null | Key | Default | Extra | +-------------+--------------+------+-----+-------------------+----------------+ | editor_id | int(11) | NO | PRI | NULL | auto_increment | | create_date | timestamp | NO | | CURRENT_TIMESTAMP | | | title | varchar(200) | NO | | NULL | | | url | varchar(255) | YES | | NULL | | +-------------+--------------+------+-----+-------------------+----------------+

As you noticed the relations are like this:

AUTHOR --< AUTHOR_BOOK >-- BOOK >-- EDITOR