Hibernate example source code file (architecture.po)

This example Hibernate source code file (architecture.po) 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.

Java - Hibernate tags/keywords

a, api, hibernate, hibernate, it, jboss, jboss, jdbc, jmx, jmx, jta, tag, tag, the

The Hibernate architecture.po source code

# translation of Collection_Mapping.po to
# Xi Huang <xhuang@redhat.com>, 2006.
# Xi HUANG <xhuang@redhat.com>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-07-21 05:38+0000\n"
"PO-Revision-Date: 2010-03-15 08:47+1000\n"
"Last-Translator: Xi HUANG <xhuang@redhat.com>\n"
"Language-Team:  <en@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"

#. Tag: title
#: architecture.xml:34
#, no-c-format
msgid "Architecture"
msgstr "体系结构（Architecture）"

#. Tag: title
#: architecture.xml:37
#, no-c-format
msgid "Overview"
msgstr "概况（Overview）"

#. Tag: para
#: architecture.xml:39
#, no-c-format
msgid ""
"The diagram below provides a high-level view of the Hibernate architecture:"
msgstr "下面的图表提供了 Hibernate 体系结构的高层视图："

#. Tag: para
#: architecture.xml:52
#, no-c-format
msgid ""
"Unfortunately we cannot provide a detailed view of all possible runtime "
"architectures. Hibernate is sufficiently flexible to be used in a number of "
"ways in many, many architectures. We will, however, illustrate 2 "
"specifically since they are extremes."
msgstr ""

#. Tag: title
#: architecture.xml:59
#, fuzzy, no-c-format
msgid "Minimal architecture"
msgstr "体系结构（Architecture）"

#. Tag: para
#: architecture.xml:61
#, fuzzy, no-c-format
msgid ""
"The \"minimal\" architecture has the application manage its own JDBC "
"connections and provide those connections to Hibernate; additionally the "
"application manages transactions for itself. This approach uses a minimal "
"subset of Hibernate APIs."
msgstr ""
"“最小”的体系结构方案，要求应用程序提供自己的 JDBC 连接并管理自己的事务。这种"
"方案使用了Hibernate API 的最小子集："

#. Tag: title
#: architecture.xml:77
#, no-c-format
msgid "Comprehensive architecture"
msgstr ""

#. Tag: para
#: architecture.xml:79
#, no-c-format
msgid ""
"The \"comprehensive\" architecture abstracts the application away from the "
"underlying JDBC/JTA APIs and allows Hibernate to manage the details."
msgstr ""
"“全面解决”的体系结构方案，将应用层从底层的 JDBC/JTA API 中抽象出来，而让 "
"Hibernate 来处理这些细节。"

#. Tag: title
#: architecture.xml:94
#, no-c-format
msgid "Basic APIs"
msgstr ""

#. Tag: para
#: architecture.xml:95
#, no-c-format
msgid ""
"Here are quick discussions about some of the API objects depicted in the "
"preceding diagrams (you will see them again in more detail in later "
"chapters)."
msgstr ""

#. Tag: term
#: architecture.xml:100
#, fuzzy, no-c-format
msgid ""
"SessionFactory (<interfacename>org.hibernate.SessionFactory)"
msgstr "SessionFactory (<literal>org.hibernate.SessionFactory)"

#. Tag: para
#: architecture.xml:102
#, fuzzy, no-c-format
msgid ""
"A thread-safe, immutable cache of compiled mappings for a single database. A "
"factory for <interfacename>org.hibernate.Session instances. "
"A client of <interfacename>org.hibernate.connection.ConnectionProvidersecond level cache "
"of data that is reusable between transactions at a process or cluster level."
msgstr ""
"针对单个数据库映射关系经过编译后的内存镜像，是线程安全的（不可变）。 作为 "
"<literal>Session 的工厂和 ConnectionProvider 的"
"客户。<literal>SessionFactory 可以在进程或集群的级别上，为那些事务"
"之间可以重用的数据提供可选的二级缓存。"

#. Tag: term
#: architecture.xml:112
#, fuzzy, no-c-format
msgid "Session (<interfacename>org.hibernate.Session)"
msgstr "Session (<literal>org.hibernate.Session)"

