Java Rocks!!!

How to add BASIC Authentication into HttpURLConnection?

2011-08-10T03:34:00.001+05:30

Here is one sample.

...
try {
//Create connection
url = new URL(targetURL);
connection = (HttpURLConnection)url.openConnection();
connection.setRequestMethod("POST");
...
BASE64Encoder enc = new sun.misc.BASE64Encoder();
String userpassword = username + ":" + password;
String encodedAuthorization = enc.encode( userpassword.getBytes() );
connection.setRequestProperty("Authorization", "Basic "+
encodedAuthorization);
...
//Send post data
...

} catch (Exception e) {
...
} finally {

if(connection != null) {
connection.disconnect();
}
}
}
...

How to Use JDBC Java to Create Table?

2011-08-10T03:33:00.002+05:30

his example demonstrates how to create a table in JDBC in MySQL database.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCCreateTable {

private static final String DBURL =
"jdbc:mysql://localhost:3306/mydb?user=usr&password=sql&" +
"useUnicode=true&characterEncoding=UTF-8";
private static final String DBDRIVER = "org.gjt.mm.mysql.Driver";

static {
try {
Class.forName(DBDRIVER).newInstance();
} catch (Exception e){
e.printStackTrace();
}
}

private static Connection getConnection()
{
Connection connection = null;
try {
connection = DriverManager.getConnection(DBURL);
}
catch (Exception e) {
e.printStackTrace();
}
return connection;
}

public static void main(String[] args) {
Connection con = getConnection();
Statement stmt =null;
String createString;
createString = "CREATE TABLE `mydb`.`employees` ("+
"`EmployeeID` int(10) unsigned NOT NULL default '0',"+
"`Name` varchar(45) collate utf8_unicode_ci NOT NULL default '',"+
"`Office` varchar(10) collate utf8_unicode_ci NOT NULL default '',"+
"`CreateTime` timestamp NOT NULL default CURRENT_TIMESTAMP,"+
"PRIMARY KEY (`EmployeeID`)"+
") ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;";
try {
stmt = con.createStatement();
stmt.executeUpdate(createString);
} catch(SQLException ex) {
System.err.println("SQLException: " + ex.getMessage());
}
finally {
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
System.err.println("SQLException: " + e.getMessage());
}
}
if (con != null) {
try {
con.close();
} catch (SQLException e) {
System.err.println("SQLException: " + e.getMessage());
}
}
}
}

}

How to read input from console (keyboard) in Java?

2011-08-10T03:31:00.001+05:30

There are few ways to read input string from your console/keyboard. The following smaple code shows how to read a string from the console/keyboard by using Java.

