Notes

Websphere Process Server training docs

2012-07-27T10:44:00.000-07:00

http://publib.boulder.ibm.com/infocenter/ieduasst/v1r1m0/index.jsp?topic=/com.ibm.iea.wpi_v6/wpswid/6.2/SCA/WBPMv62_SCA_SCAToolsAndExamples/player.html

Human tasks

http://publib.boulder.ibm.com/infocenter/ieduasst/v1r1m0/index.jsp?topic=/com.ibm.iea.wpi_v6/wpswid/6.1/WID/WPIv61_WIDOverview/player.html

http://publib.boulder.ibm.com/infocenter/ieduasst/v1r1m0/topic/com.ibm.iea.wpi_v6/wpswid/6.0/Selectors/WPSWIDv6_Selectors_Overview/playershell.swf

Selectors

http://publib.boulder.ibm.com/infocenter/ieduasst/v1r1m0/topic/com.ibm.iea.wpi_v6/wpswid/6.0/BusinessRules/WPSWIDv6_BusinessRules_Overview/playershell.swf

Business rules

http://publib.boulder.ibm.com/infocenter/ieduasst/v1r1m0/index.jsp?topic=/com.ibm.iea.wpi_v6/wpswid/6.0/BusinessStateMachine/WPSWIDv6_BusinessStateMachine/player.html

BSM

http://publib.boulder.ibm.com/infocenter/ieduasst/v1r1m0/index.jsp?topic=/com.ibm.iea.wpi_v6/wpswid/6.2/MediationFlows/WBPMv62_MediationModules/player.html

http://publib.boulder.ibm.com/infocenter/ieduasst/v1r1m0/topic/com.ibm.iea.wpi_v6/wpswid/6.0.2/MediationLabs/WPIv602_ESB_UnModeledFaultsLab.pdf

requierment for enhanced for loop in java (J2SE5.0)

2012-07-27T06:55:00.000-07:00

Enhanced for loops allow convenient iteration over collections, without the need for an explicitly defined iterator. This reduces the need for boilerplate iteration code and the corresponding opportunities for errors.
as per JSR 121

Running Java without Main method

2012-07-25T11:08:00.000-07:00

StaticBlockClass.java

~~~~~~~~~~~~~~~~~~~~~

package com.anil.builder.design.pattern;

