Hi Andrei,
You're not alone, I had the same misconception. Field and property access
apply to how the persistence provider runtime accesses the state of an
entity. Regardless of the access type the client should use the entity's
accessor methods.
>From section 2.1 and 2.1.1 of the JPA specification
2.1
. . .
The persistent state of an entity is represented by instance variables,
which may correspond to Java-
Beans properties. An instance variable may be directly accessed only from
within the methods of the
entity by the entity instance itself.* Instance variables must not be
accessed by clients of the entity. The
state of the entity is available to clients only through the entity's
accessor methods (getter/setter methods)
or other business methods*. Instance variables must be private, protected,
or package visibility.
2.1.1 Persistent Fields and Properties
The persistent state of an entity is accessed by the persistence provider
runtime[1] either via JavaBeans
style property accessors or via instance variables. A single access type
(field or property access) applies
to an entity hierarchy. When annotations are used, 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.
. . .
[1] The term "persistence provider runtime" refers to the runtime
environment of the persistence implementation. In Java EE environments,
this may be the Java EE container or a third-party persistence provider
implementation integrated with it.
. . .
So technically the second option is the more correct way to set a state
variable.
Hope this helps,
-mike
On Tue, Jun 17, 2008 at 2:27 PM, Andrei Tchijov <[EMAIL PROTECTED]>
wrote:
> I guess I m doing something wrong. Please enlighten me what it is I am
> doing wrong.
>
> I have a class with number of fields. One of which is boolean.
>
> @Entity
> class A {
> ...
> @Basic
> boolean foo;
> ...
> }
>
> OpenJPA doing wonderful job of retrieving "state" of the objects of this
> class (including 'foo' field). What puzzles me is that it seems to fail to
> do "opposite". Somewhere else in my code I have
>
>
> ...
> _tx.begin();
> A a = getA();
> a.foo = !a.foo;
> _tx.commit();
> ...
>
> It looks similar enough to examples from documentation, but it does not
> work. I am quite confident that "a" is in "attached" state when I am trying
> to change "condition" field (_em.contans(a ) returns true ). What makes me
> really puzzled is that if I change code like this:
>
>
> @Entity
> class A {
> ...
> @Basic
> boolean foo;
> ...
> public void setFoo( boolean v ) {
> this.foo = v;
> }
> }
>
>
> ...
> _tx.begin();
> A a = getA();
> a.setFoo( ! a.foo );
> _tx.commit();
> ...
>
>
> To complete picture, I should mention that I am running "outside of
> container" (stand alone application).
>
> Any help will be highly appreciated.
>
> Andrei
>
