ThreadLocal is one of the rarely used class in Java. I found it is one of the powerful class in Java on multi-threaded programming. In multi threaded program generally we use session object to track the current users information.

These information is passed to various method to retrieve desired value. For example in Struts execute method passes HttpServletRequest and HttpServletResponse, what if we want the instance of ServletContext? we have to change the method signatore to pass ServletContext. One can use ThreadLocal to keep certain objects/values available throught the thread execution.

ThreadLocal object is not required on day to day programming unlike ArrayList or HashMap. But it is good choice to solve a few problems at framework level. In one of my recent project I have used ThreadLocal to expose user specific information like User info, UserId, Roles and access, etc.

The main reason is I want hide the code which identifies these values so that in future it is easy to change the behavior and fine tune the code across the application.

ü  Abstract class is a class which contains one or more abstract methods, which has to be implemented by sub classes. An abstract class can contain no abstract methods also i.e. abstract class may contain concrete methods. A Java Interface can contain only method declarations and public static final constants and doesn’t contain their implementation. The classes which implement the Interface must provide the method definition for all the methods present.

ü  Abstract class definition begins with the keyword “abstract” keyword followed by Class definition. An Interface definition begins with the keyword “interface”.

ü  Abstract classes are useful in a situation when some general methods should be implemented and specialization behavior should be implemented by subclasses. Interfaces are useful in a situation when all its properties need to be implemented by subclasses

ü  All variables in an Interface are by default – public static final while an abstract class can have instance variables.

ü  An interface is also used in situations when a class needs to extend another class apart from the abstract class. In such situations it’s not possible to have multiple inheritances of classes. An interface on the other hand can be used when it is required to implement one or more interfaces. Abstract class does not support Multiple Inheritance whereas an Interface supports multiple Inheritances.

ü  An Interface can only have public members whereas an abstract class can contain private as well as protected members.

ü  A class implementing an interface must implement all of the methods defined in the interface, while a class extending an abstract class need not implement any of the methods defined in the abstract class.

ü  The problem with an interface is, if you want to add a new feature (method) in its contract, then you MUST implement those methods in all of the classes which implement that interface. However, in the case of an abstract class, the method can be simply implemented in the abstract class and the same can be called by its subclass

ü  Interfaces are slow as it requires extra indirection to find corresponding method in the actual class. Abstract classes are fast

ü  Interfaces are often used to describe the peripheral abilities of a class, and not its central identity,

 E.g. an Automobile class might implement the Recyclable interface, which could apply to many otherwise totally unrelated objects.

Note: There is no difference between a fully abstract class (all methods declared as abstract and all fields are public static final) and an interface.

Note: If the various objects are all of-a-kind, and share a common state and behavior, then tend towards a common base class. If all they
share is a set of method signatures, then tend towards an interface.

Similarities:
Neither Abstract classes nor Interface can be instantiated.

I’m pleased to inform that SPRING 3.0 M1 is finally available to download.

This release has several major changes like

Ø  revised project layout and build system with module-based sources

Ø  updated entire codebase for Java 5 code style (generics, varargs)

Ø  updated to JUnit 4.5 and JRuby 1.1

Ø  introduced Spring EL parser (org.springframework.expression package)

Ø  introduced support for #{…} expressions in bean definitions

Ø  introduced expression-enabled @Value annotation for embedded expressions

Ø  introduced @PathVariable annotation for URI template handling in MVC handlers

Ø  introduced default value support for @RequestParam in MVC handlers

Ø  introduced @RequestHeader annotation for HTTP header access in MVC handlers

Ø  introduced AbstractAtomFeedView and AbstractRssFeedView base classes

Ø  introduced <spring:url> and <spring:param> JSP tags

Ø  Support EL and REST

Ø  new support for the Java EE 6 JPA (Java Persistence API) 2, in addition to already existing support for JDBC, Hibernate, iBatis, and much more.

Ø  Use the now fully integrated SpringSecurity framework, formerly Acegi.

As well as various minor changes.

This version is specifically based on JAVA 6 and J2EE 5 .but its compatibility with JAVA 5 and J2EE1.4 or above.

Encapsulation refers to an object hiding its attributes behind its operations.

For more information:

It seals the attributes in a capsule, with operations on the edge.

Hidden attributes are said to be private.

Way to think of encapsulation is to imagine that objects are courteous to one another. If you wanted to borrow some money from a colleague to buy food in the staff canteen, you wouldn’t grab their wallet and look through it to see if they had enough cash.

Instead, you would ask them whether they could lend you some money and they would look

in their own wallet.

Static Binding:

Static binding is deciding at compile time which methods to invoke.

The method gets invoked is determined by the type of the reference.

In Java, static methods are statically bound.

Also class member variable is applicable for static binding because,

In Java does not support polymorphic behavior for member variables.

For example,

public class Animal

{

            public String type = “mammal”;

            public void show()

            {

                        System.out.println(“The animal is a: “ + type);

            }

}

public class Dog extends Animal

{

            public String type;  //same member variable name as in base class

            public Dog(String type)

