The Geek's Blog

This pattern is used when it must be decided at run time which one of several compatible classes is to be instantiated. For example, the abstract Collator class's getInstance() method returns a collation object that is appropriate for the default locale, as determined by java.util.Locale.getDefault() : Like other locale-sensitive classes, you can use the static factory method, getInstance, to obtain the appropriate Collator object for a given locale.  The following example shows how to compare two strings using the Collator for the default locale. Compare two strings in the default locale Collator myCollator = Collator.getInstance(); if( myCollator.compare("abc", "ABC") < 0 ) System.out.println("abc is less than ABC"); else System.out.println("abc is greater than or equal to ABC");

Lazy Initialization :- The instantiation of an object can be delayed until it is actually needed. Usage: This especially beneficial when the constructor is doing a costly job like, accessing a remote database. Example: This code demonstrates how the Singleton pattern can be used to create a counter to provide unique sequential numbers, such as might be required for use as primary keys in a Database:   Sequence.java   public class Sequence { private static Sequence instance; private static int counter; private Sequence() { counter = 0; // May be necessary to obtain // starting value elsewhere... } public static synchronized Sequence getInstance() { if(instance==null) // Lazy instantiation { instance = new Sequence(); } return instance; } public static synchronized int getNext() { return ++counter; } }   Some things to note about this implementation: Synchronized methods are used to ensure that the class is thread-safe. This class cannot be subclassed because the constructor is private ...

The pattern is an organised way of solving some specific class of problems. These patterns come in to the picture at analysis and high-level-design phase. The first step of applying one pattern to the code base is first to understand the find the vector of change in the code base. Next step is to isolate the things that are subject to change form the things that are not. That is adding a layer of abstraction to the code. The goal of design patterns is isolating the changes in your code. Understand Inheritance and Composition as a solution to a specific class of problems. Inheritance : - It allows you to express differences in behavior (that's the thing that changes) in objects that all have the same interface (that's what stays the same). Composition : - Composition can also be considered a pattern, since it allows you to change—dynamically or statically—the objects that implement your class, and thus the way that class works. Some principles of designing the c...

Complex Products Unmaintainable System Non-portable, frame-work committed business components Unpredictable System Why EJB 2.0 is complex / complicated? Session bean - to write say hello method in EJB 2.x, you need to write home interface component interface bean in EJB 3.x, you need to write interface (with annotation) bean (with annotation) EJB 2.x; lookup is the only way to get server object/resource EJB 3; DI (dependency injection) & lookup are the available way there are more points. But basically, with EJB 3 responsibility of container is heavy & responsibility of developer is light weight; so that development is less & maintenance is easy.

  Here are some tips I have gathered during our Seam project. @Create - Signals that this method should be called upon instantiation of the JavaBean. @Stateless - Makes an EJB3 object @Stateful - (SESSION) Caches in memory between server requests @In - These variables will automatically be set by Seam through injection of the variables labeled by the annotation. i.e String zipCode; (Behind the curtain: zipCode = request.getParameter("zipCode"); ) @Out - Same as above. This variable is also automatically set by Seam. Behind the curtain this variable is set in the HttpSession object. ( request.setAttribute("bestRestaurant", restaurant); ) What you also must remember is that if you want to use the outjected object, you only call it with its name. Not component name first. i.e. If you stateful session bean is named @Name("someName") and you have a @Out String test, then when you use it in the view, you must write #{test} and not #{someName.test} You can als...

Hibernate is a Object relational mapping framework. What it will help us is in saving the objects into the relational world. Employee.java public class Employee { private String Name; private int Emp_Id; private String Designation; private String Reportee; private int Access_Carad_No;          public String getName() {         return Name;     }     public void setName(String name) {         Name = name;     }     public int getEmp_Id() {         return Emp_Id;     }     public void setEmp_Id(int emp_Id) {         Emp_Id = emp_Id;     }     public String getDesignation() {         return Designation;     }     public void setDesignation(String designation) {         Designation = designation;     }     public String getReportee() {         return Reportee;     }     public void setReportee(String reportee) {         Reportee = reportee;     }     public int getAccess_Carad_No() {         return Access_Carad_No;     }     public void setAccess_Carad_No(int access_Carad_No) {         Acc...

The container is responsible for loading, activating, and in general maintaining the "life-cycle" of objects it provides. EJB have a fairly complex life-cycle. There are several kinds of EJB: Session Beans: These may be either stateful or stateless, and are primarily used to encapsulate business logic, carry out tasks on behalf of a client, and act as controllers or managers for other beans.   Entity Beans: Entity beans represent persistent objects or business concepts that exist outside a specific application's lifetime. They are typically stored in a relational database. Entity beans can be developed using bean-managed persistence, which is implemented by the developer, or container-managed persistence, implemented by the container.   Message-Driven Beans : Message-driven beans listen asynchronously for Java Message Service (JMS) messages from any client or component and are used for loosely coupled, typically batch processing.