Question

i’m trying to figure wether there’s a difference betweeen anotating (let’s take @id as an example) a getter method and the concerned field directly , in case i annotate the field , does JPA use some kind of reflection to invok the corresponding getter ?
because in my case i’m trying to obfuscate my entity classes , so i’m looking for a way to keep the business logic since the getters will be renamed into something like aaa() .

Answer 1

Here’s what the section 2.3.1 of the JPA2 specification says:

By default, a single access type (field or property access) applies to
an entity hierarchy. The default access type of an entity hierarchy is
determined by the placement of mapping annotations on the attributes
of the entity classes and mapped superclasses of the entity hierarchy
that do not explicitly specify an access type. An access type is
explicitly specified by means of the Access annotation[6], as
described in section 2.3.2. When annotations are used to define a
default access type, the placement of the mapping annotations on
either the persistent fields or persistent properties of the entity
class specifies the access type as being either field- or
property-based access respectively.

• When field-based access is used, the object/relational mapping annotations for the entity class annotate the instance variables, and
  the persistence provider runtime accesses instance variables directly.
  All non-transient instance variables that are not annotated with the
  Transient annotation are persistent.
• When property-based access is used, the object/relational mapping annotations for the entity class annotate the getter property
  accessors[7], and the persistence provider runtime accesses persistent
  state via the property accessor methods. All properties not annotated
  with the Transient annotation are persistent.
• Mapping annotations must not be applied to fields or properties that are transient or Transient.

All such classes in the entity hierarchy whose access type is
defaulted in this way must be consistent in their placement of
annotations on either fields or properties, such that a single,
consistent default access type applies within the hierarchy. Any
embeddable classes used by such classes will have the same access type
as the default access type of the hierarchy unless the Access
annotation is specified as defined below. It is an error if a default
access type cannot be determined and an access type is not explicitly
specified by means of annotations or the XML descriptor. The behavior
of applications that mix the placement of annotations on fields and
properties within an entity hierarchy without explicitly specifying
the Access annotation is undefined.

So, if you want to avoid problems with the obfuscation, then annotate the fields and not the getters, consistently, or use the @Access annotation to force field access type.