public class StaticBlockClass {

static{

System.out.println("i dont have main method");

}

TestStaticClient.java

~~~~~~~~~~~~~~~~~~~~~

package com.anil.builder.design.pattern;

public class TestStaticClient {

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {

Class.forName("com.anil.builder.design.pattern.StaticBlockClass");

}

Builder DesignPattern

2012-07-24T11:16:00.000-07:00

Builder Design pattern is used when there is a requirement for creating complex objects.
if it is a simple object you can make use of factory design pattern.

Car.java
~~~~~~~~~
package com.anil.builder.design.

pattern;

public class Car {

private String engine;
private String tyre;
private String paint;

public String getEngine() {
return engine;
}

public void setEngine(String engine) {
this.engine = engine;
}

public String getTyre() {
return tyre;
}

public void setTyre(String tyre) {
this.tyre = tyre;
}

public String getPaint() {
return paint;
}

public void setPaint(String paint) {
this.paint = paint;
}

}
----------------------------------------------------

CarBuilder.java
~~~~~~~~~~~~~~~

package com.anil.builder.design.pattern;

public interface CarBuilder {
public String makeEngine();
public String makeTyre();
public String makePaint();
public void makeCar();
public Car getCar();
}
----------------------------------------------------------

USCarBuilder.java
~~~~~~~~~~~~~~~~~~

package com.anil.builder.design.pattern;

public class USCarBuilder implements CarBuilder {

private Car car;

@Override
public String makeEngine() {
// TODO Auto-generated method stub
return "US Engine added ";
}

@Override
public String makeTyre() {
return "APPOLO tyres added";
}

@Override
public String makePaint() {
return "Red colour added";
}

@Override
public void makeCar() {
car=new Car();
car.setEngine(makeEngine());
car.setTyre(makeTyre());
car.setPaint(makePaint());
}

@Override
public Car getCar() {
// TODO Auto-generated method stub
return car;
}

}
--------------------------------------------------------

GermanCarBuilder.java
~~~~~~~~~~~~~~~~~~~~~~

package com.anil.builder.design.pattern;

public class GermanCarBuilder implements CarBuilder {

private Car car;

@Override
public String makeEngine() {
// TODO Auto-generated method stub
return "German Engine";
}

@Override
public String makeTyre() {
return "German tyres";
}

@Override
public String makePaint() {
return "Blue";
}

@Override
public void makeCar() {
car=new Car();
car.setEngine(makeEngine());
car.setTyre(makeTyre());
car.setPaint(makePaint());
}

@Override
public Car getCar() {
return car;
}

}
----------------------------------------------------

Director.java
~~~~~~~~~~~~~
package com.anil.builder.design.pattern;

public class Director {

private CarBuilder carBuilder;

public Director(CarBuilder carBuilder) {
super();
this.carBuilder = carBuilder;
}

public CarBuilder getCarBuilder() {
return carBuilder;
}

public void setCarBuilder(CarBuilder carBuilder) {
this.carBuilder = carBuilder;
}

public void build() {
carBuilder.makeCar();
}
}
-----------------------------------------------------------
Test.java
~~~~~~~~~
package com.anil.builder.design.pattern;

public class Test {

public static void main(String[] args) {
CarBuilder builder=new USCarBuilder();
Director director=new Director(builder);
director.build();
Car car=builder.getCar();
System.out.println(" Car Engine : "+car.getEngine());
}

Pattern Definition
Moves the Construction logic of the Object from the Object Class to Builder Class

Improves

Object Construction
Making new Changes
Modular Design

Abstract Factory Design Pattern in Java

2012-07-19T11:59:00.000-07:00

Definition : Provides an interface for creating families of related or dependent objects without specifying their concrete classes.

Button.java
~~~~~~~~~
package com.anil.product;

public abstract class Button {
public abstract void add(String os);
}

WinButton.java
~~~~~~~~~~~~
package com.anil.product;

public class WinButton extends Button {

@Override
public void add(String os) {
System.out.println(" Button Added name "+os+" for Windows");
}

}

LinuxButton.java
~~~~~~~~~~~~
package com.anil.product;

public class LinuxButton extends Button {
@Override
public void add(String os) {
System.out.println(" Button Added name "+os+" for Linux");

}
}

ComboBox.java
~~~~~~~~~~~~
package com.anil.product;

public abstract class ComboBox {
public abstract void add(String os);
}

WinComboBox.java
~~~~~~~~~~~~~~~~
package com.anil.product;

public class WinComboBox extends ComboBox {

@Override
public void add(String os) {
System.out.println(" Combo Box Added with name "+os+" for Windows" );
}

}

LinuxComboBox.java
~~~~~~~~~~~~~~~~
package com.anil.product;

public class LinuxComboBox extends ComboBox {
@Override
public void add(String os) {
System.out.println(" Combo Box Added name "+os+" for Linux");
}

}

OSComponents.java
~~~~~~~~~~~~~~~
package com.anil.product;

public abstract class OSComponents {
public abstract ComboBox createCombo();
public abstract Button createButton();
}

WindowsComponents.java
~~~~~~~~~~~~~~~~~~~~~
package com.anil.product;

public class WindowsComponents extends OSComponents {

@Override
public ComboBox createCombo() {
return new WinComboBox();
}

@Override
public Button createButton() {
return new WinButton();
}

}

LinuxComponents.java
~~~~~~~~~~~~~~~~~~~~
package com.anil.product;

public class LinuxComponents extends OSComponents {

@Override
public ComboBox createCombo() {
return new LinuxComboBox();
}

@Override
public Button createButton() {
return new LinuxButton();
}

}

AbstractOSComponentsFactory.java

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

package com.anil.product;

public abstract class AbstractOSComponentsFactory {
public abstract ComboBoxInf createCombo();

public abstract ButtonInf createButton();

public static AbstractOSComponentsFactory getOSFactory(String s) {
if (s == "win") {
return new WindowsComponentsFactory();
} else {
return new LinuxComponentsFactory();
}
}
}

AbstractFactoryClient.java
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
package com.anil.product;

public class AbstractFactoryClient {

public static void main(String os[]) {

AbstractOSComponentsFactory factory =AbstractOSComponentsFactory.getOSFactory("win");
factory.createButton().add("windows1");
factory.createCombo().add("windows2");

}

}

Benefits
* Isolates concrete classes
* Allows to change product family easily
* Promotes consistency among products
Usage
* When the system needs to be independent of how its products are created composed and represented.
* When the system needs to be configured with one of multiple families of products.
* When a family of products need to be used together and this constraint needs to be enforced.
* When you need to provide a library of products, expose their interfaces not the implementation.

Session Facade

2012-07-16T13:22:00.000-07:00

Problem

In a multitiered Java 2 Platform, Enterprise Edition (J2EE) application environment, the following problems arise.

if Client is exposed to the Business Objects of the application(DAO,Session Beans or Entity Beans) there will be a tight coupling between the client and the Business Objects.

if the application grows eventually the number of business objects will grow so that Client logic will become more and more complex.

if the Client is Accessing the Enterprise beans directly so There will be a heavy usage of the n/w.

if Multiple Clients are using the Business objects there will not be uniformity in the way client uses them.

To resolve the above issues we can make use of Session Facade Design pattern

Structure :

Session Facade class diagram

Participants and Collaborations

in the below Figure contains the sequence diagram that shows the interactions of a Session Facade with two entity beans, one session bean, and a DAO, all acting as participants in fulfilling the request from the client.

Session Facade sequence diagram :

you can define a Session Facade as

1. Stateless Session bean : if Business process include single method call in your business process
2. Statefull Session bean : if Business process include multiple method calls in your business process

Uses of Session Facade:

Introduces Business-Tier Controller Layer
Exposes Uniform Interface
Reduces Coupling, Increases Manageability
Improves Performance, Reduces Fine-Grained Methods
Provides Coarse-Grained Access
Centralizes Security Management
Centralizes Transaction Control
Exposes Fewer Remote Interfaces to Clients

sample code :

ProjectResourceManagerSession.java

package corepatterns.apps.psa.ejb;

import java.util.*;
import java.rmi.RemoteException;
import javax.ejb.*;
import javax.naming.*;
import corepatterns.apps.psa.core.*;
import corepatterns.util.ServiceLocator;
import corepatterns.util.ServiceLocatorException;

// Note: all try/catch details not shown for brevity.

public class ProjectResourceManagerSession
  implements SessionBean {

  private SessionContext context;

  // Remote references for the
  // entity Beans encapsulated by this facade
  private Resource resourceEntity = null;
  private Project projectEntity = null;
  ...

  // default create
  public void ejbCreate() 
  throws CreateException {
  }

  // create method to create this facade and to
  // establish connections to the required entity
  // beans
  // using primary key values
  public void ejbCreate(
    String resourceId, String projectId, ...)
  throws CreateException, ResourceException {

    try {
      // locate and connect to entity beans
      connectToEntities(resourceId, projectId, ...);
    } catch(...) {
      // Handle exceptions
    }
  }

  // method to connect the session facade to its 
  // entity beans using the primary key values
  private void connectToEntities (
    String resourceId, String projectId)
  throws ResourceException {
    resourceEntity = getResourceEntity(resourceId);
    projectEntity = getProjectEntity(projectId);
    ...
  }

  // method to reconnect the session facade to a
  // different set of entity beans using primary key
  // values
  public resetEntities(String resourceId,
    String projectId, ...)
  throws PSAException {

    connectToEntities(resourceId, projectId, ...);
  }

  // private method to get Home for Resource
  private ResourceHome getResourceHome()
  throws ServiceLocatorException {
    return ServiceLocator.      getInstance().getHome(
        "ResourceEntity", ResourceHome.class);
  }

  // private method to get Home for Project
  private ProjectHome getProjectHome()
  throws ServiceLocatorException {
    return ServiceLocator.      getInstance().getHome(
        "ProjectEntity", ProjectHome.class);  
  }

  // private method to get Resource entity
  private Resource getResourceEntity(
    String resourceId)   throws ResourceException {
    try {
      ResourceHome home = getResourceHome();
      return (Resource) 
        home.findByPrimaryKey(resourceId);
    } catch(...) {
      // Handle exceptions
    }
  }

  // private method to get Project entity
  private Project getProjectEntity(String projectId)
  throws ProjectException {
    // similar to getResourceEntity
    ...
  }

  // Method to encapsulate workflow related
  // to assigning a resource to a project.
  // It deals with Project and Resource Entity beans
  public void assignResourceToProject(int numHours)
  throws PSAException {

    try {
      if ((projectEntity == null) ||
          (resourceEntity == null)) {

        // SessionFacade not connected to entities
        throw new PSAException(...);
      }

      // Get Resource data
      ResourceTO resourceTO =
          resourceEntity.getResourceData();

      // Get Project data
      ProjectTO projectTO =
        projectEntity.getProjectData();
      // first add Resource to Project
      projectEntity.addResource(resourceTO);
      // Create a new Commitment for the Project
      CommitmentTO commitment = new
        CommitmentTO(  ...);

      // add the commitment to the Resource
      projectEntity.addCommitment(commitment);

    } catch(...) {
      // Handle exceptions
    }
  }

  // Similarly implement other business methods to
  // facilitate various use cases/interactions
  public void unassignResourceFromProject()
  throws PSAException {
    ...
  }

  // Methods working with ResourceEntity
  public ResourceTO getResourceData()
  throws ResourceException {
    ...
  }

  // Update Resource Entity Bean
  public void setResourceData(ResourceTO resource) 
  throws ResourceException {
    ...
  }

  // Create new Resource Entity bean
  public ResourceTO createNewResource(ResourceTO 
    resource)   throws ResourceException {
    ...
  }

  // Methods for managing resource's blockout time
  public void addBlockoutTime(Collection blockoutTime) 
  throws RemoteException,BlockoutTimeException {
    ...
  }
  
  public void updateBlockoutTime(
    Collection blockoutTime)   
  throws RemoteException, BlockoutTimeException {
    ...
  }
  
  public Collection getResourceCommitments() 
  throws RemoteException, ResourceException {
    ...
  }

  // Methods working with ProjectEntity
  public ProjectTO getProjectData()
  throws ProjectException {
    ...
  }

  // Update Project Entity Bean
  public void setProjectData(ProjectTO project) 
  throws ProjectException {
    ...
  }

  // Create new Project Entity bean
  public ProjectTO createNewProject(ProjectTO project)
  throws ProjectException {
    ...
  }

  ...

  // Other session facade method examples

  // This proxies a call to a Transfer Object Assembler
  // to obtain a composite Transfer Object.
  // See Transfer Object Assembler pattern
  public ProjectCTO getProjectDetailsData()
  throws PSAException {
    try {
      ProjectTOAHome projectTOAHome = (ProjectTOAHome)
        ServiceLocator.getInstance().getHome(
          "ProjectTOA", ProjectTOAHome.class);
      // Transfer Object Assembler session bean
      ProjectTOA projectTOA = 
          projectTOAHome.create(...);
      return projectTOA.getData(...);
    } catch (...) {
        // Handle / throw exceptions
    }
  }

  // These method proxies a call to a ValueListHandler
  // to get a list of projects. See Value List Handler 
  // pattern.
  public Collection getProjectsList(Date start, 
  Date end) throws PSAException {
    try {
      ProjectListHandlerHome projectVLHHome = 
        (ProjectVLHHome)
          ServiceLocator.getInstance().getHome(
            "ProjectListHandler",
            ProjectVLHHome.class);
      // Value List Handler session bean
      ProjectListHandler projectListHandler = 
        projectVLHHome.create();
      return projectListHandler.getProjects(
                    start, end);
    } catch (...) {
        // Handle / throw exceptions
    }
  }

  ...

  public void ejbActivate() {
    ...
  }

  public void ejbPassivate() {
    context = null;
  }

  public void setSessionContext(SessionContext ctx) {
       this.context = ctx;
  }

  public void ejbRemove() {
    ...
  }
}

Remote Interface :

package corepatterns.apps.psa.ejb;

import java.rmi.RemoteException;
import javax.ejb.*;
import corepatterns.apps.psa.core.*;

// Note: all try/catch details not shown for brevity.

public interface ProjectResourceManager
  extends EJBObject {

  public resetEntities(String resourceId,
  String projectId, ...)
  throws RemoteException, ResourceException ;

  public void assignResourceToProject(int numHours)
  throws RemoteException, ResourceException ;

  public void unassignResourceFromProject()
  throws RemoteException, ResourceException ;

  ...

  public ResourceTO getResourceData()
  throws RemoteException, ResourceException ;

  public void setResourceData(ResourceTO resource) 
  throws RemoteException, ResourceException ;

  public ResourceTO createNewResource(ResourceTO resource)
  throws ResourceException ;

  public void addBlockoutTime(Collection blockoutTime) 
  throws RemoteException,BlockoutTimeException ;
  
  public void updateBlockoutTime(Collection blockoutTime) 
  throws RemoteException,BlockoutTimeException ;
  
  public Collection getResourceCommitments()
  throws RemoteException, ResourceException;

  public ProjectTO getProjectData()
  throws RemoteException, ProjectException ;
  
  public void setProjectData(ProjectTO project) 
  throws RemoteException, ProjectException ;

  public ProjectTO createNewProject(ProjectTO project)
  throws RemoteException, ProjectException ;

  ...

  public ProjectCTO getProjectDetailsData()
  throws RemoteException, PSAException ;

  public Collection getProjectsList(Date start, 
  Date end) throws RemoteException, PSAException ;

  ...
}

Home Interface :

package corepatterns.apps.psa.ejb;

import javax.ejb.EJBHome;
import java.rmi.RemoteException;
import corepatterns.apps.psa.core.ResourceException;
import javax.ejb.*;

public interface ProjectResourceManagerHome 
extends EJBHome {
    
    public ProjectResourceManager create() 
            throws RemoteException,CreateException;
    public ProjectResourceManager create(String
        resourceId, String projectId, ...) 
            throws RemoteException,CreateException;
}

Note : the usage of Session Facade is depend on the application.For a smaller

application Session Facade does add much.it is useful when your application goes bigger

Resource :
http://www.oracle.com/technetwork/java/sessionfacade-135203.html
http://www.oracle.com/technetwork/java/sessionfacade-141285.html

JSP Static include and Dynamic include

2012-07-15T12:58:00.000-07:00

Static Include : <%@include file="secondInclude.jsp"%>

used to add or include static content in jsp

Dynamic Include : <jsp:include page="include.jsp"></jsp:include>

used to addup Dynamic content in JSP.

Implecit Objects of jsp

2012-07-15T12:48:00.000-07:00

request
response
out
session
page : (like this references current jsp instance)
pageContext : with context info it has access to all implicit variables of the page and used for setting the attributes of different scopes and has methods for including another URL's contents, and for forwarding or redirecting to another URL.

Ex : pageContext.include( test.jsp ); pageContext.forward( test.jsp );

application : this Object is Like ServletContext.
Exception
config : this Object is Like ServletConfig.

Collection Hierarchy in Java

2012-07-15T12:15:00.000-07:00

Collection Interface Hierarchy

_____________________________________________________________________________________________

The Core Collection Interfaces and Their Implementations

_____________________________________________________________________________________________

The Core Map Interfaces and Their Implementations

java Stack vs Heap

2012-07-14T15:03:00.000-07:00

Heap Stores :

class(static fields) and instance variables, method code and Object instances.

Stack Stores :

local method/local variables and method calls.

According to java 6 some of the instances may be stored in Stack also

public class Bicycle{

