Step 1:- Set receiving computer in listening mode.

nc –l 9999 > abc.tar

This command will open a client socket on the current machine(say Target Machine) on port 9999 and listen on it. Whenever some program sends data on this port, it will dump those data to abc.tar file.

Step 2:- Send file from the sender computer

tar -cvpz <file or folder>  | nc 9999

This command will open a TCP/IP connection to , tar the file and send the raw stream to target machine on port 9999

This is much simpler and quicker way to transfer any file from one machine to another machine. There are many ways to use nc command some of them are listed here.

Here’s an excerpt:

A New York City subway train holds 1,200 people. This blog was viewed about 7,100 times in 2011. If it were a NYC subway train, it would take about 6 trips to carry that many people.

Click here to see the complete report.

Lets see where this exploration end up.

There are some online desktop projects by gnome or igoogle , but these are in initial stage. I am talking about an online solution which moves the whole OS(say complete windows or Linux to online). We can install program on this online desktop,play games music like we do on normal system. I have not found any. Lets see when we will see these kind of softwares.

•Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.

•If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.

•It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.

I always has a doubt about contract 2. So, I try o clarify this doubt with an example. Consider a case when two objects are equals but returns difference hashCode. Here is one class with bas hashCode and equals methos. I am specifying this class only for example.

class myclass{
int value;
public myclass(int value){
this.value = value;
}
public String toString(){
return "" + value;
}
public boolean equals(Object obj){
return true;
}
public int hashCode(){
return value;
}

Here we always returns true from equals methos, which says that all the objects are equals. But returns different values of hashCode.
Now create a HashSet and store theese value:-

import java.util.*;
public class test{
public static void main(String args[]){
HashSet set = new HashSet();
myclass myObject1 = new myclass(12);
myclass myObject2 = new myclass(13);
set.add(myObject1);
set.add(myObject2);
System.out.println("HashSet is:"+set);
HashSet set2 = new HashSet();
set2.add("vivek");
set2.add("vivek");
System.out.println("HashSet2 is:"+set2);
}
}

Here is the output:-

C:\DOCUME~1\Vivek>java test
HashSet is:[12, 13]
HashSet2 is:[vivek]

If you see the output you realize that eventough myObject1 and myObject2 are equals they are stored as different in HashSet, which is not the case with “vivek”.
The reason behind this is that, the concept of equality is different in “hash based” collection. Given an object the system store these values in two levels one at bucket and another the values in side the bucket.

When we insert myObject1, system will calculate the hash value by calling hashCode method and this value determine the exact bucket under which this “myObject1” will fall. Just assume that this is mapped to bucket1.

Bucket1 —> myObject1

When we add another value system will first verify if the value is already present. In normal case this will happens by just calling equals method, nut in clase of “hash based colelction” this happens in two steps. First hashCode of myObject2 is determined and this will decide the bucket, next system will search this bucket and calls equals method to check if any duplicate value is present. In this case myObject2 will be mapped to different bucket(in indeal situation this should be mapped to bucket1) and hence system will fail to verify that already an equal object(myObject1) is inserted.

Bucket2 –> myObject2

And hence two duplicate values will be inserted in a set which is wrong.
The concept of equality is different in case of “hash based collection”, two objects are considered equal only of they are equal(pass equals()) and have same hashCode.

The same concept applies with HashTable also. Lets modify the program little bit:-

import java.util.*;
public class test{
public static void main(String args[]){
Hashtable table1 = new Hashtable();
myclass myObject1 = new myclass(12);
myclass myObject2 = new myclass(13);
table1.put(myObject1,"abcde");
table1.put(myObject2,"bcdeff");
System.out.println("Hashtable 1 is:"+table1);

Hashtable table2 = new Hashtable();
table2.put("vivek","abcde");
table2.put("vivek","bcdeff");
System.out.println("Hashtable 2 is:"+table2);
}
}

Here is the output:-

C:\DOCUME~1\Vivek>java test
Hashtable 1 is:{13=bcdeff, 12=abcde}
Hashtable 2 is:{vivek=bcdeff}

Same reason as describe above applies here. myObject1 and myObject2 are treated differently eventhough they are equals, which is not the case with String (“vivek”)

We can develop a webservice eith by using Servlet Container Model or by EJB container model. Here I use servlet cotainer model to develop a web service.

Here is our simple business method:-

package com.vivek.hello;
public class Hello{
public String sayHello(String userName){
return "Hello "+ userName;
}
}
}
Exposing this business method is bery simple. We just need to add some annotations and package it as a war file.

