String, StringBuffer and StringBuilder

With respect to C or C++ in java String handling is different. Java provides String class to represent Strings. For better memory utilization java treats String as constant and their value can't be changed.

This behavior is popularly known as immutable.The idea is if some one write

String hello = "Hello"; 

String greetings = "Hello";

Internally both refer to same object. In JVM memory area there is a dedicated memory for these String literals, known as String pool.

So in our example hello == greetings will return true.

But if someone write

String str = new String("Hello");

It will create a new object, it won't point to same literal available in string pool.

So hello == str will return false. 

Another advantage of java String is we can use + for concatenation.

String greetMe = hello + "Java";

We can concatenate diffrent type of object other than String with String too. The typecast is automatic.String conversions are implemented through the method toString, defined by Object and inherited by all classes in Java.

As we learned String objects are immutable means the values cannot be altered. So strings are always thread safe. Any operation such as hello.toLowerCase() will result another object. For extensive String manipulation java provides two other classes StringBuffer and StringBuilder. These classes gives us a way to manipulate String efficiently. The only difference is StringBuffer is thread safe while StringBuilder is not. So by design StringBuilder is faster than StringBuffer.

So when to use what

String is used to handle multiple literal, it gives you optimum way to handle duplicate literal for better memory utilization.

StringBuffer is natural choice if we need to do a lots of String manipulation in a thread safe way. If synchronization is not the issue StringBuilder should be used since its faster than StringBuffer.

Have fun with your Strings  ;)

Future of Enterprise Applications Development

This is something I came to know while working with Weblogic for past few years. Over the years weblogic has developed quite a bit from one of its oldest version 6 (formerly known as BEA and before that known as Aqualogic) to Weblogic 12 (currently known as Oracle weblogic).

David Moyes might have left Manchester United in a mess this year (2013-2014), but oracle has done its bit to enhance Weblogic for its betterment. The most stable version currently in industry standard is 11g (10.3.6). Forgive me for showing my untiring effort to link Football to Weblogic, which are no way related, but one more expensive player bought on board by Oracle is Sun Java. And as a branch of Oracle Java is growing very fast and although Java 6 is considered as an industry standard now, there is already a new version of Java 8 already released in March 2014.

Now, naturally the question is where am I leading you to? The point I am trying to make is, the version of Java that comes for the latest Weblogic is still Java 6. Although you can use Java 7 in weblogic 12c (http://docs.oracle.com/cd/E24329_01/doc.1211/e24492/jdk7.htm), as of now we haven’t seen Weblogic using the full potential of the new Java versions. All features available might not be of use, but features like new concurrent Garbage Collector , improved compiler warnings etc would mean a vastly improved Weblogic application server with less and less memory issues for heavy enterprise applications.

And the latest in this is Java 8 which boasts of a very small JVM of 3MB. These features combined with the new improved weblogic GUI, security features gives enterprise applications a huge boost in terms of performance and ease of handling. What I am looking forward to is coming days with a complete package having the latest version of all the products required for enterprise application development. A Language (Java),an Application Server (Weblogic), a database (Oracle Database) and an IDE (NetBeans). This might act as a Commercial Of the Shelf (COTS) product for oracle and would standardize the process starting from development till deployment. Although this might sound as taking away the flexibility of the individual options that you can have but it is more to make an industry acceptable standard for enterprise architecture while free lancers and open source community continuing their adventure to explore new avenues and improve the standard in future.

Do it my way ...

Every body like to do their work in their own way, and others to follow their way. If not everybody, certainty most of the people. The art of making others doing the work in your way is called managerial skill, leadership etc .. No need to worry I am not getting some sort of management concepts.

We programmers  do copy the real world arrangement and behaviors to solve software designing problems. So the idea of one program,module and class controlling the way other behave is quite natural. Dependency injection is the well known way of doing such thing.
In Java it used to happen through interface and abstract class. Anonymous class is widely used to define the concrete class for such interface or abstract class.

JButton testButton = new JButton("Test Button");
     testButton.addActionListener(new ActionListener(){
     @Override public void actionPerformed(ActionEvent ae){
        System.out.println("Click Detected ...");
       }
     });

In the above code we are creating an anonymous class which extends  ActionListener. This is a commonly used technique. In Java 8 this whole concept is more formalized into lambda expression. We can re-write the previous example

JButton testButton = new JButton("Test Button");
testButton.addActionListener(e->System.out.println("Click Detected ..."));

Lambda expression simplifies the code significantly. Lambda expression is used when we have to implement a functional interface. Functional interface means interface with only one method to be implemented.
So the advantage of lambda expression over anonymous class is it reduce the lines of code.

Happy Coding ;)

