首页 \ 教程 \ hibernate

知识点

  • Hibernate

    • 相关文章

    更多
  • Java核心技术(卷2)：高级特性(原书第8版)
  • Hadoop权威指南学习（六）——MapReduce的特性
  • Java核心技术·卷2:高级特性(原书第9版) （完整中文版）.pdf
  • 从 prototype.js 深入学习 javascript 的面向对象特性
  • Solr的特性
  • hibernate抓取策略
  • Apache Solr 的新特性
  • jQuery Mobile 的特性
  • [Hadoop] Hive 性能+特性
  • JavaScript 语句特性
  • JSF的功能特性
  • JPA高级映射(继承)
  • hibernate查询
  • 关于hibernate的saveorupdate
  • hadoop2.3新特性

    • 最近更新

    更多
  • java线程状态详解(6种)
  • redis从库只读设置-redis集群管理
  • Netty环境配置
  • Netty基于流的传输处理
  • Netty入门实例-使用POJO代替ByteBuf
  • Netty入门实例-时间服务器
  • Netty入门实例-编写服务器端程序
  • Netty开发环境配置
  • 电商平台数据库设计
  • HttpClient 上传文件
  • MongoDB常用命令
  • 快速了解MongoDB【基本概念与体系结构】
  • windows系统安装MongoDB
  • Spring boot整合MyBatis-Plus 之二：增删改查
  • 分布式ID生成器【snowflake雪花算法】

    • 学习hibernate高级特性之前

    2019-03-02 18:43|来源: 领悟书生

    在学习HQL,查询缓存之前，先搭建一个例子，初始化一些数据。这里就以一个专业(Special)有多个班级（Classroom），一个班级（Classroom）有多个学生这样的关系来搭建环境。这里主要是以XML的配置文件，但有的也会标明注解的方式（注释了）。


    专业实体类及映射：

    package org.zttc.itat.model;
 
import java.util.Set;
/**
 * 专业
 */
//@Entity
//@Table(name="t_special")
public class Special {
    private int id;
    private String name;
    private String type;
    private Set<Classroom> clas;
    public Special() {
    }
    public Special(String name, String type) {
        this.name = name;
        this.type = type;
    }
    public Special(int id) {
        this.id = id;
    }
//  @Id
//  @GeneratedValue
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
 
    //name,type的set get 方法省略
 
//  @OneToMany(mappedBy="special")
//  @LazyCollection(LazyCollectionOption.EXTRA)
    public Set<Classroom> getClas() {
        return clas;
    }
    public void setClas(Set<Classroom> clas) {
        this.clas = clas;
    }
}

    Special.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 package="org.zttc.itat.model">
    <class name="Special" table="t_special">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="type"/>
        <set name="clas" inverse="true" lazy="extra">
            <key column="spe_id"/>
            <one-to-many class="Classroom"/>
        </set>
    </class>
</hibernate-mapping>

    班级的实体及映射文件

    Classroom.java

    package org.zttc.itat.model;
 
import java.util.Set;
/**
 * 班级
 */
//@Entity
//@Table(name="t_classroom")
public class Classroom {
    private int id;
    private String name;
    private int grade;//年级
     
    private Set<Student> stus;
    private Special special;
     
    public Classroom() {
    }
    public Classroom(String name, int grade, Special special) {
        this.name = name;
        this.grade = grade;
        this.special = special;
    }
    public Classroom(int id) {
        this.id = id;
    }
     
//  @Id
//  @GeneratedValue
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
     
        //name,grade的set get 方法省去
 
//  @OneToMany(mappedBy="classroom")
//  @LazyCollection(LazyCollectionOption.EXTRA)
    public Set<Student> getStus() {
        return stus;
    }
    public void setStus(Set<Student> stus) {
        this.stus = stus;
    }
//  @ManyToOne(fetch=FetchType.LAZY)
//  @JoinColumn(name="spe_id")
    public Special getSpecial() {
        return special;
    }
    public void setSpecial(Special special) {
        this.special = special;
    }
}

    Classroom.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 package="org.zttc.itat.model">
    <class name="Classroom" table="t_classroom">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="grade"/>
        <many-to-one name="special" column="spe_id"/>
        <set name="stus" inverse="true" lazy="extra">
            <key column="cid"/>
            <one-to-many class="Student"/>
        </set>
    </class>
