My Technology Blog

Factory Method Pattern

noreply@blogger.com (Unknown) — Fri, 23 Jul 2010 07:53:00 +0000

Factory Method Pattern

An important facet of system design is the manner in which objects are created. One of the most widely used creational patterns is the Factory Method Pattern.

Creational patterns describe object-creation mechanisms that enable greater levels of reuse in evolving systems

Let’s consider that, the client is an object that requires an instance of another object (the product) for some purpose. Rather than creating the product instance directly, the client delegates this responsibility to the factory. Once invoked, the factory creates a new instance of the product, passing it back to the client. Put simply, the client uses the factory to create an instance of the product.

CLIENT ---uses----> FACTORY (Creator) ----create---->PRODUCT

The Factory completely abstracts the creation and initialization of the Product from the Client, which helps client to focus on its discrete role. As the product implementation changes in future, the client remains unchanged.

“Factory Method Pattern defines an interface for creating an object but let’s subclass decide which class to instantiate”

Most implementations of the Factory method pattern use two abstract classes, Factory and Product.

Consider the following example for Factory Method Pattern.

Let consider AbstractProduct.java class as abstract product class which return the cost of the product. This abstract product class is extended and two concrete classes are created i.e. ProductSubClass_One.java and ProductSubClass_Sec.java

ProductSubClass_One.java-This class extends AbstractProduct class and provide first concrete implementation of getProductCost() method.

ProductSubClass_Sec.java-This class extends AbstractProduct class and provide second concrete implementation of getProductCost() method.

Next consider the Factory (Creator) class AbstractCreator.java is an abstract class which contains one method createProduct(String) method for creating the Product.

Now we will create a concrete class of the Factory (creator) i.e. ConcreteCreator.java which override the createProduct (String) method to return object of the concrete Product Sub Class based on the type.

Till now we have created Factory and Product related classes, now we will create a Client class which in turn uses Factory (creator) class to obtain a Product object.

Here in this class we are creating a Factory (creator) object and using this factory object to obtain the product based on “type” which passed as argument in createProduct (String) method.

When we run the Client.java class we will get object of ProductSubClass_One class which gives following output.

Factory method pattern should be used,

When the object creation depends upon the user data or some event;
When object which is getting created is abstracted from the user;
When the type of object created is to be decided at runtime.

Amazon Interview Questions

noreply@blogger.com (Unknown) — Sat, 17 Jul 2010 08:39:00 +0000

Q1.

Given an array of size n+1 which contains all the numbers from 1 to n. Find the number which is repeated in O(n) time. How do you proceed with the same with floating numbers from 0 to 1 instead of 1 to n.

Ans:

The number appearing two times is (sum of all the numbers in the array) - (sum of the numbers from 1 to n). For floating numbers multiply it with 100 and proceed.

Q2.

How will you find the first k smallest elements in a given unsorted array in O(n) at the worst case?

Ans:

This can be solved in O(n) time. You can find out the position of kth element in an array using the "median of medians" algorithm.

Median of Medians Algorithm

Once we have the kth element, we can just iterate through the array and print elements that are smaller than the kth element to get the k smallest elements.

Effective SOA Governance

noreply@blogger.com (Unknown) — Fri, 09 Jul 2010 13:52:00 +0000

Now a day it is of paramount importance that an enterprise that is strategizing around SOA needs an efficient governance mechanism. SOA governance is more than just providing governance for SOA efforts; it is how IT governance should operate within an enterprise that has adopted SOA as its primary approach to enterprise architecture.

Steps for effective SOA governance

1. Governance should be included from very beginning of SOA initiative.

· Because of the nature of discrete, well-defined services within a SOA, governance is not exclusively a runtime or design-time activity. SOA governance happens all the time—design time, run time, and change time—and architects understand this.

2. Effective SOA starts with governance but a governance solution need to be sold to business to get necessary funding. Approach executive management with the justification for SOA governance. Business should understand the benefit of SOA governance for getting support. E.g. Hartford case study. There was firm commitment from Leadership team of Hartford to put governance in place.

Business team need to understand the benefit of codifying best practices, processes and rules into reusable services based on

· Better control of business solution

· Enabling business and IT teams to collaborate based on business requirements.

Business team needs to provide support for SOA governance

· Cross organizational oversight

· Centralize management of adoption of SOA across organization