 // Class Variable

    private static int numberOfBicycles = 0;

// instance variable       
    private int id;

// Object instace

   private  Bicycle  b=null;

 public int Method1() {

     // local variables

      int i=1;

     return i;
    }

Use of Class.forName()

2012-07-14T14:23:00.000-07:00

When we create an instance of a class using new operator, it does two things

1. Load the class in to memory, if it is not loaded -
which means creating in-memory representation of the class from the .class file so that an instance can be created out of it. This includes initializing static variables (resolving of that class)
2. create an instance of that class and store the reference to the variable.

Class.forName does only the first thing.
It loads the class in to memory and return that reference as an instance of Class. If we want to create an instance then, we can call newInstance method of that class. which will invoke the default constructor (no argument constructor).
Note that if the default constructor is not accessible, then newInstance method will throw an IllegalAccessException. and if the class is an abstract class or interface or it does not have a default constructor, then it will throw an InstantiationException. If any exception araises during resolving of that class, it will throw an ExceptionInInitializerError.

If the default constructor is not defined, then we have to invoke the defiend constructor using reflection API.

But the main advantage with Class.forName is, it can accept the class name as a String argument. So we can pass the class name dynamically. But if we create an instance of a class using new operator, the class name can't be changed dynamically.

Class.forName() inturn will call loadClass method of the caller ClassLoader (ClassLoder of the class from where Class.forName is invoked).

By default, the Class.forName() resolve that class. which means, initialize all static variables inside that class.
same can be changed using the overloaded method of Class.forName(String name,boolean initialize,ClassLoader loader)

The main reason for loading jdbc driver using Class.forName() is, the driver can change dynamically.
in the static block all Drivers will create an instance of itself and register that class with DriverManager using DriverManager.registerDriver() method. Since the Class.forName(String className) by default resolve the class, it will initialize the static initializer.
So when we call Class.forName("com.sun.jdbc.odbc.JdbcOdbcDriver"),
the Driver class will be loaded, instanciated and registers with DriverManager

So if you are using new Operator you have to do the following things.

Driver drv = new com.sun.jdbc.odbc.JdbcOdbcDriver();
DriverManager.registerDriver(drv);

Why String is final in Java ? or why String is Immutable?

2012-07-14T14:02:00.000-07:00

The above two Questions are related as Immutable --> final

consider the below scenario If String is not a Final Class

i had a String Object String super="Java";

i have two subclasses of String super( parent Class) Class A and Class B.if Class A changes its reference to A="J2EE" then the reference of Class B also points to J2EE.which is not a thread safe.

Some of the reasons why it made as Immutable :

The designers wanted to guarantee that the invariants of String could not be changed by a sub-class. To guarantee that String itself would not change they implemented parent delegation in class loaders
Another reason of Why String is immutable in Java is to allow String to cache its hashcode , being immutable String in Java caches its hashcode and do not calculate every time we call hashcode method of String, which makes it very fast as hashmap key to be used in hashmap in Java.
The absolutely most important reason that String is immutable is that it is used by the class loading mechanism, and thus have profound and fundamental security aspects.As in JVM String is mostly used parameter for loading classes or opening the connections.
and one more reason is for thread safety.

so the Question is how we can design a Immutable class

Declare all fields Private Final.
Set all fields in the constructor.
Don't provide any methods that modify the state of the object; provide only getter methods (no setters).
Declare the class final, so that no methods may be overridden.
Ensure exclusive access to any mutable components, e.g. by returning copies.

Example :

import java.util.Date;
/**
* Planet is an immutable class, since there is no way to change
* its state after construction.
*/
public final class Planet {