#. Tag: para
#: architecture.xml:114
#, fuzzy, no-c-format
msgid ""
"A single-threaded, short-lived object representing a conversation between "
"the application and the persistent store. Wraps a JDBC <interfacename>java."
"sql.Connection</interfacename>. Factory for org.hibernate."
"Transaction</interfacename>. Maintains a first level cache 的工厂。它会持有一个针对"
"持久化对象的必选（第一级）缓存，在遍历对象图或者根据持久化标识查找对象时会用"
"到。"

#. Tag: term
#: architecture.xml:126
#, no-c-format
msgid "Persistent objects and collections"
msgstr "持久的对象及其集合"

#. Tag: para
#: architecture.xml:128
#, fuzzy, no-c-format
msgid ""
"Short-lived, single threaded objects containing persistent state and "
"business function. These can be ordinary JavaBeans/POJOs. They are "
"associated with exactly one <interfacename>org.hibernate.Sessionorg.hibernate.SessionSession 被关闭，这些对象就会脱离"
"持久化状态，这样就可被应用程序的任何层自由使用（例如，用作跟表示层打交道的数"
"据传输对象）。"

#. Tag: term
#: architecture.xml:140
#, no-c-format
msgid "Transient and detached objects and collections"
msgstr "瞬态（transient）和脱管（detached）的对象及其集合"

#. Tag: para
#: architecture.xml:142
#, fuzzy, no-c-format
msgid ""
"Instances of persistent classes that are not currently associated with a "
"<interfacename>org.hibernate.Session. They may have been "
"instantiated by the application and not yet persisted, or they may have been "
"instantiated by a closed <interfacename>org.hibernate.Session discusses transient, "
"persistent and detached object states."
msgstr ""
"那些目前没有与 <literal>Session关联的持久化类实例。他们可能是在被应"
"用程序实例化后，尚未进行持久化的对象。也可能是因为实例化他们的 "
"<literal>Session 已经被关闭而脱离持久化的对象。"

#. Tag: term
#: architecture.xml:152
#, fuzzy, no-c-format
msgid "Transaction (<interfacename>org.hibernate.Transaction)"
msgstr "事务 Transaction (<literal>org.hibernate.Transaction)"

#. Tag: para
#: architecture.xml:154
#, fuzzy, no-c-format
msgid ""
"(Optional) A single-threaded, short-lived object used by the application to "
"specify atomic units of work. It abstracts the application from the "
"underlying JDBC, JTA or CORBA transaction. A <interfacename>org.hibernate."
"Session</interfacename> might span several org.hibernate."
"Transaction</interfacename>s in some cases. However, transaction "
"demarcation, either using the underlying API or <interfacename>org.hibernate."
"Transaction</interfacename>, is never optional."
msgstr ""
"（可选的）应用程序用来指定原子操作单元范围的对象，它是单线程的，生命周期很"
"短。它通过抽象将应用从底层具体的 JDBC、JTA 以及 CORBA 事务隔离开。某些情况"
"下，一个 <literal>Session 之内可能包含多个 Transaction 对象，事务边界的开启与关闭是必需的。 "

#. Tag: term
#: architecture.xml:165
#, fuzzy, no-c-format
msgid ""
"ConnectionProvider (<interfacename>org.hibernate.connection."
"ConnectionProvider</interfacename>)"
msgstr ""
"ConnectionProvider (<literal>org.hibernate.connection.ConnectionProviderjava.sql.DriverManager. It "
"is not exposed to application, but it can be extended and/or implemented by "
"the developer."
msgstr ""
"（可选的）生成 JDBC 连接的工厂（同时也起到连接池的作用）。它通过抽象将应用从"
"底层的 <literal>Datasource 或 DriverManager 隔离"
"开。仅供开发者扩展/实现用，并不开放给应用程序使用。"

#. Tag: term
#: architecture.xml:176
#, fuzzy, no-c-format
msgid ""
"TransactionFactory (<interfacename>org.hibernate.TransactionFactory)"