public class ConsoleReadingDemo {

public static void main(String[] args) {

// ====
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Please enter user name : ");
String username = null;
try {
username = reader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("You entered : " + username);

// ===== In Java 5, Java.util,Scanner is used for this purpose.
Scanner in = new Scanner(System.in);
System.out.print("Please enter user name : ");
username = in.nextLine();
System.out.println("You entered : " + username);

// ====== Java 6
Console console = System.console();
username = console.readLine("Please enter user name : ");
System.out.println("You entered : " + username);

}
}

The last part of code used java.io.Console class. you can not get Console instance from System.Console() when running the demo code through Eclipse. Because eclipse runs your application as a background process and not as a top-level process with a system console.

Why we call start() method which in turns calls run method, why not we directly call run method ?

2011-08-10T03:17:00.001+05:30

In both the above examples, the run() method is the most important method in the thread classes, it is also the only method that we need to implement in both cases. Why it's only proper to call the start() method to start the thread instead of calling the run() method directly? Because the run() method is not a regular class method. It should only be called by the JVM. Writing thread classes is not about a single sequential thread, it's about the use of multiple threads running at the same time and performing different tasks in a single program. The JVM needs to work closely with the underneath operating system for the actual implementation of concurrent operations. This is how the performance can be improved, and all other benefits mentioned above can be achieved.

You should not invoke the run() method directly. If you call the run() method directly, it will simply execute in the caller's thread instead of as its own thread. Instead, you need to call the start() method, which schedules the thread with the JVM. The JVM will call the corresponding run() method when the resources and CPU is ready. The JVM is not guaranteed to call the run() method right way when the start() method is called, or in the order that the start() methods are called. Especially for the computers have a single processor, it is impossible to run all running threads at the same time. The JVM must implement a scheduling scheme that shares the processor among all running threads. This is why when you call the start() methods from more than one thread, the sequence of execution of the corresponding run() methods is random, controlled only by the JVM.

Java JDBC Transaction Isolation Levels

2011-08-01T06:31:00.000+05:30

Generally speaking, as the isolation levels become more restrictive, the performance of the system decreases because transactions are prevented from accessing the same data. If isolation levels are very restrictivein other words, if they are at the Serializable levelthen all transactions, even simple reads, must wait in line to execute. This can result in a system that is very slow. J2EE server that process a large number of concurrent transactions and need to be very fast will therefore avoid the Serializable isolation level where it is not necessary.

Read Uncommitted
The transaction can read uncommitted data (i.e., data changed by a different transaction that is still in progress). Dirty reads, nonrepeatable reads, and phantom reads can occur. Bean methods with this isolation level can read uncommitted changes.

Read Committed
The transaction cannot read uncommitted data; data that is being changed by a different transaction cannot be read. Dirty reads are prevented; nonrepeatable reads and phantom reads can occur. Bean methods with this isolation level cannot read uncommitted data.

Repeatable Read
The transaction cannot change data that is being read by a different transaction. Dirty reads and nonrepeatable reads are prevented; phantom reads can occur. Bean methods with this isolation level have the same restrictions as those in the Read Committed level and can execute only repeatable reads.

Serializable
The transaction has exclusive read and update privileges; different transactions can neither read nor write to the same data. Dirty reads, nonrepeatable reads, and phantom reads are prevented. This isolation level is the most restrictive.

Note: J2EE Isolation level on connections used by CMP beans
In a EJB 2.x or EJB 3.0 module, when a CMP bean uses a new data source to access a backend database, the isolation level is determined by J2EE Application Server run time, based on the type of access intent assigned to the bean or the calling method. Other non-CMP connection users can access this same data source and also use the access intent and application profile support to manage their concurrency control.

Interview Tips

2011-08-01T06:15:00.001+05:30

Hello All, Today I came across very interesting site where we can find interesting interview tips for different types of interviews

Read more......

Struts / Java / J2EE Frequently-Asked Interview Questions

2010-10-29T15:06:00.001+05:30

Are Struts's action classes Thread-safe?
Yes. Action classes are based on "one-instance and many-threads". This is to conserve resources and to provide the best possible throughput.

What are the various Struts Tag libraries?
There are various struts tags. But the most-repeated tags are:
struts-bean.tld
struts-html.tld
struts-logic.tld
struts-nested.tld

What is ActionMapping in struts?
Action mapping defines the flow of one request. The possible sequence is
User -> request -> Form -> Validation -> Business Code -> Forward -> JSP -> response -> User.
The components involved are Action classes, Forms and JSP.

What are the advantages of having multiple struts-config in the same application?
The implementation with many struts-config is to organize the development work, so that many people may be involved and it is some organized way of doing things. But this would result in some compromise in performance(speed). Technically there is no any difference between single and multiple struts-config files.

What are the ways in which resource file can be used in struts?
Defining message resources in struts-config file.
Programmatically using resource files in Java classes or in JSP files.

Explain the term 'architecture of the application'?
Architecture is the set of rules (or framework) to bring in some common way of assembling or using J2EE components in the application. This helps in bringing consistency between codes developed by various developers in the team.

Which is the architecture followed by struts?
Struts follows MVC architecture.

What are components corresponding o M, V and C in struts?

Model : The model represents the data of an application. Anything that an application will persist becomes a part of model. The model also defines the way of accessing this data ( the business logic of application) for manipulation. It knows nothing about the way the data will be displayed by the application. It just provides service to access the data and modify it. Here 'Form Bean' represents Model layer.

View : The view represents the presentation of the application. The view queries the model for its content and renders it. The way the model will be rendered is defined by the view. The view is not dependent on data or application logic changes and remains same even if the business logic undergoes modification. JSP represents View Layer.

Controller : All the user requests to the application go through the controller. The controller intercepts the requests from view and passes it to the model for appropriate action. Based on the result of the action on data, the controller directs the user to the subsequent view. Action classes (action servlets) represent Controller layer.

Differentiate between the terms 'Design Patterns', 'Framework' and 'Architecture'.
Design Pattern: The various solutions arrived at for the known problem. This helps to avoid re-inventing the wheel. The risk-free solution can be easily used by others. For example, singleton is the design pattern that you can use instantly to enfore one object per class. You do not need to think of this on your own.
Framework: A framework is a structure or set of rules, used to solve or address complex issues. It is basically a reusable designf for the J2EE applications. For example, Struts, JSF,etc., are the frameworks. You can use these frameworks based on the requirements of your application and each has its own set of advantages.

Architecture: It is a design that describes how the various components in the application fit together. For example, MVC is an architecture which is helpful to define how the components interact within the application.

What is the difference between ActionForm and DynaActionForm?
In action form, you need to define the form class that extends ActionForm explicitly, whereas you can define the form dynamically inside the struts-config file when using DynaActionForm.

How can you use Validator framework in struts?
Validator Frameworks are helpful when the application needs server-side validation such that the particular set of validations occur very frequently within the same application. This avoids writing complex code in validation() method in every form bean. Using validator framework, there are different pre-written validations in place. You can customize these validations in XML file.

What are client-side and server-side vaidations?
Client-side validations: These are the validations that id done using javascripts. There is always a danger involved that the user can get through (crack-through) these validations. But for some simple validations, like converting lower-case to upper-case or date validations can be done, you can use javascripts.
Server-side validations: These are the validations done in server-side using Java components (Form bean or in business logics) where the user has no chance to crookedly get through the system.

What are the advantages & differences between using validate() method in form over validations using validator framework.
Refer to the previous-answer.

Define the terms authentication and authorisation.
Authentication is the process/rule that validates if the user is allowed to access the system or not.
Authorization is the process/rule that validates if the user is allowed to access the particular part of the system or not. This occurs after user's successful authentication.

What are the components provided in J2EE to perform authentication and authorization?
Authentication – RequestProcessor and/or Filter.
Authorization - DTO, JDO or Java or Action classes.

Give the difference between between 'DispatchAction' and 'Action'.
A DispatchAction contains various different methods other than the standard execute() method in Action classes. These methods are executed based on some request parameter. For example, you can code in such a way that three buttons (namely Insert, Delete, Update) buttons correspond to different methods such as insert(), delete() and udpate(). The submit button in JSP would have the property that has the value which matches to any one of the methods defined in DispatchAction class.

What is pagination technique? How can you design them in struts?
Pagination is the technique where the bulk of results are split into different pages and only the information where the user can conveniently see are displayed in a page. (Like in Goooooogle). This can be achieved in many ways, but the simplest method is to have a query string (say http://www.testwebsite?pageNumber=2) would lead to information corresponding to resultset rows from 11 to 20. Assuming that you want to display 10 related rows of information, you can set the formula as follows:
Starting row = (pageNumber-1) * + 1 which is equal to 11.
Ending row = Starting row + which is equal to 20.

How can you populate the drop-down list using form properties?
There are many ways for this. But the best method is to use which defines collection that needs to be used to populate the drop-down list, the property to store the selected value and the collection that is used to display the labels (what we see in JSP page). For Example,

html:options collection="form-collection-property"
property="form-property"
labelProperty="form-another-collection-property"

What is the XML parser provided in struts? Can you use it for other purposes?
'Digester' framework. Yes we can use for our applications to store and parse our application-related data.

Difference between Struts 1.0 and 1.1

Perform() method was replaced by execute()
DynaActionForms are introduced.
Tiles Concept is introduced
We can write our own Controller by Inheriting RequestProcessor

Advanced J2EE Concepts - Implementing Internationalization in Struts

2010-10-29T15:02:00.002+05:30

How is 'Internationalization' implemented in struts?

Default Internationalization (Detected based on Browser's settings):

Internationalization is an important concept of making the application to be compatible with different geographical location and user-friendly with respect to their location by means of providing the information in their preferred language.

In struts, it can be done quite easily. The application resource file name can be extended with underscore followed by locale.

For example ,

When your application contains the file "ApplicationResource_en.properties", it would mean that it supports english language. When another file "ApplicationResource_fr.properties" exists, it would mean the localization for 'French'.

The selection of file and the content is done and decided automatically by struts. When the browser's setting is found with French settings, then struts automatically retrieves the value for the specific key from the appropriate resource file. Similarly you can add multiple property files for various locale.

But please remember that you can have one property file name with different extensions like _en, _fr, _de, etc., If they differ, the internationalization will not work. Also that only one file (one time), is specified in struts-config.xml. Each property file must have the same key with different values as follows:

In ApplicationResources.properties_en, you specify mainpage.welcome=Hi, You are welcome..

In ApplicationResources.properties_fr, you specify mainpage.welcome=< message in French >

Programmatic implementation of Internationalization (By manual selection)

The localization can even be done programmatically by placing 'Locale' object in session.
session.setAttribute("org.apache.struts.action.LOCALE", new Locale("fr"));

For example, You can create links one for each country's localization in the main page. Each link leads to an action class with different query string such as

<A HREF="setCountry?lang=en" > English <A>

<A HREF = "setCountry?lang=de"> German <A>

<A HREF="setCountry?lang=fr"> French <A>

When clicked, the action is called. Inside the action class you retrieve the lang parameter as follows

String lang = request.getParamter("lang");

if (lang.equals("fr"))

session.setAttribute("org.apache.struts.action.LOCALE", new Locale("fr"));

if (lang.equals("de"))
session.setAttribute("org.apache.struts.action.LOCALE", new Locale("de"));

-------------------------------------------------------------

Hope this explains the concept of internationalization.

Six Interview Mistakes

2010-10-25T15:23:00.002+05:30

It's tough to avoid typical interview traps if you're unsure what they are. Here are a half dozen to watch out for.

1. Confusing an Interview with an Interrogation.

Most candidates expect to be interrogated. An interrogation occurs when one person asks all the questions and the other gives the answers. An interview is a business conversation in which both people ask and respond to questions. Candidates who expect to be interrogated avoid asking questions, leaving the interviewer in the role of reluctant interrogator.

2. Making a So-Called Weakness Seem Positive.

Interviewers frequently ask candidates, "What are your weaknesses?" Conventional interview wisdom dictates that you highlight a weakness like "I'm a perfectionist," and turn it into a positive. Interviewers are not impressed, because they've probably heard the same answer a hundred times. If you are asked this question, highlight a skill that you wish to improve upon and describe what you are doing to enhance your skill in this area. Interviewers don't care what your weaknesses are. They want to see how you handle the question and what your answer indicates about you.

3. Failing to Ask Questions.

Every interview concludes with the interviewer asking if you have any questions. The worst thing to say is that you have no questions. Having no questions prepared indicates you are not interested and not prepared. Interviewers are more impressed by the questions you ask than the selling points you try to make. Before each interview, make a list of five questions you will ask. "I think a good question is, 'Can you tell me about your career?'" says Kent Kirch, director of global recruiting at Deloitte. "Everybody likes to talk about themselves, so you're probably pretty safe asking that question."

4. Researching the Company But Not Yourself.

Candidates intellectually prepare by researching the company. Most job seekers do not research themselves by taking inventory of their experience, knowledge and skills. Formulating a talent inventory prepares you to immediately respond to any question about your experience. You must be prepared to discuss any part of your background. Creating your talent inventory refreshes your memory and helps you immediately remember experiences you would otherwise have forgotten during the interview.

5. Leaving Your Cell Phone On.

We may live in a wired, always-available society, but a ringing cell phone is not appropriate for an interview. Turn it off before you enter the company.

6. Waiting for a Call.

Time is your enemy after the interview. After you send a thank-you email and note to every interviewer, follow up a couple of days later with either a question or additional information. Try to contact the person who can hire you, and assume that everyone you met with has some say in the process. Additional information can be details about your talents, a recent competitor's press release or industry trends. Your intention is to keep everyone's memory of you fresh.

Java Exceptions and Error Handling Interview Questions

2010-10-25T15:01:00.000+05:30

Q: What do you mean by exception and error handling?

A: When a program encounters and un-expected situation from where it cannot continue the normal flow, it can break from the normal execution flow by throwing and exception or an error.

Q: What is the difference between an Error and an Exception?

A: An Exception is an unexpected scenario from which the program can recover but an error means that the program has encountered an unrecoverable problem.

Q: Can you give an example of an unrecoverable problem when error is thrown?

A: Yes, when a java program runs out of memory it is a problem from which the program cannot recover and OutOfMemoryError will be thrown.

Q: Does it mean that when error is thrown, we cannot catch it and continue execution?

A: We can catch errors, but it is not advised to do that because when error happens it means that some unrecoverable problem has happened. Even if we catch the error, we cannot guarantee the stability of the application and something else might fail.

Q: What are the different kinds of Exceptions?

A: Checked Exceptions and Unchecked Exceptions.

Q: What are runtime Exceptions?

A: Un Checked Exceptions are also known as Runtime Exceptions.

Q: What do you mean by Checked Exceptions?

A: Checked exceptions are those exceptions which have to be explicitly handled in the code.

Q: Can we create our own checked exceptions?

A: Yes, we just have to extend the Exception class or any of its sub classes (except RuntimeException)

Q: How can we create our own runtime exception?

A: We have to extend the RuntimeException class or any of its sub classes.

Q: How can we create our own Errors?

A: We have to extend the Error class.

Q: What are the different approaches of Exception handling?

A: We can use Try Catch block or we can declare the exception in the method definition's throws clause

Q: Explain the difference between the two approaches of exception handling

A: We use the try catch clause where we want to process the exception and perform some action like displaying an error message. When an exception is caught using the catch clause, it will not be propagated to the caller.

We declare the exception in the throws clause of the calling method when the exception has to be propagated to the caller and the exception is supposed to be handled by the caller.

Q: What is finally?

A: Finally is also a block like catch block to be used with the try block. Control will come to finally block irrespective of whether exception was thrown or not.

Q: What is the difference between catch and finally?

A: When a catch block is used, we have to mention what exception has to be caught in the catch clause; where as in finally we need not mention anything. Code in the catch block is executed only when the exception is thrown whereas the code in finally is executed irrespective of whether exception was thrown or not.

Q: Can we have a try block without a catch block?

A: yes, then we must have a finally block. When try block is used, we must use either a catch block or a finally block or both.

Q: What happens when we use only try and finally block without a catch block?

A: When catch block is not used, the exceptions that are thrown will not be caught and the exception will be propagated to the caller, but before the exception is propagated, the code in the finally block will be executed.

Q: When do you use a catch block and when do you use a finally block?

A: We use a catch block when we want to handle the exception scenario. We use a finally block alone when we want to do some cleanup but at the same time propagate the exception to the caller. We use a finally block together with a catch block when we want to do something irrespective of what exception is thrown.

Q: what will happen if we return from the try block, will the finally block get executed?

A: yes, after the return statement in the try block is executed, the statements in the finally block will be executed before the control goes to the calling method.

Q: What happens when we have a return statement in the try block as well as in the finally block.

A: when we have return statement both in try and finally blocks, then first the return statement of try block gets executed, the before the method returns, the statements in the finally block will get executed and since there is return statement in finally also, that will also get executed and the value that will be returned to the caller will be the value returned from the finally block.

Q: If I write System.exit (0); at the end of the try block, will the finally block still execute?

A: No.

Q: Can I have more than one catch block following a try block?

A: yes,

Q: what are the rules for having multiple catch blocks?

1) Each exception can be caught only once.

2) The catch block for sub class exceptions should come before e the catch block for parent class exceptions for example, FileNotFoundException extends IOException, so the catch block for FileNotFoundException should come before the catch block for IOException.

Q: Suppose I have a class A that has a method X which throws FileNotFoundException. I have a class B that extends class A and the method X is overridden in B. In the ovverriden method X in class B can I throw IOException?

A: No, because FileNotFoundException is a subclass if IOException and in the overridden method X in class B we can throw only FileNotFoundException or any other exception that extends FileNotFoundException.

Q: Is the above rule logical?

A: yes, the above rule is logical because java supports runtime polymorphism and at runtime an object of type B can be assigned to a variable of type A because B extends A, and when the method X is called on the variable of type A, the compile only check that the calling method should either catch or declare the exception that method X in class A is throwing, and if the method X in class B throws IOException, and the caller is handling only FileNotFoundException, then the exception will escape unhandled.

This message contains information that may be privileged or confidential and is the property of the Capgemini Group. It is intended only for the person to whom it is addressed. If you are not the intended recipient, you are not authorized to read, print, retain, copy, disseminate, distribute, or use this message or any part thereof. If you receive this message in error, please notify the sender immediately and delete all copies of this message.

What are Java Comparators and Comparables?

2010-10-25T14:40:00.001+05:30

As both names suggest (and you may have guessed), these are used for comparing objects in Java. Using these concepts; Java objects can be
sorted according to a predefined order.

Two of these concepts can be explained as follows.

Comparable

A comparable object is capable of comparing itself with another object. The class itself must implements the java.lang.Comparable interface in order to be able to compare its instances.

Comparator

A comparator object is capable of comparing two different objects. The class is not comparing its instances, but some other class's instances. This comparator class must implement the java.util.Comparator interface

Advantages of Hibernate

2010-10-25T14:18:00.001+05:30

Caching objects. The session is a transaction-level cache of persistent objects. You may also enable a JVM-level/cluster cache to memory and/or local disk.

Executing SQL statements later, when needed. The session never issues an INSERT or UPDATE until it is actually needed. So if an exception occurs and you need to abort the transaction, some statements will never actually be issued. Furthermore, this keeps lock times in the database as short as possible (from the late UPDATE to the transaction end).

Never updating unmodified objects. It is very common in hand-coded JDBC to see the persistent state of an object updated, just in case it changed…..for example, the user pressed the save button but may not have edited any fields. Hibernate always knows if an object's state actually changed, as long as you are inside the same (possibly very long) unit of work.

Efficient Collection Handling. Likewise, Hibernate only ever inserts/updates/deletes collection rows that actually changed.

Rolling two updates into one. As a corollary to (1) and (3), Hibernate can roll two seemingly unrelated updates of the same object into one UPDATE statement.

Updating only the modified columns. Hibernate knows exactly which columns need updating and, if you choose, will update only those columns.

Outer join fetching. Hibernate implements a very efficient outer-join fetching algorithm! In addition, you can use subselect and batch pre-fetch optimizations.

Lazy collection initialization.

Lazy object initialization. Hibernate can use runtime-generated proxies (CGLIB) or interception injected through bytecode instrumentation at build-time.

A few more (optional) features of Hibernate that your handcoded JDBC may or may not currently benefit from

second-level caching of arbitrary query results, from HQL, Criteria, and even native SQL queries
efficient 'PreparedStatement' caching (Hibernate always uses 'PreparedStatement' for calls to the database)
JDBC 2 style batch updates
Pluggable connection pooling

Multiple Resource bundle in struts.

2010-10-24T14:57:00.001+05:30

I had got one requirement from client as I had to implement multiple resource bundles and define same key in both bundle.

Example –

Say I have ApplicationResources.properties which has all global level messages defined and another module specific property file. If because of some reason the key didn't find in module specific file then System should display message from my global (ApplicationResources.properties) file.

I struggled a lot to find solution for the same and finally I found one.

Keep both properties files in class path.
updated struts-config.xml file as below

<message-resources parameter="Account,ApplicationResources" null="false" />

Create CustomeActionServlet and CustomMessageResources.javause <bean:message> tag in the jsp to display text
And the message will be render from all files. Download here..

How to find unused code in Eclipse

2009-07-23T19:16:00.003+05:30

Its easy to find unused code using eclipse editor .The java compiler detects unreachable code, unused variables, parameters, imports and unused private types, methods and fields.
The setting is on the Java > Compiler preference page.

C to Java converter

2009-07-23T19:14:00.001+05:30

While browsing I found very cool tool which converts C code to java code. I know everybody would be things how?? Need to know how?? Read more….

How to create a ZIP File

2009-07-23T18:56:00.002+05:30

Java tip illustrates a method of creating a ZIP file. ZIP is a universal format used by many applications to compress their files. By using this option developer may give their user an option of compressing their files in ZIP format. Read more on....

Top 10 Things Need to Know About Java SE 6

2009-07-23T18:48:00.000+05:30

Version 6 of the Java Platform, Standard Edition (Java SE), was released for general availability in December 2006. So here are the top 10 things you need to know about the release, if you're still hovering hesitantly over
Web Services
Scripting
Database
More Desktop APIs
Monitoring and Management
Compiler Access
Pluggable Annotations
Desktop Deployment
Security
The -lities: Quality, Compatibility, Stability
Know more about above point on link….

The J2EE Architect's Handbook

2009-06-07T22:37:00.002+05:30

This book is written for technical architects and senior developers tasked with designing and leading the development of J2EE java applications. This book will guide the architect through the entire process of delivering a project from analysis through application deployment providing numerous tips, tricks, and “best practices” along the way.
It is available in ZIP format.
Download..

Coding Standards - Part IV

2009-05-30T15:36:00.001+05:30

Error and Exception Handling

Does the code avoid catching Exception (as opposed to more specific exception types)?
Does the code avoid throwing an explicit Exception object?

Does the code avoid having empty catch blocks?

Do methods check for null / empty arguments using Asserts in the Service Layer?
"E.g.
public void identifyUnadjustableCharges(List chargesDetails) {
Assert.notNull(chargesDetails,""Charges detail cannot be null."");
Assert.notEmpty(chargesDetails,""Charges detail cannot be empty."");"

Does the code use logging instead of System.out.println() or Throwable.printStackTrace()?

Are log types (fatal, error, warn, info, debug and trace) used appropriately?

Comment Rules
Is the amount of commenting appropriate?
A good rule of thumb is a ratio of comments to code of about 20-25%.
Commenting just for the sake of commenting should be avoided.

Are all date comments in the format YYYY/MM/DD?

Are all class members commented except for getters/setters?

Unit Test

Do test cases use meaningful Input combinations?
Include boundary conditions and invalid conditions. Null inputs has to be tested

Do test cases adequately cover functionality?
Test should exercise most of branches.80% code coverage is a good rule-of-thumb.
Is every method tested?
Simple getters and setters can be exempted.

Are all test cases independent of one another?

Is all test code under test folder?

Coding Standards - Part-III

2009-05-30T15:34:00.000+05:30

Hibernate
Does the DAO extend Spring's Hibernate DAO support class?

Does the DAO methods throw Spring's DataAccessException?
Like All DAO methods should throw Spring DataAccessException. Also, declare the throw in the DAO interface.

Does the Hibernate code generate n+1 queries for 1 to many queries?
i.e. If code fetchs parent class along with its childern, it should only issue one query. Verify by viewing the logs.

Does the HQL uses named parameters?

Does the collection mappings have lazy initialization set to true?
All collections should lazy initialized; Verify by looking at the logs.

Struts

Does the code use duplicate form submission for POST operations?
use saveToken and isTokenMethod in the action class

Does the name of the action class conform with the naming conventions?

Does the action class contain business logic?
Verify that most of the code is for page flow, validation, object conversion etc.

Is the action scope set to "request" in the mapping?

JSP

Are labels and texts externalize to properties files?

Does the code use JSTL?
Majority of the code should be written in JSLT.

Are the html tages lower case?
All html tags should be lower case.

JSP's that will be used for AJAX should not contain the HEAD and BODY tags.

Coding Standards - Part II

2009-05-30T15:30:00.000+05:30

Naming: (mostly covered by checkstyle)

Are class, variable, and method names descriptive?
Like Other than following naming convention, all names should be descriptive

Coding Standard

Is the code self-descriptive and easily understood?
Like Code should be self-descriptive and logically paragraphed.If a reviewer can not get general idea of a method in 30 seconds,
either the design or the comments should be updated

Does the code use if/else for mutually exclusive conditions rather than if/if?
like avoid using flat if while nested conditionals are more accurate

When comparing a constant with a variable, is the constant's equals() method used?
like Avoid null object reference

Are static final String constants used instead of string literals?

Is StringBuilder used instead of appending Strings?

Is StringBuilder used instead of StringBuffer?

Are JDK 1.5 enhanced for loops used instead of using index on collections?

Does the code use equals() instead of comparing references (==||!=)?

Does the code check instanceof before a casting?

Does the code check for null before accessing an object?

Does the code use Spring for resource access?

Are variables declared using an interface when available rather than a class?

Does the code avoid making assignments to loop iterator variables?

Assignment to loop variable makes the code difficult to read and maintain

Does the code avoid using unnecessary return statements?

Will all loops terminate whether or not an exception occurs?

Coding Standards - Part I

2009-05-28T21:03:00.005+05:30

Some of you would be thinking why do need coding Standards. As a developer, I would like to highlight few points which will definatly convince every developer why we need to follow coding Standards.
The best applications are coded properly. This sounds like an obvious statement, but by 'properly', I mean that the code not only does its job well, but is also easy to add to, maintain and debug.

Why do need coding Standards?
1)80% of the lifetime cost of a piece of software goes to maintenance.
2)Hardly any software is maintained for its whole life by the original author.
etc etc...
Code conventions/Standards improve the readability of the software, allowing engineers to understand new code more quickly and thoroughly.