· Encourage collaboration across business units with different perspectives.

3. Create a comprehensive plan to create high value and right business service with executive support. Roadmap is needed to ensure success.

· Begin with understanding of the corporate goals and objectives of the business. Establish a governance process before your organization begins building business services.

· Choosing projects that integrate and automate business processes that have the most widespread, visible, and positive impact across the organization enables IT to both qualitatively and quantifiably demonstrate the value of well-governed SOA to the business.

· Develop a process to catalog information about each service- definitions, control, and change management.

· Plan to ensure services are safe to use i.e. security

4. Establish process for organizational change-managing change is as important as creating SOA services.

· Put processes in place to keep track of which business services are developed and when/how they are changed

· Avoid chaos by creating systematic approach to notification and approval for changes.

· Business need to agree on business rules to ensure stability and trust.

· Create business services in a predictable manner based on corporate governance requirements.

5. Balancing risk with oversight to find proper balance for SOA governance.

· How much risk can you afford to take?

· Which business need high level of oversight at corporate and IT level? Some business process require high level of oversight other not. There should always be room for innovation. Future innovation should not be constrained.

· Build flexibility into your governance model.

6. Governing Service Lifecycle – ongoing process

Governance process needs to be ongoing. Step to manage service over their lifecycle

· Decompose parts of business processes

· Identify the service owner.

· Identify the source of funding.

· Govern services from an end to end perspective, so they are not viewed as isolated elements.

· Provide support to ongoing services.

· Ensure service meet the corporate objectives. As corporate objective change services change

In the end some important points

· SOA demands a business focus to be effective

· SOA demands that you codify business processes into reusable services

· Trust is the heart of SOA governance – predictability is the foundation of trust

Business and IT are jointly responsible for ensuring that software reflects best business and IT practices

Singleton Design Pattern

noreply@blogger.com (Unknown) — Sat, 26 Jun 2010 11:03:00 +0000

The Singleton creation pattern is a common programming idiom.The Singleton is a useful Design Pattern for allowing only one instance of your class to be created, but common mistakes can inadvertently allow more than one instance to be created.

The classic example is:

This is a good solution and design of this class ensures that only one Singleton object is ever created. The constructor is declared private and the getInstance() method creates only one object In the general case, however, it is not thread-safe. This implementation is fine for single threaded program but when multiple threads are introduced then getInstance() method must be protected.

Consider two threads calling the getInstance() method concurrently and the following sequence of events.

Thread A calls the getInstance() method and determines that instance is null at //1.
Thread A enters the if block at //1, but is preempted by thread B before executing the line at //2.
Thread B calls the getInstance() method and determines that instance is null at //1.
Thread B enters the if block at //1 and creates a new Singleton object and assigns the variable instance to this new object at //2.
Thread B returns the Singleton object reference at //3.
Thread B is preempted by thread A.
Thread A starts where it left off and executes line //2 which results in creation of another Singleton object.
Thread A returns this second object at //3.

The above classic example creates two Singleton objects when it should create one. This problem can be corrected by synchronization of getInstance() method, which would allow only one thread to execute at a time in getInstance() method.

The synchronized code mentioned above works correctly for a multithreaded access to getInstance() method. But on carefully looking at the code, you can easily make out that instead of synchronizing whole of getInstance() method, synchronization is required only for the first invocation of the method. Subsequent invocations to getInstance() method does not require synchronization because the first invocation is the only invocation that executes the code at line //2. Synchronization has performance cost associated with it, so in order to make above program more efficient we have following third approach.

SyncSingleton_2 class also exhibits the same problem as was there with the Classic approach.

Consider two threads calling the getInstance() method concurrently and the following sequence of events.

Thread A calls the getInstance() method and determines that instance is null at //1.
Thread A enters the if block at //1, but is preempted by thread B before entering the Synchronized block..
Thread B calls the getInstance() method and determines that instance is null at //1.
Thread B enters the if block at //1 and creates a new Singleton object and assigns the variable instance to this new object at //2.
Thread B returns the Singleton object reference at //3.
Thread B is preempted by thread A.
Thread A starts where it left off and executes line //2 which results in creation of another Singleton object.
Thread A returns this second object at //3.

To fix the above problem there is solution which require that a second check should be made before creating the object. This method is called Double Checked locking.

