SQL Tuning has a critical role in code performance. If you take SQL Tuning light, it will definitely screw up your entire code performance no matter whatever optimization you have done on your Java middle layer and front end.  Of course, its important that you should design your application in such a way that it will do your desired task with the minimal database hit. But, here we are talking about how your SQL query can be optimized so that it will take the minimum time to do your database operations (SELECT, CREATE, INSERT etc). Believe me, SQL Tuning is gonna make a BIG difference in your application’s overall performance.

Try to avoid “SELECT * FROM”

Use the actual column names to be selected in the SELECT statement instead of “SELECT * FROM”. The SQL Query becomes considerably faster if you use the actual column names in SELECT statement. Let me say, this is one among the basic lessons in SQL Tuning school (Even newbies to SQL Tuning should be aware of this).

For example:

Write the Query as

SELECT id, first_name, last_name, age, subject FROM student_details;

Instead of:

SELECT * FROM student_details;

Avoid using “HAVING” in place of “WHERE”

“HAVING” clause is used to filter the rows after all the rows are selected. It is just like a filter, do not use it as an alternative to “WHERE”

For example:

Write the Query as

SELECT subject, count(subject)
FROM student_details
WHERE subject != 'Science'

Instead of:

SELECT subject, count(subject)
FROM student_details
HAVING subject != 'Science';

Keep in mind that you have to use “HAVING” clause in some particular cases, no other go. Example: If the HAVING clause is applied to aggregate functions, it cannot be replaced by WHERE. I mean to say, just for the sake of SQL Tuning you cannot replace every “HAVING” with “WHERE”.

Minimize number of subqueries

Sometimes you may have more than one subqueries in your main query. Try to minimize the number of subquery-block in your query.

For example:

Write the query as

SELECT name
FROM employee
WHERE (salary, age ) = (SELECT MAX (salary), MAX (age)
FROM employee_details)
AND dept = 'Electronics';

Instead of:

SELECT name
FROM employee
WHERE salary = (SELECT MAX(salary) FROM employee_details)
AND age = (SELECT MAX(age) FROM employee_details)
AND emp_dept = 'Electronics';

Use operators EXISTS and IN appropriately

• Usually IN has the slowest performance.
• IN is efficient when most of the filter criteria is in the sub-query.
• EXISTS is efficient when most of the filter criteria is in the main query.

For example:

Write the query as

SELECT name, department_id
FROM department,
WHERE NOT EXISTS
(SELECT department_id
FROM employee
WHERE department.department_id=employee.department_id)

Instead of:

SELECT name, department_id
FROM department
WHERE department_id NOT IN
(SELECT department_id FROM employee)

Use “GROUP BY” instead of “DISTINCT”

This is another basic lesson in SQL Tuning. Avoid using “DISTINCT” when you can use GROUP BY

For example:

Write the query as

select col1 from table1 group by col1;

Instead of:

select distinct col1 from table1;

Use UNION ALL instead of UNION

UNION requires a sort operation to eliminate any rows that are duplicated across the two row sets. UNION ALL returns all rows, even if they are duplicated. If duplicated rows are not important, or if you are sure there won’t be any duplicate rows, using UNION ALL can avoid potentially expensive sorts, merges, and filtering operations.

For example:

Write the query as

SELECT acct_num, balance_amt
FROM debit_transactions
WHERE tran_date = `31-DEC-99'
UNION ALL
SELECT acct_num, balance_amt
FROM credit_transactions
WHERE tran_date = `31-DEC-99';

Instead of:

SELECT acct_num, balance_amt
FROM debit_transactions
WHERE tran_date = `31-DEC-99'
UNION
SELECT acct_num, balance_amt
FROM credit_transactions
WHERE tran_date = `31-DEC-99';

Avoid unnecessary use of Aggregate Functions

While considering SQL optimization, Aggregate Functions are costly, use it only if its necessary

For example:

Write the query as

SELECT id, first_name, age
FROM student_details
WHERE first_name LIKE 'Chan%';

Instead of:

