Hibernate实战(第二版)笔记----第二章--开启一个项目

女爷i 2022-06-13 08:54 205阅读 0赞

最近在看Hibernate实战(第二版)这本书,个人感觉翻译的不是很好，有些地方读都读不通。。。

![20170703152212071][]

随便做下笔记,书中提供下载源码的地址为: [ http://jpwh.org][http_jpwh.org]

![20170703152410661][]

下载下来之后，目录如下

![20170703151916098][]

其中:

apps----第18/19章对应的客服端与服务端程序

environment----一些通用的环境

examples----一些实例

model---一些实体类

shared---共享的一些帮助类什么的

README.txt说明文件如下:

==============================================================================
    Java Persistence with Hibernate - Second Edition
    
    http://www.manning.com/bauer3/
    
    ==============================================================================
    
    
    入门
    ------------------------------------------------------------------------------
    
    - Install JDK 7.
    
    - Install Maven 3.x.
    
    - 运行'mvn clean test'来执行所有的例子（这将需要一段时间
      依赖关系必须首次下载）。
    
    - 打开报告 examples/target/surefire-reports/index.html
    
    - 详细了解每个子目录的pom.xml文件中的模块并进行浏览
      源代码。
    
    - 获取更多的日志输出, 编辑 shared/src/main/resources/logging.properties
      并运行测试。 所有日志输出都将写入文件
      examples/target/surefire-reports/TestSuite-output.txt
    
    - 要仅运行单个测试，请先将模块安装到您的本地Maven中
      存储库使用'mvn clean install'。 然后运行测试：
    
          mvn -pl examples -Dtest=org.jpwh.test.simple.CRUD clean test
    
    - 如果只运行单个测试，则控制台日志输出将被写入
      在以前的情况下，一个不同的文件：
    
      examples/target/surefire-reports/org.jpwh.test.simple.CRUD-output.txt
    
    
    运行示例APPS
    ------------------------------------------------------------------------------
    
    - 安装Wildfly 8.2.0.Final
    
    - 在后台使用 $WILDFLY/bin/standalone.sh运行应用程序服务器
    
    - 运行 "Stateless Client/Server" 示例应用程序:
    
        mvn -P app-stateless-server clean install
        mvn -P app-stateless-server clean package wildfly:deploy
        mvn -P app-stateless-client clean test
        mvn -P app-stateless-server clean package wildfly:undeploy
    
    - Run the "Stateful Client/Server" example app:
    
        mvn -P app-stateful-server clean install
        mvn -P app-stateful-server clean package wildfly:deploy
        mvn -P app-stateful-client clean test
        mvn -P app-stateful-server clean package wildfly:undeploy
    
    - Run the "CaveatEmptor Web Application" example:
    
        mvn -P app-web clean package wildfly:deploy
        Open in browser: http://localhost:8080/app-web/
        mvn -P app-web wildfly:undeploy
    
    
    运行/浏览外部数据库
    ------------------------------------------------------------------------------
    
    - 默认情况下，使用内存中H2数据库实例进行测试。 你不能
       使用SQL控制台访问和浏览此数据库。 如果你只想看看
       模式/SQL，如上所述编辑logging.properties。
    
    - 您可以切换到外部已经运行的H2数据库。 首先启动
       数据库通过双击H2.jar文件。 它应该在你的Maven
       存储库（~/.m2/repository/com/h2database/）或者你可以从它下载
       http://h2database.com。 H2网页控制台将打开，你可以简单的
       用户'sa'连接到数据库实例，没有密码。
    
    - 将示例模块安装到本地存储库中:
    
        mvn clean install
    
    - 运行单个测试方法，并在完成后保留模式/数据：
    
        mvn -pl examples \
         -Dtest=org.jpwh.test.simple.CRUD#storeAndQueryItems \
         -DconnectionURL=jdbc:h2:tcp://localhost/mem:test \
         -DkeepSchema=true \
         clean test
    
    - 在H2控制台中执行测试方法后浏览数据库。
    
    - 您可以再次执行相同的测试方法，数据库将被清理
       在方法运行之前。 您可以执行相同测试的其他方法
       类，每个测试类使用相同的数据库模式。
    
    - 要执行另一个具有不同模式的测试类的方法，请停止
    	在切换测试类时启动H2数据库。请注意,H2
    	删除最后一个连接时的内存数据库。如果
    	在H2 web控制台断开连接，数据库将被删除。
    
    
    ------------------------------------------------------------------------------
    
    Visit us on the Manning author forum:
        http://www.manning-sandbox.com/forum.jspa?forumID=844

打开Eclipse选择Import

![20170703153131826][]

选择一个存在的Maven项目

![20170703153232918][]

然后点击Finish，完成导入，导入成功之后如下:

![20170703153337529][]

导入之后，会报很多错:

比如说这几个类CreditCard\_、 Item\_ 、Bid\_提示找不到，我找了半天在书中对应的论坛找到了一种说法:[https://forums.manning.com/posts/list/35484.page][https_forums.manning.com_posts_list_35484.page]

![20170703153709328][]

暂时把那些报错的地方全部注释掉。然后对照着书中的第二章的开启一个项目,运行测试,发现测试用的TestNG框架,然后把TestNG插件装上

**(一)、使用JPA的"Hello Word"**

它这里使用了持久化单元,什么是持久化单元,网上的解释是,一个持久化单元（Persistence Unit）就是关于一组Entity类的命名配置。持久化单元是一个静态的概念,持久性单元具有唯一的名称，负责定义应用中的一组实体如何进行管理和持久性。在应用中使用persistence.xml文件来设置持久性单元，可以配置多个持久性单元，但每个单元拥有唯一的名称。  
  
持久性单元包含的属性有：

1.在该持久性单元范围（作用域）内的实体类  
2.为上述实体类提供持久性的持久性提供者(Persistence Provider)或库  
3.上述实体类的数据源(Data Source)  
4.应用使用的事务类型(Transaction Type)  
5.持久性单元能够被打包成WAR文件，EJB-JAR文件,EAR文件的一部分，或者直接打包成应用程序能够直接使用的JAR文件。  
  
持久性单元的范围（作用域）取决于persistence.xml文件的位置。一般说来，IDE能够使用引导界面来正确放置persistence.xml的位置。例如使用IDE为EJB模块（Module）创建的持久性单元，persistence.xml文件将被放在EJB模块的src/conf目录中，当你将模块打包时，persistence.xml文件被放在EJB JAR文件的META-INF目录中。这样持久性单元的作用域就是EJB JAR文件中的类。  
  
注意：persistence.xml文件的位置决定持久性的根(Persistence Root)。持久性的根为JAR文件或者包含META-INF目录（前提是persistence.xml位于此）的目录。

JPA规范要求在类路径的META-INF目录下放置persistence.xml, 文件的名称是固定的，配置模板如下：

<?xml version="1.0" encoding="UTF-8"?>
 <persistence version="2.1"
  xmlns="<a target=_blank href="http://xmlns.jcp.org/xml/ns/persistence">http://xmlns.jcp.org/xml/ns/persistence</a>" xmlns:xsi="<a target=_blank href="http://www.w3.org/2001/XMLSchema-instance">http://www.w3.org/2001/XMLSchema-instance</a>"
  xsi:schemaLocation="<a target=_blank href="http://xmlns.jcp.org/xml/ns/persistence">http://xmlns.jcp.org/xml/ns/persistence</a>
  <a target=_blank href="http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd</a>">
 
 	<persistence-unit name="persist-unit" transaction-type="RESOURCE_LOCAL">
 	
 	  <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
 	  
 	  <class>boa.framework.entity.CustomerEntity</class>   <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
 	   <validation-mode>CALLBACK</validation-mode> 
 	  <properties>
 	   
 	   <property name="javax.persistence.jdbc.url" value="jdbc:derby:memory:exampleDB;create=true" />
 	   <property name="javax.persistence.jdbc.driver" value="org.apache.derby.jdbc.EmbeddedDriver" />
 	   <property name="javax.persistence.jdbc.user" value="" />
 	   <property name="javax.persistence.jdbc.password" value="" />
 	   <property name="javax.persistence.schema-generation.database.action"
 	    value="drop-and-create" />
 	   <property name="javax.persistence.schema-generation.create-source"
 	    value="script" />
 	   <property name="javax.persistence.schema-generation.create-script-source"
 	    value="META-INF/create-script.sql" />
 	   <property name="eclipseink.logging.level" value="INFO" />
 	  </properties>
 	 </persistence-unit>
 
 
 	 
 	<persistence-unit name="unitName" transaction-type="JTA"> 
 
  
 <description> </description> 
 
  
 <provider> </provider> 
 
  
 <jta-data-source>java:/test</jta-data-source> 
 <non-jta-data-source> </non-jta-data-source> 
 
  
 <mapping-file>product.xml</mapping-file> 
 
  
 <jar-file>../lib/model.jar</jar-file> 
 
  
 <class>boa.framework.entity.CustomerEntity</class>
 
  
 <exclude-unlisted-classes>true</exclude-unlisted-classes>　
 　　　shared-cache-mode
 　　缓存模式。加了@Cacheable注解的默认为二级缓存。有四种模式：ALL-缓存所有实体；NONE-禁止缓存；ENABLE_SELECTIVE-如果加了缓存的标识，是默认的选选　　　　　　　　项；DISABLE_SELECTIVE- enable caching unless explicitly marked as  @Cacheable(false) (not  recommended)
 　　validation-mode
 　　实体的验证模式，默认是激活的。当一个实体在创建、更新，在实体发送到数据库前会被进行验证。CALLBACK: entities are validated on creation, update and deletion. If no Bean Validation provider  is present, an exception is raised at initialization time.  
 <properties> 
  
   <property name="eclipseink.logging.level" value="INFO" /> 
 </properties> 
 
 	</persistence-unit> 
 
 </persistence>

本示例中的persistence.xml内容为:

<persistence
 version="2.1"
 xmlns="http://xmlns.jcp.org/xml/ns/persistence"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
 http://xmlns.jcp.org/xml/ns/persistence_2_1.xsd">
 
 
 <persistence-unit name="HelloWorldPU">
 
 
 <jta-data-source>myDS</jta-data-source>
 
 
 <class>org.jpwh.model.helloworld.Message</class>
 
 
 <exclude-unlisted-classes>true</exclude-unlisted-classes>
 
 
 <properties>
 
 
 <property
 name="javax.persistence.schema-generation.database.action"
 value="drop-and-create"/>
 
 
 <property name="hibernate.format_sql" value="true"/>
 <property name="hibernate.use_sql_comments" value="true"/>
 
 
 <property name="hibernate.archive.autodetection" value="none"/>
 
 </properties>
 </persistence-unit>
 
 
 </persistence>

里面有很多,这里删除了一些。

找到examples中的HelloWorldJPA

package org.jpwh.helloworld;
 
 import org.jpwh.env.TransactionManagerTest;
 import org.jpwh.model.helloworld.Message;
 import org.testng.annotations.Test;
 
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
 import javax.persistence.Persistence;
 import javax.transaction.UserTransaction;
 import java.util.List;
 
 import static org.testng.Assert.assertEquals;
 
 public class HelloWorldJPA extends TransactionManagerTest {
 
 @Test
 public void storeLoadMessage() throws Exception {
 
 EntityManagerFactory emf =
 Persistence.createEntityManagerFactory("HelloWorldPU");
 
 try {
 	
 	
 	
 	//初始化代码块
 {
 /* 
 					访问标准事务API <code>UserTransaction</code>和
 					在执行的线程上启动事务。
 */
 UserTransaction tx = TM.getUserTransaction();
 tx.begin();
 
 /* 
 					通过创建一个<code>EntityManager</code>来开始一个新的会话
 					是所有持久性操作的上下文。
 */
 EntityManager em = emf.createEntityManager();
 
 /* 
 Create a new instance of the mapped domain model class <code>Message</code> and
 set its <code>text</code> property.
 */
 Message message = new Message();
 message.setText("Hello World!");
 
 /* 
 					 使用持久性上下文来列举瞬态实例，使其持续存在。
                      Hibernate现在知道你想存储的数据，它不一定调用
                      数据库，但是。
 */
 em.persist(message);
 
 /* 
 						提交事务，Hibernate现在自动检查持久化上下文
 						执行必要的SQL <code>INSERT</code>语句。
 */
 tx.commit();
 // INSERT into MESSAGE (ID, TEXT) values (1, 'Hello World!')
 
 /* 
 If you create an <code>EntityManager</code>, you must close it.
 */
 em.close();
 }
 
 {
 /* 
 					每个与数据库的交互都应该在显式事务边界内发生，
 					即使你只是在阅读数据。
 */
 UserTransaction tx = TM.getUserTransaction();
 tx.begin();
 
 EntityManager em = emf.createEntityManager();
 
 /* 
 					执行一个查询，以从数据库检索<code>Message</code>的所有实例。
 */
 List<Message> messages =
 em.createQuery("select m from Message m").getResultList();
 // SELECT * from MESSAGE
 
 
 assertEquals(messages.size(), 1);
 assertEquals(messages.get(0).getText(), "Hello World!");
 
 
 /* 
 					您可以更改属性的值，Hibernate会自动检测到这一点，因为
 					加载的<code>Message</code>仍然依附于它所加载的持久化上下文。
 */
 messages.get(0).setText("Take me to your leader!");
 
 /* 
 On commit, Hibernate checks the persistence context for dirty state and executes the
 SQL <code>UPDATE</code> automatically to synchronize the in-memory with the database state.
 */
 tx.commit();
 // UPDATE MESSAGE set TEXT = 'Take me to your leader!' where ID = 1
 
 em.close();
 }
 
 } finally {
 TM.rollback();
 emf.close();
 }
 }
 
 }

项目右键Run AS---> TestNG运行

![20170703154330553][]

输出如下:

PASSED: storeLoadMessage
    
    ===============================================
        Default test
        Tests run: 1, Failures: 0, Skips: 0
    ===============================================
    
    七月 03, 2017 3:44:03 下午 bitronix.tm.BitronixTransactionManager shutdown
    信息: shutting down Bitronix Transaction Manager
    
    ===============================================
    Default suite
    Total tests run: 1, Failures: 0, Skips: 0
    ===============================================
    
    [TestNG] Time taken by org.testng.reporters.jq.Main@5fdef03a: 25 ms
    [TestNG] Time taken by [FailedReporter passed=0 failed=0 skipped=0]: 1 ms
    [TestNG] Time taken by org.testng.reporters.XMLReporter@77556fd: 4 ms
    [TestNG] Time taken by org.testng.reporters.JUnitReportReporter@14899482: 4 ms
    [TestNG] Time taken by org.testng.reporters.SuiteHTMLReporter@16b3fc9e: 26 ms
    [TestNG] Time taken by org.testng.reporters.EmailableReporter2@ed17bee: 4 ms

接下来分析下他的源码,HelloWorldJPA继承TransactionManagerTest

/environment/src/main/java/org/jpwh/env/TransactionManagerTest.java的内容如下:

package org.jpwh.env;
 
 import org.testng.annotations.AfterSuite;
 import org.testng.annotations.BeforeSuite;
 import org.testng.annotations.Optional;
 import org.testng.annotations.Parameters;
 
 import java.util.Locale;
 
 /**
 * 在测试套件中启动和停止事务管理器/数据库池
 * 
 * 一个套件中的所有测试都是单个执行的 {@link TransactionManagerSetup}, 
 * 调用静态 {@link TransactionManagerTest#TM} 
 * 在您的测试中访问JTA事务管理器和数据库连接。
 * 
 * 
 * 测试参数 <code>database</code> (指定一个支持
 * {@link DatabaseProduct}) 和一个 <code>connectionURL</code> 
 * 默认设置是内存中的H2数据库实例，为每个测试套件自动创建和销毁
 * 
 */
 public class TransactionManagerTest {
 
 // 每个测试套件静态单数据库连接管理器
 static public TransactionManagerSetup TM;
 
 @Parameters({"database", "connectionURL"})
 @BeforeSuite()
 public void beforeSuite(@Optional String database,
 @Optional String connectionURL) throws Exception {
 TM = new TransactionManagerSetup(
 		
 	 //默认使用H2数据库
 database != null
 ? DatabaseProduct.valueOf(database.toUpperCase(Locale.US))
 : DatabaseProduct.H2,
 connectionURL
 );
 }
 
 @AfterSuite(alwaysRun = true)
 public void afterSuite() throws Exception {
 if (TM != null)
 TM.stop();
 }
 }

他里面加了这个类TransactionManagerSetup

/environment/src/main/java/org/jpwh/env/TransactionManagerSetup.java

package org.jpwh.env;
 
 import bitronix.tm.TransactionManagerServices;
 import bitronix.tm.resource.jdbc.PoolingDataSource;
 
 import javax.naming.Context;
 import javax.naming.InitialContext;
 import javax.sql.DataSource;
 import javax.transaction.Status;
 import javax.transaction.UserTransaction;
 import java.util.logging.Logger;
 
 /**
 *提供与Bitronix JTA事务的数据库连接池
   * manager（http://docs.codehaus.org/display/BTM/Home）。
   * 
   * Hibernate将通过查找数据源和<code> UserTransaction </code>
   * 通过JNDI,这就是为什么你还需要一个<code> jndi.properties </code>文件。最小的
   * JNDI上下文与Bitronix绑定并启动。
 * 
 */
 public class TransactionManagerSetup {
 //数据源名称
 public static final String DATASOURCE_NAME = "myDS";
 
 private static final Logger logger =
 Logger.getLogger(TransactionManagerSetup.class.getName());
 
 protected final Context context = new InitialContext();
 protected final PoolingDataSource datasource;
 public final DatabaseProduct databaseProduct;
 
 public TransactionManagerSetup(DatabaseProduct databaseProduct) throws Exception {
 this(databaseProduct, null);
 }
 
 public TransactionManagerSetup(DatabaseProduct databaseProduct,
 String connectionURL) throws Exception {
 
 logger.fine("Starting database connection pool");
 
 logger.fine("Setting stable unique identifier for transaction recovery");
 TransactionManagerServices.getConfiguration().setServerId("myServer1234");
 
 logger.fine("Disabling JMX binding of manager in unit tests");
 TransactionManagerServices.getConfiguration().setDisableJmx(true);
 
 logger.fine("Disabling transaction logging for unit tests");
 TransactionManagerServices.getConfiguration().setJournal("null");
 
 logger.fine("Disabling warnings when the database isn't accessed in a transaction");
 TransactionManagerServices.getConfiguration().setWarnAboutZeroResourceTransaction(false);
 
 logger.fine("Creating connection pool");
 datasource = new PoolingDataSource();
 datasource.setUniqueName(DATASOURCE_NAME);
 datasource.setMinPoolSize(1);
 datasource.setMaxPoolSize(5);
 datasource.setPreparedStatementCacheSize(10);
 
 //我们的锁定/版本控制测试假设读取提交的事务
 //隔离。这不是默认的MySQL InnoDB，所以我们设置
 //明确地在这里。
 datasource.setIsolationLevel("READ_COMMITTED");
 
 //Hibernate的SQL模式生成器调用connection.setAutoCommit(true)
 //当EntityManager处于挂起状态时，我们使用自动提交模式
 //模式，并没有加入一个事务。
 datasource.setAllowLocalTransactions(true);
 
 logger.info("Setting up database connection: " + databaseProduct);
 this.databaseProduct = databaseProduct;
 databaseProduct.configuration.configure(datasource, connectionURL);
 
 logger.fine("Initializing transaction and resource management");
 datasource.init();
 }
 
 public Context getNamingContext() {
 return context;
 }
 
 public UserTransaction getUserTransaction() {
 try {
 return (UserTransaction) getNamingContext()
 .lookup("java:comp/UserTransaction");
 } catch (Exception ex) {
 throw new RuntimeException(ex);
 }
 }
 
 public DataSource getDataSource() {
 try {
 return (DataSource) getNamingContext().lookup(DATASOURCE_NAME);
 } catch (Exception ex) {
 throw new RuntimeException(ex);
 }
 }
 
 public void rollback() {
 UserTransaction tx = getUserTransaction();
 try {
 if (tx.getStatus() == Status.STATUS_ACTIVE ||
 tx.getStatus() == Status.STATUS_MARKED_ROLLBACK)
 tx.rollback();
 } catch (Exception ex) {
 System.err.println("Rollback of transaction failed, trace follows!");
 ex.printStackTrace(System.err);
 }
 }
 
 public void stop() throws Exception {
 logger.fine("Stopping database connection pool");
 datasource.close();
 TransactionManagerServices.getTransactionManager().shutdown();
 }
 
 }

它其中还引用了databaseProduct类databaseProduct类是一个枚举类型的,定义了一些数据库

/environment/src/main/java/org/jpwh/env/DatabaseProduct.java

package org.jpwh.env;
    
    import bitronix.tm.resource.jdbc.PoolingDataSource;
    
    import java.util.Properties;
    
    public enum DatabaseProduct {
    
        H2(
            new DataSourceConfiguration() {
                @Override
                public void configure(PoolingDataSource ds, String connectionURL) {
                    ds.setClassName("org.h2.jdbcx.JdbcDataSource");
    
                    // External instance: jdbc:h2:tcp://localhost/mem:test;USER=sa
                    ds.getDriverProperties().put(
                        "URL",
                        connectionURL != null
                            ? connectionURL :
                            "jdbc:h2:mem:test"
                    );
    
                    // TODO: http://code.google.com/p/h2database/issues/detail?id=502
                    ds.getDriverProperties().put("user", "sa");
    
                    // TODO: Don't trace log values larger than X bytes (especially useful for
                    // debugging LOBs, which are accessed in toString()!)
                    // System.setProperty("h2.maxTraceDataLength", "256"); 256 bytes, default is 64 kilobytes
                }
            },
            org.jpwh.shared.ImprovedH2Dialect.class.getName()
        ),
    
        ORACLE(
            new DataSourceConfiguration() {
                @Override
                public void configure(PoolingDataSource ds, String connectionURL) {
                    ds.setClassName("oracle.jdbc.xa.client.OracleXADataSource");
                    ds.getDriverProperties().put(
                        "URL",
                        connectionURL != null
                            ? connectionURL :
                            "jdbc:oracle:thin:test/test@192.168.56.101:1521:xe"
                    );
    
                    // Required for reading VARBINARY/LONG RAW columns easily, see
                    // http://stackoverflow.com/questions/10174951
                    Properties connectionProperties = new Properties();
                    connectionProperties.put("useFetchSizeWithLongColumn", "true");
                    ds.getDriverProperties().put("connectionProperties", connectionProperties);
                }
            },
            org.hibernate.dialect.Oracle10gDialect.class.getName()
        ),
    
        POSTGRESQL(
            new DataSourceConfiguration() {
                @Override
                public void configure(PoolingDataSource ds, String connectionURL) {
                    ds.setClassName("org.postgresql.xa.PGXADataSource");
                    if (connectionURL != null) {
                        throw new IllegalArgumentException(
                            "PostgreSQL XADataSource doesn't support connection URLs"
                        );
                    }
                    ds.getDriverProperties().put("serverName", "10.0.0.2");
                    ds.getDriverProperties().put("databaseName", "test");
                    ds.getDriverProperties().put("user", "test");
                    ds.getDriverProperties().put("password", "test");
                }
            },
            org.hibernate.dialect.PostgreSQL82Dialect.class.getName()
        ),
    
        MYSQL(
            new DataSourceConfiguration() {
                @Override
                public void configure(PoolingDataSource ds, String connectionURL) {
                    // TODO: MySQL XA support is completely broken, we use the BTM XA wrapper
                    //ds.setClassName("com.mysql.jdbc.jdbc2.optional.MysqlXADataSource");
                    ds.setClassName("bitronix.tm.resource.jdbc.lrc.LrcXADataSource");
                    ds.getDriverProperties().put(
                        "url",
                        connectionURL != null
                            ? connectionURL :
                            "jdbc:mysql://localhost/test?sessionVariables=sql_mode='PIPES_AS_CONCAT'"
                    );
    
                    ds.getDriverProperties().put("driverClassName", "com.mysql.jdbc.Driver");
                }
            },
            // Yes, this should work with 5.6, no idea why Gail named it 5.7
            org.hibernate.dialect.MySQL57InnoDBDialect.class.getName()
        );
    
        public DataSourceConfiguration configuration;
        public String hibernateDialect;
    
        private DatabaseProduct(DataSourceConfiguration configuration,
                                String hibernateDialect) {
            this.configuration = configuration;
            this.hibernateDialect = hibernateDialect;
        }
    
        public interface DataSourceConfiguration {
    
            void configure(PoolingDataSource ds, String connectionURL);
        }
    
    }

**(二)、原生Hibernate配置**

HelloWorldHibernate测试类

/examples/src/test/java/org/jpwh/helloworld/HelloWorldHibernate.java

package org.jpwh.helloworld;
 
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.boot.Metadata;
 import org.hibernate.boot.MetadataBuilder;
 import org.hibernate.boot.MetadataSources;
 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
 import org.hibernate.cfg.Environment;
 import org.hibernate.resource.transaction.backend.jta.internal.JtaTransactionCoordinatorBuilderImpl;
 import org.hibernate.service.ServiceRegistry;
 import org.jpwh.env.TransactionManagerTest;
 import org.jpwh.model.helloworld.Message;
 import org.testng.annotations.Test;
 
 import javax.transaction.UserTransaction;
 import java.util.List;
 
 import static org.testng.Assert.*;
 
 public class HelloWorldHibernate extends TransactionManagerTest {
 
 protected void unusedSimpleBoot() {
 SessionFactory sessionFactory = new MetadataSources(
 new StandardServiceRegistryBuilder()
 .configure("hibernate.cfg.xml").build()
 ).buildMetadata().buildSessionFactory();
 }
 
 protected SessionFactory createSessionFactory() {
 
 /* 
 		 此构建器可帮助您创建不可变服务注册表
              链接方法调用。
 */
 StandardServiceRegistryBuilder serviceRegistryBuilder =
 new StandardServiceRegistryBuilder();
 
 /* 
 通过应用设置配置服务注册表。
 */
 serviceRegistryBuilder
 .applySetting("hibernate.connection.datasource", "myDS")
 .applySetting("hibernate.format_sql", "true")
 .applySetting("hibernate.use_sql_comments", "true")
 .applySetting("hibernate.hbm2ddl.auto", "create-drop");
 
 // 启用JTA（这有点粗糙，因为Hibernate开发人员仍然相信JTA是
 // 仅用于怪异的应用服务器，您将永远不会看到此代码）。
 serviceRegistryBuilder.applySetting(
 Environment.TRANSACTION_COORDINATOR_STRATEGY,
 JtaTransactionCoordinatorBuilderImpl.class
 );
 ServiceRegistry serviceRegistry = serviceRegistryBuilder.build();
 
 /* 
 		 您只能使用现有服务注册表输入此配置阶段。 
 		 */
 MetadataSources metadataSources = new MetadataSources(serviceRegistry);
 
 /* 
 			将持久化类添加到（映射）元数据源。 
 		*/
 metadataSources.addAnnotatedClass(
 org.jpwh.model.helloworld.Message.class
 );
 
 // 添加hbm.xml映射文件
 // metadataSources.addFile(...);
 
 // 从JAR读取所有hbm.xml映射文件
 // metadataSources.addJar(...)
 
 MetadataBuilder metadataBuilder = metadataSources.getMetadataBuilder();
 
 Metadata metadata = metadataBuilder.build();
 
 assertEquals(metadata.getEntityBindings().size(), 1);
 
 SessionFactory sessionFactory = metadata.buildSessionFactory();
 
 return sessionFactory;
 }
 
 @Test
 public void storeLoadMessage() throws Exception {
 SessionFactory sessionFactory = createSessionFactory();
 try {
 {
 /* 
 					 访问标准事务API <code> UserTransaction </code>和
                      在这个执行线程上开始一个事务。
 */
 UserTransaction tx = TM.getUserTransaction();
 tx.begin();
 
 /* 
 					 每当你在同一个线程中调用<code> getCurrentSession（）</code>
                      相同的<code> org.hibernate.Session </code>。 它会自动被绑定到
 					 正在进行的事务，在该事务时自动关闭提交或回滚。
 */
 Session session = sessionFactory.getCurrentSession();
 
 Message message = new Message();
 message.setText("Hello World!");
 
 /* 
 					 本机Hibernate API与标准的Java Persistence API和大多数方法非常相似
                      有相同的名字。
 */
 session.persist(message);
 
 /* 
 					 Hibernate将会话与数据库同步并关闭“当前”
                      会话自动提交绑定事务。
 */
 tx.commit();
 // INSERT into MESSAGE (ID, TEXT) values (1, 'Hello World!')
 }
 
 {
 UserTransaction tx = TM.getUserTransaction();
 tx.begin();
 
 /* 
 					 Hibernate标准查询是表达查询的类型安全的编程方式，
                      自动翻译成SQL。
 */
 List<Message> messages =
 sessionFactory.getCurrentSession().createCriteria(
 Message.class
 ).list();
 // SELECT * from MESSAGE
 
 assertEquals(messages.size(), 1);
 assertEquals(messages.get(0).getText(), "Hello World!");
 
 tx.commit();
 }
 
 } finally {
 TM.rollback();
 }
 }
 }

总结:

本章主要讲解了两种持久化API的用法

1、EntityManagerFactory  
2、SessionFactory

对于这两种方法的区别可查考这:[http://javabeat.net/jpa-entitymanager-vs-hibernate-sessionfactory/?utm\_source=tuicool&utm\_medium=referral][http_javabeat.net_jpa-entitymanager-vs-hibernate-sessionfactory_utm_source_tuicool_utm_medium_referral] 我把它翻译下

JPA EntityManagerFactory Vs Hibernate’s SessionFactory

如果你正在使用JPA的标准规范执行（读：[介绍JPA][JPA]），然后您可以使用EntityManagerFactory打开会话。但是，如果您使用的是Hibernate实现，你有Hibernate特定SessionFactory管理会议。这里有很多开发者喜欢哪一个是最好的方法混淆。在这里，有两种意见是受欢迎的：

1、EntityManagerFactory是标准实现，在所有实现中都是相同的。如果我们将ORM迁移到任何其他提供者，处理事务的方法将不会发生任何变化。相反，如果使用hibernate的会话工厂，它与hibernate api绑定，不会轻易迁移到新的供应商。

2、使用标准实现的一个不利之处在于它不提供高级功能。 在EntityManager API中没有提供很多控件。 而Hibernate的SessionFactory有很多高级功能，在JPA中无法完成。 一个这样的事情是检索ID生成器而不关闭事务，批量插入等。

看了以上几点，必须决定哪一个是更好的。没有硬性规定，毕竟这取决于开发商的要求。另一个建议是，我们可以用实体和会话工厂经理一起。在这种方法中，实体管理代表会议处理Hibernate通过调用Unwrap方法。这样地:

Session session = entityManager.unwrap(Session.class);

使用EntityManagerFactory方法，我们可以使用@PrePersist，@ PostPersist，@PreUpdate等回调方法注释，无需额外的配置。 使用SessionFactory时使用类似的回调需要额外的努力。

[20170703152212071]: /images/20220613/0bca34ad4fa54f65b72338c02abce91e.png
[http_jpwh.org]: http://jpwh.org
[20170703152410661]: /images/20220613/dbea2b66969d4244b462ee16acc00888.png
[20170703151916098]: /images/20220613/9b4bff92ad6f4996a086469b349a08c4.png
[20170703153131826]: /images/20220613/fc51c429c52c4ebc85f4af731e25b48a.png
[20170703153232918]: /images/20220613/7c446da0eb344d6b8dd11a57fe465ef9.png
[20170703153337529]: /images/20220613/9a5ba390d94b47c4afc31f762b266c89.png
[https_forums.manning.com_posts_list_35484.page]: https://forums.manning.com/posts/list/35484.page
[20170703153709328]: /images/20220613/880010c83dfd4d84abe59a9abb4b9f77.png
[20170703154330553]: /images/20220613/5031cf1dfdb44544aeeb160baf16f95a.png
[http_javabeat.net_jpa-entitymanager-vs-hibernate-sessionfactory_utm_source_tuicool_utm_medium_referral]: http://javabeat.net/jpa-entitymanager-vs-hibernate-sessionfactory/?utm_source=tuicool&utm_medium=referral
[JPA]: http://www.javabeat.net/jpa/