Archive for 2019

Home Archive for 2019

One of the important feature in jBPM is work item handlers. Using work item handlers we can create the custom service task which accepts certain parameter as argument and can have the output after some processing.There are many things which are achieved in jBPM using work item handlers only.Few of the things are making rest/soap calls,Email Task and the bit of complex example will be to have an work item handlers for saving JPA entity.

Let's begin with the steps for creating work item handler.

WorkItemDefinition

First we need to define the work item handler.The definition of work item handler contains the name of it, parameter which can be passed in to the work item handler,display name of the handler,icon of the handler and the category to which it will belong.Simple definition of work item handler will look like below.

[
"name" : "Email",
"parameters" : [
"From" : new StringDataType(),
"To" : new StringDataType(),
"Subject" : new StringDataType(),
"Body" : new StringDataType()
],
"displayName" : "Email",
"icon" : "defaultemailicon.gif"
]

Note : Please keep in the mind the the name which we are using over here will be used in reference in future. for mapping between this definition and the implementation of work item handler.

One we have defined our work item handler in work item definition file we can see that handler in the BPMN designer as shown in below screenshot.

Implementation of WorkItemHandler

Once the handler has has been defined inside the work item definition we need to write the implementation of work item handler.For implementation we need to implement the existing interface in our new java class.Name of interface is WorkItemHandler. Let's create one WorkItemHandler which will accept 2 numeric argument and we will display sum of it(Just making it simpler).

 
import org.kie.api.runtime.process.WorkItem;
import org.kie.api.runtime.process.WorkItemHandler;
import org.kie.api.runtime.process.WorkItemManager;

public class RestWorkItemHandler implements WorkItemHandler{

 @Override
 public void executeWorkItem(WorkItem workItem, WorkItemManager manager) {
  Integer number1=Integer.parseInt(workItem.getParameter("number1").toString());
  Integer number2=Integer.parseInt(workItem.getParameter("number2").toString());
  System.out.println(number1+number2);
 }

 @Override
 public void abortWorkItem(WorkItem workItem, WorkItemManager manager) {
 }
 
}

Mapping between work item definition and workitem handler.
Final step is to create mapping between work item handler and the workitem definition.This mapping we are creating inside kie-deployment-descriptor.Below is the code which we need to add inside above mentioned file.Below configuration can also be done using UI of kie-workbench.

The name which we have defined inside the work item handler will be used in below for mapping purpose.

 
 <work-item-handlers>
        <work-item-handler>
            <resolver>mvel</resolver>
            <identifier>new com.myspace.employeeevaluation.wih.RestWorkItemHandler()</identifier>
            <parameters/>
            <name>Rest</name>
        </work-item-handler>
 </work-item-handlers>

When I first heard of a stream, every body was comparing it with the Collection api, So the picture which was there on my mind was that , it is a new kind of data structure introduced in java.But streams are not the data structure.Streams provides methods using which we can perform multiple operations by pipe lining it to produce the desired result.streams are providing results in lazy manner.

Streams is the best feature, java has introduced till now.With the usage of streams so many things in development are easy.But before understanding streams let's see what kind of problem was there in traditional approach.Let's consider below scenario and how does it can be solved using traditional approach and how it can be solved with streams.

Problem Statement

There is a list,containing an employee object.In the employee class there are certain fields defined.Fields like name,age,salary and designation.This list contains duplicate objects also.Now we need a list of employees whose salary are more than 30,000/- Rs.

Below is how we can solve it using traditional approach.

 
                
List<employee> emplaoyeeList = getEmployeeList();
  
  List<employee> resultList = new ArrayList<>();
  for(int i=0;i<emplaoyeelist .size="" emplaoyeelist.get="" getsalary="" i="" if=""> 30000 && !resultList.contains(emplaoyeeList.get(i))) {
    resultList.add(emplaoyeeList.get(i));
   }
  }

Now, let's see the code for solving the same problem using streams.

 
List<employee> emplaoyeeList = getEmployeeList();
  List<Employee> resultList = emplaoyeeList.stream().
             distinct()
              .filter(e -> e.getSalary()>30000).
                collect(Collectors.toList());

As its visible, the code is much smaller for the same things.There might be certain logical diferrence between the logic for traditional approach.But even the best logic will not be able to bit streams.In case of streams we just need to call certain methods for filtering out the results and that's it.We have seen some basic things on streams ,Now lets see the kind of operations which we can perform on streams.

Intermediate Operations

Intermediate operation returns the object of stream type only,The reason is that,by pipe lining the results we can perform multiple operations.

sorted

sorted method is used for sorting the stream.
Example:

 
List<string> letters = Arrays.asList("B","A","C");
List<string> result = letters.stream().map(x->x+" : "+x).collect(Collectors.toList());
System.out.println(result);

Output:
[A, B, C]

map

map method is used for mapping an object in different one based on predicate passed in to it.
Example:

 
 List<string> letters = Arrays.asList("B","A","C");
  List<string> result = letters.stream().map(x->x+" : "+x).collect(Collectors.toList());
  System.out.println(result);

Output:
[B : B, A : A, C : C]

filter