SELECT id, first_name, age
FROM student_details
WHERE SUBSTR(first_name,1,3) = 'Cha';

Make use of available Operators

If operators are avilable for your desired task, use it instead of writing it on your own.

For example:

Write the query as

SELECT product_id, product_name
FROM product
WHERE unit_price BETWEEN MAX(unit_price) and MIN(unit_price);

Instead of:

SELECT product_id, product_name
FROM product
WHERE unit_price >= MAX(unit_price)
and unit_price <= MIN(unit_price);

Please note: BETWEEN operates behaves differently in different databases. For some databases BETWEEN operator will return all the value between lower and upper limit, for some databases it will return values including the upper and lower limit, for some others it will return values including either one of the limits.

Avoid Unnecessary Operations

This optimization is non specific to SQL tuning, its applicable in all sort of programming language.

For example:

Write the query as

SELECT id, name, salary
FROM employee
WHERE salary < 25000;

Instead of:

SELECT id, name, salary
FROM employee
WHERE salary + 10000 < 35000;

Join tables wisely

This is another basic lesson in SQL Tuning, the order in which tables are joined really matters alot in SQL tuning.

The order in which tables are joined normally affects the number of rows processed by that JOIN operation and hence proper ordering of tables in a JOIN operation may result in the processing of fewer rows, which will in turn improve the performance. The key to decide the proper order is to have the most restrictive filtering condition in the early phases of a multiple table JOIN.

For example, in case we are using a master table and a details table then it’s better to connect to the master table first. Connecting to the details table first may result in more number of rows getting joined. This is a very effective SQL Tuning lesson which you may come across multiple times if you are dealing with complex queries with multiple JOINs.

Two or more methods in a Java class can have the same name, provided their argument lists are different, this feature is known as Method Overloading.

Method Overloading in Java is Static Polymorphism

Overloaded methods invocation will be resolved during compile time. In other words, while compiling, when the overloaded methods are invoked JVM will choose the appropriate method based on the arguments used for invocation. For example, if the print method is invoked with an int argument, the JVM will choose the overloaded print method that accepts an int parameter.

For a valid method overloading, argument list could differ in any of this

• Data type of parameters
• Number of parameters
• Sequence of parameters (Consider only the datatype of each parameter)

Java Method overloading Example (difference in Data type of parameters)

void print(int i){
    System.out.println(i);
}
void print(double d){
    System.out.println(d);
}
void print(char c){
    System.out.println(c);
}

Java Method overloading Example (difference in Number of parameters)

void print(int i){
    System.out.println(i);
}
void print(int i,int j){
    System.out.println(i+j);
}

Java Method overloading Example (difference in Sequence of parameters)

void print(int i,String j){
    System.out.println(j+i);
}
void print(String j,int i){
    System.out.println(j+i+j);
}

If there is a difference in Sequence of datatype of parameters it’s a valid method overloading, otherwise its not. The following example is not a valid method overloading, it will throw compilation error.

void print(int i,String j){
    System.out.println(j+i);
}
void print(int j,String i){
    System.out.println(j+i);
}

Methods differing only in return type

Methods differing only in return type will NOT be treated as overloaded methods, it will result in compilation error. For Example, the below given methods will give compilation error.

void print(int i){
    System.out.println(i);
}
int print(int i)){
    System.out.println(i);
    return i;
}

Constructor Overloading

Just like other methods, constructors also can be overloaded.

public class Student{
    public Student(){
        mark = 100;
    }
    public Student(int rollNo, double mark){
        this.rollNo = rollNo;
        this.mark = mark;
    }
}

The Java enhanced For loop is a new feature which was introduced in Java 5.0/J2SE 5.0 as a simpler way to iterate through the elements (all elements) of an array or a Collection (like ArrayList). If you are using the enhanced For loop, you don’t need to use Iterator or calculate end conditions of For loop using incrementing/decrementing loop counter. Thus, enhanced for loop replaces the traditional ways of accessing elements in a collection.