The concept behind double-checked locking is that the second check at //2 makes it impossible for two different SyncSingleton_3 objects to be created.
The concept behind Double Check Locking makes it perfect, but this is not the case.The problem with double-checked locking is that there is no guarantee it will work.This is because of Java Platform memory model which allow out-of order writes. We won't be covering that here.

The bottom line is that double-checked locking, in whatever form, should not be used because you cannot guarantee that it will work. So there are only two options left which are as follows.

First is to synchronize getInstance() method, which we have already covered above.
Second is to let go synchronization and use static instead, which we will cover now.

In the above scenario StaticSingleton object is not created until call is made to static getInstance() method. This is a good alternative is you donot wish to use synchronisation.The Java specs guarantees that the static initializer will be executed only once, at class load time. There could be an argument that, this would create an object if someone refers to the class or at class loading time even if it is not used and this becomes a valid argument when the object is heavy.

An embedded static final class can defer this as shown below

If someone happens to refer to StaticSingleton.class , the singleton object would not be created unless explicit call to getInstance() method is not done.At that time, SingletonHolder is referred to; its class loads; and its static member instance is instantiated.

There is one thing clear after above discussion on Singleton, that any implementation should be matched carefully to the application at hand.

Configuration of Oracle BPM enterprise 10.3.1.0.0 (Standalone) with MSSQL Server 2005

noreply@blogger.com (Unknown) — Thu, 17 Jun 2010 19:04:00 +0000

Step 1: Click on Add button

Step 2:

Step 3:

Step 4:

Enter the host name were MSSQL server is running Host: localhost
Enter the Port on which MSSQL server is listening/running Port : 2108
Create a login in MSSQL server obpmdir and provide dbcreator role

a. Enter User : obpmdir

b. Enter Password : ********

c. Enter Confirm Password : *********

Enter the database name for Directory: Database : OBPMDir

Step 5:

Step 6:

Step 7: Repeat steps performed for creating directory i.e. step 4, for creating engine

Step 8:

Step 9: Make sure MSSQL server is up and running

Step 10: Directory configuration added under Directories section

How to install and run PHP 5 with Apache 1.x on Windows

noreply@blogger.com (Unknown) — Mon, 29 Dec 2008 14:27:00 +0000

Step 1 : Download PHP 5 from following link
PHP 5 Download

Step 2: Download Apache 1.3.x from following link
Apache 1.3.x Download

Step 3 : Install Apache 1.3.x download by running the msi file.

Step 4: On Server Information screen enter the following information

Network Domain : localhost
Server Name : localhost
Administrator Email Address : abc@abc.com
Select for All Users, on Port 80 radio button

Step 5 : Select Typical radio button and click next to install Apache Http Server.

Step 6 : Install PHP by clicking on the php msi installer

Step 7 : Select Apache 1.3.x Module as radio button option

Step 8 : Specify the location of the PHP installation.

Basic installation is done by following steps from 1 to 8. Now Apache needs to be configured for using PHP 5.

Step 1 : Open httpd configuration file which can be found at
\\Apache Software Foundation\Apache\conf

Step 2 : Enter the following LoadModule statement after series of LoadModule statement as shown below

LoadModule php5_module "c:/php/php5apache.dll"

Step 3 : Enter the following AddType statement after series of AddType statements as shown below

AddType application/x-httpd-php .php
AddType application/x-httpd-php .phtml

Step 4 : Enter the following ScriptAlias after ScriptAlias statement as shown below
ScriptAlias /php/ "c:/PHP/"

Step 5 : Test PHP configuration

Create PHP file as follows

test.php

Place this file under \\Apache Software Foundation\Apache\htdocs directory.

Start the Apache server and place http://localhost/test.php in browser.

If screen with php info is displayed then it mean that configuration is successful else there is something wrong somewhere.

Book Review : Jasper Report for Java Developers

noreply@blogger.com (Unknown) — Fri, 26 Dec 2008 09:03:00 +0000

I just finished reading Jasper Report for Java Developer written by David R. Heffelfinger and published by PACKT publishing and here is my review on the book.

The book is really a good read as far as I am concerned. I had never worked on the Jasper Reports earlier, so I can say that its a very good book for beginners . If you are a java developer and want to learn working on Jasper Reports fast I would recommend this as a first book about Jasper Reports.

For those who have never worked on java I would not recommend this as the first book as it requires some basic java understanding.

