Step by Step to create web services in Hybris e-commerce suit | E-commerce domain ERP

Create a new extension

We will create a new extension similar to the one already covered in Trail+~New+Extension, to expose our webservice. However we won't define any new Items in the data model.

1. Open the Ant view in Eclipse and invoke the platform's task extgen. 
   1. Enter the name "cuppywstrail" for the extension WHICH MUST BE ONE WORD IN LOWER CASE
   2. Enter the package prefix "de.hybris.platform.cuppywstrail" also WHICH MUST BE ALL IN LOWER CASE
   3. Select yempty for the extension template
2. The Ant script will now create a skeleton extension for you in <YOURPATH>/bin/custom/cuppywstrail but this is not yet imported into Eclipse
3. Import the generated extension into your Eclipse environment
   1. Right-click in package explorer and select Import
   2. Select General|Existing Projects into Workspace and browse to the new extension <YOURPATH>/bin/custom/cuppywstrail
   3. Remember to ensure that the "Copy projects into workspace" check box is not checked before clicking on the Finish button
   4. You should now see the extension in your Eclipse Package Explorer
   5. You can ignore any build errors currently being reported as the configuration is not yet complete
4. Append the new extension to config/localextensions.xml file in the config project:
   config/localextensions.xml

   ...    <extension dir="${HYBRIS_BIN_DIR}/custom/cuppywstrail"/> </extensions>

5. Run Ant's all task from Eclipse
   1. This will generate the Java Source files representing the Data Entities ("items") in all the -items.xml files (see buildprocessessentials for an overview)
   2. See the output in Eclipse's console view and wait for completion
6. Load the generated files into Eclipse and build
   1. Select all top-level projects in the Package Explorer, right-click and select refresh - this will reload all generated files into Eclipse
      
   2. Ensure that in Eclipse the option Project|Build Automatically is checked
   3. Eclipse will now start to build your project
7. Explore your new extension's structure
8. Run hybris and ensure your new extension is accessible
   1. Start hybris (by executing hybrisserver.bat or ./hybrisserver.sh from the command line in the directory <YOURPATH>/bin/platform)
   2. Open http://localhost:9001/cuppywstrail and verify that you get a simple message with the extension name, "cuppywstrail" and "welcome to my extension" below it.
   3. You can also verify that your extension is running by opening http://localhost:9001 under Platform/Extensions. You should see "cuppywstrail" in the list.
      
      This tells you that the extension is now running

Generated Classes

As discussed in Trail+~+New+Data+Model, the hybris build framework generates a number of java source files for each item type defined in items.xml. This includes:

• models created for the service layer (business logic should go there)
• classes created to support CRUD logic via RESTful URIs
• low-level Jalo classes which we won't discuss as their use is discouraged

We will now explore the classes generated for supporting the CRUD cycle through RESTful webservice calls.
A Stadium Data Entity is defined in cuppytrail's items.xml file. As described in Trail+~+New+Data+Model, we should expect to see several files generated for this entity including DTOs and Resources. These were created for the cuppytrail extension where we defined the Item type Stadium. It is important to note that they are actually created in the platform project. To verify that these classes exist, search for them in Eclipse, using the Navigate Menu / Open Type, or the shortcut key Ctrl-Shift-T. If you search for "StadiumDTO", for example, you will see that it has been created in the platform project, in the package de/hybris/platform/cuppytrail/dto which is located in the web/gensrc folder.

• Since DTOs and Resources are located in the platform's web folder, they are in the web-layer of the platform. If we try and reference them in code which is in our web layer, i.e. the web folder of the cuppywstrail extension, they will not be in the build path. Web-layers within separate extensions are not able to see each other's classes. Eclipse handles this by dynamically applying a build path to the entire workspace, but when you build your project with Ant, any references you make, for example to the data transfer object for Stadium, will result in a build failure. Individual web applications do not share the same class loaders which matches the final deployment scenario. However this usually turns out to be quite inconvenient for developing and deploying.

• Next we will see how to solve this problem.

Webservice nature

To allow the cuppywstrail extension to expose the Stadium item type to a web service client, we need to do two things:
First, we need make the cuppywstrail extension visible to the cuppytrail extension where the Stadium class is defined.
Add the following tags inside the extension tag in extensioninfo.xml of the cuppywstrail project.

extensioninfo.xml

<requires-extension name="cuppy"/> <requires-extension name="cuppytrail"/>