            {

                        this.type = type;

            }

            public void show()  //same method signature as in base class

            {

                        System.out.println(“The dog is a: “ + type);

            }

}

public class DemoStaticBinding

{

            public static void main(String[] args)

            {

                        Animal doggie = new Dog(“daschund”);

                        doggie.show(); // “The dog is a: daschund”  (dynamic binding)

                        System.out.println(“The type is: “ + doggie.type); //”The type is: mammal” (static binding)

            }

}

Dynamic Binding:

Dynamic binding is deciding at run time which methods to invoke.

Here I explain the concepts,

public class Shape {

            private String name;

            public Shape(String aName) {

                        name = aName;

            }

            public String getName() {

                        return name;

            }

            public float calculateArea() {

                        return 0.0f;

            }

            public static void main(String argv[]) {

            Circle c = new Circle(“Circle C”);

            Square s = new Square(“Square S”);

            Shape shapeArray[] = {c, s};

            for (int i=0; i<shapeArray.length; i++) {

                        System.out.println(“The area of “ + shapeArray[i].getName()

                                                + ” is “ + shapeArray[i].calculateArea()+” sq. cm.\n”);

            }

            }

}

public class Circle extends Shape {

            private int radius;

             Circle(String aName) {

                        super(aName);

                        radius = 3;

            }

            public float calculateArea() {

                        float area;

                        area = (float) (3.14 * radius * radius);

                        return area;

            }

}

class Square extends Shape {

            private int side;

             Square(String aName) {

                        super(aName);

                        side = 3;

            }

            public float calculateArea() {

                        int area;

                        area = side * side;

                        return area;

            }

}

Based on the output from the code, it is clear that the appropriate method for

responding to the choice in shapeArray has been used:

The area of Circle C is 28.26 sq. cm.

The area of Square S is 9 sq. cm.

The method has been selected based on the class of the shape referenced in

shapeArray at run-time. This is only possible in programming languages that support

dynamic binding. With dynamic binding, the variable shapeArray[i] is bound

to an object method at run time when the class definition of the shape referenced is

known.

Note:

            Static binding is limited and may lead to difficulty software maintenance.

On the other hand dynamic binding is very flexibility and easy to maintain.

Hi guys,

 We are most struggling with “Out of memory error” in web application when reference memory is over head.

For example:

            public final class Large { 

private static final double[ ] [ ] [ ] matrix = new double [1357] [ 1687] [4]; 

                        public static final void main(String[] arg) {

                        }

            }

O/P:

java.lang.OutOfMemoryError: Java heap space

                        at outofmemory.Large.<clinit>(Large.java:5)

Exception in thread “main”

How to solve?

            Increase java heap space based on jvm which you used.

Set java heap size in JVM?

java -Xms64m -Xmx512m

where -Xms<size> specifies the initial Java heap size and -Xmx<size> the maximum Java heap size. 

Set java heap size in Tomcat?
Stop Tomcat server, set environment variable CATALINA_OPTS, and then restart Tomcat. Look at the file tomcat-install/bin/catalina.sh or catalina.bat for how this variable is used. For example,

set CATALINA_OPTS="-Xms512m -Xmx512m"  (Windows)
export CATALINA_OPTS="-Xms512m -Xmx512m"  (ksh/bash)
setenv CATALINA_OPTS "-Xms512m -Xmx512m"  (tcsh/csh)

Set java heap size in JBoss?
Stop JBoss server, edit $JBOSS_HOME/bin/run.conf, and then restart JBoss server. You can change the line with JAVA_OPTS to something like:

JAVA_OPTS="-server -Xms128m -Xmx128m"
 

Set java heap size in Eclipse?
You have 2 options:
1. Edit eclipse-home/eclipse.ini to be something like the following and restart Eclipse.

-vmargs
-Xms64m
-Xmx256m

2. Or, you can just run eclipse command with additional options at the very end. Anything after -vmargs will be treated as JVM options and passed directly to the JVM. JVM options specified in the command line this way will always override those in eclipse.ini. For example,

eclipse -vmargs -Xms64m -Xmx256m

Set java heap size in Weblogic?

Java heap size values must be specified whenever you start WebLogic Server. This can be done either from the Java command line or by modifying the default values in the sample startup scripts that are provided with the WebLogic distribution for starting WebLogic Server.

For example, when starting WebLogic Server from a Java command line, the heap size values could be specified as follows:

$ java -XX:NewSize=128m -XX:MaxNewSize=128m -XX:SurvivorRatio=8  -Xms512m -Xmx512m
-Dweblogic.Name=%SERVER_NAME% -Dbea.home=”C:\bea”
-Dweblogic.management.username=%WLS_USER%
-Dweblogic.management.password=%WLS_PW%
-Dweblogic.management.server=%ADMIN_URL%
-Dweblogic.ProductionModeEnabled=%STARTMODE%
-Djava.security.policy=”%WL_HOME%\server\lib\weblogic.policy”
 weblogic.Server

The default size for these values is measured in bytes. Append the letter `k’ or `K’ to the value to indicate kilobytes, `m’ or `M’ to indicate megabytes, and `g’ or `G’ to indicate gigabytes.