The book is divided into 11 chapters.

Chapter 1 and 2 are introductory chapter describing history of Jasper Report in general and what Jasper Report is all about. It also describes the environment setup required for using Jasper Reports.

Chapter 3 is the actually where you create your first report. It also provides some of the basics of Jasper Reporting.

Chapter 4 and 5 deals with generating reports by embedding sql queries in report and using different data sources like databases, XML, Java objects etc.

Chapter 6 is an important chapter of the book as provide knowledge about maintaining report layout and design. Sub reporting details are also provided in this chapter.

Chapter 7 and 8 details out step required for adding Chart and other graphic features to the report.

Chapter 9 is totally dedicated to export formats that are supported by Jasper Reports.

Chapter 10 describe how to create reports using IReport designer. IReport makes the designing of the report very easy and simpler. In earlier chapter whatever has been mentioned related to layout and designing of report are done by writing code in JRXML file of report, but using IReport designer its just drag and drop. Although its always good to know how its reflected at the actual jrxml file and how to create reports if designer is not available.

Chapter 11 is all about integrating of Jasper Report with other frameworks like Struts and Spring. These have been explained with simple example.

In the end I would like to recommend this book to all developers who want to learn or use Jasper Report. This book is written in easy to understand language with simple example which can be used for getting hands-on.

Book can be purchased from Packt publishing

Identifiers in Java

noreply@blogger.com (Unknown) — Tue, 16 Dec 2008 16:18:00 +0000

Some points about Identifiers

A name in a program is called an identifier.
An identifier is sequence of characters which can be a letter, digit, connecting characters (Underscore _) or a currency symbol ($, ¢, ¥ or £).
Identifier cannot start with a digit, after first character digits are allowed.
Identifiers in java are case sensitive i.e. test and Test are two different Identifiers.
Identifier can be of any length
Keywords cannot be used as an Identifier.

Illegal Identifier

45abcd – Starting with a digit
abcd@efgh – @ is not allowed
new – Keyword not allowed

Legal Identifier

$$ – $ is allowed
Ab88cd – Digits are allowed after first character.
Abc_88 – Underscore is a valid connecting character.

Important Point about hash code

noreply@blogger.com (Unknown) — Tue, 16 Dec 2008 16:07:00 +0000

Important points about hash code

Hash code is used for increasing the performance of large collection of data.
Hash code is not always unique.
Hash code only tell about the bucket to go into, but not how to locate the name once we are in that bucket.
Collection use the hash code value of the object to decide in which bucket / slot the object should land.
If two objects have same hash code value then it is not necessary that they are equal.
Hashing is a two step process firstly search the right bucket using the hash code value, then search for the element in the bucket using equals()

equals() and ==

noreply@blogger.com (Unknown) — Tue, 16 Dec 2008 15:53:00 +0000

== operator evaluates to true, only when both references refer to the same object
e.g reference a------------> Object1
reference b------------> Object1
then a == b returns true.

String class and Wrapper classes has override equals() method , so that two different objects could be compared to see if their contents are meaningfully equal.
If classes equals() method is not overridden then it cannot be used as key in a Hashtable.
equals() method in Object Class use only the == operator for comparison.
If two objects are considered equal by using the equals() method then they should have identical hashcode values. So it is advisable to override hashCode() when equals() is overridden.

Basics of Java

noreply@blogger.com (Unknown) — Tue, 16 Dec 2008 04:55:00 +0000

Complexity can be handled by abstraction. In OOPS abstraction is modeled using Classes and objects.
A Class models abstraction by defining properties and behavior of an object.
Properties of an object are defined by the attributes, which are fields in java. A field in java is a variable that can hold value.
Behavior of an object is defined by the methods in java.

Object is an instance of the class. In java objects can only be manipulated using references.
Each Object created maintains its own copy of instance variables. Two objects can have same state if the values of their instance variable are same.
Object communicates with each other using message passing.

Static members/methods

Certain members belong to Class only not to object these are called static members.
A static member is initialized when the class is loaded at runtime.
Certain methods that belong to the Class only and not to an object are called static methods.
Client can access static methods using the class name.
Static members of the Class can be accessed either using Object reference or using Class name.

Example of Class & Object

package Test;
//Class declaration

