How to build our own library using java

1. Create a "Java Project" named as "OurOwnLibrary", and create a "Class" named "OurOwnLibrary" add three method named "diplayStaticMethod", "diplayNonStaticMethod", "diplayMethodWithArgument" under "OurOwnLibrary" class.

Here is the project Structure:

OurOwnLibrary.java

package ourownlibrary;

/**
 *
 * @author Aravind Sankaran Nair
 */
public class OurOwnLibrary {

    /**
     * @param args the command line arguments
     */
    public static String diplayStaticMethod() {
        // TODO code application logic here
        return "You are using OurOwnLibrary Class and its diplayStaticMethod()";
    }
     public String diplayNonStaticMethod() {
        // TODO code application logic here
        return "You are using OurOwnLibrary Class and its diplayNonStaticMethod()";
    }
     public String diplayMethodWithArgument(String myArgument) {
        // TODO code application logic here
        return "You are using OurOwnLibrary Class and its diplayNonStaticMethod(). Argument is "+myArgument;
    }
}

Right click "OurOwnLibrary" project and select clean and build.
A jar file is created in dist  folder in which the project is located.

2. Create a "Java Project" named as "OurOwnLibraryImplimentaion", and create a "Class" named "OurOwnLibraryImplimentaion".

 Here is the project Structure:

OurOwnLibraryImplimentaion.java

package ourownlibraryimplimentaion;
import ourownlibrary.OurOwnLibrary;

/**
 *
 * @author Aravind Sankaran Nair
 */
public class OurOwnLibraryImplimentaion {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        System.out.println(OurOwnLibrary.diplayStaticMethod());
        OurOwnLibrary ourOwnLibrary=new OurOwnLibrary();
        System.out.println(ourOwnLibrary.diplayNonStaticMethod());
        System.out.println(ourOwnLibrary.diplayMethodWithArgument("aravind"));
    }
}


 Right click "OurOwnLibraryImplimentaion " project and select properties.
A new window popups
Select libraries
Click Add JAR/Folder
A new window popups and ask you to add external jar file.
Specify the jar file location (ie, jar file inside dist folder of OurOwnLibrary project)
After selection the jar file, clik open
Now the jar file is listed in the librarylist
Click ok.
Run OurOwnLibraryImplimentaion.java

Output:
You are using OurOwnLibrary Class and its diplayStaticMethod()
You are using OurOwnLibrary Class and its diplayNonStaticMethod()
You are using OurOwnLibrary Class and its diplayNonStaticMethod(). Argument is aravind

How to create our own Marker Interface in java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package markerinterface;

/**
 *
 * @author Aravind Sankaran Nair
 */
public class MarkerInterface {
    public static void main(String args[]){
        MarkerImplementation markerImplementation=new MarkerImplementation();
       
      if(markerImplementation instanceof FirstMarker)  {
           System.out.println(markerImplementation.display());
      }
      if(markerImplementation instanceof SecondMarker)  {
          System.out.println(markerImplementation.display());
      }
    }
}
interface FirstMarker{
   
}
interface SecondMarker{
   
}
class MarkerImplementation implements FirstMarker{
   String display(){        
       return getClass().getInterfaces()[0].getSimpleName()+" interface is implimented";
   }
   
}

Output:
FirstMarker interface is implimented

WSDL (Web Services Description Language)

             As communications protocols and message formats are standardized in the     web community, it becomes increasingly possible and important to be able to describe the communications in some structured way.WSDL addresses this need by defining an XML grammar for describing network services as collections   of communication  endpoints  capable of  exchanging messages.

                    WSDL service  definitions provide documentation for   distributed systems and serve as a recipe for automating the details involved in applications communication

               A WSDL document defines services as collections of network endpoints, or ports. In WSDL, the abstract definition of endpoints and messages is separated from their concrete network deployment or data format bindings. This allows the reuse of abstract definitions: messages, which are abstract descriptions of the data being exchanged, and port types which are abstract collections of operations. The concrete protocol and data format specifications for a particular port type constitutes a reusable binding. A port is defined by associating a network address with a reusable binding, and a collection of ports define a service. Hence, a WSDL document uses the following elements in the definition of network services:

•           Types– a container for data type definitions using some type system (such as XSD).

•           Message– an abstract, typed definition of the data being communicated.

•           Operation– an abstract description of an action supported by the service.

•           Port Type–an abstract set of operations supported by one or more endpoints.

•           Binding– a concrete protocol and data format specification for a particular port type.

•           Port– a single endpoint defined as a combination of a binding and a network address.

•           Service– a collection of related endpoints.

               It is important to observe that WSDL does not introduce a new type definition language.   WSDL recognizes the need for rich type systems for describing message formats, and supports the XML Schemas specification (XSD) [11] as its canonical type system. However, since it is unreasonable to expect a single type system grammar to be used to describe all message formats present and future, WSDL allows using other type definition languages via extensibility.

                In addition, WSDL defines a common binding mechanism. This is used to attach a specific protocol or data format or structure to an abstract message, operation, or endpoint. It allows the reuse of abstract definitions.

               In addition to the core service definition framework, this specification introduces specific binding extensions for the following protocols and message formats:

•           SOAP 1.1

•           HTTP GET / POST

•           MIME

Structure Of A WSDL Document

<definitions>

<types>

 definition of types........

</types>

<message>

 definition of a message....

</message>

<portType>

 definition of a port.......

</portType>

<binding>

  definition of a binding....

</binding>

</definitions>

What is a Web service

Web service is a way of communication that allows interoperability between different applications on different platforms, for example, a java based application on Windows can communicate with a .Net based one on Linux. The communication can be done through a set of XML messages over HTTP protocol.

Web services are browsers and operating system independent service, which means it can run on any browser without the need of making any changes.

The World Wide Web Consortium (W3C) has defined the web services. According to W3C, “Web Services are the message-based design frequently found on the Web and in enterprise software. The Web of Services is based on technologies such as HTTP, XML, SOAP, WSDL, SPARQL, and others.”

Types of web services

WSDL

• WSDL stands for Web Services Description Language
• WSDL is an XML-based language for describing Web services.
• WSDL is a W3C recommendation

SOAP

• SOAP stands for Simple Object Access Protocol
• SOAP is an XML based protocol for accessing Web Services.
• SOAP is based on XML
• SOAP is a W3C recommendation

UDDI

• UDDI stands for Universal Description, Discovery and Integration
• UDDI is a directory service where companies can search for Web services.
• UDDI is described in WSDL
• UDDI communicates via SOAP

RDF

• RDF stands for Resource Description Framework
• RDF is a framework for describing resources on the web
• RDF is written in XML
• RDF is a W3C Recommendation

Dynamic class loading and invoking its methods

package dynamic;
import java.lang.reflect.Method;
/**
 *
 * @author Aravind Sankaran
 */
public class DynamicClassLoading {
    public static void main(String ar[]){       
        Class noParameter[]={};
        Class stringParameter[]=new Class[1];      
        stringParameter[0]=String.class;       
        try{
            System.out.println("Dynamic Loading");
            Class classLoader=Class.forName("dynamic.Dynamic");
            Object object=classLoader.newInstance();
            Method method=classLoader.getDeclaredMethod("display",noParameter);
            method.invoke(object, null);
            method=classLoader.getDeclaredMethod("display", stringParameter);
            method.invoke(object,"Aravind");
           
        }catch(Exception e){
           
        }
    }     
}
class Dynamic{
   public void display(){
        System.out.println("Inside Dynamic Class");
    }
   public void display(String name){
        System.out.println("Inside Dynamic Class"+name);
    }
}

output:
Dynamic Loading
Inside Dynamic Class
Inside Dynamic Class Aravind