Java豆技术站点 » Hibernate

连接池泄露的问题：Timeout waiting for idle object

阿超 — Tue, 13 Jul 2010 10:58:47 +0000

问题描述:连接池泄露的问题：org.apache.commons.dbcp.SQLNestedException: Cannot get a connection, pool exhausted, cause:java.util.NoSuchElementException: Timeout waiting for idle object
问题同样适用于其他服务器,使用spring配置文件的可以加下面的参数

1 问题描述
Web程序在tomcat刚开始运行时速度很快，但过一段时间后发现速度变得很慢。
检查日志输出，发现异常如下:
org.apache.commons.dbcp.SQLNestedException: Cannot get a connection, pool exhausted, cause:
java.util.NoSuchElementException: Timeout waiting for idle object
同时在SQLServer事件探查器中发现，每执行一次sql语句都要产生Audit login事件，语句执行后产生
Audit logout事件。说明每一次tomcat都是重新打开新的连接。
2 问题解决
tomcat 的数据源定义提供了三个参数：
a. 如果设为true则tomcat自动检查恢复重新利用，没有正常关闭的Connection.（默认是false）

removeAbandoned
true

b. 设定连接在多少秒内被认为是放弃的连接，即可进行恢复利用。

removeAbandonedTimeout
60

c. 输出回收的日志，可以详细打印出异常从而发现是在那里发生了泄漏

logAbandoned
true

hibernate C3P0连接池详细配置

阿超 — Tue, 06 Jul 2010 12:30:18 +0000

1000

false

属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作，它将只供c3p0测试
使用。Default: null–>
Test

保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
获取连接失败后该数据源将申明已断开并永久关闭。Default: false–>
false

SQLException,如设为0则无限期等待。单位毫秒。Default: 0 –>
100

Default: com.mchange.v2.c3p0.impl.DefaultConnectionTester–>

Default: null–>
null

（文档原文）作者强烈建议不使用的一个属性–>
false

属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0–>
100

通过多线程实现多个操作同时被执行。Default: 3–>
3

的数据源时。Default: null–>
root

password

测试的表必须在初始数据源的时候就存在。Default: null–>
select id from test where id=1

300

时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
等方法来提升连接测试的性能。Default: false –>
false

true

root

允许用户恢复到动态反射代理以解决不稳定的故障。最新的非反射代理更快并且已经开始
广泛的被使用，所以这个参数未必有用。现在原先的动态反射与新的非反射代理同时受到
支持，但今后可能的版本可能不支持动态反射代理。Default: false–>
false

con_test
30000
30
10
30
25
10
0

200

300

你所不知道的提高spring+hibernate性能的一个方法

阿超 — Fri, 05 Feb 2010 09:13:56 +0000

在spring + hibernate的应用中，你监控mysql日志，你会发现大量的log如下：

1. 158268 Query       SET autocommit=1
2. 158268 Query       SET autocommit=1
3. 158268 Query       SET autocommit=1
4. 158268 Query       SET autocommit=0
5. 158268 Query       commit
6. 158268 Query       SET autocommit=1
7. 158268 Query       SET autocommit=1
8. 158268 Query       SET autocommit=1
9. 158268 Query       SET autocommit=0
10. 158268 Query       commit

158268 Query       SET autocommit=1
158268 Query       SET autocommit=1
158268 Query       SET autocommit=1
158268 Query       SET autocommit=0
158268 Query       commit
158268 Query       SET autocommit=1
158268 Query       SET autocommit=1
158268 Query       SET autocommit=1
158268 Query       SET autocommit=0
158268 Query       commit

另外，你如果看mysqlreport，你会发现set_option和commt几乎占了mysql query的一半！！

原因是？

我们先看第一个问题：

1. 158268 Query SET autocommit=0
2. 158268 Query commit

158268 Query SET autocommit=0
158268 Query commit

这种日志产生的原因是hibernate查询时，如果所请求的对象在cache中，那么hibernate仍然会向数据库发出这样的两个sql语句。

再来看第二个问题

1. 158268 Query SET autocommit=1

158268 Query SET autocommit=1

这是因为当connection 被放回conn pool时，conn pool会恢复此连接取出时的autocommit状态。一般连接池里面的autocommit状态为true，所以每个查询都会紧跟着一个set autocommit＝1。

对第一个问题我们的解决方案：

那就是利用LazyConnectionDataSourceProxy

这个conn 代理的作用就是，只有当确实有必要时，他它向DB发出查询。一切没有必要的set autocommit=0 commit语句都不会发向数据库。

此class的详细作用请参见spring 文档

example配置如下:

1.
2.   com.mysql.jdbc.Driver
3.   jdbc:mysql
4. ://localhost:3306/imagedb
5.   admin
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.

com.mysql.jdbc.Driver
jdbc:mysql
://localhost:3306/imagedb
admin

第二个问题的解决方案：

通过conn pool 的jdbc url把autocommit设为false来解决，不过mysql driver好像不支持这个设置。

另外，如果你使用的是mysql，那么第一个问题还有一个更简单的解决方案，那就是在jdbcUrl中加入

useLocalSessionState=true

这可以达到和

1. LazyConnectionDataSourceProxy

LazyConnectionDataSourceProxy

一样的效果

Struts2 json session close no session 异常解决

阿超 — Tue, 05 Jan 2010 06:16:56 +0000

异常信息：

ERROR – failed to lazily initialize a collection of role: com.dudu.pojo.User.roles, no session or session was closed

org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.dudu.pojo.User.roles, no session or session was closed

异常说明：session已关闭，无法初始化懒加载数据集role

异常原因：Hibernate映射文件中配置了lazy=”true”，同时也启用了OpenSessionInViewFilter。当实现ajax检测role名称是否可用时报以上异常，我这里检测role名称是利用json格式返回数据的。json返回数据的特点是：如果action中的属性有get()方法并且该属性没有transient修饰，那么json就会将其返回。在我的TrackSmsExpertAction中有private User role;并且role有get()方法，所以在检测名称是否可用后返回的json数据中会将这一属性返回，但是检测名称的可用性根本不需要用到这个属性，异常就是由于启用懒加载机制下json中返回role这个属性需要查询数据库，而这时session已经关闭，因此报异常。

解决方法：用transient对role属性进行修饰，即：private transient User role;这样json就不会将其返回，因为也不用再次查询关联数据不会出现session已关闭的异常。

如果还是不行的话请检查你的Action中是否有多余的get set方法把不用的全部去掉就可以解决问题了最后感谢下IT北瓜的提醒帮我解决问题

用hibernate的hql查询查询成map或list

阿超 — Mon, 04 Jan 2010 07:43:21 +0000

这里制作一个引子，具体内容比较多，而且hibernate文档里的hql篇写的很详细
可以这么用：
List list = getHibernateTemplate().find(“select new map(t1.c1,t2.c3) from table1 t1 ,table2 t2 where t1.c1=t2.c2″);
这样的话list里的每个元素都是一个map，每个map里包含两个元素
注意：这里的table1和table2都是class名并不是真的表名，毕竟这是hql。除了可以用map还还支持list和自定义的bean。

//HQL-Associations
String hql = “select s.name, p.name, p.price from Product p inner join p.supplier as s”;
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Delete
String hql = “delete from Product where name = :name”;
Query query = session.createQuery(hql);
query.setString(“name”,”Product 1″);
int rowCount = query.executeUpdate();

//HQL-Function
String hql = “select min(product.price), max(product.price) from Product product”;
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Fetch Associations HQL Inner Join
String hql = “from Supplier s inner join fetch s.products as p”;
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Named Parameters
String hql = “from Product where price > :price”;
Query query = session.createQuery(hql);
query.setDouble(“price”,2.0);
List results = query.list();
String hql = “from Product as product where product.supplier=:supplier”;
Query query = session.createQuery(hql);
query.setEntity(“supplier”,supplier);
List results = query.list();

//HQL-Update
String hql = “update Supplier set name = :newName where name = :name”;
Query query = session.createQuery(hql);
query.setString(“name”,”Supplier Name 1″);
query.setString(“newName”,”s1″);
int rowCount = query.executeUpdate();

//HQL-where
String hql = “from Product where price > 2.0 and name like ‘P%’”;
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Map
String hql = ” select new map(usr.name as userName, usr.password as password) from User usr”;
Query query = session.createQuery(hql);
List list = query.list();
Map goods =(Map)list.get(0);

【注】
String hql = ” select new map(usr.name as userName, usr.password as password)　from com.jason.User usr”;
String hql = ” select new map(usr.name as userName, usr.password as password) from com.jason.User usr”;
由于from之前的空格，引起unexpected token: 　from

//select new

给一个构建函数：
public class Department(Department d, Integer employeeSize)

使 Hibernate Tools生成注释

阿超 — Sat, 14 Nov 2009 12:24:09 +0000

最近做项目时，使用Hibernate Tools 3.2.4生成entity和hbm.xml，但默认情况下，DB中的comments没法生成到javadoc和xml中，改了templates倒是有注释了，但却是乱码，心里一直耿耿于怀…（这不符合咱一直强调的编码规范不是？最主要的是人懒，有时用entity不想再找文档）。在网上找了半天，大多说是freemarker编码设置问题，但不管怎么设置，都没一点效果，决定自己动手。下了源码，查到原因，人家压根就没处理中文问题。记录一下处理过程。

ftl是freemarker模板，可以通过在jar包外使用，java和properties重新打包替换hibernate-tools.jar，如果是eclipse-plugins，jar包在plugins\org.hibernate.eclipse_3.2.4.GA-R200905070146-H18\lib\tools\hibernate-tools.jar

pojo\PojoFields.ftl

<#-- // Fields -->

<#foreach field in pojo.getAllPropertiesIterator()><#if pojo.getMetaAttribAsBool(field, "gen-property", true)>    /** *//** *//** *//**
<#if pojo.hasMetaAttribute(field, "field-description")>
     ${pojo.getFieldJavaDoc(field, 0)}

<#foreach column in field.columnIterator><#if column.comment?exists && column.comment?trim?length!=0>     * ${column.comment}.


     */
    ${pojo.getFieldModifiers(field)} ${pojo.getJavaTypeName(field, jdk5)} ${field.name}<#if pojo.hasFieldInitializor(field, jdk5)> = ${pojo.getFieldInitialization(field, jdk5)};

pojo\PojoPropertyAccessors.ftl

<#-- // Property accessors -->
<#foreach property in pojo.getAllPropertiesIterator()>
<#if pojo.getMetaAttribAsBool(property, "gen-property", true)>
    /** *//**
<#if pojo.hasFieldJavaDoc(property)>
     * ${pojo.getFieldJavaDoc(property, 4)}

<#foreach column in property.columnIterator><#if column.comment?exists && column.comment?trim?length!=0>     * 取得 ${column.comment}.


     */
    <#include "GetPropertyAnnotation.ftl"/>
    ${pojo.getPropertyGetModifiers(property)} ${pojo.getJavaTypeName(property, jdk5)} ${pojo.getGetterSignature(property)}() {
        return this.${property.name};
    }

    /** *//**
<#if pojo.hasFieldJavaDoc(property)>
     * ${pojo.getFieldJavaDoc(property, 4)}

<#foreach column in property.columnIterator><#if column.comment?exists && column.comment?trim?length!=0>     * 设置 ${column.comment}.


     */
    ${pojo.getPropertySetModifiers(property)} void set${pojo.getPropertyName(property)}(${pojo.getJavaTypeName(property, jdk5)} ${property.name}) {
        this.${property.name} = ${property.name};
    }

org\hibernate\tool\hbm2x\TemplateProducer.java

public void produce(Map additionalContext, String templateName, File destination, String identifier, String fileType, String rootContext) {

        String tempResult = produceToString( additionalContext, templateName, rootContext );

        if(tempResult.trim().length()==0) {
            log.warn("Generated output is empty. Skipped creation for file " + destination);
            return;
        }
        FileWriter fileWriter = null;
        Writer fileWriter = null;
        try {

            th.ensureExistence( destination );    

            ac.addFile(destination, fileType);
            log.debug("Writing " + identifier + " to " + destination.getAbsolutePath() );
            fileWriter = new FileWriter(destination);
            fileWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(destination), "UTF-8"));

            fileWriter.write(tempResult);
        }
        catch (Exception e) {
            throw new ExporterException("Error while writing result to file", e);
        } finally {
            if(fileWriter!=null) {
                try {
                    fileWriter.flush();
                    fileWriter.close();
                }
                catch (IOException e) {
                    log.warn("Exception while flushing/closing " + destination,e);
                }
            }
        }

    }

org\hibernate\tool\hbm2x\jtidy.properties

indent=auto
indent-spaces=4
#indent-attributes=yes
    wrap=180
markup=yes
clean=yes
output-xml=yes
input-xml=yes
show-warnings=yes
trim-empty-elements=yes
input-encoding=utf-8
output-encoding=utf-8

Hibernate dao单元测试

阿超 — Thu, 10 Sep 2009 23:35:00 +0000

单元测试作为保证软件质量及重构的基础，早已获得广大开发人员的认可。单元测试是一种细粒度的测试，越来越多的开发人员在提交功能模块时也同时提交相应的单元测试。对于大多数开发人员来讲，编写单元测试已经成为开发过程中必须的流程和最佳实践。

对普通的逻辑组件编写单元测试是一件容易的事情，由于逻辑组件通常只需要内存资源，因此，设置好输入输出即可编写有效的单元测试。对于稍微复杂一点的组件，例如Servlet，我们可以自行编写模拟对象，以便模拟HttpRequest和HttpResponse等对象，或者，使用 EasyMock之类的动态模拟库，可以对任意接口实现相应的模拟对象，从而对依赖接口的组件进行有效的单元测试。

在J2EE开发中，对DAO组件编写单元测试往往是一件非常复杂的任务。和其他组件不通，DAO组件通常依赖于底层数据库，以及JDBC接口或者某个ORM框架（如Hibernate），对DAO组件的测试往往还需引入事务，这更增加了编写单元测试的复杂性。虽然使用EasyMock也可以模拟出任意的JDBC接口对象，或者ORM框架的主要接口，但其复杂性往往非常高，需要编写大量的模拟代码，且代码复用度很低，甚至不如直接在真实的数据库环境下测试。不过，使用真实数据库环境也有一个明显的弊端，我们需要准备数据库环境，准备初始数据，并且每次运行单元测试后，其数据库现有的数据将直接影响到下一次测试，难以实现“即时运行，反复运行”单元测试的良好实践。

本文针对DAO组件给出一种较为合适的单元测试的编写策略。在JavaEE开发网（http://javadou.com）的开发过程中，为了对DAO组件进行有效的单元测试，我们采用HSQLDB这一小巧的纯Java数据库作为测试时期的数据库环境，配合Ant，实现了自动生成数据库脚本，测试前自动初始化数据库，极大地简化了DAO组件的单元测试的编写。
在Java领域，JUnit作为第一个单元测试框架已经获得了最广泛的应用，无可争议地成为Java领域单元测试的标准框架。本文以最新的JUnit 4版本为例，演示如何创建对DAO组件的单元测试用例。

javadou的持久层使用Hibernate 3.2，底层数据库为MySQL。为了演示如何对DAO进行单元测试，我们将其简化为一个DAOTest工程：

由于将Hibernate的Transaction绑定在Thread上，因此，HibernateUtil类负责初始化SessionFactory以及获取当前的Session：

public class HibernateUtil {
  private static final  SessionFactory sessionFactory;
  static {
  try {
  sessionFactory =  new AnnotationConfiguration()
  .configure()
  .buildSessionFactory();
  }
  catch(Exception e) {
  throw new  ExceptionInInitializerError(e);
  }
  }   public static Session  getCurrentSession() {
  return  sessionFactory.getCurrentSession();
  }
  }