Next we need include the generated DTOs and Resources from cuppytrail in our classpath.
This is done by assigning cuppywstrail a "webservice nature which generates the file core-webservices.jar containing the platform's generated DTOs and Resources in cuppywstrail/webroot/WEB-INF/lib. As the folder is included in cuppywstrail's classpath, we can now reference and extend the DTOs and Resources. A new web.xml file will be created, as well as the file cuppywstrail/resources/cuppywstrail-web-spring.xml redirecting requests to our webservice request handler.

• In Eclipse, drag the file cuppywstrail/build.xml into your Ant View.
• Select the cuppywstrail target webservice_nature
  
• Clean your extension by running your extension's ant clean (Note this is not the platform clean's ant task)
• Finally run the platform all ant task

The DTO class will be extended later to demonstrate how to customise DTO and Resource behaviour.
Let's summarize the previous steps:

• we created a new extension referencing the cuppytrail extension
• classes in this extension were not able to access the generated DTOs and Resources because they reside in the platform's web-layer
• we assigned a webservice nature to cuppywstrail and rebuilt the system resulting in a jar (core-webservices.jar) with DTOs and resources from the cuppytrail extension to be copied to cuppywstrail

Webservice support for the Stadium Data Entity

We have now we have enabled web service support for the Stadium Data Entity.

Perform standard CRUD operations via RESTful URIs - Attempt 1

A regular web browser is not suitable for testing our RESTful calls as we also need to be able to enter a client's username and password via a pre-emptive BASIC protocol which is not supported by a regular browser. To this end we will use a RESTful webservices client to test the web-services exposure of our Stadium object. Note that as our extension now has a web services nature, the default "welcome to my extension" message will no longer be returned from http://localhost:9001/cuppywstrail. In fact, you will get a 404 error saying "The requested resource (/cuppywstrail/) is not available.".

1. Start hybris
2. Start a RESTful Client
   1. Go to http://code.google.com/p/rest-client/downloads/list and download the REST Client
   2. Download the latest RESTClient GUI release
      
   3. Run the RESTClient and open Authentication tab, set the Authentication Mode to Basic and Enter “admin” and “nimda” as credentials
      
3. Make a RESTful request to view a list of the Stadium
   1. Type and run the URI request http://localhost:9001/cuppywstrail/rest/stadiums in the RESTful Client
   2. You will (probably) receive a response stating that you are not allowed to view this resource
      
      We will address this issue now.

Modify the RESTful access rights

As discussed in WebService API - Security Architecture users must be a member of the webservicegroup to be able to access resource via REST which is not done by default.
To verify that this user group is set up for you:

• Open the hMC and see if the usergroup webservicegroup is listed; if not:
  • Create the webservicegroup:
    
  • Add the user group AdminGroup to the user group webservicegroup:
    

Perform standard CRUD operations via RESTful URIs - Attempt 2

1. With a new user group webservicegroup defined as described in WebService API - Security Architecture and the admingroup added to it, our RESTful request with user name admin should now succeed.
   
   The request returns an XML representation of the Stadiums that are currently in the system.

   <?xml version="1.0" encoding="UTF-8"?> <stadiums uri="http://localhost:9001/cuppytrail/rest/stadiums" xmlns:ns2="http://research.sun.com/wadl/2006/10">     <stadium code="Wembley" pk="8796093065099" uri="http://localhost:9001/cuppytrail/rest/stadiums/Wembley"/>     <stadium code="Allianz" pk="8796093097867" uri="http://localhost:9001/cuppytrail/rest/stadiums/Allianz"/> </stadiums>

2. Enter the http://localhost:9001/cuppywstrail/rest/stadiums/Wembley to obtain an XML representation of the Wembley Stadium.

   <?xml version="1.0" encoding="UTF-8"?> <stadium code="Wembley" pk="8796093065099" uri="http://localhost:9001/cuppytrail/rest/stadiums/Wembley" xmlns:ns2="http://research.sun.com/wadl/2006/10">     <comments/>     <creationtime>2010-11-08T16:30:40+01:00</creationtime>     <modifiedtime>2010-11-08T16:30:40+01:00</modifiedtime>     <capacity>123456</capacity>     <matches/>     <stadiumType>openair</stadiumType> </stadium>

3. Add some matches to Wembley Stadium in the hMC.
4. Rerun the query http://localhost:9001/cuppytrail/rest/stadiums/Wembley and you will see the matches you just added.

   <?xml version="1.0" encoding="UTF-8"?> <stadium code="Wembley" pk="8796093065099" uri="http://localhost:9001/cuppytrail/rest/stadiums/Wembley" xmlns:ns2="http://research.sun.com/wadl/2006/10">     <comments/>     <creationtime>2010-11-08T16:30:40+01:00</creationtime>     <modifiedtime>2010-11-10T13:00:40+01:00</modifiedtime>     <capacity>123456</capacity>     <matches>         <match id="1" pk="8796093055137" uri="http://localhost:9001/cuppytrail/rest/stadiums/Wembley/matchs/8796093055137">             <matchday>0</matchday>         </match>         <match id="4" pk="8796093153441" uri="http://localhost:9001/cuppytrail/rest/stadiums/Wembley/matchs/8796093153441">             <matchday>0</matchday>         </match>     </matches>     <stadiumType>openair</stadiumType> </stadium>

