5Hibernate配置及使用方法----青软S2SH(笔记)

关于hibernate的简单配置,先看结构图,我们需要

1.还要弄一下需要的 jar包.

2.配置两个文件(hibernate配置文件和映射文件),不过映射文件可以用注解替代.

3.写一个pojo类,写一个示例demo

1.关于jar包,下载网站http://hibernate.org/orm/downloads/

下载的完整版的压缩包,解压后,lib里有一个required,这个基本就是需要的jar包,如果有别的需求再另加.

另外,这里边没有连接数据库的包(比如连接mysql的mysql-connector-java-5.1.36-bin.jar),需要自己下载.

如下图,我用的是目前的最新版,5.2.3

2.建立项目,建立配置文件

hibernate.cfg.xml,放在src下面,

<!-- 注册所有ORM映射文件 -->这一步看情况而定,但是建议用注解的方式如果你是用xml配置映射的POJO,那么就用这种形式<mapping resource="com/qst/chapter05/pojos/Student.hbm.xml" />
如果你是用注解配置映射的POJO,那么就用这种形式<mapping class="com.qst.chapter05.pojos.TestAno" /> 

如果你是用的5.2.6版本,那么也可以不用配置映射,直接在代码里指定就可以.
<!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>
        <!-- 配置访问Oracle数据库参数信息 -->
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <property name="connection.url">
        jdbc:mysql://127.0.0.1:3306/hibTest
            <!-- jdbc:oracle:thin:@localhost:1521:orcl -->
        </property>
        <property name="connection.username">root</property>
        <property name="connection.password">password</property>
        <!-- 在控制台显示SQL语句 -->
        <property name="show_sql">true</property>
        <!--根据需要自动生成、更新数据表 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 注册所有ORM映射文件 -->
        <mapping resource="com/qst/chapter05/pojos/Student.hbm.xml" />
        <mapping resource="com/qst/chapter05/pojos/User.hbm.xml" />
        <mapping class="com.qst.chapter05.pojos.TestAno" /> 

    </session-factory>
</hibernate-configuration>

3.demo

例子有好多个,主要如第二步的配置文件的形式分成三类,

第一类:用xml配置ORM映射,这个映射文件一般放到相应的POJO所在的包下面

在hibernate.cfg.xml里配置如下

 <mapping resource="com/qst/chapter05/pojos/User.hbm.xml" />
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.qst.chapter05.pojos.User" table="tbUsers">
        <!-- 主键 -->
        <id name="id" column="ID">
            <generator class="native" />
        </id>
        <!-- 用户名 -->
        <property name="userName" column="USERNAME" type="string"
            not-null="true" />
        <!-- 密码 -->
        <property name="userPwd" column="USERPWD" type="string"
            not-null="true" />
        <!-- 权限 -->
        <property name="role" column="ROLE" type="java.lang.Integer" not-null="true" />

    </class>
</hibernate-mapping>

此时pojo就是平常的类,没啥改动,额,得序列化

package com.qst.chapter05.pojos;

import java.io.Serializable;

public class User implements Serializable {
    /* 用户ID */
    private Integer id;
    /* 用户名 */
    private String userName;
    /* 密码 */
    private String userPwd;
    /* 权限 */
    private Integer role;
    /* 默认构造方法 */
    public User() {
    }
    /* 根据属性创建 构造方法 */
    public User(String userName, String userPwd,Integer role) {
        this.userName = userName;
        this.userPwd=userPwd;
        this.role=role;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPwd() {
        return userPwd;
    }
    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
    public Integer getRole() {
        return role;
    }
    public void setRole(Integer role) {
        this.role = role;
    }

}

第二类:用注解配置ORM映射,这种形式只需要hibernate.cfg.xml一个配置文件就好.

在hibernate.cfg.xml里配置如下

<mapping class="com.qst.chapter05.pojos.TestAno" />

不需要xxx.hbm.xml

package com.qst.chapter05.pojos;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="test_Ano")
public class TestAno implements Serializable {
    /**
     *
     */
    private static final long serialVersionUID = -2018875535473489473L;
    /* 用户ID */
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name = "id", insertable = false, updatable = false)
    private Integer id;

    /* 用户名 */
    @Column(name = "user_name")
    private String userName;
    /* 密码 */
    @Column(name = "user_pwd")
    private String userPwd;
    /* 权限 */
    @Column(name = "role")
    private Integer role;
    /* 默认构造方法 */
    public TestAno() {
    }
    /* 根据属性创建 构造方法 */
    public TestAno(String userName, String userPwd,Integer role) {
        this.userName = userName;
        this.userPwd=userPwd;
        this.role=role;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPwd() {
        return userPwd;
    }
    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
    public Integer getRole() {
        return role;
    }
    public void setRole(Integer role) {
        this.role = role;
    }

}

