CODEWITHSUNDEEP
javadesign-patterns
Niranjan
Niranjan

Reputation: 2931

What design pattern is appropriate here?

I am working on an application which has REST endpoints and for a Get-By-ID service, I am populating a resource (basically a POJO) by collecting data from the persistent store. Now, before sending the response back, I have to populate the HREF in the POJO resource. I want to do it in a generic way so that various other REST services (search etc.) can use it. I want to do this HREF population at a common place for reusability purpose. In a nutshell, my resource POJO can go through various massaging layers to have different state changed and finally sent back to the consumer.


    Resource POJO --> Massager 1 --> Massager 2 --> Final Massaged POJO

Could someone help me to figure out a design pattern that can fit my problem.

I thought of Decorator pattern, but somehow it does not sail my ship.

~ NN

Upvotes: 2

Views: 164

Answers (2)

ekostadinov
ekostadinov

Reputation: 6950

Even if the previous answers are good and does solve it, I want to propose you additional way if you want to go further. The communication between objects is very common, so a lot of concepts are out there and you can choose the one that fits best for your needs.

The Command pattern can help you with the encapsulation of a request as an object in

collecting data from the persistent store

It'll allow you to parameterize clients with queue or log requests.

The Mediator pattern can define your communication between the Massager 1 --> Massager 2 classes. By doing this it'll encapsulate your objects interaction. Also it promotes loose coupling by keeping objects from referring to each other explicitly, and it'll let you vary their interaction independently.

If you'll deal with how to notify change to Massager 1 --> Massager 2 classes

my resource POJO can go through various massaging layers to have different state changed

than the Observer pattern can define a dependency between your objects so that when one object changes state, all its dependents are notified and updated automatically.

Upvotes: 1

Daniel
Daniel

Reputation: 1861

You could adapt Chain Of Responsability to your needs. Instead of having a series of processing objects which pass your POJO from one to another in case it cannot handle it, you could process your POJO and then pass it further. 

abstract class Messager{

    private  Messager nextMessager;

    void setNextMessager(Messager messager){
        this.nextMessager = messager;
    }

    Messager getNextMessager(){
        return this.nextMessager;
    }

    abstract void handle(Pojo pojo);
}

class FooMessager extends Messager{

    void handle(Pojo pojo){
       //operate on your pojo
       if(pojo.getHref == null){
           pojo.setHref("broken");
       }

       if(this.getNextMessager() != null){
           this.getNextMessager().handle(pojo);
       }

    }
}

class BarMessager{

     void handle(Pojo pojo){
       //operate on your pojo
       if(pojo.getHref().contains("broken")){
          pojo.setHref(pojo.getHref().replace("broken","fixed"));
       }

       if(this.getNextMessager() != null){
           this.getNextMessager().handle(pojo);
       }

    }

}

class Pojo{

    private String href;

    public Pojo() {
    }

    public String getHref() {
        return href;
    }

    public void setHref(String href) {
        this.href = href;
    }

}

class Test{

     public static void main(String[] args) {

         Pojo pojo = new Pojo();
         pojo.setHref(null);

         Messager foo = new FooMessager();
         Messager bar = new BarMessager();
         foo.setNextMessager(bar);

         foo.handle();
     }
}

Upvotes: 4

Related Questions