5. Notice that the URI attributes in the XML are also URIs pointing to resources. This is a standard RESTful practice in which RESTful responses may contain URIs that in turn can be interrogated.

   Tip You may have noticed that responses are by default in XML format. hybris optionally accepts and sends responses in JSON format. To change the default, all you have to do is to set the headers for the request and response: Header Entry Value Result Accept application/xml Response is sent in XML format Accept application/json Response is sent in JSON format Content-type application/xml Body in request is expected to be in XML format Content-type application/json Body in request is expected to be in JSON format

Modify a Stadium via REST

We will now send a RESTful PUT request to modify the capacity of the wembley stadium.

• In an earlier step we invoked a RESTful call with the URI http://localhost:9001/cuppytrail/rest/stadiums/Wembley  and received the XML
  

  <?xml version="1.0" encoding="UTF-8"?> <stadium code="Wembley" pk="8796093065099" uri="http://localhost:9001/cuppytrail/rest/stadiums/Wembley" xmlns:ns2="http://research.sun.com/wadl/2006/10">     <comments/>     <creationtime>2010-11-08T16:30:40+01:00</creationtime>     <modifiedtime>2010-11-08T16:30:40+01:00</modifiedtime>     <capacity>123456</capacity>     <matches/>     <stadiumType>openair</stadiumType> </stadium>

  
  
• Modify the RESTClient's mode to PUT and set its context to text/xml.
  
  Now enter the following code in the body field:

  <stadium code="Wembley" pk="8796093065099" uri="http://localhost:9001/cuppytrail/rest/stadiums/Allianz" xmlns:ns2="http://research.sun.com/wadl/2006/10">     <capacity>11111</capacity> </stadium>

• Note that this xml was obtained by stripping down the xml returned from http://localhost:9001/cuppytrail/rest/stadiums/Wembley entering a new value for capacity.
• Invoke the RESTful call and you should then see a HTTP 1.1 200 OK status
  
• Change the RESTful client's mode back to GET
• If you now rerun the request you will find the new capacity returned. But note if you have implemented the Model Interceptor earlier in this trail, the stadium's name will now be in lowercase. As a result, the URI you need to invoke is http://localhost:9001/cuppytrail/rest/stadiums/wembley.

Custom DTOs and Custom Resources

Earlier we wrote code in your own extension that references the DTOs and Resource generated in the Platform.  Default DTO and Resource implementations may be customized by extending the respective classes.  See Customizing Resources and DTOs for a discussion on how to do this.

Triggering Commands via REST

In addition to performing CRUD on Data via REST, hybris allows you to easily create commands that can then be triggered via RESTful calls. See REST Commands Tutorial for a discussion.

Summary

In this step you should have learned

• what classes are generated for supporting RESTful CRUD operations on your Data Entities
• what the webservice_nature target is and why it is needed
• how to perform RESTful CRUD operations on your Data Entities
• how to extend DTOs and Resources
• how to write virtual DTOs

Linux and Unix Usefull command | How to Find Runtime of a Process in UNIX and Linux

 So you checked your process is running in Linux operating system and it's running find, by using ps command. But now you want to know, from how long process is running, What is start date of that process etc. Unfortunately ps command in Linux or any UNIX based operating system doesn't provide that information. But as said, UNIX has commands for everything, there is a nice UNIX tip, which you can use to check from how long a process is running. It’s been a long time, I have posted any UNIX or Linux command tutorial, after sharing some UNIX productivity tips . So I thought to share this nice little tip about finding runtime of a process in UNIX based systems e.g. Linux and Solaris. In this UNIX command tutorial, we will see step by step guide to find, since when a particular process is running in a server.


Commands to find Runtime of a process in UNIX
UNIX command to find runtime of a process in LinuxAs I said, there is no single command, which can tell us that from how long a process is running. We need to combine multiple commands, and our knowledge of UNIX based systems to find uptime of a process.

Step 1 : Find process id by using ps command e.g.

$ ps -ef | grep java
user 22031 22029   0   Jan 29 ?          24:53 java -Xms512M -Xmx512 Server

