|
|
Hibernate example source code file (persistent_classes.pot)
This example Hibernate source code file (persistent_classes.pot) is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.
The Hibernate persistent_classes.pot source code
# SOME DESCRIPTIVE TITLE.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-07-20 21:02+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <kde-i18n-doc@kde.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: application/x-xml2pot; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
#. Tag: title
#: persistent_classes.xml:32
#, no-c-format
msgid "Persistent Classes"
msgstr ""
#. Tag: para
#: persistent_classes.xml:34
#, no-c-format
msgid "Persistent classes are classes in an application that implement the entities of the business problem (e.g. Customer and Order in an E-commerce application). The term \"persistent\" here means that the classes are able to be persisted, not that they are in the persistent state (see <xref linkend=\"objectstate-overview\"/> for discussion)."
msgstr ""
#. Tag: para
#: persistent_classes.xml:41
#, no-c-format
msgid "Hibernate works best if these classes follow some simple rules, also known as the Plain Old Java Object (POJO) programming model. However, none of these rules are hard requirements. Indeed, Hibernate assumes very little about the nature of your persistent objects. You can express a domain model in other ways (using trees of <interfacename>java.util.Map instances, for example)."
msgstr ""
#. Tag: title
#: persistent_classes.xml:49
#, no-c-format
msgid "A simple POJO example"
msgstr ""
#. Tag: title
#: persistent_classes.xml:52
#, no-c-format
msgid "Simple POJO representing a cat"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:53
#, no-c-format
msgid ""
"package eg;\n"
"import java.util.Set;\n"
"import java.util.Date;\n"
"\n"
"public class Cat {\n"
"private Long id; // identifier\n"
"\n"
"private Date birthdate;\n"
"private Color color;\n"
"private char sex;\n"
"private float weight;\n"
" private int litterId;\n"
"\n"
" private Cat mother;\n"
" private Set kittens = new HashSet();\n"
"\n"
" private void setId(Long id) {\n"
" this.id=id;\n"
" }\n"
" public Long getId() {\n"
" return id;\n"
" }\n"
"\n"
" void setBirthdate(Date date) {\n"
" birthdate = date;\n"
" }\n"
" public Date getBirthdate() {\n"
" return birthdate;\n"
" }\n"
"\n"
" void setWeight(float weight) {\n"
" this.weight = weight;\n"
" }\n"
" public float getWeight() {\n"
" return weight;\n"
" }\n"
"\n"
" public Color getColor() {\n"
" return color;\n"
" }\n"
" void setColor(Color color) {\n"
" this.color = color;\n"
" }\n"
"\n"
" void setSex(char sex) {\n"
" this.sex=sex;\n"
" }\n"
" public char getSex() {\n"
" return sex;\n"
" }\n"
"\n"
" void setLitterId(int id) {\n"
" this.litterId = id;\n"
" }\n"
" public int getLitterId() {\n"
" return litterId;\n"
" }\n"
"\n"
" void setMother(Cat mother) {\n"
" this.mother = mother;\n"
" }\n"
" public Cat getMother() {\n"
" return mother;\n"
" }\n"
" void setKittens(Set kittens) {\n"
" this.kittens = kittens;\n"
" }\n"
" public Set getKittens() {\n"
" return kittens;\n"
" }\n"
"\n"
" // addKitten not needed by Hibernate\n"
" public void addKitten(Cat kitten) {\n"
" kitten.setMother(this);\n"
" kitten.setLitterId( kittens.size() );\n"
" kittens.add(kitten);\n"
" }\n"
"}"
msgstr ""
#. Tag: para
#: persistent_classes.xml:57
#, no-c-format
msgid "The four main rules of persistent classes are explored in more detail in the following sections."
msgstr ""
#. Tag: title
#: persistent_classes.xml:62
#, no-c-format
msgid "Implement a no-argument constructor"
msgstr ""
#. Tag: para
#: persistent_classes.xml:64
#, no-c-format
msgid "<classname>Cat has a no-argument constructor. All persistent classes must have a default constructor (which can be non-public) so that Hibernate can instantiate them using java.lang.reflect.Constructor.newInstance(). It is recommended that this constructor be defined with at least package visibility in order for runtime proxy generation to work properly."
msgstr ""
#. Tag: title
#: persistent_classes.xml:74
#, no-c-format
msgid "Provide an identifier property"
msgstr ""
#. Tag: para
#: persistent_classes.xml:77
#, no-c-format
msgid "Historically this was considered option. While still not (yet) enforced, this should be considered a deprecated feature as it will be completely required to provide a identifier property in an upcoming release."
msgstr ""
#. Tag: para
#: persistent_classes.xml:84
#, no-c-format
msgid "<classname>Cat has a property named id. This property maps to the primary key column(s) of the underlying database table. The type of the identifier property can be any \"basic\" type (see ). See for information on mapping composite (multi-column) identifiers."
msgstr ""
#. Tag: para
#: persistent_classes.xml:92
#, no-c-format
msgid "Identifiers do not necessarily need to identify column(s) in the database physically defined as a primary key. They should just identify columns that can be used to uniquely identify rows in the underlying table."
msgstr ""
#. Tag: para
#: persistent_classes.xml:99
#, no-c-format
msgid "We recommend that you declare consistently-named identifier properties on persistent classes and that you use a nullable (i.e., non-primitive) type."
msgstr ""
#. Tag: title
#: persistent_classes.xml:107
#, no-c-format
msgid "Prefer non-final classes (semi-optional)"
msgstr ""
#. Tag: para
#: persistent_classes.xml:109
#, no-c-format
msgid "A central feature of Hibernate, <emphasis>proxies (lazy loading), depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods. You can persist final classes that do not implement an interface with Hibernate; you will not, however, be able to use proxies for lazy association fetching which will ultimately limit your options for performance tuning. To persist a final class which does not implement a \"full\" interface you must disable proxy generation. See and ."
msgstr ""
#. Tag: title
#: persistent_classes.xml:121
#, no-c-format
msgid "Disabling proxies in <literal>hbm.xml"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:122
#, no-c-format
msgid "<![CDATA[]]>"
msgstr ""
#. Tag: title
#: persistent_classes.xml:126
#, no-c-format
msgid "Disabling proxies in annotations"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:127
#, no-c-format
msgid "<![CDATA[@Entity @Proxy(lazy=false) public class Cat { ... }]]>"
msgstr ""
#. Tag: para
#: persistent_classes.xml:130
#, no-c-format
msgid "If the <literal>final class does implement a proper interface, you could alternatively tell Hibernate to use the interface instead when generating the proxies. See and ."
msgstr ""
#. Tag: title
#: persistent_classes.xml:139
#, no-c-format
msgid "Proxying an interface in <literal>hbm.xml"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:140
#, no-c-format
msgid "<![CDATA[]]>"
msgstr ""
#. Tag: title
#: persistent_classes.xml:144
#, no-c-format
msgid "Proxying an interface in annotations"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:145
#, no-c-format
msgid "<![CDATA[@Entity @Proxy(proxyClass=ICat.class) public class Cat implements ICat { ... }]]>"
msgstr ""
#. Tag: para
#: persistent_classes.xml:148
#, no-c-format
msgid "You should also avoid declaring <literal>public final methods as this will again limit the ability to generate proxies from this class. If you want to use a class with public final methods, you must explicitly disable proxying. Again, see and ."
msgstr ""
#. Tag: title
#: persistent_classes.xml:158
#, no-c-format
msgid "Declare accessors and mutators for persistent fields (optional)"
msgstr ""
#. Tag: para
#: persistent_classes.xml:160
#, no-c-format
msgid "<classname>Cat declares accessor methods for all its persistent fields. Many other ORM tools directly persist instance variables. It is better to provide an indirection between the relational schema and internal data structures of the class. By default, Hibernate persists JavaBeans style properties and recognizes method names of the form getFoo, isFoo and setFoo. If required, you can switch to direct field access for particular properties."
msgstr ""
#. Tag: para
#: persistent_classes.xml:169
#, no-c-format
msgid "Properties need <emphasis>not be declared public. Hibernate can persist a property declared with package, protected or private visibility as well."
msgstr ""
#. Tag: title
#: persistent_classes.xml:178
#, no-c-format
msgid "Implementing inheritance"
msgstr ""
#. Tag: para
#: persistent_classes.xml:180
#, no-c-format
msgid "A subclass must also observe the first and second rules. It inherits its identifier property from the superclass, <literal>Cat. For example:"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:184
#, no-c-format
msgid ""
"package eg;\n"
"\n"
"public class DomesticCat extends Cat {\n"
" private String name;\n"
"\n"
" public String getName() {\n"
" return name;\n"
" }\n"
" protected void setName(String name) {\n"
" this.name=name;\n"
" }\n"
"}"
msgstr ""
#. Tag: title
#: persistent_classes.xml:188
#, no-c-format
msgid "Implementing <literal>equals() and hashCode()"
msgstr ""
#. Tag: para
#: persistent_classes.xml:191
#, no-c-format
msgid "You have to override the <literal>equals() and hashCode() methods if you:"
msgstr ""
#. Tag: para
#: persistent_classes.xml:196
#, no-c-format
msgid "intend to put instances of persistent classes in a <literal>Set (the recommended way to represent many-valued associations); and"
msgstr ""
#. Tag: para
#: persistent_classes.xml:202
#, no-c-format
msgid "intend to use reattachment of detached instances"
msgstr ""
#. Tag: para
#: persistent_classes.xml:206
#, no-c-format
msgid "Hibernate guarantees equivalence of persistent identity (database row) and Java identity only inside a particular session scope. When you mix instances retrieved in different sessions, you must implement <literal>equals() and hashCode() if you wish to have meaningful semantics for Sets."
msgstr ""
#. Tag: para
#: persistent_classes.xml:212
#, no-c-format
msgid "The most obvious way is to implement <literal>equals()/hashCode() by comparing the identifier value of both objects. If the value is the same, both must be the same database row, because they are equal. If both are added to a Set, you will only have one element in the Set). Unfortunately, you cannot use that approach with generated identifiers. Hibernate will only assign identifier values to objects that are persistent; a newly created instance will not have any identifier value. Furthermore, if an instance is unsaved and currently in a Set, saving it will assign an identifier value to the object. If equals() and hashCode() are based on the identifier value, the hash code would change, breaking the contract of the Set. See the Hibernate website for a full discussion of this problem. This is not a Hibernate issue, but normal Java semantics of object identity and equality."
msgstr ""
#. Tag: para
#: persistent_classes.xml:228
#, no-c-format
msgid "It is recommended that you implement <literal>equals() and hashCode() using Business key equality. Business key equality means that the equals() method compares only the properties that form the business key. It is a key that would identify our instance in the real world (a natural candidate key):"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:235
#, no-c-format
msgid ""
"public class Cat {\n"
"\n"
" ...\n"
" public boolean equals(Object other) {\n"
" if (this == other) return true;\n"
" if ( !(other instanceof Cat) ) return false;\n"
"\n"
" final Cat cat = (Cat) other;\n"
"\n"
" if ( !cat.getLitterId().equals( getLitterId() ) ) return false;\n"
" if ( !cat.getMother().equals( getMother() ) ) return false;\n"
"\n"
" return true;\n"
" }\n"
"\n"
" public int hashCode() {\n"
" int result;\n"
" result = getMother().hashCode();\n"
" result = 29 * result + getLitterId();\n"
" return result;\n"
" }\n"
"\n"
"}"
msgstr ""
#. Tag: para
#: persistent_classes.xml:237
#, no-c-format
msgid "A business key does not have to be as solid as a database primary key candidate (see <xref linkend=\"transactions-basics-identity\"/>). Immutable or unique properties are usually good candidates for a business key."
msgstr ""
#. Tag: title
#: persistent_classes.xml:244
#, no-c-format
msgid "Dynamic models"
msgstr ""
#. Tag: title
#: persistent_classes.xml:247
#, no-c-format
msgid "Note"
msgstr ""
#. Tag: emphasis
#: persistent_classes.xml:249
#, no-c-format
msgid "The following features are currently considered experimental and may change in the near future."
msgstr ""
#. Tag: para
#: persistent_classes.xml:253
#, no-c-format
msgid "Persistent entities do not necessarily have to be represented as POJO classes or as JavaBean objects at runtime. Hibernate also supports dynamic models (using <literal>Maps of Maps at runtime) and the representation of entities as DOM4J trees. With this approach, you do not write persistent classes, only mapping files."
msgstr ""
#. Tag: para
#: persistent_classes.xml:259
#, no-c-format
msgid "By default, Hibernate works in normal POJO mode. You can set a default entity representation mode for a particular <literal>SessionFactory using the default_entity_mode configuration option (see )."
msgstr ""
#. Tag: para
#: persistent_classes.xml:265
#, no-c-format
msgid "The following examples demonstrate the representation using <literal>Maps. First, in the mapping file an entity-name has to be declared instead of, or in addition to, a class name:"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:270
#, no-c-format
msgid ""
"<hibernate-mapping>\n"
"\n"
" <class entity-name=\"Customer\">\n"
"\n"
" <id name=\"id\"\n"
" type=\"long\"\n"
" column=\"ID\">\n"
" <generator class=\"sequence\"/>\n"
" </id>\n"
"\n"
" <property name=\"name\"\n"
" column=\"NAME\"\n"
" type=\"string\"/>\n"
"\n"
" <property name=\"address\"\n"
" column=\"ADDRESS\"\n"
" type=\"string\"/>\n"
"\n"
" <many-to-one name=\"organization\"\n"
" column=\"ORGANIZATION_ID\"\n"
" class=\"Organization\"/>\n"
"\n"
" <bag name=\"orders\"\n"
" inverse=\"true\"\n"
" lazy=\"false\"\n"
" cascade=\"all\">\n"
" <key column=\"CUSTOMER_ID\"/>\n"
" <one-to-many class=\"Order\"/>\n"
" </bag>\n"
"\n"
" </class>\n"
" \n"
"</hibernate-mapping>"
msgstr ""
#. Tag: para
#: persistent_classes.xml:272
#, no-c-format
msgid "Even though associations are declared using target class names, the target type of associations can also be a dynamic entity instead of a POJO."
msgstr ""
#. Tag: para
#: persistent_classes.xml:276
#, no-c-format
msgid "After setting the default entity mode to <literal>dynamic-map for the SessionFactory, you can, at runtime, work with Maps of Maps:"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:281
#, no-c-format
msgid ""
"Session s = openSession();\n"
"Transaction tx = s.beginTransaction();\n"
"\n"
"// Create a customer\n"
"Map david = new HashMap();\n"
"david.put(\"name\", \"David\");\n"
"\n"
"// Create an organization\n"
"Map foobar = new HashMap();\n"
"foobar.put(\"name\", \"Foobar Inc.\");\n"
"\n"
"// Link both\n"
"david.put(\"organization\", foobar);\n"
"\n"
"// Save both\n"
"s.save(\"Customer\", david);\n"
"s.save(\"Organization\", foobar);\n"
"\n"
"tx.commit();\n"
"s.close();"
msgstr ""
#. Tag: para
#: persistent_classes.xml:283
#, no-c-format
msgid "One of the main advantages of dynamic mapping is quick turnaround time for prototyping, without the need for entity class implementation. However, you lose compile-time type checking and will likely deal with many exceptions at runtime. As a result of the Hibernate mapping, the database schema can easily be normalized and sound, allowing to add a proper domain model implementation on top later on."
msgstr ""
#. Tag: para
#: persistent_classes.xml:290
#, no-c-format
msgid "Entity representation modes can also be set on a per <literal>Session basis:"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:293
#, no-c-format
msgid ""
"Session dynamicSession = pojoSession.getSession(EntityMode.MAP);\n"
"\n"
"// Create a customer\n"
"Map david = new HashMap();\n"
"david.put(\"name\", \"David\");\n"
"dynamicSession.save(\"Customer\", david);\n"
"...\n"
"dynamicSession.flush();\n"
"dynamicSession.close()\n"
"...\n"
"// Continue on pojoSession"
msgstr ""
#. Tag: para
#: persistent_classes.xml:295
#, no-c-format
msgid "Please note that the call to <literal>getSession() using an EntityMode is on the Session API, not the SessionFactory. That way, the new Session shares the underlying JDBC connection, transaction, and other context information. This means you do not have to call flush() and close() on the secondary Session, and also leave the transaction and connection handling to the primary unit of work."
msgstr ""
#. Tag: para
#: persistent_classes.xml:304
#, no-c-format
msgid "More information about the XML representation capabilities can be found in <xref linkend=\"xml\"/>."
msgstr ""
#. Tag: title
#: persistent_classes.xml:310
#, no-c-format
msgid "Tuplizers"
msgstr ""
#. Tag: para
#: persistent_classes.xml:312
#, no-c-format
msgid "<interfacename>org.hibernate.tuple.Tuplizer and its sub-interfaces are responsible for managing a particular representation of a piece of data given that representation's org.hibernate.EntityMode. If a given piece of data is thought of as a data structure, then a tuplizer is the thing that knows how to create such a data structure, how to extract values from such a data structure and how to inject values into such a data structure. For example, for the POJO entity mode, the corresponding tuplizer knows how create the POJO through its constructor. It also knows how to access the POJO properties using the defined property accessors."
msgstr ""
#. Tag: para
#: persistent_classes.xml:322
#, no-c-format
msgid "There are two (high-level) types of Tuplizers:"
msgstr ""
#. Tag: para
#: persistent_classes.xml:326
#, no-c-format
msgid "<interfacename>org.hibernate.tuple.entity.EntityTuplizer which is responsible for managing the above mentioned contracts in regards to entities"
msgstr ""
#. Tag: para
#: persistent_classes.xml:332
#, no-c-format
msgid "<interfacename>org.hibernate.tuple.component.ComponentTuplizer which does the same for components"
msgstr ""
#. Tag: para
#: persistent_classes.xml:340
#, no-c-format
msgid "Users can also plug in their own tuplizers. Perhaps you require that <interfacename>java.util.Map implementation other than java.util.HashMap be used while in the dynamic-map entity-mode. Or perhaps you need to define a different proxy generation strategy than the one used by default. Both would be achieved by defining a custom tuplizer implementation. Tuplizer definitions are attached to the entity or component mapping they are meant to manage. Going back to the example of our Customer entity, shows how to specify a custom org.hibernate.tuple.entity.EntityTuplizer using annotations while shows how to do the same in hbm.xml"
msgstr ""
#. Tag: title
#: persistent_classes.xml:353
#, no-c-format
msgid "Specify custom tuplizers in annotations"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:354
#, no-c-format
msgid ""
"@Entity\n"
"@Tuplizer(impl = DynamicEntityTuplizer.class)\n"
"public interface Cuisine {\n"
" @Id\n"
" @GeneratedValue\n"
" public Long getId();\n"
" public void setId(Long id);\n"
"\n"
" public String getName();\n"
" public void setName(String name);\n"
"\n"
" @Tuplizer(impl = DynamicComponentTuplizer.class)\n"
" public Country getCountry();\n"
" public void setCountry(Country country);\n"
"}"
msgstr ""
#. Tag: title
#: persistent_classes.xml:357
#, no-c-format
msgid "Specify custom tuplizers in <literal>hbm.xml"
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:358
#, no-c-format
msgid ""
"<hibernate-mapping>\n"
" <class entity-name=\"Customer\">\n"
" <!--\n"
" Override the dynamic-map entity-mode\n"
" tuplizer for the customer entity\n"
" -->\n"
" <tuplizer entity-mode=\"dynamic-map\"\n"
" class=\"CustomMapTuplizerImpl\"/>\n"
"\n"
" <id name=\"id\" type=\"long\" column=\"ID\">\n"
" <generator class=\"sequence\"/>\n"
" </id>\n"
"\n"
" <!-- other properties -->\n"
" ...\n"
" </class>\n"
"</hibernate-mapping>"
msgstr ""
#. Tag: title
#: persistent_classes.xml:363
#, no-c-format
msgid "EntityNameResolvers"
msgstr ""
#. Tag: para
#: persistent_classes.xml:365
#, no-c-format
msgid "<interfacename>org.hibernate.EntityNameResolver is a contract for resolving the entity name of a given entity instance. The interface defines a single method resolveEntityName which is passed the entity instance and is expected to return the appropriate entity name (null is allowed and would indicate that the resolver does not know how to resolve the entity name of the given entity instance). Generally speaking, an org.hibernate.EntityNameResolver is going to be most useful in the case of dynamic models. One example might be using proxied interfaces as your domain model. The hibernate test suite has an example of this exact style of usage under the org.hibernate.test.dynamicentity.tuplizer2. Here is some of the code from that package for illustration."
msgstr ""
#. Tag: programlisting
#: persistent_classes.xml:377
#, no-c-format
msgid ""
"/**\n"
" * A very trivial JDK Proxy InvocationHandler implementation where we proxy an\n"
" * interface as the domain model and simply store persistent state in an internal\n"
" * Map. This is an extremely trivial example meant only for illustration.\n"
" */\n"
"public final class DataProxyHandler implements InvocationHandler {\n"
" private String entityName;\n"
" private HashMap data = new HashMap();\n"
"\n"
" public DataProxyHandler(String entityName, Serializable id) {\n"
" this.entityName = entityName;\n"
" data.put( \"Id\", id );\n"
" }\n"
"\n"
" public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {\n"
" String methodName = method.getName();\n"
" if ( methodName.startsWith( \"set\" ) ) {\n"
" String propertyName = methodName.substring( 3 );\n"
" data.put( propertyName, args[0] );\n"
" }\n"
" else if ( methodName.startsWith( \"get\" ) ) {\n"
" String propertyName = methodName.substring( 3 );\n"
" return data.get( propertyName );\n"
" }\n"
" else if ( \"toString\".equals( methodName ) ) {\n"
" return entityName + \"#\" + data.get( \"Id\" );\n"
" }\n"
" else if ( \"hashCode\".equals( methodName ) ) {\n"
" return new Integer( this.hashCode() );\n"
" }\n"
" return null;\n"
" }\n"
"\n"
" public String getEntityName() {\n"
" return entityName;\n"
" }\n"
"\n"
" public HashMap getData() {\n"
" return data;\n"
" }\n"
"}\n"
"\n"
"public class ProxyHelper {\n"
" public static String extractEntityName(Object object) {\n"
" // Our custom java.lang.reflect.Proxy instances actually bundle\n"
" // their appropriate entity name, so we simply extract it from there\n"
" // if this represents one of our proxies; otherwise, we return null\n"
" if ( Proxy.isProxyClass( object.getClass() ) ) {\n"
" InvocationHandler handler = Proxy.getInvocationHandler( object );\n"
" if ( DataProxyHandler.class.isAssignableFrom( handler.getClass() ) ) {\n"
" DataProxyHandler myHandler = ( DataProxyHandler ) handler;\n"
" return myHandler.getEntityName();\n"
" }\n"
" }\n"
" return null;\n"
" }\n"
"\n"
" // various other utility methods ....\n"
"\n"
"}\n"
"\n"
"/**\n"
" * The EntityNameResolver implementation.\n"
" *\n"
" * IMPL NOTE : An EntityNameResolver really defines a strategy for how entity names\n"
" * should be resolved. Since this particular impl can handle resolution for all of our\n"
" * entities we want to take advantage of the fact that SessionFactoryImpl keeps these\n"
" * in a Set so that we only ever have one instance registered. Why? Well, when it\n"
" * comes time to resolve an entity name, Hibernate must iterate over all the registered\n"
" * resolvers. So keeping that number down helps that process be as speedy as possible.\n"
" * Hence the equals and hashCode implementations as is\n"
" */\n"
"public class MyEntityNameResolver implements EntityNameResolver {\n"
" public static final MyEntityNameResolver INSTANCE = new MyEntityNameResolver();\n"
"\n"
" public String resolveEntityName(Object entity) {\n"
" return ProxyHelper.extractEntityName( entity );\n"
" }\n"
"\n"
" public boolean equals(Object obj) {\n"
" return getClass().equals( obj.getClass() );\n"
" }\n"
"\n"
" public int hashCode() {\n"
" return getClass().hashCode();\n"
" }\n"
"}\n"
"\n"
"public class MyEntityTuplizer extends PojoEntityTuplizer {\n"
" public MyEntityTuplizer(EntityMetamodel entityMetamodel, PersistentClass mappedEntity) {\n"
" super( entityMetamodel, mappedEntity );\n"
" }\n"
"\n"
" public EntityNameResolver[] getEntityNameResolvers() {\n"
" return new EntityNameResolver[] { MyEntityNameResolver.INSTANCE };\n"
" }\n"
"\n"
" public String determineConcreteSubclassEntityName(Object entityInstance, SessionFactoryImplementor factory) {\n"
" String entityName = ProxyHelper.extractEntityName( entityInstance );\n"
" if ( entityName == null ) {\n"
" entityName = super.determineConcreteSubclassEntityName( entityInstance, factory );\n"
" }\n"
" return entityName;\n"
" }\n"
"\n"
" ..."
msgstr ""
#. Tag: para
#: persistent_classes.xml:379
#, no-c-format
msgid "In order to register an <interfacename>org.hibernate.EntityNameResolver users must either:"
msgstr ""
#. Tag: para
#: persistent_classes.xml:383
#, no-c-format
msgid "Implement a custom tuplizer (see <xref linkend=\"persistent-classes-tuplizers\"/>), implementing the getEntityNameResolvers method"
msgstr ""
#. Tag: para
#: persistent_classes.xml:389
#, no-c-format
msgid "Register it with the <classname>org.hibernate.impl.SessionFactoryImpl (which is the implementation class for org.hibernate.SessionFactory) using the registerEntityNameResolver method."
msgstr ""
Other Hibernate examples (source code examples)
Here is a short list of links related to this Hibernate persistent_classes.pot source code file:
|
The search page
Other Hibernate source code examples at this package level
Click here to learn more about this project