filter method is used for filtering the stream, based on certain parameter.
Example:

 
  List<String> letters = Arrays.asList("B","BigSize","C");
  List<String> result = letters.stream().filter(x -> x.length()<2).collect(Collectors.toList());
  System.out.println(result);

Output: [B, C] distinct Using distinct operation we can remove the duplicate element from the stream.Let's see the example. Example:

 
List<String> mychar = new ArrayList<String>();
  mychar.add("A");
  mychar.add("B");
  mychar.add("C");
  mychar.add("A");
  mychar.add("F");
  System.out.println(mychar.stream().distinct().count());

Output:
4

Terminal Operations

Using terminal operations we can get the resultant type of object.For example list of string.In terminal operation result type will not be of stream.

collect

After performing the operations on collection, if we want the resultant object as collection in that case we can use the collect.

Example:

 
List<String> letters = Arrays.asList("B","BigSize","C");
  List<String> result = letters.stream().filter(x -> x.length()<2).collect(Collectors.toList());
  System.out.println(result);

Output:

[B, C]

forEach

This method is used when we want to iterate element of the stream.For printing each element of print.
Example:

 
  List<String> lettersForEach = Arrays.asList("B","BigSize","C");
  lettersForEach.stream().forEach(x->{
     System.out.println(x);
  });

});

Output:

BigSize

reduce

reduce method is taking BinaryOperator as parameter.This is bit difficult to explain.By looking at the code and its output, people will get more idea on that.So let's take a look over that.

Example:

 
List<String> reduceChar = new ArrayList<String>();
    reduceChar.add("A");
    reduceChar.add("B");
    reduceChar.add("C");
    reduceChar.add("D");
    reduceChar.add("F");
    Optional<String> reduced = reduceChar.stream().reduce((s1, s2) -> {
            System.out.println(s1 +" : "+s2);
            return s2;
    });
    System.out.println(reduced);

Output:

A : B

B : C

C : D

D : F

Optional[F]

count

Using count operation we can count the number of element inside stream.Let's consider an example where we want count of distinct element.

Example:

 
List<String> countStream = new ArrayList<String>();
  countStream.add("A");
  countStream.add("B");
  countStream.add("C");
  countStream.add("A");
  countStream.add("F");
  System.out.println(countStream.stream().distinct().count());

Output:

Introduction

The most important question to evaluate any person in java is to ask the architecture of hashmap and how hashmap is internally working in Java.We will begin with the basic understand of hashmap.

What is HashMap?

HashMap is nothing but the implementation of Map interface in Java. HashMap is introduced in Java in Java version 1.2. HashMap is storing the data in the Key,Value Pair.The HashMap is called as HashMap because it is internally working on a technique called hashing.Another important point to note here is that the key in HashMap obejct is unique.

Internal working of hashmap

The main data structure internally used by hashmap are array and linked list(as you can see in below image).

Consider that object of hashmap is created using below code.

Map<Integer, String> hashMap = new HashMap<String,Integer,>()

Now on above object each method written on above image is called.When put method will be called using values of the hashmap.

Calculate hashvalue for key1.
Based on hashvalue calculate the index.( hashValue & n-1) where n is size of array.
If at the calculated index of array there is no element then it will add the value in the first linked list node.
If value does exist at the calculated index using hash value, it will go to the last linked list node on particular index and will append the value.

Now consider a scenario where the get method of an object is called.In this case it will follow below things.

Calculate hashvalue specified in method arguments of get method.
Based on hashvalue calculate the index.( hashValue & n-1) where n is size of array.
If at the calculated index of array there is only one element then it will return that value
If there are multiple nodes available at the calculated index, it will first compare the hashValue and if it is the same it will compare the key using equals method.

Design of HashMap Class

You can find java file of HashMap.java on below git link.

https://github.com/openjdk-mirror/jdk7u-jdk/blob/master/src/share/classes/java/util/HashMap.java

Inside the HashMap class, which is inside the java.util package,there is a static class named as Node containing below four fields.

hash => Hash value of a value calculated using hashing
value=>value of node.
key=>Key of a node
next=>Pointer to the next node.

Now lets see how it works, First it will do the hashing of key.What exactly hashing does is converting an object in to integer value.This value is calculated using the Hashcode method of object class.Once we have the hash value.We need to add value of hashmap at the index which is calculated using hashing technique.

Now the problem here is that the hashing value is too long.If we add the value of hashmap at the index of hashvalue the array will become so much larger.So what hashmap does here is that, using the default size of array and bitwise operator it will calculate the index of value in array.

Once the index value is calculated ,It will create and object of node and it will add that node i linked list.IF the specified index is null the head pointer of that linked list will to this element other wise appended at the last value.

Another point to note in hashmap is about the instance variable.There are many instance variable declared in hashmap class.But the important one are table,threshold and loadfactor. table is array in which all the key,values are getting stored.threshold is a variable whic is usefull in identification whether the array is full or not.If the array becomes full it will double the size of array.

Now if the numbers of keys added are greater than the threshold value than it will expand the map.In the put/putAll method this check has been made.

Default initial capacity of table inside hashmap class it 16.

Subscribe to: Posts ( Atom )

Navigation

Krutik Jayswal

jBPM:WorkItemHandlers

Java 8 : Working of streams

Java : Internal working of hashmap