software

Create a Java web service using top down approch

Mallik1 Comment

In the bottom up approach, we will write the java class and generates the WSDL file and other dependent components. The same will be deployed into the web containers.

In Top down approach, Architects will write the WSDL file based on the requirements. Developer need to make the corresponding service implementation using the WSDL provided. This post will explain how to create a service using the WSDL file.

Step 1: Create a dynamic or java project as mentioned here

Here, I have created a sample web dynamic project with the name SampleWS as given below.

Dyanmic web project

Step 2: generate the service using top down approach

Right click on the SamplWS project name -> New -> Other

SelectOther

Select the Web Service from the wizard as below and click on Finish button.

select webservice

Select the Web service type as ‘Top down Java bean Web service’ and provide the WSDL url in the Service definition drop down and click on Finish button.

Sample WSDL URL is: http://localhost:8080/SampleWebService/wsdl/Calculator.wsdl

providethewsdl

Your Web service is ready with the Java bean methods as below and the Final folder structure looks like below:

service Folder structure

Write the business logic into the Service class as given below:

Generated class:

/**
* CalculatorSoapBindingImpl.java
*
* This file was auto-generated from WSDL
* by the Apache Axis 1.4 Apr 22, 2006 (06:55:48 PDT) WSDL2Java emitter.
*/

package in.malliktalksjava;

public class CalculatorSoapBindingImpl implements in.malliktalksjava.Calculator{
public int addition(int var1, int var2) throws java.rmi.RemoteException {
return -3;
}

public int multiplication(int var1, int var2) throws java.rmi.RemoteException {
return -3;
}

public int division(int var1, int var2) throws java.rmi.RemoteException {
return -3;
}

}

Implemented class:

/**
* CalculatorSoapBindingImpl.java
*
* This file was auto-generated from WSDL
* by the Apache Axis 1.4 Apr 22, 2006 (06:55:48 PDT) WSDL2Java emitter.
*/

package in.malliktalksjava;

public class CalculatorSoapBindingImpl implements in.malliktalksjava.Calculator{
public int addition(int var1, int var2) throws java.rmi.RemoteException {
return var1+var2;
}

public int multiplication(int var1, int var2) throws java.rmi.RemoteException {
return var1*var2;
}

public int division(int var1, int var2) throws java.rmi.RemoteException {
return var1/var2;
}

}

Deploy the application into server and use the below url as a WSDL for this to have the client.

http://localhost:8080/SampleWebService/wsdl/Calculator.wsdl

 

Other Useful Links:

 Click here to know more about webservices

Click here to know more about RESTfull web services.

Click here for Web services Question and Answers.

Click here to know how to write web service client suing java.

Write a Client for web service

Mallik4 Comments

Below steps explains how to write a web service client in java using STS IDE.

Step 1: Create a Java project using the steps mentioned here.

Step 2: Generate the stubs for the Java web service using below steps

Mouse Right click on Client project and select New -> Other

select other option

Select the Web service client from the wizard

Select webservice cliet

Provide the service WSDL url in the Service Definition text box and click on finish button.

Enterwsdl into service defination

Web service client stubs will be generated into the package and final folder structure looks below.

Client stubs generated

Write the Client class using the stubs and test the client project.

Write a client

 

Use the below sample code to write the client:

 

package in.malliktalksjava.client;

import java.rmi.RemoteException;

import in.malliktalksjava.Calculator;
import in.malliktalksjava.CalculatorServiceLocator;
import javax.xml.namespace.QName;
import javax.xml.rpc.ServiceException;

