andrus commented on code in PR #21:
URL: https://github.com/apache/cayenne-website/pull/21#discussion_r1257162587
##########
src/main/site/content/docs/4.2/cayenne-guide.html:
##########
@@ -524,22 +524,22 @@ <h4 id="objectcontext"><a class="anchor"
href="#objectcontext"></a>2.3.1. Object
</div>
</div>
<div class="paragraph">
- <p>The call above creates a new instance of ObjectContext that can access
the database via this runtime. ObjectContext is a single "work area" in
Cayenne, storing persistent objects. ObjectContext guarantees that for each
database row with a unique ID it will contain at most one instance of an
object, thus ensuring object graph consistency between multiple selects (a
feature called "uniquing"). At the same time different ObjectContexts will have
independent copies of objects for each unique database row. This allows users
to isolate object changes from one another by using separate
ObjectContexts.</p>
+ <p>The call above creates a new instance of ObjectContext that can access
the database via this runtime. ObjectContext is a single "work area" in
Cayenne, storing persistent objects. ObjectContext guarantees that, for each
database row with a unique ID, it will contain at most one instance of an
object, thus ensuring object graph consistency between multiple selects (a
feature called "uniquing"). At the same time, different ObjectContexts will
have independent copies of objects for each unique database row. This allows
users to isolate object changes from one another by using separate
ObjectContexts.</p>
</div>
<div class="paragraph">
- <p>These properties directly affect the strategies for scoping and
sharing (or not sharing) ObjectContexts. Contexts that are only used to fetch
objects from the database and whose objects are never modified by the
application can be shared between mutliple users (and multiple threads).
Contexts that store modified objects should be accessed only by a single user
(e.g. a web application user might reuse a context instance between multiple
web requests in the same HttpSession, thus carrying uncommitted changes to
objects from request to request, until he decides to commit or rollback them).
Even for a single user it might make sense to use mutliple ObjectContexts (e.g.
request-scoped contexts to allow concurrent requests from the browser that
change and commit objects independently).</p>
+ <p>These properties directly affect the strategies for scoping and
sharing (or not sharing) ObjectContexts. Contexts that are only used to fetch
objects from the database and whose objects are never modified by the
application can be shared between mutliple users (and multiple threads).
Contexts that store modified objects should be accessed only by a single user
(e.g. a web application user might reuse a context instance between multiple
web requests in the same HttpSession, thus carrying uncommitted changes to
objects from request to request, until they decide to commit them or roll them
back). Even for a single user it might make sense to use mutliple
ObjectContexts (e.g. request-scoped contexts to allow concurrent requests from
the browser that change and commit objects independently).</p>
</div>
<div class="paragraph">
- <p>ObjectContext is serializable and does not permanently hold to any of
the application resources. So it does not have to be closed. If the context is
not used anymore, it should simply be allowed to go out of scope and get
garbage collected, just like any other Java object.</p>
+ <p>ObjectContext is serializable and does not permanently hold any of the
application resources. So it does not have to be closed. If the context is not
used anymore, it should simply be allowed to go out of scope and get garbage
collected, just like any other Java object.</p>
</div>
</div>
<div class="sect3">
<h4 id="persistent-object-and-its-lifecycle"><a class="anchor"
href="#persistent-object-and-its-lifecycle"></a>2.3.2. Persistent Object and
its Lifecycle</h4>
<div class="paragraph">
- <p>Cayenne can persist Java objects that implement
<code>org.apache.cayenne.Persistent</code> interface. Generally persistent
classes are generated from the model as described above, so users do not have
to worry about superclass and property implementation details.</p>
+ <p>Cayenne can persist Java objects that implement the
<code>org.apache.cayenne.Persistent</code> interface. Generally, persistent
classes are generated from the model as described above, so users do not have
to worry about superclass and property implementation details.</p>
</div>
<div class="paragraph">
- <p>Persistent interface provides access to 3 persistence-related
properties - <em>objectId</em>, <em>persistenceState</em> and
<em>objectContext</em>. All 3 are initialized by Cayenne runtime framework.
Application code should not attempt to change them. However it is allowed to
read them, which provides valuable runtime information. E.g. ObjectId can be
used for quick equality check of 2 objects, knowing persistence state would
allow highlighting changed objects, etc.</p>
+ <p> The persistent interface provides access to three persistence-related
properties - <em>objectId</em>, <em>persistenceState</em> and
<em>objectContext</em>. All three are initialized by the Cayenne runtime
framework. Your application code should not attempt to change them. However, it
is allowed to read them, which provides valuable runtime information. E.g.
ObjectId can be used for a quick equality check of two objects, knowing
persistence state would allow highlighting changed objects, etc.</p>
Review Comment:
Here "Persistent" is the name of the interface, so it should be capitalized
(and probably wrapped in <code> block)
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
