下次自动登录
现在的位置:
& 综合 & 正文
如何根据hibernate的实体类和实体类配置文件生成数据库的表
&!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"&
&hibernate-configuration&
&session-factory&
&property name="hibernate.connection.url"&jdbc:mysql://127.0.0.1/lianxi&/property&
&property name="hibernate.connection.driver_class"&com.mysql.jdbc.Driver&/property&
&property name="hibernate.connection.username"&root&/property&
&property name="hibernate.connection.password"&root&/property&
&property name="hibernate.dialect"&org.hibernate.dialect.MySQLDialect&/property&
&property name="hibernate.show_sql"&true&/property&
&property name="hibernate.hbm2ddl.auto"&update&/property&
&mapping resource="com/bjsxt/crm/model/User.hbm.xml"/&
&mapping resource="com/bjsxt/crm/model/ContactPerson.hbm.xml"/&
&mapping resource="com/bjsxt/crm/model/Customer.hbm.xml"/&
&mapping resource="com/bjsxt/crm/model/DataDictionary.hbm.xml"/&
&/session-factory&
&/hibernate-configuration&
上面是hibernate.cfg.xml 的配置，需要注意的就是把实体映射类的配置文件都引用过来。
还有提点需要理解的是 hibernate.hbm2dll.auto的配置：
加载hibernate时，验证创建数据库表结构
每次加载hibernate，重新创建数据库表结构，这就是导致数据库表数据丢失的原因。
create-drop
加载hibernate时创建，退出是删除表结构
加载hibernate自动更新数据库结构
在本机开发调试初始化数据的时候可以选择create、update等。
但是网站发布正式版本的时候，对数据库现有的数据或表结构进行自动的更新是很危险的。 此时此刻应该由DBA同志通过手工的方式进行后台的数据库操作。
hibernate.hbm2ddl.auto的值建议是“none”或“validate”。“validate”应该是最好的选择：这样spring在加载之初，如果model层和数据库表结构不同，就会报错，这样有助于技术运维预先发现问题。
有了自己的实体类和相应的映射文件后，就可可以通过下面的这个方法由实体类生成数据库的表了，代买如下;
import org.hibernate.cfg.C
import org.hibernate.tool.hbm2ddl.SchemaE
public class ExportDB {
public static void main(String[] args) {
//读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
SchemaExport export = new SchemaExport(cfg);
export.create(true, true);
下面是一些数据库方言，在这里列出方便查找使用
org.hibernate.dialect.DB2Dialect
DB2 AS/400
org.hibernate.dialect.DB2400Dialect
org.hibernate.dialect.DB2390Dialect
PostgreSQL
org.hibernate.dialect.PostgreSQLDialect
org.hibernate.dialect.MySQLDialect
MySQL with InnoDB
org.hibernate.dialect.MySQLInnoDBDialect
MySQL with MyISAM
org.hibernate.dialect.MySQLMyISAMDialect
Oracle (any version)
org.hibernate.dialect.OracleDialect
Oracle 9i/10g
org.hibernate.dialect.Oracle9Dialect
org.hibernate.dialect.SybaseDialect
Sybase Anywhere
org.hibernate.dialect.SybaseAnywhereDialect
Microsoft SQL Server
org.hibernate.dialect.SQLServerDialect
org.hibernate.dialect.SAPDBDialect
org.rmixDialect
HypersonicSQL
org.hibernate.dialect.HSQLDialect
org.hibernate.dialect.IngresDialect
org.hibernate.dialect.ProgressDialect
org.hibernate.dialect.MckoiDialect
org.hibernate.dialect.InterbaseDialect
org.hibernate.dialect.PointbaseDialect
org.hibernate.dialect.FrontbaseDialect
org.hibernate.dialect.FirebirdDialect
&&&&推荐文章:
【上篇】【下篇】1782人阅读
使用Hibernate自动生成数据库的功能只需要导好Hibernate的jar包，然后写好POJO实体类和ORM映射文件，在hibernate.cfg.xml里配好，然后写一个方法执行增删查改的任意一个操作就可以使Hibernate自动为你生成所有的映射好的表，但是我今天碰到一个很BT的现象，就是我的六个POJO类和ORM类都正确的写好了，然后写了一个测试DAO类（这个类只是测试了其中一个POJO类的存取操作），执行后发现对该POJO类的操作正常，可是只生成了5个表，还有一个表（t_message）没生成，也没报错。
&&&&&&& 我觉得很奇怪，仔细的对比了t_message的映射文件和其他的映射文件，没有发现什么奇怪的地方，然后我又写了一个测试Message类（与t_message对应的）的DAO类，用以测试插入操作，执行发现报错，报错内容如下：
我觉得很奇怪，仔细的对比了t_message的映射文件和其他的映射文件，没有发现什么奇怪的地方，然后我又写了一个测试Message类（与t_message对应的）的DAO类，用以测试插入操作，执行发现报错，报错内容如下：
Hibernate: insert into t_message (title, content, sender, receiver, sendDate, read) values (?, ?, ?, ?, ?, ?)
org.hibernate.exception.SQLGrammarException: could not insert: [com.gmha.entity.Message]
at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:90)
at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:66)
at org.hibernate.id.insert.AbstractReturningDelegate.performInsert(AbstractReturningDelegate.java:64)
at org.hibernate.persister.entity.AbstractEntityPersister.insert(AbstractEntityPersister.java:2186)
at org.hibernate.persister.entity.AbstractEntityPersister.insert(AbstractEntityPersister.java:2666)
at org.hibernate.action.EntityIdentityInsertAction.execute(EntityIdentityInsertAction.java:71)
at org.hibernate.engine.ActionQueue.execute(ActionQueue.java:279)
at org.hibernate.event.def.AbstractSaveEventListener.performSaveOrReplicate(AbstractSaveEventListener.java:321)
at org.hibernate.event.def.AbstractSaveEventListener.performSave(AbstractSaveEventListener.java:204)
at org.hibernate.event.def.AbstractSaveEventListener.saveWithGeneratedId(AbstractSaveEventListener.java:130)
at org.hibernate.event.def.DefaultSaveOrUpdateEventListener.saveWithGeneratedOrRequestedId(DefaultSaveOrUpdateEventListener.java:210)
at org.hibernate.event.def.DefaultSaveEventListener.saveWithGeneratedOrRequestedId(DefaultSaveEventListener.java:56)
at org.hibernate.event.def.DefaultSaveOrUpdateEventListener.entityIsTransient(DefaultSaveOrUpdateEventListener.java:195)
at org.hibernate.event.def.DefaultSaveEventListener.performSaveOrUpdate(DefaultSaveEventListener.java:50)
at org.hibernate.event.def.DefaultSaveOrUpdateEventListener.onSaveOrUpdate(DefaultSaveOrUpdateEventListener.java:93)
at org.hibernate.impl.SessionImpl.fireSave(SessionImpl.java:562)
at org.hibernate.impl.SessionImpl.save(SessionImpl.java:550)
at org.hibernate.impl.SessionImpl.save(SessionImpl.java:546)
at com.gmha.dao.HibernateUtil.save(HibernateUtil.java:58)
at com.gmha.test.TestForMessageDAO.main(TestForMessageDAO.java:18)
Caused by: com.mysql.jdbc.exceptions.MySQLSyntaxErrorException: You have an error in your SQL check the manual that corresponds to your MySQL server version for the right syntax to use near &write) values (&title&, &content&,
&sender&, &receiver&, & 17:18:24&, & at line 1
at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:936)
at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:2934)
at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:1616)
at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:1708)
at com.mysql.jdbc.Connection.execSQL(Connection.java:3255)
at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:1293)
at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:1566)
at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:1480)
at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:1465)
at org.hibernate.id.IdentityGenerator$GetGeneratedKeysDelegate.executeAndExtract(IdentityGenerator.java:94)
at org.hibernate.id.insert.AbstractReturningDelegate.performInsert(AbstractReturningDelegate.java:57)
... 17 more
这说明还是这个t_message的映射文件写得有问题，被迫无奈，我只有一行一行的去掉映射文件里的属性映射，发现由一个名为read的属性去掉后就可以生成表，运行也不报错了，然后我把read改为了isRead，结果还是不能生成数据库表，运行还是报上面的错。
经反复测试，有如下总结：
1. POJO类的属性不能取名为read和write，否则都会出现不能生成相应的数据库表和运行出错的现象。（我以为：这两个可能是Hibernate屏蔽的两个关键字）
2. POJO类的boolean类型的属性名不能以is为前缀，否则Hibernate会报找不到getter方法的异常。（我以为：如果属性为boolean类型，Eclipse生成getter方法时就是以is开头的，比如：boolean isRead；生成的getter方法名为：isRead，这时Hibernate想要找的则是isIsRead方法，所以就找不到了。）
就我的情况，解决办法就是把名为read的属性换成一个不是read/write且不以is为前缀的单词即可。（当然POJO里和ORM都要相应的改）
------------------
我按照上面的办法 一个个试了一遍 发现&& &property name=&level&/&& 这个也不行
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：3031次
排名：千里之外Hibernate基于注解方式配置来实现实体和数据库之间存在某种映射关系
实体和之间存在某种映射关系，hibernate根据这种映射关系完成数据的存取。在程序中这种映射关系由映射文件（*.hbm.xml）或者java注解(@)定义。
本文以java注解的形式总结映射关系配置。
一、导入依赖包。
二、新建实体类
package com.sou.domain.
import java.util.D
import javax.persistence.CascadeT
import javax.persistence.C
import javax.persistence.E
import javax.persistence.GeneratedV
import javax.persistence.GenerationT
import javax.persistence.Id;
import javax.persistence.JoinC
import javax.persistence.ManyToO
import javax.persistence.T
import javax.persistence.T
import javax.persistence.TemporalT
import org.springframework.format.annotation.DateTimeF
* 类名: UserLoginLog
* 描述: 用户登录记录表类
* 开发人员： souvc
* 创建时间：
* @version V3.0
@Table(name = &user_login_log&)
public class UserLoginLog implements java.io.Serializable {
private static final long serialVersionUID = 2322570L;
private Integer loginId;
@DateTimeFormat( pattern = &yyyy-MM-dd HH:mm:ss& )
private Date loginT
//private UserBaseInfo userBaseI
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = &login_id&, unique = true, nullable = false)
public Integer getLoginId() {
return loginId;
public void setLoginId(Integer loginId) {
this.loginId = loginId;
@Column(name = &ip&, nullable = true)
public String getIp() {
public void setIp(String ip) {
@Column(name = &address&, nullable = true)
public String getAddress() {
public void setAddress(String address) {
this.address =
@Column(name = &type&, nullable = false)
public Integer getType() {
public void setType(Integer type) {
this.type =
@Column(name = &status&, nullable = false)
public Integer getStatus() {
public void setStatus(Integer status) {
this.status =
@Column(name = &login_time&, nullable = true)
@Temporal(TemporalType.TIMESTAMP)
public Date getLoginTime() {
return loginT
public void setLoginTime(Date loginTime) {
this.loginTime = loginT
@ManyToOne(cascade = CascadeType.REFRESH, optional = false)
@JoinColumn(name = &user_id&, unique = true)
public UserBaseInfo getUserBaseInfo() {
return userBaseI
public void setUserBaseInfo(UserBaseInfo userBaseInfo) {
this.userBaseInfo = userBaseI
三、具体注解解释
实体类以及注解标签映射关系
实体类-----------@Entity/@Table----------数据表
Id--------------@Id----------主键
普通属性---------@Column----------普通键
集合属性---------@OneToMany/@ManyToOne/@ManyToMany/@OneToOne----------外键
A．写在类声明之前的有：
& & a．@Entity,以表明此Bean为EntityBean。每一个持久化POJO类都是一个实体bean,这可以通过在类的定义中使用@Entity注解来进行声明。
& & b．@Table(name=&TableName&),表示此实体Bean对应的数据库表名。@Table是类一级的注解, 通过@Table注解可以为实体bean映射指定表(table),目录(catalog)和schema的名字. 如果没有定义@Table,那么自动使用默认值：实体的短类名(不附带包名).@Table元素包括了一个schema 和一个 catalog属性,如果需要可以指定相应的值. 结合使用@UniqueConstraint注解可以定义表的唯一约束(unique constraint)&
B．写在getXxx（）方法声明之前的有：
a．@Column注释定义了映射到列的所有属性,如列名是否唯一，是否允许为空，是否允许更新等，他的属性介绍如下：
name 可选,列名(默认值是属性名)
unique 可选,是否在该列上设置唯一约束(默认值false)
nullable 可选,是否设置该列的值可以为空(默认值false)
insertable 可选,该列是否作为生成的insert语句中的一个列(默认值true)
updatable 可选,该列是否作为生成的update语句中的一个列(默认值true)
columnDefinition 可选: 为这个特定列覆盖SQL DDL片段 (这可能导致无法在不同数据库间移植)
table 可选,定义对应的表(默认为主表)
length 可选,列长度(默认值255)
precision 可选,列十进制精度(decimal precision)(默认值0)
scale 可选,如果列十进制数值范围(decimal scale)可用,在此设置(默认值0)
b．@Id 注释指定personid属性为表的主键，它可以有多种生成方式：
&TABLE：容器指定用底层的数据表确保唯一。
&SEQUENCE：使用数据库的SEQUENCE 列来保证唯一
&IDENTITY：使用数据库的INDENTIT列来保证唯一
&AUTO：由容器挑选一个合适的方式来保证唯一
&NONE：容器不负责主键的生成，由调用程序来完成。
c．@GeneratedValue注释定义标识字段的生成方式。
d. @Version 映射版本号属性
e. &@Column 指定属性对应的列的信息
f . @Temporal 指定日期时间的类型(TIMESTAMP,DATE,TIME)
g. 简单属性可以不用注解。默认就是@Basic
h. @Transient 指定属性不需要映射
i. &复杂属性：关联，继承，组件，联合主键，集合
C.关系/对象映射
A．一对多：
@OneToMany指明关联关系为一对多关系，下面是@OneToMany 注释的属性：
1&targetEntity
& & Class 类型的属性。定义关系类的类型，默认是该成员属性对应的类类型，所以通常不需要提供定义。
2&mappedBy
& & &String 类型的属性。定义类之间的双向关系。如果类之间是单向关系，不需要提供定义，如果类和类之间形成双向关系，我们就需要使用这个属性进行定义，否则可能引起数据一致性的问题。
CascadeType[]类型。
& & &该属性定义类和类之间的级联关系。定义的级联关系将被容器视为对当前类对象及其关联类对象采取相同的操作，而且这种关系是递归调用的。
举个例 子：Order 和OrderItem 有级联关系，那么删除Order 时将同时删除它所对应的OrderItem对象。而如果OrderItem还和其他的对象之间有级联关系，那么这样的操作会一直递归执行下去。
cascade 的值只能从：
CascadeType.PERSIST（级联新建）；
CascadeType.REMOVE（级联删除）；
CascadeType.REFRESH（级联刷新）；
CascadeType.MERGE（级联更新）中选择一个或多个。
还有一个选择是使用CascadeType.ALL，表示选择全部四项。
FetchType 类型的属性。
可选择项包括：FetchType.EAGER和FetchType.LAZY。
& & & 前者表示关系类(本例是OrderItem类)在主类(本例是Order类)加载的时候同时加载；
& & & 后者表示关系类在被访问时才加载。默认值是FetchType. LAZY。
@OrderBy(value = &id ASC&)注释指明加载OrderItem 时按id 的升序排序。
B．多对一：
@ManyToOne注释，有四个属性：targetEntity、cascade、fetch 和optional。
前三个属性的具体含义和@OneToMany注释的同名属性相同，但@ManyToOne 注释的fetch 属性默认值是FetchType.EAGER。
optional 属性是定义该关联类对是否必须存在，值为false 时，关联类双方都必须存在，如果关系被维护端不存在，查询的结果为null。值为true 时, 关系被维护端可以不存在，查询的结果仍然会返回关系维护端，在关系维护端中指向关系被维护端的属性为null。
optional属性的默认值是true。
举个例：某项订单(Order)中没有订单项(OrderItem)，如果optional 属性设置为false，获取该项订单（Order）时，得到的结果为null，如果optional属性设置为true，仍然可以获取该项订单，但订单中 指向订单项的属性为null。
实际上在解释Order 与OrderItem的关系成SQL时，optional属性指定了他们的联接关系
optional=false 联接关系为inner join,
optional=true 联接关系为left join。
@JoinColumn(name = &order_id&)注释指定OrderItem 映射表的order_id 列作为外键与Order 映射表的主键列关联。
C．一对一：
&@OneToOne 注释，有五个属性：targetEntity、cascade、fetch、optional 和mappedBy 。
前四个属性的具体含义与@ManyToOne 注释的同名属性一一对应， fetch 属性默认值是FetchType.EAGER。
mappedBy属性的具体含义与@OneToMany 注释的同名属性相同。
如果optional = true 设置表明此属性可以为null。
例如在身份证的处理时可以这样设置，因为未成年人就是没有身份证的。
D．多对多：
@ManyToMany 注释：表示此类是多对多关系的一边，mappedBy 属性定义了此类为双向关系的维护端，注意：mappedBy 属性的值为此关系的另一端的属性名。
例如，在Student类中有如下方法：
@ManyToMany(mappedBy = &students&)
public Set&Teacher& getTeachers() {
那么这里的&students&就是Teachers的一个属性，通常应该是这样的：
Set&Student&
另一端的getStudents方法如下所示：
@ManyToMany(cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
@JoinTable(name = &Teacher_Student&,joinColumns = {@JoinColumn(name = &Teacher_ID&, referencedColumnName = &teacherid&)},inverseJoinColumns = {@JoinColumn(name = &Student_ID&, referencedColumnName =&studentid&)})
public Set&Student& getStudents() {
@ManyToMany 注释表示Teacher 是多对多关系的一端。
@JoinTable 描述了多对多关系的数据表关系。
name 属性指定中间表名称，joinColumns 定义中间表与Teacher 表的外键关系。
上面的代码中，中间表Teacher_Student的Teacher_ID 列是Teacher 表的主键列对应的外键列，inverseJoinColumns 属性定义了中间表与另外一端(Student)的外键关系。
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'hibernate没有实体类的情况下,怎么查询数据库中的数据_百度知道
hibernate没有实体类的情况下,怎么查询数据库中的数据
提问者采纳
} catch (Exception e) {
e.createSQLQuery(sql);
List&lt.getSessionFactory();Object&gt.list(); list=
session.getCurrentSession()可以同过在实现了接口HibernateDaoSupport 中的类中获取session打开事物哦同过如下代码Session session = getHibernateTemplate().printStackTrace();
return null
提问者评价
很好、可以取到数据了
其他类似问题
为您推荐：
其他1条回答
select * from users&Map& FindAllUsers(User user){String sql=&quot.ALIAS_TO_ENTITY_MAP)public List&&String,Object&gt.createSQLQuery(sql);SQLQuery sqlquery = getSession().list();}这个方法通过直接执行sql语句;.setResultTransformer(Transformers
实体类的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁一个数据库表映射成多个Hibernate的实体的有关问题 - 数据库当前位置:& &&&一个数据库表映射成多个Hibernate的实体的有关问题一个数据库表映射成多个Hibernate的实体的有关问题&&网友分享于：&&浏览：23次一个数据库表映射成多个Hibernate的实体的问题
在最近一个项目中，由于项目管理的不善，导致了开发人员之间的相对独立的开发，所以就造成了本来是同一个数据库的表，但是映射成了两个Java类，本来相安无事，但是因为需求变动，造成此表要增加很多字段，本着节省工作的思想，于是在其中一个实体类中增加了成员变量，而由另外一个实体类继承之，由此引出了一下问题：
数据库表为test
两个实体类分别为testDomain1和testDomain2,其中testDomain2 extends testDomain1
在业务代码中，使用QBC查询testDomain1时的count时，是这么写的：
criteria.setProjection(Projections.rowCount()).uniqueResult();
在执行时抛出了异常：
org.hibernate.NonUniqueResultException: query did not return a unique result: 2
at org.hibernate.impl.AbstractQueryImpl.uniqueElement(AbstractQueryImpl.java:758)
at org.hibernate.impl.CriteriaImpl.uniqueResult(CriteriaImpl.java:431)
at com.ibm.b2e.framework.base.dao.BaseDaoImpl.pagedQuery(BaseDaoImpl.java:784)
at com.ibm.b2e.framework.base.dao.BaseDaoImpl.pagedQuery(BaseDaoImpl.java:651)
而看Hibernate打印出的SQL执行了两次select count（*）的操作，于是猜到是表被映射了两次的问题，想从网上查一下解决方法，但是不知道选择什么关键词，只好自己看源代码，
发现在uniqueResult()这个方法中调用的是SessionImpl的list(CriteriaImpl criteria)方法
而list()这个方法中调用了sessionFactory的getImplementors( String className )方法，这个方法返回的是一个字符串数组，调试发现，它的值正好是我两个实体类的全类名，后面的代码则是根据这两个类名来执行查询，
焦点就在sessionFactory的getImplementors( String className )中了，马上冲进去一看，发现其中有一个遍历所有已映射对象的循环操作：
while ( iter.hasNext() ) {
//test this entity to see if we must query it
EntityPersister testPersister = (EntityPersister) iter.next();
if ( testPersister instanceof Queryable ) {
Queryable testQueryable = (Queryable) testP
String testClassName = testQueryable.getEntityName();
boolean isMappedClass = className.equals(testClassName);
if ( testQueryable.isExplicitPolymorphism() ) {
if (isMappedClass) return new String[] { className }; //NOTE EARLY EXIT
if (isMappedClass) {
results.add(testClassName);
final Class mappedClass = testQueryable.getMappedClass( EntityMode.POJO );
if ( mappedClass!=null && clazz.isAssignableFrom( mappedClass ) ) {
final boolean assignableS
if ( testQueryable.isInherited() ) {
Class mappedSuperclass = getEntityPersister( testQueryable.getMappedSuperclass() ).getMappedClass( EntityMode.POJO);
assignableSuperclass = clazz.isAssignableFrom(mappedSuperclass);
assignableSuperclass =
if (!assignableSuperclass) results.add(testClassName);
看代码的意思，首先是判断当前循环到的class是不是本次查询所查的class，其次再判断Mapped class的一个属性值：testQueryable.isExplicitPolymorphism() 如果此值为true的话，直接就返回一个值只有className的字符串数组；而如果isExplicitPolymorphism（）方法返回的值是false的话，那么下面的代码将会继续检查当前循环到的类是否是QBC的类的子类，如果是，则加在字符串数组中一起返回，我所遇到的问题正是后者。
看来关键出在isExplicitPolymorphism() 的值上面。
查询了Hibernate的sessionFactory初始化代码后，发现此方法的返回值来自于Mapping配置文件，打开Mapping配置文件用代码提示看了一下，&class&元素果然有一个名为polymorphism的属性，此属性有两个候选值：explicit，implicit，在研究此值的实际作用时，发现了JavaEye上原来早已经有一篇文章QBC 解惑,里面很详尽的介绍了此方法，
而对于这样的设计梦秋雨童鞋的解释更是一针见血，非常形象，不得不在此处引用一下：
梦秋雨写道
这个事情不用去看实现，仅从对象层面上理解我觉得也能够得出同样的结论。hibernate的管理下应用似乎得到了一个大的对象池，你去查Person，好比和这个对象池的管理员说“把所有的人都叫出来”。当然会返回池中所有的Person，如果不是，那么，你还当学生是人么？ 类比，查询Object类的对象，好比说“芸芸众生啊，都来举个手”，结果可想而知。
强人啊强人。。强人啊强人。。。（此处重复30遍）
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关解决方案 12345678910 Copyright & &&版权所有