#. Tag: para
#: architecture.xml:178
#, fuzzy, no-c-format
msgid ""
"(Optional) A factory for <interfacename>org.hibernate.Transaction 对象实例的工厂。仅供开发者扩展/"
"实现用，并不开发能够给应用程序使用。"

#. Tag: emphasis
#: architecture.xml:186
#, fuzzy, no-c-format
msgid "Extension Interfaces"
msgstr "<emphasis>扩展接口 "

#. Tag: para
#: architecture.xml:188
#, no-c-format
msgid ""
"Hibernate offers a range of optional extension interfaces you can implement "
"to customize the behavior of your persistence layer. See the API "
"documentation for details."
msgstr ""
"Hibernate 提供了很多可选的扩展接口，你可以通过实现它们来定制你的持久层的行"
"为。具体请参考 API 文档。"

#. Tag: title
#: architecture.xml:200
#, no-c-format
msgid "JMX Integration"
msgstr "JMX 整合"

#. Tag: para
#: architecture.xml:202
#, no-c-format
msgid ""
"JMX is the J2EE standard for the management of Java components. Hibernate "
"can be managed via a JMX standard service. AN MBean implementation is "
"provided in the distribution: <literal>org.hibernate.jmx.HibernateService-based contextual "
"sessions, helper classes such as <literal>HibernateUtil, or "
"utilized third-party frameworks, such as Spring or Pico, which provided "
"proxy/interception-based contextual sessions."
msgstr ""
"使用 Hibernate 的大多数应用程序需要某种形式的“上下文相关的”会话，特定的会话在"
"整个特定的上下文范围内始终有效。然而，对不同类型的应用程序而言，要为什么是组"
"成这种“上下文”下一个定义通常是困难的；不同的上下文对“当前”这个概念定义了不同"
"的范围。在 3.0 版本之前，使用 Hibernate 的程序要么采用自行编写的基于 "
"<literal>ThreadLocal 的上下文会话，要么采用 "
"<literal>HibernateUtil 这样的辅助类，要么采用第三方框架（比如 "
"Spring 或 Pico），它们提供了基于代理（proxy）或者基于拦截器（interception）的"
"上下文相关的会话。"

#. Tag: para
#: architecture.xml:225
#, no-c-format
msgid ""
"Starting with version 3.0.1, Hibernate added the <literal>SessionFactory."
"getCurrentSession()</literal> method. Initially, this assumed usage of "
"<literal>JTA transactions, where the JTA "
"transaction defined both the scope and context of a current session. Given "
"the maturity of the numerous stand-alone <literal>JTA TransactionManager transaction management, whether or not they are "
"deployed into a <literal>J2EE container. Based on that, the "
"<literal>JTA-based contextual sessions are all you need to use."
msgstr ""
"从 3.0.1 版本开始，Hibernate 增加了 <literal>SessionFactory.getCurrentSession"
"()</literal> 方法。一开始，它假定了采用 JTA 事务，"
"<literal>JTA 事务定义了当前 session 的范围和上下文（scope 和 "
"context）。因为有好几个独立的 <literal>JTA TransactionManager 实现"
"稳定可用，不论是否被部署到一个 <literal>J2EE 容器中，大多数（假若不"
"是所有的）应用程序都应该采用 <literal>JTA 事务管理。基于这一点，采"
"用 <literal>JTA 的上下文相关的会话可以满足你一切需要。"

#. Tag: para
#: architecture.xml:235
#, no-c-format
msgid ""
"However, as of version 3.1, the processing behind <literal>SessionFactory."
"getCurrentSession()</literal> is now pluggable. To that end, a new extension "
"interface, <literal>org.hibernate.context.CurrentSessionContext, "
"and a new configuration parameter, <literal>hibernate."
"current_session_context_class</literal>, have been added to allow "
"pluggability of the scope and context of defining current sessions."
msgstr ""
"更好的是，从 3.1 开始，<literal>SessionFactory.getCurrentSession() "
"的后台实现是可拔插的。因此，我们引入了新的扩展接口（<literal>org.hibernate."
"context.CurrentSessionContext</literal>）和新的配置参数（hibernate."
"current_session_context_class</literal>），以便对什么是当前会话的范围"
"（scope）和上下文（context）的定义进行拔插。"