HibernateUtil还包含了一些辅助方法，如：

　public static Object query(Class clazz, Serializable id);
  public static void createEntity(Object entity);
  public static Object queryForObject(String hql, Object[] params);
  public static List queryForList(String hql, Object[] params);

在此不再多述。实体类User使用JPA注解，代表一个用户：

@Entity

  @Table(name="T_USER")

  public class User {

  public static final  String REGEX_USERNAME = "[a-z0-9][a-z0-9\\-]{1,18}[a-z0-9]";

  public static final  String REGEX_PASSWORD = "[a-f0-9]{32}";

  public static final  String REGEX_EMAIL = "([0-9a-zA-Z]([-.\\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\\w]*[0-9a-zA-Z]\\.)+[a-zA-Z]{2,9})";
  private String  username;     // 用户名 

  private String  password;     // MD5口令 

  private boolean  admin;       // 是否是管理员 

  private String  email;        // 电子邮件 

  private int  emailValidation; // 电子邮件验证码 

  private long  createdDate;    // 创建时间 

  private long  lockDate;       // 锁定时间
  public User() {}
  public User(String  username, String password, boolean admin, long lastSignOnDate) {

  this.username = username;

  this.password =  password;

  this.admin = admin;

  }
  @Id

  @Column(updatable=false,  length=20)

  @Pattern(regex=REGEX_USERNAME)

  public String  getUsername() { return username; }

  public void setUsername(String  username) { this.username = username; }
  @Column(nullable=false,  length=32)

  @Pattern(regex=REGEX_PASSWORD)

  public String  getPassword() { return password; }

  public void  setPassword(String password) { this.password = password; }
  @Column(nullable=false,  length=50)

  @Pattern(regex=REGEX_EMAIL)

  public String getEmail()  { return email; }

  public void  setEmail(String email) { this.email = email; }
  @Column(nullable=false)

  public boolean getAdmin()  { return admin; }

  public void  setAdmin(boolean admin) { this.admin = admin; }
  @Column(nullable=false,  updatable=false)

  public long  getCreatedDate() { return createdDate; }

  public void  setCreatedDate(long createdDate) { this.createdDate = createdDate; }
  @Column(nullable=false)

  public int  getEmailValidation() { return emailValidation; }

  public void  setEmailValidation(int emailValidation) { this.emailValidation =  emailValidation; }
  @Column(nullable=false)

  public long getLockDate()  { return lockDate; }

  public void  setLockDate(long lockDate) { this.lockDate = lockDate; }
  @Transient

  public boolean  getEmailValidated() { return emailValidation==0; }
  @Transient

  public boolean  getLocked() {

  return !admin  && lockDate>0 && lockDate>System.currentTimeMillis();

  }

  }

实体类PasswordTicket代表一个重置口令的请求：

@Entity

  @Table(name="T_PWDT")

  public class PasswordTicket {

  private String id;

  private User user;

  private String ticket;

  private long createdDate;
  @Id

  @Column(nullable=false, updatable=false,  length=32)

  @GeneratedValue(generator="system-uuid")

  @GenericGenerator(name="system-uuid",  strategy="uuid")

  public String getId() {  return id; }

  protected void  setId(String id) { this.id = id; }
  @ManyToOne

  @JoinColumn(nullable=false, updatable=false)

  public User getUser() {  return user; }

  public void setUser(User  user) { this.user = user; }
  @Column(nullable=false,  updatable=false, length=32)

  public String getTicket()  { return ticket; }

  public void  setTicket(String ticket) { this.ticket = ticket; }
  @Column(nullable=false,  updatable=false)

  public long  getCreatedDate() { return createdDate; }

  public void  setCreatedDate(long createdDate) { this.createdDate = createdDate; }

  }

UserDao接口定义了对用户的相关操作：

public interface UserDao {
  User  queryForSignOn(String username);
  User queryUser(String  username);
  void createUser(User  user);
  void updateUser(User  user);
  boolean  updateEmailValidation(String username, int ticket);
  String  createPasswordTicket(User user);
  boolean  updatePassword(String username, String oldPassword, String newPassword);
  boolean  queryResetPassword(User user, String ticket);
  boolean  updateResetPassword(User user, String ticket, String password);
  void updateLock(User  user, long lockTime);
  void updateUnlock(User  user);
  }

UserDaoImpl是其实现类：

　public class UserDaoImpl implements UserDao {
  public User  queryForSignOn(String username) {
  User user =  queryUser(username);
  if(user.getLocked())
  throw new  LockException(user.getLockDate());
  return user;
  }
　public User  queryUser(String username) {
  return (User)  HibernateUtil.query(User.class, username);
  }
　public void  createUser(User user) {
  user.setEmailValidation((int)(Math.random() * 1000000) + 0xf);
  HibernateUtil.createEntity(user);
  }
  // 其余方法略 
  ...
  }

由于将Hibernate事务绑定在Thread上，因此，实际的客户端调用DAO组件时，还必须加入事务代码：

Transaction tx =  HibernateUtil.getCurrentSession().beginTransaction();
  try {
  dao.xxx();
  tx.commit();
  }
  catch(Exception e) {
  tx.rollback();
  throw e;
  }

下面，我们开始对DAO组件编写单元测试。前面提到了HSQLDB这一小巧的纯Java数据库。HSQLDB除了提供完整的JDBC驱动以及事务支持外，HSQLDB还提供了进程外模式（与普通数据库类似）和进程内模式（In-Process），以及文件和内存两种存储模式。我们将HSQLDB 设定为进程内模式及仅使用内存存储，这样，在运行JUnit测试时，可以直接在测试代码中启动HSQLDB。测试完毕后，由于测试数据并没有保存在文件上，因此，不必清理数据库。

此外，为了执行批量测试，在每个独立的DAO单元测试运行前，我们都执行一个初始化脚本，重新建立所有的表。该初始化脚本是通过HibernateTool自动生成的，稍后我们还会讨论。下图是单元测试的执行顺序：

在编写测试类之前，我们首先准备了一个TransactionCallback抽象类，该类通过Template模式将DAO调用代码通过事务包装起来：

　public abstract class TransactionCallback {
  public final Object  execute() throws Exception {
  Transaction tx =  HibernateUtil.getCurrentSession().beginTransaction();
  try {
  Object r =  doInTransaction();
  tx.commit();
  return r;
  }
  catch(Exception e) {
  tx.rollback();
  throw e;
  }
  }
  // 模板方法： 
  protected abstract Object  doInTransaction() throws Exception;
  }

其原理是使用JDK提供的动态代理。由于JDK的动态代理只能对接口代理，因此，要求DAO组件必须实现接口。如果只有具体的实现类，则只能考虑CGLIB之类的第三方库，在此我们不作更多讨论。

下面我们需要编写DatabaseFixture，负责启动HSQLDB数据库，并在@Before方法中初始化数据库表。该DatabaseFixture可以在所有的DAO组件的单元测试类中复用：

　public class DatabaseFixture {
  private static Server  server = null; // 持有HSQLDB的实例 
  private static final  String DATABASE_NAME = "javaeedev"; // 数据库名称 
  private static final  String SCHEMA_FILE = "schema.sql"; // 数据库初始化脚本 
  private static final  List initSqls = new ArrayList();
　@BeforeClass // 启动HSQLDB数据库 
  public static void  startDatabase() throws Exception {
  if(server!=null)
  return;
  server = new  Server();
  server.setDatabaseName(0,  DATABASE_NAME);
  server.setDatabasePath(0, "mem:" + DATABASE_NAME);
  server.setSilent(true);
  server.start();
  try {
  Class.forName("org.hsqldb.jdbcDriver");
  }
  catch(ClassNotFoundException cnfe) {
  throw new  RuntimeException(cnfe);
  }
  LineNumberReader  reader = null;
  try {
  reader = new  LineNumberReader(new  　　　InputStreamReader(DatabaseFixture.class.getClassLoader().getResourceAsStream(SCHEMA_FILE)));
  for(;;) {
  String line =  reader.readLine();
  if(line==null) break;
  // 将text类型的字段改为varchar(2000)，因为HSQLDB不支持text： 
  line =  line.trim().replace(" text ", " varchar(2000)  ").replace(" 　text,", " varchar(2000),");
  if(!line.equals(""))
  initSqls.add(line);
  }
  }
  catch(IOException e)  {
  throw new  RuntimeException(e);
  }
  finally {
  if(reader!=null)  {
  try {  reader.close(); } catch(IOException e) {}
  }
  }
  }
　@Before // 执行初始化脚本 
  public void initTables()  {
  for(String sql :  initSqls) {
  executeSQL(sql);
  }
  }
static Connection  getConnection() throws SQLException {
  return  DriverManager.getConnection("jdbc:hsqldb:mem:" + DATABASE_NAME,  "sa", "");
  }
static void  close(Statement stmt) {
  if(stmt!=null) {
  try {
  stmt.close();
  }
  catch(SQLException e) {}
  }
  }
static void  close(Connection conn) {
  if(conn!=null) {
  try {
  conn.close();
  }
  catch(SQLException e) {}
  }
  }
static void  executeSQL(String sql) {
  Connection conn =  null;
  Statement stmt =  null;
  try {
  conn =  getConnection();
  boolean  autoCommit = conn.getAutoCommit();
  conn.setAutoCommit(true);
  stmt = conn.createStatement();
  stmt.execute(sql);
  conn.setAutoCommit(autoCommit);
  }
  catch(SQLException e)  {
  log.warn("Execute failed: " + sql + "\nException: "  + e.getMessage());
  }
  finally {
  close(stmt);
  close(conn);
  }
  }
public static Object  createProxy(final Object target) {
  return  Proxy.newProxyInstance(
  target.getClass().getClassLoader(),
  target.getClass().getInterfaces(),
  new  InvocationHandler() {
  public  Object invoke(Object proxy, final Method method, final Object[] args) throws  Throwable {
  return new TransactionCallback() {
  @Override
  protected Object doInTransaction() throws Exception {
  return method.invoke(target, args);
  }
  }.execute();
  }
  }
  );
  }
  }

注意DatabaseFixture的createProxy()方法，它将一个普通的DAO对象包装为在事务范围内执行的代理对象，即对于一个普通的DAO对象的方法调用前后，自动地开启事务并根据异常情况提交或回滚事务。

下面是UserDaoImpl的单元测试类：

　public class UserDaoImplTest extends DatabaseFixture {
  private UserDao userDao =  new UserDaoImpl();
  private UserDao proxy =  (UserDao)createProxy(userDao);
　@Test
  public void  testQueryUser() {
  User user =  newUser("test");
  proxy.createUser(user);
  User t =  proxy.queryUser("test");
  assertEquals(user.getEmail(), t.getEmail());
  }
  }

注意到UserDaoImplTest持有两个UserDao引用，userDao是普通的UserDaoImpl对象，而proxy则是将userDao进行了事务封装的对象。

由于UserDaoImplTest从DatabaseFixture继承，因此，@Before方法在每个@Test方法调用前自动调用，这样，每个@Test方法执行前，数据库都是一个经过初始化的“干净”的表。

对于普通的测试，如UserDao.queryUser()方法，直接调用proxy.queryUser()即可在事务内执行查询，获得返回结果。

对于异常测试，例如期待一个ResourceNotFoundException，就不能直接调用proxy.queryUser()方法，否则，将得到一个UndeclaredThrowableException：

这是因为通过反射调用抛出的异常被代理类包装为UndeclaredThrowableException，因此，对于异常测试，只能使用原始的userDao对象配合TransactionCallback实现：

　@Test(expected=ResourceNotFoundException.class)
  public void testQueryNonExistUser() throws Exception {
  new TransactionCallback()  {
  protected Object  doInTransaction() throws Exception {
  userDao.queryUser("nonexist");
  return null;
  }
  }.execute();
  }

到此为止，对DAO组件的单元测试已经实现完毕。下一步，我们需要使用HibernateTool自动生成数据库脚本，免去维护SQL语句的麻烦。相关的Ant脚本片段如下：

完整的Ant脚本以及Hibernate配置文件请参考项目工程源代码。

利用HSQLDB，我们已经成功地简化了对DAO组件进行单元测试。我发现这种方式能够找出许多常见的bug：

HQL语句的语法错误，包括SQL关键字和实体类属性的错误拼写，反复运行单元测试就可以不断地修复许多这类错误，而不需要等到通过Web页面请求而调用DAO时才发现问题；
传入了不一致或者顺序错误的HQL参数数组，导致Hibernate在运行期报错；
一些逻辑错误，包括不允许的null属性（常常由于忘记设置实体类的属性），更新实体时引发的数据逻辑状态不一致。

总之，单元测试需要根据被测试类的实际情况，编写最简单最有效的测试用例。本文旨在给出一种编写DAO组件单元测试的有效方法。

MyEclipse生成的Spring+Hibernate无法保存数据问题2

阿超 — Wed, 09 Sep 2009 02:41:00 +0000

MyEclipse生成的Spring+Hibernate无法保存数据问题的解决方法2 – 用 CGLIB 来实现事务管理

上一小节讨论了用 JDK 的代理机制来实现事务管理的解决方案, 相比起来它有一个麻烦的地方就是必须需要生成一个 DAO 的接口才能工作. 那么另一种比较简单的解决方案就是用 CGBLIB, 可以不用编写接口, 那么下面是 Spring 参考文档中的内容:
7.5.3. 基于JDK和CGLIB的代理
这个小节作为说明性文档，解释了对于一个目标对象（需要被代理的对象），ProxyFactryBean是如何决定究竟创建一个基于JDK还是CGLIB的代理的。

注意
ProxyFactoryBean需要创建基于JDK还是CGLIB代理的具体行为在版本1.2.x和2.0中有所不同。现在ProxyFactoryBean在关于自动检测接口方面使用了与TransactionProxyFactoryBean相似的语义。

如果一个需要被代理的目标对象的类（后面将简单地称它为目标类）没有实现任何接口，那么一个基于CGLIB的代理将被创建。这是最简单的场景，因为 JDK代理是基于接口的，没有接口意味着没有使用JDK进行代理的可能。在目标bean里将被插入探测代码，通过interceptorNames属性给出了拦截器的列表。注意一个基于CGLIB的代理将被创建即使 ProxyFactoryBean的proxyTargetClass属性被设置为false。（很明显这种情况下对这个属性进行设置是没有意义的，最好把它从bean的定义中移除，因为虽然这只是个多余的属性，但在许多情况下会引起混淆。）

如果目标类实现了一个（或者更多）接口，那么创建代理的类型将根据ProxyFactoryBean的配置来决定。

如果ProxyFactoryBean的proxyTargetClass属性被设为true，那么一个基于CGLIB的代理将创建。这样的规定是有意义的，遵循了最小惊讶法则（保证了设定的一致性）。甚至当ProxyFactoryBean的proxyInterfaces属性被设置为一个或者多个全限定接口名，而proxyTargetClass属性被设置为true仍然将实际使用基于CGLIB的代理。

如果ProxyFactoryBean的proxyInterfaces属性被设置为一个或者多个全限定接口名，一个基于JDK的代理将被创建。被创建的代理将实现所有在proxyInterfaces属性里被说明的接口；如果目标类实现了全部在proxyInterfaces属性里说明的接口以及一些额外接口，返回的代理将只实现说明的接口而不会实现那些额外接口。

如果ProxyFactoryBean的proxyInterfaces属性没有被设置，但是目标类实现了一个（或者更多）接口，那么 ProxyFactoryBean将自动检测到这个目标类已经实现了至少一个接口，一个基于JDK的代理将被创建。被实际代理的接口将是目标类所实现的全部接口；实际上，这和在proxyInterfaces属性中列出目标类实现的每个接口的情况是一样的。然而，这将显著地减少工作量以及输入错误的可能性。

