spring4.x + hibernate4.x 配置详解
hibernate4之入门
hibernate4之入门Hibernate是什么Hibernate是一个轻量级的ORMapping框架ORMapping原理(Object Relational Mapping)ORMapping基本对应规则:1:类跟表相对应2:类的属性跟表的字段相对应3:类的实例与表中具体的一条记录相对应4:一个类可以对应多个表,一个表也可以对应对个类5:DB中的表可以没有主键,但是Object中必须设置主键字段6:DB中表与表之间的关系(如:外键)映射成为Object之间的关系7:Object中属性的个数和名称可以和表中定义的字段个数和名称不一样ORMapping的基本实现方式:使用JDBC,用SQL来操作数据库,只是看动态生成还是人工写代码来实现。
大家想想,我们实现过ORMapping吗?Hibernate能干什么:Hibernate主要用来实现Java对象和表之间的映射,除此之外还提供还提供数据查询和获取数据的方法,可以大幅度减少开发时人工使用SQL和JDBC处理数据的时间。
Hibernate的目标是对于开发者通常的数据持久化相关的编程任务,解放其中的95%。
对于以数据为中心的程序来说,它们往往只在数据库中使用存储过程来实现商业逻辑,Hibernate可能不是最好的解决方案;对于那些在基于Java的中间层应用中,它们实现面向对象的业务模型和商业逻辑的应用,Hibernate是最有用的。
Hibernate可以帮助你消除或者包装那些针对特定厂商的SQL代码,并且帮你把结果集从表格式的表示形式转换到一系列的对象去。
一个非常简要的Hibernate体系结构的高层概要图Hibernate运行时体系结构“最小”的体系结构方案,要求应用程序提供自己的JDBC 连接并管理自己的事务。
这种方案使用了Hibernate API 的最小子集.“全面解决”的体系结构方案,将应用层从底层的JDBC/JTA API中抽象出来,而让Hibernate来处理这些细节。
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>。
Hibernate配置(web开发)
Hibernate的映射文件Hibernate的映射文件映射文件也称映射文档,用于向Hibernate提供关于将对象持久化到关系数据库中的信息.持久化对象的映射概念可全数存储在同一个映射文件中,也可将每一个对象的映射概念存储在独立的文件中.后一种方式较好,因为将大量持久化类的映射概念存储在一个文件中比较麻烦,建议采纳每一个类一个文件的方式来组织映射文档.利用多个映射文件还有一个优势:若是将所有映射概念都存储到一个文件中,将难以调试和隔离特定类的映射概念错误.映射文件的命名规那么是,利用持久化类的类名,并利用扩展名.映射文件需要在中注册,最好与领域对象类放在同一目录中,如此修改起来很方便.领域对象和类public class User{个选项在第一次启动程序时放开,以后切记关闭 --><!-- <property name="">create</property> --><!-- 持久化类的映射文件 --><mapping resource="com/sitinspring/domain/" /><mapping resource="com/sitinspring/domain/" /><mapping resource="com/sitinspring/domain/" /><mapping resource="com/sitinspring/domain/" /></session-factory></hibernate-configuration>映射文件物理位置例如映射文件的大体结构映射概念以hibernate-mapping元素开始, package属性设置映射中非限定类名的默许包.设置那个属性后,关于映射文件中列出的其它持久化类,只需给出类名即可.要引用指定包外的持久化类,必需在映射文件中提供全限定类名.在hibernate-mapping标签以后是class标签.class标签开始指定持久化类的映射概念.table属性指定用于存储对象状态的关系表.class元素有很多属性,下面将逐个介绍.IDId元素描述了持久化类的主码和他们的值如何生成.每一个持久化类必需有一个ID元素,它声明了关系表的主码.如右:Name属性指定了持久化类顶用于保留主码值的属性,该元素说明,User类中有一个名为id的属性.若是主码字段与对象属性不同,那么能够利用column属性.<id name="id" column="ID" ><generator class=""/></id>生成器生成器创建持久化类的主码值.Hibernate提供了多个生成器实现,它们采纳了不同的方式来创建主码值.有的是自增加式的,有点创建十六进制字符串, 还能够让外界生成并指定对象ID,另外还有一种Select生成器你那个从数据库触发器trigger检索值来取得主码值.右边利用了用一个128-bit的UUID算法生成字符串类型的标识符,这在一个网络中是唯一的(利用了IP地址)。
S4S2H4环境搭建过程
Spring4.2.3 +Struts2.3.24 +Hibernate4.3.11配置过程新建一个web项目一、搭建spring4.2.3环境并测试1.先引入spring开发包2.编写一个spring配置文件 applicationContext.xml3.测试spring安装是否完成二、整合Hibernate4.3.111. 引入hibernate jar包(其中包含了hibernate的C3P0支持包3个)其中包含的C3P0支持包如下:2.分别测试spring和hibernate是否正常。
两方都正常再进行下面集成。
Ps 1.测试时要注意加入第三方jdbc连接包。
Ps 2.发现错误解决:下载aopalliance.jar 并导入项目,问题解决。
3.在spring中配置 hibernate 资源文件(spring接管hibernate 的配置文件和对象映射文件)3.1 在 applicationContext.xml中配置数据源3.2 配置sessionFactory对象3.3 编写对象及映射文件4. 测试hibernate安装是否完成5.配置事务管理器(1.在applicationContext.xml中配置事务管理器2.启用事务注解3.在使用事务的类前加注解@Transactional,让spring事务管理器接管该service的所有事务。
ps.如果只需接管某些方法中的事务,可以在方法前加注解@Transactional)6. 测试hibernate安装是否正常三、整合struts 2.3.248.1 引入struts开发包注:由于在之前的jar包中,已经包含低版本的同类包,红色部分先不进行引入。
用于struts2集成spring。
Ps.引入后测试spring和hibernate集成能否正常使用。
8.2 创建 struts.xml 文件8.3 在web.xml中配置struts ,开发对应的action、form和对应页面8.4 测试struts是否正常配置8.5 在web容器中实例化spring容器(通过web.xml 实例化spring 容器),可以通过 WebApplicationContext 来获取spring容器实例8.6 将struts组件整合到spring容器中(spring接管struts的action组件)ps.1.通过spring容器注入action需要的service2.对struts2来说,sturts.xml中就action元素的class属性对应的值就应该是spring容器中的一个bean的id。
【Hibernate】Hibernate框架配置详解
【Hibernate】Hibernate框架配置详解通过Hibernate我们可以⽅便地操作数据库读取出来的信息,减少了繁琐的JDBC操作。
⼀般情况下,有两种⽅式可以进⾏Hibernate的配置,⼀种是通过配置⽂件进⾏配置,另⼀种是通过注解进⾏配置。
我将通过注解简单介绍Hibernate框架的配置。
Hibernate框架的配置⼀般可以分为以下⼏个步骤:1.添加基本的Hibernate Jar包2.添加注解的Jar包3.编写Hibernate.cfg.xml⽂件4.编写POJO⽂件,并编写注释5.编写测试⽂件,导出到数据库进⾏测试。
⼀、导⼊基本的Hibernate Jar包⼆、导⼊Hibernate Annotation 的Jar包三、编写Hibernate.cfg.xml⽂件1<?xml version='1.0' encoding='UTF-8'?>2<!DOCTYPE hibernate-configuration PUBLIC3 "-//Hibernate/Hibernate Configuration DTD 3.0//EN"4 "/hibernate-configuration-3.0.dtd">56<!-- Generated by MyEclipse Hibernate Tools. -->7<hibernate-configuration>89<session-factory>10<!-- 配置JDBC连接属性 -->11<property name="myeclipse.connection.profile">12 com.mysql.jdbc.Driver13</property>14<property name="connection.url">15 jdbc:mysql://localhost:3306/basehibernate16</property>17<property name="ername">root</property>18<property name="connection.password">sa</property>19<property name="connection.driver_class">20 com.mysql.jdbc.Driver21</property>22<property name="dialect">23 org.hibernate.dialect.MySQLDialect24</property>2526<!-- ⾃动建表 -->27<property name="hbm2ddl.auto">auto</property>28<property name="connection.autocommit">true</property>29<mapping class="com.basehibernate.pojo.Department"/>30<mapping class="com.basehibernate.pojo.Employee"/>31<mapping class="com.basehibernate.pojo.Meal"/>32<mapping class="com.basehibernate.pojo.OrderMeal"/>33<mapping class="com.basehibernate.pojo.GradeMeal"/>34<mapping class="com.basehibernate.pojo.RewardMeal"/>3536</session-factory>3738</hibernate-configuration>不同数据库连接在Hibernate.cfg.xml中的配置不同,这⾥以MySQL为例。
Hibernate4实战之Hibernate4注解零配置
Hibernate4实战之Hibernate4注解零配置@Entity,注册在类头上,将一个类声明为一个实体bean(即一个持久化POJO类) 。
@Table,注册在类头上,注解声明了该实体bean映射指定的表(table)。
@Id用来注册主属性,@GeneratedValue用来注册主属性的生成策略,@Column用来注册属性,@Version用来注册乐观锁,@Transient用来注册不是属性。
以上的@Id、@GeneratedValue、@Column、@Version,可以用来注册属性,既可以写在Java类的属性上,也可以注册在属性对应的getter上。
@Transient注册在多余的属性或多余的getter上,但是必须与以上的@Column等对应。
@Column标识属性对应的字段,示例:@Column(name=“userName")@Column(name="columnName"; (1)boolean unique() default false; (2)boolean nullable() default true; (3)boolean insertable() default true; (4)boolean updatable() default true; (5)String columnDefinition() default""; (6)String table() default""; (7)int length() default255; (8)int precision() default0; // decimal precision (9)int scale() default0; // decimal scale (10)(1) name 可选,列名(默认值是属性名)(2) unique 可选,是否在该列上设置唯一约束(默认值false)(3) nullable 可选,是否设置该列的值可以为空(默认值false)(4) insertable 可选,该列是否作为生成的insert语句中的一个列(默认值true)(5) updatable 可选,该列是否作为生成的update语句中的一个列(默认值true)(6) columnDefinition 可选: 为这个特定列覆盖SQL DDL片段(这可能导致无法在不同数据库间移植)(7) table 可选,定义对应的表(默认为主表)(8) length 可选,列长度(默认值255)(8) precision 可选,列十进制精度(decimal precision)(默认值0)(10) scale 可选,如果列十进制数值范围(decimal scale)可用,在此设置(默认值0)@Id,标识这个属性是实体类的唯一识别的值。
六大类系统架构图及其简介
各种系统架构图及其简介1.Spring架构图Spring是一个开源框架,是为了解决企业应用程序开发复杂性而创建的。
框架的主要优势之一就是其分层架构,分层架构允许您选择使用哪一个组件,同时为J2EE应用程序开发提供集成的框架。
Spring框架的功能可以用在任何J2EE 服务器中,大多数功能也适用于不受管理的环境。
Spring的核心要点是:支持不绑定到特定J2EE服务的可重用业务和数据访问对象。
这样的对象可以在不同J2EE环境(Web或EJB)、独立应用程序、测试环境之间重用。
组成Spring框架的每个模块(或组件)都可以单独存在,或者与其他一个或多个模块联合实现。
每个模块的功能如下:核心容器:核心容器提供Spring框架的基本功能。
核心容器的主要组件是BeanFactory,它是工厂模式的实现。
BeanFactory使用控制反转(IOC)模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring上下文:Spring上下文是一个配置文件,向Spring框架提供上下文信息。
Spring上下文包括企业服务,例如JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP:通过配置管理特性,Spring AOP模块直接将面向方面的编程功能集成到了Spring框架中。
所以,可以很容易地使Spring框架管理的任何对象支持AOP。
Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。
通过使用Spring AOP,不用依赖EJB组件,就可以将声明性事务管理集成到应用程序中。
Spring DAO:JDBC DAO抽象层提供了有意义的异常层次结构,可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。
异常层次结构简化了错误处理,并且极大地降低了需要编写的异常代码数量(例如打开和关闭连接)。
Spring DAO的面向JDBC的异常遵从通用的DAO异常层次结构。
Spring ORM:Spring框架插入了若干个ORM框架,从而提供了ORM的对象关系工具,其中包括JDO、Hibernate和iBatis SQL Map。
spring配置详解
spring配置详解1.前⾔公司⽼项⽬的后台,均是基于spring框架搭建,其中还⽤到了log4j.jar等开源架包。
在新项⽬中,则是spring和hibernate框架均有使⽤,利⽤了hibernate框架,来实现持久化,简化sql操作等。
Hibernate配置⽂件可以有两种格式,⼀种是 hibernate.properties,另⼀种是hibernate.cfg.xml。
后者稍微⽅便⼀些,当增加hbm映射⽂件的时候,可以直接在 hibernate.cfg.xml ⾥⾯增加,不必像 hibernate.properties 必须在初始化代码中加⼊。
我们新项⽬中使⽤的是hibernate.cfg.xml格式。
不过在本⽂中不将细述,后续有机会再补上。
公司项⽬中,中间件主要有tomcat,webshpere,WebLogic。
以下,将对项⽬中spring基本配置,log4j的配置,还有中间件的相关参数配置做⼀个初步的介绍。
2.spring配置——以⽼GIS项⽬为例⼦GISV13中的配置涉及到了SpringMVC,IOC,AOP, Quartz⽅⾯的配置。
配置的实现是通过注记配置和XML配置来合作实现。
这⾥,我将按照Spring的配置流程,将其他⼏个⽅⾯的配置融合其中,来进⾏全⾯解析。
2.1SpringMVC的配置2.1.1.web.xml的配置Web程序中,当中间件启动时,中间件会⾸先读取web.xml中的配置。
在web.xml中可以配置监听器,过滤器,servlet映射等等。
在Spring 框架中,我们主要需配置容器初始化时读取的spring容器配置⽂件的路径以及springMVC中的分发器DispatcherServlet。
在GISV13的web.xml中,我们定义了如下内容:InitGISConfigServlet定义了容器启动时,⾸先要运⾏这个⽅法。
然后servletname为MVC的这部分便是定义了springMVC的分发器以及此servlet所对应的加载配置⽂件的路径。
Hibernate4之配置详解
Hibernate4之配置详解Hibernate基本配置其实就是SessionFactory的配置,所有配置都在<session-factory/>标签之内。
但是<session-factory/>标签又可以分成3个部分的配置:1.JDBC连接参数的基本配置2.Hibernate连接池的参数配置3.注册ORM映射文件的配置Hibernate4和Hibernate3在配置上的一些区别:连接池c3p0的配置由于Hibernate自己实现的连接池不太好,在项目中,建议使用工业级的连接池,比如:c3p0,Hibernate发行包中带有c3p0的专用jar包hibernate-c3p0-4.1.4.Final.jar,在以前的Hibernate3.X版本中是直接在核心jar包里面的,在4.X版本之后包名做出来调整,大家使用的时候需要注意了。
TransactionFactory有三个标准(内建)的选择:1:委托给数据库(JDBC)事务(默认)Hibernate3:org.hibernate.transaction.JDBCTransactionFactor yHibernate4:org.hibernate.engine.transaction.internal.jdbc.JD BCTransactionFactory2:JTA事务,如果在上下文环境中存在运行着的事务(如, EJB会话Bean的方法), 则委托给容器管理的事务, 否则,将启动一个新的事务,并使用Bean管理的事务.Hibernate3: org.hibernate.transaction.JTATransactionFactory Hibernate4:org.hibernate.engine.transaction.internal.jta.JTATransactionFacto ry3:委托给容器管理的JTA事务Hibernate3:org.hibernate.transaction.CMTTransactionFactoryHibernate4:org.hibernate.engine.transaction.internal.jta.CM TTransactionFactory也可以定义属于你自己的事务策略 (如, 针对CORBA的事务服务)Hibernate4连接池C3P0基本配置Xml代码1.<?xml version="1.0" encoding="UTF-8"?>2.<!DOCTYPE hibernate-configuration PUBLIC3."-//Hibernate/Hibernate Configuration DTD 3.0//EN"4."/hibernate-configuration-3.0.dtd">5.<hibernate-configuration>6.7.<session-factory>8.<property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:orcl</property>9.<property name="ername">username</pr operty>10.<property name="connection.password">password</ property>11.<!-- 数据库JDBC驱动类名 -->12.<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>13.<!-- 数据库方言 -->14.<property name="dialect">org.hibernate.dialect.Oracl e10gDialect</property>15.<!-- ddl语句自动建表 -->16.<property name="hbm2ddl.auto">none</property>17.<property name="show_sql">true</property>18.<property name="format_sql">true</property>19.20.<!-- 连接池配置 -->21.<property name="hibernate.connection.provider_clas s">.hibernate.service.jdbc.connections.internal.C3P0C onnectionProvider23.</property>24.<!-- 连接池中JDBC连接的最小数量。
Hibernate 配置详解 (一)
Hibernate 配置详解(一)Hibernate的基本配置文件有两种:hibernate.cfg.xml和*.hbm.xml文件。
前者包含了Hibernate与数据库的基本连接信息,在Hibernate工作的初始阶段,这些信息被先后加载到Configuration和SessionFactory实例;后者包含了Hibernate的基本映射信息,即系统中每一个类与其对应的数据库表之间的关联信息,在Hibernate工作的初始阶段,这些信息通过hibernate.cfg.xml的mapping 节点被加载到Configuration和SessionFactory实例。
这两种文件信息包含了Hibernate的所有运行期参数。
下面我们用详细的例子来说明这两种文件的基本结构和内容。
一、hibernate.cfg.xml文件:<!--该文件的开头信息,对Hibernate而言,该类文件基本都这么开头:--> <?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><!-- 正文开始--><hibernate-configuration><!--下面是数据库的基本连接信息,对一个应用来说,设置一个session-factory节点就够了,除非我们中间使用了多个数据库--> <session-factory><!--数据库驱动信息--><propertyname="connection.driver_class">com.mysql.jdbc.Driver</property><!--url信息--><propertyname="connection.url">jdbc:mysql://localhost:3306/webases</property><!--用户名--><property name="ername">root</property><!--密码--><property name="connection.password">274507</property><!--数据库方言信息--><property name="dialect">org.hibernate.dialect.MySQLDialect</property><!--指定Hibernate映射文件路径--><mapping resource="com/Hibernate/test_products.hbm.xml" /></session-factory></hibernate-configuration>。
Hibernate入门-基础配置
Hibernate入门 - 基础配置作者:robbin (MSN:robbin_fan AT hotmail DOT com)版权声明:本文严禁转载,如有转载请求,请和作者联系Hibernate配置文件可以有两种格式,一种是hibernate.properties,另一种是hibernate.cfg.xml后者稍微方便一些,当增加hbm映射文件的时候,可以直接在hibernate.cfg.xml里面增加,不必像hibernate.properties必须在初始化代码中加入。
但不管怎么说,两种的配置项都是一样的,下面详细介绍:在Hibernate的src目录下有一个hibernate.properties模板,我们不必自己从头写,修改模板就可以了:)∙hibernate.query.substitutions true 1, false 0, yes 'Y', no 'N'这个配置意思是当你在Hibernate里面输入true的时候,Hibernate会转化为1插入数据库,当你在Hibernate里面输入false的时候,Hibernate会转化为0插入数据库,后面的Y,N同理。
对于某些数据库,例如Oracle来说,没有boolean数据类型,就是采用1代表true,0代表false,因此使用这个配置在Hibernate里面直接用true/false 会非常直观。
∙hibernate.dialect net.sf.hibernate.dialect.MySQLDialecthibernate.connection.driver_class com.mysql.jdbc.Driverhibernate.connection.url jdbc:mysql:///testername roothibernate.connection.password这是一个连接MySQL数据库的例子,很直观,不必解释,不同的数据库的连接参数模板中全部给出了。
Struts,Spring, hibernate基本配置
Servlet, Spring, hibernate基本配置本文主要描述个人对于servlet,spring,及hibernate初始化过程的理解。
1,一切皆因web.xml而起。
web.xml,也叫deployment descriptor。
从这个名字就知道它包含了web程序运行的所有信息。
当servlet容器初始化的时候就会读取该文件的内容,来决定如何初始化程序上下文,如何定义servlet的参数,如何定义Request Dispatch,如何挂载filter,如何运行Listener等信息。
来看一个简单的web.xml的例子:web.xml1<?xml version="1.0" encoding="UTF-8"?>2<web-app xmlns="/xml/ns/javaee"; xmlns:xsi="http://www.w3.o rg/2001/XMLSchema-instance";3 xsi:schemaLocation="/xml/ns/javaee4 /xml/ns/javaee/web-app_3_0.xsd";5 version="3.0">6<display-name>chronicles</display-name>78<context-param>9<param-name>key</param-name>10<param-value>value</param-value>11</context-param>1213<listener>14<listener-class>org.springframework.web.context.ContextLoaderListener 15</listener-class>16</listener>1718<filter>19<filter-name>LoggingFilter</filter-name>20<filter-class>org.springframework.web.filter.Log4jNestedDiagnosticConte xtFilter</filter-class>21</filter>2223<filter-mapping>24<filter-name>LoggingFilter</filter-name>25<url-pattern>/*</url-pattern>26</filter-mapping>2728<servlet>29<servlet-name>chronicles</servlet-name>30<servlet-class>org.springframework.web.servlet.DispatcherServlet31</servlet-class>32<load-on-startup>1</load-on-startup>33</servlet>3435<servlet-mapping>36<servlet-name>chronicles</servlet-name>37<url-pattern>/</url-pattern>38</servlet-mapping>3940<welcome-file-list>41<welcome-file>index.jsp</welcome-file>42</welcome-file-list>43</web-app>44该例子包含了常用的一些标签。
springmvc+spring+hibernate整合详解注解形式事物管理
Springmvc4+spring4+hibernate4整合步骤前言:(声明式事务管理采用配置文件来配置事物)准备工作:1/安装并配置java运行环境2/数据库的安装配置(Mysql)3/安装并配置服务器(Tomcat)4/Maven5/ IntelliJIDEA的安装配置(本人使用的主要软件是IntelliJIDEA,没用eclipse什么的)6/ 使用IntelliJIDEA创建一个web app项目。
一、在pom.xml文件中引入相关框架整合的依赖二、SpringMvc配置:我们先配置下SpringMVC的配置:resources/META-INF/spring-mvc.xml(也可以把OK,SpringMVC配置完成,现在我们进行一下测试吧在controller层新建一个TestController,内容如下test.jsp网页如下:重启Tomcat服务器,然后浏览器访问localhost:8080/test如下图所示:三、springmvc+Spring整合这个就十分简单了,配置applicationContext.xml这个Spring的配置文件如下:完善web.xml配置文件如下:(applicationContext.xml在META-INF文件夹下配置如下),如果直接在resources下配置:classpath*:/applicationContext.xmlweb.xml配置文件中更改了三处:引入Spring配置文件Spring的监听器以及字符集过滤,以及加载Spring上下文配置OK,Spring+SpringMVC配置完成,下面我们开始测试:在service写一个TestServiceImpl实现TestService接口并实现其test()方法,代码如下:TestServiceTestServiceImplTestController更改如下:控制器这里我们运用了Spring的依赖注入自动装配。
SSH常见错误
一、Hibernate配置错误1、Limit附近有语法错误(不能进行分页)映射文件中数据库方言配置错误,应该有MySQLDialect改为SQLServerDialect二、Strus2配置错误1、ng.NoClassDefFoundError: org/apache/commons/lang3/StringUtils缺少struts2中的jar包commons-lang-2.5.jar2、Unable to load configuration. - action – file:...struts.xmlCaused by: Action class [example.HelloWorld] not foundStruts.xml中Action配置错误3、ng.NoClassDefFoundError: org/apache/struts2/util/ObjectFactoryDestroyable重启tomcat4、Exception in thread "main" ng.IllegalArgumentException: PWC6311: compilerTargetVM 1.7 too high将项目——属性——源代码/二进制格式改成JDK1.6,而不是原来的JDK1.75、failed to lazily initialize a collection of role: entity.Student.classes, no session or session was closed映射文件中设置lazy=”false”,加载方式改成load而不是get6、升级到struts2.3后validate框架失效的解决<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//EN""/xwork/xwork-validator-1.0.2.dtd">改成:<!DOCTYPE validators PUBLIC"-//Apache Struts//XWork Validator 1.0.2//EN""/xwork/xwork-validator-1.0.3.dtd">7、com.mchange.v2.async.ThreadPoolAsynchronousRunner$DeadlockDetector@12539a92 -- APPARENT DEADLOCK!!! Complete Status:数据库服务没有启动三、Spring3配置错误1、log4j:WARN No appenders could be found for logger<context-param><param-name>log4jConfigLocation</param-name><param-value>/WEB-INF/config/log4j.properties</param-value></context-param>······<!-- 定义LOG4J监听器--><listener><listener-class>org.springframework.web.util.Log4jConfigListener</listener-class></listener>2、ng.ClassNotFoundException: org.testng.annotations.BeforeTestSpring3类库中添加testing3、WARN [org.hibernate.internal.util.xml.DTDEntityResolver] - HHH000223: Recognized obsoletehibernate namespace /. Use namespace/dtd/ instead. Refer to Hibernate 3.6 Migration Guide!修改配置文件和映射文件中dtd的地址改成四、Spring3.x+Hibernate4.x升级问题1、Caused by: ng.ClassNotFoundException: org.hibernate.cache.CacheProvider出现这个问题主要是hibernate4里不在有cacheprovider类,cacheprovider在hibernate3中才有,用hibernate4就应该用hibernate4的SessionFactory。
hibernate4基本配置
hibernate4基本配置可编程的配置方式-1如果在配置cfg.xml的时候,不想在里面配置hbm.xml怎么办呢?可在程序里使用可编程的配置方式,也就是使用程序来指定在cfg.xml里面的配置信息,不推荐这种方式。
如下:Configuration cfg = new Configuration().addResource("Item.hbm.xml").addResource("Bid.hbm.xml");一个替代方法(有时是更好选择)是,指定被映射的类,让Hibernate帮你寻找映射定义文件:Configuration cfg = new Configuration().addClass(org.hibernate.auction.Item.class).addClass(org.hibernate.auction.Bid.class);这种方式消除了任何对文件名的硬编码可编程的配置方式-2还可以通过编程的方式来指定配置属性:Configuration cfg = new Configuration().addClass(org.hibernate.auction.Item.class).setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLInnoDBDialect").setProperty("hibernate.connection.datasource", "java:comp/env/jdbc/test").setProperty("hibernate.order_updates", "true");其他可以传入配置属性的方式:1:properties文件2:xml文件3:设置Java的系统属性,形如:java –Dproperty=value另外要注意一点:org.hibernate.cfg.Configuration 实例被设计成启动期间(startup-time)对象,一旦SessionFactory 创建完成它就被丢弃了。
Spring4+Hibernate4事务管理配置注解AOP
Spring4+Hibernate4事务管理配置注解AOP在单独使⽤hibernate的时候使⽤如下配置:<property name="hibernate.current_session_context_class">thread</property>根据⽂档,这个是hibernate3.1以后的⼀个新扩展,⽬的在于可以让我们在某⼀个上下⽂环境(⽐如说当前线程)中可以通过SessionFactory.getCurrentSession()得到同⼀个session会话.该⽅式会⾃动关闭session,但是事务控制仍然需要⼿动开始和提交。
public Long createUser(UserVO user) {Session session = sessionFactory.getCurrentSession();Transaction tx = session.beginTransaction();Long id = (Long) session.save(user);mit();return id;}在Spring + Hibernate 整合时我们希望通过使⽤声明式事务管理或使⽤@Transactional注解进⾏事务管理。
如果 hibernate.current_session_context_class 属性配置为thread话,会抛⼀个异常: get is not valid without active transaction。
这个错误⼀般情况是因为由getCurrentSession得到的session中没有获得的transaction,我们⼀般要⼿动的调⽤Transaction tx =session.beginTransaction(); 和 mit() 来控制事务。
但是问题是,我们在spring的配置⽂件中不是已经通过aop,指定了此处由spring来管理事务吗,怎么还要⼿动处理事务?解决办法是将 thread 改为 org.springframework.orm.hibernate4.SpringSessionContext。
Spring配置文件集成Hibernate配置文件
Spring配置⽂件集成Hibernate配置⽂件Spring对hibernate配置⽂件hibernate.cfg.xml的集成,来取代hibernate.cfg.xml的配置。
spring对hibernate配置⽂件hibernate.cfg.xml的集成相当好,可以在Spring中配置Hibernate的SessionFactory从⽽取代Hibernate.cfg.xml和HibernateSessionFactory.javaSpring在集成Hibernate时⼜分为两种形式:1、继续使⽤Hibernate的映射⽂件*.hbm.xml2、使⽤jpa注解形式的pojo对象,⽽去掉*.hbm.xml的Hibernate映射⽂件⾸先要引⼊jar包⼀.继续使⽤Hibernate的映射⽂件*.hbm.xml<!-- 定义dbcp数据源 --><bean id="dataSource" class="mons.dbcp.BasicDataSource"><!-- 指定jdbc驱动 --><property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property><!-- 连接数据库的url地址 --><property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"></property><!-- 连接数据的⽤户名和密码 --><property name="username" value="hyj"></property><property name="password" value="123"></property></bean><!-- 定义sessionFactory --><bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><!-- 为LocalSessionFactoryBean注⼊定义好的数据源 --><property name="dataSource"><ref bean="dataSource"/></property><!--添加hibernate配置参数 --><property name="hibernateProperties"><props><!-- 每个数据库都有其对应的Dialect以匹配其平台特性 --><prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop><!-- 是否将运⾏期⽣成的sql输出到⽇志以供调试 --><prop key="hibernate.show_sql">true</prop><!-- 是否格式化sql --><prop key="hibernate.format_sql">true</prop><prop key="hibernate.hbm2ddl.auto">update</prop></props></property><!-- 添加对象关系映射 --><property name="mappingResources"><list><value>classpath:cn/entity/User.hbm.xml</value></list></property></bean>⼆.使⽤jpa注解形式的pojo对象,⽽去掉*.hbm.xml的Hibernate映射⽂件这⾥需要注意的就是1.spring中配置SessionFactory bean时它对应的class应为org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean2.AnnotationSessionFactoryBean中查找jpa注解形式的pojo映射对象的属性有:annotatedClasses、packagesToScan① annotatedClasses:指定classpath下指定的注解映射实体类的类名② packagesToScan指定映射⽂件的包名<!-- 定义dbcp数据源 --><bean id="dataSource" class="mons.dbcp.BasicDataSource"><!-- 指定jdbc驱动 --><property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property><!-- 连接数据库的url地址 --><property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"></property><!-- 连接数据的⽤户名和密码 --><property name="username" value="hyj"></property><property name="password" value="123"></property></bean><!-- 定义sessionFactory --><bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"><!-- 为LocalSessionFactoryBean注⼊定义好的数据源 --><property name="dataSource"><ref bean="dataSource"/></property><!--添加hibernate配置参数 --><property name="hibernateProperties"><props><!-- 每个数据库都有其对应的Dialect以匹配其平台特性 --><prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop><!-- 是否将运⾏期⽣成的sql输出到⽇志以供调试 --><prop key="hibernate.show_sql">true</prop><!-- 是否格式化sql --><prop key="hibernate.format_sql">true</prop><prop key="hibernate.hbm2ddl.auto">update</prop></props></property><!-- 添加对象关系映射 --><property name="packagesToScan"><list><value>cn.entity.*</value></list></property></bean>。
多数据库配置
spring+hibernate 多数据源配置及使用2010-10-07 15:52:58| 分类:Java|字号订阅spring配置文件(主要写了多数据源的配置,后面的sessionFactory和事务管理没有写):<!--parentDataSource表示多个数据源共有的信息,这里我用的是mysql中的不同数据库--><bean id="parentDataSource"class="mons.dbcp.BasicDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"></property> <property name="username" value="root"></property><property name="password" value="root"></property><!-- 连接池启动时的初始值 --><property name="initialSize" value="1"/><property name="maxActive" value="500"/><property name="maxIdle" value="2"/><property name="minIdle" value="1"/></bean><!--adminDataSource为一个数据源,这里的数据库为zgcyx,两个数据远的url链接不一样--><bean name="adminDataSource" parent="parentDataSource"><property name="url"value="jdbc:mysql://127.0.0.1:3306/zgcyx?createDatabaseIfNotExist=true&useU nicode=true&characterEncoding=utf8&autoReconnect=true&zeroDateTimeB ehavior=convertToNull"/></bean><!--userDataSource为另一个数据源,这里的数据库为tieba--><bean name="userDataSource" parent="parentDataSource"><property name="url"value="jdbc:mysql://127.0.0.1:3306/tieba?createDatabaseIfNotExist=true&useU nicode=true&characterEncoding=utf8&autoReconnect=true&zeroDateTimeB ehavior=convertToNull"/></bean><!--类DynamicDataSource会在下文中创建--><bean id="dataSource" class="cn.zgcyx.web.site.action.DynamicDataSource"> <property name="targetDataSources"><map key-type="ng.String"><!--Amin和Use的类型,必须与类中的类型一样r--><!--Admin和User为两个字符串,用来区别不同的数据源的与类中填写的值要完全一样--><entry key="Admin" value-ref="adminDataSource"></entry><entry key="User" value-ref="userDataSource"></entry></map></property><property name="defaultTargetDataSource"ref="adminDataSource"></property><!--默认的数据源为adminDataSource--></bean>类DataSourceMap.java(用来区分不同的数据源)public class DataSourceMap {public static final String Admin="Admin";public static final String User = "User";}类CustomerContextHolder.javapublic class CustomerContextHolder {private static final ThreadLocal contextHolder = new ThreadLocal();public static void setCustomerType(String customerType) {contextHolder.set(customerType);}public static String getCustomerType() {return (String) contextHolder.get();}public static void clearCustomerType() {contextHolder.remove();}}类DynamicDataSource.java(需要继承AbstractRoutingDataSource ,并重写方法determineCurrentL)public class DynamicDataSource extends AbstractRoutingDataSource {@Overrideprotected Object determineCurrentLookupKey() {// TODO Auto-generated method stubreturn CustomerContextHolder.getCustomerType();}}在这里,默认使用的是数据源是adminDataSource,需要对数据源B进行引用的话action中:public String getFromTieBa(){HttpServletRequest request = ServletActionContext.getRequest();Integer typeId = Integer.parseInt(request.getParameter("typeId"));CustomerContextHolder.setCustomerType(er); //引用user数据源,这样才能到数据源user中进行操作listProblemFromTieBa = siteServices.getById(typeId); //for(ProblemFromTieBa p:listProblemFromTieBa){System.out.println(p.getTitle()+"-----"); //}return null;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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:指定当前方法必需在事务环境中运行,如果当前有事务环境就加入当前正在执行的事务环境,如果当前没有事务,就新建一个事务。
这是默认值。
--><tx:method name="create*"propagation="REQUIRED"/><tx:method name="save*"propagation="REQUIRED"/><tx:method name="add*"propagation="REQUIRED"/></beans>自己写了一个test用的basedao package tdxy.dao;import java.util.List;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Repository;/**** @Title: BaseDao.java* @Package tdxy.dao* @Description: TODO(baseDao 数据库操作实现类)* @author dapeng* @date 2014年5月7日下午5:09:22* @version V1.0*/@Repositorypublic class BaseDao {/*** Autowired 自动装配相当于get() set()*/@Autowiredprotected SessionFactory sessionFactory;/*** gerCurrentSession 会自动关闭session,使用的是当前的session事务** @return*/public Session getSession() {return sessionFactory.getCurrentSession();}/*** openSession 需要手动关闭session 意思是打开一个新的session** @return*/public Session getNewSession() {return sessionFactory.openSession();}public void flush() {getSession().flush();}public void clear() {getSession().clear();}/*** 根据id 查询信息** @param id* @return*/@SuppressWarnings("rawtypes")public Object load(Class c, String id) {Session session = getSession();return session.get(c, id);}/*** 获取所有信息** @param c** @return*/@SuppressWarnings({ "rawtypes" })public List getAllList(Class c) {String hql = "from " + c.getName();Session session = getSession();return session.createQuery(hql).list();}/*** 获取总数量** @param c* @return*/@SuppressWarnings("rawtypes")public Long getTotalCount(Class c) {Session session = getNewSession();String hql = "select count(*) from " + c.getName();Long count = (Long) session.createQuery(hql).uniqueResult();session.close();return count != null? count.longValue() : 0;}/*** 保存** @param bean**/public void save(Object bean) {try{Session session = getNewSession();session.save(bean);session.flush();session.clear();session.close();} catch(Exception e) {e.printStackTrace();}}/*** 更新** @param bean**/public void update(Object bean) {Session session = getNewSession();session.update(bean);session.flush();session.clear();session.close();}/*** 删除** @param bean**/public void delete(Object bean) {Session session = getNewSession();session.delete(bean);session.flush();session.clear();session.close();}/*** 根据ID删除** @param c 类** @param id ID**/@SuppressWarnings({ "rawtypes" })public void delete(Class c, String id) {Session session = getNewSession();Object obj = session.get(c, id);session.delete(obj);flush();clear();}/*** 批量删除** @param c 类** @param ids ID 集合**/@SuppressWarnings({ "rawtypes" })public void delete(Class c, String[] ids) { for(String id : ids) {Object obj = getSession().get(c, id);if(obj != null) {getSession().delete(obj);}}}}不知大家有没有注意applicationContext.xml 这样一句代码<!-- 设置自动创建|更新|验证数据库表结构-->hibernate.hbm2ddl.auto=update这个意思是只要在实体bean指定了entity,那么在数据库会自动创建对应的表和表结构test用的一个实体beanpackage tdxy.bean;import java.io.Serializable;import javax.persistence.Entity;import javax.persistence.Id;/**** @ClassName: UserInfoBean* @Description: TODO(用户信息类)* @author dapeng* @date 2014年5月7日上午12:13:44* @version V1.0**/@Entitypublic class UserInfoBean implements Serializable {private static final long serialVersionUID = 7280747949998651159L;@Idprivate String id;/*** 昵称*/private String nickName;private String pwd;/*** 等级**/private String level;/*** 经验值*/private String emValue;/*** 性别(0 男1女)*/private String sex;private String birthday;private String qq;private String email;/*** 头像*/private String img;/*** 所在地*/private String address;/*** 签名*/private String qmd;public String getId() {return id;}public void setId(String id) {this.id = id;}public String getNickName() {return nickName;}public void setNickName(String nickName) { this.nickName = nickName;}public String getPwd() {return pwd;}public void setPwd(String pwd) {this.pwd = pwd;}public String getLevel() {return level;}public void setLevel(String level) {this.level = level;}public String getEmValue() {return emValue;}public void setEmValue(String emValue) { this.emValue = emValue;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public String getBirthday() {return birthday;}public void setBirthday(String birthday) { this.birthday = birthday;}public String getQq() {return qq;}public void setQq(String qq) {this.qq = qq;}public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}public String getImg() {return img;}public void setImg(String img) {this.img = img;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}public String getQmd() {return qmd;}public void setQmd(String qmd) {this.qmd = qmd;}}当应用成功启动之后,数据库会出现表和结构,即刚才定义的bean是一样的,大家可以自己查看一下即可。