#. Tag: para
#: architecture.xml:242
#, no-c-format
msgid ""
"See the Javadocs for the <literal>org.hibernate.context."
"CurrentSessionContext</literal> interface for a detailed discussion of its "
"contract. It defines a single method, <literal>currentSession(), "
"by which the implementation is responsible for tracking the current "
"contextual session. Out-of-the-box, Hibernate comes with three "
"implementations of this interface:"
msgstr ""
"请参阅 <literal>org.hibernate.context.CurrentSessionContext 接口的 "
"Javadoc，那里有关于它的契约的详细讨论。它定义了单一的方法，"
"<literal>currentSession()，特定的实现用它来负责跟踪当前的上下文相关"
"的会话。Hibernate 内置了此接口的三种实现："

#. Tag: para
#: architecture.xml:252
#, no-c-format
msgid ""
"<literal>org.hibernate.context.JTASessionContext: current sessions "
"are tracked and scoped by a <literal>JTA transaction. The "
"processing here is exactly the same as in the older JTA-only approach. See "
"the Javadocs for details."
msgstr ""
"<literal>org.hibernate.context.JTASessionContext：当前会话根据 "
"<literal>JTA 来跟踪和界定。这和以前的仅支持 JTA 的方法是完全一样"
"的。详情请参阅 Javadoc。"

#. Tag: para
#: architecture.xml:260
#, no-c-format
msgid ""
"<literal>org.hibernate.context.ThreadLocalSessionContext:current "
"sessions are tracked by thread of execution. See the Javadocs for details."
msgstr ""
"<literal>org.hibernate.context.ThreadLocalSessionContext：当前会话"
"通过当前执行的线程来跟踪和界定。详情也请参阅 Javadoc。"

#. Tag: para
#: architecture.xml:266
#, no-c-format
msgid ""
"<literal>org.hibernate.context.ManagedSessionContext: current "
"sessions are tracked by thread of execution. However, you are responsible to "
"bind and unbind a <literal>Session instance with static methods on "
"this class: it does not open, flush, or close a <literal>Session."
msgstr ""
"<literal>org.hibernate.context.ManagedSessionContext：当前会话通过"
"当前执行的线程来跟踪和界定。但是，你需要负责使用这个类的静态方法将 "
"<literal>Session 实例绑定、或者取消绑定，它并不会打开（open）、"
"flush 或者关闭（close）任何 <literal>Session。"

#. Tag: para
#: architecture.xml:275
#, fuzzy, no-c-format
msgid ""
"The first two implementations provide a \"one session - one database "
"transaction\" programming model. This is also known and used as "
"<emphasis>session-per-request. The beginning and end of a "
"Hibernate session is defined by the duration of a database transaction. If "
"you use programmatic transaction demarcation in plain JSE without JTA, you "
"are advised to use the Hibernate <literal>Transaction API to hide "
"the underlying transaction system from your code. If you use JTA, you can "
"utilize the JTA interfaces to demarcate transactions. If you execute in an "
"EJB container that supports CMT, transaction boundaries are defined "
"declaratively and you do not need any transaction or session demarcation "
"operations in your code. Refer to <xref linkend=\"transactions\"/> for more "
"information and code examples."
msgstr ""
"前两种实现都提供了“one session - one database transaction”的编程模型，也称作 "
"<emphasis>session-per-request。Hibernate session 的起始和终结由数"
"据库事务的生存来控制。假若你在纯粹的 Java SE 之上采用自行编写代码来管理事务，"
"而不使用 JTA，建议你使用 Hibernate <literal>Transaction API 来把底"
"层事务实现从你的代码中隐藏掉。如果你使用 JTA，请使用 JTA 接口来对事务限界。如"
"果你在支持 CMT 的 EJB 容器中执行代码，事务边界是声明式定义的，你不需要在代码"
"中进行任何事务或会话管理操作。请参阅 <xref linkend=\"transactions\"/> 一节来"
"阅读更多的内容和示例代码。 "