好了, 详细阐述这个解决方案.

用 MyEclipse 的自动生成功能产生的 Spring + Hibernate 的 DAO 有时候会出现不能保存数据但是可以查询数据的问题, 这是因为默认生成的 Spring 配置文件里面没有包含对事务的操作, 也就是没有 commit Hibernate transaction 的调用所以无法保存数据. 也就是正确的调用需要 beginTran, save, commit, 但是现在就少了 tran 的调用代码部分. 因为刚刚接触 Spring 这个 "轻量级" 非侵入框架不久, 所以好多问题不是太熟悉, 最近收集了一些资料看了看总算解决了问题. 有问题不要紧, 只要能通过学习来解决它就可以了, 我个人并不很喜欢没事去精通 XXX 框架, 而是喜欢做一些解决问题和查资料能力的锻炼, 有了后面所提的能力, 不管改天是不是出了个 Winter 框架, 也不会担心落伍, 当然前提是基础知识要牢固, 否则很容易看不懂.

解决方法是在配置文件里"侵入性"(必须这样做, 做额外的配置, 否则就无法正常工作, 所以是侵入性的)的加入事务配置后就可以正常的保存数据到 Derby, Oracle 等数据了:

1. 修改配置文件给原来的 UsersDAO 加入代理类来进行事务管理:

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
value="file:src/hibernate.cfg.xml">

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

保存时没有提交 hibernate 的事务, 这将无法对数据库进行改动, 也就是原来要调用 UsersDAO 的地方都要转而调用这个代理对象 userDAOProxy; 具体的属性配置在 target 参数那里指定了这个对象对原来的 UsersDAO 对象进行代理;
也因为要使用代理, 只有通过它来作为原来配置的 UsersDAO 的代理工作, 才能让 Spring 在保存数据的时候自动打开 Hibernate 的 Transaction 并提交, 即属性 transactionManager 配置的 HibernateTransactionManager –>
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

true

    PROPAGATION_REQUIRED

2. 修改调用代码, 原来调用 UsersDAO 的地方都要转而调用 userDAOProxy, 因为用了 CGLIB, 所以类型转换不会发生异常.
原始代码:
UsersDAO dao = applicationContext.getBean("UsersDAO");
dao.save(users);// 可能无法保存数据, 因为没有事务管理
修改为:
UsersDAO dao = applicationContext.getBean("userDAOProxy");
dao.save(users);// 现在应该 OK 了, 因为事务提交了

MyEclipse生成Spring+Hibernate无法保存数据问题解决方法

阿超 — Wed, 09 Sep 2009 01:40:00 +0000

MyEclipse生成的Spring+Hibernate无法保存数据问题的解决方法

用 MyEclipse 的自动生成功能产生的 Spring + Hibernate 的 DAO 有时候会出现不能保存数据但是可以查询数据的问题, 这是因为默认生成的 Spring 配置文件里面没有包含对事务的操作, 也就是没有 commit Hibernate transaction 的调用所以无法保存数据. 也就是正确的调用需要 beginTran, save, commit, 但是现在就少了 tran 的调用代码部分. 因为刚刚接触 Spring 这个 “轻量级” 非侵入框架不久, 所以好多问题不是太熟悉, 最近收集了一些资料看了看总算解决了问题. 有问题不要紧, 只要能通过学习来解决它就可以了, 我个人并不很喜欢没事去精通 XXX 框架, 而是喜欢做一些解决问题和查资料能力的锻炼, 有了后面所提的能力, 不管改天是不是出了个 Winter 框架, 也不会担心落伍, 当然前提是基础知识要牢固, 否则很容易看不懂.

解决方法是在配置文件里”侵入性”(必须这样做, 做额外的配置和修改, 否则就无法正常工作, 所以是侵入性的)的加入事务配置后就可以正常的保存数据到 Derby, Oracle 等数据了, 也有其它的解决办法, 希望用 Spring 比较早的经验多的人提出建议:

1. 用 Ecipse 的重构给自动生成的 UsersDAO 类添加一个接口, 里面包含所有的方法声明, 例如 IUsersDAO, 加入接口的目的是为了使用 JDK 的动态代理方式实现的 Spring AOP 来工作, 也有另一种解决方案使用 CGLIB 的话就不需要这一步了, 这种方式下一次讨论.

public interface IUsersDAO {

public abstract void save(Users transientInstance);
}

public class UsersDAO extends HibernateDaoSupport implements IUsersDAO {
…
public void save(Users transientInstance) {
log.debug(“saving Users instance”);
try {
getHibernateTemplate().save(transientInstance);
log.debug(“save successful”);
} catch (RuntimeException re) {
log.error(“save failed”, re);
throw re;
}
…
}

2. 修改配置文件给原来的 UsersDAO 加入代理类来进行事务管理:

xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd”>

class=”org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
value=”file:src/hibernate.cfg.xml”>

class=”org.springframework.orm.hibernate3.HibernateTransactionManager”>

保存时没有提交 hibernate 的事务, 这将无法对数据库进行改动, 也就是原来要调用 UsersDAO 的地方都要转而调用这个代理对象 userDAOProxy; 具体的属性配置在 target 参数那里指定了这个对象对原来的 UsersDAO 对象进行代理;
也因为要使用动态代理, 所以这里必须给 UsersDAO 抽象一个接口 IUsersDAO, 只有通过它来作为原来配置的 UsersDAO 的代理工作, 才能让 Spring 在保存数据的时候自动打开 Hibernate 的 Transaction 并提交, 即属性 transactionManager 配置的 HibernateTransactionManager –>
class=”org.springframework.transaction.interceptor.TransactionProxyFactoryBean”>

PROPAGATION_REQUIRED

3. 修改调用代码, 原来调用 UsersDAO 的地方都要转而调用 userDAOProxy, 而且转换后的目标要修改为 IUsersDAO, 否则就会报 ClassCastException, 具体原因参考 Spring 的 AOP 实现部分的内容, 也可以用 cglib 来解决.
原始代码:
UsersDAO dao = applicationContext.getBean(“UsersDAO”);
dao.save(users);// 可能无法保存数据, 因为没有事务管理
修改为:
IUsersDAO dao = applicationContext.getBean(“userDAOProxy”);
dao.save(users);// 现在应该 OK 了, 因为事务提交了

Spring 整合 Hibernate + Mysql 的代码

阿超 — Tue, 08 Sep 2009 22:38:00 +0000

开始用的是 MyEclipse 自带的 Derby 数据库, 发现单独的 Hibernate DAO 没有问题, 一整合 Spring 就插入不了数据, 甚至按照参考资料上的将 HibernateTransactionManager 的加进去也无济于事. 今天换成了 Mysql 就好了, 调试信息全打开也没看到什么出错, 不知原因, 甚是郁闷.

原因已经找到, 事务管理器没加对.具体解决方案请参考:

MyEclipse生成的Spring+Hibernate无法保存数据问题的解决方法

MyEclipse生成的Spring+Hibernate无法保存数据问题的解决方法2 – 用 CGLIB 来实现事务管理

可以新建一个 Java Project 然后添加 Hibernate 和 Spring 开发功能就能测试本文提到的代码了.

建表的 SQL:

CREATE TABLE `usertable` (
  `id` int(11) NOT NULL,
  `username` varchar(200) NOT NULL,
  `password` varchar(20) NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=GBK;

src/TestSpringHibernateDAO.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import entity.Usertable;

import spring_hibernate_dao.UsertableDAO;

public class TestSpringHibernateDAO {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
        "applicationContext.xml");

        UsertableDAO dao = UsertableDAO.getFromApplicationContext(ctx);

        Usertable user = new Usertable();
        user.setId(5);
        user.setUsername("5");
        user.setPassword("5");

        dao.save(user);
    }

}

src/entity/Usertable.java

package entity;

public class Usertable implements java.io.Serializable {

    // Fields

    private Integer id;

    private String username;

    private String password;

    // Constructors

    /** default constructor */
    public Usertable() {
    }

    /** full constructor */
    public Usertable(Integer id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    // Property accessors

    public Integer getId() {
        return this.id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return this.username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return this.password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}

src/entity/Usertable.hbm.xml

src/spring_hibernate_dao/UsertableDAO.java

package spring_hibernate_dao;

import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.LockMode;
import org.springframework.context.ApplicationContext;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import entity.Usertable;

/**
 * Data access object (DAO) for domain model class Usertable.
 *
 * @see spring_hibernate_dao.Usertable
 * @author MyEclipse Persistence Tools
 */

public class UsertableDAO extends HibernateDaoSupport {
    private static final Log log = LogFactory.getLog(UsertableDAO.class);

    // property constants
    public static final String USERNAME = "username";

    public static final String PASSWORD = "password";

    protected void initDao() {
        // do nothing
    }

    public void save(Usertable transientInstance) {
        log.debug("saving Usertable instance");
        try {
            getHibernateTemplate().save(transientInstance);
            log.debug("save successful");
        } catch (RuntimeException re) {
            log.error("save failed", re);
            throw re;
        }
    }

    public void delete(Usertable persistentInstance) {
        log.debug("deleting Usertable instance");
        try {
            getHibernateTemplate().delete(persistentInstance);
            log.debug("delete successful");
        } catch (RuntimeException re) {
            log.error("delete failed", re);
            throw re;
        }
    }

    public Usertable findById(java.lang.Integer id) {
        log.debug("getting Usertable instance with id: " + id);
        try {
            Usertable instance = (Usertable) getHibernateTemplate().get(
                    "spring_hibernate.Usertable", id);
            return instance;
        } catch (RuntimeException re) {
            log.error("get failed", re);
            throw re;
        }
    }

    public List findByExample(Usertable instance) {
        log.debug("finding Usertable instance by example");
        try {
            List results = getHibernateTemplate().findByExample(instance);
            log.debug("find by example successful, result size: "
                    + results.size());
            return results;
        } catch (RuntimeException re) {
            log.error("find by example failed", re);
            throw re;
        }
    }

    public List findByProperty(String propertyName, Object value) {
        log.debug("finding Usertable instance with property: " + propertyName
                + ", value: " + value);
        try {
            String queryString = "from Usertable as model where model."
                    + propertyName + "= ?";
            return getHibernateTemplate().find(queryString, value);
        } catch (RuntimeException re) {
            log.error("find by property name failed", re);
            throw re;
        }
    }

    public List findByUsername(Object username) {
        return findByProperty(USERNAME, username);
    }

    public List findByPassword(Object password) {
        return findByProperty(PASSWORD, password);
    }

    public List findAll() {
        log.debug("finding all Usertable instances");
        try {
            String queryString = "from Usertable";
            return getHibernateTemplate().find(queryString);
        } catch (RuntimeException re) {
            log.error("find all failed", re);
            throw re;
        }
    }

    public Usertable merge(Usertable detachedInstance) {
        log.debug("merging Usertable instance");
        try {
            Usertable result = (Usertable) getHibernateTemplate().merge(
                    detachedInstance);
            log.debug("merge successful");
            return result;
        } catch (RuntimeException re) {
            log.error("merge failed", re);
            throw re;
        }
    }

    public void attachDirty(Usertable instance) {
        log.debug("attaching dirty Usertable instance");
        try {
            getHibernateTemplate().saveOrUpdate(instance);
            log.debug("attach successful");
        } catch (RuntimeException re) {
            log.error("attach failed", re);
            throw re;
        }
    }

    public void attachClean(Usertable instance) {
        log.debug("attaching clean Usertable instance");
        try {
            getHibernateTemplate().lock(instance, LockMode.NONE);
            log.debug("attach successful");
        } catch (RuntimeException re) {
            log.error("attach failed", re);
            throw re;
        }
    }

    public static UsertableDAO getFromApplicationContext(ApplicationContext ctx) {
        return (UsertableDAO) ctx.getBean("UsertableDAO");
    }
}

src/applicationContext.xml

src/hibernate.cfg.xml


  





root



            jdbc:mysql://localhost/test





            org.hibernate.dialect.MySQLDialect





            mysql localhost





            com.mysql.jdbc.Driver

2 分钟用MyEclipse 开发一个 Hibernate 应用

阿超 — Sat, 05 Sep 2009 11:21:00 +0000

用 MyEclipse, 就有必要把 MyEclipse 快速开发的功能熟悉一下. 当我们熟悉了基本的开发过程之后, 就需要考虑用顺手的 IDE 来让我们的开发速度有个飞跃了.

这次讨论的主题包括: Hibernate 快速开发, Spring 快速开发, Struts 登录应用开发, UML 建模, 可视化Swing界面开发这些个内容.

首先就是大家可以看 MyEclipse 的帮助文档进行学习了, 里面很全, 图文并茂, 唯一缺点呢就是文档是英文的. 具体方法:
菜单 Help -> Help Contents, 然后会在浏览器里打开 MyEclipse 帮助文档, 展开左边的 MyEclipse Learning Center, 就能看到详细的开发教程了. 其中 "JEE Application Development" 的部分是我们重点关注的内容.

使用的开发工具是 MyEclipse 5.5.1 GA, Windows/Linux 版本均可.

好了, 现在简单介绍一下用 MyEclipse 2 分钟开发一个 Hibernate 应用的步骤.
1. 在 MyEclipse 视图下的 Servers 面板上, 启动 MyEclipse Derby 这个服务器. 相信大家都很熟悉这个过程了.
2. 选择菜单 Window -> Open Persipective -> MyEclipse Database Explorer, 打开新的数据库浏览视图.
3. 在最左边的 DB Browser 面板下选中 MyEclipse Derby 项, 点击右键并选择弹出菜单中的菜单项 Open Connection 来打开数据库连接并显示所有的数据库和表格.
4. 展开 MyEclipse Derby 节点, 单击选中第一项 Connected to MyEclipse Derby, 点击右键并选择弹出菜单中的菜单项 New SQL Editor.
5. 在 SQL 编辑器里键入下列建表语句:
create table testUser(
id int not null,
username varchar(200),
age int,
primary key ("ID")
)
, 然后点击编辑器上面的绿色的运行向右箭头按钮来创建表格.
6. 新建一个 Java Project 名字为 MyHibernateTest, 这个过程无需赘述了, 建议建项目的时候将 src 目录和 bin(或者classes)目录分开, 另外提示你切换透视图的时候一定要切换过去到 Java 透视图, 此时默认会在 Package Explorer 中选中刚才已经建好的 Java Project, 但是背景为灰色.
7. 首先单击一下左边的 Package Explorer 中新建的 MyHibernateTest 项目来使其高亮选中, 接着点击菜单项 MyEclipse -> Add Hibernate Capabilities…, 接着会弹出对话框 New Hibernate Project 提示你设置当前项目的 Hibernate 属性.
对话框的第一页选择 Hibernate 3.1, 其它保持默认;
第二页同样如此, 保持默认来创建新的 Hibernate 配置文件;
第三页Specify Hibernate database connection details则点击 DB Driver 下拉框选择 MyEclipse Derby, 这时候下面的输入框会自动填好数据库连接对应的值.
第四页 Define SessionFactory properties 则先点击 Java Package 一行最右侧的 New… 按钮来新建一个名字为 dao 的包. 这时候你可以看到 Finish 按钮终于不为灰色了, 点击它完成给项目加入 Hibernate 开发功能的操作, 包括 Hibernate 类库, jdbc 驱动和 Hibernate 配置文件都已经设置完毕了.
8. 选择菜单 Window -> Open Persipective -> MyEclipse Database Explorer, 打开数据库浏览视图. 展开 Connected to MyEclipse Derby 下面的 APP 节点, 再选中下面的 TABLE 目录, 点击右键并选择弹出菜单中的菜单项 Refresh 来刷新数据库表格列表, 这时候展开此节点可以看到下面出现了一个名为 TESTUSER 的表.
9. OK, 最关键的操作即将开始了. 请在 TESTUSER 节点上点击右键并选择弹出菜单中的菜单项 Hibernate Reverse Engineering…, 弹出一个对话框提示你 Save All Modified Resources, 点击 OK 并且选中 MyHibernateTest, 在 File name 右侧的文件名输入框中输入 create.sql 来保存我们最开始所写的那个建表的 SQL 文件.
10. 接着 Hibernate Reverse Engineering 对话框弹出了.
点击 Java src folder 一行最右侧的 Browser.. 按钮来选择源码目录, 并把下面的 Java package 右侧的输入框中输入包名 dao, 我们选择 /MyHibernateTest/src 目录并点击完成, 接着选中下面的三个复选框:
[x] Hibernate mapping file (*.hbm.xml) for each database table
[x] Java Data Object (POJO <> DB Table)
[x] Java Data Access Object (DAO) (Hibernate 3 only)

好了, 点击 Finish 按钮, 就可以看到反向工程的忙碌对话框. 最后当一切结束后弹出对话框提示切换视图到 MyEclipse Hibernate perspective 的时候点击 "OK" 按钮, 您就可以看到工作成果了, 包括下列文件:
HibernateSessionFactory.java
Testuser.hbm.xml
BaseHibernateDAO.java
IBaseHibernateDAO.java
Testuser.java
TestuserDAO.java
hibernate.cfg.xml
. 那么, 我们的 POJO 已经生成了, 就是 Testuser.java, DAO 的代码也已经生成, 就是 TestuserDAO, 这些代码都已经帮我们写好, 当然我们可以做进一步的修改来适应我们的要求. 当你用工具生成代码的时候, 请确保您已经了解了 Hibernate 手工开发的步骤. 好了, 接下来的事情, 我们就可以
11. 修改 Testuser.hbm.xml 里面的主键生成方式为合适的方式(默认的是 ), 或者一些属性映射关系, 这些仍然要求开发人员对 Hibernate 的配置文件有一定的了解;
或者
12. 继续重复 1, 3, 5, 8, 9, 10 来生成更多的 POJO 或者 DAO.
13. 编写测试代码来运行测试.

小结: 虽然这些步骤很繁琐, 但是当你熟练之后完全可以在2分钟内完成所有操作, 这样就省去了手工编写大量 Java 代码和 XML 配置文件的痛苦, 这也是实际中程序员采取的偷懒的步骤.
前提: 您一定要理解 Hibernate 手工开发的步骤和 JDBC 驱动的概念, 否则生成的文件有时候是有潜在的问题的, 工具只能帮你完成部分工作, 不能完成全部工作.

更多提示: 当你执行第 9 步的时候, 还可以看到弹出的菜单中有 JPA 和 EJB 3 反向工程的选项, 这个就留给大家做练习了, 同样也能生成类似的 JPA 或者 EJB 3 实体类, 当然您实现要建好支持 JPA 或者 EJB 的项目.

Hibernate 分页的设计和编码

阿超 — Sat, 05 Sep 2009 10:19:00 +0000

分页的设计和编码, 代码下载请访问: Hibernate + JSP 分页代码

1. 当前页码的表单参数 listuser.do?page=2
    同时转换成一个 int 类型的页码变量
    int currentPage = Integer.parseInt(
        request.getParameter("page");// 当前页

2. 下一页 listuser.do?page=${currentPage+1}
   上一页 listuser.do?page=${currentPage-1}
3. 一页显示多少数据
    int pageSize = 5;//每页显示的数据数
4. 总页数 totalPage
    1) 先从数据库取得总记录数
    dao.UserDAO#getUserTotalCount()
        int totalCount = executeQuery("select count(*) from Users");
    2) 根据一页的数据类计算出总页数
        dao.UserManager#getTotalPage(int pageSize)
           // 得到页面总数
        int totalPageCount = ((totalCount + pageSize) – 1) / pageSize;