The enhanced For loop is really a useful feature. The enhanced for loop is very simple structure which allows the programmer to simplify code by writing the For loops that iterates through all elements in an array or a collection without explicitly writing the code to iterate through each element. It’s not necessary that every programmer should switch to this all new enhanced for loops. As the old coding style didn’t become invalid with the new for loop syntax, you can stick to the traditional ways to iterate through the collections if you prefer. Let’s go through some examples.

When to use Enhanced For Loop.

Enhanced for loops may be simple but inflexible. You don’t have access to LoopIndex. Prefer Enhanced For Loop only

1. If you have to iterate through all the elements.
2. If you don’t need to know the loop index of the current element
3. If you need to iterate through the Collection/Array in first-to-last order.(In other words, if the order doesn’t matter to you)

In all other cases, the “standard” For loop should be preferred.

Enhanced For Loop in Array Iteration

With the new enhanced for loop, array iteration code will change something like the following:

Traditional For Loop (before Java 5.0)

for (int i=0; i < arrayOfElements.length; i++) {
    System.out.println("Element: " + arrayOfElements[i]);
}

Enhanced For Loop (Java 5.0+)

for (String element : arrayOfElements) {
    System.out.println("Element: " + element);
}

Enhanced For Loop in ArrayList Iteration

With the new enhanced For loop, ArrayList iteration code will change something like the following:

Traditional For Loop (before Java 5.0)

ArrayList<String> listOfString = new ArrayList<String>();
listOfString.add("Cpp");
listOfString.add("Java");
listOfString.add("Python");
listOfString.add("LISP");
for (int i=0; i<listOfString.size();i++){
	System.out.println(listOfString.get(i));
}

Traditional For Loop with Iterator(before Java 5.0)

ArrayList<String> listOfString = new ArrayList<String>();
listOfString.add("Cpp");
listOfString.add("Java");
listOfString.add("Python");
listOfString.add("LISP");
Iterator<String> iterator =listOfString.iterator();
for (;iterator.hasNext();){
	System.out.println(iterator.next());
}

Enhanced For Loop (Java 5.0+)

ArrayList<String> listOfString = new ArrayList<String>();
listOfString.add("Cpp");
listOfString.add("Java");
listOfString.add("Python");
listOfString.add("LISP");
for (String element : listOfString){
	System.out.println(element);
}

To read properties file in Java and get the fields from it, use the following technique. Here, we read the properties file as a stream and loads to the Properties class and use the getProperty() method to get the value from the properties. This is conventional java technique to read properties file and get the data, you can use this method to read properties file irrespective of whether you are using any java framework or not.

public Properties getBankConfigProps() {

		// Reading properties file to set Default values
		Properties bankConfig = new Properties();
		try {
			bankConfig.load(BankUtility.class.getClassLoader().getResourceAsStream("conf/configuration.properties"));
		} catch (IOException e) {
			System.out.println("Exception in getBankConfigProps: "+e);
		}
		return bankConfig;
	}

	public String getClubIdFromProps()
	{
		/* Reading properties file in Java */
		Properties bankConfig;
		bankConfig = getBankConfigProps();
		String strClubId = bankConfig.getProperty("clubId");
		System.out.println("club id is "+strClubId);
		return strClubId;
	}

And of course you should have conf/configuration.properties

clubId=northclub
someotherfields1=someothervalues1
someotherfields2=someothervalues2

But, if you are using spring dependancy injection/ Inversion of control(IOC) framework in your project, then there are much better ways to load properties file in to your java application. You can inject the properties directly to your class with spring’s dependency injection.

How to read properties file in Spring versions prior to spring 3.0

This is a really cool feature from Spring framework, you dont need to read from properties file on your own, instead spring will inject the values for you wherever you want. You just need to add a class variable to which the value should get injected(expirationOffset and expirationOffsetString)and a setter method. See the below example, spring will handle the data type also. You can declare the variable(to which you need the value to get injected from properties file) as String or int, spring will do the rest for you, you dont need to typecast it. Here, in this example its trying to load values from properties file to expirationOffset and expirationOffsetString. So your Java class will look something like this.

