Quartz Job Scheduler -- Part 1 (Setting up development project in Netbeans 6.1 beta)

Setting up development project in Netbeans 6.1 beta

Step 1 :Run Netbeans IDE and create a New Java project opening the new project creation wizard like below.
Step 2: Click on the Next button and enter the project name. Here i am giving the name as "MyQuartz". Click on finish. (see the below figure)
Step 3: Download Quartz from the location --> http://www.opensymphony.com/quartz/download.action . Once downloaded extract the archive to a location.
Step 4: The below table explains the files inside the extracted archive.

Files/Directory	Purpose
quartz-all-.jar	Quartz library includes the core Quartz components and all optional packages. If you are using this library then no other quartz-*.jars need to include.
quartz-.jar	core Quartz library.
quartz-jboss-.jar	optional JBoss Quartz extensions such as the Quartz startup MBean, QuartzService.
quartz-oracle-.jar	optional Oracle specific Quartz extensions such as the OracleDelegate
quartz-weblogic-.jar	optional WebLogic specific Quartz extensions such as the WebLogicDelegate
build.xml	an "ANT" build file, for building Quartz.
docs	root directory of all documentation
docs/wikidocs	the main documentation for Quartz. Start with the "index.html"
docs/dbTables	sql scripts for creating Quartz database tables in a variety of different databases.
src/java/org/quartz	the main package of the Quartz project, containing the 'public' (client-side) API for the scheduler
src/java/org/quartz/core	a package containing the 'private' (server-side) components of Quartz.
src/java/org/quartz/simpl	this package contains simple implementations of Quartz support modules (JobStores, ThreadPools, Loggers, etc.) that have no dependencies on external (third-party) products.
src/java/org/quartz/impl	this package contains implementations of Quartz support modules (JobStores, ThreadPools, Loggers, etc.) that may have dependencies on external (third-party) products - but may be more robust.
src/java/org/quartz/utils	this package contains some utility/helper components used through-out the main Quartz components.
src/examples/org/quartz	this directory contains some examples usage of Quartz.
webapp	this directory contains a simple web-app for managing Quartz schedulers.
lib	this directory contains all third-party libraries that are needed to use all of the features of Quartz.

Step 5: Open Add JAR/Folder wizard in netbeans like shown below.

Step 6: Add "quartz-all-1.6.0.jar" and all other jars found inside "lib" folder. See the below figure to see the added jars to the project.

Step 7: Now the Development Environment is ready.

Collection of Jars in One place

From the below URL we can find the collection of Java related jars in one place.

http://www.java2s.com/Code/Jar/CatalogJar.htm

Highlights of NetBeans 6.1

Highlights of NetBeans 6.1 include:

* JavaScript support such as semantic highlighting, code completion, type analysis, quick fixes, semantic checks and refactoring;

* Performance enhancements including faster startup and code completion;

* Spring framework support with features such as configuration file support, code completion and hyperlinks to speed navigation;

* New MySQL support in the Database Explorer to make it easier to create, launch and view MySQL databases;

* Significant enhancements to the Ruby/JRuby support, including a new Ruby platform manager, support for the latest version of Rails and new hints and quick fixes in the editor;

* Beta support for the ClearCase version control system - made available as a plugin from the Update Center.

download from --> http://dlc.sun.com.edgesuite.net/netbeans/6.1/beta/

Spring - Part I

Here is the simple example to start up with spring,

To write a simple spring application we need one interface, one implementation of that interface and a test client to test the implementation. Apart form that we also need a configuration XML file.

One interface --> Hello.java
One implementation --> HelloImpl.java
One Test Client --> HelloClient.java
One Spring XML File --> Hello.xml (Should be in the classpath).

Now let us see the interface Hello.java.

package com.javawave.spring.cli;

/**
 * @author dhanago
 */
public interface Hello
{
   /**
    * This method will return the salutation for the name passed as input
    * param to it.
    * 
    * @param name
    * @return
    */
   public String sayHello( String name );
}

The above interface has only one method to say hello. This method has to be implemented in the implementation class "HelloImpl.java"

package com.javawave.spring.cli;

/**
 * @author dhanago
 */
public class HelloImpl implements Hello
{

   private String greet;

   /**
    * zero-arg constructor
    */
   public HelloImpl()
   {
      
   }

   /**
    * @param greet
    */
   public HelloImpl( String greet )
   {
      this.greet = greet;
   }

   /*
    * (non-Javadoc)
    * 
    * @see com.javawave.spring.cli.Hello#sayHello(java.lang.String)
    */
   public String sayHello( String name )
   {

      return this.greet + name;
   }

   /**
    * @param greet the greet to set
    */
   public void setGreet( String greet )
   {
      this.greet = greet;
   }

}

The Impl class has a property called greet. This also has a setter method "setGreet" to set the value for this property.

Now let us see the spring xml. This XML file will be used for creating the objects in spring framework. This XML is also called wiring xml. Through this XML we will set the greet property of the HelloImpl class.

Hello.XML
~~~~~~~~~

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC
"-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
  <beans>
   <bean id="hello"
         class="com.javawave.spring.cli.HelloImpl">
     <property name="greet">
       <value>Good Morning!...</value>
     </property>
   </bean>
</beans>

Here in the XML you can see the tag called bean which will map to the bean what you are using in the application. It has an attribute called "id" and a attribute called "class". The "class" attribute maps to the HelloImpl.java in our case. The property tag inside the bean tag maps to the property inside the bean class. Here in our case it is the "greet" property. The value for the property is given in the value element inside the property element. This is the value passed to the bean's property "greet" . This is how spring does the dependency injection (DI). Here what you are doing is injecting dependency through setter method. This is also called Setter Injection.

