Wednesday, 16 November 2016

Facade pattern

The facade pattern is a wrapper of many other interfaces in a result to produce a simpler interface. Facade hides the complexities of the system and provides an interface to the client from where the client can access the system easily.
A facade is an object that provides a simplified interface to a larger body of code, such as a class library.





Example: This is an abstract example of how a client ("you") interacts with a facade (the "computer") to a complex system (internal computer parts, like CPU and HardDrive).

/* Complex parts */

class CPU {
      public void freeze() {
            ...
      }
      public void jump(long position) {
            ...
      }
      public void execute() {
            ...
      }
}

class Memory {
      public void load(long position, byte[] data) {
            ...
      }
}

class HardDrive {
      public byte[] read(long lba, int size) {
            ...
      }
}

/* Facade */

class ComputerFacade {
      private CPU processor;
      private Memory ram;
      private HardDrive hd;

      public ComputerFacade() {
            this.processor= new CPU();
            this.ram = new Memory();
            this.hd = new HardDrive();
      }

      public void start() {
            processor.freeze();
            ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE));
            processor.jump(BOOT_ADDRESS);
            processor.execute();
      }
}

/* Client */

class Facade {
      public static void main(String[] args) {
            ComputerFacade computer = newComputerFacade();
            computer.start();
      }
}


Points to remember about façade design pattern:
1. Wrap a poorly designed collection of APIs with a single well-designed API.
2. Reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system;
3. Facade design pattern is more like a helper for client applications; it doesn’t hide subsystem interfaces from the client. Whether to use Facade or not is completely dependent on client code.
4. Facade design pattern can be applied at any point of development, usually when the number of interfaces grows and system gets complex.
5. Subsystem interfaces are not aware of Facade and they shouldn’t have any reference of the Facade interface.

We can use Factory pattern with Facade to provide better interface to client systems.

Sunday, 6 November 2016

Enum constant should be the first field in the enum

Java requires that the constants be defined first, prior to any fields or methods. Also, when there are fields and methods, the list of enum constants must end with a semicolon.

enum constants with compilation error:
public enum DayEnum {
    
     String value;
     /*Multiple markers at this line
     - Syntax error on token "String", invalid Modifiers
     - Syntax error on token ";", , expected*/
    
     SUNDAY, MONDAY, TUESDAY, WEDNESDAY,THURSDAY, FRIDAY, SATURDAY;
}

enum constants as first statement without any compilation error:
public enum DayEnum {
    
     SUNDAY, MONDAY, TUESDAY, WEDNESDAY,THURSDAY, FRIDAY, SATURDAY;
    
     String value;
}

Thursday, 3 November 2016

What is Interceptor in Struts2?

Interceptor is an object that is invoked at the preprocessing and post processing of a request. In Struts 2, interceptor is used to perform operations such as validation, exception handling, internationalization, displaying intermediate result etc.

ActionInvocation is responsible to encapsulate Action classes and interceptors and to fire them in order. The most important method for use in ActionInvocation is invoke() method that keeps track of the interceptor chain and invokes the next interceptor or action. This is the best example of Chain of Responsibility pattern in J2EE.

Interceptors are conceptually the same as servlet filters or the JDKs Proxy class.

Advantage of interceptors
Interceptor plays a crucial role in achieving high level of separation of concerns.
Providing preprocessing/post processing logic before/after the action is called.

Catching exceptions so that alternate processing can be performed.

Pluggable if we need to remove any concern such as validation, exception handling, logging etc. from the application, we don't need to redeploy the application. We only need to remove the entry from the struts.xml file.

Which design pattern is implemented by Struts2 interceptors?
Struts2 interceptors are based on intercepting filters design pattern. 

The invocation of interceptors in interceptor stack closely resembles Chain of Responsibility design pattern.
Related Posts Plugin for WordPress, Blogger...