好了,配置就上面这些,下面看如何使用hibernate来往数据库倒数据,额,就是如何获取SessionFactory

而如何配置,无论是用注解还是xml,对调用时没影响,所以,注解跟xml是可以混用的(一般不建议这麽做,当然,一般也没机会这么做,毕竟这些一般都有要用到spring整合的,单独用hibernate的机会比较少).

下面看是一个传统的获取SessionFactory的方式,这个方式适应于4.3版本,如果用到是版本5以上,那么这方法会出现找不到映射对象的错误,

public static void main(String[] args) {
        // 创建User对象
        User user = new User("zhangsan", "123", 1);
        // 实例化Configuration
        Configuration configuration = new Configuration();
        // 加载hibernate.cfg.xml文件
        configuration.configure("/hibernate.cfg.xml");
        // 创建SessionFactory
        // Hibernate4.3创建SessionFactory的方式
        StandardServiceRegistryBuilder standardServiceRegistryBuilder = new StandardServiceRegistryBuilder();
        standardServiceRegistryBuilder.applySettings(configuration
                .getProperties());
        SessionFactory sessionFactory = configuration
                .buildSessionFactory(standardServiceRegistryBuilder.build());
        // 打开Session
        Session session = sessionFactory.openSession();
        // 开始一个事务
        Transaction trans = session.beginTransaction();
        // 持久化操作
        session.save(user);
        // 提交事务
        trans.commit();
        // 关闭Session
        session.close();
    }

hibernate5版本以上,用以下方式,就一行代码,不过这个方法被hibernate5.2.6里弃用了,当然,用也不会报错.

SessionFactory sessionFactory = new Configuration().configure("/hibernate.cfg.xml").buildSessionFactory();

当然,如果也可以不指定配置/hibernate.cfg.xml,代码如下

SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

而hibernate会默认去寻找/hibernate.cfg.xml

public static void main(String[] args) {
        // 创建User对象
        TestAno testAno = new TestAno("555553", "123", 1);
        // 实例化Configuration
//        Configuration configuration = new Configuration();
        // 加载hibernate.cfg.xml文件
//        configuration.configure("/hibernate.cfg.xml");
        // 创建SessionFactory
        // Hibernate4.3创建SessionFactory的方式
//        StandardServiceRegistryBuilder standardServiceRegistryBuilder = new StandardServiceRegistryBuilder();
//        standardServiceRegistryBuilder.applySettings(configuration
//                .getProperties());
//        SessionFactory sessionFactory = configuration
//                .buildSessionFactory(standardServiceRegistryBuilder.build());
        @SuppressWarnings("deprecation")
        SessionFactory sessionFactory = new Configuration().configure("/hibernate.cfg.xml").buildSessionFactory();
        // 打开Session
        Session session = sessionFactory.openSession();
        // 开始一个事务
        Transaction trans = session.beginTransaction();
        // 持久化操作
        session.save(testAno);
        // 提交事务
        trans.commit();
        // 关闭Session
        session.close();
    }

在5.2.6里,用以下方式,这种方式不需要在hibernate.cfg.xml中配置ORM映射,可以直接在代码里指定

