Thursday, May 17, 2012

J2EE - PO, BO, VO, DTO, POJO and DAO concept

PO ( Persistent Object )
A PO data library record.
The advantage of the record as an object processing, can be easily converted into other objects.

BO ( Business Object )
The main role is to encapsulate the business logic for an object. This object can include one or more other objects.
Such as a resume, education, experience, work experience, education experience corresponds to a the PO and work experience correspond to a PO.
Establish a corresponding CV BO object processing resumes, each BO contains the PO.
So deal with business logic, we can for BO to deal with.

VO ( Value Object )
The ViewObject performance layer object corresponds to the interface to display data objects. For a WEB page, or SWT, SWING interface, with a VO object corresponding to the value of the entire interface.
Entity and the VO:
Entity with the Identity, the VO did not take the Identity that is Entity only transaction Identity considered as different objects, but as long as the VO attribute is changed, it is regarded as a different object

The DTO ( Data Transfer Object )
Mainly used in place of the remote call and need to transmit large amounts of objects.
For example, our one table has 100 fields, then the corresponding PO has 100 properties.
Our interface as long as 10 field, the client access to information, WEB service does not require the PO object passed to the client.
That can use only 10 attributes DTO to pass the results to the client, so would not be exposed to the service end of the table structure. To reach the client, if this object to the corresponding interface display, and that its identity into the VO

POJOs ( Plain Old Java Object or the Plain Ordinary Java Objects)
Attributes and getters, setters of Java Objects
A POJO persistence after a PO
Pass it directly, the transfer process is the DTO
Directly used to map the presentation layer is the VO

DAO ( Data Access Object )
Mainly used to encapsulate the database access. It can POJO persistence into the PO, PO assembly of the VO, the DTO

Wednesday, May 16, 2012

Design Patterns Tutorials

