Bindings in ADF

Binding provides objects to link components, it is the most innovative part of ADF after Task Flows and provides direct interaction with Appication Module. We can work with bindings in ManagedBean and also in Expression Builder. Bindings are basically used for the interaction on the model and the viewController in an ADF Application.

When we drag any DataControl on page then a binding entry is made in the pageDef of the page for that particular field. Suppose we want to Use CreateInsert operation on a button clik in the page, then we have to create the binding of CreateInsert action in the pageDef on that page and then we can use this action in our ManagedBean to perform the desired operation.

Oracle ADF provides following types of bindings:

1. Action Binding
   
   Action Binding is specifically defined for a button component. Provides access to operations defined by the business object. Such as CreateInsert , Delete.
   

   //The code below gets the Bindings entry of the binding container and fetches the current bindings entry
    BindingContainer bindings = BindingContext.getCurrent().getCurrentBindingsEntry();
    //Gets the opertaion bindings for the method "CreateInsert"
    OperationBinding operationBinding = bindings.getOperationBinding("CreateInsert");
    //Then execute executes the method of the binding
    operationBinding.execute(); 
    

   Likewise you can use the above code to call bindings in ManagedBean.
2. Iterator Binding
3. When we drag tables on the page in ADF then ADF creates a IteratorBinding in the pageDef of the page. The iterator binding can be used to get the iterator of the table in the ManagedBean.
4. Given below is the code that can be used to get the IteratorBinding in the ManagedBean.
   

       BindingContext btx = BindingContext.getCurrent();
       DCBindingContainer dcbct = (DCBindingContainer)btx.getCurrentBindingsEntry();
       DCIteratorBinding binding = dcbct.findIteratorBinding("StudentIterator");
       Row currentRow = binding.getCurrentRow();

5. Here in the last line I have get the current Row from th iterator. 

   LikeWise you can use it to perform desired action. 

7. ValueBindings
   Value Bindings are created in the pageDef for all the attributes that are added on the page from the dataControl.

Java Collections , Map Interface

Map is the most important Data Structure in Java. It is used to store Key & Value pairs.

There are commonly 4 implementations of Maps :

1. HashMap ( No Ordering on Keys or Values )
2. TreeMap ( Ordered on the basis of Key )
3. HashTable ( Implemented same as HashMap, except that HashTable is Synchronised . )
4. LinkedHashMap ( It preserves the order of insertion of elements. )

1. HashMap

   HashMap is used to store Key and Value pairs in the collection. Here is a very simple example.    
   
   
   
   import java.util.HashMap;
   import java.util.Map.Entry;
   
   public class SimpleHashMapTest {
       public SimpleHashMapTest() {
           super();
       }
   
       public static void main(String[] args) {
           //Create a hash map
           HashMap<Integer, String> map = new HashMap<Integer, String>();
           //add key value pairs in the hashMap
           map.put(1, "First");
           map.put(2, "Second");
           map.put(4, "Fourth");
           map.put(3, "Third");
           map.put(5, "Fifth");
           map.put(6, "Sixth");
           map.put(7, "Seventh");
           
           System.out.println("The key value pairs in HashMap are :");
           for(Entry<Integer,String> e : map.entrySet()){
               System.out.println("Key : "+e.getKey()+"        Val : "+e.getValue());
           }
           //get(key) is used to get the value at the given key
           System.out.println("Value at key : "+3+" is :"+map.get(3));
           //These methods can be used to check if the map contains the particular key or not. 
           //They return boolean
           map.containsKey(1);
           map.containsValue("Sixth");
       }
   }
   

   
      And the output on the console is as below.
   
   
   
   
   
   

2. TreeMap

   TreeMap is sortedd on the basis of Key. i.e. if you want to make a key-value pair that need to be sorted on the basis of the key, then you gotta use TreeMap. Let us take an example and try to understand.
   I am taking a self-defined class Animal.class as key and will make a TreeMap. So to make a self-made class a key we need to define implement following interface.
   • Comparable ( This helps in Sorting the keys by comparing them. )
      
   
   

   public class Animal implements Comparable{
       String name;
       Integer size;
       public Animal(String name, Integer size) {
           this.name = name;
           this.size = size;
       }
   
       @Override
       public int compareTo(Object o) {
           return ((Animal)o).size - this.size;
       }
       
       public String toString(){
           return size+". "+name;
       }
   }
   
   public class TreeMapTest {
     
       public static void main(String[] args) {
           TreeMap<Animal,Integer> map = new TreeMap<Animal,Integer>();
           map.put(new Animal("Elefant", 10), 1);
           map.put(new Animal("Cat", 3), 2);
           map.put(new Animal("Tiger", 7), 1);
           map.put(new Animal("Lion", 8), 1);
           map.put(new Animal("Deer", 5), 1);
           
           //map.entrySet() gets you a sorted list of key - value pairs
           System.out.println("Sorted list :");
           for(Entry<Animal,Integer> e : map.entrySet()){
               System.out.println("Key is : "+e.getKey()+ " value : "+e.getValue());
           }
           
           // If you want a sorted in descending order you can use map.descendingMap()
           System.out.println("Descending order list :");
           for(Entry<Animal,Integer> e : map.descendingMap().entrySet()){
               System.out.println("Key is : "+e.getKey()+ " value : "+e.getValue());
           }
           
       }
   }
   

   
   output is  :
   

3. HashTable

   HashTable and HashMap are almost same. The little difference between them is that
   • HashTable is synchronised
   • HashMap is unsynchronised
   That means HashTable is Thread safe and HashMap is not. That simply means that if so many threads are modifying a HashTable then locking is handeled by HashTable itself whereas in case of HashMap synchronisation needs to be done.

4. LinkedHashMap

   LinkedHashMap is similar to HashMap except for the fact that LinkedHashMap maintains the insertion order of the elements in the LinkedHashMap.
   Let us take an example and try to understand.      

   public class Animal implements Comparable{
       String name;
       Integer size;
       public Animal(String name, Integer size) {
           this.name = name;
           this.size = size;
       }
   
       @Override
       public int compareTo(Object o) {
           return ((Animal)o).size - this.size;
       }
       
       public String toString(){
           return size+". "+name;
       }
   }
   
   import java.util.LinkedHashMap;
   import java.util.Map.Entry;
   import java.util.TreeMap;
   
   public class LinkedHashMapTest {
       public static void main(String[] args) {
           LinkedHashMap<Animal,Integer> map = new LinkedHashMap<Animal,Integer>();
           map.put(new Animal("Elefant", 10), 1);
           map.put(new Animal("Cat", 3), 2);
           map.put(new Animal("Tiger", 7), 1);
           map.put(new Animal("Lion", 8), 1);
           map.put(new Animal("Deer", 5), 1);
           
           //map.entrySet() gets you a list of key - value pairs
           System.out.println("List :");
           for(Entry<Animal,Integer> e : map.entrySet()){
               System.out.println("Key is : "+e.getKey()+ " value : "+e.getValue());
           }
           
          
       }
   }
   

   
   
OutPut is : 


Here you can eaisly see that the values are stored in the LinkedHashMap in the order they are inserted.