public class Example_Class {

//Attribute declaration - These variables defines the state of the object

private int first_attribute;
private int second_attribute;

//constructor
public Example_Class(int x, int y) {

//Initializing attributes of newly created object.
this.first_attribute = x;
this.second_attribute =y;
}
//Method - These methods define the behavior of the object
public int addResult() {
return first_attribute + second_attribute;
}
//Main method of Class
public static void main(String[] args) {

/* Object instantiation - Object is created using "new" keyword With new keyword Constructor of the class is called which returns the reference of the newly created object, which is assigned to
reference variable of appropriate Class.
*/

// objFirst ---------> Object1(1,2)

Example_Class objFirst = new Example_Class(1, 2);

//Both objFirst and objSecond object refernces will point to two different objects in heap
// objSecond ---------> Object2(1,2)

Example_Class objSecond = new Example_Class(1, 2);

int addResultFirst = objFirst.addResult();
System.out.println("Add Result First:" + addResultFirst);

//Calling method on second created Object
int addResultSecond = objSecond.addResult();
System.out.println("Add Result Second:" + addResultSecond);

}

Installing & using SoapUI

noreply@blogger.com (Unknown) — Sun, 30 Nov 2008 07:48:00 +0000

Steps for installing and using SoapUI are as follows

Install the Soap UI plug-in in eclipse or WebLogic Workshop
Go to the Help > Software Updates > Find & Install
Select for "Search for new features to install".
Click Next button
Click on "New Remote Site".
Enter the name : SoapUI
Enter url: http://www.soapui.org/eclipse/update/site.xml
Click Finish
SoapUI plug-in will be installed on system.
After installation is complete, restart the workshop
Go to Window > Open Perspective > Other
Select SoapUI
Right click on Project Icon on the left and create "New WSDL Project"
Enter the project name
Enter the WSDL location
Click OK button
Project will be created with entered name and all the projects exposed by WSDL will be visible under the + sign
Click on + sign to view all the methods
Double click on the method you want to test and click on Request 1 icon
Enter the inputs required by the method and click on green play button on the top left.
Based on entered input Response is generated on right pane.

Important Points about Threads in Java

noreply@blogger.com (Unknown) — Sun, 30 Nov 2008 07:33:00 +0000

To synchronize threads, the Java programming language uses monitors, which are a high-level mechanism for allowing only one thread at a time to execute a region of code protected by the monitor.
The behavior of monitors is explained in terms of locks; there is a lock associated with each object.
The methods wait, notify, and notifyAll of class Object support an efficient transfer of control from one thread to another.
A thread can suspend itself using wait until such time as another thread awakens it using notify.
Each thread has a working memory, in which it may keep copies of the values of variables from the main memory that is shared between all threads.
To access a shared variable, a thread usually first obtains a lock and flushes its working memory. This guarantees that shared values will thereafter be loaded from the shared main memory to the threads working memory.
When a thread unlocks a lock it guarantees the values it holds in its working memory will be written back to the main memory.
Every thread has a working memory in which it keeps its own working copy of variables that it must use or assign. As the thread executes a program, it operates on these working copies. The main memory contains the master copy of every variable.
The main memory also contains locks; there is one lock associated with each object. Threads may compete to acquire a lock.

Finalization in Java

noreply@blogger.com (Unknown) — Sat, 26 Jul 2008 06:56:00 +0000

protected void finalize() throws Throwable

It is declared in Object class.
Is invoked by the garbage collector after it determines that this object is no longer reachable and its space is to be reclaimed.
finalize is that it is invoked if and when the Java^TM virtual machine has determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, except as a result of an action taken by the finalization of some other object or class which is ready to be finalized.
Subclasses of Object may override this definition.
It is guaranteed that the thread that invokes finalize() will not be holding any user-visible synchronization locks when finalize() is invoked.
Any exception thrown by the finalize() causes the finalization of this object to be halted, but is otherwise ignored.
finalize() is invoked at most once per object, even if execution of this method causes the object to become reachable again and later it becomes unreachable again.

ENUMS in Java

noreply@blogger.com (Unknown) — Sun, 17 Feb 2008 07:19:00 +0000

Some Important points about Java Enums.

Enums can be declared as their own separate class, or as a class member, however they must not be declared within a method.
Enums can be declared outside the class.
Enums cannot be private or protected.
Enums can have only default or public modifier.
Semicolon at the end of Enums declaration is optional.
Enum is a special type of Class.
Enum constructor are never invoked directly
Enum constructor can be overloaded just like any other constructor in class.
If an enum is declared as public then it should be declared in its own file.
Enums declared within a class can have public, private, protected, default, static and abstract modifiers

package TechnicalTutorial;

/* Enum declared outside the class can have default access only */

enum TechEnum{
FIRST, SECOND, THIRD
}

public class Example_1 {

public enum TechEnum_2{
HUNDRED, THOUSAND
}

public static void main(String[] args) {
TechEnum num = TechEnum.FIRST;
System.out.println(num);

}
}

In above example enum can be declared as public only within a Class i.e. TechEnum_2 . If an enum need to be declared as public outside the class then it should be created in separate file.

Book Review : Business Process Management with Jboss JBPM

noreply@blogger.com (Unknown) — Mon, 14 Jan 2008 11:41:00 +0000

Currently I am working on a project that involves jBPM as the workflow engine and jPDL as the design language. Recently I had gone through a review copy of book Business Process Management with JBoss jBPM, written by Matt Cumberlidge and published by PACKT Publishing and here is the review on the book as per terms of review copy.

The book is good introduction into the JBPM, primarily for Business Analysts and architects. For developers it is useful guide that highlights the correct approach that should be followed before implementing a BPM solution.

Things I liked about the book:

Firstly, the book actually delivers what it says: providing a good introduction into the jBPM world. It can be followed as hands on book by business analyst and beginners can follow it as a tutorial for quick start.

All the features of jPDL designer are explained step by step with properly supporting images. Images always put information more intuitively. Initial chapter of the book talk about the environment setup which includes installation of each and every software.

Book follows one example approach, linking whole software development lifecycle and how BPM fits in it, although I personally would have liked some small examples also.

Things I didn’t like about the book:

There are more than a couple of things that I didn’t like about the book. The book doesn’t dive deep into the technical aspect of the jBPM. The book is more on theoretical side with only one example explained through out the book. Some of the technical stuff related to sub process and super states was too concise. The book was not thoroughly enough for developers.

Conclusion

I would recommend this book to newbie’s who wants to learn about JBPM and BPM. From developer’s point of view it does not provide answer to actually create an enterprise level application although it is good book for beginners.

The book can found at Packt Publishing

Setting Variables

noreply@blogger.com (Unknown) — Thu, 27 Dec 2007 15:48:00 +0000

For setting variables ContextInstance is required. ContextInstance maintains all the key-value pairs for a process instance.

We can get ContextInstance from Process Instance.

ContextInstance contextInstance = processInstance.getContextInstance ();

Variable can be set as mentioned below using ContextInstance obtained from processInstance.

contextInstance.setVariable (“Variable Name”, “Value”);

JBPM Database Steps

noreply@blogger.com (Unknown) — Thu, 27 Dec 2007 15:43:00 +0000

One of the basic features of jBPM is the ability to persist executions of processes in the database when they are in a wait state.

1. First we create the JBPM Configuration.

Static JbpmConfiguration jBpmConfiguration = null;

This is static as same jbpm configuration can be used for the entire threads configuration.

2. All the configuration related information is stored in resource file “jbpm.cfg.xml”

3. The jBPM configuration is loaded.

jBpmConfiguration = JbpmConfiguration.parseResource ("jbpm.cfg.xml");

4. Get the jBPM context from the jbpm configuration.

jBPMContext = jBpmConfiguration.createJbpmContext ();

5. Get the graph Session from jBPM Context

jbpmGraphSession = jBPMContext.getGraphSession ();

6. Get process definition from Graph Session

ProcessDefinition processDefinition= jbpmGraphSession.findLatestProcessDefinition (“Add Product”);

7. Get process Instance from Process Definition

ProcessInstance processInstance = new ProcessInstance (processDefinition);

After getting the process Instance user can do whatever he wants to do.
Data will not not be persisted in database untill and unless jBPMContext is not closed

JBPM Architecture Continued !!

noreply@blogger.com (Unknown) — Wed, 26 Dec 2007 16:06:00 +0000

Action Handlers are contained in process definition and are executed in JBPM engine.When the process engine encounter a node during the execution of process instance which is derived from process definition, action handler associated with them are executed. Action handlers are instances of Java code that interact with external systems when executed.

Process Definition: A process definition is based on a directed graph (A ProcessDefinition is formal description of process represented as Java Objects). The graph is composed of nodes, transitions, one start state, and one end state. The type of each node defines the runtime behavior for the node. While a process definition executes, the following entities come into play:

Process instance: A process instance is one execution of a process definition. When a process instance is created a token is created for main path of execution called the "Root Token" and is positioned and the start state of the Process Definition.

ProcessInstance processInstance = new ProcessInstance (processDefinition);

Token: A token is one path of execution. A token is the runtime concept that maintains a pointer to a node in the graph.

Token token = processInstance.getRootToken ();

Signal: A signal instructs a token to continue graph execution by transition out of a node.When receiving an unnamed signal, the token will leave its current node over the default leaving transition. When a transition-name is specified in the signal, the token will leave its node over the specified transition. A signal given to the process instance is delegated to the root token.

token.signal ();

Node: Nodes are responsible for the continuation of a graph execution. When a token enters a node, the node executes. Node type determine what will happen when execution arrives at a particular node.A node that does not propagate execution is regarded as a state.

Action: Actions are instances of Java code executed when events occur in a process execution. The primary event types are "entering a node," "leaving a node”, and "taking a transition."

Overview of JBOSS JBPM Architecture

noreply@blogger.com (Unknown) — Wed, 26 Dec 2007 15:43:00 +0000

JBoss jBPM defines process definitions within files written using the JBoss process definition language e.g jPDL. JPDL is a graphic-oriented programming (GOP) language based on a model of nodes, transitions, and actions. In this model, nodes are traversed and executed as they are encountered during the flow of a process definition. Transitions direct the flow of execution of a process definition, and actions perform specific logic as a node or transition event occurs.

In jBPM, process definitions are packaged as process archives, when process definition is created using Process designer ".par" file is created. A process archive is passed to the JBPM process engine for execution. The JBPM runtime engine traverses a process graph (which is always a directed graph) and executes actions defined with various transitions and states or nodes.

JBoss jBPM mainly consists of following components.

Runtime engine: This component executes process actions, maintains process state, and logs all process events via the following components:

A request handler
A state manager
A log manager
A definition loader
An execution service

Process monitor: There are various modules in JBPM one of them is Process monitor, which is responsible for auditing and logging.

Process language: The process definition language (jPDL) is based on GOP which is easier to use and can keep business and programmer on same page. Business can create the Graph (More or less like flowchart) and developer can implement the logic.

Interaction services: These services expose legacy applications as functions or data to be used in process executions

What is JBPM ?

noreply@blogger.com (Unknown) — Wed, 26 Dec 2007 12:05:00 +0000

In simple words Jboss jBPM is sophisticated state machine that can execute long running process that can be visualized graphically.JBoss jBPM is a JBoss Enterprise Framework that delivers work flow, business process management (BPM), and process orchestration in a scalable and flexible product footprint.
JBoss jBPM 3.0 delivers the capability of developing new automated business processes and work flows with industry-standard orchestration using Business Process Execution Language (BPEL), a flexible and pluggable API, a native process definition language, and a graphical modeling tool.

JBoss jBPM enables automation of business processes that coordinate between people, applications and services.

BPM Continued

noreply@blogger.com (Unknown) — Wed, 26 Dec 2007 11:56:00 +0000

BPM has three important phases.

Process design: The task of designing existing and new processes using various process design languanges such as jPDL (jBPM Process Definition Language), BPEL (Business Process Execution Language) etc

Process execution: The execution of an automated sequence of related events involving software processes and/or human activities

Process monitoring: Observance and auditing of the state of individual processes so that the statistics and performance of these processes can be recorded, reported, and optimized

What is BPM ?

noreply@blogger.com (Unknown) — Wed, 26 Dec 2007 11:26:00 +0000

The term BPM i.e business process management typically refers to a set of activities enterprises can employ to automate and optimize business processes in a manner adaptable to dynamically changing environments.

BPM offers a programmatic structure for designing transactions and executing them using automated decisions, tasks and sequence flows. These activities usually seek help from software engineering and tools therefore, the term BPM is often used directly to refer to the engineering techniques and tools.

BPM solutions typically include three components: an engine that executes process definitions, services that allow the engine to interact with the outside world, and tools that aid process development and monitoring.