How do you apply design patterns?

  1. It depends how you write the code. If it's a big project I decide before coding, then after I start writing the code, if I notice places where design patterns should be used, I refactor the code.
  2. Yes, as mentioned before.
  3. in 99.99% of the cases: Factory Pattern, Singleton (Like everyone I use it in many places because is simple to implement, and in practice I tend to remove it while refactoring the code). Then: Object Pool(if I have resources I want to reuse - some of my projects are games and I need a good management of resources), Strategy and Template Method (because they are great for decoupling and serve well the purpose to make the code easy to extend). Then the Adapter is something to use when you have a library you want to use, without relying on it(decoupling).
  4. Same as Above, if I didn't use them yet. It works also in the opposite way. If I don't find the reason to use a design pattern I remove it or skip it while writing the code (it happens all the time with singleton and from time to time with factories. Sometime I use a factory which is also a singleton to provide me those which were supposed to be singletons objects; not sure if it's wise thing to do, but it works for me).
  5. The only code hint I might think it the number of references you have to a class. You can also use PMD, jDepend and Architecture Rules to spot the places where the classes contains too many dependencies. I'm not sure it this is a coding tip. In the design phase and not only there when you decide to use a design pattern just think to the benefits. I found that Software Design Principles are extremely important to help you understand when and why (not) to use a design pattern, but they are unknown to many programmers who are using design patterns.
  6. I'm not sure what do you mean by Micro DP. I'm trying to use DPs only when I find reasons to use them and when the benefits seem to be bigger than the problems. I avoid the overuse because it leads you to loosing time implementing and maintaining factory patterns instead of real software.
                                                                                                                                                                  Flyweight reduces memory consumption.
The Proxy pattern can be used for speed optimization.
The Bridge pattern can change the implementation of an abstraction on the fly - always picking the most efficient one.

    Java Design Patterns

    Using the MVC design pattern with JSP/Servlet


     Model View Controller pattern

    The core (architectural) design pattern you'd like to use is the Model-View-Controller pattern. The Controller is to be represented by a Servlet which (in)directly creates/uses a specific Model and View based on the request. The Model is to be represented by Javabean classes. This is often further dividable in Business Model which contains the actions (behaviour) and Data Model which contains the data (information). The View is to be represented by JSP files which have direct access to the (Data) Model by EL (Expression Language).
    Then there are variations based on how actions and events are handled. The popular ones are:
    • Request (action) based MVC: this is the simplest to implement. The (Business) Model works directly with HttpServletRequest and HttpServletResponse objects. You have to gather, convert and validate the request parameters (mostly) yourself. The View can be represented by plain vanilla HTML/CSS/JS and it does not maintain state across requests. This is how among others Spring MVC, Struts and Stripes works.
    • Component based MVC: this is harder to implement. But you end up with a simpler model and view wherein all the "raw" Servlet API is abstracted completely away. You shouldn't have the need to gather, convert and validate the request parameters yourself. The Controller does this task and sets the gathered, converted and validated request parameters in the Model. All you need to do is to define action methods which works directly with the model properties. The View is represented by "components" in flavor of JSP taglibs or XML elements which in turn generates HTML/CSS/JS. The state of the View for the subsequent requests is maintained in the session. This is particularly helpful for server-side conversion, validation and value change events. This is how among others JSF, Wicket and Play! works.
    As a side note, I warmly recommend to pick an existing framework rather than reinventing your own. Learning an existing and well-developed framework takes in long term less time than developing and maintaining a robust framework yourself. From the mentioned ones I personally recommend JSF 2.0.
    In the below detailed explanation I'll restrict myself to request based MVC since that's easier to implement.

    Front Controller pattern (Mediator pattern)

    First, the Controller part should implement the Front Controller pattern (which is a specialized kind of Mediator pattern). It should exist of only a single servlet which provides a centralized entry point of all requests. It should create the Model based on information available by the request, such as the pathinfo or servletpath, the method and/or specific parameters. The Business Model is called Action in the below HttpServlet example.
    protected void service(HttpServletRequest request,  
        HttpServletResponse response) throws ServletException, IOException {
        try {
            Action action = ActionFactory.getAction(request);
            String view = action.execute(request, response);
            if (view.equals(request.getPathInfo().substring(1)) {
                request.getRequestDispatcher("/WEB-INF/" + view + ".jsp")
                    .forward(request, response);
            } else {
               // We'd like to fire redirect in case of a view change as 
               //result of the action (PRG pattern).
        } catch (Exception e) {
            throw new ServletException("Executing action failed.", e);

    Strategy pattern

    The Action should follow the Stategy pattern. It needs to be definied as an abstract/interface type which should do the work based on the passed-in arguments of the abstract method (this is the difference with the Command pattern, wherein the abstract/interface type should do the work based on the arguments which are been passed-in during the creation of the implementation).
    public interface Action {
    public String execute(HttpServletRequest request, HttpServletResponse response) throws Exception;
    You may want to make the Exception more specific with a custom exception like ActionException. It's just a basic kickoff example, the remnant is all up to you.
    Here's an example of a LoginAction which (as its name says) logs in the user. The User itself is in turn a Data Model. The View is aware of the presence of the User.
    public class LoginAction implements Action {
    public String execute(HttpServletRequest request, HttpServletResponse response) throws Exception {
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    User user = userDAO.find(username, password);
    if (user != null) {
    .getSession().setAttribute("user", user); // Login user.
    return "home"; // Redirect to home page.
    } else {
    .setAttribute("error", "Unknown username/password. Please retry."); // Store error message in request scope.
    return "login"; // Go back to redisplay login form with error.

    Abstract Factory pattern

    The ActionFactory should follow the Abstract Factory pattern. Basically, it should provide a creational method which returns an abstract/interface type. In this case, it should return an implementation of the Action interface based on the information provided by the request. For example, the method and pathinfo (the pathinfo is the part after the context and servlet path in the request URL, excluding the query stirng).
    public static Action getAction(HttpServletRequest request) {
        return actions.get(request.getMethod() + request.getPathInfo());
    The actions in turn should be some static/applicationwide Map<String, Action> which holds all known actions. It's up to you how to fill this map. Hardcoding:
    actions.put("POST/register", new RegisterAction());
    actions.put("POST/login", new LoginAction());
    actions.put("GET/logout", new LogoutAction());
    // ...
    Or configureable based on a properties/XML configuration file in the classpath: (pseudo)
    for (Entry entry : configuration) {
        actions.put(entry.getKey(), Class.forName(entry.getValue()).newInstance());
    Or dynamically based on a scan in the classpath for classes implementing a certain interface and/or annotation: (pseudo)
    for (ClassFile classFile : classpath) {
        if (classFile.isInstanceOf(Action.class)) {
           actions.put(classFile.getAnnotation("mapping"), classFile.newInstance());
    Keep in mind to create a "do nothing" Action for the case there's no mapping. Let it for example return directly the request.getPathInfo().substring(1) then.

    Java examples of GoF design patterns


    Creational patterns

    Abstract factory (recognizeable by creational methods returning an abstract/interface type)

    Builder  (recognizeable by creational methods returning the instance itself)

    Factory method (recognizeable by creational methods returning a concrete type)

    Prototype (recognizeable by creational methods returning a different instance of itself with the same properties)

    Singleton (recognizeable by creational methods returning the same instance (usually of itself) everytime)

    Structural patterns

    Adapter (recognizeable by creational methods taking an instance of different abstract/interface type and returning an implementation of own/another abstract/interface type which decorates/overrides the given instance)

    Bridge (recognizeable by creational methods taking an instance of different abstract/interface type and returning an implementation of own abstract/interface type which delegates/uses the given instance)

    • None comes to mind yet. A fictive example would be new LinkedHashMap(LinkedHashSet<K>, List<V>) which returns an unmodifiable linked map which doesn't clone the items, but uses them. The java.util.Collections#newSetFromMap() and singletonXXX() methods however comes close.

    Composite (recognizeable by behavioral methods taking an instance of same abstract/interface type)

    Decorator (recognizeable by creational methods taking an instance of same abstract/interface type)

    Facade (recognizeable by behavioral methods which internally uses instances of different independent abstract/interface types)

    Flyweight (recognizeable by creational methods returning a cached instance, a bit the "multiton" idea)

    Proxy (recognizeable by creational methods which returns an implementation of given abstract/interface type which in turn delegates/uses a different implementation of given abstract/interface type)

    Behavioral patterns

    Chain of responsibility (recognizeable by behavioral methods which (indirectly) invokes the same method in another implementation of same abstract/interface type in a queue)

    Command (recognizeable by behavioral methods in an abstract/interface type which invokes a method in an implementation of a different abstract/interface type which has been encapsulated by the command implementation during its creation)

    Interpreter (recognizeable by behavioral methods returning a structurally different instance/type of the given instance/type; note that parsing/formatting is not part of the pattern, determining the pattern and how to apply it is)

    Iterator (recognizeable by behavioral methods sequentially returning instances of a different type from a queue)

    Mediator (recognizeable by behavioral methods taking an instance of different abstract/interface type (usually using the command pattern) which delegates/uses the given instance)

    Memento (recognizeable by behavioral methods which internally changes the state of the whole instance)

    Observer (or Publish/Subscribe) (recognizeable by behavioral methods which invokes a method on an instance of another abstract/interface type, depending on own state)

    State (recognizeable by behavioral methods which changes its behaviour depending on the instance's state which can be controlled externally)

    Strategy (recognizeable by behavioral methods in an abstract/interface type which invokes a method in an implementation of a different abstract/interface type which has been passed-in as method argument into the strategy implementation)

    Template method (recognizeable by behavioral methods which already have a "default" behaviour definied by an abstract type)

    Visitor (recognizeable by two different abstract/interface types which has methods definied which takes each the other abstract/interface type; the one actually calls the method of the other and the other executes the desired strategy on it)