1)Coding standards are great -- but how do you decide which standards you want to apply, and how they will be defined? When you formulate your ideal coding style, you should think about these points

2)Can you actually read the code? Is it spaced out clearly?

3)Do you separate blocks of code into 'paragraphs' so that different sections are
easily defined?

4)Are you using indentation to show where control structures (if, else, while and
other loops) begin and end, and where the code within them is?

5)Are your variable naming conventions consistent throughout the code and do they
briefly describe that data that they'll contain?

6)Are functions named in accordance with what they do?

7)If you come back to the code in a few weeks or months, will you be able to work
out what's happening without needing to look at every line?

8)How are you commenting the work?

9)Have you used complex language functions/constructs that are quicker to write but
affect readability?

Improving code quality with Eclipse plugins (Check-Style and PMD))

2009-05-10T15:41:00.004+05:30

One of my primary goals when developing software is either preventing a defect from being introduced into a code base or limiting its lifetime; in other words, I try to find defects as early as possible. Obviously, the more I learn about how to write better code and learn how to effectively test software, the better I am at catching defects. But, I also like to have a safety net that can find potential defects. To achieve this we have lots of plug-in available on the Internet. I would suggest to used PMD as i found this is one of the most useful tool to improve the code quality as well as Its very easy to install. The plug-in which I found on Internet is check-Style, This is also one of the best tool I have ever used. Other than PMD and check-Style there lot other plug-in available, please find details for few as below

Table 1. List of code improvement plugins and installation URLs
CheckStyle : Coding standard analysis - http://eclipse-cs.sourceforge.net/update/
Coverlipse : Test code coverage - http://coverlipse.sf.net/update
CPD :Copy/Paste detection - http://pmd.sourceforge.net/eclipse/
JDepend: Package dependency analysis - http://andrei.gmxhome.de/eclipse/
PMD Coding standard analysis - http://pmd.sourceforge.net/

REST vs SOAP Webservices

2009-05-01T13:30:00.002+05:30

After long time I am updating my blog since, I was very busy with my new project. Today I got some free time so thought I will update my blog with technology which I am using in my project. this time I am working on RESTful webservices ...ummm I know what next is coming in your mind..... what is RESTFul webservice and how its different from the the SOAP right ??? so here we go......

REST - stands for "Representational State Transfer", this basically means that each unique URL is a representation of some object. You can get the contents of that object using an HTTP GET, to delete it, you then might use a POST, PUT, or DELETE to modify the object (in practice most of the services use a POST for this).

SOAP - stands for "Simple Object Access Protocol" was designed to be a platform and language-neutral alternative to previous middleware techologies like CORBA and DCOM

Pros and cons of SOAP

Pros :

Langauge, platform, and transport agnostic
Designed to handle distributed computing environments
Is the prevailing standard for web services, and hence has better support from other standards (WSDL, WS-*) and tooling from vendors Built-in error handling (faults) Extensibility

Cons:

Conceptually more difficult,
more "heavy-weight" than REST
More verbose Harder to develop, requires tools

Pros and cons of REST

Pros:

Language and platform agnostic
Much simpler to develop than SOAP
Small learning curve, less reliance on tools
Concise, no need for additional messaging layer
Closer in design and philosophy to the Web

Cons :

Assumes a point-to-point communication model
Generaly not usable for distributed computing environment where message may go through one or more intermediaries
Lack of standards support for security, policy, reliable messaging, etc.
Services that have more sophisticated requirements are harder to develop ("roll your own") Tied to the HTTP transport model

Hibernate Vs JDBC

2008-09-22T09:58:00.002+05:30

Following link has very good explanation about hibernate and JDBC as well as it explains difference between hibernate and JDBC.
http://www.mindfiresolutions.com/mindfire/Java_Hibernate_JDBC.pdf

Explain Facade Design Pattern in Java?

2008-09-22T09:00:00.000+05:30

The objective of Facade pattern is to make a complex system simple. It is achieved by providing a unified or general interface, which is a higher layer to these subsystems.Facade pattern decouples subsystems, reduce its dependency, and improve portability,makes an entry point to your subsystems and hides clients from subsystem components and their implementation.
JDBC design is a good example of Façade pattern. A database design is complicated. JDBC is used to connect the database and manipulate data without exposing details to the clients.
A client is exposed to certain set of methods like just getting a single instance of database connection or closing it when not required.
Another possibility is designing security of a system with Façade pattern. Clients' authorization to access information may be classified. General users may be allowed to access general information, special guests may be allowed to access more information,administrators and executives may be allowed to access the most important information. These subsystems may be generalized by oneinterface. The identified users may be directed to the relatedsubsystems.

What Is Caster Mapping?

2008-09-18T16:52:00.002+05:30

Castor XML mapping is a way to simplify the binding of java classes to XML document. It allows to transform the data contained in a java object model into/from an XML document.
Although it is possible to rely on Castor's default behavior to marshal and unmarshal Java objects into an XML document, it might be necessary to have more control over this behavior. For example, if a Java object model already exists, Castor XML Mapping can be used as a bridge between the XML document and that Java object model.
Castor allows one to specify some of its marshalling/unmarshalling behavior using a mapping file. This file gives explicit information to Castor on how a given XML document and a given set of Java objects relate to each other...........http://www.castor.org/xml-mapping.html

What are the differences between ActionErrors and ActionMessage?/What are the differences between Action.saveErrors(...) and Action.saveMessages(...)?

2008-06-30T15:02:00.000+05:30

To summarize, the difference between the classes ActionErrors/ActionError/ActionMessages/ActionMessage has absolutely nothing to do with the difference in behavior in Action.saveErrors(...) and Action.saveMessages(...)The

difference between the classes is zero -- all behavior in ActionErrors was pushed up into ActionMessages and all behavior in ActionError was pushed up into ActionMessage. This was done in the attempt to clearly signal that these classes can be used to pass any kind of messages from the controller to the view -- errors being only one kind of message.
The difference between saveErrors(...) and saveMessages(...) is simply the attribute name under which the ActionMessages object is stored, providing two convenient default locations for storing controller messages for use by the view. If you look more closely at the html:errors and html:messages tags, you can actually use them to get an ActionMessages object from any arbitrary attribute name in any scope.
The difference between html:errors and html:messages is purely in syntax and model -- both tags *default* to look for an ActionMessages object under Globals.ERROR_KEY despite the difference in names.html:messages provides more flexibility at the cost of more typing

First steps for diagnosis of memory leaks in Websphere Application Server v6.1

2008-06-28T15:04:00.000+05:30

Enable verbose GC.
- If using Sun JVM, use the -XX:+HeapDumpOnOutOfMemoryError option to tell the VM to generate a heap dump if OutOfMemoryError is thrown. If using IBM JVM, then enable automatic heap dump generation.
- Start the lightweight memory leak detection
- Generate heap dumps manually if required using the wsadmin tool.
- Use the MDD4J tool (Memory Dump Diagnostic for Java) for diagnosing root causes behind memory leaks in the Java heap. The heap dump collected in the above steps will be the input to this tool. More information about this tool can be found here , here and here.The MDD4J tool supports the following heap dump formats:1.IBM Portable Heap Dump (.phd) format (for WebSphere Application Server Versions 6.x on most platforms)2.IBM Text heap dump format (for WebSphere Application Server Versions 5.0 and 4.0 on most platforms)3.HPROF heap dump format (for WebSphere Application Server on the Solaris® and HP-UX platforms)4.SVC Dumps (WebSphere on the IBM zSeries)
On Solaris platform, starting with Java 1.5, Sun has been shipping a cool tool called jmap which allows you to attach to any 1.5 JVM and obtain heap layout information, class histograms and complete heap snapshots. The cool thing is that you don’t have to configure the JVM with any special options, and that it therefore runs exactly as during normal operation.
jmap -dump:format=b,file=snapshot2.jmap PID_OF_PROCESSjhat snapshot2.jmap

JSF Interview Questions

2008-06-21T11:00:00.000+05:30

Does JSF require JSP?

No, it does not. As a matter of fact, JSF was written to be render-technology neutral. This means you can use it with all sorts of non-JSP technology, including XML-based languages like XUL and templating systems like Velocity. The reference implementation includes an XUL-based example that has nothing to do with JSP. That being said, you'll definitely find more industry support behind use of JSP with JSF.

Can we use JSF with JSTL or other custom tags?

When used with JSP, JSF is implemented with JSP custom tags (also called custom actions). The JSF tags will generally work with other custom tags that you or third-parties have developed. Faces tags can be nested within other tags, and vice-versa. In addition, there has been a lot of specific work done to make sure that JSF tags work well with JSTL custom tags.

How to get localized objects in Java?

2008-06-17T15:07:00.000+05:30

A lot of "i18N" programs only have to deal with "strings" that need to be localized. For e.g. labels, other text etc.But what if U need a localized object ?..i.e a double object, a JPEG object etc.There is a special class in Java "ListResourceBundle" that allows a ResourseBundle to be loaded from a ".class" file.Read the tutorial below for more info :http://java.sun.com/docs/books/tutorial/i18n/resbundle/list.html

Soft references, Weak References, Phantom references in Java !!!

2008-06-06T15:08:00.000+05:30

The Reference API in Java can leave any sane person fully confused !!!..I tried to make sense of what the different types of references are and what purpose do they solve.I am still not crystal clear about the usability of all these references, but I hope I will understand someday.

ReferentAn object that is softly, weakly, or phantomly referenced from inside a SoftReference, WeakReference, or PhantomReference object, respectively.

Soft references:

The garbage collector might or might not reclaim a softly reachable object depending on how recently the object was created or accessed, but is required to clear all soft references before throwing an OutOfMemoryError.Weakly reachable objects are finalized some time after their weak references have been cleared. The only real difference between a soft reference and a weak reference is that the garbage collector uses algorithms to decide whether or not to reclaim a softly reachable object, but always reclaims a weakly reachable object.

Phantomly reachable objects are objects that have been finalized, but not reclaimed.

The garbage collector will never clear a phantom reference. All phantom references must be explicitly cleared by the program.An excellent article explaining GC in Java is given athttp://www.artima.com/insidejvm/ed2/gc17.html

Cool Cool The below code is in .NET C#

2008-06-05T15:10:00.000+05:30

With JDK 1.2, Sun introducted the Java Collection Framework, a cool API for data-structures in Java. At the base of the heirarchy were collection interfaces like:

List: A collection that is ordered and whose members can be accessed by index. A list can also contain duplicates and null values.Set: A collection that is not ordered and hence there are no methods that allow to access members thru a index. Also a Set does not allow duplicates and atmost one null value.

Though I personally feel that the JDK Collection framework is quite comprehensive and should suffice most development needs, it is good to know about some other alternatives:

1) Jakarta Commons Collections - An open source initiative that contains some extra cool collections like MultiMap etc.

2) JGL (Java Generic Library) - A port of the C++ STL (Standard tag library) to the Java language. Thought I was first impressed by this package, I think this API would appleal more to those from the C++ background. Also the latest version is no longer free, I believe.

Awt, Swing and SWT

2008-05-30T15:12:00.000+05:30

AWT: The idea was to wrap the native GUI widgets of the various operating systems with a platform-independent Java API called Abstract Window Toolkit (AWT). Only common widgets such as text field, text area, check box, radio button, list, and push button were supported by AWT. The graphics and imaging features were also very limited. That was, at best, enough for building simple applets.

SWING: is one of the most complex GUI frameworks ever developed. It has a complete set of GUI components ranging from buttons and text fields to tables, trees, and styled text editors. These components do not rely on the native widgets of the operating system; instead, Swing components are painted using graphic primitives such as lines, rectangles, and text. The painting is delegated to a look and feel (L&F) plug-in that can imitate the native L&F. Swing also has a platform-independent L&F called "Metal." JBuilder, uses Swing, and its speed is quite good.

Standard Widget Toolkit (SWT) is the GUI toolkit developed by IBM for its Eclipse IDE. SWT can be used outside of the Eclipse environment and offers direct access to the native GUI features of the operating system. Therefore, SWT-based Java applications have native GUIs and can be integrated with other native applications and components. SWT delegates to native widgets for common components (such as labels, lists, tables, and so on) as AWT does, while emulating in Java more sophisticated components (for example, toolbars are emulated when running on Motif) similarly to Swing's strategy.SWT has been designed to be as inexpensive as possible. This means (among the other things) that it is native-oriented. Anyway, it differs from AWT in a number of details. SWT provides different Java implementations for each platform, and each of these implementations calls natively (through the Java Native Interface, JNI) the underlying native implementation. The old AWT is different in that all platform-dependent details are hidden in C (native) code and the Java implementation is the same for all the platforms.

A simple recursive function to get all files in all sub-dirs of a folder

2008-05-17T15:13:00.000+05:30

The below code is in .NET C#public ArrayList

GetAllFiles(string directory)

{

ArrayList totalFilesList = new ArrayList(10);

string[] files = Directory.GetFiles(directory);//add all files in that current folder.totalFilesList.AddRange(files);//Check if the current directory has sub-directories string [] subDirs = Directory.GetDirectories(directory);

if(subDirs.Length > 0)

{

//now look for all files in current folder's sub-dir's. foreach(string subDir in subDirs)

{

ArrayList tempArrayList = GetAllFiles(subDir);

totalFilesList.AddRange(tempArrayList);

}

}

return totalFilesList;

}

38. What is multithreading and what are the methods for inter-thread communication and what is the class in which these methods are defined?

2008-04-30T12:06:00.000+05:30

Multithreading is the mechanism in which more than one thread run independent of each other within the process. wait (), notify () and notifyAll() methods can be used for inter-thread communication and these methods are in Object class. wait() : When a thread executes a call to wait() method, it surrenders the object lock and enters into a waiting state. notify() or notifyAll() : To remove a thread from the waiting state, some other thread must make a call to notify() or notifyAll() method on the same object.

JSF Interview Questions

2008-04-30T11:00:00.001+05:30

What are ORMs supported by Spring and how it integrates with Hibernate?

2008-04-22T10:35:00.000+05:30

Spring framework supports the following ORMs:
-Hibernate
-TopLink
-JDO
-iBatis
-JPA
and more..
With Hibernate,Spring can be integrated in following steps:
-Wire with datasource
-Declaring Hibernate properties
-Tell Spring about the Hibernate Mapping files.

Some More JDBC Interview Questions

2008-04-21T10:57:00.000+05:30