here 22031 is process id or PID. By the way if there are more than one Java process running in your server, than you might want to use a more specific grep command to find PID. Anyway, once you found PID, you can look into proc directory for that process and check creation date, that's the time when your process was started. By looking that timestamp you can easily find from how long your process is running in Linux. In order to check timestamp of any process id proc directory, you can use following ls UNIX command with option -ld as shown below :

$ ls -ld /proc/20317
dr-x--x--x   5 user     group           832 Jan 22 13:09 /proc/22031

Here process with PID 22031 has been running from Jan 22, 13:09.

That's all on How to find uptime for a process in Java. Yes, it's similar to what uptime command return for a server. I really like this UNIX tips, as it's a great tool to find from how long a process is running in UNIX or Linux

Complete Ajax Tutorial Step by Step

AJAX is a buzzword these days. What really is AJAX ? Is it a new technology ? New framework ?
AJAX ( Asynchronous Javascript And XML ) is mainly used for manipulating the part of the web page and transfering some computation to the client system. Using this technology the page need not be reloaded when a part of the page changes because of user actions. This can be achieved by dynamically getting the data from the server when user interaction happens using the XMLHTTPRequest object. This is the new approach of developing rich client application.
AJAX is the mix of :

XML and DOM

Javascript

XMLHttpRequest Object.

HTML ( or XHTML )

CSS

The traditional problem we have is, a lack of interactiveness for web applications like Desktop applications. When we submit a form or request some data from the server from the client side, the client has to wait till the request is processed and response is sent back to the client. If the server side request handler is taking long time to process the request, the client has to wait till the response comes back, probably with "working-in-background" mouse pointer or "Busy" mouse pointer. This is really annoying to the users and if user clicks many times on the windows that’s working on the request, OS may report that window as "Not Responding" and shows a blank white screen with just the title bar appearing (referring to IE on Windows). And users like me will definitely go to the taskbar and try to end the process. What if we can do this request processing work in the background asynchronously not disturbing the front-end screen and display a proper and relevant message "Processing Request" or "Waiting for reply" and allow the user to continue with some other tasks in the same window.

A Simple usecase:

In the web application I am working on has user selection field, which can be used to select any corporate user. (This is used to select users in a HTML form). Once the user selects "user selection" field and selects the particular corporate user, then the information regarding the selected user , like phone number, mailstop, mail address, manager, will be displayed in other fields of the form. The present solution developed waits till the request is processed and user can’t do any other task, like filling up other fields of the form in the same page. And sometimes, it takes nearly 30 seconds to 1 min for the response. If the user tries to click the window two or three times during this period then a blank window will appear and nothing works. And as I told you before, users like me will definitely kill the window using Task Manger and I have done that many times. This is a real annoying situation for the end user. This can be quite enough for a user to stop using the application altogether. So, what if we process that request of getting user information in the background asynchronously and still allowing the user to work on other fields of the form and process the information once we get the response from the back-end server ?
This kind of situations can be very well handled using AJAX, which has A ( Asynchronous ) at it’s core. Let’s get to the code and see how we can use AJAX in an application.

XMLHttpRequest Object:

One of the core component in AJAX framework is XMLHttpRequest object which allows asynchronous processing. XMLHttpRequest object also supports events. So, we can take actions whenever that’s necessary instead of continously checking for the status of the request. For example, we can just set a event handler to execute when the request is completed and response is received and continue with other tasks in the page and or wait for user input. This object also supports XML content. If the response is XML content then we can directly get a XML DOM object instead of taking the string and constructing the XML DOM object explicitly. Let’s look at the features of this object.

Object Methods (Most commonly used ):

open( method, URL, [isAsynchronous]) : This method is used to tell XMLHTTPRequest object which url to be considered to open the connection, what’s the method to use (GET/POST/PUT) and whether to process this request (accessing the specified URL) asynchronously or synchronously. The third parameter is option and by default it’s true, meaning that the request is processed asynchronously. The other optional parameters include username and password.
Example:
var xmlHttpRequest; //XMLHTTPRequest object
...... ( object construction goes here...will look into this later)
xmlHttpReuqest.open("GET","http://www.geocities.com/keelypavan/test.xml",true) // This method tells the object to get using GET method asynchronously. This is a dummy URL I used for demonstration purpose.
Note: This open doesn’t really open the connection to the server. We should call send(..) method for the request to be actually sent.

send( parameters as string ) : This method is used to actually send the request to the server for processing. Parameters if any specified will be sent to the server. Typically if the method id GET then the parameter will be null or an empty string or call the method without any parameters. If the method is POST then the parameter string would be the POST parameters in query string format, i.e. name=value pairs delimited by "&".
Example:
var xmlHttpRequest; //XMLHTTPRequest object
xmlHttpRequest.send( null ); //for GET
xmlHttpRequest.send( "name1=value1&name2=value2....");
Note: Make sure to set the onreadystatechange event handler before using the send method on the object.