        if(totalPageCount == 0) {
            totalPageCount = 1;
        }
5. 从数据库里把第currentPage页的数据读取出来(Hibernate), DAO 层的代码
dao.UserDAO#findPagedAll(int currentPage, int pageSize)

两个参数: currentPage 当前页(从1开始的)

                pageSize 取多少数据
    String queryString = "from User";
    Query queryObject = getSession().createQuery(queryString);

queryObject.setFirstResult((currentPage – 1) * pageSize);
queryObject.setMaxResults(pageSize);

List result = queryObject.list();

6. 在前台显示上下页的链接,并根据总页数的上下限来避免让用户跳到第-1页或者比最大页数还大的页码哪里

       [ 上一页的链接 ]


       [ 上一页的文本 ]

7. 通过 forEach 来显示数据

${user.id}
${user.username}

8. 通过下拉菜单来跳转页面

转到

Hibernate + JSP 分页代码开发

阿超 — Sat, 05 Sep 2009 09:15:00 +0000

下载后导入项目到 MyEclipse , 然后修改数据库连接参数即可测试. 我这用的是 MySQL 数据库. 用 JSP 是因为 Hibernate 可以配合各种框架, 因此在代码里我已经尽量的把页面和后台的直接变量耦合分隔开了.
hibernate_page
部分代码显示:

spring+hibernate避免延迟加载异常OpenSessionInViewFilter(no session)

阿超 — Sat, 05 Sep 2009 08:09:00 +0000

在hibernate中，延迟加载是1个非常大的优点，但有时候却给我们带来一些小麻烦，在后台查询结束后，session已经关闭，但在前台显示的时候，如果存在关联关系就会产生延迟加载异常。
解决办法是客户端每次请求就分配1个session,将请求结果返回给客户端，并完成展现后关闭session。
实现这个功能非常简单，在web.xml中加入以下配置


        hibernateFilter

              org.springframework.orm.hibernate3.support.OpenSessionInViewFilter 

      

          singleSession

          true

      





      hibernateFilter

      *.do

使用spring提供这个过滤器就可以实现session的集中管理了，所有以.do结尾的请求都自动分配了1个session,并且在这个请求过程中都使用这个session.

hibernate3出现could not initialize proxy – no Session

阿超 — Wed, 02 Sep 2009 11:37:00 +0000

hibernate3出现could not initialize proxy – no Session 错误的解决办法以及lazy load的介绍

异常：
org.hibernate.LazyInitializationException: could not initialize proxy – no Session
at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:57)
at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:111)
原因：hibernate3 many-to-one的默认选项是 lazy = "proxy"
解决方法： & 中设置 lazy="false"

HIBERNATE的持久化对象加载策略。
延迟加载, 也就是用到的时候才去加载.这样可以提高一些性能.
Hibernate的lazy loading 采用了一个HibernateSession来管理session，它的逻辑是每进行一次数据库操作，就开新的session，操作完成后立即关闭该session。这样做的好处是可以严格关闭session，避免菜鸟级的错误，但是hibernate.org并不推荐这么做。因为这不适合lazy loading，也不适合跨方法的事务。
比如在我们的应用中，user->post形成一对多的映射，User中有一个包含post的List。
在User中，有多个属性：name，password，phone等，还有一个List类型的posts。当我们对posts使用lazy laoding的时候，hibernate会在获得User对象的时候，仅仅返回name,password,phone等基本属性，当你访问posts的时候，它才会从数据库中提取posts需要的数据，这就是所谓lazy laoding。但是在我们的系统中，session是被立即关闭的，也就是在读取了name,password,phone等基本属性后，session已经close了，再进行lazy loaiding就会有异常。
解决办法是在close session之前，调用Hibernate.initialize(user.getPosts())，告诉系统，user.getPosts()是需要lazy laoding的。但是这样做会破坏HibernateSession类的封装.
后来采用所谓的OpenSessionInView模式，把session的周期交给servlet filter来管理，每当有request进来，就打开一个session，response结束之后再关闭它，这样可以让session存在于整个请求周期中。

Hibernate中Lazy延迟加载
Hibernate有关one-to-one和many-to-one在查询中的父亲端lazy问题
Hibernate3 在关联上有lazy这个属性，如果是Hibernate2，应该是设置outer-join="false"，然后被关联的对象，在class那个地方设置lazy="true".首先，对于many-to-one的问题，可以在父亲端的class标签中设置lazy来解决，这样，在查询儿子的时候，不会发送多余的sql .
对于one-to-one，在hibernate2里面，由于one-to-one里面没有lazy的选项，所以只能通过设置outer-join="false"来解决。而hibernate3已经加入了lazy，所以不会有这个问题。
总体来说，如果你发现你查询儿子的时候，有多余的sql发送，那一定是你对hibernate的误用..

在hibernate 的one-to-many,many-to-one,many-to-many中，为了效率的提高，我们一般都采用lazy机制，但使用spring的 getHibernateTemplate().save(Object)时，HibernateTemplate试图每次在execute之前去获得 Session，执行完就力争关闭Session 。也就是说Hibernate的Lazy初始化1:n关系时，你必须保证是在同一个Session内部使用这个关系集合，不然Hiernate将抛出 Failed to lazily initialize a collection – no session or session was closed的例外。

Hibernate 中的对象的关联(association)的设置还是不够灵活，实际应用中有的地方需要lazy load，有的地方又不需要，其实还有的地方就根本不需要使用association。而在Hibernate中，只能在影射文件中设置一种方式，像我们这样的应用，我是不敢轻易使用open session in view的(慢点总比lock住要好)，只能是要么不设置association，要么就是lazy=true的。以前的分类信息只用了一个many to one的关系，代价还可以忍受，但现在关系越来越复杂了，再多加几个的话，所要付出的performance，带宽等方面的代价恐怕就不能忽略了,即使使用cache提高一点performance，对带宽的浪费也还是不可原谅的。

Spring hibernate使用方法整理@Component(五)

阿超 — Wed, 02 Sep 2009 10:31:00 +0000

虽然我们可以通过 @Autowired 在 Bean 类中使用自动注入功能，但是 Bean 还是在 applicatonContext.xml 文件中通过进行定义 —— 在前面的例子中，我们还是在配置文件中定义 Bean，通过 @Autowired为 Bean 的成员变量、方法形参或构造函数形参提供自动注入的功能。
那么能不是也可以通过注解定义 Bean，从 XML 配置文件中完全移除 Bean 定义的配置呢？
答案是肯定的，我们通过 Spring 5 提供的 @Component 注释就可以达到这个目标了。
修改Bean的java类的代码如下，在类名前面加上 @Component注解

    package com.firemax.test.service;
      import java.util.ArrayList;

    import java.util.Iterator;

    import java.util.List;

    import org.apache.commons.logging.Log;

    import org.apache.commons.logging.LogFactory;

    import org.dom4j.Document;

   import org.dom4j.DocumentHelper;

   import org.dom4j.Element;

   import org.springframework.beans.factory.annotation.Autowired;

   import org.springframework.stereotype.Component;

   import com.firemax.test.hibernate.AlcorTCitys;

   import com.firemax.test.hibernate.AlcorTCitysDAO;

   import com.firemax.test.hibernate.AlcorTCountries;

   import com.firemax.test.hibernate.AlcorTCountriesDAO;

   import com.firemax.test.hibernate.AlcorTProvinces;

   import com.firemax.test.hibernate.AlcorTProvincesDAO;

   import com.firemax.test.hibernate.AlcotTDistrict;

   import com.firemax.test.hibernate.AlcotTDistrictDAO;

   @Component

   public class CountryService {

       private static Log logger = LogFactory.getLog(CountryService.class);

       @Autowired

       private AlcorTCountriesDAO  alcorTCountriesDAO;

       @Autowired

       private AlcorTProvincesDAO  alcorTProvincesDAO;

       @Autowired

       private AlcorTCitysDAO          alcorTCitysDAO;

       @Autowired

       private AlcotTDistrictDAO       alcotTDistrictDAO;

       public CountryService(){

       }

        //这里是业务逻辑的方法

        。。。。。

   }

然后，我们修改配置文件applicatonContext.xml中，启用自动注入的功能，而放弃原来的方式的配置

http://www.springframework.org/schema/beans”

xmlns:context=”http://www.springframework.org/schema/context”

xmlns:xsi=”http://www.worg/2001/XMLSchema-instance”

xmlns:tx=”http://www.springframework.org/schema/tx”

xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-xsd”

default-autowire=”autodetect”>

class=”org.springframework.orm.jpa.LocalEntityManagerFactoryBean”>

class=”org.springframework.transaction.interceptor.TransactionInterceptor”>

PROPAGATION_REQUIRED

PROPAGATION_REQUIRED,readOnly

PROPAGATION_REQUIRED

所简化

–>

配置项不但启用了对类包进行扫描以实施注释驱动 Bean 定义的功能，同时还启用了注释驱动自动注入的功能（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor），因此当使用后，就可以将移除了。 –>

class=”org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator”>

*Service

transactionInterceptor

–>

新的applicaitonContext.xml 配置文件中蓝色的部分就是原来的的注入方式，现在已经给屏蔽了。不需要再写。而红色部分就是使用了，让spirng自动搜索，然后注入。

注意：

* 这里注入的bean 的名称是按照类的名称，把第一个字母改成小写来命名的。比如例子中的CountryService的bean的名称就是countryService.

* 我们也可以通过@Component(“countryService”) 这种方式来显示的定义一个bean的注入名称。但是在大多数情况下没有必要。

的 base-package 属性指定了需要扫描的类包，类包及其递归子包中所有的类都会被处理。

还允许定义过滤器将基包下的某些类纳入或排除。Spring 支持以下 4 种类型的过滤方式，通过下表说明：

扫描过滤方式

过滤器类型说明

注释假如 com.firemax.test.SomeAnnotation 是一个注释类，我们可以将使用该注释的类过滤出来。

类名指定通过全限定类名进行过滤，如您可以指定将 com.firemax.test.IncludeService纳入扫描，而将 com.firemax.test.NotIncludeService 排除。

正则表达式通过正则表达式定义过滤的类，如下所示： com\.firemax\.test\.Default.*

AspectJ 表达式通过 AspectJ 表达式定义过滤的类，如下所示： com. firemax.test..*Service+

下面是一个简单的例子：

默认情况下通过 @Component 定义的 Bean 都是 singleton 的，如果需要使用其它作用范围的 Bean，可以通过 @Scope 注释来达到目标，如以下代码所示：

通过 @Scope 指定 Bean 的作用范围

    package com.firemax.tester.service;
      import org.springframework.context.annotation.Scope;

    …

    @Scope("prototype")

    @Component("countryService")

    public class CountryService{

        …

    }

这样，当从 Spring 容器中获取 boss Bean 时，每次返回的都是新的实例了。

在Spring5中引入了更多的典型化注解，@Repository ，@Service，@Controler是@Component的细化。分别表示持久层，服务层，控制层。建议使用这个注解来取代@Component