  public Planet (double aMass, String aName, Date aDateOfDiscovery) {
     fMass = aMass;
     fName = aName;
     //make a private copy of aDateOfDiscovery     //this is the only way to keep the fDateOfDiscovery     //field private, and shields this class from any changes that      //the caller may make to the original aDateOfDiscovery object     fDateOfDiscovery = new Date(aDateOfDiscovery.getTime());
  }

  /**
  * Returns a primitive value.
  *
  * The caller can do whatever they want with the return value, without 
  * affecting the internals of this class. Why? Because this is a primitive 
  * value. The caller sees its "own" double that simply has the
  * same value as fMass.
  */
  public double getMass() {
    return fMass;
  }

  /**
  * Returns an immutable object.
  *
  * The caller gets a direct reference to the internal field. But this is not 
  * dangerous, since String is immutable and cannot be changed.
  */
  public String getName() {
    return fName;
  }
//  /**
//  * Returns a mutable object - likely bad style.
//  *
//  * The caller gets a direct reference to the internal field. This is usually dangerous, 
//  * since the Date object state can be changed both by this class and its caller.
//  * That is, this class is no longer in complete control of fDate.
//  */
//  public Date getDateOfDiscovery() {
//    return fDateOfDiscovery;
//  }
  /**
  * Returns a mutable object - good style.
  * 
  * Returns a defensive copy of the field.
  * The caller of this method can do anything they want with the
  * returned Date object, without affecting the internals of this
  * class in any way. Why? Because they do not have a reference to 
  * fDate. Rather, they are playing with a second Date that initially has the 
  * same data as fDate.
  */
  public Date getDateOfDiscovery() {
    return new Date(fDateOfDiscovery.getTime());
  }

  // PRIVATE //
  /**
  * Final primitive data is always immutable.
  */
  private final double fMass;

  /**
  * An immutable object field. (String objects never change state.)
  */
  private final String fName;

  /**
  * A mutable object field. In this case, the state of this mutable field
  * is to be changed only by this class. (In other cases, it makes perfect
  * sense to allow the state of a field to be changed outside the native
  * class; this is the case when a field acts as a "pointer" to an object
  * created elsewhere.)
  */
  private final Date fDateOfDiscovery;
}

References :

http://www.javapractices.com/topic/TopicAction.do?Id=29
http://renaud.waldura.com/doc/java/final-keyword.shtml
http://stackoverflow.com/questions/2068804/why-is-string-final-in-java

String pool in java

2012-07-14T04:27:00.000-07:00

The easiest way of creating a String object is using a string literal:

String str1 = "You cannot change me!";
String str2 = "You cannot change me!";

here str1 and str2 holds the same String literal.

so at the Compile time java compiler optimizes handling of string literals(and compile-time constant
expressions that evaluate to strings)

so for the above two String str1 and str2 holds the same character sequence so they will be sharing a single string reference .these type of String are said to be "Interned".

The String class maintains a private pool where such strings are interned.

and if you call any methods on str2 wont effect the str1 reference.

String str3 = "You cannot" + "change me!";

this intern can be applied to str3 also

String s = "change me!";

String str5 = "You cannot" + s ;

intern will not be applied to str5 so a new string will be created for str5.

and finally A string constructed with new operator will always creates a new reference in jvm.

Adding SOAP header in Webservice Handler

2012-07-10T12:03:00.000-07:00

In this program in "handleRequest" method i added a Username/password in SOAP Header.

import javax.xml.namespace.QName;
import javax.xml.rpc.handler.Handler;
import javax.xml.rpc.handler.HandlerInfo;
import javax.xml.rpc.handler.MessageContext;
import javax.xml.rpc.handler.soap.SOAPMessageContext;
import javax.xml.soap.Name;
import javax.xml.soap.SOAPElement;
import javax.xml.soap.SOAPEnvelope;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPHeader;
import javax.xml.soap.SOAPHeaderElement;
import javax.xml.soap.SOAPMessage;
import javax.xml.soap.SOAPPart;

public class WSDLServiceHandler implements Handler {
   private static final String HDR_PREFIX = "wsse";
   private static final String HDR_URI = "http://schemas.xmlsoap.org/ws/2002/07/secext";

   @Override
   public void destroy() {
   }

   @Override
   public QName[] getHeaders() {
       return null;
   }

   @Override
   public boolean handleFault(MessageContext context) {
       return true;
   }

   @Override
   public boolean handleRequest(MessageContext context) {
       try {
           SOAPMessageContext smc = (SOAPMessageContext) context;
           SOAPMessage msg = smc.getMessage();
           SOAPPart part = msg.getSOAPPart();
           SOAPEnvelope env = part.getEnvelope();
           SOAPHeader sh = msg.getSOAPHeader();
           if (sh == null) {
               sh = env.addHeader();
           }
           Name nameHdr = env.createName("Security", HDR_PREFIX, HDR_URI);
           SOAPHeaderElement security = sh.addHeaderElement(nameHdr);
           security.setMustUnderstand(false);
           security.addNamespaceDeclaration(HDR_PREFIX, HDR_URI);
           SOAPElement userNameToken = security.addChildElement("UsernameToken", HDR_PREFIX);
           userNameToken.addNamespaceDeclaration(HDR_PREFIX, HDR_URI);
           SOAPElement userName = userNameToken.addChildElement("Username",HDR_PREFIX);
           userName.addNamespaceDeclaration(HDR_PREFIX, HDR_URI);
           userName.addTextNode("USERNAME");
           SOAPElement password = userNameToken.addChildElement("Password",HDR_PREFIX);
           password.addNamespaceDeclaration(HDR_PREFIX, HDR_URI);
           password.addTextNode("UserPassword");
           String soapEnvelope = env.toString();
       } catch (SOAPException e) {
           e.printStackTrace();
       }
       return true;
   }

   @Override
   public boolean handleResponse(MessageContext context) {
       return true;
   }