1)How do we get a JBDC connection?
2) What are prepared statements?
3) What are callable statements?
4) What is the BCNF?
5)What is partial dependency?
6)What is transitive dependency?
7) What is lossless decomposition?
8) Is there something called `lossy' decomposition ?

Java Threading/ Multithreading Interview Questions with Answers

2008-04-21T10:50:00.000+05:30

Describe synchronization in respect to multithreading.

Ans: With respect to multithreading, synchronization is the capability to control the access of multiple threads to shared resources. Without synchonization, it is possible for one thread to modify a shared variable while another thread is in the process of using or updating same shared variable. This usually leads to significant errors.

Explain different way of using thread?

Ans: The thread could be implemented by using runnable interface or by inheriting from the Thread class. The former is more advantageous, 'cause when you are going for multiple inheritance..the only interface can help.

What are the two types of multitasking?

Ans :

1.process-based

2.Thread-based

What are the two ways to create the thread?

Ans :

1.by implementing Runnable

2.by extending Thread

What is the signature of the constructor of a thread class?

Ans : Thread(Runnable threadob,String threadName)

What are all the methods available in the Runnable Interface?

Ans : run()

What is the data type for the method isAlive() and this method is available in which class?

Ans : boolean, Thread

What are all the methods available in the Thread class?

Ans :

1.isAlive()

2.join()

3.resume()

4.suspend()

5.stop()

6.start()

7.sleep()

8.destroy()

What are all the methods used for Inter Thread communication and what is the class in which these methods are defined?

Ans :

1. wait(),notify() & notifyall()

2. Object class

What is the mechanisam defind by java for the Resources to be used by only one Thread at a time?

Ans : Synchronisation

What is the procedure to own the moniter by many threads?

Ans : not possible

What is the unit for 1000 in the below statement?

ob.sleep(1000)

Ans : long milliseconds

What is the data type for the parameter of the sleep() method?

Ans : long

What are all the values for the following level?

max-priority

min-priority

normal-priority

Ans : 10,1,5

What is the method available for setting the priority?

Ans : setPriority()

What is the default thread at the time of starting the program?

Ans : main thread

The word synchronized can be used with only a method.

True/ False

Ans : False

Which priority Thread can prompt the lower primary Thread?

Ans : Higher Priority

How many threads at a time can access a monitor?

Ans : one

What are all the four states associated in the thread?

Ans : 1. new 2. runnable 3. blocked 4. dead

The suspend()method is used to teriminate a thread?

True /False

Ans : False

The run() method should necessary exists in clases created as subclass of thread?

True /False

Ans : True

When two threads are waiting on each other and can't proceed the programe is said to be in a deadlock?

True/False

Ans : True

Which method waits for the thread to die ?

Ans : join() method

Which of the following is true?

1) wait(),notify(),notifyall() are defined as final & can be called only from with in a synchronized method

2) Among wait(),notify(),notifyall() the wait() method only throws IOException

3) wait(),notify(),notifyall() & sleep() are methods of object class

1
2
3
1 & 2
1,2 & 3
Ans : D

Garbage collector thread belongs to which priority?

Ans : low-priority

What is meant by timeslicing or time sharing?

Ans : Timeslicing is the method of allocating CPU time to individual threads in a priority schedule.

What is meant by daemon thread? In java runtime, what is it's role?

Ans : Daemon thread is a low priority thread which runs intermittently in the background doing the garbage collection operation for the java runtime system.

How to handle duplicate submits in Struts?

2008-04-18T15:03:00.000+05:30

The duplicate form submission occurs-When a user clicks the Submit button more than once before the response is sent back or- When a client accesses a view by returning to a previously bookmarked page.It may result in inconsistent transactions and must be avoided.In Struts this problem can be handled by using the saveToken() and isTokenValid() methods of Action class. saveToken() method creates a token (a unique string) and saves that in the user's current session, while isTokenValid() checks if the token stored in the user's current session is the same as that was passed as the request parameter.It can be done by loading JSP through an Action and before loading the JSP call saveToken() to save the token in the user session. When the form is submitted, check the token against that in the session by calling isTokenValid

Explain different inheritance mapping models in Hibernate?

2008-04-17T15:01:00.001+05:30

There can be three kinds of inheritance mapping in hibernate

1. Table per concrete class with unions

2. Table per class hierarchy

3. Table per subclassExample:

We can take an example of three Java classes like Vehicle, which is an abstract class and two subclasses of Vehicle as Car and UtilityVan.1. Table per concrete class with unionsIn this scenario there will be 2 tablesTables: Car, UtilityVan, here in this case all common attributes will be duplicated.2. Table per class hierarchySingle Table can be mapped to a class hierarchyThere will be only one table in database named 'Vehicle' which will represent all attributes required for all three classes.Here it is be taken care of that discriminating columns to differentiate between Car and UtilityVan3. Table per subclassSimply there will be three tables representing Vehicle, Car and UtilityVan

What are the problems you have with JDBC and how does Spring framework help to resolve them?

2008-04-17T14:59:00.000+05:30

JDBC helps in accessing underlying RDBMS but it sometimes be quite cumbersome to use them and in following situations it become problematic:
-You have to ensure that ResultSets, Statements and (most importantly) Connections are closed after use. Hence correct use of JDBC results in a lot of code which is a common source of errors. Connection leaks can quickly bring applications down under load.
-The SQLException does not provide much information about what actually the probelm is as JDBC does not offer an exception hierarchy, but throws SQLException in response to all errors.The meaning of these values varies among databases.
Spring addresses these problems in two ways:
-By providing APIs that move tedious and error-prone exception handling out of application code into the framework. The framework takes care of all exception handling; application code can concentrate on issuing the appropriate SQL and extracting results. -By providing a meaningful exception hierarchy for your application code to work with in place of SQLException. When Spring first obtains a connection from a DataSource it examines the metadata to determine the database product. It uses this knowledge to map SQLExceptions to the correct exception in its own hierarchy descended from org.springframework.dao.DataAccessException. Thus your code can work with meaningful exceptions, and need not worry about proprietary SQLState or error codes. Spring's data access exceptions are not JDBC-specific, so your DAOs are not necessarily tied to JDBC because of the exceptions they may throw

How you will handle errors and exceptions in Struts?

2008-04-17T14:54:00.000+05:30

An efficient error and exception handling makes an application behave gracefully under abnormal conditions.Struts has errors and exception handling done in different ways.The form validations using Struts require a proper mechanism.For handling errors in Struts,it has two objects ActionError and ActionErrors.Whenever a form is submitted then cotroller receives request and then create ActionForm object which calls reset() method and stores ActionForm object to required scope and then it loads ActionForm object from request and calls validate() method.If validate method fails then errors are displayed on the form itself through html:errors tags.
Exception Handling can be done in following ways:

-try-catch block within -Using declarative exception handling.In struts-config.xml we can declare on which type of exception, a request should be redirected to.Use Global Exceptions tag in struts-config.xml

global-exceptions

"<"exception key="errors.MyException" type="java.lang.MyException" path="/myExcption.jsp"/ ">"

So whenever MyException occurs then Struts framework will display 'myException.jsp' page.The interpretation of this is that if MyException is caught by Struts' ActionServlet then it should redirect to myExcption.jsp. The key is as usual a pointer to the message resource file.

What causes memory leaks in Java?

2008-04-16T15:05:00.000+05:30

We know that a memory leak can occur in Java applications when object references are unintentionally held onto after the references are no longer needed. Typical examples of these are large collection objects, a unbounded cache, large number of session objects, infinite loops etc. A memory leak results in a OutOfMemoryError.Besides this core reason, there are other factors that may also result in a OutOfMemoryError exception

1. Java heap fragmentation: Heap fragmentation occurs when no contiguous chunk of free Java heap space is available from which to allocate Java objects. Various causes for this problem exist, including the repeated allocation of large objects (no single large fragment in first generation). In this case, even if we see good amount of free heap, memory allocation fails.

2. Memory leaks in native heap. This problem occurs when a native component, like database connections, is leaking.

3. Perm size has exhausted. The permanent generation of the heap contains class objects. If your code is using a lot of reflection/introspection, then a number of temporary class objects are created that would exhaust the perm space. More info can be found here.

Collection Of good Technical Websites For Tutorials And Books

2008-04-11T10:47:00.000+05:30

Enterprise JavaBeans Tutorial
http://developer.java.sun.com/developer/onlineTraining/Beans/EJBTutorial/index.html

JavaBeans Short

Course

http://developer.java.sun.com/developer/onlineTraining/Beans/JBShortCourse/index.html

Introduction to the JavaBeans API

http://developer.java.sun.com/developer/onlineTraining/Beans/JBeansAPI/index.html

read more

Developer and Testing/Tester

2008-04-08T14:04:00.000+05:30

Development and testing are two sides of coin, without development testing can’t be possible and without testing development can’t be complete. As a developer what I feel is a developer should be good tester to deliver quality of product

Following list of Questions are helpful for tester as well as developer so that developer can become good tester and tester can become very very good in testing to deliver quality of product.

1. What is Software Testing?
2. What is the Purpose of Testing?
3. What types of testing do testers perform?
4. What is the Outcome of Testing?
5. What kind of testing have you done?
6. What is the need for testing?
7. What are the entry criteria for Functionality and Performance testing?
8. What is test metrics?
9. Why do you go for White box testing, when Black box testing is available?
10. What are the entry criteria for Automation testing?
11. When to start and Stop Testing?
12. What is Quality?
13. What is Baseline document, Can you say any two?
14. What is verification?
15. What is validation?
16. What is quality assurance?
17. What is quality control?
18. What is SDLC and TDLC?
19. What are the Qualities of a Tester?
20. When to start and Stop Testing?
21. What are the various levels of testing?
22. What are the types of testing you know and you experienced?
23. What exactly is Heuristic checklist approach for unit testing?
24. After completing testing, what would you deliver to the client?
25. What is a Test Bed?26. What is a Data Guidelines?
27. Why do you go for Test Bed?
28. What is Severity and Priority and who will decide what?
29. Can Automation testing replace manual testing? If it so, how?
30. What is a test case?
31. What is a test condition?
32. What is the test script?
33. What is the test data?
34. What is an Inconsistent bug?
35. What is the difference between Re-testing and Regression testing?
36. What are the different types of testing techniques?
37. What are the different types of test case techniques?
38. What are the risks involved in testing?
39. Differentiate Test bed and Test Environment?
40. What ifs the difference between defect, error, bug, failure, fault?
41. What is the difference between quality and testing?
42. What is the difference between White & Black Box Testing?
43. What is the difference between Quality Assurance and Quality Control?
44. What is the difference between Testing and debugging?
45. What is the difference between bug and defect?
46. What is the difference between verification and validation?
47. What is the difference between functional spec. and Business requirement specification?
48. What is the difference between unit testing and integration testing?
49. What is the diff between Volume & Load?
50. What is diff between Volume & Stress?
51. What is the diff between Stress & Load Testing?
52. What is the Diff between Two Tier & Three tier Architecture?
53. What is the diff between Client Server & Web Based Testing?
54. What is the diff between Integration & System Testing?
55. What is the Diff between Code Walkthrough & Code Review?
56. What is the diff between walkthrough and inspection?
57. What is the Diff between SIT & IST?
58. What is the Diff between static and dynamic?
59. What is the diff between alpha testing and beta testing?
60. What are the Minimum requirements to start testing?
61. What is Smoke Testing & when it will be done?
62. What is Adhoc Testing? When it can be done?
63. What is cookie testing?
64. What is security testing?
65. What is database testing?
66. What is the relation ship between Quality & Testing?
67. How do you determine, what to be tested?
68. How do you go about testing a project?
69. What is the Initial Stage of testing?
70. What is Web Based Application Testing?
71. What is Client Server Application Testing?
72. What is Two Tier & Three tier Architecture?
73. What is the use of Functional Specification?
74. Why do we prepare test condition, test cases, test script (Before Starting Testing)?
75. Is it not waste of time in preparing the test condition, test case & Test Script?
76. How do you go about testing of Web Application?
77. How do you go about testing of Client Server Application?
78. What is meant by Static Testing?
79. Can the static testing be done for both Web & Client Server Application?
80. In the Static Testing, what all can be tested?
81. Can test condition, test case & test script help you in performing the static testing?
82. What is meant by dynamic testing?
83. Is the dynamic testing a functional testing?
84. Is the Static testing a functional testing?
85. What are the functional testing you perform?
86. What is meant by Alpha Testing?
87. What kind of Document you need for going for an Functional testing?
88. What is meant by Beta Testing?
89. At what stage the unit testing has to be done?
90 Who can perform the Unit Testing?
91. When will the Verification & Validation be done?
92. What is meant by Code Walkthrough?
93. What is meant Code Review?
94. What is the testing that a tester performs at the end of Unit Testing?
95. What are the things, you prefer & Prepare before starting Testing?
96. What is Integration Testing?
97. What is Incremental Integration Testing?
98. What is meant by System Testing?
99. What is meant by SIT?
100 .When do you go for Integration Testing?
101 Can the System testing be done at any stage?
102. What are stubs & drivers?
103. What is the Concept of Up-Down & Down-Up in Testing in integration testing?
104. What is the final Stage of Integration Testing?
105. Where in the SDLC, the Testing Starts?
106. What is the Outcome of Integration Testing?
107. What is meant by GUI Testing?
108. What is meant by Back-End Testing?
109. What are the features, you take care in Prototype testing?
110. What is Mutation testing & when can it be done?
111. What is Compatibility Testing?
112. What is Usability Testing?
113 What is the Importance of testing?
114. What is meant by regression Testing?
115. When we prefer Regression & what are the stages where we go for Regression Testing?
116. What is performance testing?
117. What is the Performance testing; those can be done Manually & Automatically?
118 What is Volume, Stress & Load Testing?
119. What is a Bug?120. What is a Defect?
121. What is the defect Life Cycle?
122. What is the Priority in fixing the Bugs?
123. Explain the Severity you rate for the bugs found?
124. Diff between UAT & IST?125. What is meant by UAT?
126. What all are the requirements needed for UAT?
127. What are the docs required for Performance Testing?
128. What is risk analysis?129. How to do risk management?
130. What are test closure documents?
131. What is traceability matrix?
132. What ways you followed for defect management?

SINGLETON vs STATIC

2008-03-25T11:52:00.000+05:30

The Singleton pattern is useful when the object itself needs to keep some state.If no such thing is needed, a static method can do the job as well.

A purely static class can save state as well. Static variables can be used to store state.A static block can be used to initialize state. Static methods can be used to access or modify the state.AFAIK, the only think a purely static class cannot do is to force parameterization of the initialization of the class, since any method call can trigger the static initialization block. Such forced parameterization can be provided in the singleton by only providingan .instance() method with the desired arguments in the parameter list.

the Singleton pattern in that a Singleton class is supposed to have one (and only one) *instance*, while a "static class" is never instanciated (or, at least, there is no point in instanciating it).
a class full of static methods can't be polymorphic, but a singleton can.

The Singleton pattern has several advantages over the "static class" pattern. First, a singleton can extend classes and implement interfaces, while a static class cannot (well, it can extend classes, but it does not inherit their instance members). A singleton can be initialized lazily or asynchronously whilea static class is generally initialized when it is first loaded. A sinlgeton class can be extended and it's methods overidden. Perhaps the most important advantage, though, is that singletons can be handled polymorphically without forcing their users to assume that there is only one instance. For instance, assume you have a Configuration class that holds some global configs. Methods that use this configuration information may be defined as:

public void doSomething(Configuration config) {...}

What is the difference between Apache struts and jakarta struts?

2008-03-23T11:22:00.000+05:30

Both apache struts and jakarta struts are one and the same.Struts was originally created by Craig McClanahan and donated to the Apache Foundation in May, 2000.However after gaining prominence in the J2EE community through its evolution as a Jakarta Project, in early 2004 it become an official Apache Project.Thus there is no difference between them.

Why is it not advisable to catch type “Exception”?

2008-03-22T11:19:00.000+05:30

Exception handling in Java is polymorphic in nature. For example if you catch type Exception in your code then it can catch or throw its descendent types like IOException as well. So if you catch the type Exception before the type IOException then the type Exception block will catch the entire exceptions and type IOException block is never reached. In order to catch the type IOException and handle it differently to type Exception, IOException should be caught first (remember that you can’t have a bigger basket above a smaller basket). The diagram below is an example for illustration only. In practice it is not recommended to catch type “Exception”. We should only catch specific subtypes of the Exception class. Having a bigger basket (i.e. Exception) will hide or cause problems. Since the RunTimeException is a subtype of Exception, catching the type Exception will catch all the run time exceptions (like NullpointerException, ArrayIndexOut-OfBounds-Exception) as well.

Spring IOC and its benefits

2008-03-14T12:33:00.000+05:30

What are the different types of IOC (dependency injection) ?
There are three types of dependency injection:
Constructor Injection (e.g. Pico container, Spring etc): Dependencies are provided as constructor parameters.
Setter Injection (e.g. Spring): Dependencies are assigned through JavaBeans properties (ex: setter methods).
Interface Injection (e.g. Avalon): Injection is done through an interface.
Note: Spring supports only Constructor and Setter Injection

What are the benefits of IOC (Dependency Injection)?
Benefits of IOC (Dependency Injection) are as follows:
Minimizes the amount of code in your application. With IOC containers you do not care about how services are created and how you get references to the ones you need. You can also easily add additional services by adding a new constructor or a setter method with little or no extra configuration.
Make your application more testable by not requiring any singletons or JNDI lookup mechanisms in your unit test cases. IOC containers make unit testing and switching implementations very easy by manually allowing you to inject your own objects into the object under test.
Loose coupling is promoted with minimal effort and least intrusive mechanism. The factory design pattern is more intrusive because components or services need to be requested explicitly whereas in IOC the dependency is injected into requesting piece of code. Also some containers promote the design to interfaces not to implementations design concept by encouraging managed objects to implement a well-defined service interface of your own.
IOC containers support eager instantiation and lazy loading of services. Containers also provide support for instantiation of managed objects, cyclical dependencies, life cycles management, and dependency resolution between managed objects etc.

What's New in Java 1.5?

2008-03-13T11:48:00.000+05:30

Sun has recently "upgraded" the Java language to include many new features such as Generics, Type-Safe Enumerations, Automatic Boxing and Unboxing, Annotations, For/In loops, and Static Imports. How will this affect the way you teach APCS? Immediately, it will have a minimal effect, but as you need to expand the scope of your APCS course to encompass the new features it might be difficult to find time. I'm going to discuss the current effect 1.5 has on APCS as well as possible future implications it may have on your course. for more detail read..http://www.cs.indiana.edu/classes/jett/sstamm/

transient,persistent or detached

2008-02-21T11:24:00.000+05:30

After going through the life cycle, the question that comes into mind is that, how does hibernate know whether an object is transient,persistent or detached ?

A range of options are available for that. Hibernate will assume that an instance is unsaved
Transient instance if :
a) The identifier property is null
b) The version property (if exists) is null.
c) You supply an unsaved-value attribute in and the value of the identifier property
matches.
d) You supply Hibernate Interceptor and return Boolean.TRUE from Interceptor.isUnsaved()
after checking the instance in your code.

What is Application Context in Spring?

2008-01-11T12:45:00.000+05:30

A bean factory is fine to simple applications, but to take advantage of the full power of the Spring framework, you may want to move up to Springs more advanced container, the application context. On the surface, an application context is same as a bean factory.Both load bean definitions, wire beans together, and dispense beans upon request. But it also provides:

A means for resolving text messages, including support for internationalization.
A generic way to load file resources.
Events to beans that are registered as listeners.

What are the types of Dependency Injection Spring supports?

2008-01-02T12:24:00.000+05:30

Setter Injection:
Setter-based DI is realized by calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.

Constructor Injection:
Constructor-based DI is realized by invoking a constructor with a number of arguments, each representing a collaborator.

What is Significance of JSF- Spring integration ?

2007-12-02T12:54:00.000+05:30

Spring - JSF integration is useful when an event handler wishes to explicitly invoke the bean factory to create beans on demand, such as a bean that encapsulates the business logic to be performed when a submit button is pressed.

What Is Spring?

2007-11-27T12:13:00.000+05:30

In the world of technology so may frame-works are coming and it’s a big question in front of us that which one is better.To solve this query I tried explaining frame-work in short. So, let’s start with Spring frame-work

Spring is an open-source framework, and to Put simply, Spring is a
lightweight inversion of control and aspect-oriented container
framework.
Okay, that’s not so simple a description. But it does summarize
what Spring does. To make more sense of Spring, let’s break this description down:

■ Lightweight—Spring is lightweight in terms of both size and overhead.
The entire Spring framework can be distributed in a single JAR file that
weighs in at just over 1 MB. And the processing overhead required by
Spring is negligible. What’s more, Spring is nonintrusive: objects in a
Spring-enabled application typically have no dependencies on Springspecific
classes.

■ Inversion of control—Spring promotes loose coupling through a technique
known as inversion of control (IoC). When IoC is applied, objects are passively
given their dependencies instead of creating or looking for dependent
objects for themselves. You can think of IoC as JNDI in reverse—
instead of an object looking up dependencies from a container, the container
gives the dependencies to the object at instantiation without waiting
to be asked.

■ Aspect-oriented—Spring comes with rich support for aspect-oriented programming
that enables cohesive development by separating application
business logic from system services (such as auditing and transaction management).
Application objects do what they’re supposed to do—perform
business logic—and nothing more. They are not responsible for (or even
aware of) other system concerns, such as logging or transactional support.

■ Container—Spring is a container in the sense that it contains and manages
the life cycle and configuration of application objects. You can configure
how your each of your beans should be created—either create one single
instance of your bean or produce a new instance every time one is needed
based on a configurable prototype—and how they should be associated
with each other. Spring should not, however, be confused with traditionally
heavyweight EJB containers, which are often large and cumbersome
to work with.

■ Framework—Spring makes it possible to configure and compose complex
applications from simpler components. In Spring, application objects are
composed declaratively, typically in an XML file. Spring also provides
much infrastructure functionality (transaction management, persistence
framework integration, etc.), leaving the development of application logic
to you.

All of these attributes of Spring enable you to write code that is cleaner, more
manageable, and easier to test. They also set the stage for a variety of subframeworks
within the greater Spring framework.

Features of Spring Framework:

2007-11-20T20:53:00.000+05:30

1 An Inversion of Control (IoC) container (Spring Core package) that supports Dependency Injection, a powerful technique pioneered by Spring for configuring POJO-based applications. Spring is the most popular and powerful of a number of frameworks in the IoC space.

2 A pure Java AOP (Aspect-Oriented Programming) framework (the Spring AOP package) that enables crosscutting functionality to be applied to POJOs, which enables sophisticated support for declarative transaction management in a range of environments.

3 A flexible web MVC framework. Spring also integrates out-of-the-box with popular web tier solutions such as Struts, WebWork, Tapestry, or JSF.

4 A common approach to persistence (the Spring DAO package).

5 Support for remoting, working with EJBs, JMS, and other important enterprise functionality (Spring Context package).

6 Integration with numerous third-party products, including the Quartz scheduler and Velocity template engine.

Why Spring?

2007-11-18T20:51:00.000+05:30

1 The "Struts" framework is no doubt a good framework to enhance the ability of the web tier, but the biggest drawback is the fact that it caters only to the web tier and leaves most of the Enterprise tier or middle tier to the fancy of the application architects.

2 The Application architects need to provide an additional framework to deal with the enterprise tier and make sure that the new framework integrates well with the Struts framework.

3 Spring tries to alleviate this problem by providing a comprehensive framework, which includes an MVC framework, an AOP integration framework, a JDBC integration framework, and an EJB integration framework.

4 It also provides integration modules for major O/R mapping tools like Hibernate and JDO. Spring provides all these in a modular fashion without imposing any layer on to the user.

5 Spring is not a take-it-or- leave-it kind of framework. It tries to seamlessly blend into the existing framework users have without hindrances.

6 Spring also provides transaction management support using Java classes, email support packages using framework classes, web services support through proxies and many more features like the above.

7 As mentioned earlier all these packages are optional and spring does not make any of them mandatory. Spring can seamlessly integrate with existing applications and provide specific functionality that you intend to provide with minimal demands for customization.

8 A user can continue to use Struts for the web tier and top link O/R for the database and meanwhile hook spring to provide e-mail services and web services support. Spring is based on the Inversion of Control/Dependency Injection pattern that has been making rounds in message boards all over the Internet.

Architectural benefits of Spring

2007-11-17T20:49:00.000+05:30

Before we get down to specifics, let's look at some of the benefits Spring can bring to a project:

1 Spring can effectively organize your middle tier objects, whether or not you choose to use EJB. Spring takes care of plumbing that would be left up to you if you use only Struts or other frameworks geared to particular J2EE APIs. And while it is perhaps most valuable in the middle tier, Spring's configuration management services can be used in any architectural layer, in whatever runtime environment.

2 Spring can eliminate the proliferation of Singletons seen on many projects. In my experience, this is a major problem, reducing testability and object orientation.

3 Spring can eliminate the need to use a variety of custom properties file formats, by handling configuration in a consistent way throughout applications and projects. Ever wondered what magic property keys or system properties a particular class looks for, and had to read the Javadoc or even source code? With Spring you simply look at the class's JavaBean properties or constructor arguments. The use of Inversion of Control and Dependency Injection (discussed below) helps achieve this simplification.

4 Spring can facilitate good programming practice by reducing the cost of programming to interfaces, rather than classes, almost to zero.

5 Spring is designed so that applications built with it depend on as few of its APIs as possible. Most business objects in Spring applications have no dependency on Spring.

6 Applications built using Spring are very easy to unit test.

7 Spring can make the use of EJB an implementation choice, rather than the determinant of application architecture. You can choose to implement business interfaces as POJOs or local EJBs without affecting calling code.

8 Spring helps you solve many problems without using EJB. Spring can provide an alternative to EJB that's appropriate for many applications. For example, Spring can use AOP to deliver declarative transaction management without using an EJB container; even without a JTA implementation, if you only need to work with a single database.

9 Spring provides a consistent framework for data access, whether using JDBC or an O/R mapping product such as TopLink, Hibernate or a JDO implementation.

10 Spring provides a consistent, simple programming model in many areas, making it an ideal architectural "glue." You can see this consistency in the Spring approach to JDBC, JMS, JavaMail, JNDI and many other important APIs.

What is Dependency Injection Pattern?

2007-10-13T19:47:00.000+05:30

1 The idea behind dependency injection (a.k.a. Inversion of Control, IOC) is that each application component declares what type of service objects it requires (a.k.a its dependency).

2 The container resolves the dependency between application components, instantiates service objects, and then injects service stubs into the application at runtime via automatic Java Bean setter calls or direct data field value assignment.

3 Dependency Injection proposes separating the implementation of an object and the construction of objects that depend on them.

4 The job of coordinating the implementation and construction is left to the Assembler code. The object that needs to be implemented does not need to instantiate the dependent objects and can rely on the assembler to do the job.

5 The assembler will gather and instantiate, if necessary, all the dependent objects and make them available to the implemented object.

6 Since the assembler does not depend on the code directly changes can be made to the assembler without any changes to the code.

7 The assembler gathers the required classes through configuration files so a change in the assembler only needs changes to the configuration file. In this case the Assembler code would be the spring framework.

Types of Dependency Injections.

2007-09-10T19:46:00.000+05:30

1 Type 1 IOC also called Interface Injection

o In Type 1 IOC the injection is done though an interface. The interface will define the injection method and the implementation class has to implement this interface and provide concrete implementation for the injection method.

2 Type 2 IOC also called Setter Injection

o In Type 2 IOC the injection is done via a setter method. Type 2 IOC uses setter methods to get the dependent classes it needs.

3 Type 3 IOC also called Constructor Injection.

o In Type 3 IOC implementing class defines a constructor to get all its dependents. The dependent classes are defined in the constructor arguments.

Spring supports only Constructor based injection and setter based injection.

Spring recommends setter-based injection over constructor-based injection as multiple constructors can make the bean huge and unmanageable.

How does Spring Work?

2007-09-08T19:44:00.000+05:30

The idea is that beans follow the Dependency Injection pattern. Beans have information on the classes dependent on them. Beans define their own attributes within bean descriptors and also define the beans they depend on in the same descriptors.

 The Bean does not need to locate and instantiate these classes using service locators or JNDI calls. The Assembler (Spring Framework in this case) takes care of finding these classes based on the information provided in the descriptor and makes them available to the calling class.

 The service locator pattern does almost the same job, so why do we need another pattern to do it?
o The class that needs the dependent classes needs to tell the Service Locator as to which classes are required by it and moreover the responsibility of finding these classes and invoking them falls on the calling class. This makes the classes tightly coupled with each other making them difficult to unit test them separately.

 In the case of the Dependency Injection pattern the responsibility is shifted to the Assembler to load these classes. The assembler can make changes to the dependent classes by simply modifying the descriptor file.

Inversion of control container

2007-08-06T19:42:00.000+05:30

The core of Spring is the org.springframework.beans package, designed for working with JavaBeans. This package typically isn't used directly by users, but underpins much Spring functionality.
The next higher layer of abstraction is the bean factory. A Spring bean factory is a generic factory that enables objects to be retrieved by name, and which can manage relationships between objects.
Bean factories support two modes of object:

1 Singleton: in this case, there's one shared instance of the object with a particular name, which will be retrieved on lookup. This is the default, and most often used, mode. It's ideal for stateless service objects.

2 Prototype or non-singleton: in this case, each retrieval will result in the creation of an independent object. For example, this could be used to allow each caller to have its own distinct object reference.
Because the Spring container manages relationships between objects, it can add value where necessary through services such as transparent pooling for managed POJOs, and support for hot swapping, where the container introduces a level of indirection that allows the target of a reference to be swapped at runtime without affecting callers and without loss of thread safety. One of the beauties of Dependency Injection (discussed shortly) is that all this is possible transparently, with no API involved.

As org.springframework.beans.factory.BeanFactory is a simple interface, it can be implemented in different ways. The BeanDefinitionReader interface separates the metadata format from BeanFactory implementations themselves, so the generic BeanFactory implementations Spring provides can be used with different types of metadata. You could easily implement your own BeanFactory or BeanDefinitionReader, although few users find a need to. The most commonly used BeanFactory definitions are:

1 XmlBeanFactory: This parses a simple, intuitive XML structure defining the classes and properties of named objects. We provide a DTD to make authoring easier.

2 DefaultListableBeanFactory: This provides the ability to parse bean definitions in properties files, and create BeanFactories programmatically.

What is Inversion of Control container?

2007-07-03T19:38:00.000+05:30

Spring is an Inversion of Control container.

o IoC moves the responsibility for making things happen into the framework, and away from application code. Whereas your code calls a traditional class library, an IoC framework calls your code. Lifecycle callbacks in many APIs, such as the setSessionContext () method for session EJBs, demonstrate this approach.
Dependency Injection is a form of IoC that removes explicit dependence on container APIs; ordinary Java methods are used to inject dependencies such as collaborating objects or configuration values into application object instances.

o In traditional container architectures such as EJB, a component might call the container to say "where's object X, which I need to do my work",

o With Dependency Injection the container figures out that the component needs an X object, and provides it to it at runtime. The container does this figuring out based on method signatures (usually JavaBean properties or constructors) and, possibly, configuration data such as XML.
The two major flavors of Dependency Injection are Setter Injection (injection via JavaBean setters); and Constructor Injection (injection via constructor arguments). Spring provides sophisticated support for both, and even allows you to mix the two when configuring the one object.

As well as supporting all forms of Dependency Injection, Spring also provides a range of callback events, and an API for traditional lookup where necessary. However, we recommend a pure Dependency Injection approach in general.
Dependency Injection has several important benefits. For example:

1 Because components don't need to look up collaborators at runtime, they're much simpler to write and maintain. In Spring's version of IoC, components express their dependency on other components via exposing JavaBean setter methods or through constructor arguments. The EJB equivalent would be a JNDI lookup, which requires the developer to write code that makes environmental assumptions.

2 For the same reasons, application code is much easier to test. For example, JavaBean properties are simple, core Java and easy to test: simply write a self-contained JUnit test method that creates the object and sets the relevant properties.

3 A good IoC implementation preserves strong typing. If you need to use a generic factory to look up collaborators, you have to cast the results to the desired type. This isn't a major problem, but it is inelegant. With IoC you express strongly typed dependencies in your code and the framework is responsible for type casts. This means that type mismatches will be raised as errors when the framework configures the application; you don't have to worry about class cast exceptions in your code.

4 Dependencies are explicit. For example, if an application class tries to load a properties file or connect to a database on instantiation, the environmental assumptions may not be obvious without reading the code (complicating testing and reducing deployment flexibility). With a Dependency Injection approach, dependencies are explicit, and evident in constructor or JavaBean properties.

5 Most business objects don't depend on IoC container APIs. This makes it easy to use legacy code, and easy to use objects either inside or outside the IoC container. For example, Spring users often configure the Jakarta Commons DBCP DataSource as a Spring bean: there's no need to write any custom code to do this. We say that an IoC container isn't invasive: using it won't invade your code with dependency on its APIs. Almost any POJO can become a component in a Spring bean factory. Existing JavaBeans or objects with multi-argument constructors work particularly well, but Spring also provides unique support for instantiating objects from static factory methods or even methods on other objects managed by the IoC container.

What is the main difference between shallow cloning and deep cloning of objects?

2007-06-06T21:01:00.000+05:30

The default behaviour of an object’s clone() method automatically yields a shallow copy. So to achieve a deepcopy the classes must be edited or adjusted.

Shallow copy: If a shallow copy is performed on obj-1 as shown in fig-2 then it is copied but its contained objects
are not. The contained objects Obj-1 and Obj-2 are affected by changes to cloned Obj-2. Java supports shallow
cloning of objects by default when a class implements the java.lang.Cloneable interface.

Deep copy: If a deep copy is performed on obj-1 as shown in fig-3 then not only obj-1 has been copied but the
objects contained within it have been copied as well. Serialization can be used to achieve deep cloning. Deep
cloning through serialization is faster to develop and easier to maintain but carries a performance overhead.

Web Servers vs. App Servers

2007-05-19T12:48:00.000+05:30

These are two quite different pieces of software.There are few Web servers in common use: Apache takes the lion's share, while Microsoft Internet Information Server (IIS) and iPlanet Web Server are among the others. Application servers jumped into the limelight only about two years ago and there is a proliferation of products from companies such as BEA, iPlanet, Oracle, SilverStream, HP (Bluestone), and IBM.

Speaking of functionality, in differentiating the two servers we have to say "in general" because there are customized versions of both Web and application servers that have crossover functionality. The Web server, in general, sends Web pages to browsers as its primary function. Most Web servers also process input from users, format data, provide security, and perform other tasks. The majority of a Web server's work is to execute HTML or scripting such as Perl, JavaScript, or VBScript.

In general, an application server prepares material for the Web server -- for example, gathering data from databases, applying business rules, processing security clearances, or storing the state of a user's session. In some respects the term application server is misleading since the functionality isn't limited to applications. Its role is more as an aggregator and manager for data and processes used by anything running on a Web server.

Where and how can you use a private constructor?

2007-05-19T12:36:00.000+05:30

Private constructor is used if you do not want other classes to instantiate the object. The instantiation is done by a public static method within the same class.
1. Used in the singleton pattern. (Refer Q45 in Java section).
2. Used in the factory method pattern (Refer Q46 in Java section).
3. Used in utility classes e.g. StringUtils etc.

Why there are some interfaces with no defined methods (i.e. marker interfaces) in Java?

The interfaces with no defined methods act like markers. They just tell the compiler that the objects of the classes implementing the interfaces with no defined methods need to be treated differently. Example Serializable, Cloneable etc

The code in a finally clause will never fail to execute, right?
Well, hardly ever. But here's an example where the finally code will not execute, regardless of the value of the boolean choice:

try {
if (choice)
{
while (true) ;
} else
{
System.exit(1);
}
} finally
{code.to.cleanup();
}

What are the benefits of the Java collection framework?

2007-05-05T20:24:00.000+05:30

Java Collection framework provides flexibility,
performance, and robustness.

1.Polymorphic algorithms – sorting, shuffling, reversing, binary search etc.
2.Set algebra - such as finding subsets, intersections, and unions between objects.
3.Performance - collections have much better performance compared to the older Vector and Hashtable
classes with the elimination of synchronization overheads.
4.Thread-safety - when synchronization is required, wrapper implementations are provided for temporarily
synchronizing existing collection objects.
5.Immutability - when immutability is required wrapper implementations are provided for making a collection
immutable.
6.Extensibility - interfaces and abstract classes provide an excellent starting point for adding functionality and
features to create specialized object collections.

What is the difference between Struts 1.0 and Struts

2007-04-05T03:14:00.000+05:30

The main differences are
1. In Action class Perform() method was replaced by execute() method.
2. DynaActionForms are added.
3. Tiles Concept is introduced.
4. We can write our own Controller by Inheriting RequestProcessor class. i.e., nothing but we can override the process() method of the RequestProcessor class.
Apart from these some updates in web.xml and Struts-Config.xml.

Where and how can you use a private constructor?

2007-03-03T22:07:00.000+05:30

Private constructor is used if you do not want other classes to instantiate the object. The instantiation is done by a
public static method within the same class.

1.Used in the singleton pattern..
2.Used in the factory method pattern .
3.Used in utility classes e.g. StringUtils etc.

Ways to Improve The Performance of your java Program

2007-02-22T06:55:00.000+05:30

Following article has tips on ways to Improve the performance of your java Program
I must say this is good article I ever gone through.Please have a look and please leave your comments for the same.

Garbage collection and memory management in Java applications

2007-02-21T06:30:00.000+05:30

As a modern language, Java has an automatic memory management mechanism called garbage collection, which makes it much easier for you to manage objects created in the application code. When an object is created by new keyword, it is placed into the Java heap of the Java Virtual Machine (JVM). The JVM has a garbage collector, and when this object is no longer needed by any code, the garbage collector removes it from the Java heap. Listing 1 is an example of a method defined in a Java class

public void aMethod() {
String example = new String("My Example"); // String is a Java class
}

In above example, a new String object is allocated in the Java heap. In Java , you don't need to write code to explicitly delete the object from the heap after you're done with it. When the method is called and returned, the only reference to this String object, s, is set to null and removed from the thread stack. The JVM garbage collector detects that the number of references to this String object is 0, indicating no code may access or use the object any longer. When the garbage collector has an opportunity to run, it treats this String object as garbage, removes it from the Java heap, and frees the memory allocated for it.

Java memory leaks

If a program holds a reference to a heap chunk that is not used during the rest of its life, it is considered a memory leak because the memory could have been freed and reused. GC won't reclaim it due to the reference being held by the program. A Java program could run out of memory due to such leaks. Java memory leaks are mostly a result of non-obvious programming errors.

Finding Reason for memory leaks
Usually, solving a memory leak problem is a two-step process:identifying which Java classes caused the memory leak, and then determining where in the application leak occurred. The goal of the first step is easy to achieve with the tools

The second step is more challenging, because tracking the relevant information in a profiling tool slows down performance. The profiler discussed in this article doesnot provide the detailed information needed to track down the source of memory leaks inthe code, partly because of performance considerations. Some tools may be configured to collect such information with significant adverse impact on performance, such as Hprof and other third party tools.Given the scale of J2EE applications and the J2EE environment associated with them, performance concerns often prevent developers from tracking sufficient information using those tools.

To simplify the discussion of resolving the difficulty in the second step in this article, memory leaks are divided into two types.

1. Rarely used object leak
2. Frequently used object leak

Preventing memory leaks

You can prevent memory leaks by watching for some common problems. Collection classes,
such as hashtables and vectors, are common places to find the cause of a memory leak.
This is particularly true if the class has been declared static and exists for the life of the application.

Another common problem occurs when you registera class as an event listener without bothering to unregister when the class is no longer needed. Also, many times member variables of a class that point to other classes simply needto be set to null at the appropriate time.

How does Java allocate stack and heap memory? Explain re-entrant, recursive and idempotent

2007-02-17T22:10:00.000+05:30

Each time an object is created in Java it goes into the area of memory known as heap. The primitive variables like
int and double are allocated in the stack, if they are local method variables and in the heap if they are member
variables (i.e. fields of a class). In Java methods local variables are pushed into stack when a method is invoked
and stack pointer is decremented when a method call is completed. In a multi-threaded application each thread
will have its own stack but will share the same heap. This is why care should be taken in your code to avoid any
concurrent access issues in the heap space. The stack is threadsafe (each thread will have its own stack) but the
heap is not threadsafe unless guarded with synchronisation through your code.

A method in stack is reentrant allowing multiple concurrent invocations that do not interfere with each other. A
function is recursive if it calls itself. Given enough stack space, recursive method calls are perfectly valid in Java
though it is tough to debug. Recursive functions are useful in removing iterations from many sorts of algorithms. All
recursive functions are re-entrant but not all re-entrant functions are recursive. Idempotent methods are methods,
which are written in such a way that repeated calls to the same method with the same arguments yield same
results. For example clustered EJBs, which are written with idempotent methods, can automatically recover from a
server failure as long as it can reach another server.

What is serialization? How would you exclude a field of a class from serialization?

2007-02-11T21:57:00.000+05:30

Serialization is a process of reading or writing an object. It is a process of saving an object’s state to a sequence of
bytes, as well as a process of rebuilding those bytes back into a live object at some future time. An object is
marked serializable by implementing the java.io.Serializable interface, which is only a marker interface -- it simply
allows the serialization mechanism to verify that the class can be persisted, typically to a file.

What are some of the best practices relating to Java collection?

2007-02-02T21:30:00.000+05:30

Use ArrayLists, HashMap etc as opposed to Vector, Hashtable etc, where possible to avoid any
synchronization overhead. Even better is to use just arrays where possible. If multiple threads concurrently
access a collection and at least one of the threads either adds or deletes an entry into the collection,
then the collection must be externally synchronized. This is achieved by:

List myList = Collections.synchronizedList (myList);

Map myMap = Collections.synchronizedMap (myMap);

Set the initial capacity of a collection appropriately (e.g. ArrayList, HashMap etc). This is because collection
classes like ArrayList, HashMap etc must grow periodically to accommodate new elements. But if you have a very large array, and you know the size in advance then you can speed things up by setting the initial size
appropriately.

HashMaps/Hashtables need to be created with sufficiently large capacity to minimise
rehashing (which happens every time the table grows). HashMap has two parameters initial capacity and
load factor that affect its performance and space requirements. Higher load factor values (default load factor
of 0.75 provides a good trade off between performance and space) will reduce the space cost but will
increase the lookup cost of myMap.get(…) and myMap.put(…) methods. When the number of entries in the
HashMap exceeds the current capacity * loadfactor then the capacity of the HasMap is roughly doubled by
calling the rehash function. It is also very important not to set the initial capacity too high or load factor too
low if iteration performance or reduction in space is important.

Avoid where possible

The code below is hard to maintain and understand by
others. Also gets more complicated as the requirements
grow in the future because we are throwing different
types of objects like Integer, String etc into a list just
based on the indices and it is easy to make mistakes
while casting the objects back during retrieval.

List myOrder = new ArrayList()
ResultSet rs = …
While (rs.hasNext()) {
List lineItem = new ArrayList();
lineItem.add (new Integer(rs.getInt(“itemId”)));
lineItem.add (rs.getString(“description”));
….
myOrder.add( lineItem);
}
return myOrder;

Example 2:
List myOrder = new ArrayList(10);
//create an order
OrderVO header = new OrderVO();
header.setOrderId(1001);
…
//add all the line items
LineItemVO line1 = new LineItemVO();
line1.setLineItemId(1);
LineItemVO line2 = new LineItemVO();
Line2.setLineItemId(2);

Better approach

When storing items into a collection define value objects as shown
below:

(VO is an acronym for Value Object).

public class LineItemVO {
private int itemId;
private String productName;
public int getLineItemId(){return accountId ;}
public int getAccountName(){return accountName;}
public void setLineItemId(int accountId ){
this.accountId = accountId
}
//implement other getter & setter methods
}

Now let’s define our base wrapper class, which represents an order:

public abstract class Order {
int orderId;
List lineItems = null;
public abstract int countLineItems();
public abstract boolean add(LineItemVO itemToAdd);
public abstract boolean remove(LineItemVO itemToAdd);
public abstract Iterator getIterator();
public int getOrderId(){return this.orderId; }
}
Now a specific implementation of our wrapper class:
public class OverseasOrder extends Order {
public OverseasOrder(int inOrderId) {
this.lineItems = new ArrayList(10);
this.orderId = inOrderId;
}

How can I customize the seralization process?

2007-01-23T05:31:00.000+05:30

Yes it is possible to have control over serialization process. The class should implement Externalizable interface. This interface contains two methods namely readExternal and writeExternal. You should implement these methods and write the logic for customizing the serialization process.

How does Java handle integer overflows and underflows?
It uses those low order bytes of the result that can fit into the size of the type allowed by the operation.

Why do threads block on I/O?
Threads block on i/o (that is enters the waiting state) so that other threads may execute while the i/o Operation is performed.

Does importing a package imports the subpackages as well? e.g. Does importing com.MyTest.* also import com.MyTest.UnitTests.*?

2007-01-23T05:25:00.000+05:30

No you will have to import the subpackages explicitly. Importing com.MyTest.* will import classes in the package MyTest only. It will not import any class in any of it's subpackage.

What is the difference between declaring a variable and defining a variable?

In declaration we just mention the type of the variable and it's name. We do not initialize it. But defining means declaration + initialization. e.g String s; is just a declaration while String s = new String ("abcd"); Or String s = "abcd"; are both definitions.

Can a level class be private or protected?
No. A level class can not be private or protected. It can have either "public" or no modifier. If it does not have a modifier it is supposed to have a default access. If a level class is declared as private the compiler will complain that the "modifier private is not allowed here". This means that a level class can not be private. Same is the case with protected.

What type of parameter passing does Java support?
In Java the arguments are always passed by value .

Primitive data types are passed by reference or pass by value?
Primitive data types are passed by value.

Objects are passed by value or by reference?
Java only supports pass by value. With objects, the object reference itself is passed by value and so both the original reference and parameter copy both refer to the same object .

what are the differences between a Web container, Web server, servlet container and an application server?

2007-01-01T07:03:00.000+05:30

Typically, a Web server refers to an execution infrastructure that handles HTTP requests and responses; a servlet container refers to a component that handles the lifecycle for servlets; an application server refers to a framework (servlet container, EJB container, JSP engine, MQ container, etc.) for handling Web applications. However, a Web container has a couple of meanings depending on the source. Most refer to a Web container as the part of an application server that manages servlets, JavaServer Pages (JSP) files, and other Web-tier components. Some refer to a Web container as the infrastructure for managing the lifecycle for Web services.

List of Java Versions

2006-12-31T04:18:00.000+05:30

1995: Version 1.0 of the Java Development Kit (JDK) was released for free by Sun.
8 packages with 212 classes
Netscape 2.0-4.0 included Java 1.0.
Microsoft and other companies licensed Java.

1997: Version 1.1:
23 packages - 504 classes
Improvements include better event handling, inner classes, improved JVM.
Microsoft developed its own 1.1. compatible Java Virtual Machine for the Internet Explorer.
Many browsers in use are still compatible only with 1.1.
Swing packages of greatly improved graphics became available during this time but not included with the core language.

1999: Version 1.2, also called the Java 2 Platform
59 packages - 1520 classes
Code and tools distributed as The Software Development Kit (SDK)
Java Foundation Classes (JFC), based on Swing, for improved graphics and user interfaces, now included with the core language.
Collections API included support for various lists, sets, and hash maps.

2000: Version 1.3:
76 packages - 1842 classes
Performance enhancements including the Hotspot virtual machine.

2002: Version 1.4:
135 packages - 2991 classes
Improved IO, XML support, etc.

2004: Version 5.0 (previously numbered 1.5):
165 packages, over 3000 classes
Faster startup and smaller memory footprint
Metadata
Formatted output
Generics
Improved multithreading features

Web Application Security Cheat Sheet

2006-11-27T12:04:00.000+05:30

This is a handy reference, but it is good to keep in mind that no book, or article about security is ever exaustive or conclusive. It is a good starting point, but you can't assume that it covers every possible security problem your web application could encounter.

http://www.petefreitag.com/item/574.cfm

What is the JavaMail API?

2006-09-01T11:11:00.000+05:30

The JavaMail API is a set of abstract APIs that model a mail system. The API provides a platform independent and protocol independent framework to build Java technology based email client applications. The JavaMail API provides facilities for reading and sending email. Service providers implement particular protocols. Several service providers are included with the JavaMail API package; others are available separately. The JavaMail API is implemented as a Java optional package that can be used on JDK 1.4 and later on any operating system. The JavaMail API is also a required part of the Java Platform, Enterprise Edition (Java EE).

Implementing High Performance Web Services Using JAX-WS 2.0

2006-08-14T23:47:00.000+05:30

By Bharath Mundlapudi, August 2006 E-mail

Download

Articles Index

Service-oriented architecture (SOA) allows businesses to enable legacy systems and new software products as a service to a wider audience by way of the Internet. Web services technology is the cornerstone of SOA implementation, which involves complex business transactions between various business entities. XML processing, the core component of web services technology, involves SOAP processing, XML binding, and XML parsing. Understanding various traits of the Web Services Description Language (WSDL) is important for gaining better performance and scalability of web services.

This article shows how to implement high performance web services using the Java API for XML Web Services (JAX-WS) 2.0 and provides feature and performance comparisons with the Java API for XML-Based RPC (JAX-RPC) 1.1. The performance data in this article will help you design highly performant web services.

Web Services Stack Overview
Sun's initial implementation of web services was called JAX-RPC 1.1 (JSR 101). This was a standards-based implementation, but the binding and parsing layers underneath it were proprietary. Additionally, JAX-RPC 1.1 does not completely cover schema specification.

Sun's newer version of the web services stack, JAX-WS 2.0 (JSR 224), is completely standards based. Even the binding layer, the Java Architecture for XML Binding (JAXB, JSR 222), and the parsing layer, the Streaming API for XML (StAX, JSR 173) are standards based and also support schema specification 100 percent.

SCJA Mock Exams

2006-08-10T21:45:00.000+05:30

Whizlabs SCJA Certification Exam Simulator Trial Version
There are 2 free exams available in this trial version. Trial exam has 16 questions with answers and reports. Diagnostic exam has 51 questions without answers and reports.

Sun ePractice Sample Questions for the Sun Certified Associate for the Java Platform
There are 10 free sample questions in this exam simulator by Sun Microsystems. Free registration is required to access this exam.

Download Java API Secifications

2006-08-04T23:44:00.000+05:30

Java API for XML Web Services (JAX-WS)
These are the API specifications for the Java API for XML Web Services.

Java Architecture for XML Binding (JAXB)
These are the API specifications for Java Architecture for XML Binding(JAXB).

Java API for XML Messaging (JAXM)
These are the API specifications for Java API for XML Messaging (JAXM).

Java API for XML Processing (JAXP)
These are the API specifications for Java API for XML Processing (JAXP).

Java API for XML Registries (JAXR)
These are the API specifications for Java API for XML Registries (JAXR).

Java API for XML-based RPC (JAX-RPC)
These are the API specifications for Java API for XML-based RPC (JAX-RPC).

SOAP with Attachments API for Java (SAAJ)
These are the API specifications for SOAP with Attachments API for Java (SAAJ).

Java API for XML Web Services Addressing (JAX-WSA)
These are the API specifications for the Java API for XML Web Services Addressing.

Java API for XML Web Services Addressing (JAX-WSA)

2006-08-04T23:39:00.000+05:30

The Java API for XML Web Services Addressing (JAX-WSA) is a new component in Project GlassFish. It provides an implementation of the WS-Addressing specification, currently under development at the World Wide Web Consortium. JAX-WSA is also a part of Project Tango, Sun Microsystem's Web Services Interoperability Technology.

The JAX-WSA component is an EA release designed to give Web services developers a first look at this new technology in the Java WSDP. It is experimental in that it relies on a somewhat different line of code for JAX-WS than is installed by default with the open-source Java EE 5-compliant application server in Project GlassFish.

Users should note that the JAX-WSA component is not installed by default but requires a custom installation. Please see the installation instructions below for more information.

Installation Instructions for Solaris, Linux, UNIX
Installation Instructions for Microsoft Windows

JAX-WS is now an open-source project at java.net! Check it out, join in, and make your contribution to this vital technology.

why the Java Vector class is called a "Vector"?

2006-08-03T20:15:00.000+05:30

"Vector" is a common name for an array of one dimension.
I think that it was designed to be accessed in only one direction - from start to end. Of course, you can write code to iterate backwards...
But the enumeration it goes you don't have a getPrev() method, only a getNext():
for (Enumeration e = v.elements() ;
e.hasMoreElements() {
System.out.println(e.nextElement());
}
So a Vector has dimension (number of elements) and direction (in terms of access).

Is it possible to update the version of java automatically like antivirus?

2006-08-03T19:42:00.000+05:30

Yes, If u install latest version of java 1.4.2_01 and later. java updated is new features of SDK/JRE.Its purpose is to provide the latest version of java in flexible way

Why String class is immutable?

2006-08-01T19:39:00.000+05:30

JVM internally maintains the "String Pool". To achive the memoryefficiency, JVM will refer the String object from pool. It will notcreate the new String objects. So, whenevr you create a new stringliteral, JVM will check in the pool whether it already exists or not.If already present in the pool, just give the reference to the sameobject or create the new object in the pool. There will be manyreferences point to the same String objects, if someone changes thevalue, it will affect all the references. So, sun decided to make itimmutable.

e-Books

2006-07-24T13:31:00.000+05:30

http://worldebookfair.com

What are some advantages and disadvantages of Java Sockets?

2006-07-21T09:43:00.000+05:30

Some advantages of Java Sockets:
Sockets are flexible and sufficient. Efficient socket based programming can be easily implemented for general communications. Sockets cause low network traffic. Unlike HTML forms and CGI scripts that generate and transfer whole web pages for each new request, Java applets can send only necessary updated information.

Some disadvantages of Java Sockets:
Security restrictions are sometimes overbearing because a Java applet running in a Web browser is only able to establish connections to the machine where it came from, and to nowhere else on the network Despite all of the useful and helpful Java features, Socket based communications allows only to send packets of raw data between applications. Both the client-side and server-side have to provide mechanisms to make the data useful in any way.

. What happens if a try-catch-finally statement does not have a catch clause to handle an exception that is thrown within the body of the try statemen

2006-07-10T21:36:00.000+05:30

The exception propagates up to the next higher level try-catch statement (if any) or results in the program's termination.

Types of Exceptions

2006-07-07T13:20:00.000+05:30

Java provides support for both checked and unchecked exceptions. The main differences between these exceptions is summarised below.

Checked Exception
extends Exception
caller must handle exception
e.g. FileNotFoundException

Unchecked Exception
extends RuntimeException
caller does not have to handle exception
e.g. NullPointerException

So, when should you use checked exceptions and when should you use unchecked exceptions?

A good guidline is to throw checked exceptions when the caller can reasonable handle a failure and can perform appropriate action. For example a client could easily perform some corrective action if a FileNotFound exception were to be thrown. If however the system throws a ClassCastException (which is an unchecked exception), there's not much that the caller could do about this. In this case, it may be better to throw a unchecked exception.

In J2EE containers, unchecked exceptions are caught by the container, and would, for example, cause an EJB transaction to be rolled back.

In Spring, unchecked exceptions are used extensively for data access code in the form of DataAccessExceptions. Typically if an error occurs in data access code, the client application cannot recover and a roll-back operation is performed. In this case unchecked exceptions (e.g. DataAccessException) are appropriate.

If a class is located in a package, what do you need to change in the OS environment to be able to use it?

2006-07-05T21:38:00.000+05:30

You need to add a directory or a jar file that contains the package directories to the CLASSPATH environment variable. Let's say a class Employee belongs to a package com.xyz.hr; and is located in the file c:\dev\com\xyz\hr\Employee.java. In this case, you'd need to add c:\dev to the variable CLASSPATH. If this class contains the method main(), you could test it from a command prompt window as follows:

c:\>java com.xyz.hr.Employee

What is a task's priority and how is it used in scheduling?

2006-07-05T09:39:00.000+05:30

A task's priority is an integer value that identifies the relative order in which it should be executed with respect to other tasks. The scheduler attempts to schedule higher priority tasks before lower priority tasks.

Does it matter in what order catch statements for FileNotFoundException and IOExceptipon are written?

2006-06-30T09:29:00.000+05:30

Yes, it does. The FileNoFoundException is inherited from the IOException. Exception's subclasses have to be caught first.

Can we use the constructor, instead of init(), to initialize servlet?

2006-06-28T09:07:00.000+05:30

Yes , of course you can use the constructor instead of init(). There’s nothing to stop you. But you shouldn’t. The original reason for init() was that ancient versions of Java couldn’t dynamically invoke constructors with arguments, so there was no way to give the constructur a ServletConfig. That no longer applies, but servlet containers still will only call your no-arg constructor. So you won’t have access to a ServletConfig or ServletContext.

EJB Interview Questions Part-1

2006-06-27T20:30:00.000+05:30

What is the need of Remote and Home interface. Why cant it be in one?
The main reason is because there is a clear division of roles and responsabilities between the two interfaces. The home interface is your way to communicate with the container, that is who is responsable of creating, locating even removing one or more beans. The remote interface is your link to the bean, that will allow you to remotely access to all its methods and members. As you can see there are two distinct elements (the container and the beans) and you need two different interfaces for accessing to both of them.

Can I develop an Entity Bean without implementing the create() method in the home interface?
As per the specifications, there can be 'ZERO' or 'MORE' create() methods defined in an Entity Bean. In cases where create() method is not provided, the only way to access the bean is by knowing its primary key, and by acquiring a handle to it by using its corresponding finder method. In those cases, you can create an instance of a bean based on the data present in the table. All one needs to know is the primary key of that table. i.e. a set a columns that uniquely identify a single row in that table. Once this is known, one can use the 'getPrimaryKey()' to get a remote reference to that bean, which can further be used to invoke business methods.

What is the difference between Context, InitialContext and Session Context? How they are used?
javax.naming.Context is an interface that provides methods for binding a name to an object. It's much like the RMI Naming.bind() method.

javax.naming.InitialContext is a Context and provides implementation for methods available in the Context interface.

Where as SessionContext is an EJBContext object that is provided by the EJB container to a SessionBean in order for the SessionBean to access the information and/or services or the container.

There is EntityContext too which is also and EJBContext object that'll be provided to an EntityBean for the purpose of the EntityBean accessing the container details. In general, the EJBContext (SessionContext and EntityContext), AppletContext and ServletContext help the corresponding Java objects in knowing about its 'context' [environment in which they run], and to access particular information and/or service. Whereas, the javax.naming.Context is for the purpose of 'NAMING' [by the way of referring to] an object.

java e-Books

2006-06-23T15:50:00.000+05:30

http://www.sap-img.com/java/java-books.htm

How many Design Patterns are there in Java ?

2006-06-23T15:28:00.001+05:30

In j2ee they have 15 Design Pattern:

Presentation Tier:
1.Intercepting Filter
2. Front Controller
3. View Helper
4. Composite View
5. Service to Worker
6. Dispatcher View

Business Tier:
7. Business Delegate
8. Transfer Object
9. Session Facade
10. Service Locator
11. Transfer Object
12. Value List Handler
13. Composite Entity

Integration Tier:
14.Service Activator
15 Data Access Object