Java - Tips n Tricks

Flow

- Communication object is simple JS Array.

- GWT client layer is invoked by native JS call with array object created by External client application.

- JNSI Object get modified by server (using GWT Async. RPC call).

- Additional external app info’s can also be passed from external app(If required).

Benefits

- Call and communication object is same for all Actions like save, update, any other future operations.

- Hiding the details of internal integration part with GWT.

- Reducing number of native JS object creation.

JavaScript variable:

var arr= new Array()["one","two","three"];

JNSI Call :

private native JSHolderArray getArr()/*-{
return $wnd.arr ;

}-*/;

External JavaScript Object (arr)can be convertible to custom GWT JavaScriptObject to manipulate external script object using GWT JNSI call.

package com.google.gwt.sample.contacts.client;
import com.google.gwt.core.client.JavaScriptObject;
/**
*External javascript array object holder.
*
* @author Hiren
*
*/

public class JSHolderArray extends JavaScriptObject {
protected JSHolderArray() {
}

public final native int length() /*-{
return this.length;
}-*/;

public final native String getOtherData(int index) /*-{
return this[index];
}-*/;

public final native void setOtherData(int index, String data) /*-{
this[index] = data;
}-*/;
}

GZip is based on the DEFLATE algorithm, which is a combination of LZ77 and Huffman coding. gzip is often also used to refer to the gzip file format, which is:

1. a 10-byte header, containing a magic number, a version number and a time stamp.
2. optional extra headers, such as the original file name.
3. a body, containing a DEFLATE-compressed payload.
4. an 8-byte footer, containing a CRC-32 checksum and the length of the original uncompressed data.

Although its file format also allows for multiple such streams to be concatenated (zipped files are simply decompressed concatenated as if they were originally one file), gzip is normally used to compress just single files . Compressed archives are typically created by assembling collections of files into a single tar archive, and then compressing that archive with gzip. The final .tar.gz or .tgz file is usually called a tarball.

Most of the FE view generation time is tied up in downgrading all the components in the page: like html, images, stylesheets, scripts, ActiveX components and static resources.
Using gzip compression technique we can drastically reduce the size (almost 1/10th of original response content size ,as per spec) of the resources which takes less time, bandwidth to traverse through the wire interns increase the view generation performance.
It Also it provides transport layer encoding.




Steps to Implement

1. Write a GZipFilter through which all request/response should pass to/from Web app Servlet.
2. In filter Check if the requester (For web app its browser) can support gzip encoding or not. by checking "Accept-Encoding" header value of request. This check is necessary because if the requester client does not support gzip encoding then normal operation should be performed without encoding.
4, If client supposts gzip encoding set a response header "Content-Encoding" with value "gzip". It's needed for browser to understand about the meta-data of coming response content.
3. If it's supports gzip encoding set the object of GZipOutputStream in HTTPServletResponseweb app servlet.
4. Web app will write the response byte Stream in GZipOutputStream instead of simple OutputStream and browser will take care of the rest.

Your queries/suggestions are welcome, please put it into the comment section.

XStream is a simple library to serialize objects to XML and back again.

A thread can be in one of the following states: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED. Now its a internal implementation of Spring ThreadPoolTaskExecutor how it manipulates the thread state after invoking execute(). That's why getActiveCount() can't give exact numbers but approximate.

Accessing Static Methods and Variables:

import java.io.*;
import java.net.*;

public class ViewSource{
 public static void main (String[] args) throws IOException{
   System.out.print("Enter url to view html source code: ");
   BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   String url = br.readLine();
   try{
     URL u = new URL(url);
     HttpURLConnection uc = (HttpURLConnection) u.openConnection();
     int code = uc.getResponseCode();
     String response = uc.getResponseMessage();
     System.out.println("HTTP/1.x " + code + " " + response);
     for(int j = 1; ; j++){
       String header = uc.getHeaderField(j);
       String key = uc.getHeaderFieldKey(j);
       if(header == null || key == null)
         break;
       System.out.println(uc.getHeaderFieldKey(j) + ": " + header);
     }
     InputStream in = new BufferedInputStream(uc.getInputStream());
     Reader r = new InputStreamReader(in);
     int c;
     while((c = r.read()) != -1){
       System.out.print((char)c);
     }
   }
   catch(MalformedURLException ex){
     System.err.println(url + " is not a valid URL.");
   }
   catch(IOException ie){
     System.out.println("Input/Output Error: " + ie.getMessage());
   }
 }
}

The default behaviour of an object’s clone() method automatically yields a shallow copy. So to achieve a deep copy the classes must be edited or adjusted.

Deep copy: If a deep copy is performed on obj-1 then not only obj-1 has been copied but the objects contained within it have been copied as well. Serialization can be used to achieve deep cloning. Deep cloning through serialization is faster to develop and easier to maintain but carries a performance overhead.