Dependency Injection for Objects in Spring

Now as we already know how to push up properties in to bean using Spring DI, its now a time to take a next step towards containment using Spring. 

In many real life scenario we need to have the object as a property of bean. For instance, if we are creating Employee object like : 

public class Employee {

int empId;

String empName;

Date dt_of_join;

public int getEmpId() {

return empId;

}

public void setEmpId(int empId) {

this.empId = empId;

}

public String getEmpName() {

return empName;

}

public void setEmpName(String empName) {

this.empName = empName;

}

public Date getDt_of_join() {

return dt_of_join;

}

public void setDt_of_join(Date dt_of_join) {

this.dt_of_join = dt_of_join;

}

}

Here the Employee is dependent on the object of Date. We need to create the object of Date and then insert it into Employee.

public class Date {

     int dd, mm, yy;

     public int getDd() {

          return dd;

     }

     public void setDd(int dd) {

          this.dd = dd;

     }

     public int getMm() {

          return mm;

     }

     public void setMm(int mm) {

          this.mm = mm;

     }

     public int getYy() {

          return yy;

     }

     public void setYy(int yy) {

          this.yy = yy;

     }

}

To achieve this containment concept , spring uses Dependency Injection using bean reference. We can do it by following change in our configuration file 

<beans>

<bean id="id1" class="Date">

<property name="dd" value="10" />

<property name="mm" value="12" />

<property name="yy" value="1982" />

</bean>

<bean id="id2" class="Employee">

<property name="empId" value="10" />

<property name="empName" value="Ajay" />

<property name="dt_of_join" ref="id1" />

</bean>

</beans>

We need to first of create a bean of Date class (id1) which we can inject in Employee bean (id2) by using attribute ref="id1" of property "dt_of_join". 

So one can add any number of beans of Date in xml file and can change the reference of that bean in Employee's property at run time without changing coding of application class/Employee class. 

One more important thing is even though we change the definition of Date class, the Employee class and Main application class file would remain unchanged. :-) 

HelloWorld : Basic example of Spring Framework

Hi Folks !!

After a long time coming back to blog !!! Hope you are still in touch with Spring Framework. For all those who are waiting for the first implementation of Spring .. Here I am !!

We had enough theory earlier about what is dependency injection and why dependency enjoy. Lets make our hands wet with some coding now.

HelloWorld Implementation . 

In this implementation we will learn the property injection using spring framework.

To begin with create a bean, MyBean

public class MyBean {

             private String message;

             public void setMessage(String message)

             {

                      this.message = message;

             }

             public void show()

             {

                      System.out.println(message);

             }

}

As you can observer, MyBean has a property message, and setter, getter methods for the same. Normaly we would have gone with constructor arguments to initiate the message like :

MyBean mb=new MyBean("My message"); 

But to implement dependency injection we will be injecting this property through xml.

Create a xml file, config.xml in src folder :

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"

"http://www.springframework.org/dtd/spring-beans-2.0.dtd">

<beans>

<bean id="id1" class="MyBean">

<property name="message" value="Welcome to spring" />

</bean>

</beans>

Here object of bean MyBean is referred by bean is "id1". The property tag contains attributes name and values which is used to push the values of properties for "id1".

Create application class to load the object from bean container:

import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

public class MainApp {

          public static void main(String[] args)

          {

                   Resource res = new ClassPathResource("config.xml");

                   BeanFactory factory = new XmlBeanFactory(res);

                   Object o = factory.getBean("id1");

                   MyBean wb = (MyBean)o;

                   wb.show();

          }

}

Thats it guys !! You are ready to execute your first spring application. 

Execute MainApp class and you will get output as : 

Welcome to spring

Jar files required to run this application;

1. spring-2.5.jar

2. common-logging-1.1.jar

3. cgilib-2.2.jar

In my coming post I will explain how to push object through dependency injection and pushing the properties through constructor argument.. 

Keep reading  :-)

Spring Dependency Injection

Spring Dependency Injection

Spring uses inversion of control the dependencies between objects. Traditional approach before Spring framework was to hard code the dependencies and this creates tightly coupled code and there was no easy way to change that. People used to minimize this tight coupling, by resorting to ” programming to an interface and not to an implementation”, but even with that approach, the actual creation of the dependent object was the responsibility of the calling piece of code. Of course there were custom frameworks being developed by various individuals to create some form of  inversion of control to achieve dependency injection ( DI). Spring changed all that by incorporating dependency injection in a framework.

