在POJO Getter / Setter中添加静态方法逻辑

Question

I have a Persistence Entity class (JPA) where I'm debating adding a static method call in the getter and setter to do some conversion logic, but for some reason it just doesn't seem like the proper thing to do. Is there a best practice for getter/setter custom logic? Any downsides to this approach? The UI needs to enter the data with "/" but then another system interfacing with this one needs the "/" converted to "_".

@Entity
public class Sample {
 @Id   
 private id;
 @Column
 private String test;

 public String getTest() {
        return Util.convert(test);
 }
 public void setTest(String test) {
        this.test = Util.convert(test);
 }

}

    import org.apache.commons.lang3.StringUtils;
    public class Util{

    public static String convert(String enteredValue){
        return StringUtils.replace(enteredValue,"/","_"); //just example
    }
    }

Answer 1

No, your POJO should not be converting its data format just to become compatible with a system. This approach would break as soon as the POJO needs to work with disparate systems with different data format requirements.

The POJO should save its state true to its user input. The difference in format should be handled by the system that's requesting the data. This way if the format changes down the line the responsibility lies with the requesting system not with the POJO. If the POJO directly tries to accommodate the new format it risks breaking any other system that might have also become dependent on it.

If the client system requires the data in a particular format and does not wish to deal with it; it should then be handled by YourSystemFacade API that the client is using to interface with you. For example

// at the other system
YourSystemFacade.getInstance().getTestSample();

// at your system
class YourSystemFacade {
    // ...
    public String getTestSample() {
        return Utils.convert(sample.getTest());
    }
}

Answer 2

Making static method call in getter is ok. But you might face issues if another part of your application needs data in original format or some other format than this, lets say / replaced with .

Alternative approach would be to have another getter method, say getTestWithHyphen or getTestWithDot .

Or let your clients call Util method whenever they need data in different format.

Answer 3

Since the conversion logic is very simple you should put it in the setter, because all other methods in your class can then rely on the fact that the instance variable is always in a correct state. Also JPA can access it then through field access.

If the conversion would be more complex or time consuming I would place it in the getter and let all other methods only access it through the getter. But then you need one more field to track that state and you must configure JPA to use property access.

PS: rename setName or getTest if they belong to the same property

Answer 4

Well , there is nothing stop you to do this. You can do it.

I belive a POJO is also a simple java class, nothing special other than a proper pre defined structure.

You can use it safely.

Take some example from inbuilt methods too.Look at the getBytes() method.

From Open JDK String class

     public byte[] getBytes() {
     return StringCoding.encode(value, 0, value.length);
    }