All Blog Entries

Consider the following scenario: you are working on a project with client specific APIs .You need to test some API methods before you put them in your real code. For that, you might consider a separate test workspace or defining a new test class in your running workspace. What about scrapbook page? Ever heard of it?

Eclipse provide scrapbook pages to test write test code for experimental purposes. It is easier to use a Java scrapbook page than create a new class. A scrapbook page
...

Unit tests are essential part of software development especially. In complex and large softwares, introducing new changes in very tricky as it can break some other part. If you have clearly defined test cases, then you can check the working of newly introduced change and make sure it works as expected.

Unit tests are small snippets of code that are written to check a particular method or class. With unit tests in place, when a change is made to the code we can simply run all the tests
...

Working on a project, I need to search all the methods defined in my workspace or in a package or in a class with a specific return type. Eclipse search feature (ctrl + h) provides support for this. We all have used eclipse search window a lot of times but many of us don’t know how to really use it to great affect.

Mark occurrences is a nice feature in Eclipse. It simply marks/highlights all the occurrences of a variable, method or a type.

This can be done by clicking ‘Mark Occurrences’ icon on the menu bar. If you like to use short cut keys, then use Alt+Shift+O. If you select methods return type, and mark occurrences is enabled, all the method exit points will be highlighted.

Ever heard of hot code replace in reference to debugging in Eclipse? Well, its sure is a powerful and useful feature. It enables you to change code while debugging. It simply means that you may change the code in debug mode and see its affect.

Hot code replace is supported in 1.4 or higher VM. There are some changes like adding or deleting methods, class variables or inner classes which cannot be hot swapped. This depend on the support provided by a particular VM. This might also
...

When you are working with multi threading where resources are locked and released, deadlock prevention becomes very important. To prevent starvation, proper lock and release mechanism has to be defined/implemented.

Eclipse’s debugger provides monitor information in the debug view. To use it, use the Show Monitors action which can be found in the Debug view drop down menu. It will show which threads are holding locks and which are waiting to acquire locks. The threads in red indicated
...

There are few ways of accessing SessionFactory metrics. One of them is to use JMX to publish metrics. For that you need to enable the StatisticsService MBean. A single MBean can be enabled for your SessionFactory or one per factory.

Hibernate logs various events using Apache commons-logging. Hibernate logs are very interesting to read if you want to do some troubleshooting or performance improvement. Hibernate uses commons-logging service for logging. It actually sends the log to either Log4j or to JDK1.4 logging.

If you want hibernate to log using Log4j, then put log4j.jar into class path along with log4j.properties. Since log4j has almost become a standard these days, I would advice using that.
Hibernate
...

Ever wanted to launch a Java program from a network computer and debug it from the workstation running the Java platform? Example scenario is that you have an a J2EE application deployed on a dedicated server and you need to do debugging on you machine. This can be done if Java VM that supports this feature.

To do this, launch the program in debug mode on the remote machine. It means that the program on server will wait for a connection from your debugger. Now start the debugger
...

Hibernate uses lazy select fetching for collections by default. This behavior makes sense and is used as it is unless you really want to do something different for some reason.

Hibernate will use the batch fetch optimization for lazy fetching if you set hibernate.default_batch_fetch_size. There is a problem with lazy fetching that should be considered. Remember, you should never access to a lazy association outside of the context of an open Hibernate session otherwise exceptions
...

You may wish to share the code written in setUp() and tearDown() methods of your JUnit tests. This clearly will indicate that you have excessive coupling in your design. Coupling is not bad always but if more tests share the same test fixture state, then this indicates that the classes under test have some undesirable dependencies.

You may wish to remove these dependencies but its another stories. As I said, coupling or dependencies are not always bad. But if you wish to keep coupling
...

JNDI is a standard Java API that comes with JDK 1.3 and higher. It provides a common interface to a variety of existing naming services for example DNS, LDAP, Active Directory, RMI registry, COS registry, NIS, and file systems.

The JNDI API is divided logically into a client API and service provider interface. Client API is used to access naming services and a SPI allows the user to create JNDI implementations for naming services.
The naming service providers must implement
...

In JNDI, all naming and directory operations are performed relative to a context. There are no absolute roots. Therefore JNDI defines an initial context, InitialContext, which provides a starting point for naming
...

If you're looking at a web application deployed on a tomcat server, then you might notice META-INF and WEB-INF directories.

The META-INF directory is related to .jar files, It contains the manifest file which has list of jars. The WEB-INF directory is a vital component of your web application. Web application won't run without it. It contains a hierarchy in which you'll find the necessary configuration information for your web application, and all the class files for your servlets
...

Eclipse provides an easy way to generate stubs for the parent classes and implemented interfaces.

Right click the your class and select Source > Override/Implement methods. You will be presented a window where you can select all the methods that you want to override/implement. This methods will be from the implemented interface or extended class.

Its right to say that final keyword improves performance. For example, if you declare a method as final, then you cannot override it in derived classes. When this is told to compiler in advance using final keyword, it improves performance.

Java Code:

public final void doSomethng()
{
...
}

Knowing that a method cannot be overridden, complier inline that method into its derived classes.
Final variables, especially static final variables,
...

Unit testing brings a lot of benefits but there is some cost for this. Lets talk about this.

Unit tests require skill and time. Often managers dont appreciate unit tets because they regard it something othere than development. Ofcource client in not interested in unit tests but management needs to understand that these tests will save a lot of debugging effort in future.

For unit testing to really deliver, all developers need to use it. Mostly due to lack of communicationm
...

Eclipse provides an option to detach a view so that it can be moved to the desired place. Detached views are used if you are not comfortable with the placing of a view and want it to be move to someplace that is more feasible.

We use tags and beans to fetch data from the bean and present it. If you have some knowledge about these, then you will love working with these.

Bean interaction involves JSP getting the value of some property of a bean and displaying that value to the user. Another role of JavaBean is defining how events are specified. Tags can be concerned with two bean-related issues:

Introspecting the beans to find the properties and get the methods that these tags should call

If you think that you cannot access private data members of a class from some other class, then think again. With Reflection, this is possible.

Using reflection, we can see / view / access a private member, private variable, private method. Some people will not like this with argument that this actually means messing up the laws of encapsulation. I use it for unit testing private methods.