abort():This Method aborts the request operation.
setRequestHeader( headerName, headerValue): Sets the request headers that will be sent to the server with the request.
Example:
var xmlHttpRequest; //XMLHTTPRequest object
xmlHttpRequest.setRequestHeader("IF-MODIFIED-SINCE","Sat, 04 Feb 2006 17:47:00 PST");
getResponseHeader( headerName ): Gets the specified response header sent by the server. Example response header are, content-type, content-length etc.
getAllResponseHeaders():Gets all the response header with header name and value as a string.

Properties:
readystate: Returns the ready state of the http request, which represents the internal state of the obejct. Values are listed below.

0	Unintialized
1	Loading
2	Loaded
3	Interactive
4	Completed

onreadystatechange: Sets the event handler function which will be called everytime there is a state change (readystate value change).This method is useful as we are requesting the resource from server asynchronously not waiting for the response. So, applications can use this method to come back and perform the necessary action when the request is completed.

status: Returns the status sent by the server. This status is HTTP status code. At the high level these codes mean:

1xx	Informational
2xx	Successful
3xx	Redirection
4xx	Client Error
5xx	Server Error

statusText:Returns the text message (string) associated with the status code returned by the server.
For Example: Server send "OK" with the status code 200.

responseText: Returns the content of the response as a string returned by the server. Using this properly when the object is not is completed "readystate" will give an error.

reponseXML: Returns the XML DOM Document object if the response content is XML. For this to work, the server should send the XML content with content-type set as "text/xml" otherwise the responseXML will be empty. This is an important thing for developers as sometimes everything would be fine, the response will be XML content and XML will be well-formed but the responseXML method will not return DOM Document object.
If the response content is not well-formed XML, then the responseXML will return DOM Document with the parseError properly set so that applications can be aware of the problem.

Example:
Now let’s take an example and see how AJAX works.
Note: The sample application I developed works in IE, will try to develop a cross-browser app soon.
The sample application gets the RSS feeds from http://www.traffic.com/ site and displays them in the page.

Note: As this application tries to get the RSS feeds from traffic.com site, the security option allowing access to other domain resources should be enabled.
Object Creation:First let’s look at the object creation.
Object creation code:
if( window.XMLHttpRequest )
{
try{
xmlHTTPObj = new XMLHttpRequest();
}catch(e)
{
xmlHTTPObj = null;
}
}
else if( window.ActiveXObject )
{
try{
xmlHTTPObj = new ActiveXObject("MSXML2.XMLHTTP");
}catch( e )
{
xmlHTTPObj = null;
}
if( xmlHTTPObj == null )
{
try{
xmlHTTPObj = new ActiveXObject("Microsoft.XMLHTTP");
}catch(e)
{
xmlHTTPObj = null;
}
}
}

This code uses the object detection technique to find out whether the object is defined in the browser environment. If yes, then this code creates that particular object and returns it. The other way of creating this object is using browser detection technique, meaning, check which browser is executing this piece of code and create the object accordingly. If it can't create the object, it would return a null value.

Sending Request:
Piece of code used for sending request:

document.getElementById("trafficDetails").innerHTML = "Loading Data ...";
var selectedCity = obj.options[ obj.selectedIndex ].value;
if( selectedCity != "" )
{
xmlhttp.open("GET",rssXMLBaseURL+trafficRSSXMLs.get( selectedCity ),true );
xmlhttp.setRequestHeader("If-Modified-Since","Thu, 26 Jan 2006 00:00:00 GMT");
xmlhttp.onreadystatechange = processRequest;
xmlhttp.send( "" );
}
else
{
document.getElementById("trafficDetails").innerHTML = "Select a city";
}

it uses, open(...), setRequestHeader(...), onreadystatechange, send() with the XMLHttpRequest object.
The first method used with XMLHttpRequest object is open(...). This method assigns the HTTP method to use to get the resource, URL and asynchronous flag.
setRequestHeader method is used in this case to check to see if the server resource has changed after the specified date and time. This has been set to a past date to get the content everytime.
onreadystatechange(..) method is used to set the event handler method.
At this point, the request is not yet sent but all other parameters are set. The next method send() transmits the HTTP request to the server. Be sure to set event handler method, onreadystatechange, before using send() method on the object.