BankServiceImpl.java

public class BankServiceImpl implements BankService {
	private int expirationOffset;
	private String expirationOffsetString;

	public void setExpirationOffset(int expirationOffset) {
		this.expirationOffset = expirationOffset;
	}

	public void setExpirationOffsetString(String expirationOffsetString) {
		this.expirationOffsetString = expirationOffsetString;
	}

And our ApplicationContext.xml will look something like this

<!DOCTYPE beans PUBLIC
    "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="location">
			<value>file:conf/configuration.properties</value>
		</property>
	</bean>
	<bean id="bankService" class="com.blah.blah.BankServiceImpl">
		<property name="bankDAO">
			<ref bean="bankDAO" />
		</property>
		<property name="expirationOffset">
			<value>${xprnOffset}</value>
		</property>
		<property name="expirationOffsetString">
			<value>${xprnOffsetProp}</value>
		</property>
	</bean>
</beans>

<property name=”expirationOffsetString”><value>${xprnOffsetProp}</value></property> using this configurations you are saying spring framework that you need to get value of xprnOffsetProp from properties file get injected to the member variable expirationOffsetString.
<property name=”expirationOffset”><value>${xprnOffset}</value></property>using this configurations you are saying spring framework that you need to get value of xprnOffset from properties file get injected to the member variable expirationOffset.

And your properties file will look something like this

conf/configuration.properties

xprnOffset= 7
xprnOffsetProp= Hello
someotherfields1=someothervalues1
someotherfields2=someothervalues2

So when you run this application, while instantiating BankServiceImpl class, spring framework will inject expirationOffset and expirationOffsetString for you.

How to read properties file in Spring versions 3.0 +

In spring 3.0+ versions, its more easy, you don’t need to do all this setter method circus, instead you can use autowiring and annotations and all new Spring Expression Language (SpEL). you dont need to define the bean configurations, instead <context:component-scan base-package=”com.blah.blah”/> will take care of that.

So your ApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
    http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>
    <context:component-scan base-package="com.blah.blah"/>
    <context:property-placeholder location="conf/config.properties"/>
</beans>

and in the java class where you intend to get the value injected by annotations, add this

private @Value("${xprnOffset}") int expirationOffset;
private @Value("${xprnOffsetProp}") int expirationOffsetString;

use the same conf/configuration.properties

xprnOffset= 7
xprnOffsetProp= Hello
someotherfields1=someothervalues1
someotherfields2=someothervalues2

your member variable expirationOffset will get injected with the value 7.
your member variable expirationOffsetString will get injected with the value “Hello”.

Spring Interview Questions Index

What is Spring framework ?
What is Dependency Injection/Inversion Of Control(IOC) in Spring framework ?
What are the different types of Inversion of Control or dependency injection ?
What are the different types of Spring dependency injection ?
What are the advantages or Pros of IOC (Dependency Injection) ?
What are the pros or benefits of Spring framework ?
What are the various modules in Spring?

1. What is Spring framework ?

Spring framework is an open source Java application framework created to ease developers effort by addressing the enterprise application development complexity. The beauty of Spring framework is it’s layered architecture which allows the programmer to be selective about which all spring components he wants. And Spring also provides a cohesive framework for Java Enterprise application development. Spring framework comprises of several modules that provide different services such as Spring IOC(dependency injection)framework, Spring MVC, Spring data access framework, Spring validator framework etc. In fact, it’s a common practice in Software industry to use struts MVC together with spring IOC framework, so whenever you mention about Spring framework you can be more specific like spring IOC framework or Spring MVC framework.
2. What is Dependency Injection/Inversion Of Control(IOC) in Spring framework ?

You can expect this question, this one among the common Spring Interview Questions.

The basic concept of the Dependency Injection or Inversion of Control is that, programmer do not need to create the objects, instead just describe how it should be created. 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.

In other words, while applying Inversion Of Control, at the time of object creation, objects are given their dependencies by some external entity that coordinates each object in the system. That means, dependencies are injected into objects at the time of their creation. So, Inversion of Control means an inversion of responsibility with regard to how an object obtains references to collaborating objects.
3. What are the different types of Inversion of Control or dependency injection ?

There are three different types of Inversion of Control or dependency injection:

• Setter Injection: Dependencies are injected through JavaBeans properties (ex: setter/Getter methods in bean objects).
• Constructor Injection: Dependencies are assigned as constructor parameters.
• Interface Injection: Injection is done through an interface.

Constructor and Setter Injection are the two dependency injection method which Spring supports.
4. What are the different types of Spring dependency injection ?

As I said earlier, its Setter Injection and Constructor Injection

• Setter Injection: Dependencies are provided through JavaBeans properties (ex: setter/Getter methods in bean objects).
• Constructor Injection: Dependencies are assigned as constructor parameters.

5. What are the advantages or Pros of IOC (Dependency Injection) ?

Advantages of Dependency Injection/Inversion of Control are as follows:

• Dependency Injection minimizes the amount of code in any application. Dependency is handled by the framework itself
• Dependency Injection makes developers life easier. With Inversion of Control containers developers do not need to think about how services are created and how to get references to the ones he needs.
• Easily scalable applications. It’s very easy to add additional services by adding a new constructor or a getter/setter method with a minimal configuration. With Spring Framework 3.0, its even easier as <context:component-scan base-package=”com.blah.blah”/> will do everything for you, you don’t need to add getter and setter method and beans for each dependency injection, just autowire the services wherever it needed.<Read how spring 3.0 made a developers life easier>
• Dependency Injection makes your application more test-friendly by not demanding any JNDI lookup mechanisms or singletons in your test cases. IOC containers make testing and switching implementations easy by allowing you to inject your own objects into the object under test.
• Comparing to other options like factory design pattern the IOC container is injecting the dependency into requesting piece of code where as the factory design pattern is more intrusive and components or services need to be requested explicitly.
• IOC containers support eager instantiation and lazy loading of services.
• IOC Containers provide support for instantiation of cyclical dependencies, managed objects, life cycles management and dependency resolution between managed objects etc.

6. What are the pros or benefits of Spring framework ?

This is one among the common Spring Interview Questions

The pros of Spring framework are as follows:

• Spring is an open source framework and free to download.
• Spring has layered architecture. You can select the feature you wants, as I said before you can have Struts MVC and Springs IOC container in one application itself. Eventhough spring has MVC framework if you want you can opt out.
• Spring Enables Plain Old Java Object (POJO) Programming. POJO programming enables continuous integration and testability.
• Dependency Injection is really cool stuff, spring 3.0 onwards the introduction of component-scan/autowiring and Spring Expression Language makes it even spicier.
• spring is lightweight.

7. What are the various modules in Spring?

Spring comprises of seven different modules. They are as follows

Inversion of Control container/ The core container
The core container/IoC container handles the configuration of application components and lifecycle management of Java objects. It is responsible for the Dependency Injection. Inversion of Control container provides the essential functionality of the Spring framework. A primary component of the core container is the BeanFactory, an implementation of the Factory pattern. The BeanFactory applies the IOC pattern to separate an application’s actual application code and configuration and dependency specification.

Spring context
The Spring context is a configuration file that provides context information to the Spring framework. The Spring context includes enterprise services such as JNDI, EJB, e-mail, internalization, validation, and scheduling functionality.

Spring AOP -Aspect oriented programming
The Spring AOP module integrates aspect-oriented programming functionality directly into the Spring framework through its configuration management feature. Spring AOP enables implementation of cross-cutting routines. As a result you can easily enable aspect oriented programming in any object managed by the Spring framework. The Spring AOP module provides transaction management services for objects in any Spring-based application. With Spring AOP you can incorporate declarative transaction management into your applications without relying on EJB components.

Spring DAO -Data access
The Spring JDBC DAO abstraction layer offers an exception hierarchy for managing the exception handling and error messages thrown by different database vendors. The exception hierarchy simplifies error handling and greatly reduces the amount of exception code you need to write, such as opening and closing connections. Spring DAO’s JDBC-oriented exceptions comply to its generic DAO exception hierarchy.Spring DAO is working with relational database management systems on the Java platform using JDBC and object-relational mapping tools and with NoSQL databases

Spring ORM
The Spring framework plugs into several ORM frameworks to provide its Object Relational tool, including JDO, Hibernate, and iBatis SQL Maps. All of these comply to Spring’s generic transaction and DAO exception hierarchies.

Spring Web module
The Web context module builds on top of the application context module, providing contexts for Web-based applications. As a result, the Spring framework supports integration with Jakarta Struts. The Web module also eases the tasks of handling multi-part requests and binding request parameters to domain objects.

Spring MVC framework
The Model-View-Controller (MVC) framework is a full-featured MVC implementation for building Web applications. The MVC framework is highly configurable via strategy interfaces and accommodates numerous view technologies including JSP, Velocity, Tiles, iText, and POI.

Keep 3 things in mind before doing properties injection into a bean via Annotations.

1. Injection of values using component-scan will not work on Spring versions prior to 3.0
2. If you are using previous versions of spring framework (older than Spring 3.0), you could have either bundle up your value types in a reference type and inject the reference type or define the bean explicitly. Before Spring 3.0 framework, there was no option to inject values using component-scan (or in other words autowiring).
3. Once Spring 3.0 is launched you can inject property value into Spring bean using the all new Spring Expression Language (SpEL).

ApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
	http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