   @Override
   public void init(HandlerInfo config) {
   }

}

create SOAP Element From XML String

2012-07-09T12:09:00.000-07:00

import java.io.IOException;
import java.io.StringReader;
import java.util.Iterator;
import javax.xml.parsers.*;
import javax.xml.soap.*;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

public class Test{

public static SOAPElement createSOAPElementFromXMLString(String xmlString)
        throws ParserConfigurationException, IOException, SAXException
    {
        StringReader stringReader = new StringReader(xmlString);
        InputSource inputSource = new InputSource(stringReader);
        SAXParserFactory factory = SAXParserFactory.newInstance();
        factory.setNamespaceAware(true);
        SAXParser parser = factory.newSAXParser();
        SoapElementSaxHandler handler = new SoapElementSaxHandler();
        parser.parse(inputSource, handler);
        return handler.getSOAPElement();
    }

}

SoapElementSaxHandler.java
~~~~~~~~~~~~~~~~~~~~~~
import java.util.ArrayList;
import java.util.HashMap;
import javax.xml.soap.*;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class SoapElementSaxHandler extends DefaultHandler
{

    public SoapElementSaxHandler()
    {
        prefixURIMapping = new HashMap();
        uris = new ArrayList();
        rootElement = null;
        currentElement = null;
    }

    public SOAPElement getSOAPElement()
    {
        return rootElement;
    }

    public void startDocument()
        throws SAXException
    {
        try
        {
            soapFactory = SOAPFactory.newInstance();
        }
        catch(SOAPException e)
        {
            throw new SAXException("Can't create a SOAPFactory instance", e);
        }
    }

    public void startPrefixMapping(String prefix, String uri)
    {
        prefixURIMapping.put(uri, prefix);
        uris.add(uri);
    }

    public void characters(char ch[], int start, int length)
        throws SAXException
    {
        String str = String.valueOf(ch);
        if(length > 0)
            try
            {
                currentElement.addTextNode(str.substring(start, start + length));
            }
            catch(SOAPException e)
            {
                throw new SAXException("Can't add a text node into SOAPElement from text", e);
            }
    }

    public void endElement(String uri, String localName, String qName)
    {
        if(currentElement != rootElement)
            currentElement = currentElement.getParentElement();
    }

    public void startElement(String namespaceURI, String localName, String qName, Attributes atts)
        throws SAXException
    {
        String prefix = (String)prefixURIMapping.get(namespaceURI);
        try
        {
            if(rootElement == null && currentElement == null)
            {
                rootElement = soapFactory.createElement(localName, prefix, namespaceURI);
                currentElement = rootElement;
            } else
            {
                currentElement = currentElement.addChildElement(localName, prefix, namespaceURI);
            }
            if(uris.size() > 0)
            {
                for(int i = 0; i < uris.size(); i++)
                {
                    String uri = (String)uris.get(i);
                    String pre = (String)prefixURIMapping.get(uri);
                    currentElement.addNamespaceDeclaration(pre, uri);
                }

                uris.clear();
            }
            for(int i = 0; i < atts.getLength(); i++)
            {
                javax.xml.soap.Name attriName;
                if(atts.getURI(i) != null)
                {
                    String attriPre = (String)prefixURIMapping.get(atts.getURI(i));
                    attriName = soapFactory.createName(atts.getLocalName(i), attriPre, atts.getURI(i));
                } else
                {
                    attriName = soapFactory.createName(atts.getLocalName(i));
                }
                currentElement.addAttribute(attriName, atts.getValue(i));
            }

        }
        catch(SOAPException e)
        {
            throw new SAXException(e);
        }
    }

    private HashMap prefixURIMapping;
    private ArrayList uris;
    private SOAPElement rootElement;
    private SOAPElement currentElement;
    private SOAPFactory soapFactory;
}

Create DomElement From XML String

2012-07-09T12:05:00.000-07:00

import java.io.StringReader;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.*;
import org.xml.sax.InputSource;

public class DomParser{

public static Element createDomElementFromXMLString(String xmlString)
    {
        InputSource inputSource;
        StringReader stringReader = new StringReader(xmlString);
        inputSource = new InputSource(stringReader);
        Document document;
        DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
        document = docBuilder.parse(inputSource);
        return document.getDocumentElement();
        JVM INSTR pop ;
        return null;
    }
}

Web Service Security using Apache Rampart

2012-07-07T14:20:00.000-07:00

Web Service Security Encryption with Rampart 1.4 and Axis2 1.4.1

Writing Client Based on the .JKS and .CER files

Download axis2-1.4.1-bin.zip (Standard Binary Distribution) from axis site, the URL is http://ws.apache.org/axis2/download/1_4/download.cgi
Download rampart-dist-1.4-bin.zip (Standard Binary Distribution) from Apache Rampart, the URL is http://ws.apache.org/rampart/download/1.4/download.cgi
Copy these 2 zip files in C:\ and extract it.

Creating Project in Eclipse AND CREATING CLIENT AND STUB

Create a new Project in C:\ using Eclipse with the name TestWSS. File --> New --> Java Project
Set your class path to JAVA_HOME
Open Command Prompt and Go to C:\axis2-1.4.1-bin\axis2-1.4.1\bin
Execute axis2.bat
Copy your wsdl file into C:\axis2-1.4.1-bin\axis2-1.4.1\bin (Assume the wsdl file name is meal.wsdl).
Execute the below command from command prompt
C:\axis2-1.4.1-bin\axis2-1.4.1\bin>wsdl2java -uri C:\axis2-1.4.1-bin\axis2-1.4.1\bin\meal.wsdl
After executing the above command you will get the stub and Handler class in the C:\axis2-1.4.1-bin\axis2-1.4.1\bin with package.

Placing Client Files in Project SRC and applying signature through Rampart 1.4

Copy generated file into C:\TestWSS\src folder.
Create a folder parallel to src with the name client-repo and copy module directory from C:\rampart-dist-1.4-bin\rampart-1.4\ to C:\TestWSS\client-repo.
This module folder should contain rampart-1.4.mar and addressing-1.41.mar
Add all .jar files present in the C:\rampart-dist-1.4-bin\rampart-1.4\lib directory needs to add to the Eclipse Project build path.
Add all .jar files present in the C:\axis2-1.4-bin\axis2-1.4\lib directory needs to add to the Eclipse Project build path.
Refresh the project in Eclipse and compile it this time you won’t get any compilation errors because we already set the required jars to the class path.

Writing Client Policy File
As you can see, the above security policy contains two main security assertions: an asymmetric binding assertion and a signed parts assertion. Asymmetric binding defines what keys to be used and a few additional properties such as which algorithms to be used in cryptographic operations, layout of the security header, etc. Signed parts assertion defines what parts of the message should be signed. In this tutorial we will be signing the SOAP body of the message.

Identifying Special Characters in a Given String

2012-07-07T14:18:00.000-07:00

package special;

public class IdentifySpecialChar {