Event Handler Method ( i.e. processRequest ): This method will be called every time there is a change in the readystate of the object. This method checks the readystate value and if it’s in completed state ( value 4 ) then it tries to see what’s the status code returned by the server. If status is 200 (successful) then it tries to get the content with responseXML and transforms using XSLT. You can get the XSLT source. If the status code is not 200, then it reports an error string statusText.
The piece code is:
if( xmlhttp.readystate == 4 )
{
var divObj = document.getElementById("trafficDetails");
if( xmlhttp.status == 200 )
{
divObj.innerHTML = xmlhttp.responseXML.transformNode( xsltDoc );
}
else
{
divObj.innerHTML = "Could not load data";
alert( "Error:"+xmlhttp.statusText );
}
}
End of example:

Conclusion:
AJAX is very much useful to get the dynamic content from the server. This can be used to get the content of from the server even after the page load, in better terms, lazy loading and create very rich and interactive applications.

Data Interchange formats for Ajax based applications using XML and JSON

With the introduction of Ajax, the classic web-applications are moving towards sending data instead of content to the web browser (in most of the cases). The emphasis on data interchange formats is more than before. This article points out available data interchange formats.

If you consider a normal web-application (non-Ajax), server sends some content (normally, HTML content) and like a faithful servant, web browser displays it and it may have Javascript working but to a limited level. But when we talk about richness of the application, we need something more than this. Most part of how we display the content should be left to the application running in browser, so that it can change the content or even look and feel dynamically, i.e. Ajax app, especially Javascript.

As we all know, the XMLHttpRequest is the core component of Ajax and it communicates with the server to get data to display in the browser without any reload of the page. Different applications use different data formats based on their application needs.

Following types of data interchange I can think of in the industry now.

- XML (eXtensible Markup Language)
- JSON (Javascript Object Notation)
- String with delimiters
- Script-centric approach
- Classic way of sending content.


Well, first three formats together can be considered data-centric approaches. But for clarity I am separating them. Let’s discuss each of the formats individually.

XML:

XML is a web standard for data interchange formats. It’s been around for quite sometime now. The support for XML in Javascript is very good as most of the browser implemented XML DOM specifications. The main usage of XML is that structured and hierarchical data can be represented very well and it’s readable by human beings. This comes with a cost of including meta-data, which describes what that data represents. Of course, I have seen many XML documents, which you can’t make out anything from but let’s keep that aside for now. One good thing about this is its pure data representation, which lacks in HTML. (HTML represents data intermingled with styles and formatting.)

Once you get the XML content as a response to the client-side you can use XSLT to transform the data into HTML content or you can use XML DOM API to parse and access XML and form HTML content, may be using innerHTML or standard DOM API.

Let’s take an example and see how we can represent the same data/content in all the formats. The example I am going to take is folder contents’ information. The XML is self-explanatory, so I am not spending much time explaining what it represents.

<?xml version="1.0"?>
<items>
<item>
<name>Test Document</name>
<type>document</type>
<creator>Test creator</creator>
</item>
<item>
<name>Test Folder</name>
<type>folder</type>
<creator>Test Creator 2</creator>
</item>
<item>
<name>Test Shortcut</name>
<type>shortcut</type>
<creator>Test Creator 3</creator>
</item>
</items>
JSON:

JSON is a light-weight data interchange format. It’s a text (string) representation of Javascript objects. An object in Javascript is represented in key, value pairs. A key is a string enclosed in double-quotes whereas the value can be number, string, boolean (true or false), object, array or null. Following paragraph explains JSON format in brief.

An object is a set of name, value pairs and it’s enclosed in "{" and "}". Name and value is separated by " : " and Name, value pairs are separated by " , ".

An array is ordered collection of values and is enclosed in "[" and "]" and values are separated by " , ".

Name is a string enclosed in double-quotes.

Value can be anyone of the following. String, Number, Boolean (true or false), Object, Array, null.

The advantage of JSON is that it’s more compact than XML format and parsing JSON is a lot simpler than XML. You just need to pass JSON string to eval of Javascript or you can also download JSON parsers for different programming languages from http://www.json.org/. As we have parsers for most of the famous programming languages, it makes JSON a good data interchange format. I know that a lot of people think that eval is very evil but doing eval once to evaluate the JSON string will not cause any big performance impact. But if the data grows larger then definitely JSON will not be a good option.

Example: Let’s take the same example I represented in XML and write that in JSON format.

{items:[
{"name": "Test Document", "type": "document", "creator": "Test creator"},
{"name": "Test Folder", "type": "folder", "creator": "Test Creator 2"},
{"name": "Test Shortcut", "type": "shortcut", "creator": "Test Creator 3"}
]}

String with delimiters:
Though it’s not a standard to use a plain string with delimiters as the response format, it has some advantages. We can use regular expressions or split the string into pieces using the delimiter and use the data as an array. Not much of processing is required for parsing the string.