	<context:annotation-config/>
	<context:component-scan base-package="com.blah.blah"/>
	<context:property-placeholder location="conf/config.properties"/>
</beans>

and config.properties

expirationOffset = 7
someotherValues=45
someothervalue=33

and in the java class where you intend to get the value injected by autowiring, add this

private @Value("${expirationOffset}") int exprnOffset;

your member variable exprnOffset will get injected with the value 7.

Another Approach to Inject values in Spring

Instead of <context:property-placeholder location=”conf/config.properties”/> you can use the old conventional bean definition

<bean id=”config” class=”org.springframework.beans.factory.config.PropertyPlaceholderConfigurer”>
<property name=”location”><value>file:conf/config.properties</value></property>
</bean>

If you want to do it this way, your  applicationContext.xml will look like this

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
	http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

	<context:annotation-config/>

	<context:component-scan base-package="com.blah.blah"/>
	<bean id="config" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    	<property name="location"><value>file:conf/config.properties</value></property>
	</bean>

</beans>

This java code will generate 8 or 9 digit alphanumeric code which contains only capital letters. Here, we are basically converting a base10(decimal) literal to base36 literal(alphanumeric). If your system is able to distinguish between capital letters and small letters, you can go for base62(26 Capital letters+26 Small letters+10 integers) conversion instead which will make your unique alphanumeric code even shorter.