.addAnnotatedClass( HiberNew.class )因为用这个方法,类名可以直接从方法里用反射获取,写代码时就会灵活很多.
    public static void main(String[] args) {
        // 创建User对象
        HiberNew hiberNew = new HiberNew("hiber5.2.6", "1", 1);
        // 实例化Configuration
//        Configuration configuration = new Configuration();
        // 加载hibernate.cfg.xml文件
//        configuration.configure("/hibernate.cfg.xml");
        // 创建SessionFactory
        // Hibernate4.3创建SessionFactory的方式
//        StandardServiceRegistryBuilder standardServiceRegistryBuilder = new StandardServiceRegistryBuilder();
//        standardServiceRegistryBuilder.applySettings(configuration
//                .getProperties());
//        SessionFactory sessionFactory = configuration
//                .buildSessionFactory(standardServiceRegistryBuilder.build());
        StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder()
        .configure( "hibernate.cfg.xml" )
        .build();

    Metadata metadata = new MetadataSources( standardRegistry )
        .addAnnotatedClass( HiberNew.class )
        .getMetadataBuilder()
        .applyImplicitNamingStrategy( ImplicitNamingStrategyJpaCompliantImpl.INSTANCE )
        .build();

    SessionFactory sessionFactory = metadata.getSessionFactoryBuilder().build();
        // 打开Session
        Session session = sessionFactory.openSession();
        // 开始一个事务
        Transaction trans = session.beginTransaction();
        // 持久化操作
        session.save(hiberNew);
        // 提交事务
        trans.commit();
        // 关闭Session
        session.close();
    }

总结一下:

由于方法较多,上面例子已经写得很清楚,这里就不再重复了.

当我们已经获取了session之后,就可以进行数据库操作了,session的使用方式如下:

1.使用事务,直接用session进行持久化操作

// 打开Session
        Session session = sessionFactory.openSession();
        // 开始一个事务
        Transaction trans = session.beginTransaction();
        // 持久化操作
        session.save(user);
        // 提交事务
        trans.commit();
        // 关闭Session
        session.close();

2.使用Query接口

Query query = session.createQuery("from User");
// 打开Session
        Session session = sessionFactory.openSession();
        // 开始一个事务
        Transaction trans = session.beginTransaction();
        // 查询Customer表
        Query query = session.createQuery("from User");
        // 执行查询
        List<User> list = query.list();
        // 遍历输出
        for (User u : list) {
            System.out.println(u.getId() + "\t" + u.getUserName() + "\t"
                    + u.getUserPwd() + "\t" + u.getRole());
        }
        // 提交事务
        trans.commit();
        // 关闭Session
        session.close();

3.使用Criteria接口

// 打开Session
        Session session = sessionFactory.openSession();
        // 开始一个事务
        Transaction trans = session.beginTransaction();
        // 创建一个Criteria查询对象，查询Student类的所有对象
        Criteria criteria = session.createCriteria(Student.class);
        // 执行查询
        List<Student> list = criteria.list();
        // 遍历输出
        for (Student stu : list) {
            System.out.println(stu.getId() + "\t" + stu.getName() + "\t"+stu.getScore());
        }
        // 提交事务
        trans.commit();
        // 关闭Session
        session.close();

因为不能每次都这么调用session,所以写一个工具类来产生session,这个例子用的是单例模式,但是没实现线程安全

package com.qst.chapter06.util;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {
    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
    private static final ThreadLocal<Session> threadLocal
                                    = new ThreadLocal<Session>();
    private static Configuration configuration = new Configuration();
    private static StandardServiceRegistryBuilder standardServiceRegistryBuilder = new StandardServiceRegistryBuilder();
    private static SessionFactory sessionFactory;
    private static String configFile = CONFIG_FILE_LOCATION;
    /* 静态代码块创建SessionFactory */
    static {
        try {
            configuration.configure(configFile);
            //Hibernate4.3创建SessionFactory的方式
            standardServiceRegistryBuilder.applySettings(configuration.getProperties());
            sessionFactory = configuration.buildSessionFactory(standardServiceRegistryBuilder.build());
        } catch (Exception e) {
            System.err.println("%%%% Error Creating SessionFactory %%%%");
            e.printStackTrace();
        }
    }
    private HibernateUtils() {
    }
    /**
     * 返回ThreadLocal中的session实例
     */
    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;
    }
    /**
     * 返回Hibernate的SessionFactory
     */
    public static void rebuildSessionFactory() {
        try {
            configuration.configure(configFile);
            sessionFactory = configuration.buildSessionFactory(standardServiceRegistryBuilder.build());
        } catch (Exception e) {
            System.err.println("%%%% Error Creating SessionFactory %%%%");
            e.printStackTrace();
        }
    }
    /**
     * 关闭Session实例并且把ThreadLocal中副本清除
     */
    public static void closeSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
        threadLocal.set(null);
        if (session != null) {
            session.close();
        }
    }
    /**
     * 返回SessionFactory
     */
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    public static void setConfigFile(String configFile) {
        HibernateUtils.configFile = configFile;
        sessionFactory = null;
    }
    public static Configuration getConfiguration() {
        return configuration;
    }
}
时间： 2024-08-25 15:32:41

