Prakash Malani's Blog

Prakash Malani's Homepage
Prakash Malani has extensive experience in architecting, designing, and developing software. He has been doing software development in many application domains such as entertainment, finance, retail, medicine, communications, and interactive television. He practices and mentors leading technologies such as Java 2 Enterprise Edition (J2EE), the Unified Modeling Language (UML), and the eXtensible Markup Language (XML). He teaches as well as preaches best practices and design patterns at institutions such as California State Polytechnic University, Pomona, etc. He has published various articles in industry leading publications such as JavaWorld and WebLogic Developers Journal. Currently, he helps organize the Los Angeles BEA Users Group (LABEAUG).

Spring Framework 2.5.x Configuration Options

The typical way to configure Spring Framework is using the XML configuration file. This configuration contains beans definitions. The application context is built by reading this configuration file.

Spring 2.5.x supports couple of additional ways to configure the spring framework and hence build the application context. The first is using auto-wiring with annotations. The second approach is to do configuration in Java instead of XML. This is the JavaConfig approach.

This blog entry and the accompanying presentation slides describe the approaches in detail. This section describes the annotation-based configuration in great detail. Additional details about JavaConfig can be found here.

Each approach has its pros and cons. You should carefully consider them when adapting one or more of these approaches.These approaches are not mutually exclusive. They can be used together.

If you are starting a new project, you may want to look at these newer approaches. My recommendation is to consider going with the auto-wire approach.

Prakash