附上一个java Applicaiton的简单测试程序

    /*
       * Created on 2008-9-28

     *

     */

    package com.firemax.test.tester;

    import java.util.Iterator;

   import org.springframework.context.ApplicationContext;

   import org.springframework.context.support.FileSystemXmlApplicationContext;

   import com.firemax.test.hibernate.AlcorTCitys;

   import com.firemax.test.hibernate.AlcorTCitysDAO;

   import com.firemax.test.hibernate.AlcorTCountries;

   import com.firemax.test.hibernate.AlcorTProvinces;

   import com.firemax.test.hibernate.AlcotTDistrict;

   import com.firemax.test.hibernate.AlcotTDistrictDAO;

   import com.firemax.test.service.CountryService;

   public class Tester {

       /**

        * @param args

        */

       public static void main(String[] args) throws Exception{

           // TODO Auto-generated method stub

           ApplicationContext ctx =     new FileSystemXmlApplicationContext("/WebContent/WEB-INF/classes/applicationContext*.xml");

           String[] beans = ctx.getBeanDefinitionNames();

           for (int i = 0 ; i < beans.length;i++)

           {

               System.out.println(beans[i]);

           }

           CountryService countryService= (CountryService)ctx.getBean("countryService");

           AlcorTCountries  alcorTCountries= countryService.getCountriesInfo("CN");

           System.out.println(alcorTCountries.getCountry());

           System.out.println("开始调用子类");

           System.out.println(alcorTCountries.getAlcorTProvinceses().size());

           Iterator it = alcorTCountries.getAlcorTProvinceses().iterator();

           while (it.hasNext()){

               AlcorTProvinces  alcorTProvinces= (AlcorTProvinces)it.next();

               System.out.println(alcorTProvinces.getProvinceName());

           }

           AlcotTDistrict alcotTDistrict= new AlcotTDistrict();

           alcotTDistrict.setDistrictCode("22");

           alcotTDistrict.setDistrictName("浦东");

           AlcorTCitys alcorTCitys =countryService.getCityInfo("021");

           alcotTDistrict.setAlcorTCitys(alcorTCitys);

           countryService.saveProvinces(alcotTDistrict);

       }

   }

在所有的JPOPO中，我们可以使用@Entity 这个注解来注入 JOPO。这样我们在 Persistent.xml中就不需要在定义哪些POJO的类了。

感谢 JPA 感谢Spring ，终于不要频繁的去定义和修改这些Bean了

Spring JPA hibernate 使用方法整理（四)命名空间

阿超 — Wed, 02 Sep 2009 09:27:00 +0000

在（三）里面。我们引入了其实在spring 里面还有其他三个BeanPostProcessor 。总共有四个，分别是：
AutowiredAnnotationBeanPostProcessor
CommonAnnotationBeanPostProcessor
PersistenceAnnotationBeanPostProcessor
equiredAnnotationBeanPostProcessor

但是直接在 Spring 配置文件中定义这些 Bean 显得比较笨拙。Spring 为我们提供了一种方便的注册这些 BeanPostProcessor 的方式，这就是

Spring 1 添加了一个新的 context 的 Schema 命名空间，该命名空间对注释驱动、属性文件引入、加载期织入等功能提供了便捷的配置。我们知道注释本身是不会做任何事情的，它仅提供元数据信息。要使元数据信息真正起作用，必须让负责处理这些元数据的处理器工作起来。

这段代码就是启用了这个命名空间后的applicationContext.xml文件

xmlns:context=”http://www.springframework.org/schema/context”
xmlns:xsi=”http://www.worg/2001/XMLSchema-instance”
xmlns:tx=”http://www.springframework.org/schema/tx”
xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-xsd”
>
class=”org.springframework.orm.jpa.LocalEntityManagerFactoryBean”>

class=”org.springframework.transaction.interceptor.TransactionInterceptor”>

PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED,readOnly

PROPAGATION_REQUIRED,readOnly

PROPAGATION_REQUIRED,readOnly

PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED

所简化

–>

class=”org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator”>

*Service

transactionInterceptor

注意2段标红的内容，就是这次更新的配置内容。在配置文件中使用 context 命名空间之前，必须在元素中声明 context 命名空间。

Spring hibernate使用方法整理@Autowired(三)

阿超 — Wed, 02 Sep 2009 08:25:00 +0000

通过前两篇文章的介绍。我们已经做了初步的简化程序。
但是在我们编写spring 框架的代码时候。一直遵循是这样一个规则：所有在spring中注入的bean 都建议定义成私有的域变量。并且要配套写上 get 和 set方法。虽然可以通过eclipse等工具来自动生成。但是还是会引起程序阅读性上的不便。那么既然注解这么强大。是否可以也把他精简掉呢？

当然可以。这个标签就是@Autowired

Spring 5 引入了 @Autowired 注释，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。

要实现我们要精简程序的目的。需要这样来处理：

* 在applicationContext.xml中加入：

* 修改在原来注入spirng容器中的bean的方法。在域变量上加上标签@Autowired,并且去掉相应的get 和set方法
/*国家，省份，城市，城区信息维护服务
* Created on 2008-9-26
*
* 徐泽宇 roamer
*/
package com.firemax.test.service;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.springframework.beans.factory.annotation.Autowired;
import com.firemax.test.hibernate.AlcorTCitys;
import com.firemax.test.hibernate.AlcorTCitysDAO;
import com.firemax.test.hibernate.AlcorTCountries;
import com.firemax.test.hibernate.AlcorTCountriesDAO;
import com.firemax.test.hibernate.AlcorTProvinces;
import com.firemax.test.hibernate.AlcorTProvincesDAO;
import com.firemax.test.hibernate.AlcotTDistrict;
import com.firemax.test.hibernate.AlcotTDistrictDAO;
public class CountryService {
private static Log logger = LogFactory.getLog(CountryService.class);
@Autowired
private AlcorTCountriesDAO alcorTCountriesDAO;
@Autowired
private AlcorTProvincesDAO alcorTProvincesDAO;
@Autowired
private AlcorTCitysDAO alcorTCitysDAO;
@Autowired
private AlcotTDistrictDAO alcotTDistrictDAO;
public CountryService(){
}
/**修改一个国家信息
* @param alcorTCountries
* @throws Exception
*/
public void updateCountry(AlcorTCountries alcorTCountries ) throws Exception{
this.alcorTCountriesDAO.update(alcorTCountries);
}
….
//这里去掉了哪些DAO 变量的get 和set 方法。
}

* 在applicatonContext.xml中把原来引用的标签也去掉。

修改成

当然，我们也可以在构造函数上使用@Auwowired 注解。如果构造函数有两个入参，分别是 bean1 和 bean2，@Autowired 将分别寻找和它们类型匹配的 Bean，将它们作为 CountryService (Bean1 bean1 ,Bean2 bean2) 的入参来创建 CountryService Bean。

在运行一下你的业务程序。如果没有错误。恭喜你。这个步骤我们又完成了。

Spring 2.5 JPA hibernate 使用方法的整理（二）

阿超 — Wed, 02 Sep 2009 07:22:00 +0000

通过上面一步骤。我们简化了hibernate中扰人的 xxxxx.hbm.xml文件。那么是否可以再进行简化呢？
那么，我们在这一步骤的目的，就是把整个 hibernate.cfg.xml都给简化了。

依然是利用注解注入的方式。通过jpa 我们可以把 hibernate.cfg.xml中那些 mapping classes再次简化与无形。

    在applicationContext.xml中进行如下配置

                        xmlns:xsi="http://www.worg/2001/XMLSchema-instance"
              xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-xsd"
              xmlns:tx="http://www.springframework.org/schema/tx">
                                class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">






                              class="org.springframework.transaction.interceptor.TransactionInterceptor">







                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED,readOnly

                         PROPAGATION_REQUIRED,readOnly

                         PROPAGATION_REQUIRED,readOnly

                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED




                              class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">



                         *Service






                         transactionInterceptor

注意红色部分。这部分和（一）里面提到的那个applicationContext.xml中使用的bean是不同的。这里面已经用到了spring 的jpa部分。
其中是指向了一个 jpa的PU（Persistent Units）

      那么这个是在哪里定义的呢？
      这里的定义是在你的 classes（src）目录下META-INF下的persistence.xml文件中来定义
      persistence.xml文件内容如下：

                        xmlns:xsi="http://www.worg/2001/XMLSchema-instance"
              xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_xsd"
              version="0">
                                transaction-type="RESOURCE_LOCAL">
                 org.hibernate.ejb.HibernatePersistence
                 com.firemax.test.hibernate.AlcorTCountries
                 com.firemax.test.hibernate.AlcorTProvinces
                 com.firemax.test.hibernate.AlcotTDistrict
                 com.firemax.test.hibernate.AlcorTCitys

                                              value="com.mysql.jdbc.Driver" />
                                              value="jdbc:mysql://localhost:3306/alcorweb?useUnicode=true&characterEncoding=utf-8" />
                                              value="alcorweb" />
                                              value="alcorweb" />

仔细观察他的代码，我们发现其实和hibernate.cfg.xml和相似。都有指向pojo的定义和 database连接的定义。先别着急。我们这次的优化，就先完成这个目标。主要是引入的spring的jpa框架。
后面将介绍更进一步的优化。来展示jpa 和注释注入的能力。

Spring 2.5 JPA hibernate 使用方法整理(一)

阿超 — Wed, 02 Sep 2009 06:21:00 +0000

以下几篇文章简单的介绍一下jpa 和 spring5 hibernate2 整合配置的一个过程。纯粹个人经验只谈。如果有错误，请各位留言指出。

本系列重点是涉及配置过程，对注释的用法不多介绍。

注释语法越来越多的被业界所使用,并且注释配置相对于 XML 配置具有很多的优势：它可以充分利用 Java 的反射机制获取类结构信息，这些信息可以有效减少配置的工作。注释和 Java 代码位于一个文件中，而 XML 配置采用独立的配置文件，大多数配置信息在程序开发完成后都不会调整，如果配置信息和 Java 代码放在一起，有助于增强程序的内聚性。而采用独立的 XML 配置文件，程序员在编写一个功能时，往往需要在程序文件和配置文件中不停切换，这种思维上的不连贯会降低开发效率。因此在很多情况下，注释配置比 XML 配置更受欢迎，注释配置有进一步流行的趋势。Spring 5 的一大增强就是引入了很多注释类，现在您已经可以使用注释配置完成大部分 XML 配置的功能。

首先，我们已经通过传统的spring +hibernate方式构架成功了一个应用的后台体系。
这个体系里面有这样几个重要的配置文件。

    hibernate.cfg.xml 。
      里面通过配置 mapping来指向每张数据表单生成配置文件.xxxx.hbm.xml文件
    applicaitonContex.xml。
      里面通过定义一个一个bean 来配置各个需要用到的 DAO 和 Service。

          http://www.springframework.org/dtd/spring-beans.dtd">

                                class="org.springframework.orm.hibernateLocalSessionFactoryBean">
                                        value="classpath:hibernate.cfg.xml">















                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED,readOnly
                         PROPAGATION_REQUIRED,readOnly
                         PROPAGATION_REQUIRED,readOnly
                         PROPAGATION_REQUIRED
                         PROPAGATION_REQUIRED,readOnly




                  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">



                 *Service






         transactionInterceptor



                              class="com.firemax.manatee.hibernate.McCityInfoDAO">




                              class="com.firemax.manatee.hibernate.McMaterialInfoDAO">





      hibernate.cfg.xml要配置这么多 xxxxx.hbm.xml文件。每次数据结构发生变化的时候。要重新去改写pojo和dao以及这些xxxxx.hbm.xml
      那么好。我们现在就用注解的力量去把这部分工作简化。

* 首先我们需要

    hibernate2 以上版本的jar
    jdk 5 以上的环境
    spring2

* 然后我们修改pojo的java类。加上注解。使起通过注解来取代原先要xxxx.hbm.xml里面配置的指向的数据库表单结构的信息。

    package com.alcor.web.hibernate;
    import java.util.HashSet;
    import java.util.Set;
    import javax.persistence.CascadeType;
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.FetchType;
    import javax.persistence.Id;
   import javax.persistence.JoinColumn;
   import javax.persistence.ManyToOne;
   import javax.persistence.OneToMany;
   import javax.persistence.Table;
   /**
    * AlcorTCitys entity. @author MyEclipse Persistence Tools
    */
   @Entity
   @Table(name = "alcor_t_citys", catalog = "alcorweb")
   public class AlcorTCitys implements java.io.Serializable {
       // Fields
       private String cityCode;
       private AlcorTProvinces alcorTProvinces;
       private String cityName;
       private Set alcotTDistricts = new HashSet(0);
       // Constructors
       /** default constructor */
       public AlcorTCitys() {
       }
       /** minimal constructor */
       public AlcorTCitys(String cityCode, AlcorTProvinces alcorTProvinces,
               String cityName) {
           this.cityCode = cityCode;
           this.alcorTProvinces = alcorTProvinces;
           this.cityName = cityName;
       }
       /** full constructor */
       public AlcorTCitys(String cityCode, AlcorTProvinces alcorTProvinces,
               String cityName, Set alcotTDistricts) {
           this.cityCode = cityCode;
           this.alcorTProvinces = alcorTProvinces;
           this.cityName = cityName;
           this.alcotTDistricts = alcotTDistricts;
       }
       // Property accessors
       @Id
       @Column(name = "city_code", unique = true, nullable = false, length = 32)
       public String getCityCode() {
           return this.cityCode;
       }
       public void setCityCode(String cityCode) {
           this.cityCode = cityCode;
       }
       @ManyToOne(fetch = FetchType.EAGER)
       @JoinColumn(name = "province_code", nullable = false)
       public AlcorTProvinces getAlcorTProvinces() {
           return this.alcorTProvinces;
       }
       public void setAlcorTProvinces(AlcorTProvinces alcorTProvinces) {
           this.alcorTProvinces = alcorTProvinces;
       }
       @Column(name = "city_name", nullable = false, length = 64)
       public String getCityName() {
           return this.cityName;
       }
       public void setCityName(String cityName) {
           this.cityName = cityName;
       }
       @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = "alcorTCitys")
       public Set getAlcotTDistricts() {
           return this.alcotTDistricts;
       }
       public void setAlcotTDistricts(Set alcotTDistricts) {
           this.alcotTDistricts = alcotTDistricts;
       }
   }

* 修改hibernate.cfg.xml中的定义方式，把原来的maping source=“xxxxx.hbm.xml”修改成

这样我们就可以把原来的 xxxxx.hbm.xml全部删除了。
经过这个步骤。如果你原有的servcice层的功能能够正常使用。恭喜你。迈出了成功的第一步。

Spring 2.5 JPA hibernate 使用方法整理(六)

阿超 — Wed, 02 Sep 2009 05:18:00 +0000

一、实体 Bean

每个持久化POJO类都是一个实体Bean, 通过在类的定义中使用 @Entity 注解来进行声明。

声明实体Bean

@Entity
public class Flight implements Serializable {
Long id;
@Id
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
}

@Entity 注解将一个类声明为实体 Bean, @Id 注解声明了该实体Bean的标识属性。

Hibernate 可以对类的属性或者方法进行注解。属性对应field类别，方法的 getXxx()对应property类别。

定义表

通过 @Table 为实体Bean指定对应数据库表，目录和schema的名字。

