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

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

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

下载下来之后，目录如下

其中:

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

选择一个存在的Maven项目

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

导入之后，会报很多错:

比如说这几个类CreditCard_、 Item_ 、Bid_提示找不到，我找了半天在书中对应的论坛找到了一种说法:https://forums.manning.com/posts/list/35484.page

暂时把那些报错的地方全部注释掉。然后对照着书中的第二章的开启一个项目,运行测试,发现测试用的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>
	  <!-- All persistence classes must be listed -->
	  <class>boa.framework.entity.CustomerEntity</class>                                                                                 <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
	   <validation-mode>CALLBACK</validation-mode>     
	  <properties>
	   <!-- Provider-specific connection 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>

  
	<!--   
		  Name属性用于定义持久化单元的名字 (name必选,空值也合法);   
		  transaction-type 指定事务类型(可选)   
	-->  
	<persistence-unit name="unitName" transaction-type="JTA">  
  
   <!-- 描述信息.(可选) -->  
   <description> </description>  
  
   <!-- javax.persistence.PersistenceProvider接口的一个实现类(可选) -->  
   <provider>   </provider>  
  
   <!-- Jta-data-source和 non-jta-data-source用于分别指定持久化提供商使用的JTA和/或non-JTA数据源的全局JNDI名称(可选) -->  
   <jta-data-source>java:/test</jta-data-source>  
   <non-jta-data-source> </non-jta-data-source>  
  
   <!-- 声明orm.xml所在位置.(可选) -->  
   <mapping-file>product.xml</mapping-file>  
  
   <!-- 以包含persistence.xml的jar文件为基准的相对路径,添加额外的jar文件.(可选) -->  
   <jar-file>../lib/model.jar</jar-file>  
  
   <!-- 显式列出实体类,在Java SE 环境中应该显式列出.(可选) -->  
   <class>boa.framework.entity.CustomerEntity</class>
  
   <!-- 声明是否扫描jar文件中标注了@Enity类加入到上下文.若不扫描,则如下:(可选) -->  
   <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>  
    <!-- hibernate.hbm2ddl.auto= create-drop / create / update -->  
      <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">

    <!-- 
			<code>persistence.xml</code>文件至少配置一个持久化单元;
			每个单元必须有一个唯一的名称。
    -->
    <persistence-unit name="HelloWorldPU">

        <!-- 
				每个持久化单元必须有一个数据库连接。在这里你委托给
				现有的<code>java.sql.DataSource</code>。Hibernate会找到数据源
				通过在启动时使用JNDI查找来命名。
        -->
        <jta-data-source>myDS</jta-data-source>

        <!-- 
				持久单元有持久的(映射)类，您将它们列在这里。       
		 -->
        <class>org.jpwh.model.helloworld.Message</class>

        <!-- 
			Hibernate可以为映射的类扫描类路径并自动添加它们
			给你的坚持单位。
			这种设置禁用了该特性。
        -->
        <exclude-unlisted-classes>true</exclude-unlisted-classes>

        <!-- 
				可以将标准或供应商特定的选项设置为持久性单元的属性。
				任何标准属性都有 <code>javax.persistence</code> 名称前缀,
				使用Hibernate的设置 <code>hibernate</code>
        -->
        <properties>

            <!-- 
				JPA引擎应该在启动时自动删除和重新创建数据库中的SQL模式。
				对于自动化测试来说，这是非常理想的，
				当您想要为每个测试运行使用一个干净的数据库时。
            -->
            <property
                name="javax.persistence.schema-generation.database.action"
                value="drop-and-create"/>

            <!-- 
               	 当在日志中打印SQL时，让Hibernate格式化SQL并将注释生成到SQL字符串中，这样我们就可以知道为什么Hibernate执行SQL语句了
            -->
            <property name="hibernate.format_sql" value="true"/>
            <property name="hibernate.use_sql_comments" value="true"/>

            <!-- 禁用Hibernate扫描，我们也不需要任何的hbm.xml文件。它会发现并自动添加的xml文件 -->
            <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运行

输出如下:

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;

/**
 * 在测试套件中启动和停止事务管理器/数据库池
 * <p>
 * 一个套件中的所有测试都是单个执行的 {@link TransactionManagerSetup}, 
 * 调用静态 {@link TransactionManagerTest#TM} 
 * 在您的测试中访问JTA事务管理器和数据库连接。
 * </p>
 * <p>
 * 测试参数 <code>database</code> (指定一个支持
 * {@link DatabaseProduct}) 和一个 <code>connectionURL</code> 
 * 默认设置是内存中的H2数据库实例，为每个测试套件自动创建和销毁
 * </p>
 */
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）。
  * <p>
  * Hibernate将通过查找数据源和<code> UserTransaction </code>
  * 通过JNDI,这就是为什么你还需要一个<code> jndi.properties </code>文件。最小的
  * JNDI上下文与Bitronix绑定并启动。
  * </p>
 */
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 我把它翻译下

JPA EntityManagerFactory Vs Hibernate’s SessionFactory

如果你正在使用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时使用类似的回调需要额外的努力。