For more information on the heap size options

Setting the New generation heap size                        -XX:NewSize

Setting the maximum New generation heap size                   -XX:MaxNewSize

Setting New heap size ratios                                                  -XX:SurvivorRatio

Setting minimum heap size                                                     -Xms

Setting maximum heap size                                                    -Xmx

Yet another Web Application Framework! This time it is from JBoss Community. JBoss provides a new Web Application Framework called “JBoss Seam” which combines the advantages from the two rapidly growing technologies Enterprise Java Beans 3.0 and Java Server Faces. JBoss Seam, by sitting on top of J2EE provides a nice way of integration between JSF and EJB Components with other great functionalities

what is Hibernate?

HIBERNATE is an ORM ( Object-Relational-Mapping) technology. It is an Open-Source and free technology , developed in SourceForge.net. There have been a number of such ORM technologies,in recent past.. TopLink is one such tool , subsequently adopted by Oracle and so proprietory.

Hibernate from SourceForge and OJB(Object-Relational-Bridge) from Apache are two well known ORM tools,open-source and free. JDO , also falls within the same category.

Hibernate and EJB 3.0

EJB-3 , is the latest version and it is heavily influenced by Hibernate. Some readers equate EJB-3 with Hibernate. Some even equate EJB-3 with JBOSS! Oracle supports EJB-3 proposals and as it is the main Database company in j2ee world, EJB-3 has bright future. J2EE( Java Enterprise Edition) by its very name is an Enterprise level technology, and as EJB is the essence of such Enterprise applications, because of the built-in container services offered, the significance of the surging interest in Hibernate can be really appreciated only in association with EJB and hence a detour into EJB is inevitable.

EJB has three types. One type is the SESSION BEAN,residing in ENTERPRISE container, which can be thought of as a function-bean, invoked in RMI-IIOP style. (this is a rough definition).Such session-bean , may be either stateless or stateful.

This type of EJB has stood the test of time during the last six years and has even gained wide approval, even for data-access, especially since it fits very well with the emerging XML WebService technology, and is very easy to learn and implement.( The earlier tutorial on EJB as webservice in Feb-2005, in DeveloperIQ illustrates this feature).The stateless bean working in Enterprise container has an exact counter-part in Microsoft COM+(MTS), but the other types are said to be available in MS platform only through third-party extensions.

ORM tools have been sometimes used along with Session beans. The only problem till recently was that they were proprietary and rather costly. But nowadays, very reliable open-source ORM tools are available, and even Richard Monson Haefel ( an acknowledged authority and author on EJB)approves this method as a safe and productive alternative to Entity beans.( page-467..EJB by Haefel-OReilly).

The other branch, the ENTITY BEAN has been less lucky. EJB-1.1, EJB-2.0 and then EJB-2.1 , have meant a number of changes in the specification relating to Entity Beans. We can say that an Entity bean is an ‘Attribute bean’ or ‘property-bean’, with setter and getter methods, invoked in RMI-IIOP style and persisted in Enterprise container. The pattern of defining a typical Javabean is a recurring theme in Java. The same style occurs in BDK,EJB-Entity beans, Struts,JSF and now in Hibernate too. So, it is very important and elegant.

The third branch is Messaging paradigm and MDB. A recent article in the web dubbed the ‘RPC’ style, on which the previous two types of EJB are based, as stone-age technologies! An Enterprise by its very name implies huge number of customers and concurrent transactions, RPC style being like telephone call, could result in ‘line-engaged!’ problem. If the call involves the called person referring to some records before replying, it leads to line- blocking. But, messaging style, as in email, at least ensures that the message has been sent. It is evident that dubbing RPC( read ‘telephone’) as unsuitable , is over-statement. Sometimes, we desire immediate response, too. By the same token, even XML webservice , if it is really serious, should adopt messaging style and it does.MDB (Message-Driven bean) has weathered the storm and is in fact gaining more and more acceptance.

Hi!

I have got the problem while define the custom message in acegi with spring.

 Reading the reference guide does not help me, since following code snip from it does not work:

<bean id=”messageSource” class=”org.springframework.context.support.Reloada bleResourceBundleMessageSource”>

<property name=”basename”><value>my/project/securitymessages</value></property>

</bean>

After reading the Source Code of Acegi, I have got the following idea:

<bean id=”messageSource” class=”org.acegisecurity.AcegiMessageSource”>

<property name=”basename”><value>my/project/securitymessages</value></property>

</bean>

This bean definition works. I have no idea, if the reference guide is wrong or I simply used the MessagesSource otherwise than expected, but since it works for now, it is fine for me and fine for you, too. I hope .

TagSoup is a library for extracting information out of unstructured HTML code, sometimes known as tag-soup. The HTML does not have to be well formed, or render properly within any particular framework. This library is for situations where the author of the HTML is not cooperating with the person trying to extract the information, but is also not trying to hide the information.

Please find the below URL for more details :http://mercury.ccil.org/~cowan/XML/tagsoup/