#. Tag: para
#: architecture.xml:287
#, no-c-format
msgid ""
"The <literal>hibernate.current_session_context_class configuration "
"parameter defines which <literal>org.hibernate.context."
"CurrentSessionContext</literal> implementation should be used. For backwards "
"compatibility, if this configuration parameter is not set but a <literal>org."
"hibernate.transaction.TransactionManagerLookup</literal> is configured, "
"Hibernate will use the <literal>org.hibernate.context.JTASessionContext 配置参数定义了应该"
"采用哪个 <literal>org.hibernate.context.CurrentSessionContext 实"
"现。注意，为了向下兼容，如果未配置此参数，但是存在 <literal>org.hibernate."
"transaction.TransactionManagerLookup</literal> 的配置，Hibernate 会采用"
"<literal>org.hibernate.context.JTASessionContext。一般而言，此参数"
"的值指明了要使用的实现类的全名，但那三种内置的实现可以使用简写，即 \"jta\"、"
"\"thread\" 和 \"managed\"。 "

#~ msgid "Instance states"
#~ msgstr "实例状态"

#~ msgid ""
#~ "An instance of a persistent class can be in one of three different "
#~ "states. These states are defined in relation to a <emphasis>persistence "
#~ "context</emphasis>. The Hibernate Session object is "
#~ "the persistence context. The three different states are as follows:"
#~ msgstr ""
#~ "一个持久化类的实例可能处于三种不同状态中的某一种。这三种状态的定义则与所谓"
#~ "的<emphasis>持久化上下文（persistence context）有关。Hibernate "
#~ "的 <literal>Session 对象就是这个所谓的持久化上下文。这三种不同的"
#~ "状态如下："

#~ msgid "transient"
#~ msgstr "瞬态（transient）"

#~ msgid ""
#~ "The instance is not associated with any persistence context. It has no "
#~ "persistent identity or primary key value."
#~ msgstr ""
#~ "该实例从未与任何持久化上下文关联过。它没有持久化标识（相当于主键值）。 "

#~ msgid "persistent"
#~ msgstr "持久化（persistent）"

#~ msgid ""
#~ "The instance is currently associated with a persistence context. It has a "
#~ "persistent identity (primary key value) and can have a corresponding row "
#~ "in the database. For a particular persistence context, Hibernate "
#~ "<emphasis>guarantees that persistent identity is equivalent to "
#~ "Java identity in relation to the in-memory location of the object."
#~ msgstr ""
#~ "实例目前与某个持久化上下文有关联。它拥有持久化标识（相当于主键值），并且可"
#~ "能在数据库中有一个对应的行。对于某一个特定的持久化上下文，Hibernate "
#~ "<emphasis>保证 持久化标识与 Java 标识（其值代表对象在内存中的位"
#~ "置）等价。　"

#~ msgid "detached"
#~ msgstr "脱管（detached）"

#~ msgid ""
#~ "The instance was once associated with a persistence context, but that "
#~ "context was closed, or the instance was serialized to another process. It "
#~ "has a persistent identity and can have a corresponding row in the "
#~ "database. For detached instances, Hibernate does not guarantee the "
#~ "relationship between persistent identity and Java identity."
#~ msgstr ""
#~ "实例曾经与某个持久化上下文发生过关联，不过那个上下文被关闭了，或者这个实例"
#~ "是被序列化（serialize）到另外的进程。它拥有持久化标识，并且在数据库中可能"
#~ "存在一个对应的行。对于脱管状态的实例，Hibernate 不保证任何持久化标识和 "
#~ "Java 标识的关系。 "

#~ msgid ""
#~ "We do not have the scope in this document to provide a more detailed view "
#~ "of all the runtime architectures available; Hibernate is flexible and "
#~ "supports several different approaches. We will, however, show the two "
#~ "extremes: \"minimal\" architecture and \"comprehensive\" architecture."
#~ msgstr ""
#~ "提供 Hibernate 所有运行时体系结构的更多细节不是本文档的范畴。由于 "
#~ "Hibernate 非常灵活，且支持多种应用方案， 所以我们这只描述一下两种极端的情"
#~ "况：“最小”和“全面解决”的体系结构方案。"