-----
My blog (http://dev2dev.bea.com/blog/pmalani/)
Answers to J2EE, Java, UML, Process, and Patterns! (http://www.bartssandbox.com/)
Java Enterprise in a Nutshell (http://www.oreilly.com/catalog/javaentnut3/)

JMSOrderException with Unit of Work

How does Unit of Work work in a cluster? Typically, in a cluster we configure a distributed destination. All the messages in the a single unit of work will be routed to a single member of the distributed destination.

How is a member selected from the members of the distributed destination? As described here in detail, there are two basic ways: path service and hash-based routing. The path service uses a persistent map. The hash based routing does not uses persistence storage.

Let's say I am using a hash based routing (default) with a uniform distributed queue. As the members of the queue become available, they will participate in getting a group of messages. Now, when the members become unavailable, should the messages still be produced to the unavailable member? I observed that the messages were still being produced to the unavailable member resulting in a JMSOrderException in WebLogic 9.2.

Getting the JMSOrderException makes sense if the client is in the middle of producing messages. The producer gets the exception because only one distributed destination member must consume messages for a particular unit of work. However, the new unit of work should not be produced to the unavailable member of the destination, but was... The hash based routing must consider the state and status of the members and not select members that were once available, but currently not available.

Prakash

-----
My blog (http://dev2dev.bea.com/blog/pmalani/)
Answers to J2EE, Java, UML, Process, and Patterns! (http://www.bartssandbox.com/)
Java Enterprise in a Nutshell (http://www.oreilly.com/catalog/javaentnut3/)

On JMS Unit Of Work

Last time I looked at how using Unit Of Order (UOO) helps deliver messages in the same order in which they are produced.

Now, consider we have message driven beans (MDBs) or Spring message driven POJOs (MDPs) listening to the messages. A pool of listener beans is going to process the messages. A listener from the pool picks up the message and processes the message.

In the previous example, we want to deliver the delete message first and then the create message. Now, these messages are going to be processed in parallel. There is a good chance that the create message is delivered after, but processed before the delete message. But, my intention was to not only get the messages delivered, but also processed in the same order.

Unit Of Work can help impose a processing order on the messages. With Unit Of Work messages are grouped into a single group -- known as Unit Of Work. This group of messages is delivered as a single object message. The single object message contains the individuals message. Thus, in my example, the single object message contains the delete message and the create message. Both of these messages are grouped together, delivered together, and now will be processed together.

-----
My blog
Answers to J2EE, Java, UML, Process, and Patterns!
Java Enterprise in a Nutshell

On JMS Unit of Order (UOO)

Let's say I have two messages. One to create a product and other to delete a product. The way I update the system that is product master is to delete an existing product and then create a new one. So, I send out the delete message and then send out the create message. However, the create one arrives and fails. The delete one arrives and then succeeds. This is not want I want... I want messages to be delivered in sequence.

Let's see if I can use Unit of Order (UOO) to help me. So, the message are delivered in the order in which they are created. Nice. Therefore, the message to delete will be delivered after the message to create.

But, there are some problems... I will explore those in upcoming entries.

Comments, feedback, and questions are most welcome...

TechStart Seminar by BEA on EJB 3, Spring...

BEA and Azul are presenting on EJB 3, Spring, etc. The event is on Wednesday, July 12, 2006. More information here: http://www.azulsystems.com/events/bea_techstart/TechStart_blended_Q2_Irvine_Partner.htm?ID=1142

Video from the OCJUG presentation on EJB 3

Recently I presented on EJB 3 at the Orange Country Java Users Group (OCJUG). The meeting as usual was very exciting with lots of debates and discussion. The materials from the meeting are available here. The exchange of ideas and topics continued after the meeting. A short video of such discussion after the meeting is captured by JavaJosh and is available here.

Presenting on EJB 3 Persistence at OCJUG on May 11th, 2006

Hi,

How are you doing? I am presenting this Thursday at OCJUG. I am presenting on a much talked about subject: EJB3 persistence. The specification is now final and the implementations are rolling out. The presentation is going to fun and very interactive:) The presentation is available here. The source code example is available here. The presentation is similar to the one that I did at the Southern California Code camp, but has been thoroughly updated to reflect the changes in the specification. I am using BEA Kodo as the EJB3 implementation which is freely available for download. BEA has announced that they have are donating Kodo to Apache under OpenJPA.

Looking forward to seeing you there,
+prakash

-----
My blog (http://dev2dev.bea.com/blog/pmalani/)
Answers to J2EE, Java, UML, Process, and Patterns! (http://www.bartssandbox.com/)
Los Angeles BEA Users Group (http://groups.yahoo.com/group/LABEAUG/)
Java Enterprise in a Nutshell (http://www.oreilly.com/catalog/javaentnut3/)

Spring, Hibernate, and AppFuse discussion at Orange County Java Users Group (OCJUG)

I am participating in a discussion on Spring, Hibernate, and AppFuse at Orange County Java Users Group (OCJUG) today, November 10, 2005. More information about today's meeting is available here. For individuals in the Orange County, California and nearby areas please join us for this lively discussion.

Best regards,
+prakash

-----
My blog (http://dev2dev.bea.com/blog/pmalani/)
Answers to J2EE, Java, UML, Process, and Patterns! (http://www.bartssandbox.com/)
Los Angeles BEA Users Group (http://groups.yahoo.com/group/LABEAUG/)

Hibernate and Spring Presentation

My presentation at the Los Angeles BEA Users Group (LABEAUG) on Hibernate and Spring is now available here. The sample application used to demonstrate the concepts is also available here.

The presentation went extremely well. We had one of the largest numbers of attendances in the history of LABEAUG. The extremely knowledgeable audience asked thoughtful and interesting questions.

In the future blog entries, I will discuss advanced topics, so stay tuned...

I look forward to hearing your experiences on leveraging Hibernate and Spring within WebLogic. Comments, feedback, and questions are most welcome.

Best regards,
+prakash

-----
My blog (http://dev2dev.bea.com/blog/pmalani/)
Answers to J2EE, Java, UML, Process, and Patterns! (http://www.bartssandbox.com/)
Los Angeles BEA Users Group (http://groups.yahoo.com/group/LABEAUG/)

Presenting on Hibernate and Spring at LABEAUG (10/19)

I am presenting at LABEAUG today (10/19) on Hibernate and Spring in WebLogic. I will make the presentation as well as the example available. More information about presentation is available here. I plan to make the presentation interactive, educational, as well as fun. Please pass this information along to your friends and colleagues.

See you there,
+prakash

-----
My blog (http://dev2dev.bea.com/blog/pmalani/)
Answers to J2EE, Java, UML, Process, and Patterns! (http://www.bartssandbox.com/)
Los Angeles BEA Users Group (http://groups.yahoo.com/group/LABEAUG/)

WebLogic and Spring - Part III

In the past few blog entries (part I and part II), I covered configuring Hibernate, a very popular open source Object Relational Mapping (ORM) software with WebLogic. The interest in the blog as well as source code example has been phenomenal. This blog entry describes basic configuration as well as an example of the Spring framework.

Follow these steps to configure WebLogic with Spring.

• Once you have downloaded the Spring framework, copy the contents of the /dist/spring.jar directory into the APP-INF/lib.


• A Spring bean typically is a service. Spring encourages the service to have an interface and an implementation. Dependencies between the services are injected using dependency injection (DI). DI is one of the core themes in Spring. The dependencies are captured in a configuration XML file. Where should I put this configuration file? I have lots of choices, including under WEB-INF. However, I am not comfortable with the dependencies from other projects to the web-project. My choice is put the configuration file in the Java project. Refer to the applicationContext.xml configuration xml included in the source code example.


• Depending upon where I decided to put the configuration file, there are various ways to load the file and configure the bean factory or application context. Some ways are purely declarative as they do not require any coding at all. For example, had I decided to put the configuration file under WEB-INF, Spring ships with a context listener (startup servlet is another option) to create the application context. Since, I decided to put the configuration file in the Java project, I wrote a very simple singleton to do the initialization. Refer to SpringUtil.java in the included source code example.


• Now, I use the SpringUtil to obtain Spring beans from the context. Refer to OrderManager.jws included in the source code example.

Please try out Spring integration with WebLogic. I have updated the sample application, and it is available here. I look forward to hearing your experiences on leveraging Spring within WebLogic. Comments, feedback, and questions are most welcome.

In the future blog entries, I will discuss advanced Spring topics, including integration with Hibernate.

Best regards,
+prakash

-----
My blog (http://dev2dev.bea.com/blog/pmalani/)
Answers to J2EE, Java, UML, Process, and Patterns! (http://www.bartssandbox.com/)
Los Angeles BEA Users Group (http://groups.yahoo.com/group/LABEAUG/)

Configuring WebLogic 8.1 and Hibernate 3.0 - Part II

My previous blog entry described step-by-step instructions on configuring WebLogic 8.1 with Hibernate 3.0. The response and interest in the entry has been tremendous! In this blog entry, I evaluate advanced configuration where Hibernate leverages WebLogic's implementation of Java Naming and Directory Interface (JNDI), Java Transaction API (JTA), Java Connector Architecture (JCA), and Java Management eXtensions (JMX).

Let me start with JNDI. Just by naming the SessionFactory in the hibernate.cfg.xml file, Hibernate makes the SessionFactory available in the JNDI. Alas! This does not work for WebLogic. As described here WebLogic JNDI and Hibernate do not play well together. There are multiple workarounds. The workarounds manually bind the SessionFactory with in the JNDI either via a WebLogic startup class or a start-up servlet. However, I was not able to get the SessionFactory instance reliably back from the JNDI. Therefore, a reasonable compromise is to add an accessor for the SessionFactory to the HibernateUtil utility class.

In order to configure Hibernate to use JTA, I configured transaction.factory_class in the hibernate.cfg.xml file. There are two possible options: org.hibernate.transaction.JTATransactionFactory and org.hibernate.transaction.CMTTransactionFactory. The documentation recommends using the JTATransactionFactory for a bean with Bean Managed Transaction Demarcation (BMTD) and CMTTransactionFactory for a bean with Container Managed Transaction Demarcation (CMTD). The JTATransactionFactory seems more generic of the two transaction factories. It seems to support beans with BMTD as well as CMTD. Therefore, I configured JTATransactionFactory. Additionally, to lookup a transaction in a container-specific way, I configured transaction.manager_lookup_class in the hibernate.cfg.xml file. With this configuration, I do not need to use the Hibernate Transaction API at all as illustrated in the DomainManagerBean.updateWorkPhone() method.

JCA support for Hibernate is experimental and currently not fully baked for WebLogic. In the future, I can imagine that Hibernate is packaged as Resource ARchive (RAR) file. The Hibernate RAR file is deployed as a resource adapter. The adapter makes the Session available in the JNDI. All the configuration elements are done with the resource adapter (xml file) instead of the hibernate.cfg.xml file or by some other means. Why configure Hibernate using JCA into WebLogic? JCA is designed to encapsulate legacy system's connections, transactions, etc. and make them available in the J2EE world. However, Hibernate is designed from group up to play well in the J2EE world. Therefore, the traditional resource adapter benefits are not fully realized. Once Hibernate is configured as a resource adapter, the coupling of specific applications to Hibernate is weakened a little. Multiple different applications can leverage the same Hibernate resource adapter. The benefits of this configuration will be even more pronounced with the standardization of persistence APIs of Enterprise JavaBeans (EJBs), Hibernate, and Java Data Objects (JDO) with current ongoing EJB 3.0 effort. Theoretically, hot (re)deploying the adapter and changing the persistence implementation is possible.

Hibernate ships with JMX Management Bean (MBean) implementation. I did not see a way to deploy Hibernate into WebLogic using JMX. What are the benefits of leveraging JMX with Hibernate and WebLogic? I see at least two benefits. One is deployment as well as re-deployment. But, more importantly is being able to monitor Hibernate and obtain statistics. Runtime monitoring from a JMX console is essential for health and caring of a deployed application.

Please try out these new additional configurations. I have updated the sample application, and it is available here. (Note: Free membership to bartsandbox is required.) I look forward to hearing your experiences on leveraging WebLogic's implementation of JNDI, JTA, JCA, and JMX with Hibernate. Comments, feedback, and questions are most welcome.

In the future blog, entries I will discuss Spring integration with WebLogic 8.1 as well as Hibernate 3.0. So please stay tuned...

Best regards,
+prakash

-----
My blog (http://dev2dev.bea.com/blog/pmalani/)
Answers to J2EE, Java, UML, Process, and Patterns! (http://www.bartssandbox.com/)
Los Angeles BEA Users Group (http://groups.yahoo.com/group/LABEAUG/)

Configuring WebLogic 8.1 and Hibernate 3.0

Recently, I was asked for step-by-step instructions for configuring Hibernate with WebLogic on bartsandbox. As you may already know, Hibernate is a very popular open source Object Relational Mapping (ORM) tool. Follow these steps to configure Hibernate with WebLogic 8.1.

• First you create a domain. I created a WebLogic Workshop (WLW) domain, because I am going to use WLW to create and implement the application.


• Either add hibernate...\lib\antlr-2.7.5H3.jar to the PRE_CLASSPATH or set the query.factory_class property in hibernate.cfg.xml file to user 2.x's query factory.


• The WLW domain also starts a PointBase database instance. I am going to use this built in instance. I created a new user and schema. I populated the schema with some sample data.


• In the server instance, you configure a connection pool and a data source.
.

• Create the application. I am going to use WebLogic Workshop to create an application.


• Where should you put the libraries (jar files) required to successfully run Hibernate? Place the libraries in APP-INF/lib folder of the application. This includes hibernate.jar and additional 3rd party libraries. Refer to table 3-1 of the Hibernate Reference.


• You create a Java project in WLW. This Java project contains the domain classes that map to the database. WLW compiles this project and puts the resultant jar file into the APP-INF/lib directory. In the Java project code the domain class. You create the Hibernate mapping file as well as the Hibernate configuration file. Additionally, you create the HibenateUtil class by copying the implementation from the Hibernate Reference. The Hibernate configuration file contains the JNDI name of the data source.


• You create an EJB project (i.e., a module). This project contains session beans. You code a session bean that manipulates the domain class.


• You create a Web or Web Service project (i.e., a module). This project contains components to interactively test the session beans.

The complete, working, and self-contained sample application is available here. This includes the schema and all the Hibernate configuration files. (Note: Free membership to bartsandbox is required.)

In the next few blog entries, I will enhance this basic configuration. In meantime, try out the above steps. Comments, questions, and feedback are most welcome.

Best regards,
+prakash

-----
My blog (http://dev2dev.bea.com/blog/pmalani/)
Answers to J2EE, Java, UML, Process, and Patterns! (http://www.bartssandbox.com/)
Los Angeles BEA Users Group (http://groups.yahoo.com/group/LABEAUG/)

Seven Steps to Pain and Suffering

This paper titled How to fail with RUP: Seven Steps to Pain and Suffering from the stalwarts of our industry, such as Craig Larman and Philippe Kruchten, is an eye-opener. If you feel, think, or believe that your organization is following Unified Process (UP), this paper may make you realize that you might be following the words of the UP, but not the spirit of the UP. This paper made me realize that UP and Rational Unified Process (RUP) are lot more agile-like than the common widespread perceptions. Read this paper, even if you do not implement UP or RUP.

Here are some of the quotes from the paper that can lead of pain and suffering.

First, do most of the requirements, making the implicit assumption that requirements can be well defined by the users of a product they have not seen before.

This is a norm on many projects. The effects of analysis-paralysis greatly endanger the project. The requirements keep getting polished. Every last detail is inscribed in stone! Alas! Before you know, the world has changed! Again!

Expect Believable Estimates and Detailed Plans Near the Start of a Project

This issue arises because you can not get a budget approval if you do not have a believable estimate and a detailed plan. Without budget, there is no project! How do you derive an estimate? How do you create the detailed plan? These are very difficult questions to answer.

Create most—or even better, all—of the RUP artifacts Add lots of project and process formal ceremony, and even better, several project committees.

The UP process describes 100+ different artifacts created by 100+ activities. As such the UP process is heavy, also known as high-ceremony. Creating the artifacts is one thing, maintaining them is an altogether a different matter. Most projects have a slew of out-dated (and wrong!) artifacts. As such they waste lot of time and energy. Does your project religiously maintain the use-cases? How about the domain model? What about unit-tests?

You think that only prototypes are created in elaboration. In reality, the production-quality core of the risky architectural elements should be programmed in elaboration.

In my consulting I see this all the time. Prototypes and other toys are created, with little or no bearing on the real system. The problem is not that prototypes are not important; the problem is that wrong meaning of accomplishment is derived on completion of the prototypes. There is a huge gap between prototype and "real" application. Lot of time and energy is put into the prototypes, but that time and energy is just thrown away. Instead of being able to iteratively build, we are back to big-bang approach.

Use the seven steps described in the paper as a checklist to see if you are following any of these steps to pain and suffering (actually, regardless of the process / methodology you are using). Drop me a note, and share with your favorite anecdotes and findings from your projects,
+prakash

Should your next web application leverage portal instead of being just Plain Old Web Application (POWA)?

Should your next web application leverage portal instead of being just Plain Old Web Application (POWA)? In this blog entry let me evaluate this decision critically. I am big believer in the KISS (Keep it simple silly) [let us not get into the various incarnations of KISS] principle. Therefore, if I am developing a web-application, I like to keep things as simple as possible but not simpler. Here are the questions I ask myself to help make the decision?

• Do I plan to leverage the portal presentation framework (with books, pages, portlets, etc.)? More importantly, does the application user interface lend itself to the portal presentation framework?


• Do I need to let my end-users customize the application?


• Do I plan to take advantage of integration with content management system (CMS)? More importantly, does my CMS integrate with the portal?


• Do I need security features like entitlements? More importantly are entitlements sufficient for my security needs?


• Do I have requirements for campaign and personalization driven by user's preferences and attributes?


• Do I want features like search? More importantly is my search tool integrated with portal?

This list of questions is my no means exhaustive. For example, I did not consider cost above. If your favorite question is not on the list, drop me a note. I would love to hear from you.

If I answer most of the above questions in affirmative, I should highly consider leveraging the portal framework. But wait; not so fast! The decision must also take into consideration the effort of writing (architecting, designing, coding, and maintaining!) it from scratch versus the amount of customization. For example, I have a page with lots of dynamic content with lots of dependencies. Going crazy with inter-portlet communications may not be such a great idea after all. This does not prohibit or prevent me from using other parts of the portal framework. I just have to ensure that the sum of advantages is greater than disadvantages. One size fits all architecture is just inappropriate.

Let me illustrate with another example. I have a business application that is mainly database-driven with lots of forms for querying the data and displaying the results. There are some transaction aspects to the application as well. Carefully, evaluating the above criteria, the answers are not in favor of a portal. A POWA is sufficient. Writing the application as POWA does not prevent it from being integrated / aggregated into a portal. Refer to my previous blog entry on how multiple POWAs can be aggregated in a portal.

Drop me a note, and let me know if you are writing POWAs, portal applications, or both?
+prakash

-----
My blog (http://dev2dev.bea.com/blog/pmalani/)
Answers to J2EE, Java, UML, Process, and Patterns! (http://www.bartssandbox.com/)
Los Angeles BEA Users Group (http://groups.yahoo.com/group/LABEAUG/)

May 2008

Search this blog:

Archives

March 2008
February 2008
July 2006
May 2006
November 2005
October 2005
August 2005
July 2005
June 2005
May 2005
April 2005

Categories

Recent Entries

Spring Framework 2.5.x Configuration Options

JMSOrderException with Unit of Work

On JMS Unit Of Work

Articles

BEA Users Group: Your local BEA community
BEA User Groups, or BUGS as they are affectionately known, are communities of BEA users that meet to share and learn about the latest trends in technologies and tools. This article describes the structure and purpose of these groups. After reading this article, you will have an understanding of the activities at a user group meeting and the benefits of joining and participating in a BEA users group. Jan. 17, 2005

All articles by Prakash Malani »