- 浏览: 822260 次
- 性别:
- 来自: 深圳
文章分类
- 全部博客 (488)
- struts1 (4)
- spring (13)
- extjs (36)
- mysql (3)
- sqlserver (2)
- oracle (37)
- 杂谈 (11)
- 面试相关 (35)
- Java基础知识总结 (5)
- Java重要知识点 线程和io流知识点 (6)
- 服务器相关 (1)
- 生活 (1)
- jsp (7)
- servlet (2)
- junit (3)
- struts2 (9)
- 开发必备 (4)
- 使用开发工具总结的知识 (4)
- ibatis (12)
- ajax (2)
- dwr (2)
- jquery (1)
- 设计模式 (4)
- Lucene的学习 (5)
- 经验总结 (19)
- mysql全文搜索相关 (7)
- hibernate (33)
- Sphinx (1)
- log4j的总结 (1)
- 敏捷开发 (9)
- 持续集成 (15)
- UML使用总结 (1)
- Scrum (1)
- OO(面向对象编程) (1)
- struts1和struts2总结 (1)
- 数据库加密 (1)
- 多线程和Socket编程 (6)
- PowerDesigner (2)
- 权限相关 (1)
- ant应用总结 (4)
- 面试必知知识点总结 (6)
- io流与nio流总结 面试相关 (1)
- 敏捷管理工具的使用 (7)
- hsqldb相关 (1)
- svn源码相关 (2)
- debug调试技巧总结 (1)
- hibernate和ibatis对比相关 (6)
- eclipse mylyn 插件的使用总结 (2)
- fisheye使用总结 (2)
- java泛型总结 (1)
- ssh整合总结 (10)
- SpringSide的学习总结 (1)
- JPA学习总结 (2)
- RoR 总结 (2)
- 模型驱动 总结 (1)
- Oracle SQL优化技巧 (4)
- 数据库相关资料 (1)
- oracle练习相关 (4)
- PowerDesigner 使用总结 (2)
- Struts实现国际化相关 (2)
- 权限框架 Spring Security (1)
- freemarker使用总结 (1)
- jsp servlet总结相关 (3)
- Java NIO总结 (1)
- 自己学习必须 (3)
- 蝴蝶容器相关 (2)
- eclipse插件的使用 (1)
- myeclipse的使用 (1)
- flex相关 (1)
- javaeye重生后总结的知识点 (2)
- 公司学习总结 (3)
- JAXB 相关 (1)
- ECSide (1)
- EdoJs 企业ajax框架 (1)
- RSA加密算法 (1)
- jbpm相关 (1)
- JMF原理 (1)
- MyEclipse使用总结 (1)
- Funsion Charts 相关总结 (3)
- 常用知识2011 (2)
- Flex与Java整合 (1)
- IBM WebSphere相关 (1)
- jQuery使用技巧 (2)
- 2011年面试相关知识点总结 (2)
- sqlserver开发相关 (8)
- eclipse 打jar相关 (2)
- Oracle/Mysql/SqlServer比较 (1)
- WebService Axis1.4开发相关 (4)
- 进制数的转换 总结 (1)
- WebService Axis2.0开发相关 (0)
- iteye Struts2 Spring Hibernate整合相关 (3)
- iteye osgi资料相关总结 (1)
- iteye ifos相关相关 (1)
- iteye 国际化相关 (1)
- iteye Hibernate缓存机制 (4)
- iteye Struts2 总结 (1)
- iteye Struts标签总结 (0)
- iteye web配置文件大全 (6)
- iteye Efs 框架总结 (1)
- iteye sql优化 (2)
- iteye 大数据量高并发的数据库优化 (1)
- iteye 开发相关 (1)
- iteye s1sh 和 s2sh整合中的问题以及解决 (1)
- iteye s1sh整合实例 (1)
- iteye s2sh整合实例 (1)
- iteye 面试相关 基础篇 (1)
- iteye Android相关 (1)
- iteye 面试相关 Web篇 (1)
- iteye Sql Server相关 (0)
- iteye struts1与struts2比较 (1)
- iteye jquery 和Struts2 (0)
- iteye struts2与其他插件整合 (0)
- iteye jquery 开发相关 (1)
- iteye eclipse结合spket(Ext,Jquery)开发相关 (0)
- iteye myeclipse 使用技巧相关 (0)
- iteye Memcached 缓存系统相关 (0)
- iteye 常用软件相关 (0)
- iteye 最新技术预览 AjaxSwing (0)
- iteye struts上传下载相关 (0)
- iteye 新技术相关 (0)
- test (0)
- iteye 开发Java游戏相关 (0)
- iteye Java反编译 (0)
- iteye XML解析相关 (0)
- iteye 压缩ZIP相关 (0)
- iteye 面试相关 (0)
- iteye Android开发相关 (4)
- csdn (0)
- e-inoc (0)
- iteye http错误码对应说明 (0)
- iteye 面试扩展知识点 (0)
- iteye oracle面试相关 存储过程,触发器,游标等 (0)
- iteye english study (0)
- iteye starflow工作流引擎 (0)
- iteye IBM WebSphere Application Server Toolkit使用相关 (0)
- iteye spring3 (0)
- iteye mybatis (0)
- iteye js技巧总结 (0)
- iteye SEO优化相关 (2)
- iteye QUI网页界面集成框架 (1)
- iteye AjaxAnywhere (1)
- iteye Nutz相关 (1)
- iteye ibatis技巧 (0)
- iteye dwz (0)
- 128个ajax/javascript框架 (0)
- iteye 2012 Java Swing教程 (1)
- iteye 码头集装箱相关 (1)
- iteye swing (2)
- 兼职工作 (0)
- 2012 新总结的面试相关知识点 常用知识点 (1)
- 淘宝网店相关 (0)
- oracle 常用函数 2012新总结 (1)
- 我的时尚潮流屋 (0)
- 2012 年 面试新总结知识 (1)
- 技巧 (1)
- 2013总结 (1)
- 2015工作相关 (3)
- springmvc (5)
- EasyPR-Java (1)
- java (2)
- editplus 4.0 注册码 (1)
- android (1)
- oracle连接数据库相关 (1)
- 编程资料总结 (2)
- 20160808 (1)
- visio 2013 (1)
最新评论
-
drew926:
泛型的类型参数可以有多个?这是java哪个版本支持的?
java泛型总结 -
listenan:
赞!非常感谢。
Scrum总结 -
cwscwj:
写的很深刻,谢谢,看了一遍,过段时间打算再看一遍。
Scrum总结 -
hwedwin:
w
Struts 2中的OGNL\EL的使用总结 -
lanni2460:
不错 很好 支持……
sqlserver三个驱动包下载
一、整体的hibernate流程。
首先我们通过web.xml中可以找到spring的配置文件(往往我们可以把spring配置文件分为多个:Dao相关的,logic相关的各种 logic的bean,表现层相关的各种action的bean),其中在dao相关的配置中,我们可以通过配置dataSource/某种连接 池,sessionFactory(包含属性指定hibernate.cfg.xml),在hibernate.cfg.xml中我们可以指定各个实体类 及其对象关系映射。
也就是说:服务器启动后----加载web.xml----加载 spring的bean(dataSource、sessionFactory)---- 加载hibernate.cfg.xml----加载各个实体类的关系对象映射。从而建立了实体与表之间的对象关系映射。
进而我们可以通过在我们的dao类中加入sessionFactory以及使用hibernate提供的模板操作数据库。
二、通过spring来管理hibernate
1、将指定位置的属性文件读取进来,以便后面的配置可以使用${hibernate.show_sql}的方式
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="classpath:mepay.properties" />
</bean>
2.1、在spring的配置文件中配置proxool连接池和 sessionFactory(proxool连接池参考全面的介绍)
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<description>proxool连接池配置</description>
//通过注释的方式写关系对象映射时需要加的配置
<property name="configurationClass">
<value>org.hibernate.cfg.AnnotationConfiguration</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.proxool.xml">hibernate/proxool.xml</prop>
<prop key="hibernate.proxool.pool_alias">webtools_proxool</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.Oracle9iDialect</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<prop key="hibernate.use_sql_comments">${hibernate.use_sql_comments}</prop>
<prop key="hibernate.use_outer_join">${hibernate.use_outer_join}</prop>
<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.max_fetch_depth">1</prop>
</props>
</property>
//通过配置configLocation属性指定 hibernate根配置位置
<property name="configLocation">
<value>classpath:hibernate/hibernate.cfg.xml</value>
</property>
</bean>
2.2、或者在spring的配置文件中配置dataSource和sessionFactory
<bean id="dataSource" class="com.mchange.v2.c3po.ComboPooledDataSource">
<property name="jdbcUrl/user/password" />
......
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
//通过注释的方式写关系对象映射时需要加的配置
<property name="configurationClass">
<value>org.hibernate.cfg.AnnotationConfiguration</value>
</property>
<property name="dataSource" ref="dataSource" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.Oracle9iDialect</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<prop key="hibernate.use_sql_comments">${hibernate.use_sql_comments}</prop>
<prop key="hibernate.use_outer_join">${hibernate.use_outer_join}</prop>
<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.max_fetch_depth">1</prop>
</props>
</property>
//通过配置configLocation属性指定 hibernate根配置位置
<property name="configLocation">
<value>classpath:hibernate/hibernate.cfg.xml</value>
</property>
</bean>
三、通过hibernate.cfg.xml来指定各个实体类
<hibernate-configuration>
<session-factory>
<mapping class="com.watchdata.mepay.domain.AdminInfo" />
<mapping class="com.watchdata.mepay.domain.UserInfo" />
<mapping class="com.watchdata.mepay.domain.Group" />
<mapping class="com.watchdata.mepay.domain.ActivateLog"/>
</session-factory>
</hibernate-configuration>
四、使用注释的方式写对象关系映射
1、表映射
@Entity
@Table(name = "ADMIN_INFO", schema = "MEPAYTWO", uniqueConstraints = @UniqueConstraint
(columnNames = "NAME"))
建立本实体@Entity与表@Table之间的映射。
name = "ADMIN_INFO":表示表名。
schema = "MEPAYTWO":数据库名。
uniqueConstraints = @UniqueConstraint(columnNames = "NAME")):约束定义--唯一性约束。
2、主键字段映射
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "admin_seq")
@SequenceGenerator(name = "admin_seq", sequenceName = "ADMIN_SEQ", allocationSize = 1)
@Column(name = "ADMIN_ID", unique = true, nullable = false, precision = 22, scale = 0)
建立主键字段与表中主键之间的映射,并且指定主键生成策略
(strategy = GenerationType.SEQUENCE, generator = "admin_seq")
指定主键生成策略GenerationType.SEQUENCE,及生产者admin_seq(下面会定义)
@SequenceGenerator(name = "admin_seq", sequenceName = "ADMIN_SEQ", allocationSize = 1)
定义一个序列主键生产者名字为admin_seq,对应于MEPAYTWO数据库中的ADMIN_SEQ序列
(我们需要在MEPAYTWO中建立一个这样的序列)
3、普通字段映射
@Column(name = "NAME", unique = true, nullable = false, length = 20)
4、一对多映射
@OneToMany(targetEntity = com.watchdata.mepay.domain.AdminGroup.class,
fetch = FetchType.LAZY,mappedBy="admin")
@Cascade(value={CascadeType.SAVE_UPDATE})
@JoinColumn(name = "ADMIN_ID")
public List<AdminGroup> getAdminGroupList(){
return adminGroupList;
}
一个用户可以属于多个组(拥有多个组的权限)
我们定义一个list变量使得我们在“一”的一方可以轻松的访问“多”
targetEntity = com.watchdata.mepay.domain.AdminGroup.class:指定目标类(多一方)
mappedBy="admin":多的一方靠那个属性知道他属于这个“一”
JoinColumn(name = "ADMIN_ID"):多的一方根据此外键连接到我们的“一”
5、一对多映射
@ManyToOne(targetEntity=AdminInfo.class)
@JoinColumn(name="ADMIN_ID")
五、利用HibernateDaoSupport以及接口+继承+范型的思想规划和实现Dao类
1、思想规划:
1.1、运用范型定义了一个基本接口(IEntityDao<T>):其中声明了每个Dao都会用到的接口方法。
1.2、为每个Dao定义了一个具体的接口:其继承自基本接口,同时定义了本Dao特有的接口方法。
继承的时候把范型具体化,如:extend IEntityDao<AdminInfo>。
1.3、运用范型定义了一个Dao基类(HibernateEntityDao<T>),继承自 HibernateDaoSupport,
实现基本接口中的方法,使得具体的Dao类只要继承自这个基类就具有了基本接口中声明的功能。
1.4、定义具体的Dao类,继承自Dao基类,实现具体的Dao接口。继承的时候要把范型具体化,如:
extends HibernateEntityDao<ActivateLog>,这里面主要实现具体Dao接口中定义的方法,
基本Dao接口方法已经通过继承自Dao基类实现了。
2、具体介绍:
2.1 IEntityDao
public interface IEntityDao<T> {
//根据Domain ID 获得一个Domain 对象
T get(Serializable id);
//获得数据库中所有的Domain 对象.如果数据库内记录巨大的话,请慎用此方法
List<T> getAll();
//保存传入的Domain 对象进入数据库
void save(Object o);
//保存或更新传入的Domain 对象进入数据库
void saveOrUpdate(Object o);
//从数据库中删除此Domain 对象对应的数据
void remove(Object o);
//根据Domain 对象的ID 从数据库中删除相应的记录
void removeById(Serializable id);
//获取Entity对象的主键名
String getIdName(Class clazz);
}
2.2、HibernateEntityDao
public class HibernateEntityDao<T> extends HibernateDaoSupport implements IEntityDao<T> {
protected Class<T> entityClass;// DAO所管理的Entity类型.
//在构造函数中将泛型T.class赋给entityClass.
public HibernateEntityDao() {
entityClass = GenericUtils.getSuperClassGenricType(getClass());
}
//根据ID获取对象.
public T get(Serializable id) {
return (T) getHibernateTemplate().get(getEntityClass(), id);
}
//获取全部对象
public List<T> getAll() {
return getHibernateTemplate().loadAll(getEntityClass());
}
//获取全部对象,带排序参数.
public List<T> getAll(String orderBy, boolean isAsc) {
return getAll(getEntityClass(), orderBy, isAsc);
Assert.hasText(orderBy);
if (isAsc) {
return getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(getEntityClass()).addOrder(
Order.asc(orderBy)));
} else {
return getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(getEntityClass()).addOrder(
Order.desc(orderBy)));
}
}
//保存对象
public void save(Object o) {
getHibernateTemplate().save(o);
}
//保存对象或更新
public void saveOrUpdate(Object o){
getHibernateTemplate().saveOrUpdate(o);
}
//保存对象,批量保存.
public void saveOrUpdateAll(Collection c) {
getHibernateTemplate().saveOrUpdateAll(c);
}
//删除对象
public void remove(Object o) {
getHibernateTemplate().delete(o);
}
//根据ID移除对象.
public void removeById(Serializable id) {
remove(get(getEntityClass(), id));
}
//批量删除.
public void removeAll(Collection col) {
getHibernateTemplate().deleteAll(col);
}
//创建Query对象.
//对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query 后自行设置.
//留意可以连续设置,如 dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();
//调用方式如下:
// dao.createQuery(hql); 或 dao.createQuery(hql,arg0); 或
// dao.createQuery(hql,arg0,arg1); 或 dao.createQuery(hql,new Object[arg0,arg1,arg2])
public Query createQuery(String hql, Object... values) {
Assert.hasText(hql);
Query query = getSession().createQuery(hql);
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
return query;
}
//取得Entity的Criteria.参数是criterions:可变的Restrictions条件列表
public Criteria createCriteria(Criterion... criterions) {
DetachedCriteria criteria=DetachedCriteria.forClass(getEntityClass());
for (Criterion c : criterions) {
criteria.add(c);
}
return criteria;
}
//取得Entity的Criteria,带排序参数.
public Criteria createCriteria(String orderBy, boolean isAsc, Criterion... criterions) {
Assert.hasText(orderBy);
DetachedCriteria criteria = createCriteria(entityClass, criterions);
if (isAsc) {
criteria.addOrder(Order.asc(orderBy));
} else {
criteria.addOrder(Order.desc(orderBy));
}
return criteria;
}
//根据属性名和属性值查询对象.
public List<T> findBy(String propertyName, Object value) {
Assert.hasText(propertyName);
DetachedCriteria criteria = createCriteria(Restrictions.eq(propertyName, value));
List<T> list=getHibernateTemplate().findByCriteria(criteria);
return list;
}
//根据属性名和属性值查询对象,带排序参数.
public List<T> findBy(String propertyName, Object value, String orderBy, boolean isAsc) {
Assert.hasText(propertyName);
Assert.hasText(orderBy);
DetachedCriteria criteria =createCriteria(
orderBy, isAsc,Restrictions.eq(propertyName, value));
List<T> list=this.getHibernateTemplate().findByCriteria(criteria);
return list;
}
//根据属性名和属性值查询单个对象.
public T findUniqueBy(String propertyName, Object value) {
Assert.hasText(propertyName);
DetachedCriteria criteria =createCriteria(Restrictions.eq(propertyName, value));
List<T> list=this.getHibernateTemplate().findByCriteria(criteria);
return list!=null&&list.size()>0?list.get(0):null;
}
//消除与 Hibernate Session 的关联
public void evit(Object entity){
getHibernateTemplate().evict(entity);
}
//取得entityClass.
protected Class<T> getEntityClass() {
return entityClass;
}
//用hql执行update和delete操作,用于小批量操作
public void excuteHql(String hql,Object...values){
getHibernateTemplate().bulkUpdate(hql, values);
}
}
2.3、为每个具体的dao建立一个接口 extend IEntityDao<Entity>
其中定义这个dao需要的IEntityDao中没有声明的特需功能
2.4、为每个具体的dao定义一个实现类,实现具体接口,extend HibernateEntityDao<Entity>
实现具体接口中定义的,基类没有实现的功能。
首先我们通过web.xml中可以找到spring的配置文件(往往我们可以把spring配置文件分为多个:Dao相关的,logic相关的各种 logic的bean,表现层相关的各种action的bean),其中在dao相关的配置中,我们可以通过配置dataSource/某种连接 池,sessionFactory(包含属性指定hibernate.cfg.xml),在hibernate.cfg.xml中我们可以指定各个实体类 及其对象关系映射。
也就是说:服务器启动后----加载web.xml----加载 spring的bean(dataSource、sessionFactory)---- 加载hibernate.cfg.xml----加载各个实体类的关系对象映射。从而建立了实体与表之间的对象关系映射。
进而我们可以通过在我们的dao类中加入sessionFactory以及使用hibernate提供的模板操作数据库。
二、通过spring来管理hibernate
1、将指定位置的属性文件读取进来,以便后面的配置可以使用${hibernate.show_sql}的方式
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="classpath:mepay.properties" />
</bean>
2.1、在spring的配置文件中配置proxool连接池和 sessionFactory(proxool连接池参考全面的介绍)
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<description>proxool连接池配置</description>
//通过注释的方式写关系对象映射时需要加的配置
<property name="configurationClass">
<value>org.hibernate.cfg.AnnotationConfiguration</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.proxool.xml">hibernate/proxool.xml</prop>
<prop key="hibernate.proxool.pool_alias">webtools_proxool</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.Oracle9iDialect</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<prop key="hibernate.use_sql_comments">${hibernate.use_sql_comments}</prop>
<prop key="hibernate.use_outer_join">${hibernate.use_outer_join}</prop>
<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.max_fetch_depth">1</prop>
</props>
</property>
//通过配置configLocation属性指定 hibernate根配置位置
<property name="configLocation">
<value>classpath:hibernate/hibernate.cfg.xml</value>
</property>
</bean>
2.2、或者在spring的配置文件中配置dataSource和sessionFactory
<bean id="dataSource" class="com.mchange.v2.c3po.ComboPooledDataSource">
<property name="jdbcUrl/user/password" />
......
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
//通过注释的方式写关系对象映射时需要加的配置
<property name="configurationClass">
<value>org.hibernate.cfg.AnnotationConfiguration</value>
</property>
<property name="dataSource" ref="dataSource" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.Oracle9iDialect</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<prop key="hibernate.use_sql_comments">${hibernate.use_sql_comments}</prop>
<prop key="hibernate.use_outer_join">${hibernate.use_outer_join}</prop>
<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.max_fetch_depth">1</prop>
</props>
</property>
//通过配置configLocation属性指定 hibernate根配置位置
<property name="configLocation">
<value>classpath:hibernate/hibernate.cfg.xml</value>
</property>
</bean>
三、通过hibernate.cfg.xml来指定各个实体类
<hibernate-configuration>
<session-factory>
<mapping class="com.watchdata.mepay.domain.AdminInfo" />
<mapping class="com.watchdata.mepay.domain.UserInfo" />
<mapping class="com.watchdata.mepay.domain.Group" />
<mapping class="com.watchdata.mepay.domain.ActivateLog"/>
</session-factory>
</hibernate-configuration>
四、使用注释的方式写对象关系映射
1、表映射
@Entity
@Table(name = "ADMIN_INFO", schema = "MEPAYTWO", uniqueConstraints = @UniqueConstraint
(columnNames = "NAME"))
建立本实体@Entity与表@Table之间的映射。
name = "ADMIN_INFO":表示表名。
schema = "MEPAYTWO":数据库名。
uniqueConstraints = @UniqueConstraint(columnNames = "NAME")):约束定义--唯一性约束。
2、主键字段映射
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "admin_seq")
@SequenceGenerator(name = "admin_seq", sequenceName = "ADMIN_SEQ", allocationSize = 1)
@Column(name = "ADMIN_ID", unique = true, nullable = false, precision = 22, scale = 0)
建立主键字段与表中主键之间的映射,并且指定主键生成策略
(strategy = GenerationType.SEQUENCE, generator = "admin_seq")
指定主键生成策略GenerationType.SEQUENCE,及生产者admin_seq(下面会定义)
@SequenceGenerator(name = "admin_seq", sequenceName = "ADMIN_SEQ", allocationSize = 1)
定义一个序列主键生产者名字为admin_seq,对应于MEPAYTWO数据库中的ADMIN_SEQ序列
(我们需要在MEPAYTWO中建立一个这样的序列)
3、普通字段映射
@Column(name = "NAME", unique = true, nullable = false, length = 20)
4、一对多映射
@OneToMany(targetEntity = com.watchdata.mepay.domain.AdminGroup.class,
fetch = FetchType.LAZY,mappedBy="admin")
@Cascade(value={CascadeType.SAVE_UPDATE})
@JoinColumn(name = "ADMIN_ID")
public List<AdminGroup> getAdminGroupList(){
return adminGroupList;
}
一个用户可以属于多个组(拥有多个组的权限)
我们定义一个list变量使得我们在“一”的一方可以轻松的访问“多”
targetEntity = com.watchdata.mepay.domain.AdminGroup.class:指定目标类(多一方)
mappedBy="admin":多的一方靠那个属性知道他属于这个“一”
JoinColumn(name = "ADMIN_ID"):多的一方根据此外键连接到我们的“一”
5、一对多映射
@ManyToOne(targetEntity=AdminInfo.class)
@JoinColumn(name="ADMIN_ID")
五、利用HibernateDaoSupport以及接口+继承+范型的思想规划和实现Dao类
1、思想规划:
1.1、运用范型定义了一个基本接口(IEntityDao<T>):其中声明了每个Dao都会用到的接口方法。
1.2、为每个Dao定义了一个具体的接口:其继承自基本接口,同时定义了本Dao特有的接口方法。
继承的时候把范型具体化,如:extend IEntityDao<AdminInfo>。
1.3、运用范型定义了一个Dao基类(HibernateEntityDao<T>),继承自 HibernateDaoSupport,
实现基本接口中的方法,使得具体的Dao类只要继承自这个基类就具有了基本接口中声明的功能。
1.4、定义具体的Dao类,继承自Dao基类,实现具体的Dao接口。继承的时候要把范型具体化,如:
extends HibernateEntityDao<ActivateLog>,这里面主要实现具体Dao接口中定义的方法,
基本Dao接口方法已经通过继承自Dao基类实现了。
2、具体介绍:
2.1 IEntityDao
public interface IEntityDao<T> {
//根据Domain ID 获得一个Domain 对象
T get(Serializable id);
//获得数据库中所有的Domain 对象.如果数据库内记录巨大的话,请慎用此方法
List<T> getAll();
//保存传入的Domain 对象进入数据库
void save(Object o);
//保存或更新传入的Domain 对象进入数据库
void saveOrUpdate(Object o);
//从数据库中删除此Domain 对象对应的数据
void remove(Object o);
//根据Domain 对象的ID 从数据库中删除相应的记录
void removeById(Serializable id);
//获取Entity对象的主键名
String getIdName(Class clazz);
}
2.2、HibernateEntityDao
public class HibernateEntityDao<T> extends HibernateDaoSupport implements IEntityDao<T> {
protected Class<T> entityClass;// DAO所管理的Entity类型.
//在构造函数中将泛型T.class赋给entityClass.
public HibernateEntityDao() {
entityClass = GenericUtils.getSuperClassGenricType(getClass());
}
//根据ID获取对象.
public T get(Serializable id) {
return (T) getHibernateTemplate().get(getEntityClass(), id);
}
//获取全部对象
public List<T> getAll() {
return getHibernateTemplate().loadAll(getEntityClass());
}
//获取全部对象,带排序参数.
public List<T> getAll(String orderBy, boolean isAsc) {
return getAll(getEntityClass(), orderBy, isAsc);
Assert.hasText(orderBy);
if (isAsc) {
return getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(getEntityClass()).addOrder(
Order.asc(orderBy)));
} else {
return getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(getEntityClass()).addOrder(
Order.desc(orderBy)));
}
}
//保存对象
public void save(Object o) {
getHibernateTemplate().save(o);
}
//保存对象或更新
public void saveOrUpdate(Object o){
getHibernateTemplate().saveOrUpdate(o);
}
//保存对象,批量保存.
public void saveOrUpdateAll(Collection c) {
getHibernateTemplate().saveOrUpdateAll(c);
}
//删除对象
public void remove(Object o) {
getHibernateTemplate().delete(o);
}
//根据ID移除对象.
public void removeById(Serializable id) {
remove(get(getEntityClass(), id));
}
//批量删除.
public void removeAll(Collection col) {
getHibernateTemplate().deleteAll(col);
}
//创建Query对象.
//对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query 后自行设置.
//留意可以连续设置,如 dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();
//调用方式如下:
// dao.createQuery(hql); 或 dao.createQuery(hql,arg0); 或
// dao.createQuery(hql,arg0,arg1); 或 dao.createQuery(hql,new Object[arg0,arg1,arg2])
public Query createQuery(String hql, Object... values) {
Assert.hasText(hql);
Query query = getSession().createQuery(hql);
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
return query;
}
//取得Entity的Criteria.参数是criterions:可变的Restrictions条件列表
public Criteria createCriteria(Criterion... criterions) {
DetachedCriteria criteria=DetachedCriteria.forClass(getEntityClass());
for (Criterion c : criterions) {
criteria.add(c);
}
return criteria;
}
//取得Entity的Criteria,带排序参数.
public Criteria createCriteria(String orderBy, boolean isAsc, Criterion... criterions) {
Assert.hasText(orderBy);
DetachedCriteria criteria = createCriteria(entityClass, criterions);
if (isAsc) {
criteria.addOrder(Order.asc(orderBy));
} else {
criteria.addOrder(Order.desc(orderBy));
}
return criteria;
}
//根据属性名和属性值查询对象.
public List<T> findBy(String propertyName, Object value) {
Assert.hasText(propertyName);
DetachedCriteria criteria = createCriteria(Restrictions.eq(propertyName, value));
List<T> list=getHibernateTemplate().findByCriteria(criteria);
return list;
}
//根据属性名和属性值查询对象,带排序参数.
public List<T> findBy(String propertyName, Object value, String orderBy, boolean isAsc) {
Assert.hasText(propertyName);
Assert.hasText(orderBy);
DetachedCriteria criteria =createCriteria(
orderBy, isAsc,Restrictions.eq(propertyName, value));
List<T> list=this.getHibernateTemplate().findByCriteria(criteria);
return list;
}
//根据属性名和属性值查询单个对象.
public T findUniqueBy(String propertyName, Object value) {
Assert.hasText(propertyName);
DetachedCriteria criteria =createCriteria(Restrictions.eq(propertyName, value));
List<T> list=this.getHibernateTemplate().findByCriteria(criteria);
return list!=null&&list.size()>0?list.get(0):null;
}
//消除与 Hibernate Session 的关联
public void evit(Object entity){
getHibernateTemplate().evict(entity);
}
//取得entityClass.
protected Class<T> getEntityClass() {
return entityClass;
}
//用hql执行update和delete操作,用于小批量操作
public void excuteHql(String hql,Object...values){
getHibernateTemplate().bulkUpdate(hql, values);
}
}
2.3、为每个具体的dao建立一个接口 extend IEntityDao<Entity>
其中定义这个dao需要的IEntityDao中没有声明的特需功能
2.4、为每个具体的dao定义一个实现类,实现具体接口,extend HibernateEntityDao<Entity>
实现具体接口中定义的,基类没有实现的功能。
发表评论
-
Hibernate工作原理
2010-10-03 10:34 4093Hibernate工作原理 图 ... -
Hibernate基础
2010-09-19 09:43 1133Hibernate基础 Part 1 1. ... -
hibernate一对一映射外键关联
2010-09-17 11:24 1309hibernate一对一映射外键关联 一对一外键关联 外键关 ... -
在Hibernate中使用JDBC事务
2010-09-16 14:21 1281在Hibernate中使用JDBC事务 Hibernate ... -
hibernate事务,一级缓存,二级缓存
2010-09-16 12:34 1156hibernate主要从以下几个 ... -
Hibernate的五个核心接口介绍
2010-09-16 12:14 1003所有的Hibernate应用中都会访问Hibernate的 ... -
Hibernate缓存配置/批量处理
2010-09-16 12:01 1186Hibernate缓存配置/批量处 ... -
hibernate知识点总结
2010-09-16 08:48 1282hibernate知识点总结 1.hibernate的优缺点 ... -
项目缓存方案总结
2010-09-16 08:42 841项目缓存方案总结 一 ... -
hibernate缓存总结
2010-09-16 08:30 965hibernate缓存总结: 缓存是位于应用程序与 ... -
Hibernate中一级缓存、二级缓存及查询缓存的技术性总结
2010-09-15 22:54 867一、 一级缓存 1. 一级缓存只缓存整个对象 ... -
Hiberante3 一级缓存总结
2010-09-15 22:53 438Hiberante3 一级缓存总结 1. ... -
Hibernate中的缓存总结
2010-09-15 22:51 982Hibernate中的缓存总结 Hibernate ... -
hibernate缓存相关
2010-09-15 22:49 807hibernate缓存相关 hibernat ... -
hibernate技术面试相关
2010-09-13 20:51 1147Hibernate 中数据表映射关 ... -
hibernate 相关面试题
2010-09-13 20:50 10081.在数据库中条件查询 ... -
hibernate get()与load()的区别
2010-09-13 15:36 818hibernate get()与load()的区别 s ... -
Hibernate持久化对象的生命周期
2010-09-13 11:06 1052持久化对象的状态: ... -
Hibernate中持久化类实例的三种状态
2010-09-13 10:59 2126在Hibernate中持久化类实 ... -
全面介绍Hibernate持久化类
2010-09-13 10:55 1201Hibernate持久化类使用的是JavaBean的风格,为要 ...
相关推荐
本教程将重点介绍如何使用Maven作为项目管理工具,结合Spring MVC作为控制层框架和Hibernate作为持久层框架,来构建一个完整的Web应用。Maven是Apache组织提供的一个项目管理和综合工具,它可以帮助我们管理项目的...
在本文中,我们将结合Struts、Spring和Hibernate三种技术来完成用户登陆系统的实现。下面是相关的知识点总结: 一、Struts框架简介 * Struts是一个基于MVC模式的Web应用程序框架,用于构建Java Web应用程序。 * ...
通过结合JSP的视图呈现、Spring的控制层管理和Hibernate的数据持久化,开发者能够快速、高效地开发出具有复杂业务逻辑的博客平台。如果你希望深入了解这个系统的实现细节,需要深入研究源代码和配置文件,理解它们...
总结,Hibernate与Spring的整合是Java开发中的常见实践,它将ORM的强大功能与Spring的全面管理相结合,为开发者带来了极大的便利。理解和掌握这种整合方式,对于提升Java EE应用开发的效率和质量至关重要。
在本节中,我们将详细介绍如何在MyEclipse环境下实现JSF、Hibernate和Spring的完美结合。 ##### 1. 添加依赖库 首先,需要在项目中添加必要的JAR文件。可以通过MyEclipse的插件管理器选择“Hibernate”、“JSF”和...
SSH(Struts+Spring+Hibernate)是Java Web开发中一种常见的技术栈,它将MVC设计模式、依赖注入和持久层框架集成为一个整体,大大提高了开发效率和代码的可维护性。下面我们将深入探讨SSH框架的各个组成部分及其结合...
3. **模型**:Struts不强制规定模型层的具体实现,模型通常与业务逻辑紧密相关,可以与其他持久化技术(如Hibernate)结合使用。 **Spring** 是SSH中的业务逻辑层框架,它是一个轻量级的框架,核心特性是控制反转...
总结来说,连接池、Spring和Hibernate的结合是现代Java Web应用的常见架构模式,它们相互配合,提供了高效、可靠的数据库访问方式。理解并熟练掌握这些知识,对于提升应用的性能和可维护性至关重要。
总结来说,这个"spring4+hibernate4整合例子"涵盖了以下几个关键点: 1. Spring4的依赖注入和面向切面编程 2. Hibernate4的对象关系映射 3. Spring4对Hibernate4的事务管理支持 4. 使用JUnit进行测试驱动开发 5. ...
**Spring+Hibernate+MySql应用实例详解** 在Java Web开发领域,Spring、Hibernate和MySQL是三个非常关键的技术组件。Spring作为一个全面的框架,提供了一种轻量级的控制反转(IoC)和面向切面编程(AOP)的解决方案...
总结来说,Spring集成Hibernate在MyEclipse环境下,主要是通过配置Spring的IoC容器和事务管理,结合Hibernate的ORM能力,实现高效的数据库操作。这个过程涉及到了项目结构、配置文件、实体类、DAO、Service等多个...
在IT行业中,开发高效、可维护的Web应用程序是至关重要的,而Tapestry、Hibernate和Spring框架的结合使用,能够帮助我们实现这一目标。本文将深入探讨如何在实际项目中运用这三个技术,以及它们如何协同工作,以实现...
综上所述,Hibernate和Spring的结合使用能大幅提升Java应用程序的开发效率,但同时也需要开发者对两者有深入的理解,以解决可能出现的性能和设计难题。掌握这些技术要点,有助于在实际项目中更好地运用这两个强大的...
1. **事务管理**:Spring提供了一套声明式事务管理机制,可以方便地与Hibernate等持久层技术结合使用,实现细粒度的事务控制。 2. **对象关系映射**:Hibernate通过配置文件或注解的方式定义实体类与数据库表之间的...
当Spring、SpringMVC和Hibernate结合使用时,Spring作为整体框架,负责管理应用的生命周期和组件依赖;SpringMVC处理HTTP请求,调用业务逻辑;而Hibernate则负责数据的持久化操作。例如,SpringMVC的Controller可以...
接下来,我们需要实现上述定义的泛型接口,并结合Spring框架来管理Hibernate的Session生命周期和事务处理。具体实现如下: ```java public class HibernateDaoImpl, PK extends Serializable> implements ...
2. Hibernate事务管理:使用`HibernateTransactionManager`结合SessionFactory进行事务控制。 3. AOP(面向切面编程)在事务管理中的应用:`TransactionInterceptor`基于AOP拦截方法调用,处理事务。 4. 配置事务...
当这三个框架结合使用时,它们各自负责不同的职责。Struts作为前端控制器,处理HTTP请求并调用业务逻辑;Spring作为整个应用的中枢,管理所有对象的依赖关系,并提供事务管理和AOP功能;Hibernate则负责对象和数据库...
Spring 和 Hibernate 的整合是企业级 Java 应用开发中的常见实践,它将 Spring 框架的控制反转(IoC)和面向切面编程(AOP)优势与 Hibernate 的持久化能力相结合,提供了更高效、灵活的数据库操作。下面我们将深入...