我应该在哪里放置字段/方法注释？

Question

I appreciate that the answer to this could be 'just be consistent' but I'd like to understand whether there are advantages to adding annotations that apply to field/method to the field or the method. For example, are there any benefits of:

@XmlElement
private String str;

public String getString() {
    return str;
}

over:

private String str;

@XmlElement
public String getString() {
    return str;
}

Thanks.

Answer 1

It depends if there is logic in the get/set methods that you want to be executed during a marshal or unmarshal operation.

Example #1 - JPA Entities

Some JPA implementations use byte code manipulation to "weave" in code on the getter to perform lazy loading. If you are mapping this type of model to XML, then you will need to annotate the getter to ensure that the logic on the get methods is called.

Example #2 - Mismatched get/set Methods

In the answer below the user had non-compliant bean access methods. For that use case I recommended the use of field access.

• Integer to int using jaxb

Example #3 - Read-Only Properties

If your object model has properties with a getter but no setter, then field access is useful.

For More Information

• http://blog.bdoughan.com/2011/06/using-jaxbs-xmlaccessortype-to.html

Answer 2

That depends on what you're doing. For example: your xml serializer/converter uses the getter or read the field directly?

1. If it uses getter, mark the getter, since you can use any back logic for the getter, not only back field.
2. If it read the field directly, mark the field, since the get is useless for the feature. The getter may change in the future but the field won't and cannot change.

Answer 3

In the first case, access to the annotated element will be performed using reflexion as the field is private. This may lead to less optimal performance (to be checked on a real live case).

In the second case, the access will be performed using the getter/setter.

In Hibernate, for instance, annotating a private attribute can create true read-only attribute:

@Id
private int id;

// No setter so it cannot be changed without reflexion
public int getId() {
    return id;
}

On the other hand, annotating the accessors will give you the opportunity to do more than merely setting/getting an attribute.

Answer 4

The benefit dependends on what the annotation represents.

1. Many frameworks allow field/method annotations to complement each other, such as setter injection in the Spring framework. There field annotations lets you decide if a setter should be present or not.

2. Other annotation processors might trigger different behaviour based on if it's a method or field which is annotated. For instance, a security annotation might be put on method control authorization to that method, while a field annotation might control authorization to all routines referencing the variable.

But generally the option in my opinion is most likely that of preference , or style if you wish.