Lets take example of Employee object 

class Employee

{

int empId;

String empName

}

Here when we wish to create object Employee, the Employee object creation is dependent on values of empId and empName i.e. 

Employee e1=new Employee(1,"Vikas");

These values need to be hard coded in the program as stated earlier. The scenario becomes still tough when we have the concept of containment in class like : 

class Date

{

int dd,mm,yy;

Date(int dd,int mm,int yy)

{

this.dd=dd;

this.mm=mm;

this.yy=yy;

}

}

And

class Employee

{

            Date dt_of_join;

            Int empId;

            String empName;

            Employee(int empId,String empName,Date dt_of_join)

            {

                        this.dt_of_join=dt_of_join;

                        this.empId=empId;

                        this.empName=empName

            }

}

Here Employee object is also dependent on object of Date. So, to create object of Employee, one need to create Date object and then push it into Employee object 

i.e.

Date d1=new Date(10,12,1989);

Employee e1=new Employee(1,"Vikas",d1)

This traditional way of creating and pushing objects is very difficult for maintenance of application. So we are in need of a concept called as DI.

Dependency Injection (DI) – Spring

In Spring framework, Dependency Injection (DI) is used to satisfy the dependencies between objects. It exits in two major types :

1. Constructor Injection
2. Setter Injection

Dependency Injection offers atleast the following advantages

• Loosely couple code
• Separation of responsibility
• Configuration and code is separate

In next session we will start with the first program of Spring DI with Setter Injection

Introduction to Spring Framework

Introduction: 

Spring is an open source framework created to address the complexity of enterprise application development. Enterprise applications has a tremendous need of wiring objects or implementing different behavior of object at runtime that too without imposing much load on application. One of the main advantages of the Spring framework is its layered architecture design, which allows us to wire the objects as and when necessary with reduced maintenance efforts.

Core Features of Spring

• Lightweight:

1.      Spring provides you different modules and allows you to use any one based to your requirement.  Ideally the spring jar is just 2-3 MB. 

2.      If you compare Spring with EJB, then you have to write very less code and configurations too. The beauty of Spring is that you can actually focus on business logic whereas in EJB you have to write lot of code along with business logic which makes the code bulky and tightly coupled.

3.      Through Spring you are playing with POJO which do not depends on Framework and it improves the testability of your code. 

4.      And, Spring provides seamless integration with frameworks, third party libraries etc.

• Inversion of control (IOC):

The Inversion of Control (IoC) and Dependency Injection (DI) patterns are all about removing dependencies from your code.. No need to directly connect your components and services together in program, instead just describe which services are needed by which components in a configuration file/xml file. The Spring IOC container is then responsible for binding it all up.

• Aspect oriented (AOP): 

Aspect oriented programming refers to the programming paradigm which isolates secondary or supporting functions from the main program's business logic. AOP is a promising technology for separating crosscutting concerns, something usually hard to do in object-oriented programming. The application's modularity is increased in that way and its maintenance becomes significantly easier.

• Container:

Spring contains and manages the life cycle and configuration of application objects.

• MVC Framework:

Spring comes with MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI. But other frameworks can be easily used instead of Spring MVC Framework.

• Transaction Management:

Spring framework provides a generic abstraction layer for transaction management. This allowing the developer to add the pluggable transaction managers, and making it easy to demarcate transactions without dealing with low-level issues. Spring's transaction support is not tied to J2EE environments and it can be also used in container less environments.

• JDBC Exception Handling:

The JDBC abstraction layer of the Spring offers a meaningful exception hierarchy, which simplifies the error handling strategy. Integration with Hibernate, JDO, and iBATIS: Spring provides best Integration services with Hibernate, JDO and iBATIS

Architecture:

Spring is well-organized architecture consisting  of seven modules. Modules in the Spring framework are:

1. Spring AOP:

One of the key components of Spring is the AOP framework. AOP is used in Spring:

• To provide declarative enterprise services, especially as a replacement for EJB declarative services. The most important such service is declarative transaction management, which builds on Spring's transaction abstraction.
• To allow users to implement custom aspects, complementing their use of OOP with AOP
1. Spring ORM:

The ORM package is related to the database access. It provides integration layers for popular object-relational mapping APIs, including JDO, Hibernate and iBatis.
  

3. Spring Web:

The Spring Web module is part of Spring?s web application development stack, which includes Spring MVC.

·  Spring DAO:

The DAO (Data Access Object) support in Spring is primarily for standardizing the data access work using the technologies like JDBC, Hibernate or JDO.
 

·  Spring Context:

This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
  

·  Spring Web MVC:

This is the Module which provides the MVC implementations for the web applications.
  

·  Spring Core:

The Core package is the most import component of the Spring Framework. 
This component provides the Dependency Injection features. The BeanFactory  provides a factory pattern which separates the dependencies like initialization, creation and access of the objects from your actual program logic.

In my next blog post I will let you dive in Dependency injection(ioc) in spring

Keep posting your queries if any

Java Spring Series

Spring Framework is a Java platform that provides comprehensive infrastructure support for developing Java applications. Spring handles the infrastructure so you can focus on your application.

Spring enables you to build applications from “plain old Java objects” (POJOs) and to apply enterprise services non-invasively to POJOs. This capability applies to the Java SE programming model and to full and partial Java EE.

In my coming posts I will be exploring Spring for you.. 

TARGET AUDIENCE

This tutorial is designed for Java programmers who need to understand the Spring 3 framework and its application.

PREREQUISITES:

Before proceeding with this tutorial you should have a good understanding of the Java programming language. 
This is 1 of 13 parts of tutorial series

CONTENT: exploring spring

Introduction to spring framework
Dependency injection(ioc) in spring
Spring hello world example in eclipse
Dependency injection via setter method in spring
Dependency injection via constructor in spring
Spring Bean scopes with examples
Initializing collections in spring
Beans Autowiring in spring 
Inheritance in Spring 
Spring ApplicationContext 
Spring lifetime callbacks 
BeanPostProcessors in Spring 
Annotation based Configuration in spring 

You can post your questions in subsequent topics if any. You can also suggest me if you would like me to add few more points in the content. 

Why Marker Interfaces ?

Why Marker or Tag interface do in Java

1) Looking carefully on marker interface in Java e.g. Serializable, Clonnable and Remote it looks they are used to indicate something to compiler or JVM. So if JVM sees a Class is Serializable it done some special operation on it, similar way if JVM sees one Class is implement Clonnable it performs some operation to support cloning. Same is true for RMI and Remote interface. So in short Marker interface indicate, signal or a command to Compiler or JVM.

This is pretty standard answer of question about marker interface and once you give this answer most of the time interviewee definitely asked "Why this indication can not be done using a flag inside a class?” this make sense right? Yes this can be done by using a boolean flag or a String but doesn't marking a class like Serializable or Clonnable makes it more readable and it also allows to take advantage of Polymorphism in Java.

Where Should I use Marker interface in Java

Apart from using built in marker interface for making a class Serializable or Clonnable. One can also develop his own marker interface. Marker interface is a good way to classify code. You can create marker interface to logically divide your code and if you have your own tool than you can perform some pre-processing operation on those classes. Particularly useful for developing API and framework like Spring or Struts.

After introduction of Annotation on Java5, Annotation is better choice than marker interface and JUnit is a perfect example of using Annotation e.g. @Test for specifying a Test Class. Same can also be achieved by using Test marker interface.

Another use of marker interface in Java

One more use of marker interface in Java can be commenting. a marker interface called Thread Safe can be used to communicate other developers that classes implementing this marker interface gives thread-safe guarantee and any modification should not violate that. Marker interface can also help code coverage or code review tool to find bugs based on specified behavior of marker interfaces.

Again Annotations are better choice @ThreadSafe looks lot better than implementing ThraedSafe marker interface.

In summary marker interface in Java is used to indicate something to compiler, JVM or any other tool but Annotation is better way of doing same thing.

Why and how hashcode - part 1

In Java, every object has a method hashCode that is simple to understand but still it’s sometimes forgotten or misused. We need to understand the real use of HashCode.

An object’s hash code allows algorithms and data structures to put objects into compartments, just like letter types in a printer’s type case. The printer puts all “A” types into the compartment for “A”, and he looks for an “A” only in this one compartment. This simple system lets him find types much faster than searching in an unsorted drawer. That’s also the idea of hash-based collections, such as HashMap and HashSet.

The hashCode contract

The contract is explained in the hashCode method’s JavaDoc. It can be roughly summarized with this statement:

Objects that are equal must have the same hash code within a running process