Encrypted JDBC connection with Oracle Database

To protect sensitive data encryption is the standard way. Its highly recommended if you are dealing with sensitive data, the application database connection also need to be encrypted. In this article we will go through how to establish a secure JDBC connection to Oracle database.

 1) We need to turn on encryption in oracle server. We can do that by starting Oracle Net Manger. There we have to select Oracle Advance Security and in Encryption tab there is option to turn on Encryption for server.

There is the brief documentation about different options and algorithm can be used for Encryption can be found here. 

2) Once the encryption for server is turned on. Next is how to establish a secure connection from Java.

JDBC driver has the capability to establish a encrypted connection. we have to pass necessary information as part of properties to do so. Here is documentation for that.

In this way we can establish encrypted connection. To test whether its working or not, we have to install some network sniffer tools. By that we can verify the exchanged data is encrypted or not. Another way is by turning on the tracing in Oracle Net Manger for network communication. And to check those trace for network traffic data is encrypted or not. 

Internationalization Of af:query

I found ADF af:query is very useful. It provide out of box search and reporting capability. Typically we define some search criteria in View Object, and we use that criteria as af:query component.

All the labels we see in the page can be internationalized by using resource bundle in normal way.

For some labels we can use the below properties of af:query

                              ·         headerText

                              ·         resetButtonText

                              ·         saveButtonText

                              ·         searchButtonText

“Advanced” and “Saved Search” automatically take care. In fact all these labels are automatically translated as per locale. Only to support the language for which translation is not available or you want to have your customize label you can use above properties.

And rest of the labels can be customized or internationalized by using resource bundle configured for application module. To do so we need to modify the attribute of view object, In Control Hints section, Label Text filed can be modified to point right message key from the bundle.

ADF Tree Table javax.faces.model.NoRowAvailableException

Usually this issue appears with Tree Table, when we modify the model associated with the tree. The UI state (disclosure and section information) is captured corresponding UI component object. When the model is updated those state become invalid. And when the tree try to restore the old state with new set of data then there could be a situation where this NoRowAvailableException can occur.

To avoid this better to clear the selection when model is updated. And then immediately partial refresh the tree .

I had used something like this to clear.

 if (treeTable != null && treeTable .getDisclosedRowKeys()!=null ){
        treeTable .getDisclosedRowKeys().clear();
    }

JBO-26001: NoXMLFileException

This exception comes in ADF BC projects. In my case <project>.jpx file was not part of deployment.
Run time BC needs the .jpx, As it is not able to find it throw JBO-26001: NoXMLFileException exception.
To make sure .jpx is part of deployment. Right click on project under deployment section check whether its included or not. If its not included add it.
Hope it solve the issue.

Hashcode and Equals Method

It’s a common topic In  java interviews. And these two methods are always common to any class you write in Java. So let’s know them in and out.

boolean equals(Object  obj) and int hashCode() are two methods implemented in Object class with several other methods.  In Java every class implicitly inherit Object class so every class has these methods.  Equals method check the reference is holding same object or not.

MyClass obj1 = new MyClass();

MyClass obj2 = 0bj1;

Then obj1.equals(obj2) returns true.

MyClass obj3 = new MyClass();

In this case obj1.equals(obj3) will return false.

It means original equals method check whether two reference contain same object or not. If two object are logically similar, for ex like wrapper class Integer, Boolean etc we need to override equals method.

Boolean b1 = true;

Boolean b2 = true;

b1.equals(b2)  will return true. 

To overload equals method programmer may chose to compare field by filed.

Public class Employee

{

Integer employeeId;

String name;

public  boolean equals(Object obj)

{

 if (obj != null && obj instanceof Employee)

{

 Employee obj2 = (Employee) obj;

 return (obj2.getEmployeeId() == null ? this.employeeID == null : 

 obj2.getEmployeeId().equals(this.employeeID))

&& (obj2.getEmployeeName() == null ? this.employeeName == null : 

 obj2.getEmployeeName().equals(this.employeeName));  

}

return false;

}

Hascode method always return integer. Any two object equals return true always return same hashcode.  But its not necessary if two object produce same hashcode need to be equal.

Now here is the million dollar question if we override equals method do we need to override hashcode method. The answer is yes. We need to override hashcode method. It should satisfy two condition every distinct object produce different hashcode consistently and equals object will produce same hashcode.

Hashcode is important when we use HashTable, HashSet or HashMap in collections api. If we don’t construct the object in the above way, these collections may not work properly, performance can deteriorate.

So bottom line is always override hashcode when you override equals. J