</hibernate-mapping>

    学生的实体及映射文件

    Student.java

    package org.zttc.itat.model;
/**
 * 学生
 */
//@Entity
//@Table(name="t_stu")
public class Student {
    private int id;
    private String name;
    private String sex;
//  private int version;
    private Classroom classroom;
    public Student() {
    }
    public Student(String name, String sex, Classroom classroom) {
        this.name = name;
        this.sex = sex;
        this.classroom = classroom;
    }
     
//  public int getVersion() {
//      return version;
//  }
//  public void setVersion(int version) {
//      this.version = version;
//  }
     
//  @Id
//  @GeneratedValue
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
//  LAZY就是XML中的select,EAGER就表示XML中的join
//  @ManyToOne(fetch=FetchType.LAZY)
//  @JoinColumn(name="cid")
    public Classroom getClassroom() {
        return classroom;
    }
    public void setClassroom(Classroom classroom) {
        this.classroom = classroom;
    }
     
     
}

    Student.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 package="org.zttc.itat.model">
    <class name="Student" table="t_stu">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="sex"/>
        <many-to-one name="classroom" column="cid"/>
    </class>
</hibernate-mapping>

    添加一些测试数据

    package org.zttc.itat.test;
 
import java.util.Random;
 
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.junit.Test;
import org.zttc.itat.model.Classroom;
import org.zttc.itat.model.Special;
import org.zttc.itat.model.Student;
import org.zttc.itat.util.HibernateUtil;
 
/**
 * 为HQL的数据做准备
 */
public class TestAdd {
 
    Random ran = new Random();
 
    @Test
    public void testAddSpecial() {
        Session session = null;
        session = HibernateUtil.openSession();
        try {
            session.beginTransaction();
 
            session.save(new Special("计算机教育", "教育类"));
            session.save(new Special("计算机应用技术", "高职类"));
            session.save(new Special("计算机网络技术", "高职类"));
            session.save(new Special("计算机信息管理", "高职类"));
            session.save(new Special("数学教育", "教育类"));
            session.save(new Special("物理教育", "教育类"));
            session.save(new Special("化学教育", "教育类"));
            session.save(new Special("会计", "高职类"));
            session.save(new Special("英语教育", "教育类"));
 
            session.getTransaction().commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            if (session != null)
                session.close();
        }
    }
 
    @Test
    public void testAddClassroom() {
        Session session = null;
        session = HibernateUtil.openSession();
        try {
            session.beginTransaction();
 
            session.save(new Classroom("计算机教育1班", 2009, new Special(1)));
            session.save(new Classroom("计算机教育2班", 2009, new Special(1)));
            session.save(new Classroom("计算机教育班", 2010, new Special(1)));
            session.save(new Classroom("计算机教育班", 2011, new Special(1)));
            session.save(new Classroom("计算机应用技术", 2009, new Special(2)));
            session.save(new Classroom("计算机应用技术", 2010, new Special(2)));
            session.save(new Classroom("计算机应用技术", 2011, new Special(2)));
            session.save(new Classroom("计算机网络技术", 2009, new Special(3)));
            session.save(new Classroom("计算机网络技术", 2010, new Special(3)));
            session.save(new Classroom("计算机网络技术", 2011, new Special(3)));
            session.save(new Classroom("计算机信息管理", 2009, new Special(4)));
            session.save(new Classroom("计算机信息管理", 2010, new Special(4)));
            session.save(new Classroom("计算机信息管理", 2011, new Special(4)));
            session.save(new Classroom("数学教育1班", 2009, new Special(5)));
            session.save(new Classroom("数学教育2班", 2009, new Special(5)));
            session.save(new Classroom("数学教育3班", 2009, new Special(5)));
            session.save(new Classroom("数学教育1班", 2010, new Special(5)));
            session.save(new Classroom("数学教育2班", 2010, new Special(5)));
            session.save(new Classroom("数学教育1班", 2011, new Special(5)));
            session.save(new Classroom("数学教育2班", 2011, new Special(5)));
            session.save(new Classroom("物理教育", 2009, new Special(6)));
            session.save(new Classroom("物理教育", 2010, new Special(6)));
            session.save(new Classroom("物理教育", 2011, new Special(6)));
            session.save(new Special("化学教育", "教育类"));
            session.save(new Classroom("化学教育", 2009, new Special(7)));
            session.save(new Classroom("化学教育", 2010, new Special(7)));
            session.save(new Classroom("化学教育", 2011, new Special(7)));
            session.save(new Classroom("会计", 2009, new Special(8)));
            session.save(new Classroom("会计", 2010, new Special(8)));
            session.save(new Classroom("会计", 2011, new Special(8)));
            session.save(new Classroom("英语教育A班", 2009, new Special(9)));
            session.save(new Classroom("英语教育B班", 2009, new Special(9)));
            session.save(new Classroom("英语教育A班", 2010, new Special(9)));
            session.save(new Classroom("英语教育B班", 2010, new Special(9)));
            session.save(new Classroom("英语教育A班", 2011, new Special(9)));
            session.save(new Classroom("英语教育B班", 2011, new Special(9)));
            session.save(new Classroom("选修课班A", 2011, null));
            session.save(new Classroom("选修课班B", 2011, null));
            session.getTransaction().commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            if (session != null)
                session.close();
        }
    }
 