The problem with this approach is that we need to rely on the position of the elements. And if there is any change in the positions of the elements (data) then it requires a change in the client side code. And representing deep hierarchical data is very difficult and error-prone in this approach.

Example:The data represented in two examples above could be represented in this approach as:

Test Document#document#Test creator$$Test Folder#folder#Test Creator 2$$Test Shortcut#shortcut#Test Creator 3

As you see this format is very compact because it doesn’t contain any meta-data but as the nested ness of data increases, like corporate taxonomy, representing that data is this fashion would definitely be a problem.

Script-centric approach:
In this approach a piece of script will sent from the server like assigning values to variables, function calls, which will be dynamically evaluated at the client side to perform the necessary actions.

The disadvantage of this approach is that it assumes some Javascript environment (like some functions defined in the page) at the client side. This means more coupling with the response with the page that’s requesting the resource.

Example: As we can’t represent data as-is and there will be piece of Javascript code as a response in this approach, there could be multiple ways you can represent this.

Response:
var matchingItems = {items:[
{"name": "Test Document", "type": "document", "creator": "Test creator"},
{"name": "Test Folder", "type": "folder", "creator": "Test Creator 2"},
{"name": "Test Shortcut", "type": "shortcut", "creator": "Test Creator 3"}
]} //new lines are just for clarity.

someMethod( matchingitems,… )

Content-Centric Approaches:

In the content-centric approach, the response from the server contains HTML content. So, the client side application (Javascript) has to take the content as is and place the content in any container using innerHTML or related methods. The advantage of this approach is that there is no explicit parsing of the data required. I used “explicit”, because internally when you use HTML content, the data has to parsed and shown in the web page. But the disadvantage is that it’s data with formatting tags. If you want to reuse the data of a response in this approach then we have to rely on DOM methods to retrieve the data, which is cumbersome.

Example:

As the response would be in HTML format, we can represent this in many ways depending on the need. Here is a way:

Response:

<div><span>Test Document</span><span>document</span><span>Test Creator</span></div>
<div><span>Test Folder</span><span>folder</span><span>Test Creator2</span></div>
<div><span>Test Shortcut</span><span>shortcut</span><span>Test Creator3</span></div>

We can take this content as-is and insert as HTML content in any of the allowed elements using innerHTML (or related) method. There’s not much processing required at the client side.

Sites/Apps using these formats:

XML:

Netflix

Dell

Google suggestions toolbar (new beta)

Script-centric approach:

Google Suggest

JSON format:

Yahoo provides JSON for its web services.

Conclusion: Depending on application needs, appropriate data interchange format has to be chosen. This article just describes the options available and the decision is yours.

Interview First Question : Introduce yourself / Tell something about yourself / Describe yourself

It’s probably the most common question. It’s very simple to answer this question, but a decent answer requires you to keep few things in mind before coming up with your version of the answer. Answer to this question should be concise and precise. Normally this is the first question in any interview and an effective answer to this question will boost your confidence for the entire interview. As we all know that first impression is of utmost importance, so it may be better for you to work on the answer to this question in advance instead of giving an instant reply. All the interviewers know that the candidates already know this question, so the answer you give in the interview is normally supposed to be the best you can give. Beware of it :-)

Try to cover your name, place you’re from, the highest degree you hold, years of experience (if applicable) in one-two lines. After that, you should present your qualification in the best possible way to align the acquired skills with those needed for the job you’re applying for. Don’t let the panel know that you’re not even aware of the major skills required for the job. If you feel that only a subset of skills required can be aligned with the skills you’ve acquired by your qualification, work exp, etc. then try to present yourself well aware of the gap and do mention the path you’ll follow the imbibe rest of the skills not only to make yourself fit into the profile, but to excel in that. Your learning skills, analytical skills, problem solving skills, and most importantly your attitude will come handy in such a situation. Figure out the instances in your life where you really proved something similar by using any of these (or may be some other skill). The interviewers may ask an example. You should be ready with that. But, don’t rush into the example straightaway. You may prefer to take a pause (few seconds) before explaining that example. Always keep in mind that the more interactive the session is, the better it may be for you. If you’re about to speak at length about something, present only the gist first and then seek their approval before explaining the whole idea. In the end, don’t forget to ask them if you really answered everything they wanted. For example, you may ask “Is there anything specific you wanted to know and I didn’t cover so far?”

Avoid including your percentage, CPI, honors/awards, etc., which you’ve already mentioned in your resume. You may lose their attention by doing so. They already know, so no point repeating the same. They’ll anyway ask you to elaborate on something they really want.