5Hibernate配置及使用方法----青软S2SH(笔记)的相关文章

5Hibernate入门----青软S2SH(笔记)

这里有个问题,就是这本书第五章的示例代码中的hibernate的jar包有问题,各种找不到类,把lib下的包后换成第六章里的包就好了. 换成5.1的就好了,而且如果只是简单使用hibernate的话,那么,jar包用完整版的required目录里那几个就好,如下图 由于这个教程是以hibernate4.3为基础的,比较老,所以有些地方不太对,另外整理了一篇5Hibernate配置及使用方法----青软S2SH(笔记)

2Struts2配置----青软S2SH(笔记)

实例的文件目录如下:两个配置文件(web.xml和struts.xml),一个UserAction.java,三个jsp. 1.配置Struts2应用环境: 下载Struts2的jar包,官网是:http://struts.apache.org/download.cgi 下载完整版,里边的lib文件夹里有struts2的核心类库和依赖的第三方类库. 新建立一个web项目,把这些类库导入到项目的lib文件夹中. 一般来说,只要导入基本的几个jar包就好了,其他的需要了再导入,基础jar包如下几个:

6Hibernate进阶----青软S2SH(笔记)

关于关联关系的配置,用注解配置如下(这里引用的jar包是javax.persistence) // @ManyToOne(fetch=FetchType.LAZY) @ManyToOne(fetch=FetchType.EAGER) @JoinColumn(name="supplier_id",nullable=true) private Supplier supplier; 用xml文件配置如下,这个跟注解配置有些不同,就不详解了,反正我也不会用xml配置 例子 /* 使用HQL对查

GIFT-EMS礼记----青软S2SH(笔记)

这个S2SH的项目,是这本书的一个贯穿项目,所以这里要记录一下, 看这个项目有两个目的: 1.借助这个项目,学习一下S2SH的综合配置及使用 2.借助这个项目练习一下如何做需求分析和项目架构设计. POJO设计,实际就是数据库设计,在确定了使用的框架之后,,数据库设计是最重要的设计.  这个项目的目录层次设计的并不很好,按说,用户使用的部分,和后台管理部分,这是要分开的

7Hibernate高级----青软S2SH(笔记)

2Struts2基础----青软S2SH(笔记)

4Struts2标签库----青软S2SH(笔记)

这里弄错了,这一堆属性是<datetimepicker>标签的,不是<doubleselect>标签的 输出错误信息这个不错,挺方便的. 这个树形标签,也用了好多网络,分析如下 <tree>在浏览器生成的代码如下 <tree>标签在浏览器生成的代码 这个树形菜单自己写js也是可以实现的,虽然麻烦点,如下面这个例子, http://www.2cto.com/kf/201210/159436.html 总体来说,对于上面这些表单标签中的特殊功能标签,比如<

“青软杯”安徽科技学院第六届程序设计大赛_专业组

Contest - "青软杯"安徽科技学院第六届程序设计大赛_专业组 Start time:  2015-04-18 08:00:00.0  End time:  2015-04-18 12:00:00.0 Current System Time:  2015-04-21 00:07:42.57  Contest Status:   Ended 关于举办"青软杯"安徽科技学院 第六届程序设计大赛通知 ACM 国际大学生程序设计竞赛 (International Co

Spring配置bean的方法(工厂方法和Factorybean)

通过工厂方法配置bean 通过调用静态工厂方法创建bean 通过静态工厂方法创建bean是将对象创建的过程封装到静态方法中.当客户端需要对象时,只需要简单地调用静态方法,而不关心创建对象的细节. 要声明通过静态方法创建的bean,需要在bean的class属性里指定拥有该工厂的方法的类,通知在factory-method属性里指定工厂方法的名称, 最后,使用<constructor-arg>元素为该方法传递方法参数 通过调用实例工厂方法创建bean 实例工厂方法:将对象的创建过程封装到另外一个