Annotations:-
1.javax.jws.WebService :- This annotation is placed at class level and this tells that the class is a web service.
2.javax.jws.WebMethod :- This annotation is placed at method level and this tells that this method is exposed as Wbservice.

After applying these 2 annotation our class looks like:-

package com.vivek.hello;
import javax.jws.WebMethod;
import javax.jws.WebService;
@WebService
public class Hello{
@WebMethod
public String sayHello(String userName){
return "Hello "+ userName;
}
}
}
Now we have to write deployment descriptor for this webservice. This is same like writing deployment descriptor for a servlet.

Web.xml content:-

Packaging:-

Create a war file with the above class and web.xml.

That’s it. Here we have developed a simple web service. Place this war file in
folder and start the Jobss server.

To check this WebService open a browser and put http://localhost:8080//Hello/?wsdl. Ie( http://localhost:8080/JbossWs/Hello/?wsdl) If you get wsdl description then this web service is deployed successfully.

Here is the output of the browser:-

Accessing webservice:-
There are three methods to access a webservice:-
1.Stub.
2.Dynamic Proxy
3.Dymaic Invocation Interface(DII):-

Stub is very simple, here we use the wsdl to generate different stub and skelton classes usind WSDL to Java conversion tool(http://ws.apache.org/axis/java/user-guide.html#UsingWSDLWithAxis ) and use these classes to access the web service like any standalone java program.

DII and Dynamic Proxy are more flexiable. Here we generate the stub skelton in runtime. These two differ int the way we access the webservice. Let me demonstrate this by an example:-

Dynamic Invocation Interface:-

import java.net.URL;
import javax.xml.namespace.QName;
import javax.xml.rpc.Call;
import javax.xml.rpc.Service;
import javax.xml.rpc.ServiceFactory;
public class Test {
public static void main(String[] argv)throws Exception
{
try
{
ServiceFactory factory = ServiceFactory.newInstance();
//Lookup Service. . Service is entry point for a web service.
Service service = factory.createService(new URL(
"http://localhost:8080/JbossWS/?wsdl"), new QName(
"http://hello.vivek.com/", "HelloService"));
//A webservice can have di,fferent port. Port is like a library of methods.
//Set the location of wsdl.
Call call = service.createCall(new QName("http://hello.vivek.com/","HelloPort" ),new QName("http://hello.vivek.com/","sayHello"));
//Register input parameter and return type.

Object[] params = {"Vivek"};
//Invoke the method.
String result = (String)call.invoke(params);
//Print the result.
System.out.println(result);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}

Output:-

Here we execute the method using method name. This is like reflection API. Once we know the details we can call the methods in runtime. This is more flexible than Stub as we dont need to complie the calsses if out webservice interface changes.

Hello Vivek

Note:- Here I used AXIS to call web service.

Dynamic Proxy:-

Dynamic proxy is less flexiable than DII and more flexiable than Dtub. Here we dynamically look up webservice interface.

Letus first create a new webservice with interface:-

Business Interface:-

package com.vivek.hello.common;

@WebService
public interface IHello extends Remote{
public String sayHello(String userName) throws RemoteException;
}

Webservice Inplementation:-

package com.vivek.hello;

@WebService(endpointInterface="com.vivek.hello.common.IHello")
public class Hello implements IHello
{
@Override
@WebMethod
public String sayHello(String userName)
{
return "Greeting " + userName + "! Have a nice day...";
}
}

Here we implement a webservice interface. EndpointInterface tells that which webservice interface we are implementing. Client will use this interface to acesss the webservice mthods.

Client Code using Dynamic Proxy:

import java.net.URL;

import com.vivek.hello.common.IHello;
public class Test {
public static void main(String[] argv)throws Exception
{
try
{
ServiceFactory factory = ServiceFactory.newInstance();
//Lookup Service. . Service is entry point for a web service.
Service service = factory.createService(new URL(
"http://localhost:8080/JbossWS/?wsdl"), new QName(
"http://hello.vivek.com/", "HelloService"));
//A webservice can have di,fferent port. Port is like a library of methods.
//Set the location of wsdl.
IHello helloInterface = (IHello)service.getPort(new QName("http://hello.vivek.com/","HelloPort"),IHello.class);
//Invoke and Print the result.
System.out.println(helloInterface.sayHello("Vivek"));
}
catch (Exception e)
{
e.printStackTrace();
}
}
}

Output:-

Greeting Vivek! Have a nice day...

Static Stub:-
This is the simplest one. Here we get the wsdl file use a tool to compile(like WSDL2Java) the wsdl file which generats the client classes. We use these classes to call webservice client.