Please note that this does not imply the following common misconceptions:

• Unequal objects must have different hash codes – WRONG!
• Objects with the same hash code must be equal – WRONG!

Whenever you implement equals, you MUST also implement hashCode

If you fail to do so, you will end up with broken objects. Why? An object’s hashCode method must take the same fields into account as its equals method. By overriding the equals method, you’re declaring some objects as equal to other objects, but the original hashCode method treats all objects as different. So you will have equal objects with different hash codes. For example, calling contains() on a HashMap will return false, even though the object has been added.

How to write a good hashCode function is beyond the scope of this article, it is perfectly explained in Joshua Bloch’s popular book Effective Java, which should not be missing in a Java developer’s bookshelf.

Optimizing Java Code !! Performance Matters !!

General optimization techniques

Optimiziation is one of most serious concern of Java. Writing a program and generating output is altogether different than to increase the performance of application. There are different ways to making the optimization, in this blog we will be discussing few :-) 

Strength reduction

Strength reduction occurs when an operation is replaced by an equivalent operation that executes faster. The most common example of strength reduction is using the shift operator to multiply and divide integers by a power of 2. For example, x >> 2 can be used in place of x / 4, and x << 1 replaces x * 2.

Common sub expression elimination

Common sub expression elimination removes redundant calculations. Instead of writing

double x = d * (lim / max) * sx;

double y = d * (lim / max) * sy;

the common sub expression is calculated once and used for both calculations:

double depth = d * (lim / max);

double x = depth * sx;

double y = depth * sy;

Code motion

Code motion moves code that performs an operation or calculates an expression whose result doesn't change, or is invariant. The code is moved so that it only executes when the result may change, rather than executing each time the result is required. This is most common with loops, but it can also involve code repeated on each invocation of a method. The following is an example of invariant code motion in a loop:

for (int i = 0; i < x.length; i++)

 x[i] *= Math.PI * Math.cos(y);

becomes

double picosy = Math.PI * Math.cos(y);for (int i = 0; i < x.length; i++)

x[i] *= picosy;

Unrolling loops

Unrolling loops reduces the overhead of loop control code by performing more than one operation each time through the loop, and consequently executing fewer iterations. Working from the previous example, if we know that the length of x[] is always a multiple of two, we might rewrite the loop as:

double picosy = Math.PI * Math.cos(y);for (int i = 0; i < x.length; i += 2) {

x[i] *= picosy;

x[i+1] *= picosy;

}

In practice, unrolling loops such as this -- in which the value of the loop index is used within the loop and must be separately incremented -- does not yield an appreciable speed increase in interpreted Java because the bytecodes lack instructions to efficiently combine the "+1" into the array index.

All of the optimization tips in this article embody one or more of the general techniques listed above.

Some Tough Interview Questions in Java

Why wait and notify is declared in Object class instead of Thread ?

In Java in order to enter critical section of code, Threads needs lock and they wait for lock, they don't know which threads holds lock instead they just know the lock is hold by some thread and they should wait for lock instead of knowing which thread is inside the synchronized block and asking them to release lock. this analogy fits with wait and notify being on object class rather than thread in Java.

Why multiple inheritance is not supported in Java ?
Reason is ambiguity around Diamond problem, consider a class A has foo() method and then B and C derived from A and has there own foo() implementation and now class D derive from B and C using multiple inheritance and if we refer just foo() compiler will not be able to decide which foo() it should invoke. This is also called Diamond problem because structure on this inheritance scenario is similar to 4 edge diamond.


Why String is immutable in Java?
String is Immutable in Java because String objects are cached in String pool. Since cached String literals are shared between multiple clients there is always a risk, where one client's action would affect all another client. For example, if one client changes the value of String "Test" to "TEST", all other clients will also see that value as explained in the first example. Since caching of String objects was important from performance reason this risk was avoided by making String class Immutable. At the same time, String was made final so that no one can compromise invariant of String class e.g. Immutability, Caching, hashcode calculation etc by extending and overriding behaviors. Another reason of why String class is immutable could die due to HashMap. Since Strings are very popular as HashMap key, it's important for them to be immutable so that they can retrieve the value object which was stored in HashMap. Since HashMap works in the principle of hashing, which requires same has value to function properly. Mutable String would produce two different hashcodes at the time of insertion and retrieval if contents of String was modified after insertion, potentially losing the value object in the map.