Now we will see the client application "HelloClient.java" to test the "HelloImpl.java".

/**
 * 
 */
package com.javawave.spring.cli;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

/**
 * @author dhanago
 */
public class HelloClient
{

   /**
    * @param args
    */
   public static void main( String[] args )
   {
      try
      {
         System.out.println( "Inside main of HelloClient.." );
         Resource resource = new ClassPathResource(
               "com/javawave/spring/cli/Hello.xml" );
         BeanFactory factory = new XmlBeanFactory( resource );
         Hello hello = (Hello) factory.getBean( "hello" );
         String result = hello.sayHello( "Man" );
         System.out.println( result );
      }
      catch (Exception e)
      {
         System.out.println( "Exception/Error:" + e.toString() );
      }
   }
}

This client application uses ClassPathResource to load the resource. In our case Hello.xml and it creates the factory via XmlBeanFactory. factory class has getBean method which will return a object. Here we get Hello object. So from that we can call sayHello method as shown in the above code and get the result.

The Jars used for this application is:
spring.jar
commons-logging.jar

The Output is shown below:

Inside main of HelloClient..
Good Morning!...Man
Dec 3, 2007 1:59:01 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [com/javawave/spring/cli/Hello.xml]

Comparing two Value Objects in Java

In Java comparing two value object is not straight forward. Here we will see how we can compare two value objects in Java.

For that first we will create a value object called "MyValueObject". This value object contains two properties. 1) firstName 2) lastName. Both the properties are of type string.

In the same class we also have a overridden method which does the comparison for us. This method "public boolean equals(Object obj)" takes the properties and compare them individually. if the properties values are all equal then it returns true or it will return false. By doing this our test class will just call the equals method on the object to make sure if the objects are equal or not.

Code is listed below.

/*
 */
package com.blogspot.javawave;

/**
 *
 * @author dhanago
 */
public class MyValueObject
{

    private String firstName;
    private String lastName;

    /**
     * This constructor is used to set the two properties values in the class.
     *
     * @param firstName
     * @param lastName
     */
    public MyValueObject(String firstName,
                          String lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public boolean equals(Object obj)
    {
        boolean isEqual = false;
        if (this.getClass() == obj.getClass())
        {
            MyValueObject myValueObject = (MyValueObject) obj;
            if ((myValueObject.firstName).equals(this.firstName) &&
                    (myValueObject.lastName).equals(this.lastName))
            {
                isEqual = true;
            }
        }

        return isEqual;
    }
}

Test class is given below:

/*
 */
package com.blogspot.javawave;

/**
 *This class is used to test compare the value object.
 *
 * @author dhanago
 */
public class TestCompareValueObject
{

    /**
     * This is the main method used to test compare the value object.
     * @param arg
     */
    public static void main(String[] arg)
    {
        MyValueObject obj1 = new MyValueObject("Muthu", "Kumar");
        MyValueObject obj2 = new MyValueObject("Muthu", "Kumar");
       
        if (obj1.equals(obj2))
        {
            System.out.println("Both the objects are equal");
        }
        else
        {
            System.out.println("Both the objects are not equal");
        }
    }
}

This one of the way we can easily compare the value objects in Java

SOA principles

SOA principles

The following guiding principles define the ground rules for development, maintenance, and usage of the SOA^[8]

• Reuse, granularity, modularity, composability, componentization, and interoperability
• Compliance to standards (both common and industry-specific)
• Services identification and categorization, provisioning and delivery, and monitoring and tracking

The following specific architectural principles for design and service definition focus on specific themes that influence the intrinsic behaviour of a system and the style of its design:

• Service Encapsulation - A lot of existing web-services are consolidated to be used under the SOA Architecture. Many a times, such services have not been planned to be under SOA.
• Service Loose coupling - Services maintain a relationship that minimizes dependencies and only requires that they maintain an awareness of each other
• Service contract - Services adhere to a communications agreement, as defined collectively by one or more service description documents
• Service abstraction - Beyond what is described in the service contract, services hide logic from the outside world
• Service reusability - Logic is divided into services with the intention of promoting reuse
• Service composability - Collections of services can be coordinated and assembled to form composite services
• Service autonomy – Services have control over the logic they encapsulate
• Service optimization – All else equal, high-quality services are generally considered preferable to low-quality ones
• Service discoverability – Services are designed to be outwardly descriptive so that they can be found and assessed via available discovery mechanisms^[9]

In addition, the following factors should also be taken into account when defining a SOA implementation:

• SOA Reference Architecture covers the SOA Reference Architecture, which provides a worked design of an enterprise-wide SOA implementation with detailed architecture diagrams, component descriptions, detailed requirements, design patterns, opinions about standards, patterns on regulation compliance, standards templates etc.^[10]
• Life cycle management SOA Practitioners Guide Part 3: Introduction to Services Lifecycle introduces the Services Lifecycle and provides a detailed process for services management though the service lifecycle, from inception through to retirement or repurposing of the services. It also contains an appendix that includes organization and governance best practices, templates, comments on key SOA standards, and recommended links for more information.
• Efficient use of system resources
• Service maturity and performance
• EAI Enterprise Application Integration

What is WSDL?

WSDL stands for Web Services Description Language. A WSDL file is an XML document that describes a Web service. It specifies the location of the service and the operations (or methods) the service exposes. For more information about WSDL, refer to the WSDL specification, or read the WSDL tutorial