	//Java code to generate 8 or 9 digit alphanumeric code
	private String generateAuthCode() {
		System.out.println("Entering generateAuthCode()");
		//getting the current time in milliseconds
		Date date=new Date();
		long decimalNumber=date.getTime();
		System.out.println("current time in milliseconds: "+decimalNumber);

		//To convert time stamp to alphanumeric code.
		//We need to convert base10(decimal) to base36
		String strBaseDigits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
		String strTempVal = "";
        int mod = 0;
        // String concat is costly, instead we could have use stringbuffer or stringbuilder
        //but here it wont make much difference.
        while(decimalNumber!= 0){
            mod=(int) (decimalNumber % 36);
            strTempVal=strBaseDigits.substring(mod,mod+1)+strTempVal;
            decimalNumber=decimalNumber/36;
        }
        System.out.println("alphanumeric code generated from TimeStamp : "+strTempVal);
        return strTempVal;

}

If your system is having any restrictions such that it needs 8 Digit unique Alphanumeric code, you can trim the leading edge so that the generated code will be matching your requirement of 8 Digits, provided your alphanumeric code can get repeated in some decades.

To trim the generated alphanumeric code you can use the following approach.

			String strAuthCode=generateAuthCode();
			//Generated alphanumeric code can be longer than 8 digit, if thats the case we will trim the leading edge.
			//So that it will take decades to repeat the same alphanumeric code
			while(strAuthCode.length()>8){
				log.info("Generated alphanumeric code is long. Trimming it to 8 digits");
				strAuthCode=strAuthCode.substring(1);
			}
			System.out.println("AuthCode : "+strAuthCode);

JEE Architecture Diagram

J2EE application tiers are as follows

• Client Tier (Web Browser or any other kinds of clients)
• Web tier
• Business Tier
• Enterprise Information tier (Database or sometimes XMLs or flatfiles)

Various JEE Components

Components are self contained piece of software that are reusable across applications and are configurable external to the source code.
J2EE components are of three types : client component, web component and business component. The client components interact with the user, the web components interact with the web browsers using the HTTP protocol, and the business components interact with the application server and execute the business logic.

Client components is of two types : web client and application client.

• A web client, generally a browser, sends a request to the server and renders the webpage sent back by the server. However, it may not perform any complex tasks such as querying a database or performing any complicated business tasks and hence is also referred to as thin client. The complex tasks are performed on the server. For displaying web pages with applets, the web clients may require Java plug-ins and security policy files for executing the applets.
• An application client is a standalone application that doesn’t run in browsers. It can access components in the business tier directly. Note that web clients that require access to a servlet running in the Web tier can open an HTTP connection with the servlet.

Web components for java are Servlets and JavaServer Pages (JSP). A servlet receives HTTP requests from the client, processes them, and returns the output. It can also generate dynamic responses. Similar to servlets, JSP also create dynamic web pages. JSP pages are converted into servlets and executed within a servlet container. They are used to display the results processed by a servlet.

Business components implement the business logic or the functional process logic that defines the business rules and constraints. For example business process such as withdrawing amount from the bank. Business components are of three types : session beans, entity beans, and message-driven beans. Session beans represent a session with a client. Being a transient object, they lose their data on completion of the session. On the other hand, entity beans are persistent objects and so retain data even after the session. They represent a row of data in a database table. Message-driven beans are for receiving the receiving Java Message Service (JMS) messages asynchronously.

In Java, an object which is no longer referred by any reference variable will automatically be removed from the memory, this process is known as Garbage Collection. Garbage Collection is automatically done by Java Virtual Machine (JVM), the automatic Garbage Collection of Java de-allocates the dynamic memory when this memory is no more used by the program. Thus the Garabage collection feature of Java relieves the programmer from the overhead of memory de-allocation.(A major difficulty in dynamic memory allocation in C/C++ was that the programmer is responsible for de-allocating the dynamic memory at the right time. Even though experienced programmers can do this very well, beginners and average programmers often miss the statements for de-allocation which leads to memory-leak in many systems.)

How Garbage collection in Java works

If a reference variable is declared within a function, the reference is invalidated soon as the function call ends. Or programmer can explicitly set the reference variable to null to indicate that the referred object is no longer in use. And then Garbage collector will claim the memory allotted for that.

Please note: Primitive data types are not objects and they cannot be assigned null.

Application client container
Application client container is the one which is responsible for managing the application client components. Both application client and its container resides at the client machine and are executed on the client end. Example of application container is JVM.

Applet container
Applet container is the container to manage the execution of applets. Examples of an applet container include Web browser and applet viewer.

Enterprise JavaBeans (EJB) container
Enterprise JavaBeans (EJB) container is used to manage the execution of EJB component of the J2EE application. Both the EJBs and its container run on the J2EE server. J2EE server provides the EJB container, and an example of J2EE server is WebLogic.

Web container
Web container is used to manage the execution of the Servlets and the JSP. Both the Web components and its container run on the J2EE server. An example of a web container is Tomcat.

• Life cycle Management- Creating and deleting components
• Persistence- Saving information in the components
• Naming- Recording the name of a server component and locating it for the client.
• Deployment- Placing components in the server
• Messaging- Exchanging information between components.