    @Test
    public void testRan() {
        for (int i = 0; i < 20; i++) {
            System.out.println(ran.nextInt(2));
        }
    }
 
    @Test
    public void testAddStu() {
        Session session = null;
        session = HibernateUtil.openSession();
        try {
            session.beginTransaction();
            String[] sexs = new String[] { "男", "女" };
            // 仅仅添加32个班 的学生，方便做外连接的实验
            for (int i = 1; i <= 32; i++) {
                // 每个班40个学生
                for (int j = 1; j <= 40; j++) {
                    session.save(new Student(getName(), sexs[ran.nextInt(2)],
                            new Classroom(i)));
                }
            }
            session.getTransaction().commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            if (session != null)
                session.close();
        }
    }
 
    @Test
    public void testAddStuNull() {
        // 添加100个没有班级的学生方便做right连接查询
        Session session = null;
        session = HibernateUtil.openSession();
        try {
            session.beginTransaction();
            String[] sexs = new String[] { "男", "女" };
            for (int j = 1; j <= 100; j++) {
                session.save(new Student(getName(), 
                        sexs[ran.nextInt(2)], null));
            }
            session.getTransaction().commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            if (session != null)
                session.close();
        }
    }
 
    private String getName() {
        String[] name1 = new String[] {"孔","张","叶","李","叶入","孔令","张立",
                "陈","刘","牛","夏侯","令","令狐","赵","母","穆","倪","张毅","称",
                "程","王","王志","刘金","冬","吴","马","沈"};
 
        String[] name2 = new String[] { "凡","课","颖","页","源","都","浩","皓",
                "西","东","北","南","冲","昊","力","量","妮","敏","捷","杰",
                "坚","名","生","华","鸣","蓝","春","虎","刚","诚"};
 
        String[] name3 = new String[] {"吞","明","敦","刀","备","伟","唯","楚",
                "勇","诠","佺","河","正","震","点","贝","侠","伟","大","凡",
                "琴","青","林","星","集","财"};
 
        boolean two = ran.nextInt(50) >= 45 ? false : true;
        if (two) {
            String n1 = name1[ran.nextInt(name1.length)];
            String n2;
            int n = ran.nextInt(10);
            if (n > 5) {
                n2 = name2[ran.nextInt(name2.length)];
            } else {
                n2 = name3[ran.nextInt(name3.length)];
            }
            return n1 + n2;
        } else {
            String n1 = name1[ran.nextInt(name1.length)];
            String n2 = name2[ran.nextInt(name2.length)];
            String n3 = name3[ran.nextInt(name3.length)];
            return n1 + n2 + n3;
        }
    }
}


    本文链接：学习hibernate高级特性之前，领悟书生学习笔记，转载请注明出处http://www.656463.com/article/416

    相关问答

    更多

    • 请问电脑系统操作员三级算什么级别的？[2022-02-23]

      高级

    • 学习Structs,spring,hibernate的先后顺序,怎么学[2023-09-15]

      建议着重基础,多实践,不要眼高手底,努力

    • Struts Spring Hibernate的学习顺序??[2022-01-17]

      struts和hibernate谁先谁后没什么关系，因为互相没有什么关系，但是spring的学习上建议放在前2者的后面学习，这样更加便于你对spring的理解，在学习这三者之前，建议先把设计模式弄明白，不要求精通，这样更有利于你对这几样技术的认识！知道他们为什么要这么用，有什么门道在里面。 至于学习难度上，个人感觉Hibernate是比较难的技术，struts相对易学，spring难度在2者之间。 推荐学习顺序：struts-》hibernate-》spring

    • 学习Spring, Struts, Hibernate有什么好书？[2022-07-05]

      《轻量级Java EE企业应用实战——Struts 2＋Spring 3＋Hibernate整合开发》，李刚著。 这是一本很全面、很实用的ssh图书，对ssh的各个 知识点介绍得十分到位，后面还有整合这几个框架的大型案例。完全能满足你的需求。 到书店找 这本书来看看吧，可以再和其他同类书比较一下，就知道我推荐的没错。这本书现在都出第3版了。

    • 求Redis数据库高级实用特性：事务控制？？[2022-01-10]

      Redis对事务的支持目前还比较简单。redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。 由于redis是单线程来处理所有client的请求的所以做到这点是很容易的。一般情况下redis在接受到一个client发来的命令后会立即处理并 返回处理结果，但是当一个client在一个连接中发出multi命令有，这个连接会进入一个事务上下文，该连接后续的命令并不是立即执行，而是先放到一个队列中。当从此连接受到exec命令后，redis会顺序的执行队列中的所有命 ...

    • python高级特性知多少[2022-01-11]

      python语言的一些高阶用法主要有以下几个特性： 1 generators生成器用法 2 collections包常见用法 3 itertools包常见用法 4 packing/unpacking封包/解包特性 5 Decorators装饰器 6 Context Managers上下文管理期 以上几个特性我会针对应用场景，使用注意事项，应用举例几个维度分别进行讲解，如果有同学对某个特性特别熟悉则可以直接跳过。 generators生成器用法 generator一般用来产生序列类型的值得对象，一般都可以在f ...

    • 磷化液的安全特性[2023-07-10]

      磷化液分析 中温磷化剂膜结晶细致色泽均匀黑色,减少仪器内表漫反射,该磷化结晶膜具有优良的防锈性能，主要用于精密钢铸件的防护与装饰及活塞环磷化 一、 产品特点 1、磷化膜层结晶致密、均匀、无挂灰、无残液加速腐蚀。 2、产品使用周期长，工作液易调整，只许添加即可，残渣少。 3、防锈期可达1年以上。 4、成倍提高涂层附着力及耐腐蚀能力 二、 磷化液技术指标 分析项目 质量指标 磷化液外观 绿色液体 磷化液密度 1.35-1.4 工作液浓度 1:10-30 总酸度 20-40 游离酸度 1.0-3.0 磷化温度 8 ...

    • 如何学习更高级的教程[2022-06-28]

      热温冷技术区 加精可看

    • 什么时候适合学习Spring、Struts、Hibernate框架[2022-03-04]

      学习下java314即java中的servlet和jsp知识，之后学习struts框架，可以整合一点hibernate，spring的东西挺复杂的，那里的依赖注入很强大

    • 学习hibernate要学习哪些才能算比较透彻[2022-03-02]

      就是HIBERNATE ，ORM ，主要就是ORM的概念，其他的HQL熟练一些就可以了 。当然要运用的好还要了解缓存

    Copyright ©2023 peixunduo.com All Rights Reserved.粤ICP备14003112号

    本站部分内容来源于互联网，仅供学习和参考使用，请莫用于商业用途。如有侵犯你的版权，请联系我们(neng862121861#163.com)，本站将尽快处理。谢谢合作！