#~ msgid ""
#~ "This next diagram illustrates how Hibernate utilizes database and "
#~ "configuration data to provide persistence services, and persistent "
#~ "objects, to the application."
#~ msgstr ""
#~ "下图演示了 Hibernate 如何使用数据库和配置信息来为应用程序提供持久化服务"
#~ "（以及持久的对象）。"

#~ msgid "Here are some definitions of the objects depicted in the diagrams:"
#~ msgstr "图中各个对象的定义如下： "

#~ msgid ""
#~ "Given a \"minimal\" architecture, the application bypasses the "
#~ "<literal>Transaction/TransactionFactory and/"
#~ "or <literal>ConnectionProvider APIs to communicate with JTA or "
#~ "JDBC directly."
#~ msgstr ""
#~ "在特定“最小”的体系结构中，应用程序可能绕过  <literal>TransactionTransactionFactory 以及 "
#~ "<literal>ConnectionProvider 等 API 直接跟 JTA 或 JDBC 打交道。"

#~ msgid ""
#~ "For an example of how to deploy Hibernate as a JMX service on the JBoss "
#~ "Application Server, please see the JBoss User Guide. JBoss AS also "
#~ "provides these benefits if you deploy using JMX:"
#~ msgstr ""
#~ "想要看如何在 JBoss 应用服务器上将 Hibernate 部署为一个 JMX 服务的例子，您"
#~ "可以参考《JBoss 用户指南》。如果你使用 JMX 来部署 Hibernate，JBoss AS 也提"
#~ "供如下好处："

#~ msgid ""
#~ "<emphasis>Session Management: the Hibernate Session; this becomes the job of a JBoss EJB "
#~ "interceptor. You also do not have to worry about transaction demarcation "
#~ "in your code (if you would like to write a portable persistence layer use "
#~ "the optional Hibernate <literal>Transaction API for this). You "
#~ "call the <literal>HibernateContext to access a "
#~ "<literal>Session."
#~ msgstr ""
#~ "<emphasis>会话管理： Hibernate 的 Session 对"
#~ "象的生命周期可以 自动跟一个 JTA 事务边界绑定。这意味着你无需手工开关 "
#~ "<literal>Session 了, 这项工作会由 JBoss EJB 拦截器来完成。你再也"
#~ "不用担心你的代码中的事务边界了（除非你想利用 Hibernate 提供可选的 "
#~ "<literal>Transaction API 来自己写一个便于移植的的持久层）。你通"
#~ "过调用 <literal>HibernateContext 来访问 Session: the Hibernate JMX service is "
#~ "deployed using a JBoss service deployment descriptor in an EAR and/or SAR "
#~ "file, as it supports all the usual configuration options of a Hibernate "
#~ "<literal>SessionFactory. However, you still need to name all "
#~ "your mapping files in the deployment descriptor. If you use the optional "
#~ "HAR deployment, JBoss will automatically detect all mapping files in your "
#~ "HAR file."
#~ msgstr ""
#~ "<emphasis>HAR 部署: 通常情况下，你会使用 JBoss 的服务部署描述符"
#~ "（在 EAR 或/和 SAR 文件中）来部署 Hibernate JMX 服务。这种部署方式支持所有"
#~ "常见的 Hibernate <literal>SessionFactory 的配置选项。不过，你仍"
#~ "需在部署描述符中，列出你所有的映射文的名字。如果你使用 HAR 部署方式, "
#~ "JBoss 会自动探测出你的 HAR 文件中所有的映射文件。"

#~ msgid ""
#~ "Consult the JBoss AS user guide for more information about these options."
#~ msgstr "这些选项更多的描述，请参考 JBoss 应用程序用户指南。"

#~ msgid "JCA Support"
#~ msgstr "对 JCA 的支持"

#~ msgid ""
#~ "Hibernate can also be configured as a JCA connector. Please see the "
#~ "website for more information. Please note, however, that at this stage "
#~ "Hibernate JCA support is under development."
#~ msgstr ""
#~ "Hibernate 也可以被配置为一个 JCA 连接器（JCA connector）。更多信息请参看网"
#~ "站。请注意，Hibernate 对 JCA 的支持，仍处于实验性阶段。"