IT EINSTEIN

HTML5 More Useful Links

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 11 Feb 2012 14:18:00 +0000

Recent days HTML5 became more popular and good presentation web technology due to its excellent features. Currently we are unable to see most of the HTML5 based applications in the web as it is not using completely around the world. But we can believe that, in future HTML 5 replaces the most of the web presentation technologies. As a developer I have tried to look into it and tried to implement the some of the examples in HTML5 and I found that HTML5 has excellent features like canvas implementation, GPS integration tags, Audio and Vedio play tags.

As we have a greater scope or greater future for the HTML 5 designers, it is better to digest the things from now onwards. In my research I found so many examples in number of websites. As per my understanding I took some sites and I have classified them into three categories as mentioned below. This is only my experience over the sites and I feel, if a person wants to learn HTML 5 he has to go through the below step.

Basic:
http://www.w3schools.com/html5/default.asp
http://www.html5rocks.com/en/tutorials/video/basics/
http://www.gilbertocortez.com/blog/html5/sample-html5-structure
https://seogadget.co.uk/html5-examples-in-the-wild/

Medium:
http://html5demos.com/
http://www.w3schools.com/html/html_examples.asp
http://html5tutorial.net/
http://www.rgraph.net/examples/index.html
http://www.html5samples.com/category/new-features-in-html-5/html-5-and-css-3/
http://www.web3mantra.com/2011/09/12/30-best-html5-websites-inspirations/
http://www.html5tuts.co.uk/
http://blog.genggao.net/inspiration/beautiful-html5-web-design-showcases/

Extream:
http://webdesignledger.com/inspiration/30-examples-of-websites-using-html5
http://html5gallery.com/
http://html5websites.net/
http://www.devlounge.net/code/10-awesome-html5-canvas-examples
http://alteredqualia.com/canvasmol/#Anandamide
http://www.chromeexperiments.com/
http://www.webdesignersblog.net/inspiration/45-inspirational-examples-html5-websites/
http://www.web3mantra.com/2011/09/12/30-best-html5-websites-inspirations/
http://www.designfloat.com/blog/2011/08/11/html5-websites-best-capabilities/
http://101besthtml5sites.com/

HTML DTD for ICE faces JSPX

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 04 Feb 2012 18:09:00 +0000

Resolving the browser compatibility issues while developing the web applications is a bit complex. Most of the times developer tries to write the browser specific code. But, it is not possible to implement the browser specific code for all the pages of the application in all the scenarios and it is not required if we specify the DOCTYPE. Specifying the doctype for the page will decrease the most of the browser compatibility issues.

A doctype declaration refers to the rules for the markup language, so that the browsers render the content correctly.

The doctype declaration is not an HTML tag; it is an instruction to the web browser about what version of the markup language the page is written in.
The doctype declaration refers to a Document Type Definition (DTD). The DTD specifies the rules for the markup language, so that the browsers render the content correctly.

The doctype declaration should be the very first thing in an HTML document, before the tag.

There are different DTDs for the HTML page as specified below:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/transitional.dtd">

Specifying the DTD on JSF page which developed using ICE faces might not accept as you specify on the normal HTML page. You have to place it after the declaration of f:view tag.

<jsp:root version="2.1" xmlns:jsp="http://java.sun.com/JSP/Page"          xmlns:f="http://java.sun.com/jsf/core"          xmlns:h="http://java.sun.com/jsf/html"          xmlns:ice="http://www.icesoft.com/icefaces/component">

<jsp:directive.page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"/>
<f:view>

<ice:outputDeclaration doctypeRoot="HTML" doctypePublic="-//W3C//DTD HTML 4.01 Transitional//EN" doctypeSystem="http://www.w3.org/TR/html4/strict.dtd" />

</f:view>
</jsp:root>

Click here To Read more about fixing the browser compatibility issues.

equals() and hashCode() methods of Object Class

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Tue, 24 Jan 2012 17:57:00 +0000

HashTable, HashMap and HashSet are the Collection classes in java.util package that make use of hashing algorithm to store objects. In all these Collection classes except HashSet, objects are stored as key-value pairs. For the storage and the retrieval of any user-defined objects it is a good practice to override the following methods which is mentioned below,

