replace use of <br> with <p> in all the javadoc
This commit is contained in:
Gavin King
parent
44fea07abf
commit
b1ed206339
|
|
@ -9,8 +9,8 @@ package org.hibernate;
|
|||
/**
|
||||
* Represents an association fetching strategy. This is used
|
||||
* together with the <tt>Criteria</tt> API to specify runtime
|
||||
* fetching strategies.<br>
|
||||
* <br>
|
||||
* fetching strategies.
|
||||
* <p>
|
||||
* For HQL queries, use the <tt>FETCH</tt> keyword instead.
|
||||
*
|
||||
* @see Criteria#setFetchMode(String, FetchMode)
|
||||
|
|
|
|||
|
|
@ -23,8 +23,8 @@ public enum LockMode {
|
|||
* No lock required. If an object is requested with this lock
|
||||
* mode, a <tt>READ</tt> lock will be obtained if it is
|
||||
* necessary to actually read the state from the database,
|
||||
* rather than pull it from a cache.<br>
|
||||
* <br>
|
||||
* rather than pull it from a cache.
|
||||
* <p>
|
||||
* This is the "default" lock mode.
|
||||
*/
|
||||
NONE( 0, "none" ),
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@ package org.hibernate;
|
|||
* be thrown when <tt>load()</tt> is called, even if there was no
|
||||
* row on the database, because <tt>load()</tt> returns a proxy if
|
||||
* possible. Applications should use <tt>Session.get()</tt> to test if
|
||||
* a row exists in the database.<br>
|
||||
* <br>
|
||||
* a row exists in the database.
|
||||
* <p>
|
||||
* Like all Hibernate exceptions, this exception is considered
|
||||
* unrecoverable.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -15,8 +15,8 @@ import org.hibernate.query.Query;
|
|||
* by arbitrary increments. The <tt>Query</tt> / <tt>ScrollableResults</tt>
|
||||
* pattern is very similar to the JDBC <tt>PreparedStatement</tt>/
|
||||
* <tt>ResultSet</tt> pattern and the semantics of methods of this interface
|
||||
* are similar to the similarly named methods on <tt>ResultSet</tt>.<br>
|
||||
* <br>
|
||||
* are similar to the similarly named methods on <tt>ResultSet</tt>.
|
||||
* <p>
|
||||
* Contrary to JDBC, columns of results are numbered from zero.
|
||||
*
|
||||
* @see Query#scroll()
|
||||
|
|
|
|||
|
|
@ -21,37 +21,37 @@ import org.hibernate.stat.SessionStatistics;
|
|||
|
||||
/**
|
||||
* The main runtime interface between a Java application and Hibernate. This is the
|
||||
* central API class abstracting the notion of a persistence service.<br>
|
||||
* <br>
|
||||
* central API class abstracting the notion of a persistence service.
|
||||
* <p>
|
||||
* The lifecycle of a <tt>Session</tt> is bounded by the beginning and end of a logical
|
||||
* transaction. (Long transactions might span several database transactions.)<br>
|
||||
* <br>
|
||||
* transaction. (Long transactions might span several database transactions.)
|
||||
* <p>
|
||||
* The main function of the <tt>Session</tt> is to offer create, read and delete operations
|
||||
* for instances of mapped entity classes. Instances may exist in one of three states:<br>
|
||||
* <br>
|
||||
* <i>transient:</i> never persistent, not associated with any <tt>Session</tt><br>
|
||||
* <i>persistent:</i> associated with a unique <tt>Session</tt><br>
|
||||
* <i>detached:</i> previously persistent, not associated with any <tt>Session</tt><br>
|
||||
* <br>
|
||||
* for instances of mapped entity classes. Instances may exist in one of three states:
|
||||
* <ul>
|
||||
* <li><i>transient:</i> never persistent, not associated with any <tt>Session</tt>
|
||||
* <li><i>persistent:</i> associated with a unique <tt>Session</tt>
|
||||
* <li><i>detached:</i> previously persistent, not associated with any <tt>Session</tt>
|
||||
* </ul>
|
||||
* Transient instances may be made persistent by calling <tt>save()</tt>,
|
||||
* <tt>persist()</tt> or <tt>saveOrUpdate()</tt>. Persistent instances may be made transient
|
||||
* by calling<tt> delete()</tt>. Any instance returned by a <tt>get()</tt> or
|
||||
* <tt>load()</tt> method is persistent. Detached instances may be made persistent
|
||||
* by calling <tt>update()</tt>, <tt>saveOrUpdate()</tt>, <tt>lock()</tt> or <tt>replicate()</tt>.
|
||||
* The state of a transient or detached instance may also be made persistent as a new
|
||||
* persistent instance by calling <tt>merge()</tt>.<br>
|
||||
* <br>
|
||||
* persistent instance by calling <tt>merge()</tt>.
|
||||
* <p>
|
||||
* <tt>save()</tt> and <tt>persist()</tt> result in an SQL <tt>INSERT</tt>, <tt>delete()</tt>
|
||||
* in an SQL <tt>DELETE</tt> and <tt>update()</tt> or <tt>merge()</tt> in an SQL <tt>UPDATE</tt>.
|
||||
* Changes to <i>persistent</i> instances are detected at flush time and also result in an SQL
|
||||
* <tt>UPDATE</tt>. <tt>saveOrUpdate()</tt> and <tt>replicate()</tt> result in either an
|
||||
* <tt>INSERT</tt> or an <tt>UPDATE</tt>.<br>
|
||||
* <br>
|
||||
* <tt>INSERT</tt> or an <tt>UPDATE</tt>.
|
||||
* <p>
|
||||
* It is not intended that implementors be threadsafe. Instead each thread/transaction
|
||||
* should obtain its own instance from a <tt>SessionFactory</tt>.<br>
|
||||
* <br>
|
||||
* A <tt>Session</tt> instance is serializable if its persistent classes are serializable.<br>
|
||||
* <br>
|
||||
* should obtain its own instance from a <tt>SessionFactory</tt>.
|
||||
* <p>
|
||||
* A <tt>Session</tt> instance is serializable if its persistent classes are serializable.
|
||||
* <p>
|
||||
* A typical transaction should use the following idiom:
|
||||
* <pre>
|
||||
* Session sess = factory.openSession();
|
||||
|
|
@ -70,7 +70,7 @@ import org.hibernate.stat.SessionStatistics;
|
|||
* sess.close();
|
||||
* }
|
||||
* </pre>
|
||||
* <br>
|
||||
* <p>
|
||||
* If the <tt>Session</tt> throws an exception, the transaction must be rolled back
|
||||
* and the session discarded. The internal state of the <tt>Session</tt> might not
|
||||
* be consistent with the database after the exception occurs.
|
||||
|
|
@ -332,7 +332,7 @@ public interface Session extends SharedSessionContract, EntityManager, AutoClose
|
|||
* Return the persistent instance of the given entity class with the given identifier,
|
||||
* assuming that the instance exists. This method might return a proxied instance that
|
||||
* is initialized on-demand, when a non-identifier method is accessed.
|
||||
* <br><br>
|
||||
* <p>
|
||||
* You should not use this method to determine if an instance exists (use <tt>get()</tt>
|
||||
* instead). Use this only to retrieve an instance that you assume exists, where non-existence
|
||||
* would be an actual error.
|
||||
|
|
@ -348,7 +348,7 @@ public interface Session extends SharedSessionContract, EntityManager, AutoClose
|
|||
* Return the persistent instance of the given entity class with the given identifier,
|
||||
* assuming that the instance exists. This method might return a proxied instance that
|
||||
* is initialized on-demand, when a non-identifier method is accessed.
|
||||
* <br><br>
|
||||
* <p>
|
||||
* You should not use this method to determine if an instance exists (use <tt>get()</tt>
|
||||
* instead). Use this only to retrieve an instance that you assume exists, where non-existence
|
||||
* would be an actual error.
|
||||
|
|
|
|||
|
|
@ -159,8 +159,8 @@ public interface StatelessSession extends SharedSessionContract, AutoCloseable,
|
|||
|
||||
/**
|
||||
* Returns the current JDBC connection associated with this
|
||||
* instance.<br>
|
||||
* <br>
|
||||
* instance.
|
||||
* <p>
|
||||
* If the session is using aggressive connection release (as in a
|
||||
* CMT environment), it is the application's responsibility to
|
||||
* close the connection returned by this call. Otherwise, the
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ import org.jboss.logging.Logger;
|
|||
|
||||
/**
|
||||
* Provides access to configuration info passed in <tt>Properties</tt> objects.
|
||||
* <br><br>
|
||||
* <p>
|
||||
* Hibernate has two property scopes:
|
||||
* <ul>
|
||||
* <li><b>Factory-level</b> properties may be passed to the <tt>SessionFactory</tt> when it
|
||||
|
|
@ -41,14 +41,14 @@ import org.jboss.logging.Logger;
|
|||
* </ul>
|
||||
* <tt>Environment</tt> properties are populated by calling <tt>System.getProperties()</tt>
|
||||
* and then from a resource named <tt>/hibernate.properties</tt> if it exists. System
|
||||
* properties override properties specified in <tt>hibernate.properties</tt>.<br>
|
||||
* <br>
|
||||
* properties override properties specified in <tt>hibernate.properties</tt>.
|
||||
* <p>
|
||||
* The <tt>SessionFactory</tt> is controlled by the following properties.
|
||||
* Properties may be either be <tt>System</tt> properties, properties
|
||||
* defined in a resource named <tt>/hibernate.properties</tt> or an instance of
|
||||
* <tt>java.util.Properties</tt> passed to
|
||||
* <tt>Configuration.build()</tt><br>
|
||||
* <br>
|
||||
* <tt>Configuration.build()</tt>
|
||||
* <p>
|
||||
* <table>
|
||||
* <tr><td><b>property</b></td><td><b>meaning</b></td></tr>
|
||||
* <tr>
|
||||
|
|
|
|||
|
|
@ -14,28 +14,29 @@ import java.io.Serializable;
|
|||
/**
|
||||
* Provides callbacks from the <tt>Session</tt> to the persistent object.
|
||||
* Persistent classes <b>may</b> implement this interface but they are not
|
||||
* required to.<br>
|
||||
* <br>
|
||||
* <b>onSave:</b> called just before the object is saved<br>
|
||||
* <b>onUpdate:</b> called just before an object is updated,
|
||||
* ie. when <tt>Session.update()</tt> is called<br>
|
||||
* <b>onDelete:</b> called just before an object is deleted<br>
|
||||
* <b>onLoad:</b> called just after an object is loaded<br>
|
||||
* <br>
|
||||
* required to.
|
||||
* <ul>
|
||||
* <li><b>onSave:</b> called just before the object is saved
|
||||
* <li><b>onUpdate:</b> called just before an object is updated,
|
||||
* ie. when <tt>Session.update()</tt> is called
|
||||
* <li><b>onDelete:</b> called just before an object is deleted
|
||||
* <b>onLoad:</b> called just after an object is loaded
|
||||
* </ul>
|
||||
* <p>
|
||||
* <tt>onLoad()</tt> may be used to initialize transient properties of the
|
||||
* object from its persistent state. It may <b>not</b> be used to load
|
||||
* dependent objects since the <tt>Session</tt> interface may not be
|
||||
* invoked from inside this method.<br>
|
||||
* <br>
|
||||
* invoked from inside this method.
|
||||
* <p>
|
||||
* A further intended usage of <tt>onLoad()</tt>, <tt>onSave()</tt> and
|
||||
* <tt>onUpdate()</tt> is to store a reference to the <tt>Session</tt>
|
||||
* for later use.<br>
|
||||
* <br>
|
||||
* for later use.
|
||||
* <p>
|
||||
* If <tt>onSave()</tt>, <tt>onUpdate()</tt> or <tt>onDelete()</tt> return
|
||||
* <tt>VETO</tt>, the operation is silently vetoed. If a
|
||||
* <tt>CallbackException</tt> is thrown, the operation is vetoed and the
|
||||
* exception is passed back to the application.<br>
|
||||
* <br>
|
||||
* exception is passed back to the application.
|
||||
* <p>
|
||||
* Note that <tt>onSave()</tt> is called after an identifier is assigned
|
||||
* to the object, except when identity column key generation is used.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -28,8 +28,8 @@ import org.hibernate.type.Type;
|
|||
* a regular <tt>Bag</tt> by adding a synthetic identifier column to the
|
||||
* table. This identifier is unique for all rows in the table, allowing very
|
||||
* efficient updates and deletes. The value of the identifier is never exposed
|
||||
* to the application.<br>
|
||||
* <br>
|
||||
* to the application.
|
||||
* <p>
|
||||
* <tt>IdentifierBag</tt>s may not be used for a many-to-one association.
|
||||
* Furthermore, there is no reason to use <tt>inverse="true"</tt>.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -24,18 +24,18 @@ import org.hibernate.type.Type;
|
|||
* automatically deleted when unreferenced and automatically become
|
||||
* persistent when held by a persistent object. Collections can be
|
||||
* passed between different objects (change "roles") and this might
|
||||
* cause their elements to move from one database table to another.<br>
|
||||
* <br>
|
||||
* cause their elements to move from one database table to another.
|
||||
* <p>
|
||||
* Hibernate "wraps" a java collection in an instance of
|
||||
* PersistentCollection. This mechanism is designed to support
|
||||
* tracking of changes to the collection's persistent state and
|
||||
* lazy instantiation of collection elements. The downside is that
|
||||
* only certain abstract collection types are supported and any
|
||||
* extra semantics are lost<br>
|
||||
* <br>
|
||||
* extra semantics are lost
|
||||
* <p>
|
||||
* Applications should <em>never</em> use classes in this package
|
||||
* directly, unless extending the "framework" here.<br>
|
||||
* <br>
|
||||
* directly, unless extending the "framework" here.
|
||||
* <p>
|
||||
* Changes to <em>structure</em> of the collection are recorded by the
|
||||
* collection calling back to the session. Changes to mutable
|
||||
* elements (ie. composite elements) are discovered by cloning their
|
||||
|
|
|
|||
|
|
@ -16,8 +16,8 @@ import org.hibernate.service.ServiceRegistry;
|
|||
import org.hibernate.type.Type;
|
||||
|
||||
/**
|
||||
* <b>assigned</b><br>
|
||||
* <br>
|
||||
* <b>assigned</b>
|
||||
* <p>
|
||||
* An <tt>IdentifierGenerator</tt> that returns the current identifier assigned
|
||||
* to an instance.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -25,11 +25,11 @@ import org.hibernate.type.Type;
|
|||
import static org.hibernate.internal.CoreLogging.messageLogger;
|
||||
|
||||
/**
|
||||
* <b>foreign</b><br>
|
||||
* <br>
|
||||
* <b>foreign</b>
|
||||
* <p>
|
||||
* An <tt>Identifier</tt> generator that uses the value of the id property of an
|
||||
* associated object<br>
|
||||
* <br>
|
||||
* associated object
|
||||
* <p>
|
||||
* One mapping parameter is required: property.
|
||||
*
|
||||
* @author Gavin King
|
||||
|
|
|
|||
|
|
@ -23,13 +23,13 @@ import org.hibernate.type.Type;
|
|||
* identifiers and the <tt>Session</tt>. It is not intended that
|
||||
* this interface ever be exposed to the application. It <b>is</b>
|
||||
* intended that users implement this interface to provide
|
||||
* custom identifier generation strategies.<br>
|
||||
* <br>
|
||||
* Implementors should provide a public default constructor.<br>
|
||||
* <br>
|
||||
* custom identifier generation strategies.
|
||||
* <p>
|
||||
* Implementors should provide a public default constructor.
|
||||
* <p>
|
||||
* Implementations that accept configuration parameters should
|
||||
* also implement <tt>Configurable</tt>.
|
||||
* <br>
|
||||
* <p>
|
||||
* Implementors <em>must</em> be thread-safe
|
||||
*
|
||||
* @author Gavin King
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ import org.hibernate.id.insert.InsertSelectIdentityInsert;
|
|||
/**
|
||||
* A generator for use with ANSI-SQL IDENTITY columns used as the primary key.
|
||||
* The IdentityGenerator for autoincrement/identity key generation.
|
||||
* <br><br>
|
||||
* <p>
|
||||
* Indicates to the <tt>Session</tt> that identity (ie. identity/autoincrement
|
||||
* column) key generation should be used.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -31,12 +31,12 @@ import org.hibernate.service.ServiceRegistry;
|
|||
import org.hibernate.type.Type;
|
||||
|
||||
/**
|
||||
* <b>increment</b><br>
|
||||
* <br>
|
||||
* <b>increment</b>
|
||||
* <p>
|
||||
* An <tt>IdentifierGenerator</tt> that returns a <tt>long</tt>, constructed by
|
||||
* counting from the maximum primary key value at startup. Not safe for use in a
|
||||
* cluster!<br>
|
||||
* <br>
|
||||
* cluster!
|
||||
* <p>
|
||||
* Mapping parameters supported, but not usually needed: tables, column.
|
||||
* (The tables parameter specified a comma-separated list of table names.)
|
||||
*
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ import org.hibernate.type.Type;
|
|||
|
||||
/**
|
||||
* An <tt>IdentifierGenerator</tt> that requires creation of database objects.
|
||||
* <br><br>
|
||||
* <p>
|
||||
* All <tt>PersistentIdentifierGenerator</tt>s have access to a special mapping parameter
|
||||
* in their {@link #configure(Type, Properties, ServiceRegistry)} method: schema
|
||||
*
|
||||
|
|
|
|||
|
|
@ -17,13 +17,13 @@ import org.hibernate.service.ServiceRegistry;
|
|||
import org.hibernate.type.Type;
|
||||
|
||||
/**
|
||||
* <b>uuid</b><br>
|
||||
* <br>
|
||||
* <b>uuid</b>
|
||||
* <p>
|
||||
* A <tt>UUIDGenerator</tt> that returns a string of length 32,
|
||||
* This string will consist of only hex digits. Optionally,
|
||||
* the string may be generated with separators between each
|
||||
* component of the UUID.
|
||||
* <p/>
|
||||
* <p>
|
||||
* Mapping parameters supported: separator.
|
||||
*
|
||||
* @author Gavin King
|
||||
|
|
|
|||
|
|
@ -39,19 +39,20 @@ import org.hibernate.type.Type;
|
|||
* A strategy for persisting a collection role. Defines a contract between
|
||||
* the persistence strategy and the actual persistent collection framework
|
||||
* and session. Does not define operations that are required for querying
|
||||
* collections, or loading by outer join.<br>
|
||||
* <br>
|
||||
* collections, or loading by outer join.
|
||||
* <p>
|
||||
* Implements persistence of a collection instance while the instance is
|
||||
* referenced in a particular role.<br>
|
||||
* <br>
|
||||
* referenced in a particular role.
|
||||
* <p>
|
||||
* This class is highly coupled to the <tt>PersistentCollection</tt>
|
||||
* hierarchy, since double dispatch is used to load and update collection
|
||||
* elements.<br>
|
||||
* <br>
|
||||
* elements.
|
||||
* <p>
|
||||
* May be considered an immutable view of the mapping object
|
||||
* <p/>
|
||||
* <p>
|
||||
* Unless a customer {@link org.hibernate.persister.spi.PersisterFactory} is used, it is expected
|
||||
* that implementations of CollectionDefinition define a constructor accepting the following arguments:<ol>
|
||||
* that implementations of CollectionDefinition define a constructor accepting the following arguments:
|
||||
* <ol>
|
||||
* <li>
|
||||
* {@link org.hibernate.mapping.Collection} - The metadata about the collection to be handled
|
||||
* by the persister
|
||||
|
|
|
|||
|
|
@ -14,9 +14,8 @@ import org.hibernate.internal.util.StringHelper;
|
|||
|
||||
/**
|
||||
* An SQL IN expression.
|
||||
* <br>
|
||||
* <p>
|
||||
* <code>... in(...)</code>
|
||||
* <br>
|
||||
*
|
||||
* @author Gavin King
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -18,8 +18,8 @@ import org.hibernate.engine.spi.SharedSessionContractImplementor;
|
|||
* This interface should be implemented by user-defined "types".
|
||||
* A "type" class is <em>not</em> the actual property type - it
|
||||
* is a class that knows how to serialize instances of another
|
||||
* class to and from JDBC.<br>
|
||||
* <br>
|
||||
* class to and from JDBC.
|
||||
* <p>
|
||||
* This interface
|
||||
* <ul>
|
||||
* <li>abstracts user code from future changes to the <tt>Type</tt>
|
||||
|
|
@ -27,16 +27,16 @@ import org.hibernate.engine.spi.SharedSessionContractImplementor;
|
|||
* <li>simplifies the implementation of custom types and</li>
|
||||
* <li>hides certain "internal" interfaces from user code.</li>
|
||||
* </ul>
|
||||
* <br>
|
||||
* <p>
|
||||
* Implementors must be immutable and must declare a public
|
||||
* default constructor.<br>
|
||||
* <br>
|
||||
* default constructor.
|
||||
* <p>
|
||||
* The actual class mapped by a <tt>UserType</tt> may be just
|
||||
* about anything.<br>
|
||||
* <br>
|
||||
* about anything.
|
||||
* <p>
|
||||
* <tt>CompositeUserType</tt> provides an extended version of
|
||||
* this interface that is useful for more complex cases.<br>
|
||||
* <br>
|
||||
* this interface that is useful for more complex cases.
|
||||
* <p>
|
||||
* Alternatively, custom types could implement <tt>Type</tt>
|
||||
* directly or extend one of the abstract classes in
|
||||
* <tt>org.hibernate.type</tt>. This approach risks future
|
||||
|
|
|
|||
Loading…
Reference in New Issue