Hibernate4
hibernate的基本用法
hibernate的基本用法Hibernate是一个开源的Java框架,用于简化数据库操作。
它为开发人员提供了一个更加简单、直观的方式来管理数据库,同时也提高了应用程序的性能和可维护性。
本文将逐步介绍Hibernate的基本用法,包括配置、实体映射、数据操作等。
一、配置Hibernate1. 下载和安装Hibernate:首先,我们需要下载Hibernate的压缩包并解压。
然后将解压后的文件夹添加到Java项目的构建路径中。
2. 创建Hibernate配置文件:在解压后的文件夹中,可以找到一个名为"hibernate.cfg.xml"的文件。
这是Hibernate的主要配置文件,我们需要在其中指定数据库连接信息和其他相关配置。
3. 配置数据库连接:在"hibernate.cfg.xml"文件中,我们可以添加一个名为"hibernate.connection.url"的属性,用于指定数据库的连接URL。
除此之外,还需要指定数据库的用户名和密码等信息。
4. 配置实体映射:Hibernate使用对象关系映射(ORM)来将Java类映射到数据库表。
我们需要在配置文件中使用"mapping"元素来指定实体类的映射文件。
这个映射文件描述了实体类与数据库表之间的对应关系。
二、实体映射1. 创建实体类:我们需要创建一个Java类,用于表示数据库中的一行数据。
这个类的字段通常与数据库表的列对应。
同时,我们可以使用Hibernate提供的注解或XML文件来配置实体的映射关系。
2. 创建映射文件:可以根据个人喜好选择使用注解还是XML文件来配置实体类的映射关系。
如果使用XML文件,需要创建一个与实体类同名的XML文件,并在其中定义实体类与数据库表之间的映射关系。
3. 配置实体映射:在配置文件中,我们需要使用"mapping"元素来指定实体类的映射文件。
spring4.x + hibernate4.x 配置详解
spring4.x + hibernate4.x 配置详解关于spring和hibernate的使用以及特征等等,在此不再啰嗦,相信大家也都知道,或者去搜索一下即可。
本篇博文的内容主要是我最近整理的关于spring4.x 和hibernate 4.x 相关配置和使用方式,当然spring3.x以及hibernate4.x也可以借鉴。
首先是配置文件web.xml 增加以下代码即可<!-- 加载spring相关的配置文件--><context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:/applicationContext.xml</param-value> </context-param><!-- 启用spring监听--><listener><listener-class>org.springframework.web.context.ContextLoaderListener</l istener-class></listener>然后建立 applicationContext.xml 文件,src下。
文件内容如下,注释我尽量写的很详细<beans xmlns:xsi="/2001/XMLSchema-instance"xmlns="/schema/beans"xmlns:aop="http://ww /schema/aop"xmlns:context="/schema/context"xmlns:tx="ht tp:///schema/tx"xmlns:cache="/schema/cache"xmlns:p="http:// /schema/p"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-4.0.xsd/schema/aop/schema/aop/spring-aop-4.0.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd/schema/cache http://www.springframewor /schema/cache/spring-cache-4.0.xsd"><!-- 引入properties文件--><context:property-placeholder location="classpath*:/appConfig.properties"/> <!-- 定义数据库连接池数据源bean destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用--> <bean id="dataSource"class="boPooledDataSourc e"destroy-method="close"><!-- 设置JDBC驱动名称--><property name="driverClass"value="${jdbc.driver}"/><!-- 设置JDBC连接URL --><property name="jdbcUrl"value="${jdbc.url}"/><!-- 设置数据库用户名--><property name="user"value="${ername}"/><!-- 设置数据库密码--><property name="password"value="${jdbc.password}"/><!-- 设置连接池初始值--><property name="initialPoolSize"value="5"/></bean><!-- 配置sessionFactory --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><!-- 数据源--><property name="dataSource"ref="dataSource"/><!-- hibernate的相关属性配置--><property name="hibernateProperties"><value><!-- 设置数据库方言-->hibernate.dialect=org.hibernate.dialect.MySQLDialect<!-- 设置自动创建|更新|验证数据库表结构-->hibernate.hbm2ddl.auto=update<!-- 是否在控制台显示sql -->hibernate.show_sql=true<!-- 是否格式化sql,优化显示-->hibernate.format_sql=true<!-- 是否开启二级缓存-->e_second_level_cache=false<!-- 是否开启查询缓存-->e_query_cache=false<!-- 数据库批量查询最大数-->hibernate.jdbc.fetch_size=50<!-- 数据库批量更新、添加、删除操作最大数-->hibernate.jdbc.batch_size=50<!-- 是否自动提交事务-->hibernate.connection.autocommit=true<!-- 指定hibernate在何时释放JDBC连接-->hibernate.connection.release_mode=auto<!-- 创建session方式hibernate4.x 的方式-->hibernate.current_session_context_class=org.springframework.or m.hibernate4.SpringSessionContext<!-- javax.persistence.validation.mode默认情况下是auto的,就是说如果不设置的话它是会自动去你的classpath下面找一个bean-validation**包所以把它设置为none即可-->javax.persistence.validation.mode=none</value></property><!-- 自动扫描实体对象tdxy.bean的包结构中存放实体类--><property name="packagesToScan"value="tdxy.bean"/> </bean><!-- 定义事务管理--><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager "><property name="sessionFactory"ref="sessionFactory"/> </bean><!-- 定义Autowired 自动注入bean --><bean class="org.springframework.beans.factory.annotation.AutowiredAnnotati onBeanPostProcessor"/><!-- 扫描有注解的文件base-package 包路径--><context:component-scan base-package="tdxy"/><tx:advice id="txAdvice"transaction-manager="transactionManager"> <tx:attributes><!-- 事务执行方式REQUIRED:指定当前方法必需在事务环境中运行,如果当前有事务环境就加入当前正在执行的事务环境,如果当前没有事务,就新建一个事务。
Hibernate4实现单表CRUD
Hibernate4.1实现单表CRUD 学习JavaWeb的人,我想对Hibernate都不陌生,是一个比较流行的ORM框架,ORM 简称对象关系映射,那你用此框架实现过单表的CRUD吗;我们来试试利用hibernate实现单表的CRUD,也就是我们所说的增删改查;·打开我们熟悉常用的开发工具myeclipse;·新建项目Hibernate4Project·添加Hibernate开发支持,很多人使用的手动配置,其实也是可以自动配置的,右键项目Myeclipse→Project Facets→Install Hibernate Facet 表示添加Hibernate开发支持,不用你在很多JAR包中寻找了;·然后选择4.1版本,下面默认然后下一步Next;·下面按照如图配置即可,在java package那一个文本框之中,如果你没有建立包的话,就点击后面的New,然后继续NEXT;·下面我们要选择我们要操作的数据源,前提你一定要配置好数据源,如果选择,如果你没配置DB Driver的话,是没有其他选项的,点击Next·下面就是选择插件的了,如果你不需要什么插件,就选择核心包即可,core包;·点击finish即可,现在hibernate的开发支持就OK了;·如果你没有配置数据源可以看下此项选择Window→Other·下面选择要打开的视图DB Browser·你会看到下面的一个视图被打开了,应该在右下角显示的;·新建一个你要连接的数据库,空白出点击右键→new·在下面这个界面中配置就OK了;Driver template 选择你要连接的数据库类型;Driver name 自定义一个名称即可;Connection URL 数据库连接地址;User name 数据库用户名;Password 密码Drive JAR 数据库驱动包;Driver classname 选择一个常用的驱动Save password 勾选此项,然后点击Test Driver最后保存即可;·然后我们继续我们的单表CRUD实现;当我们添加好hibernate支持的时候,myeclipse会自动生成一个HibernateSessionFactory.java的类,这个类就是我们在用的数据库连接类,在hibernate之中,一个数据库连接叫做一个session,可以看下下面的这个类,我添加了一些注释;package cn.oracle.dbc;import org.hibernate.HibernateException;import org.hibernate.Session;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;/*** 数据库连接类* @author congz_000**/public class HibernateSessionFactory {/*** ThreadLocal 保存数据库连接;*/private static final ThreadLocal<Session> threadLocal = newThreadLocal<Session>();/*** 连接工厂*/private static org.hibernate.SessionFactory sessionFactory;private static Configuration configuration = new Configuration();private static ServiceRegistry serviceRegistry;static {try {configuration.configure();serviceRegistry = newServiceRegistryBuilder().applySettings(configuration.getProperties()).buildS erviceRegistry();sessionFactory =configuration.buildSessionFactory(serviceRegistry);} catch (Exception e) {System.err.println("%%%% Error Creating SessionFactory %%%%");e.printStackTrace();}}/*** 无参构造方法*/private HibernateSessionFactory() {}/*** 静态方法,我们用来得到数据库的连接;* @return返回一个数据库连接;* @throws HibernateException*/public static Session getSession() throws HibernateException {Session session = (Session) threadLocal.get();if (session == null || !session.isOpen()) {if (sessionFactory == null) {rebuildSessionFactory();}session = (sessionFactory != null) ? sessionFactory.openSession(): null;threadLocal.set(session);}return session;}/*** 从名称可以看到重建连接工厂;*/public static void rebuildSessionFactory() {try {configuration.configure();serviceRegistry = newServiceRegistryBuilder().applySettings(configuration.getProperties()).buildS erviceRegistry();sessionFactory =configuration.buildSessionFactory(serviceRegistry);} catch (Exception e) {System.err.println("%%%% Error Creating SessionFactory %%%%");e.printStackTrace();}}/*** 关闭数据库连接,静态方法,可以类名称直接调用;* @throws HibernateException*/public static void closeSession() throws HibernateException {Session session = (Session) threadLocal.get();threadLocal.set(null);if (session != null) {session.close();}}/*** 建立数据库连接工厂;* @return*/public static org.hibernate.SessionFactory getSessionFactory() { return sessionFactory;}public static Configuration getConfiguration() {return configuration;}}·我们还需要映射表,我们拿emp表来做,打开你创建的数据源,然后我们找到要操作的表,右键Hibernate Reverse Engineering·选择创建的pojo的位置,和一些自动生成配置,选择NEXT;·下面选择主键的生成类型ID Generator,选择assigned 表示指派,也就是自定义;·下一步同样,选择assigned ,其他不做修改,点击Finish;·等一会就会生成一个简单java 类和一个Emp.hbm.xml文件,如果此表中有关系字段的话,删除即可;Emp.javapackage cn.oracle.pojo;import java.util.Date;@SuppressWarnings("serial")public class Emp implements java.io.Serializable {private Short empno;private String ename;private String job;private Short mgr;private Date hiredate;private Double sal;private Double comm;}Emp.hbm.xml<?xml version="1.0"encoding="utf-8"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN" "/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="cn.oracle.pojo.Emp"table="EMP"schema="SCOTT">→对应的数据表和用户<id name="empno"type="ng.Short">→字段empno的数据类型及对应的列名称和允许的大小,及主键的指派类型;<column name="EMPNO"precision="4"scale="0"/><generator class="assigned"></generator></id><property name="ename"type="ng.String">→对应的列名称和精度<column name="ENAME"length="10"/></property><property name="job"type="ng.String">→job字段对象的列和精度<column name="JOB"length="9"/></property><property name="mgr"type="ng.Short"><column name="MGR"precision="4"scale="0"/></property><property name="hiredate"type="java.util.Date"><column name="HIREDATE"length="7"/></property><property name="sal"type="ng.Double"><column name="SAL"precision="7"/></property><property name="comm"type="ng.Double"><column name="COMM"precision="7"/></property></class></hibernate-mapping>·以上就是自动生成,需要简单修改的一部分,下面的就需要自己编写了,不过和从头到尾不用工具实现的CRUD相对简单多了;·编写DAO接口,首先我们可以编写一个公共的接口IDAO.javaIDAO.javapackage cn.oracle.dao;import java.util.List;/*** 一个公共接口,实现单表的CRUD加分页的操作;* @author congz_000** @param<K>主键类型* @param<V>简单java类*/public interface IDAO<K,V> {/*** 实现数据的增加* @param vo 简单java类对象;* @return返回boolean值,返回true表示增加成功,false表示添加失败!* @throws Exception*/public boolean doCreat(V vo)throws Exception;/*** 删除一条数据;* @param id 参数是删除数据的主键类型;* @return返回boolean数据类型,true表示删除成功,false表示删除失败;* @throws Exception*/public boolean doRemove(K id)throws Exception;/*** 修改一条数据;* @param vo 参数为简单java类对象;* @return返回boolean 类型,true表示修改成功,false表示修改失败;* @throws Exception*/public boolean doUpdate(V vo)throws Exception;/*** 查询一条数据* @param id 根据参数id查询数据;* @return返回一个简单java类对象;* @throws Exception*/public V findById(K id)throws Exception;/*** 查询表中所有数据;* @return返回一个List集合,里面是每条数据对应的简单java类对象;* @throws Exception*/public List<V> list()throws Exception;/*** 模糊查询* @param column 要模糊查询的列;* @param keyWord 模糊查询的关键字;* @param currentPage 当前页数;* @param lineSize 每页显示数据条目数;* @return返回一个list集合;* @throws Exception*/public List<V> list(String column,String keyWord,IntegercurrentPage,Integer lineSize)throws Exception;/*** 统计模糊查询的条目数;* @param column 要模糊查询的列;* @param keyWord 要模糊查询的关键字;* @return* @throws Exception*/public Integer getAllCount(String column,String keyWord)throws Exception; }IEmpDAO.java 直接继承IDAO即可;package cn.oracle.dao;import cn.oracle.pojo.Emp;public interface IEmpDAO extends IDAO<Short, Emp> {}·IEmpDAO接口的实现类,EmpDAOImpl.javapackage cn.oracle.dao.impl;import java.util.List;import org.hibernate.Query;import cn.oracle.dao.IEmpDAO;import cn.oracle.dbc.HibernateSessionFactory;import cn.oracle.pojo.Emp;public class EmpDAOImpl implements IEmpDAO {@Overridepublic boolean doCreat(Emp vo) throws Exception {String hql="INSERT INTOemp(empno,ename,job,hiredate,sal,comm)VALUES(?,?,?,?,?,?)";Query query=HibernateSessionFactory.getSession().createQuery(hql);query.setShort(0, vo.getEmpno());query.setString(1,vo.getEname());query.setString(2, vo.getJob());query.setDate(3, vo.getHiredate());query.setDouble(4,vo.getSal());query.setDouble(5, vo.getComm());return query.executeUpdate()==1;}@Overridepublic boolean doRemove(Short id) throws Exception {String hql="DELETE FROM emp AS n WHERE n.empno=?";Query query=HibernateSessionFactory.getSession().createQuery(hql);query.setShort(0, id);return query.executeUpdate()>0;}@Overridepublic boolean doUpdate(Emp vo) throws Exception {String hql="UPDATE emp AS n SETn.ename=?,n.job=?,n.hiredate=?,n.sal=?,m=? WHERE n.empno=?";Query query=HibernateSessionFactory.getSession().createQuery(hql);query.setShort(1, vo.getEmpno());query.setString(2,vo.getEname());query.setString(3, vo.getJob());query.setDate(4, vo.getHiredate());query.setDouble(5,vo.getSal());query.setDouble(0, vo.getComm());return query.executeUpdate()>0;}@Overridepublic Emp findById(Short id) throws Exception {return (Emp) HibernateSessionFactory.getSession().get(Emp.class,id);}@SuppressWarnings("unchecked")@Overridepublic List<Emp> list() throws Exception {String hql="FROM emp AS n";Query query=HibernateSessionFactory.getSession().createQuery(hql);List<Emp> all=query.list();return all;}@Overridepublic List<Emp> list(String column, String keyWord, Integer currentPage, Integer lineSize) throws Exception {String hql=" SELECT empno,ename,job,hiredate,sal,comm "+ " FROM "+ " (SELECT empno,ename,job,hiredate,sal,comm,ROWNUM rn WHERE "+column+" LIKE ? ROWNUM<?)temp "+ " WHERE temp.rn>? ";Query query=HibernateSessionFactory.getSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");query.setInteger(1, currentPage*lineSize);query.setInteger(2,(currentPage-1)*lineSize);@SuppressWarnings("unchecked")List<Emp> all=query.list();return all;}@Overridepublic Integer getAllCount(String column, String keyWord) throws Exception {String hql="SELCT COUNT(empno) FROM emp WHERE "+column+" LIKE ?";Query query=HibernateSessionFactory.getSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");return query.executeUpdate();}}·建立工厂类DAOFactory.javapackage cn.oracle.factory;import cn.oracle.dao.IEmpDAO;import cn.oracle.dao.impl.EmpDAOImpl;public class DAOFactory {public static IEmpDAO getIEmpDAOInstance(){return new EmpDAOImpl();}}建立IEmpService.java接口;package cn.oracle.service;import java.util.List;import java.util.Map;import cn.oracle.pojo.Emp;public interface IEmpService {public boolean insert(Emp vo)throws Exception;public boolean update(Emp vo)throws Exception;public boolean delete(int id)throws Exception;public Emp get(int id)throws Exception;public List<Emp> list()throws Exception;public Map<String,Object> list(String column,String keyWord,Integer currentPage,Integer lineSize)throws Exception;}·建立接口IEmpService.java的实现类,EmpServiceImpl.javapackage cn.oracle.service.impl;import java.util.HashMap;import java.util.List;import java.util.Map;import cn.oracle.dbc.HibernateSessionFactory;import cn.oracle.factory.DAOFactory;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;public class EmpServiceImpl implements IEmpService {@Overridepublic boolean insert(Emp vo) throws Exception {try{return DAOFactory.getIEmpDAOInstance().doCreat(vo);}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}@Overridepublic boolean update(Emp vo) throws Exception {try{return DAOFactory.getIEmpDAOInstance().doUpdate(vo);}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}@Overridepublic boolean delete(Short id) throws Exception {try{return DAOFactory.getIEmpDAOInstance().doRemove(id);}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}@Overridepublic Emp get(Short id) throws Exception {try{return DAOFactory.getIEmpDAOInstance().findById(id);}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}@Overridepublic List<Emp> list() throws Exception {try{return DAOFactory.getIEmpDAOInstance().list();}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}@Overridepublic Map<String, Object> list(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { Map<String,Object> map=new HashMap<String,Object>();try{map.put("allEmps", DAOFactory.getIEmpDAOInstance().list(column, keyWord, currentPage, lineSize));map.put("allCount",DAOFactory.getIEmpDAOInstance().getAllCount(column, keyWord));return map;}catch(Exception e){throw e;}finally{HibernateSessionFactory.getSession().beginTransaction().commit();HibernateSessionFactory.closeSession();}}}·最后的工厂类,ServiceFactory.javapackage cn.oracle.factory;import cn.oracle.service.IEmpService;import cn.oracle.service.impl.EmpServiceImpl;public class ServiceFactory {public static IEmpService getIEmpServiceInstance(){ return new EmpServiceImpl();}}OK 到此完成;。
Struts2+Spring3+Hibernate4+Maven整合
Struts2+Spring3+Hibernate4+Maven整合目录1.建立Maven工程2.搭建Spring33.搭建Struts2并整合Spring34.搭建Hibernate4并整合Spring3内容1.建立Maven工程第一步:第二步:第三步:第四步:注意:这里的JDK要选择默认的,这样别人在使用的时候,如何JDk不一致的话也不会出错,如下图所示:第五步:Maven标准目录src/main/javasrc/main/resourcessrc/test/javasrc/test/resources第六步:发布项目:Maven install清除编译过的项目:Maven cleanOK,Mean 工程创建成功!2. 搭建 Spring3(1)下载Spring3需要的jar包1.spring-core2.spring-context3.spring-jdbc4.spring-beans5.spring-web6.spring-expression7.spring-orm在pom.xml中编写Spring3需要的包,maven会自动下载这些包。
<!-- spring3 --><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-orm</artifactId><version>3.1.2.RELEASE</version></dependency>(2)编写Spring配置文件<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0.xsd "><!-- 引入属性文件 --><context:property-placeholderlocation="classpath:config.properties"/><!-- 自动扫描dao和service包(自动注入) --><context:component-scan base-package="com.zc.dao,com.zc.service" /></beans>(3)编写测试首先,在src/main/java中创建com.zc.service包,在包中编写一个UserService 接口,代码如下:package com.zc.service;/*** 测试* @author ZC* */public interface UserService {public void test();}然后,在src/main/java中创建com.zc.service.imple包,在包中编写UserServiceImple 实现类,代码如下:package com.zc.service.impl;import org.springframework.stereotype.Service;import erService;@Service("userService")public class UserServiceImpl implements UserService {@Overridepublic void test() {System.out.println("Hello World!");}}注意:@Service("userService")使用junit注解完成service 注入,所以还要在pom.xml中配置junit注解。
springmvc框架搭建之xml配置说明(spring4+hibernate4)
SpringMVC框架搭建说明Spring4.1.4 + hibernate4.3.81、web.xml配置程序运行时从web.xml开始,加载顺序为:context-param -> listener -> filter ->structs (如果使用structs的话)-> servlet如下为web.xml的配置说明<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance"xmlns="/xml/ns/javaee"xmlns:web="/xml/ns/javaee/web-app_2_5.xsd"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5"><!—-显示项目名称--><display-name>bmymis2</display-name><!-- 指定配置文件位置,contextConfigLocation是ContextLoaderListener中的一个参数,通过该参数在ContextLoaderListener中加载applicationContext-*.xml,并装配ApplicationContext --> <context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext-*.xml</param-value></context-param><!-- 定义SPRING监听器,启动Web容器时,自动装配ApplicationContext的配置信息--><listener><listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener><!—-字符编码过滤器,解决中文乱码问题--><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter><!—- springmvc配置--><servlet><servlet-name>springServlet</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath*:/spring-mvc.xml</param-value></init-param><load-on-startup>1</load-on-startup> //容器启动时首先初始化该servlet </servlet><servlet-mapping><servlet-name>springServlet</servlet-name><url-pattern>/</url-pattern> //表示所有页面都由springmvc处理</servlet-mapping><!—-浏览器输入到项目名,默认打开如下配置页面--><welcome-file-list><welcome-file>/web/login.jsp</welcome-file></welcome-file-list><!—-错误跳转页面--><error-page><error-code>404</error-code><location>/404.html</location></error-page></web-app>2、applicationContext-common.xml配置:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-4.0.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/aop/schema/aop/spring-aop-4.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><!-- 加载资源文件其中包含变量信息,必须在Spring配置文件的最前面加载,即第一个加载--><context:property-placeholder location="classpath:application.properties"/><!—-扫描包路径选项,使用annotation 自动注册bean,并保证@Required,@Autowired的属性被注入,有了该配置,那么<context:annotation-config/>这个配置就可以省略(以下配置包含了<context:annotation-config/>配置)--><context:component-scan base-package="xxx.xxx.xxx"/><!-- 数据源配置,使用应用内的DBCP数据库连接池 --><bean id="dataSource" class="mons.dbcp.BasicDataSource"destroy-method="close"><!-- 定义数据库连接池数据源bean destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用--><property name="driverClassName" value="${jdbc.driverClassName}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/></bean><!—Hibernate的注解配置 --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/><property name="hibernateProperties"><props><prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop><prop key="hibernate.dialect">${hibernate.dialect}</prop><prop key="hibernate.show_sql">${hibernate.show_sql}</prop></props></property><property name="packagesToScan" value="xxx.xxx.xxx.model" /></bean><!-- 配置Hibernate事务管理器 --><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><!-- 配置事务异常封装 --><bean id="persistenceExceptionTranslationPostProcessor"class="org.springframework.dao.annotation.PersistenceExceptionTranslationPost Processor"/><!-- 声明式容器事务管理 ,transaction-manager指定事务管理器为transactionManager --> <tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="add*" propagation="REQUIRED"/><tx:method name="get*" propagation="REQUIRED"/><tx:method name="*" read-only="true"/></tx:attributes></tx:advice><aop:config expose-proxy="true"><!-- 只对业务逻辑层实施事务 --><aop:pointcut id="txPointcut"expression="execution(*xxx.xxx.xxx.service..*.*(..))"/><!-- Advisor定义,切入点和通知分别为txPointcut、txAdvice --><aop:advisor pointcut-ref="txPointcut" advice-ref="txAdvice"/> </aop:config></beans>3、application.properties配置jdbc.driverClassName=org.postgresql.Driverjdbc.url=jdbc:postgresql://ip:5432/数据库名ername=postgresjdbc.password=123hibernate.dialect=org.hibernate.dialect.PostgreSQLDialecthibernate.show_sql=truehibernate.format_sql=false4、spring-mvc.xml配置<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><!-- 启用spring mvc 注解 --><mvc:annotation-driven><!-- 自动扫描且只扫描@Controller --><context:component-scan base-package="xxx.xxx.xxx "use-default-filters="false"></context:component-scan><!-- 定义JSP文件的位置 --><beanclass="org.springframework.web.servlet.view.InternalResourceView Resolver"><property name="prefix"value="/jsp/"/><property name="suffix"value=".jsp"/></bean><!-- 容器默认的DefaultServletHandler处理所有静态内容与无RequestMapping处理的URL--> <mvc:default-servlet-handler/><!-- 定义无需Controller的url<->view直接映射 --><mvc:view-controller path="/"view-name="login"/></beans>。
有关Hibernate3.3.2与3.6.10与4.1.10测试
有关Hibernate3.3.2与4.1.10测试
编辑人:星辰樱
1、建立起测试环境
首先导入测试所必需的JAR,必需的JAR包括(Hibernate3和lib\required下的所有JAR,同时还有导入相应版本slf4j-nop.jar。
Hibernate3.3.2所对应的是slf4j-nop-1.5.8.jar。
Hibernate3.6.10对应的是slf4j-nop-1.6.1.jar。
Hibernate4只需要导入lib\required下所有的JAR 就可以了。
)我们可以分别自定义三个版本的Hibernate JAR库,如图
第二个把JAR库导入项目,选择自定义的JAR库
最后导入数据库的JAR库。
2、编写测试代码
编写测试代码可以根据Hibernate的说明文档写非常的容易,要注意的是Hibernate的说明文档目前只有英文的。
1.首先我们在数据库中建立一张测试用的表,最好是简单,有主键。
2.建立一个实体类与表中的字段最好是相同,不同也行。
3.创建配置文件(hibernate.cfg.xml).
4.创建实体类与表的映射文件与实体类最好放在一起(UserBean.hbm.xml)。
5.编写测试类(Test)。
这是对Hibernate3的常规测试类。
这是对Hibernate4.1.10编写的测试类
为什么要分两个测试类,其实对Hibernate4也可以用Hibernate的测试类,当我们用Hibernate 的JAR库时,你们会看见有一句代码被线上了删除线,加上了删除线表示这个方法是过时
了的,所以最好是采用新的方法。
SpringMVC+Hibernate4+Spring3整合开发
SpringMVC+Hibernate4+Spring3整合开发·使用开发工具Myeclipse2014 、Subversion、·首先新建立一个项目SHSpringMVC ,组织好文件结构·将所建立的简单的项目发布到SVN服务器上,(如果你仅仅是想在本机搭建一个开发环境的话,不必要用SVN的,下面关于svn的发布,可以略过)选择SVN 点击Next;找到你的SVN服务资源库,如果没有的话,可以选择创建新的资源库位置;默认点击finish,然后把项目提交上去,就OK了,开始配置三个框架的开发,严谨来说是两个框架;看到如下图所示的界面说明你的项目就发布到SVN服务器上了;·接下来,就要配置开发包,也就是支持的JAR包,首先添加Spring支持,同时呢SpringMVC也是添加上了,我们要做的就是配置MVC框架;配置过程分为手动配置和自动配置,现在大部分工具都支持了自动配置,很少人再去手动配置编写配置文件了,那我们就采用自动配置的方式配置这两大框架的整合开发环境;在项目上右键→Myeclipse→Project Facets→Install Spring Facet持,点击Finish;右键空白处→new 按照下图所示配置,添加Hibernate支持,项目右键→myeclipse→project facets→install hibernate facet选择你刚刚创建的一个数据源,也就是下图显示的DB Driver,下面的一些信息就自动生成了;就选择默认核心包,没必要增加其他插件,OK 了;·增加完成之后,Hibernate 在applicationContext.xml 文件之中增加了如下的几个配置; <bean id ="sessionFactory" 这个bean 是用来连接数据库的,但是缺少了数据库的连接属性,连接属性,我们刚刚放到hibernate.cfg.xml文件之中了,但是为了项目的方便移植和可维护方便,我们就要把配置写到一个配置文件之中,所以需要在applicationContext.xml文件的sessionFactory这个bean之中增加priperty属性;class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="configLocation"value="classpath:hibernate.cfg.xml"></property>→当我们将c3p0的数据库配置添加好之后,这个配置也就可以删掉了;</bean><bean id="transactionManager"→这个bean用来配置事务提交的,不过还不完善,还需要配置很多东西,class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory"ref="sessionFactory"/> </bean>·下面我们新建立一个db.properties的资源文件,用来编写数据库连接信息;db.driverClass=org.gjt.mm.mysql.Driverdb.url=jdbc:mysql://localhost:3306/mysqlername=rootdb.password=mysqladmin我们怎么用这个配置文件呢,当然是需要在applicationContext.xml文件之中配置了;要想知道怎么配置使用这个database.properties这个资源文件,我们必须要了解的当然是ComboPooledDataSource这个类了,ng.Objectcom.mchange.v2.c3p0.impl.AbstractIdentityTokenizedcom.mchange.v2.c3p0.impl.IdentityTokenResolvablecom.mchange.v2.c3p0.impl.PoolBackedDataSourceBasecom.mchange.v2.c3p0.impl.AbstractPoolBackedDataSourcecom.mchange.v2.c3p0.AbstractComboPooledDataSourceboPooledDataSource我们看到ComboPooledDataSource这个类本身仅仅定义了几个构造方法而已,我们需要从他的父类中查找看看;我们能从文档中查到,有很多的setter、getter方法,这意味着什么呢,通过反射调用可以设置内容;也就是说,配置的dataSource这个bean的property的name值都是一定的,也就是不能自己定义,需要用提供好的那些属性名称,值也是有范围的;<bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"value="${db.driverClass}"/><property name="jdbcUrl"value="${db.url}"/><property name="user"value="${ername}"/><property name="password"value="${db.password}"/><property name="maxPoolSize"value="10000"/><property name="minPoolSize"value="1"/><property name="initialPoolSize"value="1"/><property name="maxIdleTime"value="20"/></bean>配置完成此bean就可与修改sessionFactory这个bean了,我们需要做的就是将其中的property修改为<bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/></bean>配置好这里,那hibernate.cfg.xml文件之中的数据库连接信息也就不需要了,我们就可以直接删掉了,hibernate.cfg.xml文件就编程如下的配置了,可以添加show_sql 、format_sql<?xml version='1.0'encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/dtd/hibernate-configuration-3.0.dtd"><!-- Generated by MyEclipse Hibernate Tools. --><hibernate-configuration><session-factory><property name="dialect">org.hibernate.dialect.MySQLDialect</property><property name="myeclipse.connection.profile">mysql</property><property name="show_sql">true</property><property name="format_sql">true</property></session-factory></hibernate-configuration>下面还是需要配置applicationContext.xml文件,配置事务通知属性,这个我也不是很了解怎么配置的,在网上找了一份,可以按照这个配置;<tx:advice id="txAdvice"transaction-manager="transactionManager"> <tx:attributes><tx:method name="update*"propagation="REQUIRED"/><tx:method name="insert*"propagation="REQUIRED"/><tx:method name="edit*"propagation="REQUIRED"/><tx:method name="save*"propagation="REQUIRED"/><tx:method name="add*"propagation="REQUIRED"/><tx:method name="new*"propagation="REQUIRED"/><tx:method name="set*"propagation="REQUIRED"/><tx:method name="remove*"propagation="REQUIRED"/><tx:method name="delete*"propagation="REQUIRED"/><tx:method name="change*"propagation="REQUIRED"/><tx:method name="get*"propagation="REQUIRED"read-only="true"/><tx:method name="list*"propagation="REQUIRED"read-only="true"/><tx:method name="find*"propagation="REQUIRED"read-only="true"/><tx:method name="load*"propagation="REQUIRED"read-only="true"/><tx:method name="*"propagation="REQUIRED"read-only="true"/> </tx:attributes></tx:advice>然后需要找一个log4j.properties的组件,在hibernate的开发文件包之中有一个,应该可以用,你从网上下载好hibernate的文件解压之后,从下面的这个目录可以找到一个log4j.properties文件;\hibernate-release-4.3.8.Final\hibernate-release-4.3.8.Final\project\etc最后要为项目添加annotation、aop、mvc开发支持,最重要的不要忘了,添加database.properties文件的位置,放到dataSource的bean上面就可以了;<context:property-placeholder location="classpath:database.properties"/>配置Annotation<context:annotation-config/><context:component-scan base-package="cn.oracle"/><mvc:annotation-driven/><mvc:default-servlet-handler/>接下来配置web.xml文件,配置Spring MVC的默认servlet处理用户请求;<servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet -class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value> </init-param></servlet><servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>*.action</url-pattern></servlet-mapping>此时你把项目部署到tomcat 或者weblogic上,看会不会报错,不报错误应该可开发使用了;如果你还要配置Springmvc的资源文件的话,还需要在applicationContext.xml文件之中配置另外一个bean <bean id="messageSource"class="org.springframework.context.support.ResourceBundleMessageSource"> <property name="basenames"><array><value>Message</value><value>Pages</value></array></property></bean>这上面的配置其实就是配置了ResourceBundleMessageSource 这个类下的basenames属性;private String[] basenames = new String[0];。
hibernate4学习笔记
hibernate4学习笔记Hibernate4学习笔记本⼈全部以⾃学为主,在⽹上收集各种学习资料,总结归纳学习经验,现将学习路径给予⼤家分享。
此次学习的hibernate的版本是:hibernate-release-4.2.4.Final(截⽌2015年7⽉31⽇最新版),JAVA的版本是:java8.0,使⽤的开发⼯具是:Eclipse Mars Release (4.5.0)。
第⼀天:Hibernate4基础知识和HelloWorld简单编程Hibernate是⼀种半成品ORM框架,对数据库持久化操作,程序员对数据库的操作转换成对对象的操作。
ORM 采⽤元数据来描述对象-关系映射细节, 元数据通常采⽤XML 格式, 并且存放在专门的对象-关系映射⽂件中。
HelloWorld简单编程1、准备Hibernate环境(1)导⼊Hibernate的Jar包,如下:(2)导⼊Mysql驱动包,我⽤的数据库是:Mysql 5.0,数据库驱动包如下:以上所有Jar加完毕之后,需要加⼊到Eclipse⾃⾝系统⾥⾯,具体如下:以上操作完毕之后,Hibernate的环境就算搭建完毕,下⾯就可以进⼀步操作。
2、配置hibernate.cfg.xml⽂件,主要是对数据库的连接,具体如下:"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/doc/63fa364d5022aaea998f0fde.html /hibernate-configuration-3.0.dtd ">rootmysqlname="connection.driver_class">com.mysql.jdbc.Driver jdbc:mysql:///Test(或者:jdbc:mysql://localhost:3306/Test)name="dialect">org.hibernate.dialect.MySQLInnoDBDialecttruetrueupdate3、编写⼀个实例类News.java,具体代码如下:package com.hibernate.helloworld;import java.sql.Date;public class News {private Integer id;private String title;private Date date;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}public News(String title, String author, Date date) { super();this.title = title;this.author = author;this.date = date;}public News(){}@Overridereturn"News [id="+ id+ ", title="+ title+ ", author="+ author + ", date=" + date + "]";}}4、创建News.hbm.xml配置映射⽂件,具体代码如下:"/doc/63fa364d5022aaea998f0fde.html /hibernate-mapping-3.0.dtd">5、将映射⽂件News.hbm.xml指定到hibernate.cfg.xml配置⽂件⾥⾯,即在hibernate.cfg.xml⽂件⾥加⼊⼀⾏映射代码,具体如下:6、创建hibernate API操作测试类(Juit测试),验证hibernate的优势效果,具体代码如下:package com.hibernate.helloworld;import java.sql.Date;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.Test;public class HibernateTest {@Testpublic void test() {//1. 创建⼀个 SessionFactory 对象SessionFactory sessionFactory=null;//1). 创建 Configuration 对象: 对应 hibernate 的基本配置信息和对象关系映射信息Configuration configuration=new Configuration().configure();//4.0 之前这样创建//sessionFactory=configuration.buildSessionFactory();//2). 4.0以后创建⼀个 ServiceRegistry 对象: hibernate 4.x 新添加的对象//hibernate 的任何配置和服务都需要在该对象中注册后才能有效.ServiceRegistry serviceRegistry=newServiceRegistryBuilder().applySettings(configuration.getProperties() ).buildServiceRegistry();sessionFactory=configuration.buildSessionFactory(serviceRegistry) ;//2. 创建⼀个 Session 对象Session session=sessionFactory.openSession();//3. 开启事务Transaction transaction=session.beginTransaction();//4. 执⾏保存操作News news = new News("Java12345", "ATGUIGU", new Date(new java.util.Date().getTime()));session.save(news);//5. 提交事务/doc/63fa364d5022aaea998f0fde.html mit();//6. 关闭 Sessionsession.close();//7. 关闭 SessionFactory 对象sessionFactory.close();}}7、测试结果如下:(1)数据库⾥⾯的结果如下:(2)Eclipse下的语句⽣成如下:以上就是简单Hibernate的测试,总结:1、不需要在数据库⾥⾯创建任何数据,由hibernate ⾃动⽣成;2、代码简单易理解,不复杂,测试数据只需要先创建以下⼏个步骤:SessionFactory-→Session-→Transaction-→session操作数据库-→提交-→关闭;3、不需要写SQL 语句,从头到尾没有写⼀条SQL语句,反⽽Hibernate帮我们⽣成SQL语句。
Spring+SpringSecurity+Hibernate4.1.1+Struts2.3+JPA
lt;bean id="dataSource" class="boPooledDataSource" destroy-method="close">
获取连接失败后该数据源将申明已断开并永久关闭。Default: false -->
<property name="breakAfterAcquireFailure" value="true" />
<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的 时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
</beans>
3.整合Hibernate4.1.1
添加Hibernate jar文件
Hibernate压缩包中的
lib/required/
antlr-2.7.7.jar
dom4j-1.6.1.jar
hibernate-commons-annotations-4.0.1.Final.jar
hibernate.jdbc.fetch_size=18
hibernate.jdbc.batch_size=10
hibernate.show_sql=true
hibernate.format_sql=true
配置工厂spring管理事务
<!-- 类工厂由spring管理 -->
<param-value>
WEB-INF/applicationContext.xml ------ spring主配置文件
hibernate高级用法
hibernate高级用法Hibernate是一种Java持久化框架,用于将对象转换为数据库中的数据。
除了基本的用法,Hibernate还提供了一些高级的用法,以下是一些常见的Hibernate高级用法:1、继承Hibernate支持类继承,可以让子类继承父类的属性和方法。
在数据库中,可以使用表与表之间的关系来实现继承,例如使用一对一、一对多、多对一等关系。
使用继承可以让代码更加简洁、易于维护。
2、聚合Hibernate支持聚合,可以将多个对象组合成一个对象。
例如,一个订单对象可以包含多个订单行对象。
在数据库中,可以使用外键来实现聚合关系。
使用聚合可以让代码更加简洁、易于维护。
3、关联Hibernate支持关联,可以让对象之间建立关联关系。
例如,一个订单对象可以关联一个客户对象。
在数据库中,可以使用外键来实现关联关系。
使用关联可以让代码更加简洁、易于维护。
4、延迟加载Hibernate支持延迟加载,可以在需要时才加载对象。
延迟加载可以减少数据库的负担,提高性能。
Hibernate提供了多种延迟加载的策略,例如按需加载、懒惰加载等。
5、事务Hibernate支持事务,可以确保数据库的一致性。
事务是一组数据库操作,要么全部成功,要么全部失败。
Hibernate提供了事务管理的方法,例如开始事务、提交事务、回滚事务等。
6、缓存Hibernate支持缓存,可以减少对数据库的访问次数,提高性能。
Hibernate提供了多种缓存策略,例如一级缓存、二级缓存等。
使用缓存需要注意缓存的一致性和更新问题。
7、HQL查询语言Hibernate提供了HQL查询语言,可以让开发人员使用面向对象的查询方式来查询数据库。
HQL查询语言类似于SQL查询语言,但是使用的是Java类和属性名,而不是表名和列名。
HQL查询语言可以更加灵活、易于维护。
以上是一些常见的Hibernate高级用法,它们可以帮助开发人员更加高效地使用Hibernate进行开发。
hibernate常用方法
hibernate常用方法Hibernate是一个开源的对象-关系映射框架,用于简化Java应用程序与数据库之间的交互。
Hibernate提供了丰富的API来执行通用的数据库操作,包括插入、更新、删除和查询。
下面是Hibernate常用的方法:1. save(:将一个新的对象插入到数据库中,返回一个唯一标识符。
2. update(:更新数据库中的一个对象。
3. delete(:从数据库中删除一个对象。
4. get(:根据给定的唯一标识符查询数据库中的一个对象。
5. load(:根据给定的唯一标识符查询数据库中的一个对象并加载它。
6. saveOrUpdate(:根据对象的状态来决定是插入还是更新数据库中的对象。
7. merge(:将给定对象的状态合并到数据库中的对象。
8. persist(:将一个新的对象插入到数据库中,并立即执行同步。
9. lock(:锁定一个对象,防止其他会话对其进行修改。
10. clear(:清除会话缓存中的所有对象。
11. evict(:从会话缓存中移除给定的对象。
12. refresh(:强制会话重新从数据库中加载对象的状态。
13. flush(:将会话缓存中的所有操作发送到数据库中。
14. Criteria API:用于创建复杂的查询条件。
15. HQL(Hibernate Query Language):类似于SQL的查询语言,用于查询对象。
16. Native SQL:直接执行SQL语句来操作数据库。
17. Transaction API:用于管理事务的开始、提交和回滚。
18. Session API:用于管理Hibernate会话的生命周期。
19. SessionFactory API:用于创建和销毁Hibernate会话工厂。
20. Dialect API:用于不同数据库间的差异性处理。
这些方法涵盖了Hibernate的核心功能,开发者可以根据具体的需求选择合适的方法来操作数据库。
Hibernate4在开发当中的一些改变
Hibernate4的改动较大只有spring3.1以上版本能够支持,Spring3.1取消了HibernateTemplate,因为Hibernate4的事务管理已经很好了,不用Spring再扩展了。
这里简单介绍了hibernate4相对于hibernate3配置时出现的错误,只列举了问题和解决方法,详细原理如果大家感兴趣还是去自己搜吧,网上很多。
1. Spring3.1去掉了HibernateDaoSupport类。
hibernate4需要通过getCurrentSession()获取session。
并且设置<propkey="hibernate.current_session_context_class">org.springframework.orm.hibe rnate4.SpringSessionContext</prop>(在hibernate3的时候是thread和jta)。
2. 缓存设置改为<propkey="hibernate.cache.provider_class">net.sf.ehcache.hibernate.EhCacheProvi der</prop><propkey="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhC acheRegionFactory</prop>3. Spring对hibernate的事务管理,不论是注解方式还是配置文件方式统一改为:<bean id="txManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager" ><property name="sessionFactory"><ref bean="sessionFactory"/></property></bean>4. getCurrentSession()事务会自动关闭,所以在有所jsp页面查询数据都会关闭session。
hibernate项目开发的一般步骤
Hibernate 是一个开源的对象关系映射(ORM)框架,它可以将 Java 对象映射到关系型数据库中。
使用 Hibernate 进行项目开发的一般步骤如下:
1. 配置 Hibernate:首先需要在项目中添加 Hibernate 的相关依赖,并在配置文件中进行相关配置,如连接数据库的 URL、用户名和密码等。
2. 创建实体类:根据数据库表的结构,创建相应的 Java 实体类。
这些类需要继承自Hibernate 的某个抽象类或接口,并包含相应的属性和注解。
3. 创建映射文件:为每个实体类创建一个映射文件,用于描述实体类与数据库表之间的映射关系。
映射文件通常是以`.hbm.xml`为扩展名的文件。
4. 编写 DAO 类:使用 Hibernate 提供的 API 编写数据访问对象(DAO)类,用于对数据库进行操作。
DAO 类通常包含用于插入、更新、删除和查询数据的方法。
5. 编写业务逻辑:在服务层编写业务逻辑代码,调用 DAO 类进行数据库操作。
6. 测试:编写测试代码,对业务逻辑进行测试。
7. 部署和运行:将项目部署到服务器上,并运行应用程序。
需要注意的是,在使用 Hibernate 进行项目开发时,需要遵循一些最佳实践,如延迟加载、缓存优化等,以提高系统的性能和可维护性。
以上是使用 Hibernate 进行项目开发的一般步骤,具体的步骤和实现方式可能因项目的需求和架构而有所不同。
SpringMVC+Hibernate4+Spring3整合开发实现CRUD
·在实现CRUD之前,我想你的开发环境已经搭建好了,我们就不作搭建的说明了,直接进入正题;一般搭建环境都是项目经理的事情,项目经理搭建完环境,就会把环境放到svn服务器上,你只需要从服务器上检出项目环境开发即可;File→Inport→SVN→从SVN检出项目我的资源库已经创建好了,你从视图中打开资源库视图创建一个资源库就好了,选择项目文件夹finish即可;·我们首先要生成简单Java类,也称POJO类,既然有添加hibernate的开发支持,当然要用hibernate提供的功能了,那我们首先编写一个数据库创建脚本,其中包括最常用的字段即可,就编写一个雇员表吧;USE mysql ;DROP TABLE emp ;CREATE TABLE emp(empno INT AUTO_INCREMENT ,ename VARCHAR(30) NOT NULL ,hiredate DATE ,sal VARCHAR(50) NOT NULL ,CONSTRAINT pk_nid PRIMARY KEY(empno)) ;·用hibernate生成一个表的对应的简单java类,打开DB Browser视图→找到对应的表右键→hibernate Reverse Engineering……这个界面就按照下图的设置,下图中没显示的部分,取消勾选,不做设置;·配置完成之后,会生成一个以表名称为类名的一个简单java类,不过首字母大写,采用的annotation注解的方式和数据表配置了映射关系,生成的类会有一些警告,压制一些就OK了,生成的构造方法没有任何用处,删掉即可,一些注释也可以删掉了,另外增加一个toString()方法,这样在做一些异常调试的时候很方便,此类我做了一点简单的注释,可以一看;Emp.javapackage cn.oracle.pojo;import java.util.Date;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.Table;import javax.persistence.Temporal;import javax.persistence.TemporalType;@SuppressWarnings("serial")→压制警告用的@Entity→代表这一个实体,与数据表映射对应;@Table(name = "emp", catalog = "mysql")→此设置了这个实体对应的数据库名称和表名称;name 属性是表名称,catalog 是你用到数据库的名字;public class Emp implements java.io.Serializable {private Integer empno;→对应的字段名称;private String ename; →对应的字段名称;private Date hiredate; →对应的字段名称;private String sal; →对应的字段名称;@Id→表示这个字段值主键,唯一的@GeneratedValue→表示此字段自动增长,@Column(name = "empno", unique = true, nullable = false)→对应表中的列的属性,name 表示列名称,unique表示唯一性,nullable表示是否为空;public Integer getEmpno() {return this.empno;}public void setEmpno(Integer empno) {this.empno = empno;}@Column(name = "ename", nullable = false, length = 30)→length表示长度public String getEname() {return this.ename;}public void setEname(String ename) {this.ename = ename;}@Temporal(TemporalType.DATE)→专门标注日期的;@Column(name = "hiredate", length = 10)public Date getHiredate() {return this.hiredate;}public void setHiredate(Date hiredate) {this.hiredate = hiredate;}@Column(name = "sal", nullable = false, length = 50)public String getSal() {return this.sal;}public void setSal(String sal) {this.sal = sal;}@Overridepublic String toString() {return"Emp [empno=" + empno + ", ename=" + ename + ", hiredate="+ hiredate + ", sal=" + sal + "]";}}·简单java类完成是第一步,然后我们需要配置数据库连接了,这是正常的思维模式,也就是最基本的JDBC开发思维模式,但是这一步spring已经在配置的时候已经交给了spring管理了数据库的连接池,只要得到对应的bean就可以得到数据库连接了,也就能操作数据库了;数据库连接类也就相当于spring给我们提供好了,那接下来就是编写接口了,首先编写DAO层接口,DAO(data access Object) 叫做数据访问对象,首先,我们利用泛型编写一个公共的DAO接口,实现基本的CRUD ,当数据表非常多的时候编写此公共的接口很节省代码的;IDAO.javapackage cn.oracle.dao;import java.util.List;public interface IDAO<K,V> {/*** 增加一条数据;* @param vo 简单Java类对象;* @return返回一个boolean对象,增加成功返回true,增加失败返回false;* @throws Exception*/public boolean doCreate(V vo)throws Exception;/*** 更新一条数据;* @param vo 简单Java类对象;* @return返回一个boolean对象,更新成功返回true,更新失败返回false;* @throws Exception*/public boolean doUpdate(V vo)throws Exception;/*** 删除一条数据;* @param id 简单Java类对象的id;* @return返回一个boolean对象,删除成功返回true,删除失败返回false;* @throws Exception*/public boolean doRemove(int id)throws Exception;/*** 查询出一条数据,* @param id 数据对应的id* @return返回一个简单java类对象;* @throws Exception*/public K findById(int id)throws Exception;/*** 查询所有的数据;* @return返回一个简单Java类对象;* @throws Exception*/public List<V> findAll()throws Exception;/*** 模糊查询,也是分页要用的一个方法;* @param column 列名称* @param keyWord 关键字* @param currentPage 当前页* @param lineSize 每页现实的数据条目* @return返回一个List集合;* @throws Exception*/public List<V> findAll(String column,String keyWord,IntegercurrentPage,Integer lineSize)throws Exception;/*** 统计模糊查询的条目* @param column 列名称* @param keyWord 关键字* @return返回一个整数* @throws Exception*/public int getAllCount(String column,String keyWord)throws Exception;}·公共的接口开发完成了,我们接下来就开发IEmpDAO接口,这个接口直接继承IDAO 接口即可,是不是很方便,直接继承即可,如果你需要扩充什么方法的话,直接编写方法即可,package cn.oracle.dao;import cn.oracle.pojo.Emp;public interface IEmpDAO extends IDAO<Integer, Emp> {}·然后当然是编写接口的实现类了,也就是编写方法的具体实现,EmpDAOImpl.javapackage cn.oracle.dao.impl;import java.util.List;import javax.annotation.Resource;import org.hibernate.Criteria;import org.hibernate.Query;import org.hibernate.SessionFactory;import ponent;import cn.oracle.dao.IEmpDAO;import cn.oracle.pojo.Emp;@Component→这个就是Annotation注解,其实你可以理解为在applicationContext.xml文件之中配置了一个bean<bean id=”empDAOImpl” class=”cn.oracle.dao.impl.EmpDAOImpl”>→Component<property name=”sessionFactory” ref=”sessionFactory”/>→Resource</bean>public class EmpDAOImpl implements IEmpDAO {@Resourceprivate SessionFactory sessionFactory;@Overridepublic boolean doCreate(Emp vo) throws Exception {return this.sessionFactory.getCurrentSession().save(vo) != null;}→使用Session接口的save方法来保存数据;@Overridepublic boolean doUpdate(Emp vo) throws Exception {String hql="UPDATE Emp AS e SET e.ename=?,e.hiredate=?,e.sal=? WHERE e.empno=?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, vo.getEname());query.setDate(1, vo.getHiredate());query.setString(2, vo.getSal());return query.executeUpdate()>0;}→使用Query实现更新;@Overridepublic boolean doRemove(int id) throws Exception {String hql="DELETE FROM Emp As e WHERE e.empno=?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setInteger(0, id);return query.executeUpdate()>0;}→使用Query接口实现删除;@Overridepublic Emp findById(int id) throws Exception {return (Emp) this.sessionFactory.getCurrentSession().get(Emp.class, id);}→使用Session接口查询数据;@SuppressWarnings("unchecked")@Overridepublic List<Emp> findAll() throws Exception {Criteriacriteria=this.sessionFactory.getCurrentSession().createCriteria(Emp.class);List<Emp> all=criteria.list();return all;} →使用criteria接口实现全部查询;@SuppressWarnings("unchecked")@Overridepublic List<Emp> findAll(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { String hql="FROM Emp AS e WHERE e."+column+" LIKE ?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");query.setFirstResult((currentPage-1)*lineSize);query.setMaxResults(lineSize);return (List<Emp>)query.list();}→使用query接口实现分页模糊查询;@Overridepublic int getAllCount(String column, String keyWord) throws Exception { String hql="SELECT COUNT(e.empno) FROM Emp AS e WHERE "+column+" LIKE ?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");Integer count=((Long)query.uniqueResult()).intValue();return count;} →使用query接口完成统计;}·编写完成DAO层之后,我们就要做的就是编写服务层了,也就是对DAO层接口的调用,IEmpService.javapackage cn.oracle.service;import java.util.List;import java.util.Map;import cn.oracle.pojo.Emp;public interface IEmpService {public boolean insert(Emp vo)throws Exception;public boolean update(Emp vo)throws Exception;public boolean delete(int id)throws Exception;public Emp get(int id)throws Exception;public List<Emp> list()throws Exception;public Map<String ,Object> list(String column,String keyWord,Integer currentPage,Integer lineSize)throws Exception;}·接口编写完成,之后我们就应该编写实现类了;EmpServiceImpl.javapackage cn.oracle.service.impl;import java.util.HashMap;import java.util.List;import java.util.Map;import javax.annotation.Resource;import org.springframework.stereotype.Service;import cn.oracle.dao.IEmpDAO;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;@Service Service层的专用Annotation注解;public class EmpServiceImpl implements IEmpService {@Resourceprivate IEmpDAO empDAO;@Overridepublic boolean insert(Emp vo) throws Exception {return this.empDAO.doCreate(vo);}@Overridepublic boolean update(Emp vo) throws Exception {return this.empDAO.doUpdate(vo);}@Overridepublic boolean delete(int id) throws Exception {return this.empDAO.doRemove(id);}@Overridepublic Emp get(int id) throws Exception {return this.empDAO.findById(id);}@Overridepublic List<Emp> list() throws Exception {return this.empDAO.findAll();}@Overridepublic Map<String, Object> list(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { Map<String ,Object> map=new HashMap<String,Object>();map.put("allEmps", this.empDAO.findAll(column, keyWord, currentPage, lineSize));map.put("allCount", this.empDAO.getAllCount(column, keyWord));return map;}}·到此,后台业务层的增删改查就完成了,然后就是控制器的编写了,我们用的是springmvc的话,自然编写起来很方便的;EmpAction.javapackage cn.oracle.action;import java.util.List;import javax.annotation.Resource;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.servlet.ModelAndView;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;@Controller→spring mvc的专用annotation注解,代表一个控制器;@RequestMapping("/pages/front/emp/*") →映射路径public class EmpAction {@Resourceprivate IEmpService empService;@RequestMapping(value="emp_list.jsp",method=RequestMethod.GET)public ModelAndView list(HttpServletRequest request,HttpServletResponse response){List<Emp> allEmps=null;try {allEmps=this.empService.list();} catch (Exception e) {e.printStackTrace();}ModelAndView mav=new ModelAndView();mav.setViewName("/pages/front/emp/emp_list.jsp");mav.addObject("allEmps", allEmps);System.out.println(allEmps); 我们就用一个简单的连接做测试,如果后台输出了这些对象的话,说明我们就完成了页面的操作了;return mav;}}如果后台有输出这些信息,说明你的所有配置正常,开发CRUD没任何问题的;。
Struts2.3.1.2+Spring3.3.1+Hibernate4.1.1 配置步骤
一.搭建struts-2.3.1.21.Jar包:2.配置struts2.3的过滤器,web.xml位置3.web.xml<?xml version="1.0"encoding="UTF-8"?><web-app id="WebApp_ID"version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance" xmlns:web="/xml/ns/javaee/web-app_2_5.xsd "xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"><!-- struts2单控制器 --><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.Struts PrepareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping></web-app>4.配置struts.xml<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><!-- 默认的配置包 --><package name="ssh"extends="struts-default,json-default,jfreechart-default,s pring-default"><action name="login"class="loginAction"><result name="ok">/loginOk.jsp</result><result name="error">/loginError.jsp</result></action></package></struts>5.测试struts二.整合Spring 3.1.1和Struts-2.3.1.21.jar包在配置好的strutsjar的基础上,添加额外Struts jar包:struts2-spring-plugin-2.3.1.2.jarcommons-logging-1.1.1.jarSpring的jar包:org.springframework.core-3.1.1.RELEASE.jarorg.springframework.context-3.1.1.RELEASE.jarorg.springframework.beans-3.1.1.RELEASE.jarorg.springframework.asm-3.1.1.RELEASE.jarorg.springframework.expression-3.1.1.RELEASE.jarorg.springframework.web-3.1.1.RELEASE.jar2.web.xml<?xml version="1.0"encoding="UTF-8"?>web-app id="WebApp_ID"version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi=/2001/XMLSchema-instancexmlns:web="/xml/ns/javaee/web-app_2 _5.xsd"xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_0.xsd"><!-- struts2单控制器 --><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.Str utsPrepareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping><!-- spring创建工厂监听器--><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><!-- 告知spring config location 的存储位置--><context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext.xml</par am-value></context-param></web-app>3.配置springapplicationContext.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:tx="/schema/tx"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"> <context:annotation-config /><context:component-scan base-package="com.excel" /></beans>三.整合Hibernate4.1.11.jar包添加Hibernate jar文件Hibernate压缩包中的lib/required/antlr-2.7.7.jardom4j-1.6.1.jarhibernate-commons-annotations-4.0.1.Final.jarhibernate-core-4.1.1.Final.jarhibernate-jpa-2.0-api-1.0.1.Final.jarjavassist-3.15.0-GA.jarjboss-logging-3.1.0.GA.jarjboss-transaction-api_1.1_spec-1.0.0.Final.jar lib/jpa/hibernate-entitymanager-4.1.1.Final.jarlib/optional/c3p0/hibernate-c3p0-4.1.1.Final.jarc3p0-0.9.1.jarSpring中的jar文件org.springframework.aop-3.1.1.RELEASE.jarorg.springframework.jdbc-3.1.1.RELEASE.jarorg.springframework.orm-3.1.1.RELEASE.jarorg.springframework.transaction-3.1.1.RELEASE.jar 其他的Spring支持文件aopalliance.jar -- AOP要用到的jar包以及连接db2的jarDb2jcc.Jar以及支持el表达式的standard.jar2.配置文件<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jee="/schema/jee"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xmlns:p="/schema/p"xmlns:util="/schema/util"xmlns:tool="/schema/tool" xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/tx/schema/tx/spring-tx.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/jee/schema/jee/spring-jee.xsd/schema/context/schema/context/spring-context.xsd /schema/util/schema/util/spring-util.xsd/schema/tool/schema/tool/spring-tool.xsd"default-lazy-init="true"default-autowire="byName"> <!--配置数据源 --><bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"value="com.ibm.db2.jcc.DB2Driver" /><property name="jdbcUrl"value="jdbc:db2://192.168.1.35:50000/ZL_DEMO"/><property name="user"value="db2admin"/><property name="password"value="Forwor888"/></bean><!-- hibernate.cfg.xml Spring config --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><!-- connection --><property name="dataSource"><ref local="dataSource"/></property><!-- hibernate自身属性 --><property name="hibernateProperties"><props><prop key="hibernate.show_sql">true</prop><prop key="hibernate.format_sql">true</prop><propkey="hibernate.dialect">org.hibernate.dialect.DB2Dialect</prop> </props></property><!-- 映射文件 --><property name="mappingResources"><list><value>com/forwor/ssh/entity/xml/User.hbm.xml</value></list></property></bean><!-- 注入 --><bean id="userDAO"class="erDAOImpl"> <property name="sessionFactory"><ref local="sessionFactory"/></property></bean><!-- aop --><!-- transaction --><bean id="userBiz"class="erBizImpl"> <property name="userDAO"><ref local="userDAO"/></property></bean><!-- advice --><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager "><property name="sessionFactory"><ref local="sessionFactory"/></property></bean><!-- 事务处理 --><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterce ptor"><property name="transactionManager"><ref local="transactionManager"/></property><property name="transactionAttributes"><props><prop key="register">PROPAGATION_REQUIRED</prop><!--hibernate4必须配置为开启事务否则 getCurrentSession()获取不到--><prop key="get*">PROPAGATION_REQUIRED,readOnly</prop><prop key="find*">PROPAGATION_REQUIRED,readOnly</prop><prop key="select*">PROPAGATION_REQUIRED,readOnly</prop><prop key="query*">PROPAGATION_REQUIRED,readOnly</prop><prop key="sync*">PROPAGATION_REQUIRED</prop><prop key="finish*">PROPAGATION_REQUIRED</prop><prop key="add*">PROPAGATION_REQUIRED</prop><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="edit*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="save*">PROPAGATION_REQUIRED</prop><prop key="remove*">PROPAGATION_REQUIRED</prop><prop key="delete*">PROPAGATION_REQUIRED</prop><propkey="*">PROPAGATION_REQUIRED,ng.Exception</prop></props></property></bean><!-- autoproxy 自动创建代理--><bean id="ProxyCreator"class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyC reator"><property name="beanNames"><list><value>*Biz</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><bean id="loginAction"class="com.forwor.ssh.web.LoginAction" scope="prototype"><property name="userBiz"><ref local="userBiz"/></property></bean></beans>。
hibernate query占位符参数循环处理
hibernate query占位符参数循环处理(实用版)目录1.Hibernate 查询概述2.占位符参数3.循环处理4.实际应用示例正文1.Hibernate 查询概述Hibernate 是一款流行的 Java 框架,用于将数据库中的数据与Java 对象进行映射。
在 Hibernate 中,我们可以通过编写查询语句(Query)来实现对数据库的操作,例如查询、插入、更新和删除等。
2.占位符参数在编写查询语句时,我们常常需要将某些变量或表达式的值传递给查询,以便根据不同的条件来检索数据。
在 Hibernate 中,我们可以使用占位符参数(placeholder)来实现这一目的。
占位符参数用大括号{}表示,可以出现在查询语句的任何位置。
例如,我们可以编写一个简单的查询语句,根据传入的整数值来检索对应的用户信息:```javaString hql = "from User where age = {age}";```3.循环处理在某些场景下,我们需要处理多个占位符参数。
例如,假设我们需要根据传入的多个年龄值来检索符合条件的用户信息。
为了实现这一功能,我们可以使用循环来处理占位符参数。
以下是一个使用循环处理多个占位符参数的示例:```javaString hql = "from User where age in {ages}";List<Object> params = new ArrayList<>();params.add(18);params.add(25);params.add(30);// 将参数列表转换为占位符参数字符串String[] placeholders = new String[params.size()];for (int i = 0; i < params.size(); i++) {placeholders[i] = "{ages[" + i + "]}";}// 将占位符参数字符串添加到查询语句中hql = hql.replace("{ages}", String.join(", ", placeholders));```4.实际应用示例假设我们有一个 User 实体类,包含 id、name 和 age 属性。
hibernate 生成数据库表的原理
hibernate 生成数据库表的原理Hibernate是一个Java持久化框架,它提供了一种方便的方式来映射Java对象到关系数据库中的表结构。
当使用Hibernate时,它可以根据预定义的映射文件或注解配置自动创建、更新和管理数据库表。
Hibernate生成数据库表的原理如下:1. 对象关系映射(Object-Relational Mapping,ORM):Hibernate使用ORM技术将Java类和关系数据库表之间建立起映射关系。
通过在实体类中定义注解或XML映射文件,Hibernate可以知道哪个Java类对应哪个数据库表以及类中的属性与表中的列之间的映射关系。
2. 元数据分析:当应用程序启动时,Hibernate会对实体类进行元数据分析。
它会扫描实体类中的注解或XML映射文件,获取实体类的名称、属性名、属性类型等信息,并根据这些信息生成相应的元数据。
3. 数据库模式生成:根据元数据,Hibernate可以自动生成数据库表的DDL语句。
它会根据实体类的名称创建表名,根据属性名创建列名,并根据属性类型确定列的数据类型、长度、约束等。
生成的DDL语句可以包括创建表、添加索引、外键约束等操作。
4. 数据库表管理:Hibernate可以根据生成的DDL语句来创建数据库表。
在应用程序启动时,Hibernate会检查数据库中是否已存在相应的表,如果不存在则创建表;如果已存在但结构与元数据不匹配,则根据需要进行表结构的更新或修改。
总的来说,Hibernate生成数据库表的原理是通过分析实体类的元数据,自动生成对应的DDL语句,并根据需要创建、更新和管理数据库表。
这种自动化的方式大大简化了开发人员的工作,提高了开发效率。
Hibernate4开发文档
hibernate4简介开源的对象关系映射框架(ORM)hibernate 核心接口Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流SessionFactory接口SessionFactory接口负责初始化Hibernate。
它充当数据存储源的代理,并负责创建Session对象Configuration类Configuration类负责配置并启动Hibernate,创建SessionFactory 对象。
在Hibernate的启动的过程中,Configuration类的实例首先定位映射文档位置、读取配置,然后创建SessionFactory对象Transaction接口Transaction接口负责事务相关的操作Query和Criteria接口Query和Criteria接口负责执行各种数据库查询。
它可以使用HQL语句或SQL语句两种表达方式。
hibernate 访问持久化类属性的策略accessproperty:field:hibernate 主键策略generator 主键生成器increment 自动增长数据类型long short intidentity sql server mysql自动增长long shorintnative 根据数据库的支持自动选择identity sequence hilo uuidhilo<generator class="hilo"><param name="table">hi_value</param><param name="column">next_value</param><param name="max_lo">100</param></generator>sequence 序列必须有一个序列名称assigned 自然主键主键由java程序指定hibernate 对象状态瞬时态瞬时对象在内存孤立存在,它是携带信息的载体,不和数据库的数据有任何关联关系new 对象delete()持久态处于该状态的对象在数据库中具有对应的记录,并拥有一个持久化标识save() saveOrUpdate() get() load()脱管态当一个session执行close()或clear()、evict()之后当与某持久对象关联的session被关闭后,该持久对象转变为脱管对象关系hibernate4 注解和关系hibernate4 注解@Entity 表示该类是一个实体类@Table 映射成一张表不写参数默认表名跟类名相同@Table(name="t_people")@Id 表示主键@GeneratedValue(strategy=GenerationType.AUTO)(native)@Id@GeneratedValue(generator="seq_ganerator")@GenericGenerator(name="seq_ganerator",strategy="sequence",parameters={@Parameter(name="sequence",value="seq_people")})1、native@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "native")2、uuid@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "uuid") 3、hilo@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "hilo") 4、assigned@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "assigned")5、identity@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "identity")6、select@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name="select", strategy="select",parameters = { @Parameter(name = "key", value = "idstoerung") })7、sequence@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "sequence",parameters = { @Parameter(name = "sequence", value = "seq_payablemoney") })8、seqhilo@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "seqhilo", parameters = { @Parameter(name = "max_lo", value = "5") })9、increment@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "increment")10、foreign@GeneratedValue(generator = "idGenerator")@GenericGenerator(name = "idGenerator", strategy = "foreign", parameters = { @Parameter(name = "property", value = "employee") })@Transient该注解可以屏蔽属性的映射hibernate 延迟加载getget方法一要一执行就会发出sql get没有延迟加载如果对象不存在会抛出ng.NullPointerExceptionload调用load方法时并不会发出sql语句,只有在使用该对象时才发会sql, 当完成load之后,其实拿到的是一个代理对象,这个代理对象只有一个id值,获取对象的其它值时,才会发sql 语句load 用到了hibernate的延迟加载如果对象不存会抛出org.hibernate.ObjectNotFoundException:一对一关联OneToOne单向关联<!--oneToone是many-to-one的一个特例只须要增加unique=true(唯一) cascade 表示级联(all delete none save saveorupdate--><many-to-one name="person" column="pid" unique="true" cascade="delete" ></many-to-one> 单向关联注解@OneToOne@JoinColumn(name="pid",unique=true)cascade属性的可选值:all : 所有情况下均进行关联操作。
通用后台管理系统(ExtJS 4.2+Hibernate 4.1.7+Spring MVC 3.2.8)
系统可作为OA、网站、电子政务、ERP、CRM、APP后台等基于B/S架构的应用软件系统的快速开发框架。
一、特色功能1、采用Spring MVC的静态加载缓存功能,在首页将Javascript文件、CSS文件和图片等静态资源文件加载进来放进内存,极大提高ExtJS的加载速度。
2、三种皮肤主题:经典、灰色和海王星,支持多浏览器和多分辨率。
3、分别封装了模型层、控制层、业务逻辑层和数据持久层的通用操作模块,层次分明,大大减少代码冗余,二次开发效率高。
4、系统是公司多个项目的基础框架,稳定性好,支持大并发。
二、主要功能1、采用ExtJS 4.2.1.883无限制版本,放心用于网站开发。
2、ExtJS富文本编辑器增加修改信息。
3、ExtJS的HtmlEditor的图片文件上传插件。
4、Grid列表和表单,包含添加、删除、批量删除、修改、查看、图片查看和按条件查询列表等功能。
5、导入导出Excel数据,支持xlsx和xls文件。
6、资源管理(菜单管理)。
7、用户管理和部门管理。
8、权限管理。
不仅可管理各个功能模块的权限,也可以管理功能模块里的页面按钮权限。
9、报表统计。
也可以嵌入其他报表工具插件。
10、采用开源的互动地图Javascript库Leaflet,处理自定义在线地图。
Panel里包含2个组件,在2个组件间传递参数显示数据。
三、开发工具和采用技术1、开发工具:Eclipse、MyEclipse和其他IDE。
2、采用Spring 3中最新最稳定的Spring MVC 3.2.8版本。
3、采用Hibernate 4.1.7。
Spring MVC 3.2.8支持的最高Hibernate版本是4.1.7,更高的Hibernate版本和Spring MVC 3.2.8组合会遇到兼容问题。
4、Hibernate集成二级缓存框架Ehcache。
5、数据库是MySQL、Oracle和SQL Server,Hibernate的Dialect可使程序移植到其他数据库。
hibernate4.0session.connection()废弃解决,项目升级解决...
hibernate4.0session.connection()废弃解决,项目升级解决...1,在hibernate4.0中移除了。
session.connection(); ---><url>/browse/HHH-2603</url>所以在使用hibernate操作离散型JDBC操作的时候,不能再使用这个方法。
解决方案:1,hibernate4只是在接口Deprecate了这个interface,那么我们仍然可以SessionImpl得到<code>[java]view plaincopyprint?1.[java]view plaincopyprint?1.public Connection getConnection() {2.try {3.if (connectionMethod == null) {4.// reflective lookup to bridge between Hibernate 3.x and4.x5.connectionMethod = this.session.getClass().getMethod(" connection");6.}7.return (Connection) ReflectionUtils.invokeMethod(connec tionMethod, this.session);8.}9.catch (NoSuchMethodException ex) {10.throw new IllegalStateException("Cannot find connecti on() method on Hibernate session", ex);11.}12.}</code>2,或者使用hibernate提供的解决方案在hibernate API中提到了替代方法---->/hibernate/core/3.5/api/org/hibernate/jdbc/Work.html使用方法如下:<code>[java]view plaincopyprint?1.session.doWork(new Work() {2.@Override3.public void execute(Connection conn) throws SQLExcepti on {4.doSomeThingWithJdbc(conn);5.}6.}</code>3,或者使用:SessionFactoryUtils.getDataSource(getSessionFactory()).get Connection()来自类org.springframework.orm.hibernate4.SessionFactoryUtils。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Hibernate4.3.10环境搭建1、新建一个java项目并且新建一个lib的包2、把hibernate’所需要的jar包放到lib下面还有数据库驱动包(mysql-connector-java-5.1.13-bin.jar)3、编写hibernate配置文件(hibernate.cfg.xml)<!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN" "/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration><session-factory><!--配置数据库驱动--><property name="connection.driver_class">com.mysql.jdbc.Driver</property><!--配置数据源localhost指当前主机3306是数据库服务器的端口号ch10是数据库名称--><property name="connection.url">jdbc:mysql://localhost:3306/ch10</property><!--数据库用户名--><property name="ername">root</property><!--用户密码--><property name="connection.password">root</property><!--数据库方言--><property name="dialect">org.hibernate.dialect.MySQLDialect</property><!--自动创建表,第一次创建以后更新--><property name="hbm2ddl.auto">update</property><property name="javax.persistence.validation.mode">none</property><!--持久化类的映射文件--><mapping resource="com/boy/hibernate/domain/User.hbm.xml" /></session-factory></hibernate-configuration>4、编写持久化类数据库结构是这样的(user.sql)持久化类(User.java)packagecom.boy.hibernate.domain; importjava.io.Serializable;public class User implements Serializable { privateint id;private String username;private String password;private String realname;privateint age;private String sex;private String address;publicintgetId() {return id;}public void setId(int id) {this.id = id;}public String getUsername() {return username;}public void setUsername(String username) { ername = username;}public String getPassword() {return password;}public void setPassword(String password) { this.password = password;}public String getRealname() {returnrealname;}public void setRealname(String realname) { this.realname = realname;}publicintgetAge() {return age;}public void setAge(int age) {this.age = age;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}}5、编写持久化类映射文件(User.hbm.xml)<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping><!-- name为持久化类的全名table是表名catlog指定数据库--><class name="er" table="user" catalog="ch10"> <!--对应User的id 将id设为主键generator是主键生成器--><id name="id"><generator class="native"></generator></id><!--对应User的username 长度为20 --><property name="username" length="20"></property><!--对应User的password 长度为20 --><property name="password" length="20"></property><!--对应User的realname长度为20 --><property name="realname" length="20"></property><property name="age" ></property><property name="sex" length="2"></property><property name="address" length="100"></property></class></hibernate-mapping>6、编写hibernate工具类(HibernateSessionFactory.java)mon;importorg.hibernate.Session;importorg.hibernate.SessionFactory;importorg.hibernate.cfg.Configuration;importorg.hibernate.service.ServiceRegistry;importorg.hibernate.service.ServiceRegistryBuilder;importcom.boy.hibernate.exception.HibernateInitException;public class HibernateSessionFactory {//指定要读取的配置文件private static final String CONFIG_FILE_LOCATION = "/Hibernate.cfg.xml";//实例化ThreadLocalprivate static final ThreadLocal<Session> THREAD_LOCAL = newThreadLocal<Session>();//初始化configurationprivate static Configuration configuration = new Configuration();//定义一个sessionFactory;private static SessionFactorysessionFactory;//定义config并赋值private static String config = CONFIG_FILE_LOCATION;static {try{configuration.configure(config);//初始化sessionFactoryServiceRegistryserviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();sessionFactory = configuration.buildSessionFactory(serviceRegistry);}catch(Exception e){throw new HibernateInitException("hibernate initializtion error");}}//无参构造函数privateHibernateSessionFactory(){};//public static Session getSession(){Session session = THREAD_LOCAL.get();//是否已经存在session对象if(session == null || !session.isOpen()){if(sessionFactory== null){rebuildSessionFactory();}session = (sessionFactory != null) ? sessionFactory.openSession() : null;THREAD_LOCAL.set(session);}return session;}//创建sessionFactoryprivate static void rebuildSessionFactory() {try{configuration.configure(config);//初始化sessionFactoryServiceRegistryserviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();sessionFactory = configuration.buildSessionFactory(serviceRegistry);}catch(Exception e){throw new HibernateInitException("hibernate initializtion error");}}//关闭sessionpublic static void closeSession(){Session session = THREAD_LOCAL.get();THREAD_LOCAL.set(null);if(session!=null)session.close();}//获取sessionFactorypublic static SessionFactorygetSessionFactory(){ returnsessionFactory;}//获取configurationpublic static Configuration getConfiguration(){ return configuration;}public static void setConfiguration(String cfg){ HibernateSessionFactory.config=cfg;sessionFactory = null;}}7、编写dao(UserDao.java)packagecom.boy.hibernate.dao;importjava.util.ArrayList;importjava.util.List;importorg.hibernate.Session;importorg.hibernate.Transaction;mon.HibernateSessionFactory; er;importcom.boy.hibernate.exception.DaoException;public class UserDao {//添加用户的方法publicint save( User user){int state = 0;Session session = null;Transaction transaction = null;try{session = HibernateSessionFactory.getSession();transaction = session.beginTransaction();state = Integer.parseInt(session.save(user).toString());mit();}catch(Exception e){state = 0;e.printStackTrace();throw new DaoException("fail to save");}finally{HibernateSessionFactory.closeSession();}return state;}//获取所有用户public List<User>getUserList(){List<User> users = new ArrayList<User>();Session session = null;try{session = HibernateSessionFactory.getSession();users = session.createQuery("from User order by id").list();}catch(Exception e){throw new DaoException("fail to query");}finally{HibernateSessionFactory.closeSession();}return users;}}8、导入Junit测试类用到的包右击项目>>Build Path>>Add Libraries.. 然后选择Junit4即可9、编写测试类(HibernateTest.java)packagecom.boy.web.test;importorg.hibernate.Session;importorg.junit.Test;mon.HibernateSessionFactory; er;public class HibernateTest {@Testpublic void createTable(){Session session = HibernateSessionFactory.getSession();User user = new User();session.beginTransaction();session.getTransaction().commit();HibernateSessionFactory.closeSession();}@Testpublic void save(){Session session = HibernateSessionFactory.getSession();User user = new User();session.beginTransaction();user.setUsername("麦女孩的小货车");user.setPassword("12345");user.setAge(23);user.setRealname("麦女孩");user.setSex("女");user.setAddress("很遥远");session.save(user);session.getTransaction().commit();HibernateSessionFactory.closeSession();}}测试1、首先查看数据库是否存在ch10的数据库这下还没有,先新建一个ch10 的数据库确定里面没有任何表单空空如也如果测试成功会看到一条绿色的长条这下再次查看数据库就会自动创建好了一个表再向数据库插入一条数据,如果插入了就说明Hibernate环境配置成功按照上面的方法对save测试数据库的数据插入是否成功测试通过再查看数据库数据插入成功。