If you’re applying for a profile, you’ve already been into somewhere (or maybe in current employment) then try to include a reference to that in your answer. They’ll probably ask you to explain or elaborate on that. The point I’m trying to make here is that every sentence you speak while answering this question should either reflect or give you a chance to present one or more of the reasons why they should consider you a better candidate for the profile.


Sample answer:- (As I've already said that the complete answer to this question will result from the interaction you would have with the panel. This sample answer is just a starter. They may intervene in the middle. You’ll anyway end your answer by asking them if they want you to cover anything else.)


“My name is <…> (this is also there in your resume, but it’s normally included :-)). I’m from <place … city and state should suffice>, have completed my schooling from <place>, from <institute> (prefer using the name of the university only, if you think your college/institute is not among the very well known colleges/institutes). I’m currently working (if applicable) with <company> for <years> as a <profile>. I’m handling/managing/doing <mention whatever you do>. I’m quite friendly with my friends/colleagues and like to work in a team. I’m looking for <the position you're looking for> and I believe my skills and abilities are rightly suitable for that. I like to play <the sports you like>... Anything specific you wanted me to cover and I didn’t do so far?”

Tricky Overloading in Core java | Method overloading concept in java

Choosing the Most Specific Method - Tricky Method Overloading

Let's start with looking at a code-segment and try to think of the output/error, it would produce when compiled/executed and subsequently we'll discuss the behavior of code.

public class NullTest {

   public static void method(Object obj){
     System.out.println("method with param type - Object");
   }
 
   public static void method(String obj){
     System.out.println("method with param type - String");
   }
 
   public static void main(String [] args){
     method(null);
   }
}

So, what do you expect as the output here? Before thinking about the output, do you really expect the code to compile successfully? Well... yeah, the code will compile and run fine as opposed to anyone who might have sensed an ambiguity here - we'll see the reason soon.

Since the methods are overloaded, the resolution will be done at compile-time only. Which method do you see being bind here - the one with parameter type 'Object' or the one with parameter type 'String' and why? Of course, the compiler can't bind two methods with one call, so on what basis would it pick the most suitable? Which method would be picked, is evident from the output given below:-

method with param type - String

Any guesses for why a special treatment is being given to 'String' here? Well... it's not actually for 'String' class specifically, but any sub-class would get a preference over the super class in such a situation. But, why? Because JLS (Section: 15.12.2.5) allows this. It clearly says:

"If more than one member method is both accessible and applicable to a method invocation, it is necessary to choose one to provide the descriptor for the run-time method dispatch. The Java programming language uses the rule that the most specific method is chosen."

As you easily deduce that the compiler should be able to pick 'the most specific', failing which it will throw a compile-time error. Let's understand it with the below code-segment which doesn't compile because the compiler can't pick 'the most specific' here.

public class NullTest {

   public static void method(Object obj){
     System.out.println("method with param type - Object");
   }
 
   public static void method(String str){
     System.out.println("method with param type - String");
   }
 
   public static void method(StringBuffer strBuf){
     System.out.println("method with param type - StringBuffer");
   }
 
   public static void main(String [] args){
     method(null); //... compile-time error!
   }
}

Why is the compiler not able to pick 'the most specific' here - because both String and StringBuffer are are sub-classes of the Object class, but without being in the same inheritance hierarchy. For finding 'the most specific' method, the compiler needs to find a method having the parameter type, which is a sub-class of the parameter types of all other overloaded methods.

This holds true for overloaded methods having more than one parameters as well. The compiler would pick 'the most specific' by looking which method is having at least one of its parameter types as a clear sub-class of the corresponding parameter type and other parameter types being either the same or clear sub-classes, in all other overloaded methods. If it can find one, good, otherwise it will throw a compile-time error. For example:

public class NullTest {

 public static void method(Object obj, Object obj1){
   System.out.println("method with param types - Object, Object");
 }

 public static void method(String str, Object obj){
   System.out.println("method with param types - String, Object");
 }

 public static void main(String [] args){
   method(null, null);
 }
}

Output

method with param types - String, Object

In this case the compiler can easily pick 'the most specific' as the method having parameter types (String, Object) as the other overloaded method is having its parameter types as (Object, Object) - clearly 'String' is a subclass of 'Object' and the other parameter is of same type, so the method with parameter types (String, Object) can be picked with ease. But, the below code would throw a compile-time error as none of the methods satisfy the condition for being picked as 'the most specific' method.

public class NullTest {

 public static void method(Object obj, String obj1){
   System.out.println("method with param types - Object, String");
 }

 public static void method(String str, Object str1){
   System.out.println("method with param types - String, Object");
 }

 public static void main(String [] args){
   method(null, null); //... compile-time error!
 }
}