Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用。
步骤一:解压hibernate-release-4.1.1.Final.zip,然后到hibernate-release-4.1.1.Final\lib\required文件夹下将所有的jar包拷贝到项目所在的lib文件夹下,效果图如图1所示:
图1
其中相应的jar包以及作用如下所示:
jar包(.jar) | 作用 |
antlr-2.7.7 | 语言转换工具,hibernate利用它实现HQL到SQL的转换 |
dom4j-1.6.1 | 对dom4j的封装,解析xml文件 |
hibernate-commons-annotations-4.0.1.Final | 常见的反射代码用于支持注解处理 |
hibernate-core-4.1.1.Final | Hibernate的核心代码 |
hibernate-jpa-2.0-api-1.0.1.Final | 用来定义Hibernate持久性 |
javassist-3.15.0-GA | 一个开源的分析、编辑和创建Java字节码的类库 |
jboss-logging-3.1.0.GA | Jboss的日志框架 |
jboss-transaction-api_1.1_spec-1.0.0.Final | Jboss事务处理 |
步骤二:拷贝hibernate-release-4.1.1.Final\project\etc文件夹下hibernate.cfg.xml文件到项目src目录下,然后进行更改,具体的项目结构如图2所示:
图2
对配置文件hibernate.cfg.xml进行更改,如下所示:
hibernate.cfg.xml
- <!DOCTYPE hibernate-configuration PUBLIC
- "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
- "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
- <hibernate-configuration>
- <session-factory>
- <!-- mysql连接驱动,需要导入mysql驱动jar包 -->
- <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
- <!-- mysql数据库连接地址 -->
- <property name="connection.url">jdbc:mysql://localhost/steven</property>
- <!-- 数据库用户名 -->
- <property name="connection.username">root</property>
- <!-- 数据库密码 -->
- <property name="connection.password">mysqladmin</property>
- <!-- 数据库方言 -->
- <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
- <!-- 显示sql语句 -->
- <property name="show_sql">true</property>
- <!-- 格式化sql语句 -->
- <property name="format_sql">true</property>
- <!-- 加载hibernate自动更新数据库结构 -->
- <property name="hbm2ddl.auto">update</property>
- <!-- 映射实体类 -->
- <mapping class="com.steven.entity.User" />
- </session-factory>
- </hibernate-configuration>
打开命令提示符,连接Mysql,创建数据库steven,如图3所示:
图3
注:本文Hibernate映射采用全注解方式使用,首先,注解方式简单,灵活,简洁,其次在开发中在有源代码的情况下使用较多,建议使用注解方式。
由于在hibernate.cfg.xml配置文件中已经配置映射实体类User.java,下面给出添加注解后的实体类
User.java
- package com.steven.entity;
- import java.util.Date;
- import javax.persistence.Entity;
- import javax.persistence.GeneratedValue;
- import javax.persistence.Id;
- import javax.persistence.Table;
- /**
- * 实体类
- *
- * @author Steven
- *
- */
- // 标示这个类为映射实体类
- @Entity
- // 改变数据库中映射表的名称,不加默认表名称为类名即User
- @Table(name = "t_user")
- public class User {
- // 用户Id
- private int userId;
- // 用户名
- private String userName;
- // 用户年龄
- private int age;
- // 用户生日
- private Date birthday;
- // 用户是否是会员 true:是 false:不是
- private boolean isVip;
- public User() {
- }
- // 有参构造
- public User(String userName, int age, Date birthday, boolean isVip) {
- this.userName = userName;
- this.age = age;
- this.birthday = birthday;
- this.isVip = isVip;
- }
- // 标识此字段为数据库中的主键
- @Id
- // 标识此字段为数据库中成序列增长的列,不同的数据库,Hibernate会自动匹配
- @GeneratedValue
- public int getUserId() {
- return userId;
- }
- public void setUserId(int userId) {
- this.userId = userId;
- }
- public String getUserName() {
- return userName;
- }
- public void setUserName(String userName) {
- this.userName = userName;
- }
- public int getAge() {
- return age;
- }
- public void setAge(int age) {
- this.age = age;
- }
- public Date getBirthday() {
- return birthday;
- }
- public void setBirthday(Date birthday) {
- this.birthday = birthday;
- }
- public boolean getIsVip() {
- return isVip;
- }
- public void setIsVip(boolean isVip) {
- this.isVip = isVip;
- }
- @Override
- public String toString() {
- return "用户信息: [年龄是" + this.getAge() + ", 生日是" + this.getBirthday()
- + ", 用户编号是" + this.getUserId() + ", 用户名是" + userName
- + isVip(this.getIsVip()) + "]";
- }
- /**
- * 用来进行测试使用
- *
- * @param isVip
- * @return
- */
- public String isVip(boolean isVip) {
- return ", " + (isVip == true ? "是" : "不是") + "会员";
- }
- }
然后建立测试类,首先建立一个Source Folder,用来存放所有的测试代码,点击项目名称,右键New—>Source Folder,如图4所示:
图4
点击Finish,完成创建,然后,创建包com.steven.test,创建后的目录结构如图5所示:
图5
下面将创建JUnit Test Case,点击包名com.steven.test,右键New->Other,弹出New选项窗口,选择JUnit Test Case,如图6所示:
图6
点击Next进入下一步,然后如图7所示进行选择和填写,
图7
点击Finish,弹出如图8所示的窗口,点击OK完成创建,
图8
此时项目结构图如图9所示:
图9
打开HibernateTest.java,然后更改代码如下所示:
HibernateTest.java
- package com.steven.test;
- import org.hibernate.cfg.Configuration;
- import org.hibernate.tool.hbm2ddl.SchemaExport;
- import org.junit.Test;
- /**
- * Hibernate测试类
- *
- * @author Steven
- *
- */
- public class HibernateTest {
- // JUnit注解,可以通过此进行测试
- @Test
- /**
- * 测试1,自动创建数据表,因为在配置文件Hibernate.cfg.xml中配置了<property name="hbm2ddl.auto">update</property>
- */
- public void testSchemaExport() {
- new SchemaExport(new Configuration().configure()).create(true, true);
- }
- }
接着进行测试,选中要测试的方法,右击Run As->JUnit Test,此时控制台会发现出现异常信息,
- ERROR: HHH000231: Schema export unsuccessful
- org.hibernate.HibernateException: Specified JDBC Driver com.mysql.jdbc.Driver class not found
- at org.hibernate.service.jdbc.connections.internal.DriverManagerConnectionProviderImpl.configure(DriverManagerConnectionProviderImpl.java:104)
- at org.hibernate.service.internal.StandardServiceRegistryImpl.configureService(StandardServiceRegistryImpl.java:75)
- at org.hibernate.service.internal.AbstractServiceRegistryImpl.initializeService(AbstractServiceRegistryImpl.java:159)
- at org.hibernate.service.internal.AbstractServiceRegistryImpl.getService(AbstractServiceRegistryImpl.java:131)
- at org.hibernate.tool.hbm2ddl.ManagedProviderConnectionHelper.prepare(ManagedProviderConnectionHelper.java:55)
- at org.hibernate.tool.hbm2ddl.DatabaseExporter.<init>(DatabaseExporter.java:52)
- at org.hibernate.tool.hbm2ddl.SchemaExport.execute(SchemaExport.java:368)
- at org.hibernate.tool.hbm2ddl.SchemaExport.create(SchemaExport.java:305)
- at org.hibernate.tool.hbm2ddl.SchemaExport.create(SchemaExport.java:294)
- at com.steven.test.HibernateTest.testSchemaExport(HibernateTest.java:20)
- at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
- at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
- at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
- at java.lang.reflect.Method.invoke(Method.java:597)
- at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
- at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
- at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
- at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
- at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
- at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)
- at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:73)
- at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:46)
- at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180)
- at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41)
- at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173)
- at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
- at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)
- at org.junit.runners.ParentRunner.run(ParentRunner.java:220)
- at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46)
- at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
- at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
- at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
- at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
- at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)
- Caused by: java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
- at java.net.URLClassLoader$1.run(URLClassLoader.java:200)
- at java.security.AccessController.doPrivileged(Native Method)
- at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
- at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
- at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
- at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
- at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)
- at java.lang.Class.forName0(Native Method)
- at java.lang.Class.forName(Class.java:169)
- at org.hibernate.internal.util.ReflectHelper.classForName(ReflectHelper.java:192)
- at org.hibernate.service.jdbc.connections.internal.DriverManagerConnectionProviderImpl.configure(DriverManagerConnectionProviderImpl.java:101)
- ... 33 more
- 2013-12-10 19:26:52 org.hibernate.tool.hbm2ddl.SchemaExport execute
- INFO: HHH000230: Schema export complete
Specified JDBC Driver com.mysql.jdbc.Driver class not found, 原因是因为没有导入Mysql的驱动包,此时需要加入mysql-connector-java-5.1.7-bin.jar(http://pan.baidu.com/s/1efRMV)到lib下,此时再次执行测试方法,会发现控制台出现以下信息
- …………………………………………………………
- INFO: HHH000046: Connection properties: {user=root, password=****}
- drop table if exists t_user
- create table t_user (
- userId integer not null auto_increment,
- age integer not null,
- birthday datetime,
- isVip boolean not null,
- userName varchar(255),
- primary key (userId)
- )
- 2013-12-10 19:37:59 org.hibernate.service.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
- INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/steven]
- 2013-12-10 19:37:59 org.hibernate.tool.hbm2ddl.SchemaExport execute
- INFO: HHH000230: Schema export complete
图10
数据表t_user已经创建,并且所有的字段,类型,包括主键和序列增长都已经被创建,这就是Hibernate带来的好处,但是很多类型都是Hibernate默认创建的,如果想自己定义也是可以通过注解的方式更改,在此没有给出,有兴趣的可以参照其他博文进行学习。
注:在开发过程中是先写实体类还是先建表,面向对象标准开发流程推荐第一种方法,但实际开发中大部分是第二种,主要是因为在表里设置外键比在类里写关联属性要简单,使得不熟悉Hibernate的人用第二种也可以轻松的建立好mapping,而且更加灵活的创建表结构。
此时就可以测试数据库的增删改查的方法了,为了方便测试,可以为Hibernate封装一个Util类(这个类可以在Hibernate的参考文档中找到),专门用来对Session的获取(也就相当于JDBC中连接的概念),此时项目结构如图11所示:
图11
HibernateUtil.java内容如下:
- package com.steven.util;
- import org.hibernate.Session;
- import org.hibernate.SessionFactory;
- import org.hibernate.cfg.Configuration;
- import org.hibernate.service.ServiceRegistry;
- import org.hibernate.service.ServiceRegistryBuilder;
- /**
- * 创建Hibernate工具类
- *
- * @author Steven
- *
- */
- public class HibernateUtil {
- // Session 工厂
- private static SessionFactory factory;
- static {
- Configuration cfg = new Configuration().configure();
- ServiceRegistry sr = new ServiceRegistryBuilder().applySettings(
- cfg.getProperties()).buildServiceRegistry();
- factory = cfg.buildSessionFactory(sr);
- // 已经过时(主要出现在Hibernate3.x版本)
- // factory = new
- // AnnotationConfiguration().configure().buildSessionFactory();
- }
- public static SessionFactory getSessionFactory() {
- return factory;
- }
- public static Session getSession() {
- return factory.openSession();
- }
- public static void closeSession(Session session) {
- if (session != null) {
- if (session.isOpen()) {
- session.close();
- }
- }
- }
- }
此时进行创建表数据的测试,在HibernateTest.java中添加如下代码:
- @Test
- /**
- * 测试2,用来测试创建表数据
- */
- public void testCreate() {
- User u1 = new User("Steven", 1, new Date(), true);
- Session session = HibernateUtil.getSession();
- session.beginTransaction();
- session.save(u1);
- session.getTransaction().commit();
- HibernateUtil.closeSession(session);
- }
然后一样进行JUnit测试,运行后控制台输出信息:
- Hibernate:
- insert
- into
- t_user
- (age, birthday, isVip, userName)
- values
- (?, ?, ?, ?)
在查看数据库,发现增加了一条数据,如图12所示:
图12
这样可以确定Hibernate整合已经没有问题了,下面就可以进行具体的Hibernate对数据库增删改查操作的封装,因为在开发过程中会有着很多不同的项目结构层次,但为了便于学习,一般情况下可以分为entity(实体类层),dao(数据访问对象层),service(业务层,主要可以通过Spring进行事物处理(稍后讲解)),action(执行层),有时候用到的工具包可以放在util包下,这样就可以基本架构整个项目的层次,比如在有些时候可以用到dto(数据传输对象层),都是很常见的,所以开发过程中需要具体问题具体分析,本文不需要那么复杂,仅仅在于搭建框架,可以让初学者迅速掌握搭建框架中的流程以及注意事项就可以了,以后的深入讨论,我会有其他的博文讲解,下面继续进行框架的搭建。
具体的架构呈现会在整合Spring时候完全给出,暂时的架构如图13所示:
图13
此时具体的类的内容如下:
IBaseDao.java
- package com.steven.dao.iface;
- import java.util.List;
- /**
- * 将常用的数据库增删改查进行封装
- *
- * @author Steven
- *
- * @param <T>
- */
- public interface IBaseDao<T> {
- /**
- * 保存对象
- *
- * @param t
- * @return
- */
- public void insert(T t);
- /**
- * 删除对象
- *
- * @param t
- * @return
- */
- public void delete(T t);
- /**
- * 更新对象
- *
- * @param t
- * @return
- */
- public void update(T t);
- /**
- * 根据Id查找单个对象
- *
- * @param id
- * @return
- */
- public T getById(int id);
- /**
- * 查询对象集合
- *
- * @return
- */
- public List<T> getAll();
- }
IUserDao.java
- package com.steven.dao.iface;
- import com.steven.entity.User;
- /**
- * 用来继承接口,如果有个别自己的方法可以在此进行添加
- *
- * @author Steven
- *
- */
- public interface IUserDao extends IBaseDao<User> {
- }
UserDao.java
- package com.steven.dao.impl;
- import java.util.List;
- import org.hibernate.Query;
- import org.hibernate.Session;
- import com.steven.dao.iface.IUserDao;
- import com.steven.entity.User;
- import com.steven.util.HibernateUtil;
- /**
- * 主要对方法进行编写,在这里主要实现了增加和查询所有的方法,其他的没有实现,在整合Spring过程中会进行再次的封装,到时候会编写所有的方法
- *
- * @author Steven
- *
- */
- public class UserDao implements IUserDao {
- public void delete(User t) {
- // TODO Auto-generated method stub
- }
- @SuppressWarnings("unchecked")
- public List<User> getAll() {
- Session sesson = HibernateUtil.getSession();
- // 由于Hibernate4已经没有了HibernateSupport和HibernateTemplate这两个辅助类,可以通过以下实现,
- Query query = sesson.createQuery("from User");
- return (List<User>) query.list();
- }
- public User getById(int id) {
- // TODO Auto-generated method stub
- return null;
- }
- public void insert(User t) {
- Session session = HibernateUtil.getSession();
- session.beginTransaction();
- session.save(t);
- session.getTransaction().commit();
- HibernateUtil.closeSession(session);
- }
- public void update(User t) {
- // TODO Auto-generated method stub
- }
- }
此时可以将UserAction.java更改成如下代码:
UserAction.java
- package com.steven.action;
- import java.util.Date;
- import java.util.List;
- import java.util.Map;
- import org.apache.struts2.interceptor.RequestAware;
- import com.opensymphony.xwork2.ActionSupport;
- import com.steven.dao.impl.UserDao;
- import com.steven.entity.User;
- /**
- * 通过继承ActionSupport获得Struts2的已有功能,
- * 通过实现RequestAware获取request(这种方式常用,还有其他三种方式,这里不再赘述)
- * 四种获取request方式请参照http://blog.csdn.net/ms2146/article/details/5406004
- *
- * @author Steven
- *
- */
- public class UserAction extends ActionSupport implements RequestAware {
- private static final long serialVersionUID = 1L;
- private Map<String, Object> request;
- private UserDao userDao = new UserDao();
- @Override
- public String execute() throws Exception {
- userDao.insert(new User("Lily", 1, new Date(), false));
- userDao.insert(new User("Tom", 1, new Date(), false));
- // 创建一个用户集合
- List<User> userList = userDao.getAll();
- // 创建用户并添加到用户集合中
- // userList.add(new User("Steven", 1, new Date(), true));
- // userList.add(new User("Lily", 1, new Date(), false));
- // userList.add(new User("Tom", 1, new Date(), false));
- // 将用户存储到ActionContext中(可以通过ognl表达式获取)
- request.put("userList", userList);
- return SUCCESS;
- }
- public void setRequest(Map<String, Object> request) {
- this.request = request;
- }
- }
此时在启动Tomcat,在浏览器输入http://localhost:8080/SSH,如图14所示:
图14
运行结果如图15所示:
图15
此时控制台输出信息如下所示:
- …………………………………………
- Hibernate:
- insert
- into
- t_user
- (age, birthday, isVip, userName)
- values
- (?, ?, ?, ?)
- Hibernate:
- insert
- into
- t_user
- (age, birthday, isVip, userName)
- values
- (?, ?, ?, ?)
- Hibernate:
- select
- user0_.userId as userId0_,
- user0_.age as age0_,
- user0_.birthday as birthday0_,
- user0_.isVip as isVip0_,
- user0_.userName as userName0_
- from
- t_user user0_
因此可以看出所有的操作都是通过Hibernate操作数据库的,然后通过Struts将获得的用户集合显示到页面中,所以在这个过程中,Hibernate起到的作用仅仅是对数据库的操作,而且Hibernate可以不要依靠Tomcat运行就可以使用,而Struts2主要负责接收处理数据,进行操作后然后返回到页面中呈现,典型的MVC,而且Struts依靠Tomcat的运行。
如图16所示,可以查看到数据库中的数据:
图16
注:在此,Struts2和Hibernate的简单整合已经实现,下面将进行Spring的整合,而Spring又是SSH中用到的最多而且最重要的框架之一,所以在Spring整合中我将重点讲解器IOC,AOP所代表的含义,具体的会通过例子讲解,当然到时候层次架构会发生改变,而且Dao实现会完成企业级应用的封装,到时候会改变Dao的实现方式,在此一样恭祝大家学习愉快。
转至:http://blog.csdn.net/songdeitao/article/details/17226523