hashCode()
equals()

These methods are available in the Object class and hence available to all java classes.Using these two methods, an object can be stored or retrieved from a Hashtable, HashMap or HashSet.

hashCode() method

This method returns a hashcode value as an int for the object. Default implementation for hashcode() should be overridden in order to make searching of data faster. The implementation of hashCode() method for an user-defined object should be calculated based on the properties of the class which we wish to consider.

equals() method

This method returns a boolean which specifies whether two objects are equal or not. The default implementation of equals() method given by the Object Class uses the '==' operator to compare two object references, and returns true only if they refer to the same object. But, we can meaningfully re-define this equals() method to have en equality check based on our own criterias.

Consider the following code, which defines two user defined classes Employee and EmployeeId which are supposed to be stored in a Map.

Employee.java

public class Employee {

private String name;

public Employee(String name){

this.name = name;

}

public String toString(){

return name;

}

EmployeeId.java

public class EmployeeId {

private String id;

public EmployeeId(String id){

this.id = id;

}

public String toString(){

return id;

}

The following class makes use of the above classes by storing it in a Map for later retrieval. We are adding Employee objects into the Map keyed with Employee Id.

HashCodeTest.java

public class HashCodeTest {

public static void main(String[] args) {

Map employees = new HashMap();

employees.put(new EmployeeId("111"), new Employee("Johny"));

employees.put(new EmployeeId("222"), new Employee("Jeny")); // Line A

employees.put(new EmployeeId("333"), new Employee("Jessie"));

Employee emp = employees.get(new EmployeeId("222")); // Line B

System.out.println(emp); // Line C

}

In Line B, we try to retrieve the Employee object who has Employee Id with a value of 222. We expect the output to be 'Jeny', because the Employee with Employee Id (222) was already there in the Collection, but surprisingly, the output of the above code is null. The reason is that we did not override the equals() method for EmployeeId and Employee classes because the default implementation of equals() in the Object class considers the new EmployeeId("222") in the put statement and new EmployeeId("222") in the get statement as two different instances, and hence the call to get() in Line B returns null.

Let us look at how the same code works when we provide our desired implementation for hashcode() and equals() methods. We basically override hashcode() here just to make the object to be searched fast.

Employee.java

public class Employee {

private String name;

public Employee(String name){

this.name = name;

}

public String toString(){

return name;

}

@Override

public boolean equals(Object obj){

if(obj == null) {

return false;

}

if(obj.getClass() != getClass()){

return false;

}

Employee emp = (Employee)obj;

if(this.name == emp.name){

return true;

}

return false;

}

@Override

public int hashCode(){

return name.hashCode();

}

EmployeeId.java

public class EmployeeId {

private String id;

public EmployeeId(String id){

this.id = id;

}

public String toString(){

return id;

}

public boolean equals(Object obj){

if(obj == null)

return false;

if(obj.getClass() != getClass()){

return false;

}

EmployeeId empId = (EmployeeId)obj;

if(this.id == empId.id){

return true;

}

return false;

}

@Override

public int hashCode(){

return id.hashCode();

}

Now, we get the desired output 'Jeny', because as per our implementation for the equals() method, the new EmployeeId("222") in the put statement and new EmployeeId("222") in the get statement are considered one and the same.

Introduction to RESTful Web Services

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Mon, 16 Jan 2012 18:43:00 +0000

REST is a “Representational state transfer” and it is firstly introduced by Roy Fielding (Fielding is one of the principal authors of the HTTP specification and a co-founder of the Apache HTTP Server project) in his 2000 doctoral dissertation.

REST-style services (i.e., RESTful services) adhere to a set of constraints and architectural principles that include the following:

RESTful services are stateless. As Fielding writes in Section 5.1.3 of his thesis, “each request from client to server must contain all the information necessary to understand the request, and cannot take advantage of any stored context on the server.”
RESTful services have a uniform interface. This constraint is usually taken to mean that the only allowed operations are the HTTP operations: GET, POST, PUT, and DELETE.
REST-based architectures are built from resources (pieces of information) that are uniquely identified by URIs. For example, in a RESTful purchasing system, each purchase order has a unique URI.
REST components manipulate resources by exchanging representations of the resources. For example, a purchase order resource can be represented by an XML document. Within a RESTful purchasing system, a purchase order might be updated by posting an XML document containing the changed purchase order to its URI

Thanks to 2011

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 31 Dec 2011 04:42:00 +0000

This is the time say thanks to 2011, it brought remarkable changes in my life and its gave me the confidence to start new things which takes me into redesign myself.

I have started my new career with a new team in a new company along with the 2011. As it is passing away I continued in learn new things, interacting with many number of people, continued in improving communication skills, I have learned many technical skills. So, I got the many appreciations and many recognitions for my dedicated work in the team. Finally I like to stress is 2011 brought considerable change in my work.

I am very sad for the retiring of 2011, and I am very happy in welcoming the new year 2012 which might bring more colorful and more happiness into my life. I hope 2012 brings more remarkable changes than 2011, and I wish you all the best for you all.

I am welcoming you all in inviting the new year.... :) so...

HAPPY NEW YEAR 2012 all for you my dear friends...:)

Front Controller - Core J2EE design patterns

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 19 Nov 2011 14:03:00 +0000

Front Controller pattern tells that, “There should be a Single entry and exit point for each and every request made by the user on a single application expecting for a single type of result and the same single controller may interact with different systems or programs to build the response for the request”.

For a better manageability of an application use a Front Controller as the initial point of contact for handling all related requests. The Front Controller centralizes control logic that might otherwise be duplicated, and manages the key request handling activities.

The Front Controller pattern suggests centralizing the handling of all requests but, it does not limit the number of handlers in the system, as does a Singleton. An application may use multiple controllers in a system, each mapping to a set of distinct services

Most of the current MVC based frameworks are using the Front Controller design pattern internally to handle the request from the multiple users.

Action Servlet is the Front controller in the Struts Framework (1.x)
Faces Servlet is the Front Controller in the JSF Framework.

Advantages:

Centralizes The Control: It works like a central place to handle system services and business logic across multiple requests and manages business logic processing and request handling. Centralized access to an application means that requests are easily tracked and logged.

Improves Manageability: Front Controller centralizes control, providing a choke point for illicit access attempts into the Web application. In addition, auditing a single entrance into the application requires fewer resources than distributing security checks across all pages.

Improves Reusability: Front Controller promotes cleaner application partitioning and encourages reuse, as code that is common among components moves into a controller or is managed by a controller.

Separates the System Processing Logic: Front Servlet seperates the System Processing logic from view and provides the better manageability from the same.

XML Parsing Example using DOM in Java

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 13 Nov 2011 16:20:00 +0000

package com.test;

import java.io.StringReader;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.CharacterData;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
public class XMLParsing {
public static void main(String arg[]) throws Exception{

String xmlRecords = "<data><employee><name>A</name>"
+ "<title>Manager</title></employee></data>";

DocumentBuilder db = DocumentBuilderFactory.newInstance().
newDocumentBuilder();
InputSource is = new InputSource();
is.setCharacterStream(new StringReader(xmlRecords));

Document doc = db.parse(is);
NodeList nodes = doc.getElementsByTagName("employee");

for (int i = 0; i < nodes.getLength(); i++) {
Element element = (Element) nodes.item(i);

NodeList name = element.getElementsByTagName("name");
Element line = (Element) name.item(0);
System.out.println("Name: " + getCharacterDataFromElement(line));

NodeList title = element.getElementsByTagName("title");
line = (Element) title.item(0);
System.out.println("Title: " + getCharacterDataFromElement(line));
}
}
public static String getCharacterDataFromElement(Element e) {
Node child = e.getFirstChild();
if (child instanceof CharacterData) {
CharacterData cd = (CharacterData) child;
return cd.getData();
}
return "";
}
}

Related Links:
XML Parsing using SAX Parser in Java
Read Properties File in java
J2EE Design Patterns

SAX Parser Example in JAVA

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 13 Nov 2011 16:14:00 +0000

package com.test;
import java.io.StringReader;
import java.util.Enumeration;
import java.util.Locale;
import java.util.ResourceBundle;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class ParseXMLUsingSAX {

public static String xmlString = "<?xml version='1.0'?><EMPLOYEE><USER_ID>admin</USER_ID><PASSWORD>admin123</PASSWORD></EMPLOYEE>";

public static void main(String argv[]) {
String fileName = "D:\\test.xml";
parseXml(fileName);
}
public static void parseXml(String fileName){
try {
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
InputSource is = new InputSource();
is.setCharacterStream(new StringReader(xmlString));
DefaultHandler handler = new DefaultHandler() {
boolean userID = false;
boolean password = false;
public void startElement(String uri, String localName,
String qName, Attributes attributes) throws SAXException {
if (qName.equalsIgnoreCase("USER_ID")) {
userID = true;
}
if (qName.equalsIgnoreCase("PASSWORD")) {
password = true;
}
}
public void endElement(String uri, String localName,
String qName) throws SAXException {
}
public void characters(char ch[], int start, int length) throws SAXException {
if (userID) {
System.out.println("userID : " + new String(ch, start, length));
userID = false;
}
if (password) {
System.out.println("password : " + new String(ch, start, length));
password = false;
}
}
};
//saxParser.parse(fileName, handler);
saxParser.parse(is, handler);
} catch (Exception e) {
e.printStackTrace();
}
}
}

Intercepting Filter – Core J2EE design patterns

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 13 Nov 2011 15:40:00 +0000

What Intercepting Filter does?

The Intercepting Filter pattern wraps existing application resources with a filter that intercepts the reception of a request and the transmission of a response.

What is the need of Intercepting Filter?

Consider a scenario, I your web application you want to check session from the every users request and if it is valid then only you want to let the user access the page. You can achieve this by checking sessions on all the servlet pages (or JSP pages) which users queries or you can do this by using Filter. In a filter you can write the logic to not enter the user without a valid session.

ie: An intercepting filter can pre-process or redirect application requests, and can post-process or replace the content of application responses. Intercepting filters can also be stacked one on top of the other to add a chain of separate, declaratively-deployable services to existing Web resources with no changes to source code.

Example for Intercepting Filter:

import java.io.IOException;
import java.util.Date;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;

public class LogFilter implements Filter {

public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {

HttpServletRequest request = (HttpServletRequest) req;

//Get the IP address of client machine.
String ipAddress = request.getRemoteAddr();

//Log the IP address and current timestamp.
System.out.println("IP "+ipAddress + ", Time "
+ new Date().toString());

chain.doFilter(req, res);
}
public void init(FilterConfig config) throws ServletException {

//Get init parameter
String testParam = config.getInitParameter("test-param");

//Print the init parameter
System.out.println("Test Param: " + testParam);
}
public void destroy() {
//add code to release any resource
}
}

Advantages:

Centralizes Control with Loosely Coupled Handlers: Filters provide a central place for handling processing across multiple requests, as does a controller. Filters are better suited to massaging requests and responses for ultimate handling by a target resource, such as a controller. Additionally, a controller often ties together the management of numerous unrelated common services, such as authentication, logging, encryption, and so forth, while filtering allows for much more loosely coupled handlers, which can be combined in various combinations.

Improves Re-usability: Filters promote cleaner application partitioning and encourages reuse. These pluggable interceptors are transparently added or removed from existing code, and due to their standard interface, they work in any combination and are reusable for varying presentations.

Declarative and Flexible Configuration: Numerous services are combined in varying permutations without a single recompile of the core code base.

Disadvantages:

Information Sharing is Inefficient: Sharing information between filters can be inefficient, since by definition each filter is loosely coupled. If large amounts of information must be shared between filters, then this approach may prove to be costly.

J2EE Design Patterns

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 12 Nov 2011 14:47:00 +0000

Recent times I have tried to look into the J2EE design patterns, as I am gaining the experience in Java development it is necessary the I should have complete Idea on the J2EE design patterns. Here I am planning to share my understanding, key points that I believe most important for normal java developer.

Most of J2EE/JEE based applications has the Presentation layer (which is visible to the user), Business Layer (which has the business components implementation) and Integration Layer (which integrates with other systems or databases). So, the people have classified the J2EE design patterns in to three types as below:

Presentation tier Patterns:

Intercepting Filter
Front Controller
Service to Worker
View Helper
Composite View
Dispatcher View

Business Tier Patterns:

Business Delegate
Service Locator
Session Façade
Value List Handler
Business Object
Composite Entity

Integration tier patterns:

Data Access Object
Service Activator
Web Service Broker
Domain Service

I have listed the most of the design patterns above which I feel more important. Most of the design patters depends on one or more, so implementation of a complete J2EE based and good architecture enterprise application requires all the design patters listed above.

Design pattern definition: A design pattern describes a proven solution, from experienced hands, for a recurring design problem. These solutions are very generic. They are described in well-defined Pattern Templates, with the most popular template defined by the Gang of four. For a recurring problem there would be a single solution in a single context ie. There would be none other than one solution for single problem in a single context.

Cute Smile

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Mon, 07 Nov 2011 15:02:00 +0000

Sorting of int values in an array

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 05 Nov 2011 18:23:00 +0000

package com.classes;
public class ManualSorting {
int[] arr = { 12, 1, 3, 22, 222, -9 };
public void ascendingOrder() {
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
int temp = 0;
if (arr[i] < arr[j]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
System.out.print(arr[i] + " ,");
}
System.out.println();
}
public void descendingOrder() {
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
int temp = 0;
if (arr[i] > arr[j]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
System.out.print(arr[i] + " ,");
}
System.out.println();
}
public static void main(String arr[]) {
ManualSorting ms = new ManualSorting();
ms.ascendingOrder();
ms.descendingOrder();
}
}

Read Properties file in Java

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 22 Oct 2011 18:11:00 +0000

package com.test;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Properties;
import java.util.ResourceBundle;
public class ReadPropetiesFile {
public static void main(String a[]){
String fileName = "test.properties";
ReadPropetiesFile readProp = new ReadPropetiesFile();
readProp.readProperties(fileName);
}
public void readProperties(String fileName){
try {
ResourceBundle labels = ResourceBundle.getBundle(fileName, Locale.ENGLISH);
Enumeration bundleKeys = labels.getKeys();
while (bundleKeys.hasMoreElements()) {
String key = (String)bundleKeys.nextElement();
String value = labels.getString(key);
System.out.println("key = " + key + ", " + "value = " + value);
}
}catch (Exception e) {
e.printStackTrace();
}
}
}

More Natural photo....

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 25 Sep 2011 15:20:00 +0000

How to fix browser compatibility issues?

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 17 Jul 2011 16:53:00 +0000

A normal developer never cares about the executing the application in different browsers while developing the application and he might doesn’t know that he will get lot of issues once the development is completed. This causes a big headache to him after completion of the application as he gets more number of cross browser compatibility issues and he can’t fix those instantly.

Fixing the cross browser compatibility issues after completion of the project is night mare for the developer. He has to start fixing the issues from the starting stage of the application development.

Below is the small discussion to fix the browser compatibility issues for different browsers like Chrome, Internet Explorer and Mozilla Firefox.

Mozilla Firefox:

The excellent feature that Firefox has is the add-ons. There are lot of add-ons you can add to Firefox in which Fire-Bug is the best add-on to fix the issues in applications while running in the Firefox browser. When you install the fire bug add-on, one bug icon displayed on the right-bottom corner of the browser.

Once you open your application in firefox and click on the bug icon, you will see a window which contains html source code as shown in the below screenshot. The developer has to analyze the code which display on the firebug window and has to fix the issues.

The error console (Ctrl+sift+J gives the error console) of the firefox browser contains the java script errors in the site. Developer has to fix those errors by analyzing and debugging the JavaScript code.

Developer can fix the css related issues by modifying the css classes in the fire bug window.

You can view the fire bug window by just pressing the button F12.

You can read more about the Fire bug on http://getfirebug.com/whatisfirebug

Internet Explorer:

Microsoft is providing the developer tool along with the Internet explorer to analyze the issues in the IE. Once the proper analysis is done by the developer and he can fix the issues by updating the changes in javascript code or css classes.

Below screen shot shows the Internet Explorer developer tool. You can open this by going to Tools --> Developer Tools or by simple pressing the key F12.

You can read more on Internet Explorer developer tools on http://petelepage.com/blog/2010/06/internet-explorer-developer-tools/

Google Chrome:

By clicking on F12 button, you can open the Developer tool in the Chrome browser. Below screen shot shows the code analyzer of the Chrome browser.

You can read more on Chrome Developer tools on http://code.google.com/chrome/devtools/docs/overview.html

I thought most of the cross browser issues comes with the javascript errors or javascript un supported methods in the browsers. If the developer cares about the javascript predefined functions while development, he can remove more number of cross browser issues.

Make the life more colorful....

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 26 Jun 2011 12:46:00 +0000

Colors are more important part of life. There are lot of colors with the combination of three major colors. Every one the world likes colors in their own way and for me, White and skyblue are favorite. Sometimes I like black too, most of my dresses are black, my shoes are black and my mobile is also black.

Here I am going to tell about the White color...

White is a symbol for peace and if you look into white for some time, your mindset will become more tension free. I think most of we choose White color for walls on that psychological reason.

So, bring more white color into your life from the black.

Below is the small collection on colorful life from the web...

Real Happiness - Nothing to write ... :)

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 25 Jun 2011 16:27:00 +0000

The Servlet init Vs Constructor

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 22 May 2011 06:31:00 +0000

Generally Servlets don’t have the Constructor, because a servlet is just like an applet in the respect that it has an init() method that acts as a constructor, an initialization code you need to run should be place in the init(), since it get called when the servlet is first loaded.

You cann’t use a Constructor instead of init() method to initialize a servlet.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 constructor 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.

Even while you trying to override the init() method you should pass the argument a ServletContext object because the container passes the ServletConfig object to the servlet only when it calls the init method. So ServletConfig will not be accessible in the constructor.

Servlet Life Cycle

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 21 May 2011 18:57:00 +0000

A servlet is a small Java program that runs within a Web server. Servlets receive and respond to requests from Web clients, usually across HTTP, the HyperText Transfer Protocol.

The methods which are used to initialize a servlet, to service requests, and to remove a servlet from the server are called servlet life cycle methods. These are three methods namely init(), service(), destroy().

Init(): The servlet container calls the init method exactly once after instantiating the servlet. The init method must complete successfully before the servlet can receive any requests

It Contains all information code for servlet and is invoked when the servlet is first loaded.

You can override this method to write initialization code that needs to run only once, such as loading a driver, initializing values and soon, another case you can leave normally blank.

public void init(ServletConfig config)throws ServletException

Service() : is called by the Servlet container after the init method to allow the servlet to respond to a request. Service method receives the request from the client and identifies the type of request and delegates them to doGet() or doPost() for processing.

public void service(ServletRequest request,ServletResponce response) throws ServletException, IOException

Destroy() : The Servlet Container calls the destroy( ) before removing a Servlet Instance from Sevice. Executes only once when the Servlet is removed from Server.

public void destroy()

Click here to know about Servlets

Java Servlets

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 21 May 2011 13:54:00 +0000

Servlet is a Java class used to extend the capabilities of servers that host applications accessed via a request-response programming model. Although servlets can respond to any type of request(like HTTP, FTP), they are commonly used to extend the applications hosted by Web servers.

Servlets runs at Server side typically Web Server or Application server, and respond to request by giving the response to user after processing the request.

A servlet that implements SingleThreadModel means that for every request, a single servlet instance is created. This implementation helps in implementing the business applications like bank transactions.

A multi-threaded servlet means that one servlet is capable of handling many requests which is the way most servlets should be implemented. This allows servlets to support systems such as on-line conferencing.

A servlet can handle multiple requests concurrently, and can synchronize requests. Servlets can forward requests to other servers and servlets.

As Servlet are written in java, they can make use of extensive power of the JAVA API,such as networking and URL access, multithreading, databaseconnectivity, RMI object serialization.

A Servlet implementation can be done in three ways:

By implementing the Sevlet interface into your class. The class which implementing the Servlet interface, should implement all the servlet life cycle methods defined in the Servlet interface.
By writing a subclass to GenricServlet present in the javax.servlet package. The subclass must override the abstract service method present in the Generic servlet class.
By writing a subclass to HttpServlet present in javax.servlet.http package. The subclass of HttpServlet must override any of the methods in doGet(), doPost(), doDelete(), doPut(), init(), destroy(), getServletInfo().

In general most of the cases Servlet implementation can done by sub classing to GenericServlet or HttpServlet.

Below are the differences between HttpServlet and GenericServlet:

HttpServlet is the subclass of GenericServlet.
Generic Servlet defines a generic, protocol-independent servlet. HttpServlet provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site.
A sub class which extends GenericServlet must implement the abstract service() method. A subclass of HttpServlet must override at least one method, usually one of these: doGet(), doPost(), doDelete(), doPut(), init(), destroy(), getServletInfo().

Click here to know Servlet Life cycles

Abstract class in Java

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 21 May 2011 11:38:00 +0000

Abstract class is class which has more than one abstract method which doesn’t have method body but at least one of its methods need to be implemented in derived Class.
Abstract classes can be used to implement the inheritance relationship between the classes that belongs same hierarchy.

Classes and methods can be declared as abstract.
Abstract class can extend only one Class.
If a Class is declared as abstract , no instance of that class can be created.
If a method is declared as abstract, the sub class gives the implementation of that class.
Even if a single method is declared as abstract in a Class , the class itself can be declared as abstract.
Abstract class have at least one abstract method and others may be concrete.
In abstract Class the keyword abstract must be used for method.
Abstract classes have sub classes.
Combination of modifiers Final and Abstract is illegal in java.

The general form of abstract class is :

abstract type name (parameter list);

The Number class in the java.lang package represents the abstract concept of numbers. It makes sense to model numbers in a program, but it doesn't make sense to create a generic number object.

Sample Abstract Classes: HttpServlet, GenericServlet

You can more avout Interface here
Click here for Difference between Abstract class and Iterface

Interface in Java

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 21 May 2011 11:21:00 +0000

Interfaces can be used to implement the Inheritance relationship between the non-related classes that do not belongs to the same hierarchy, i.e. any Class and any where in hierarchy. Using Interface, you can specify what a class must do but not how it does.

A class can implement more than one Interface.

An Interface can extend one or more interfaces, by using the keyword extends.

All the data members in the interface are public, static and Final by default.

An Interface method can have only Public, default and Abstract modifiers.

An Interface is loaded in memory only when it is needed for the first time.

A Class, which implements an Interface, needs to provide the implementation of all the methods in that Interface.

If the Implementation for all the methods declared in the Interface are not provided , the class itself has to declare abstract, other wise the Class will not compile.

If a class Implements two interface and both the Intfs have identical method declaration, it is totally valid.

If a class implements two interfaces both have identical method name and argument list, but different return types, the code will not compile.

An Interface can’t be instantiated. Intf Are designed to support dynamic method resolution at run time.

An interface can not be native, static, synchronize, final, protected or private.

The Interface fields can’t be Private or Protected.

A Transient variables and Volatile variables can not be members of Interface.

The extends keyword should not used after the Implements keyword, the Extends must always come before the Implements keyword.

A top level Interface can not be declared as static or final.

If an Interface species an exception list for a method, then the class implementing the interface need not declare the method with the exception list.

If an Interface can’t specify an exception list for a method, the class can’t throw an exception.

If an Interface does not specify the exception list for a method, the class can not throw any exception list.

The general form of Interface is
Access interface name {
         return-type method-name1(parameter-list);
            type final-varname1=value;
          }
-----------------------
Marker Interfaces : Serializable, Clonable, Remote, EventListener

Marker Interface is an Interface which does not have any method declarations. They are used to mark/tag the nature of the class.

Click here to More about Abstract class
Click here for more about Difference between Abstract class and Interface

Need of Real beauty to my second part of my life

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 21 May 2011 10:29:00 +0000

I am in need of a Real Beauty to be with me in my second part of the life as I have going to cross my bachelor life. At this point i am very happy to share my views about My Real beauty. The real beauty is not just a human being; it might be the place, object, animal etc… Here I am going to write about a beautiful lady, who should have real beauty characteristics to become part of my life.

I have used the word beauty on ladies by looking at their face so many times in the past. But once I decided to choose a real beauty as part of my life, then I used to think about how can I define a real beauty and what a real beauty is?. Sometimes I found that it is a hard to define or describe about the beauty of women. But, after understanding of real beauty I would expecting few of the characters as part of my partner.

The concept of beauty, in fact, is different from person to person. Anyone can tell you their personal definition of beauty: who they think is beautiful and who isn’t.

Small Definition of Beauty…..

So what is Beauty? Beauty is a characteristic of a person, place, object or idea that provides a perceptual experience of pleasure, meaning or satisfaction. Beauty may occur in different form, physical beauty of female, inner beauty of kind man, graceful beauty of grandeur dame and even ordinary beauty of common people.

As we seeing every day, beauty contests like Miss Universe and shows like Extreme Makeover, as well as People Magazine featuring the most beautiful people in the world. If we observe clearly the competitions, we can have a true definition of a real beauty?.The concept of these shows is, the competitors should have internal beauty including the external beauty. As per this assumption only winner will be decided.

So, beauty is just not a person face or person body structure; it is also a characteristic of a person.

True beauty doesn't need any kind of ornaments. It is a gift from God to Human beings. The person who gets blessed by nature gets blessed with precious beauty.

Expectations of My Real Beauty characters:

She should have well outside beauty like The Moon.
She should have cool mind like an Ice.
She should have a kindly heart like The Ocean.
She should too kind like Mother.
She should help to others like Tree.
Her thoughts should be cleaner like Milk.

This is my view about the real beauty. Different persons will have different views. So, others might have not consider all these points.

Thank you.

Java Singleton Design pattern

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Wed, 18 May 2011 17:41:00 +0000

A class which must create only one object (ie. One instance) irrespective of any number of object creations based on that class.

Steps to develop single ton class:-

1.Create a Private construcor, so that outside class can not access this constructor. And declare a private static reference of same class

2.Write a public Factory method which creates an object. Assign this object to private static Reference and return the object

Sample Code:-

public class SingleTonExample

{

private static SingleTonExample st=null;

private SingleTonExample()

{

System.out.println(“\nIn constructor”);

}

public static SingleTonExample getInstance()

{

if(st==null)

st=new SingleTonExample();

return st;

}

How to use the Singleton class created above is described in below class:

public class UsingSingletonClass{

public void testMethod(){

SingleTonExample st = SingleTonExample.hetInstance();

//you can use the SingleTonExample object st for your requirements

}

More about Static variable & Static method

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Tue, 17 May 2011 17:58:00 +0000

Static variables & methods are instantiated only once per class. In other words they are class variables, not instance variables. If you change the value of a static variable in a particular object, the value of that variable changes for all instances of that class.

Static methods can be referenced with the name of the class. It may not access the instance variables of that class, only its static variables. Further it may not invoke instance (non-static) methods of that class unless it provides them with some object.

--> When a member is declared a static it can be accessed before any object of its class are created.

--> Instance variables declared as static are essentially global variables.

--> If you do not specify an initial value to an instance & Static variable a default value will be assigned automatically.

--> Methods declared as static have some restrictions they can access only static data, they can only call other static data, they cannot refer this or super.

--> Static methods cant be overriden to non-static methods.

--> Static methods is called by the static methods only, an ordinary method can call the static methods, but static methods cannot call ordinary methods.

--> Static methods are implicitly "final", because overriding is only done based on the type of the objects

--> They cannot refer “this” are “super” in any way.