@Entity
@Table(name=”tbl_sky”)
public class Sky implements Serializable {

…

@Table 注解包含一个schema和一个catelog 属性，使用@UniqueConstraints 可以定义表的唯一约束。

@Table(name=”tbl_sky”,
uniqueConstraints = {@UniqueConstraint(columnNames={“month“, “day”})}
)

上述代码在 “month” 和 “day” 两个 field 上加上 unique constrainst.

@Version 注解用于支持乐观锁版本控制。

@Entity
public class Flight implements Serializable {
…
@Version
@Column(name=”OPTLOCK”)
public Integer getVersion() { … }
}

version属性映射到 “OPTLOCK” 列，entity manager 使用这个字段来检测冲突。一般可以用数字或者 timestamp 类型来支持 version.

实体Bean中所有非static 非 transient 属性都可以被持久化，除非用@Transient注解。

默认情况下，所有属性都用 @Basic 注解。

public transient int counter; //transient property

private String firstname; //persistent property
@Transient
String getLengthInMeter() { … } //transient property
String getName() {… } // persistent property
@Basic
int getLength() { … } // persistent property
@Basic(fetch = FetchType.LAZY)
String getDetailedComment() { … } // persistent property
@Temporal(TemporalType.TIME)
java.util.Date getDepartureTime() { … } // persistent property
@Enumerated(EnumType.STRING)
Starred getNote() { … } //enum persisted as String in database

上述代码中 counter, lengthInMeter 属性将忽略不被持久化，而 firstname, name, length 被定义为可持久化和可获取的。

@TemporalType.(DATE,TIME,TIMESTAMP) 分别Map java.sql.(Date, Time, Timestamp).

@Lob 注解属性将被持久化为 Blog 或 Clob 类型。具体的java.sql.Clob, Character[], char[] 和 java.lang.String 将被持久化为 Clob 类型. java.sql.Blob, Byte[], byte[] 和 serializable type 将被持久化为 Blob 类型。

@Lob
public String getFullText() {
return fullText; // clob type
}

@Lob
public byte[] getFullCode() {
return fullCode; // blog type
}

@Column 注解将属性映射到列。

@Entity
public class Flight implements Serializable {
…
@Column(updatable = false, name = “flight_name”, nullable = false, length=50)
public String getName() { … }

定义 name 属性映射到 flight_name column, not null, can’t update, length equal 50

@Column(
name=”columnName”; (1) 列名
boolean unique() default false; (2)    是否在该列上设置唯一约束
boolean nullable() default true; (3)   列可空？
boolean insertable() default true; (4) 该列是否作为生成 insert语句的一个列
boolean updatable() default true; (5) 该列是否作为生成 update语句的一个列
String columnDefinition() default “”; (6) 默认值
String table() default “”; (7)             定义对应的表（deault 是主表）
int length() default 255; (8)              列长度
int precision() default 0; // decimal precision (9) decimal精度
int scale() default 0; // decimal scale        (10) decimal长度

嵌入式对象（又称组件）也就是别的对象定义的属性

组件类必须在类一级定义 @Embeddable 注解。在特定的实体关联属性上使用 @Embeddable 和 @AttributeOverride 注解可以覆盖该属性对应的嵌入式对象的列映射。

@Entity
public class Person implements Serializable {
// Persistent component using defaults
Address homeAddress;
@Embedded
@AttributeOverrides( {
@AttributeOverride(name=”iso2″, column = @Column(name=”bornIso2″) ),
@AttributeOverride(name=”name”, column = @Column(name=”bornCountryName”) )
} )
Country bornIn;
…
}

@Embeddable
public class Address implements Serializable {
String city;
Country nationality; //no overriding here
}

@Embeddable
public class Country implements Serializable {
private String iso2;
@Column(name=”countryName”) private String name;
public String getIso2() { return iso2; }
public void setIso2(String iso2) { this.iso2 = iso2; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
…
}

Person 类定义了 Address 和 Country 对象，具体两个类实现见上。

无注解属性默认值：

• 属性为简单类型，则映射为 @Basic

• 属性对应的类型定义了 @Embeddable 注解，则映射为 @Embedded

• 属性对应的类型实现了Serializable,则属性被映射为@Basic并在一个列中保存该对象的serialized版本。

• 属性的类型为 java.sql.Clob or java.sql.Blob, 则映射到 @Lob 对应的类型。

映射主键属性

@Id 注解可将实体Bean中某个属性定义为主键，使用@GenerateValue注解可以定义该标识符的生成策略。

• AUTO - 可以是 identity column, sequence 或者 table 类型，取决于不同底层的数据库
• TABLE – 使用table保存id值
• IDENTITY – identity column
• SEQUENCE – seque

nce
@Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator=”SEQ_STORE”)
public Integer getId() { … }

@Id @GeneratedValue(strategy=GenerationType.IDENTITY)
public Long getId() { … }

AUTO 生成器，适用与可移值的应用，多个@Id可以共享同一个 identifier生成器，只要把generator属性设成相同的值就可以。通过@SequenceGenerator 和 @TableGenerator 可以配置不同的 identifier 生成器。

table=”GENERATOR_TABLE”
pk-column-name=”key”
value-column-name=”hi”
pk-column-value=”EMP”
allocation-size=”20″/>
//and the annotation equivalent
@javax.persistence.TableGenerator(
name=”EMP_GEN”,
table=”GENERATOR_TABLE”,
pkColumnName = “key”,
valueColumnName = “hi”
pkColumnValue=”EMP”,
allocationSize=20
)
sequence-name=”my_sequence”
allocation-size=”20″/>
//and the annotation equivalent
@javax.persistence.SequenceGenerator(
name=”SEQ_GEN”,
sequenceName=”my_sequence”,
allocationSize=20
)

The next example shows the definition of a sequence generator in a class scope:

@Entity
@javax.persistence.SequenceGenerator(
name=”SEQ_STORE”,
sequenceName=”my_sequence”
)
public class Store implements Serializable {
private Long id;
@Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator=”SEQ_STORE”)
public Long getId() { return id; }
}

Store类使用名为my_sequence的sequence，并且SEQ_STORE生成器对于其他类是不可见的。

通过下面语法，你可以定义组合键。

• 将组件类注解为 @Embeddable，并将组件的属性注解为 @Id
• 将组件的属性注解为 @EmbeddedId
• 将类注解为 @IdClass，并将该实体中所有主键的属性都注解为 @Id

@Entity
@IdClass(FootballerPk.class)
public class Footballer {
//part of the id key
@Id public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
//part of the id key
@Id public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
public String getClub() {
return club;
}
public void setClub(String club) {
this.club = club;
}
//appropriate equals() and hashCode() implementation
}

@Embeddable
public class FootballerPk implements Serializable {
//same name and type as in Footballer
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
//same name and type as in Footballer
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
//appropriate equals() and hashCode() implementation
}

@Entity
@AssociationOverride( name=”id.channel”, joinColumns = @JoinColumn(name=”chan_id”) )
public class TvMagazin {
@EmbeddedId public TvMagazinPk id;
@Temporal(TemporalType.TIME) Date time;
}

@Embeddable
public class TvMagazinPk implements Serializable {
@ManyToOne
public Channel channel;
public String name;
@ManyToOne
public Presenter presenter;
}

映射继承关系

EJB支持3种类型的继承。

• Table per Class Strategy: the element in Hibernate 每个类一张表
• Single Table per Class Hierarchy Strategy: the element in Hibernate 每个类层次结构一张表
• Joined Subclass Strategy: the element in Hibernate 连接的子类策略

@Inheritance 注解来定义所选的之类策略。

每个类一张表

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Flight implements Serializable {

有缺点，如多态查询或关联。Hibernate 使用 SQL Union 查询来实现这种策略。这种策略支持双向的一对多关联，但不支持 IDENTIFY 生成器策略，因为ID必须在多个表间共享。一旦使用就不能使用AUTO和IDENTIFY生成器。

每个类层次结构一张表

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
name=”planetype”,
discriminatorType=DiscriminatorType.STRING
)
@DiscriminatorValue(“Plane”)
public class Plane { … }

@Entity
@DiscriminatorValue(“A320″)
public class A320 extends Plane { … }

整个层次结构中的所有父类和子类属性都映射到同一个表中，他们的实例通过一个辨别符列（discriminator）来区分。

Plane 是父类。@DiscriminatorColumn 注解定义了辨别符列。对于继承层次结构中的每个类, @DiscriminatorValue 注解指定了用来辨别该类的值。辨别符列名字默认为 DTYPE，其默认值为实体名。其类型为DiscriminatorType.STRING。

连接的子类

@Entity
@Inheritance(strategy=InheritanceType.JOINED)
public class Boat implements Serializable { … }

@Entity
public class Ferry extends Boat { … }

@Entity
@PrimaryKeyJoinColumn(name=”BOAT_ID”)
public class AmericaCupClass extends Boat { … }

以上所有实体使用 JOINED 策略 Ferry和Boat class使用同名的主键关联(eg: Boat.id = Ferry.id)， AmericaCupClass 和 Boat 关联的条件为 Boat.id = AmericaCupClass.BOAT_ID.

从父类继承的属性

@MappedSuperclass
public class BaseEntity {
@Basic
@Temporal(TemporalType.TIMESTAMP)
public Date getLastUpdate() { … }
public String getLastUpdater() { … }
…
}

@Entity class Order extends BaseEntity {
@Id public Integer getId() { … }
…
}

继承父类的一些属性，但不用父类作为映射实体，这时候需要 @MappedSuperclass 注解。上述实体映射到数据库中的时候对应 Order 实体Bean, 其具有 id, lastUpdate, lastUpdater 三个属性。如果没有@MappedSuperclass 注解,则父类中属性忽略，这是 Order 实体 Bean 只有 id 一个属性。

映射实体Bean的关联关系

一对一

使用 @OneToOne 注解可以建立实体Bean之间的一对一关系。一对一关系有3种情况。

• 关联的实体都共享同样的主键。

@Entity
public class Body {
@Id
public Long getId() { return id; }
@OneToOne(cascade = CascadeType.ALL)
@PrimaryKeyJoinColumn
public Heart getHeart() {
return heart;
}
…
}

@Entity
public class Heart {
@Id
public Long getId() { …}
}

通过@PrimaryKeyJoinColumn 注解定义了一对一的关联关系。

• 其中一个实体通过外键关联到另一个实体的主键。注：一对一，则外键必须为唯一约束。

@Entity
public class Customer implements Serializable {
@OneToOne(cascade = CascadeType.ALL)
@JoinColumn(name=”passport_fk”)
public Passport getPassport() {
…
}

@Entity
public class Passport implements Serializable {
@OneToOne(mappedBy = “passport”)
public Customer getOwner() {
…
}

通过@JoinColumn注解定义一对一的关联关系。如果没有@JoinColumn注解，则系统自动处理，在主表中将创建连接列，列名为：主题的关联属性名 + 下划线 + 被关联端的主键列名。上例为 passport_id, 因为Customer 中关联属性为 passport, Passport 的主键为 id.

• 通过关联表来保存两个实体之间的关联关系。注：一对一，则关联表每个外键都必须是唯一约束。

@Entity
public class Customer implements Serializable {
@OneToOne(cascade = CascadeType.ALL)
@JoinTable(name = “CustomerPassports”,
joinColumns = @JoinColumn(name=”customer_fk”),
inverseJoinColumns = @JoinColumn(name=”passport_fk”)
)
public Passport getPassport() {
…
}

@Entity public class Passport implements Serializable {
@OneToOne(mappedBy = “passport”)
public Customer getOwner() {
…
}

Customer 通过 CustomerPassports 关联表和 Passport 关联。该关联表通过 passport_fk 外键指向 Passport 表，该信心定义为 inverseJoinColumns 的属性值。通过 customer_fk 外键指向 Customer 表，该信息定义为 joinColumns 属性值。

多对一

使用 @ManyToOne 注解定义多对一关系。

@Entity()
public class Flight implements Serializable {
@ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
@JoinColumn(name=”COMP_ID”)
public Company getCompany() {
return company;
}
…
}

其中@JoinColumn 注解是可选的，关键字段默认值和一对一关联的情况相似。列名为：主题的关联属性名 + 下划线 + 被关联端的主键列名。本例中为company_id,因为关联的属性是company, Company的主键为 id.

@ManyToOne 注解有个targetEntity属性，该参数定义了目标实体名。通常不需要定义，大部分情况为默认值。但下面这种情况则需要 targetEntity 定义（使用接口作为返回值，而不是常用的实体）。

@Entity()
public class Flight implements Serializable {
@ManyToOne(cascade= {CascadeType.PERSIST,CascadeType.MERGE},targetEntity= CompanyImpl.class)
@JoinColumn(name=”COMP_ID”)
public Company getCompany() {
return company;
}
…
}

public interface Company {
…

多对一也可以通过关联表的方式来映射，通过 @JoinTable 注解可定义关联表。该关联表包含指回实体的外键（通过@JoinTable.joinColumns）以及指向目标实体表的外键（通过@JoinTable.inverseJoinColumns）.

@Entity()
public class Flight implements Serializable {

@ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
@JoinTable(name=”Flight_Company”,
joinColumns = @JoinColumn(name=”FLIGHT_ID”),
inverseJoinColumns = @JoinColumn(name=”COMP_ID”)
)
public Company getCompany() {
return company;
}
…
}

集合类型

一对多

@OneToMany 注解可定义一对多关联。一对多关联可以是双向的。

双向

规范中多对一端几乎总是双向关联中的主体（owner）端，而一对多的关联注解为 @OneToMany(mappedBy=)

@Entity
public class Troop {
@OneToMany(mappedBy=”troop”)
public Set getSoldiers() {
…
}

@Entity
public class Soldier {
@ManyToOne
@JoinColumn(name=”troop_fk”)
public Troop getTroop() {
…
}

Troop 通过troop属性和Soldier建立了一对多的双向关联。在 mappedBy 端不必也不能定义任何物理映射。

单向

@Entity
public class Customer implements Serializable {
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
@JoinColumn(name=”CUST_ID”)
public Set getTickets() {
…
}

@Entity
public class Ticket implements Serializable {
… //no bidir
}

一般通过连接表来实现这种关联，可以通过@JoinColumn注解来描述这种单向关联关系。上例 Customer 通过 CUST_ID 列和 Ticket 建立了单向关联关系。

通过关联表来处理单向关联

@Entity
public class Trainer {
@OneToMany
@JoinTable(
name=”TrainedMonkeys”,
joinColumns = @JoinColumn( name=”trainer_id”),
inverseJoinColumns = @JoinColumn( name=”monkey_id”)
)
public Set getTrainedMonkeys() {
…
}

@Entity
public class Monkey {
… //no bidir
}

通过关联表来处理单向一对多关系是首选，这种关联通过 @JoinTable 注解来进行描述。上例子中 Trainer 通过TrainedMonkeys表和Monkey建立了单向关联关系。其中外键trainer_id关联到Trainer(joinColumns)而外键monkey_id关联到Monkey(inverseJoinColumns).

默认处理机制

通过连接表来建立单向一对多关联不需要描述任何物理映射，表名由一下3个部分组成，主表(owner table)表名 + 下划线 + 从表(the other side table)表名。指向主表的外键名:主表表名+下划线+主表主键列名指向从表的外键定义为唯一约束，用来表示一对多的关联关系。

@Entity
public class Trainer {
@OneToMany
public Set getTrainedTigers() {
…
}

@Entity
public class Tiger {
… //no bidir
}

上述例子中 Trainer 和 Tiger 通过 Trainer_Tiger 连接表建立单向关联关系。其中外键 trainer_id 关联到 Trainer表，而外键 trainedTigers_id 关联到 Tiger 表。

多对多

通过 @ManyToMany 注解定义多对多关系，同时通过 @JoinTable 注解描述关联表和关联条件。其中一端定义为 owner, 另一段定义为 inverse(对关联表进行更新操作，这段被忽略)。

@Entity
public class Employer implements Serializable {
@ManyToMany(
targetEntity=org.hibernate.test.metadata.manytomany.Employee.class,
cascade={CascadeType.PERSIST, CascadeType.MERGE}
)
@JoinTable(
name=”EMPLOYER_EMPLOYEE”,
joinColumns=@JoinColumn(name=”EMPER_ID“),
inverseJoinColumns=@JoinColumn(name=”EMPEE_ID“)
)
public Collection getEmployees() {
return employees;
}
…
}

@Entity
public class Employee implements Serializable {
@ManyToMany(
cascade = {CascadeType.PERSIST, CascadeType.MERGE},
mappedBy = “employees”,
targetEntity = Employer.class
)
public Collection getEmployers() {
return employers;
}
}

默认值：

关联表名：主表表名 + 下划线 + 从表表名；关联表到主表的外键：主表表名 + 下划线 + 主表中主键列名；关联表到从表的外键名：主表中用于关联的属性名 + 下划线 + 从表的主键列名。

用 cascading 实现传播持久化（Transitive persistence）

cascade 属性接受值为 CascadeType 数组，其类型如下：

• CascadeType.PERSIST: cascades the persist (create) operation to associated entities persist() is called or if the entity is managed 如果一个实体是受管状态，或者当 persist() 函数被调用时，触发级联创建(create)操作。

• CascadeType.MERGE: cascades the merge operation to associated entities if merge() is called or if the entity is managed 如果一个实体是受管状态，或者当 merge() 函数被调用时，触发级联合并(merge)操作。

• CascadeType.REMOVE: cascades the remove operation to associated entities if delete() is called 当 delete() 函数被调用时，触发级联删除(remove)操作。

• CascadeType.REFRESH: cascades the refresh operation to associated entities if refresh() is called 当 refresh() 函数被调用时，出发级联更新(refresh)操作。

• CascadeType.ALL: all of the above 以上全部

映射二级列表

使用类一级的 @SecondaryTable 和 @SecondaryTables 注解可以实现单个实体到多个表的映射。使用 @Column 或者 @JoinColumn 注解中的 table 参数可以指定某个列所属的特定表。

@Entity
@Table(name=”MainCat”)
@SecondaryTables({
@SecondaryTable(name=”Cat1″, pkJoinColumns={
@PrimaryKeyJoinColumn(name=”cat_id”, referencedColumnName=”id”)}),
@SecondaryTable(name=”Cat2″, uniqueConstraints={
@UniqueConstraint(columnNames={“storyPart2″})})
})
public class Cat implements Serializable {
private Integer id;
private String name;

private String storyPart1;
private String storyPart2;
@Id @GeneratedValue
public Integer getId() {
return id;
}
public String getName() {
return name;
}
@Column(table=”Cat1″)
public String getStoryPart1() {
return storyPart1;
}
@Column(table=”Cat2″)
public String getStoryPart2() {
return storyPart2;
}

上述例子中， name 保存在 MainCat 表中，storyPart1保存在 Cat1 表中，storyPart2 保存在 Cat2 表中。 Cat1 表通过外键 cat_id 和 MainCat 表关联， Cat2 表通过 id 列和 MainCat 表关联。对storyPart2 列还定义了唯一约束。

映射查询

使用注解可以映射 EJBQL/HQL 查询，@NamedQuery 和 @NamedQueries 是可以使用在类级别或者JPA的XML文件中的注解。

select p from Plane p

…

…
@Entity
@NamedQuery(name=”night.moreRecentThan”, query=”select n from Night n where n.date >= :date”)
public class Night {
…
}
public class MyDao {
doStuff() {
Query q = s.getNamedQuery(“night.moreRecentThan”);
q.setDate( “date”, aMonthAgo );
List results = q.list();
…
}
…
}

可以通过定义 QueryHint 数组的 hints 属性为查询提供一些 hint 信息。下图是一些 Hibernate hints:

映射本地化查询

通过@SqlResultSetMapping 注解来描述 SQL 的 resultset 结构。如果定义多个结果集映射，则用 @SqlResultSetMappings。

@NamedNativeQuery(name=”night&area”, query=”select night.id nid, night.night_duration, ”
+ ” night.night_date, area.id aid, night.area_id, area.name ”
+ “from Night night, Area area where night.area_id = area.id”, resultSetMapping=”joinMapping”)

@SqlResultSetMapping( name=”joinMapping”, entities={
@EntityResult(entityClass=org.hibernate.test.annotations.query.Night.class, fields = {
@FieldResult(name=”id”, column=”nid”),
@FieldResult(name=”duration”, column=”night_duration”),
@FieldResult(name=”date”, column=”night_date”),
@FieldResult(name=”area”, column=”area_id”),
discriminatorColumn=”disc”
}),
@EntityResult(entityClass=org.hibernate.test.annotations.query.Area.class, fields = {
@FieldResult(name=”id”, column=”aid”),
@FieldResult(name=”name”, column=”name”)
})
}
)

上面的例子，名为“night&area”的查询和 “joinMapping”结果集映射对应，该映射返回两个实体，分别为 Night 和 Area, 其中每个属性都和一个列关联，列名通过查询获取。

@Entity
@SqlResultSetMapping(name=”implicit”,
entities=@EntityResult(
entityClass=org.hibernate.test.annotations.@NamedNativeQuery(
name=”implicitSample”, query=”select * from SpaceShip”,
resultSetMapping=”implicit”)
public class SpaceShip {
private String name;
private String model;
private double speed;
@Id
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name=”model_txt”)
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
public double getSpeed() {
return speed;
}
public void setSpeed(double speed) {
this.speed = speed;
}
}

上例中 model1 属性绑定到 model_txt 列，如果和相关实体关联设计到组合主键，那么应该使用 @FieldResult 注解来定义每个外键列。@FieldResult的名字组成：定义这种关系的属性名字 + “.” + 主键名或主键列或主键属性。

@Entity
@SqlResultSetMapping(name=”compositekey”,
entities=@EntityResult(entityClass=org.hibernate.test.annotations.query.SpaceShip.class,
fields = {
@FieldResult(name=”name”, column = “name”),
@FieldResult(name=”model”, column = “model”),
@FieldResult(name=”speed”, column = “speed”),
@FieldResult(name=”captain.firstname”, column = “firstn”),
@FieldResult(name=”captain.lastname”, column = “lastn”),
@FieldResult(name=”dimensions.length”, column = “length”),
@FieldResult(name=”dimensions.width”, column = “width”)
}),
columns = { @ColumnResult(name = “surface”),
@ColumnResult(name = “volume”) } )
@NamedNativeQuery(name=”compositekey”,
query=”select name, model, speed, lname as lastn, fname as firstn, length, width, length * width as resultSetMapping=”compositekey”)
})

如果查询返回的是单个实体，或者打算用系统默认的映射，这种情况下可以不使用 resultSetMapping，而使用resultClass属性，例如：

@NamedNativeQuery(name=”implicitSample”, query=”select * from SpaceShip”,
resultClass=SpaceShip.class)
public class SpaceShip {

Hibernate 独有的注解扩展

Hibernate 提供了与其自身特性想吻合的注解，org.hibernate.annotations package包含了这些注解。

实体

org.hibernate.annotations.Entity 定义了 Hibernate 实体需要的信息。

• mutable: whether this entity is mutable or not 此实体是否可变

• dynamicInsert: allow dynamic SQL for inserts 用动态SQL新增

• dynamicUpdate: allow dynamic SQL for updates 用动态SQL更新

• selectBeforeUpdate: Specifies that Hibernate should never perform an SQL UPDATE unless it is certain that an object is actually modified.指明Hibernate从不运行SQL Update，除非能确定对象已经被修改

• polymorphism: whether the entity polymorphism is of PolymorphismType.IMPLICIT (default) or PolymorphismType.EXPLICIT 指出实体多态是 PolymorphismType.IMPLICIT(默认)还是PolymorphismType.EXPLICIT

• optimisticLock: optimistic locking strategy (OptimisticLockType.VERSION, OptimisticLockType.NONE, OptimisticLockType.DIRTY or OptimisticLockType.ALL) 乐观锁策略

标识符

@org.hibernate.annotations.GenericGenerator和@org.hibernate.annotations.GenericGenerators允许你定义hibernate特有的标识符。

@Id @GeneratedValue(generator=”system-uuid”)
@GenericGenerator(name=”system-uuid”, strategy = “uuid”)
public String getId() {
@Id @GeneratedValue(generator=”hibseq”)
@GenericGenerator(name=”hibseq”, strategy = “seqhilo”,
parameters = {
@Parameter(name=”max_lo”, value = “5″),
@Parameter(name=”sequence”, value=”heybabyhey”)
}
)
public Integer getId() {

新例子

@GenericGenerators(
{
@GenericGenerator(
name=”hibseq”,
strategy = “seqhilo”,
parameters = {
@Parameter(name=”max_lo”, value = “5″),
@Parameter(name=”sequence”, value=”heybabyhey”)
}
),
@GenericGenerator(…)
}
)

自然ID

用 @NaturalId 注解标识

公式

让数据库而不是JVM进行计算。

@Formula(“obj_length * obj_height * obj_width”)
public long getObjectVolume()

索引

通过在列属性(property)上使用@Index注解，可以指定特定列的索引，columnNames属性(attribute)将随之被忽略。

@Column(secondaryTable=”Cat1″)
@Index(name=”story1index”)
public String getStoryPart1() {
return storyPart1;
}

辨别符

@Entity
@DiscriminatorFormula(“case when forest_type is null then 0 else forest_type end”)
public class Forest { … }

Hibernate getCurrentSession与openSession区别

阿超 — Wed, 02 Sep 2009 04:16:00 +0000

getCurrentSession () 使用当前的session
openSession() 重新建立一个新的session
在一个应用程序中，如果DAO 层使用Spring 的hibernate 模板，通过Spring 来控制session 的生命周期，则首选getCurrentSession ()。
1. 如果使用的是getCurrentSession来创建session的话，在commit后，session就自动被关闭了，
也就是不用再session.close()了。但是如果使用的是openSession方法创建的session的话，
那么必须显示的关闭session，也就是调用session.close()方法。这样commit后，session并没有关闭
2. getCurrentSession的使用可以参见hibernate\hibernate-3.2\doc\tutorial\src项目
3. 使用SessionFactory.getCurrentSession()需要在hibernate.cfg.xml中如下配置：
* 如果采用jdbc独立引用程序配置如下：
thread
* 如果采用了JTA事务配置如下
jta

Hibernate代码:
Session session = HibernateUnit.getSessionFactory().getCurrentSession();
session.beginTransaction();
….
session.getTransaction().commit();
getcurrentSession()方法总是会返回“当前的”工作单元。
Session 在第一次被使用的时候，即第一次调用getCurrentSession()的时候，其生命周期就开始。然后她被Hibernate绑定到当前线程。当事物结束的时候，不管是提交还是回滚，Hibernate会自动把Session从当前线程剥离，并且关闭。若在次调用 getCurrentSession()，会得到一个新的Session,并且开始一个新的工作单元。这是Hibernate最广泛的thread- bound model，支持代码灵活分层(事物划分和数据访问代码的分离)。

从实现的功能上看Spring与Hibernate的整合

2008年02月27日星期三 03:26

1.管理SessionFactory

使用Spring整合Hibernate时我们不需要hibernate.cfg.xml文件。首先，在applicationContext.xml中配置数据源（dataSource）bean和session工厂（sessionFactory）bean。其中，在配置session工厂bean 时，应该注入三个方面的信息：

●数据源bean

●所有持久化类的配置文件

●Hibernate的SessionFactory的属性

Hibernate的SessionFactory的属性信息又包括两个内容，一，Hibernate的连接方法；二，不同数据库连接，启动时的选择。

2.为HibernateTemplate注入SessionFactory对象，通过HibernateTemplate来持久化对象

Spring提供了HibernateTemplate，用于持久层访问，该模板无需打开Session及关闭Session。它只要获得 SessionFactory的引用，将可以只能地打开Session，并在持久化访问结束后关闭Session，程序开发只需完成持久层逻辑，通用的操作（如对数据库中数据的增，删，改，查）则有HibernateTemplate完成。

HibernateTemplate有三个构造函数，不论是用哪一种构造，要使HibernateTemplate能完成持久化操作，都必须向其传入一个SessionFactory的引用。

HibernateTemplate的用法有两种，一种是常规的用法，另一种是复杂的用。

一，常规的用法

HibernateTemplate通过它自己的delete(Object entity) ，find(String queryString)，save(Object entity)等等常用的方法即可完成大多数DAO对象的增，删，改，查等操作。

二，复杂的用法

HibernateTemplate的复杂的用法是通过如下的两个方法来完成的：

●Object execute(HibernateCallback action)

●List execute(HibernateCallback action)

这两个方法都需要一个HibernateCallback实例，程序开发者通过HibernateCallback，可以完全使用Hibernate灵活的方式来访问数据库，解决了Spring封装Hibernate后灵活不足的缺陷。HibernateCallback是一个接口，该接口只有一个方法 doInHibernate(org.hibernate.Session session)，该方法只有一个参数Session。

通常，程序中采用实现HibernateCallback的匿名内部类来获取HibernateCallback的实例，方法doInHibernate就是Spring执行的持久化操作。具体的代码实例如下：

public class PersonDaoImpl {

private SessionFactory sessionFactory;

public void setSessionFactory(SessionFactory sessionFactory) {

this.sessionFactory = sessionFactory;

}

public List findPersonByName(final String name) {

HibernateTemplate hibernateTemplate =

new HibernateTemplate(this.sessionFactory);

return (List)hibernateTemplate.execute(

public Object doInHibernate(Session session) throws Hibernate Exception {

List result =session.createCriteria(Person.clsss)

.add(Restrictions.like(“name”,name+”%”)).list();

return result;

}

);

}

注：在方法doInHibernate内可以访问Session，该Session对象是绑定到该线程的Session实例，该方法内的持久层操作与不使用Spring时的持久层操作完全相同，这保证了对于复杂的持久层访问时，依然可以使用Hibernate的访问方式。

3.DAO的实现

DAO的实现有两种方式：一，继承HibernateDaoSupport实现DAO；二，基于Hibernate3.0实现DAO。

一，继承HibernateDaoSupport实现DAO

Spring为Hibernate的DAO提供了工具类HibernateDaoSupport。该类主要提供了如下两个方法来方便DAO的实现：

●public final HibernateTemplate getHibernateTemplate()

●public final void setSessionFactory(SessionFactory sessionFactory)

其中，setSessionFactory方法用来接收Spring的ApplicationContext依赖注入的SessionFactory实例；getHibernateTemplate方法则用来根据刚才的SessionFactory产生Session，最后由 HibernateTemplate来完成数据库访问。

二，基于Hibernate3.0实现DAO

在Hibernate处于事务的管理下时（通常Spring为Hibernate提供事务管理），通过SessionFactory的 getCurrentSession()方法可以返回当前的Session，如果当前的JTA事务关联的Session不存在，则系统打开一次新的 Session，并关联到当前的JTA事务；如果当前JTA事务关联的Session已经存在，则直接返回该Session。获得了当前的Session 后就可以进行持久化操作了。

可见，不论使用上面的哪一种方式实现DAO都需要用Spring来注入SessionFactory实例。

4.事务的管理

Hibernate建议所有的对数据库的访问都应放在事务内进行，即使进行的只是读操作。Spring同时支持编程式事务和声明式事务。通常推荐使用声明式事务。

编程式事务管理：

编程式事务提供了TransactionTemplate模板类，用的时候必须向其体提供一个PlatformTransactionManager实例。只要TransactionTemplate获取了PlatformTransactionManager的引用，TransactionTemplate就可以完成事务操作了。TransactionTemplate提供了一个execute方法，它接收一个 TransactionCallback实例。TransactionCallback包含如下方法：

●Object doInTransaction(TransactionStatus status)

这是需要有返回值的情况。如果不需要有返回值的话，我们可以用TransactionCallbackWithOutResult类来代替TransactionCallback类，它也有一个方法：

●void doInTransaction(TransactionStatus status)

在这个两个方法中，在出现异常时，TransactionStatus的实例status可以调用setRollbackOnly()方法进行回滚。

一般情况下，向execute方法传入TransactionCallback或TransactionCallbackWithOutResult实例时，采用的是匿名内部类的形式。

声明式事务管理：

声明式事务管理的配置方式通常有三种：

●使用TransactionProxyFactoryBean为目标bean生成事务代理的配置。

●使用BeanNameAutoProxyCreator，根据bean name自动生成事务代理的方式，这是直接利用Spring的AOP框架配置事务代理的方式，需要对Spring的AOP框架有所了解。

●使用DefaultAdvisorAutoProxyCreator，这也是直接利用Spring的AOP框架配置事务代理的方式，只是这种配置方式的可读性不如使用BeanNameAutoProxyCreator的配置方式。
——————————————————————

http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd“>

COM.ibm.db2.jdbc.net.DB2Driver

jdbc:db2://localhost:6789/GUOZIWEI

db2admin

db2admin

com/becom/ins/dto/User.hbm.xml
com/becom/ins/dto/InsFunds.hbm.xml
com/becom/ins/dto/Company.hbm.xml
com/becom/ins/dto/Group.hbm.xml
com/becom/ins/dto/OtherFunds.hbm.xml

org.hibernate.dialect.Oracle9Dialect
true
true

PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRED,readOnly
PROPAGATION_REQUIRED,readOnly
PROPAGATION_REQUIRED,readOnly
PROPAGATION_REQUIRED,readOnly
PROPAGATION_REQUIRED,readOnly
PROPAGATION_REQUIRED,readOnly
PROPAGATION_REQUIRED,readOnly

JPA—Hibernate Annotation入门教程

阿超 — Tue, 01 Sep 2009 18:38:00 +0000

     目前，JPA（Java Persistence API）的使用范围越来越广，作为Java EE 5.0平台标准的ORM规范，得到了诸如：Hibernate、TopLink、OpenJpa等ORM框架的支持，同时还是EJB 3.0的重要组成部分。JPA的宗旨是为POJO提供持久化标准规范。它能够脱离容器独立运行，方便开发和测试。本文将通过一个小实例来说明如何在Hibernate中使用JPA，来达到简化编程的目的。
开发环境 Eclipse 3.3.1 MyEclipse 6.0.1GA Tomcat 6.10 SQL Server 2000
            hibernate-3.2.5.GA hibernate-annotations-3.3.0.GA
            ejb3-persistence hibernate-commons-annotations-3.0.0.GA
    本文是为后续的多种Ajax技术框架应用系列作一个前期准备，让大家先了解一下相比与以前的Hibernate ORM映射的不同之处，以及采用JPA所带来的好处。
    为了保证程序能顺序运行，避免不同的Eclipse版本之间产生错误，大象强烈建议，下载源码后，按源码中的工程名，自己单独新建同一个工程，再将src和WEB-INF/lib目录下的所有文件COPY至对应的目录下。
1、创建Web Project
       点击"File"->"New"，选择"Web Project"，在"Project Name"中输入ajax，点击"Finish"。下载本文后面需要用到的JAR包，加入到WEB-INF/lib目录下，在ajax工程中，文本采用的是UTF-8编码。
2、创建HibernateSessionFactory
       传统的方法就是在工程名上点右键，选择”MyEclipse”->”Add Hibernate Capabilities”，然后就是按照提示一步一步做，不过在MyEclipse 6.0.1中添加Hibernate还是只能支持3.1，除非你选择” Add Spring Capabilities”，里面才有Hibernate 3.2的类库，要想完全兼容JPA，必须采用3.2以上版本。
       这里大家直接使用源码中的HibernateSessionFactory，注意请先建包：com.ajax.core,HibernateSessionFactory中有一个地方需要改动，原来的写法是：

private static Configuration configuration = new Configuration();

修改后为：

private static AnnotationConfiguration configuration = new AnnotationConfiguration();

因为我们采用的是JPA注释方式来映射实体，另外AnnotationConfiguration这个类在hibernate-annotations.jar这个包中。

3、创建BaseDao

在com.ajax.core包下面新建BaseDao抽象类，里面定义的是持久化操作方法，有一点特别要注意，一定要在增加、删除、修改这几个方法中加入事务控制，不管是在BaseDao基类方法中加，还是在业务方法中加，一定要加事务控制，大象觉得在基类中加会比较好一点，这样做代码显得更少更简洁。如果不加事务控制，那么增、删、改这些操作都不会产生效果，因为默认情况下，它不会进行自动提交。在做这个例子的时候，这个问题曾经困扰了我好长时间。因此，请大家记住不要再犯和大象一样的错误！贴出部分代码，详情请看源码，里面有很全面的注释。

/**
 * 抽象Dao类，用于持久化操作
 * @author Java豆
 * @version 1.0
 */
public abstract class BaseDao {

    private static Log log = LogFactory.getLog(BaseDao.class);

    /**
     * 获取Hibernate的Session对象
     */
    public Session getSession(){
        return HibernateSessionFactory.getSession();
    }

    /**
     * 根据主键得到对象
     */
    public T getObject(Class clazz, Serializable id){
        return (T)getSession().get(clazz, id);
    }

    /**
     * 保存对象
     */
    public void saveObject(T t) {
        Session session = getSession();
        Transaction tx = beginTransaction(session);
        try{
            session.saveOrUpdate(t);
            tx.commit();
        }catch(Exception e){
            tx.rollback();
            log.error("保存对象失败");
        }
    }

    /**
     * 创建事务
     */
    private Transaction beginTransaction(Session session){
        return session.beginTransaction();
    }
}

4、创建Employee

在com.ajax.employee.mode包下新建Employee类，这个就是POJO类，下面来详细说明里面的含义。

@Entity
@Table(name = "EMPLOYEE")
public class Employee implements java.io.Serializable{

    private Integer employee_id; //人员ID（主键）
    private String employee_name; //人员姓名
    private String sex; //性别
    private String birthday; //出生日期
    private String address; //地址

    @Id
    @Column(name = "EMPLOYEE_ID")
    @TableGenerator(
         name="tab-store",
         table="GENERATOR_TABLE",
         pkColumnName = "G_KEY",
         pkColumnValue="EMPLOYEE_PK",
         valueColumnName = "G_VALUE",
         allocationSize=1
    )
    @GeneratedValue(strategy = GenerationType.TABLE,generator="tab-store")
    public Integer getEmployee_id() {
        return employee_id;
    }
    public void setEmployee_id(Integer employee_id) {
        this.employee_id = employee_id;
    }
}

其它几个属性的getter和setter省略，这里我们要用到ejb3-persistence.jar，JPA的注解类就在这个包中，下面详细说明上面使用到的注解。

@Entity：通过@Entity注解将一个类声明为一个实体bean

@Table：通过 @Table注解可以为实体bean映射指定表，name属性表示实体所对应表的名称，如果没有定义 @Table，那么系统自动使用默认值：实体的类名（不带包名）

@Id：用于标记属性的主键

@Column：表示持久化属性所映射表中的字段，如果属性名与表中的字段名相同，则可以省略@Column注解，另外有两种方式标记，一是放在属性前，另一种是放在getter方法前，例如：

@Column(name = "EMPLOYEE_NAME")
    private String employee_name;

或者

@Column(name = "EMPLOYEE_NAME")
  public String getEmployee_name() {
      return employee_name;
  }

这两种方式都是正解的，根据个人喜好来选择。大象偏向于第二种，并且喜欢将属性名与字段名设成一样的，这样可以省掉@Column注解，使代码更简洁。

@TableGenerator：表生成器，将当前主键的值单独保存到一个数据库表中，主键的值每次都是从指定的表中查询来获得，这种生成主键的方式是很常用的。这种方法生成主键的策略可以适用于任何数据库，不必担心不同数据库不兼容造成的问题。大象推荐这种方式管理主键，很方便，集中式管理表的主键，而且更换数据库不会造成很大的问题。各属性含义如下：

name：表示该表主键生成策略的名称，这个名字可以自定义，它被引用在@GeneratedValue中设置的"generator"值中

table：表示表生成策略所持久化的表名，说简单点就是一个管理其它表主键的表，本例中，这个表名为GENERATOR_TABLE

pkColumnName：表生成器中的列名，用来存放其它表的主键键名，这个列名是与表中的字段对应的

pkColumnValue：实体表所对应到生成器表中的主键名，这个键名是可以自定义滴

valueColumnName：表生成器中的列名，实体表主键的下一个值，假设EMPLOYEE表中的EMPLOYEE_ID最大为2，那么此时，生成器表中与实体表主键对应的键名值则为3

allocationSize：表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50

@GeneratedValue：定义主键生成策略，这里因为使用的是TableGenerator，所以，主键的生成策略为GenerationType.TABLE，生成主键策略的名称则为前面定义的”tab-store”。

这里大象想说下，网上有很多文章写的是strategy = GenerationType.AUTO或是strategy = GenerationType.SEQUENCE，采用SEQUENCE序列是因为Oracle数据中不支持identity自动增长，要想使用它，还得在数据库中创建一个序列，如果要更换数据库，那将是一个非常麻烦的事情。SEQUENCE生成方式我们暂且不谈，这里说下采用AUTO和IDENTITY的生成方式，本例采用的是SQL Server 2000作为数据库，所以如果想使用AUTO或是IDENTITY生成策略，则一定要对主键加上identity标识，如identity(1,1)。不过对于AUTO来说，是根据不同的数据库选择最合适的自增主键生成策略。如果使用MySQL，则主键要定义AUTO_INCREMENT，如果是Oracle，则要创建Sequence来实现自增。不管采用何种生成策略，增、删、改这些方法中一定要加入事务，否则数据是不会添加到数据库中滴~~~这是大象反复测试过的结果！

5、创建数据库及表

接下来，我们需要为本例创建一个数据库及必要的表。数据库名为ajax，表只有两个EMPLOYEE和GENERATOR_TABLE，下面是SQL脚本：

CREATE TABLE EMPLOYEE(
    EMPLOYEE_ID int not null,
    EMPLOYEE_NAME varchar (20) null,
    SEX char (2) null,
    BIRTHDAY varchar(10) null,
    ADDRESS varchar(50) null,
    CONSTRAINT PK_EMPLOYEE PRIMARY KEY (EMPLOYEE_ID)
) 

CREATE TABLE GENERATOR_TABLE(
    ID int not null,
    G_KEY varchar(20) null,
    G_VALUE int null,
    CONSTRAINT PK_GENERATOR_TABLE PRIMARY KEY (ID)
)

INSERT INTO GENERATOR_TABLE VALUES(1,EMPLOYEE_PK,1)

如果你觉得麻烦，不想建库及表，可以将后面的数据库下载下来，然后还原数据库就可以了。

6、修改hibernate.cfg.xml

本例中，采用的是JTDS连接驱动，我们要对配置文件作一些设置，另外还要加入POJO类。

org.hibernate.dialect.SQLServerDialect
net.sourceforge.jtds.jdbc.Driver
jdbc:jtds:sqlserver://localhost:1433/ajax
sa
自己密码(无密码就空着)

以前没有使用JPA注解的时候，我们这里加入的都是hbm.xml文件，现在我们则加入的是类。

7、创建EmployeeManager

在com.ajax.employee.service下新建EmployeeManager类，这里面就是写业务方法，另外在这个类中添加一个main方法用于测试，将log4j的日志级别调整为DEBUG，这样我们就可以看到很详细的程序运行信息，源码中的注释很详细，这里就不贴出来了。

本例没有提供MySQL和Oracle数据库的脚本，不过这些应该很简单，按照最基本的方式建一个数据库和两张表就行了，这里附上两种数据库的hibernate配置。

MySQL：

org.hibernate.dialect.MySQLInnoDBDialect
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/ajax
root
自己的密码(无密码就空着)

Oracle：

org.hibernate.dialect.OracleDialect
oracle.jdbc.driver.OracleDriver
jdbc:oracle:thin:@127.0.0.1:1521:自己的SID
system
自己的密码(无密码就空着)

Hibernate入门 – Set 映射

阿超 — Mon, 24 Aug 2009 06:37:16 +0000

这个主题介绍如果在对象中包括集合对象，像是使用HashSet来包括其它对象时，该如何进行对象与数据表的映像，像Set这样的集合，可以包括所有的Java对象，这边先介绍当Set中包括的对象没有实体（Entiy）时的映像方式。
（简单的说，也就是所包括的对象没有对象识别（identity）值，没有数据库层次上的识别值之表格与之对应的对象，只是纯綷的值型态（value type）对象，关于Entity与value type的说明，可以看看参考手册5.2.1或是Hibernate in Action的第六章。）
假设我们有一个User类别，当中除了名称属性之外，另一个就是使用者的电子邮件地址，同一个使用者可能有多个不同的邮件地址，所以我们在 User类别中使用Set对象来加以记录，在这边我们使用String来记录每一笔邮件地址，为了不允许重复的邮件地址记录，所以我们使用Set对象，我们的User类别如下：

User.java
package onlyfun.caterpillar;
import java.util.HashSet;
import java.util.Set;
public class User {
    private long id;
    private String name;
    private Set addrs = new HashSet();
      public Set getAddrs() {
      return addrs;
   }
   public void setAddrs(Set addrs) {
      this.addrs = addrs;
   }
   public long getId() {
      return id;
   }
   public void setId(long id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
       public void addAddress(String addr) {
        addrs.add(addr);
    }
}

addAddress()方法是为了加入一笔一笔的邮件地址而另外增加的，我们也可以在外部设定好Set对象，再使用setAddrs()方法设定给User对象，在映像文件上，为了进行Set的映像，我们使用标签来进行设定，如下所示：

User.hbm.xml

从映射文件中我们可以看到，我们使用另一个表格ADDRS来记录Set中真正记录的对象，为了表明ADDRS中的每一笔数据是属于哪一个USER 的，我们透过ADDRS的外键USER_ID参考至USER的USER_ID，ADDRS的USER_ID与USER_ID的内容将会是相同的，而中设定Set所包括的对象之型态，以及它将记录在哪一个字段中。

假设我们使用下面的程序来储存User的数据：

        User user1 = new User();
        user1.setName("caterpillar");
        user1.addAddress("caterpillar@caterpillar.onlyfun.net");
        user1.addAddress("justin@caterpillar.onlyfun.net");
        user1.addAddress("justin@fake.com");

        User user2 = new User();
        user2.setName("momor");
        user2.addAddress("momor@caterpillar.onlyfun.net");
        user2.addAddress("momor@fake.com");

        Session session = sessionFactory.openSession();
        Transaction tx= session.beginTransaction();
        session.save(user1);
        session.save(user2);
        tx.commit();
        session.close();

实际上在数据库中的USER与ADDRS表格的内容将如下：

mysql> select * from user;

+———+————-+

| USER_ID | NAME |

+———+————-+

| 1 | caterpillar |

| 2 | momor |

+———+————-+

2 rows in set (0.00 sec)

mysql> select * from addrs;

+———+————————————-+

| USER_ID | ADDRESS |

+———+————————————-+

| 1 | caterpillar@caterpillar.onlyfun.net |

| 1 | justin@caterpillar.onlyfun.net |

| 1 | justin@fake.com |

| 2 | momor@caterpillar.onlyfun.net |

| 2 | momor@fake.com |

+———+————————————-+

5 rows in set (0.00 sec)

下面的程序则简单的示范如何取出数据

Session session = sessionFactory.openSession();

        List users = session.find("from User");

        session.close();
        sessionFactory.close();

        for (ListIterator iterator = users.listIterator(); iterator.hasNext(); ) {
            User user = (User) iterator.next();
            System.out.println(user.getName());
            Object[] addrs = user.getAddrs().toArray();
            for(int i = 0; i < addrs.length; i++) {
                System.out.println("\taddress " + (i+1) + ": " + addrs[i]);
            }
        }

用户ID	用户名	操作
${user.id}	${user.username}	修改