   public static void main(String[] args) {

       try {
           System.out.println(IdentifySpecialChar
                   .identifyingSpecialCharacters("Anil@"));
       } catch (Exception e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
   }

   public static boolean identifyingSpecialCharacters(String value)
           throws Exception {
       boolean returnVal = false;
       char[] charArray = value.toCharArray();
       for (int i = 0; i < charArray.length; i++) {
           System.out.println((int) charArray[i]);
           if ((((int) charArray[i]) >= 32 && ((int) charArray[i]) <= 47)
                   || (((int) charArray[i]) >= 58 && ((int) charArray[i]) <= 64)
                   || (((int) charArray[i]) >= 91 && ((int) charArray[i]) <= 96)
                   || (((int) charArray[i]) >= 123 && ((int) charArray[i]) <= 127)) {
               returnVal = true;
               break;
           }
       }
       return returnVal;
   }
}

PC Tips & Tricks

2012-07-07T13:54:00.000-07:00

Create desktop icon for restart and shutdown

Do the following:
1. Right click on your desktop
2. Then in NEW click on SHORTCUT
3. A shortcut wizard will appear
4. Type this in the box:
shutdown -s -t 00
5. Your done now right click on the folder>properties>Change Icon
And then choose any appropriate icon
For restart instead of -s type –r

Lock any folder without using any software

1. Suppose you have a folder named abcd in D:\abcd.
2. In the same drive next to the folder create a new notepad file with the exact statement
ren abcd abcd.{21EC2020-3AEA-1069-A2DD-08002B30309D}
3. Now save this text file as loc.bat
4. Create another notepad file and type
ren abcd.{21EC2020-3AEA-1069-A2DD-08002B30309D} abcd
5. Save this as key.bat
6. Now there are two batch files. Double click loc.bat and your folder will change into Control Panel and its contents cannot be viewed .
7. To open the folder double click key.bat and you get back your original folder.
8. For more safety keep the key.bat in another location . Only for unlocking copy paste to the original location and double click
(don't forget to replace abcd with the folder name)

Hide your files in jpeg format

Well, did you know you could hide your files in a JPEG file? For this, you will only need to download WinRAR. You just need to have a little knowledge about Command Prompt and have WinRAR installed.
1. Gather all the files that you wish to hide in a folder anywhere in your PC (make it in C:\hidden - RECOMMENDED).
2. Now, add those files in a RAR archive (e.g. secret.rar). This file should also be in the same directory (C:\hidden).
3. Now, look for a simple JPEG picture file (e.g. logo.jpg). Copy/Paste that file also in C:\hidden.
4. Now, open Command Prompt (Go to Run and type ‘cmd‘). Make your working directory C:\hidden.
5. Now type: “COPY /b logo.jpg + secret.rar output.jpg” (without quotes) - Now, logo.jpg is the picture you want to show, secret.rar is the file to be hidden, and output.jpg is the file which contains both.
6. Now, after you have done this, you will see a file output.jpg in C:\hidden. Open it (double-click) and it will show the picture you wanted to show. Now try opening the same file with WinRAR, it will show the hidden archive .

Make your start menu run faster

1. Go to to 'run' Type regedit.
2. Browse to HKEY_CURRENT_USER > CONTROL PANEL > DESKTOP
3. There is an key called 'MenuShowDelay'
4. Double click on it and change 400 to 0
5. Click 'ok' and restart your computer to see changes to take effect

Set Wallpapers in Drives in XP

All you have to do is just create a "Notepad" file and copy paste this in your Drive
[{BE098140-A513-11D0-A3A4-00C04FD706EC}] iconarea_image=C:\Documents and Settings\All Users\Documents\My Pictures\Sample Pictures\sunset.jpg iconarea_text=0x00FFFFFF
Save it as desktop.ini

Automatically close non-responsive programs

With a small registry tweak, Windows XP can be set to automatically close any program that 'stops responding' (crashes), eliminating the need for you to use the task manager to close down the offending software manually.
To do this:
Open REGEDIT and navigate to HKEY_CURRENT_USER\Control Panel\ Desktop
Modify the REG_SZ entry AutoEndTasks with a value of 1

Remove shut down option

Wanna play with your friends by removing the shutdown option from start menu in their computer.
Click on start>run(win key+r)
Then tpye “regedit” there, this opens up the registry editor, now goto
HKEY_LOCAL_MACHINE>SOFTWARE>Microsoft>Windows>CurrentVersion>Explorer
Then set “NoClose”=”DWORD:1

PC Tricks

2012-07-07T13:52:00.000-07:00

How to make your Desktop Icons Transparent

Go to Control Panel > System, > Advanced > Performance area > Settings button Visual Effects tab "Use drop shadows for icon labels on the Desktop"

Speed up your browsing of Windows 2000 & XP machines

Here's a great tip to speed up your browsing of Windows XP machines. Its actually a fix to a bug installed as default in Windows 2000 that scans shared files for Scheduled Tasks. And it turns out that you can experience a delay as long as 30 seconds when you try to view shared files across a network because Windows 2000 is using the extra time to search the remote computer for any Scheduled Tasks. Note that though the fix is originally intended for only those affected, Windows 2000 users will experience that the actual browsing speed of both the Internet & Windows Explorers improve significantly after applying it since it doesn't search for Scheduled Tasks anymore. Here's how :

Open up the Registry and go to :

HKEY_LOCAL_MACHINE/Software/Microsoft/Windows/Current Version/Explorer/RemoteComputer/NameSpace

Under that branch, select the key :

{D6277990-4C6A-11CF-8D87-00AA0060F5BF}

and delete it.

This is key that instructs Windows to search for Scheduled Tasks. If you like you may want to export the exact branch so that you can restore the key if necessary.

This fix is so effective that it doesn't require a reboot and you can almost immediately determine yourself how much it speeds up your browsing processes

Remove the Recycle Bin from the Desktop

If you don't use the Recycle Bin to store deleted files , you can get rid of its desktop icon all together.

Run Regedit and go to:

HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Windows/CurrentVersion/explorer/Desktop/NameSpace

Hiding folders in windows without any Software

2012-07-07T13:49:00.000-07:00

go to command prompt start--->run--->cmd-->d:
after changing it from C: to D:
type D:/>attrib +h +s anil
the above command is to hide the folder to show the folder
type D:/>attrib -h -s anil
in this type of hidding the folder cannot be viewed even if we make advance search or even changing the folders menu to (show all hidden files)

Simple Chat Demo - (server to client)

2012-07-04T14:19:00.000-07:00

Server.java
~~~~~~~~~~
package com.newChat.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
* message program server side, create server listen on special port
*
*/
public class Server {
public static void main(String[] args) {

   try {

    /*
    * create UI window
    */
    UI ui = new UI();
    ui.setTitle("server");
    ui.setVisible(true);

    /*
    * create server socket wait client connect
    */
    ServerSocket ss = new ServerSocket(8000);
    Socket socket = ss.accept();

    // /////////////////////////////////////////////////
    /*
    * common access socket method, get output stream
    */
    OutputStream os = socket.getOutputStream();
    PrintStream ps = new PrintStream(os);

    ui.setStream(ps);

    /*
    * get input stream
    */
    InputStream is = socket.getInputStream();
    InputStreamReader isr = new InputStreamReader(is);
    BufferedReader reader = new BufferedReader(isr);

    /*
    * get remote address
    */
    InetSocketAddress address = (InetSocketAddress) socket
      .getRemoteSocketAddress();
    String host = address.getHostName();

    /*
    * get message and show it in GUI window
    */
    String line;
    while ((line = reader.readLine()) != null) {
     ui.append("From: " + host + "\nMessage: " + line);
    }

   } catch (IOException e) {
    e.printStackTrace();
   }
}
}

Client.java
~~~~~~~~~~~
package com.newChat.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetSocketAddress;
import java.net.Socket;

/**
* message program client side create client
*
*/
public class Client {
public static void main(String[] args) {

   /*
   * create UI window
   */
   UI ui = new UI();
   ui.setTitle("client");
   ui.setVisible(true);

   try {
    /*
    * create client socket connect to server
    */
    Socket socket = new Socket("127.0.0.1", 8000);

    // /////////////////////////////////////////////////
    /*
    * common access socket method, get output stream
    */
    OutputStream os = socket.getOutputStream();
    PrintStream ps = new PrintStream(os);
    ui.setStream(ps);

    /*
    * get input stream
    */
    InputStream is = socket.getInputStream();
    InputStreamReader isr = new InputStreamReader(is);
    BufferedReader reader = new BufferedReader(isr);

    /*
    * get remote address
    */
    InetSocketAddress address = (InetSocketAddress) socket
      .getRemoteSocketAddress();
    String host = address.getHostName();

    /*
    * get message and show it in GUI window
    */
    String line;
    while ((line = reader.readLine()) != null) {
     ui.append("From: " + host + ": Message: " + line);
    }

   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
}
}

UI.java
~~~~~~~
package com.newChat.test;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.PrintStream;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

/**
* UI window for message program, construct GUI window
*
*
*/
public class UI extends JFrame implements ActionListener {
    private JTextArea textArea;
    private JTextField textField;
    private JButton button;
    private PrintStream stream;

    /*
    * construct method
    */
    public UI() {
       init();
    }

    /*
    * Create Message GUI Window
    */
    private void init() {
       setDefaultCloseOperation(DISPOSE_ON_CLOSE);
       setBounds(200, 200, 400, 300);

       /*
       * add textArea for show
       */
       textArea = new JTextArea();
       textArea.setEditable(false);

       JScrollPane scrollPane = new JScrollPane(textArea);
       add(scrollPane);

       /*
       * add send text field button
       */
       JPanel panel = new JPanel(new BorderLayout());
       add(panel, BorderLayout.SOUTH);

       textField = new JTextField();
       panel.add(textField);

       button = new JButton("Send");
       button.addActionListener(this);
       panel.add(button, BorderLayout.EAST);

    }

    public void actionPerformed(ActionEvent e) {

       /*
       * append send message to textArea clear send text field
       */
       String text = textField.getText();
       textArea.append("Send: ");
       textArea.append(text);
       textArea.append("\n");
       textArea.setAutoscrolls(true);

       textField.setText("");
       textField.requestFocus();

       /*
       * send text to remote
       */
       stream.println(text);
    }

    /*
    * get outputStream
    */
    public void setStream(PrintStream stream) {
       this.stream = stream;
    }

    /*
    * append get message to textArea
    */
    public void append(String text) {
       textArea.append("Get: ");
       textArea.append(text);
       textArea.append("\n");
    }

    /*
    * main method test GUI use
    */
    public static void main(String[] args) {
       new UI().setVisible(true);
    }
}

File Copy with GUI in Java

2012-07-04T14:10:00.000-07:00

CopyGUI.java
~~~~~~~~~~~~~

package com.copyFile.test;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JTextField;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

/**
* Copy File GUI
*
*/
public class CopyGUI extends JFrame implements ActionListener, ChangeListener {

    private static final long serialVersionUID = 1L;
    private JLabel fromLabel;
    private JLabel toLabel;
    private JTextField fromField;
    private JTextField toField;
    private JButton fromButton;
    private JButton toButton;
    private JProgressBar progressBar;
    private JButton beginButton;
    private File fromFile;
    private File toFile;
    private long fileLength;
    private String fileName;

    public CopyGUI() {
        init();
    }

    private void init() {
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        setBounds(200, 200, 400, 300);
        setResizable(false);
        setTitle("File Copy GUI");

        JPanel panel = new JPanel(null);
        add(panel);

        /*
        * add button and lebel
        */
        fromLabel = new JLabel("From:");
        fromLabel.setBounds(40, 20, 50, 20);

        fromField = new JTextField();
        fromField.setBounds(100, 20, 200, 20);

        fromButton = new JButton("Browse");
        fromButton.setBounds(300, 20, 80, 20);
        fromButton.addActionListener(this);

        toLabel = new JLabel("To: ");
        toLabel.setBounds(40, 40, 50, 20);

        toField = new JTextField();
        toField.setBounds(100, 40, 200, 20);

        toButton = new JButton("Browse");
        toButton.setBounds(300, 40, 80, 20);
        toButton.addActionListener(this);

        panel.add(fromLabel);
        panel.add(fromField);
        panel.add(fromButton);

        panel.add(toLabel);
        panel.add(toField);
        panel.add(toButton);

        /*
        * add progress bar
        */
        progressBar = new JProgressBar();
        progressBar.setBounds(50, 100, 300, 30);
        progressBar.addChangeListener(this);

        panel.add(progressBar);

        beginButton = new JButton("Begin Copy");
        beginButton.setBounds(200, 200, 100, 20);
        beginButton.addActionListener(this);

        panel.add(beginButton);

    }

    public void actionPerformed(ActionEvent e) {

        /*
        * choose from file
        */
        if (e.getSource() == fromButton) {
            JFileChooser fileChooser = new JFileChooser();
            fileChooser.setMultiSelectionEnabled(false);
            fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

            int op = fileChooser.showOpenDialog(this);
            if (op == JFileChooser.APPROVE_OPTION) {
                fromFile = fileChooser.getSelectedFile();
                fileName = fromFile.getName();
                fromField.setText(fromFile.getAbsolutePath());
            }
        }

        /*
        * choose to file
        */
        if (e.getSource() == toButton) {
            JFileChooser fileChooser = new JFileChooser();
            fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);

            int op = fileChooser.showOpenDialog(this);
            if (op == JFileChooser.APPROVE_OPTION) {
                toFile = fileChooser.getSelectedFile();
                if (fileName != null) {
                    fileName = fromFile.getName();
                }
                toField.setText(toFile.getAbsolutePath() + fileName);
            }
        }

        /*
        * begin copy method
        */
        if (e.getSource() == beginButton) {

            /*
            * before copy check from file and to file
            */
            if ("".equals(fromField.getText())) {
                JOptionPane.showMessageDialog(this, "Input from File!");
                return;
            }

            if ("".equals(toField.getText())) {
                JOptionPane.showMessageDialog(this, "Input to File!");
                return;
            }

            /*
            * get copy from file and to file
            */
            fromFile = new File(fromField.getText());
            toFile = new File(toField.getText());

            /*
            * if to file exist, ask user information
            */
            if (toFile.exists()) {
                int op = JOptionPane.showConfirmDialog(this, toFile.getName()
                        + " file exist! \n Do your want to cover it?",
                        "Confirm Window", JOptionPane.YES_NO_OPTION);
                if (op == JOptionPane.NO_OPTION) {
                    JOptionPane.showMessageDialog(this, "Copy Canceled");
                    fromField.setText("");
                    toField.setText("");
                    return;
                }
            }

            /*
            * get file length, set progressBar max value
            */
            fileLength = fromFile.length();
            progressBar.setMaximum((int) fileLength);

            /*
            * copy method add to a new thread when copying, increase progress
            * bar
            */
            Runnable r1 = new Runnable() {

                public void run() {

                    try {
                        FileInputStream fis = new FileInputStream(fromFile);
                        FileOutputStream fos = new FileOutputStream(toFile);

                        byte[] buf = new byte[2048];
                        int size = 0;
                        int flag = 0;
                        while ((size = fis.read(buf)) != -1) {
                            fos.write(buf, 0, size);
                            flag += size;
                            progressBar.setValue(flag);
                        }

                        fis.close();
                        fos.close();

                    } catch (Exception e1) {
                        e1.printStackTrace();
                    }
                }
            };

            /*
            * start new thread
            */
            Thread t1 = new Thread(r1);
            t1.start();

        }
    }

    /*
    * update progress bar value
    */
    public void stateChanged(ChangeEvent e) {
        if (e.getSource() == progressBar) {
            if (progressBar.getValue() == progressBar.getMaximum()) {
                JOptionPane.showMessageDialog(this, "Copy Over");
                progressBar.setValue(0);
            }
        }
    }

    /*
    * Main method
    */
    public static void main(String[] args) {
        new CopyGUI().setVisible(true);
    }
}

Simple Chat Demo With Error Check - (client to client)

2012-07-04T13:56:00.000-07:00

Server.java
~~~~~~~~~~
//Simple Chat Demo With Error Check - (client to client)(Java)

// Server.java

package com.chat.test;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
* Simple Chat Demo with error check server side
*
*
*/
public class Server {
    private boolean running;
    private ServerSocket ss;
    private Socket s;

    /*
    * use ArrayList to store all connect client
    */
    private List<Client> clients = new ArrayList<Client>();

    /*
    * construct method create server and wait client connect
    */
    public Server(int port) throws IOException {
        ss = new ServerSocket(port);
        System.out.println("server start!");
        running = true;

        /*
        * wait client connect
        */
        while (running) {
            s = ss.accept();

            /*
            * when client connect, add it to clients list and create new thread
            * to access it
            */
            Client c = new Client(s);
            clients.add(c);
            System.out.println("connect new client!");
            System.out.println("client numbers: " + clients.size());
            new Thread(c).start();
        }
    }

    /*
    * client access thread
    */
    private class Client implements Runnable {
        private Socket socket;
        private DataInputStream dis;
        private DataOutputStream dos;
        private boolean isConnected;

        /*
        * construct method, get input stream and output stream
        */
        public Client(Socket socket) throws IOException {

            this.socket = socket;
            InputStream is = socket.getInputStream();
            dis = new DataInputStream(is);

            OutputStream os = socket.getOutputStream();
            dos = new DataOutputStream(os);
            isConnected = true;
        }

        /*
        * use output stream send text to client
        */
        public void send(String text) {
            try {
                dos.writeUTF(text);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        /*
        * run method
        *
        * @see java.lang.Runnable#run()
        */
        public void run() {

            /*
            * get remote address and port
            */
            InetSocketAddress address = (InetSocketAddress) socket
                    .getRemoteSocketAddress();
            String host = address.getHostName();
            int port = address.getPort();

            /*
            * if connected, wait client send message to server.
            */
            while (isConnected) {
                try {
                    String text = dis.readUTF();
                    System.out.println("Get " + host + ":" + port
                            + " Message: " + text);

                    /*
                    * Iterator clients list, send get text to all client use
                    * test remote address method, to control text not send to
                    * sender
                    */
                    for (Client c : clients) {
                        if (!c.socket.getRemoteSocketAddress().equals(address))
                            c.send(text);
                    }

                } catch (IOException e) {
                    /*
                    * if readInput stream error occurs, then client
                    * disconnected. close all client connect resource.
                    */
                    if (dis != null)
                        try {
                            dis.close();
                            dos.close();
                            socket.close();
                            isConnected = false;
                            clients.remove(this);
                            System.out.println("disconnect client!");
                            System.out.println("Client numbers: "
                                    + clients.size());
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                }
            }

        }
    }

    /*
    * server main method create new server at 4444 port
    */
    public static void main(String[] args) {
        try {
            new Server(4444);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Client.java
~~~~~~~~~~~~
package com.chat.test;

import java.awt.BorderLayout;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

/**
* Simple Chat Demo with error check client side
*
*
*/
public class Client extends JFrame implements ActionListener {

   private JTextArea textArea;
   private TextField textField;
   private newClient client;
   private JButton button;

   public Client() {
       init();
   }

   /*
   * create client windows
   */
   private void init() {
       setDefaultCloseOperation(EXIT_ON_CLOSE);
       setBounds(200, 200, 400, 300);
       setTitle("Client");

       /*
       * add textArea to show message
       */
       textArea = new JTextArea();
       textArea.setEditable(false);
       textArea.setLineWrap(true);
       add(new JScrollPane(textArea));

       /*
       * add send textField and sendButton to send message
       */
       JPanel panel = new JPanel(new BorderLayout());
       add(panel, BorderLayout.SOUTH);

       textField = new TextField();
       textField.addActionListener(this);
       panel.add(textField);

       button = new JButton();
       button.addActionListener(this);
       panel.add(button, BorderLayout.EAST);

       /*
       * connect to server
       */
       connect();
   }

   /*
   * action access method, send text to server
   */
   public void actionPerformed(ActionEvent e) {
       String text = textField.getText();
       textArea.append("Send: ");
       textArea.append(text);
       textArea.append("\n");

       textField.setText("");
       textField.requestFocus();

       /*
       * client send message to server
       */
       client.send(text);

   }

   /*
   * connect to server
   */
   public void connect() {
       try {
           Socket socket = new Socket("127.0.0.1", 4444);
           System.out.println("client start");

           /*
           * create new thread to access connection
           */
           client = new newClient(socket);
           new Thread(client).start();

       } catch (IOException e) {
           e.printStackTrace();
       }

   }

   /*
   * add text to textArea
   */
   public void append(String text) {
       textArea.append(text);
       textArea.append("\n");
   }

   /*
   * connect access method
   */
   class newClient implements Runnable {

       private Socket socket;
       private DataInputStream dis;
       private DataOutputStream dos;
       private boolean isConnect;

       /*
       * construct method, get input stream and output stream
       */
       public newClient(Socket socket) {
           this.socket = socket;
           isConnect = true;
           try {
               InputStream is = socket.getInputStream();
               dis = new DataInputStream(is);

               OutputStream os = socket.getOutputStream();
               dos = new DataOutputStream(os);

           } catch (IOException e) {
               e.printStackTrace();
           }
       }

       /*
       * send textField's text to server
       */
       public void send(String text) {
           try {
               dos.writeUTF(text);
           } catch (IOException e) {
               e.printStackTrace();
           }
       }

       /*
       * thread access method
       */
       public void run() {

           /*
           * get remote address
           */
           InetSocketAddress address = (InetSocketAddress) socket
                   .getRemoteSocketAddress();
           String host = address.getHostName();
           int port = address.getPort();

           /*
           * wait server send text, if get text from server, add text to
           * textArea
           */
           while (isConnect) {
               try {
                   String text = dis.readUTF();
                   append("Get From " + host + ":" + port + " Message: "
                           + text);

               } catch (IOException e) {

                   /*
                   * if readInput stream error occurs, then server is
                   * disconnect, release all connect resources
                   */
                   System.out.println("server closed");
                   try {
                       dis.close();
                       dos.close();
                       isConnect = false;
                       socket.close();
                   } catch (IOException e1) {
                       e1.printStackTrace();
                   }
               }
           }// end while
       }
   }

   /*
   * main method create new server
   */
   public static void main(String[] args) {
       new Client().setVisible(true);
   }
}

Simple HTTP Server with Response Action(Java)

2012-07-04T13:30:00.000-07:00

ConnectorTest.java
~~~~~~~~~~~~~~~
package com.anils.test;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
* Simulator HTTP Server, can accept user request, according request send
* response, ConnectorTest where main ServerSocket
*
*
*/
public class ConnectorTest implements Runnable {

    private final int port;
    private ServerSocket serverSocket;

    public ConnectorTest(int port) {
        this.port = port;

        try {
            /*
            * create serverSocket, listen on special port
            */
            serverSocket = new ServerSocket(port);
            new Thread(this).start();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void run() {
        while (true) {
            try {
                /*
                * wait client connection
                */
                Socket socket = serverSocket.accept();
                new HttpdTest(socket);

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
    * main method, entry of system
    */
    public static void main(String[] args) {
        new ConnectorTest(8888);
    }
}

HttpdTest.java
~~~~~~~~~~~~~~

package com.anils.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;

/**
* Simulator HTTP Server, can accept user request, according request send
* response, HttpdTest were access thread
*
*/
public class HttpdTest implements Runnable {
    private final Socket socket;
    public static final String BASE_PATH = "d:/root";

    /**
    * construct method
    *
    * @param socket
    *            , client connect socket
    */
    public HttpdTest(Socket socket) {
        this.socket = socket;
        new Thread(this).start();
    }

    /*
    * main access method, access request, send response, then close
    */
    public void run() {

        // access request
        // access response
        // close
        try {

            /*
            * get input stream and output stream
            */
            InputStream inputStream = socket.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(
                    inputStream);
            BufferedReader reader = new BufferedReader(inputStreamReader);

            OutputStream outputStream = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(outputStream);

            /*
            * get first line, http head message
            */
            String headLine = reader.readLine();

            /*
            * split head message, get method, request file and HTTP protocol
            */
            String[] split = headLine.split(" ");

            /*
            * if is not GET method, can't access
            */
            if (!"GET".equals(split[0])) {
                // can't access
            }

            String path = split[1];

            /*
            * if end folder where '/', then add default index.html to path
            */
            if (path.endsWith("/")) {
                path = path + "index.html";
            }

            /*
            * get absolute path of file
            */
            String filename = BASE_PATH + path;

            File file = new File(filename);

            /*
            * check request file exist, if not exist, response not found page
            * message
            */
            if (!file.exists() || file.isDirectory()) {

                /*
                * send http response head format
                */
                writer.println("HTTP/1.1 404 ok");
                writer.println();
                writer.flush();
                socket.close();
                return;
            }

            /*
            * send request file found message
            */
            writer.println("HTTP/1.1 200 ok");
            String lowerName = filename.toLowerCase();

            /*
            * according file extention, send http head message
            */
            if (lowerName.endsWith(".txt") || lowerName.endsWith(".html")) {
                writer.println("Content-Type: text/html");
            } else if (lowerName.endsWith(".jpg")) {
                writer.println("Content-Type: image/jpeg");
            }
            writer.println();

            if (lowerName.endsWith(".txt") || lowerName.endsWith(".html")) {
                /*
                * if file ends with .txt or .html, get request file, read file
                * content, and send content to client
                */
                FileReader fileReader = new FileReader(file);
                char[] buf = new char[256];
                int count = 0;
                while ((count = fileReader.read(buf)) != -1) {
                    writer.write(buf, 0, count);
                }
                fileReader.close();

            } else if (lowerName.endsWith(".jpg")) {
                /*
                * if file ends with .jpg, get request jpg file, read file
                * content, and send content to client
                */
                FileInputStream fileInputStream = new FileInputStream(file);
                byte[] buf = new byte[250];
                int count = 0;
                while ((count = fileInputStream.read(buf)) != -1) {
                    outputStream.write(buf, 0, count);
                }
                outputStream.flush();
            }

            /*
            * remember call flush method
            */
            writer.flush();

            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}