/**
* @author Javatutorials
* @since version 1.0
*
*/
public class SampleWSClient {

/**
* @param args
*/
public static void main(String[] args) {

SampleWSClient sc = new SampleWSClient();
sc.callCalculatorWebservice();
}

/**
* used to call web service
*/
public void callCalculatorWebservice(){

String wsdl = “http://localhost:8080/SampleWebService/wsdl/Calculator.wsdl”;
QName queue = new QName(“http://malliktalksjava.in”, “CalculatorService”);

try {
//create the servicelocator object
CalculatorServiceLocator calServiceLoc = new CalculatorServiceLocator(wsdl, queue);
//create the service object
Calculator calculator = calServiceLoc.getCalculator();
//call the service methods
System.out.println(“addition result : “+calculator.addition(10, 11));
System.out.println(“division result : “+calculator.division(10, 5));
System.out.println(“multiplication result : “+calculator.multiplication(10, 10));
} catch (ServiceException e) {
e.printStackTrace();
} catch (RemoteException e) {
e.printStackTrace();
}
}
}

 

With this your client application is ready to use.

 

Other Useful links:

Click here to know how to create the web service project.

Click here to know the difference between SOAP and RESTfull web services.

Singleton Design pattern in JAVA

Mallik4 Comments

Below class depicts the Singleton design pattern.

SingletonDesignPattern.java

package in.javatutorials;

/**
* @author JavaTutorials
* @version 1.0
*
*/
public final class SingletonDesignPattern {

/**
* make the class object as private as it is
* not used directly out side the class
*/
private static SingletonDesignPattern singletonObj = null;

/**
* make the constructor as private.
* Object cannot be created using the constructor outside of this class.
*/
private SingletonDesignPattern(){

}

/**
* Create the class object if it is null and
*
* @return singletonObj SingletonDesignPattern
*/
public static SingletonDesignPattern getInstance(){
if(singletonObj == null){
singletonObj = new SingletonDesignPattern();
}
return singletonObj;
}

/**
* Take the user name as parameter and return the welcome message
*
* @param userName String
* @return message String
*/
public String getWelcomeInfo(String userName){
String message = null;
//make method access to synchronized to make thread safe
synchronized (SingletonDesignPattern.class) {
System.out.println(“User Name is : ” + userName);
message = “Hello ” + userName + “!!!”;
}
return message;
}
}

 

TestSingleton.java

The main() method of below class will get the single ton object and access the other methods using the same.

package in.javatutorials;

public class TestSingleton {

public static void main(String[] args) {
//Get the singleton object
SingletonDesignPattern singletonObj = SingletonDesignPattern.getInstance();

System.out.println(singletonObj.getWelcomeInfo(“Mallik”));
}

}

Java EE 5 vs Java EE 6

MallikLeave a comment

This post visualizes changes between Java EE Standards 5 and 6. The comparison of standards is listed in four sections Web-Services, Web-Container, Enterprise Application technologies and Maintenance. Hope this helps someone.

Web Service related changes

JAVA EE 5 (JSR-244) JAVA EE 6 (JSR-316)
JAX-RPC 1.1 JSR 101 JAX-RPC 1.1
Enterprise Web Services 1.2 JSR 109 Enterprise Web Services 1.3 (new version)
Web Service Metadata 1.0 JSR 181 Web Service Metadata 1.0
Streaming API for XML 1.0 JSR 173 Streaming API for XML 1.0
JAX-WS 2.0  JSR 224 JAX-WS 2.2 (new version)
JAXB 2.0 JSR 222 JAXB 2.2 (new version)
SOAP with Attachments API for Java (SAAJ)JSR 67 Java APIs for XML Messaging 1.3 (new version)spec
new! JAX-RS 1.1 JSR 311
new! Java API for XML Registries (JAXR 1.0)JSR 93

The new redesigned Java API for XML Web Services (JAX-WS) is the base or a middle part of a newly Java EE 6 Web service stack.  The new stack  includes JAX-WS 2.0, JAXB 2.0, and SAAJ 1.3. and is also called “integrated stack”.  JAX-WS was designed to take place of JAX-RPC. Due this also JSR-109 was updated because it describes run time architecture of JEE Web Services Stack. JAXB which provides an easy way to bind an XML schema to java and vice verse, was updated to.

The SOAP with Attachments API for Java (SAAJ) (also known as Java APIs for XML Messaging (JAXM)) provides a standard way to send XML documents over the Internet from the Java platform and was updated slightly containing now other consolidated standard.

New are JAX-RS, which provides support for RESTful Web services and JAXR which enables pull-parsing API for reading and writing XML documents. Also available in Java SE.

Web Applications related changes

JAVA EE 5 JAVA EE 6
JSTL JSR 52 JSTL
JavaServer Faces 1.2 JSR 252 JavaServer Faces 2.0 (new version)
JavaServer Pages 2.1 JSR 245 JavaServer Pages 2.2 /EL 2.2 (new version)
Java Servlet 2.5 JSR 154 Java Servlet 3.0 JSR 315 (new version)
new! Debugging Support for Other Languages 1.0 JSR 45

In Java EE 6 we have updates of all technologies of the Web Container except JSTL. So e.g. Servlet 3.0 improves Servlet concept in pluggability and some ease of development. It’s also introduces Async Servlet, and long waited File Uploading!. Also now configuration can be done by annotations.

New a specification of Debugging Support for Other Languages 1.0
This describes standardized tools for correlating Java virtual machine byte code to source code of languages other than the Java programming language, so it would guarantee debugging possibility of everything what runs is JSR-45 certified container.

Enterprise Technologies changes

JAVA EE 5 JAVA EE 6
Common Annotations JSR 250 Common Annotations
JCA 1.5 JSR 112 JCA 1.6 JSR 322 (new version)
JavaMail 1.4 JavaMail 1.4
JMS 1.1 JSR 914 JMS 1.1
JTA 1.1 JSR 907 JTA 1.1
Enterprise JavaBeans 3.0 JSR 220 Enterprise JavaBeans 3.1 JSR 318
(new version)
JPA 1.0 JSR 220 (together with EJB 3.0) JPA 2.0 JSR 317 (new version)
new! Contexts and Dependency Injection for Java (Web Beans 1.0) JSR 299
new! Dependency Injection for Java 1.0 JSR 330
new! Bean Validation 1.0 JSR 303
new! Managed Beans 1.0 JSR-316

In Enterprise Application section we see some important changes and new specifications. Most famous and important is  JSR-299 Context and Dependency Injection (CDI) which is there to unify the JavaServer Faces-managed bean component model with the Enterprise JavaBeans component model to simplify the programming model and architecture of web-based applications. Look an Weld Framework as reference implementation to this.

The similar sounding Standard Dependency Injection for Java JSR-330 just define a standard and common known DI like in spring and other frameworks. Look at popular Guice DI-Framework from Google which implements JSR-330.

Bean Validation  introduces a very cool annotation based and architecture layer independent Java Bean validation.

There are also some interesting improvements in EJBs. Singleton is a new type and can be only one per container, it is also possible to use @Local Beans (Same VM) without interface. Also JPA 2.0 has advanced query possibilities and validation.

Management Technologies

JAVA EE 5 JAVA EE 6
J2EE Application Deployment 1.2 JSR 88 J2EE Application Deployment 1.2
JavaBeans Activation Framework (JAF) 1.1 JSR 925 JavaBeans Activation Framework (JAF) 1.1
J2EE Management 1.0  JSR 77 J2EE Management 1.1 (new version)
Java Authorization Contract for Containers 1.1 JSR 115 Java Authorization Contract for Containers 1.3(new version)
new! Java Authentication Service Provider Interface for Containers JSR 196
new! [JavaSE] JAXP 1.3 JSR 206
new! [JavaSE] JDBC 4.0 JSR 221
new! [JavaSE] JMX 2.0 JSR 255

Nothing special to mention here.