Junit4方法详解

setUpBeforeClass()类初始化前调用

tearDownAfterClass()类初始化后调用

setUp()在测试方法前调用

tearDown()在测试方法后调用

@Test测试方法

在<many-to-one>这端，cascade默认是“none”，假如我们希望在持久化多的一端的时候，自动级联保存和更新一的一端，我们可以把cascade设置为“save-update”

重点内容：1 一对多映射实现（双向） 2 inverse属性 3 级联删除 4 一对多双向自身关联关系映射

model包：

Class.java:

package model;

import java.util.HashSet;
import java.util.Set;

public class Class {
    private long id;
    private String name;
    private Set<Student>students=new HashSet<Student>();
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }
    @Override
    public String toString() {
        return "Class [id=" + id + ", name=" + name + "]";
    }
    
    
}

Class.hbm.xml:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="model">

<class name="Class" table="t_class">
        <id name="id" column="classId">
            <generator class="native"></generator>
        </id>
        <property name="name" column="className"></property>
        <set name="students" cascade="delete" inverse="true">
            <key column="classId"></key>
            <one-to-many class="model.Student"/>
        </set>
    </class>

</hibernate-mapping>

Node.java:

package model;

import java.util.HashSet;
import java.util.Set;

public class Node {
    private long id;
    private String name;
    
    private Node parentNode;
    private Set<Node> childNodes=new HashSet<Node>();
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Node getParentNode() {
        return parentNode;
    }
    public void setParentNode(Node parentNode) {
        this.parentNode = parentNode;
    }
    public Set<Node> getChildNodes() {
        return childNodes;
    }
    public void setChildNodes(Set<Node> childNodes) {
        this.childNodes = childNodes;
    }
    
    
    
}

Node.hbm.xml:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="model">

<class name="Node" table="t_node">
        <id name="id" column="nodeId">
            <generator class="native"></generator>
        </id>
        <property name="name" column="nodeName"></property>
        
        <many-to-one name="parentNode" column="parentId" class="model.Node" cascade="save-update"></many-to-one>
        
        <set name="childNodes" inverse="true">
            <key column="parentId"></key>
            <one-to-many class="model.Node"/>
        </set>
    </class>

</hibernate-mapping>

Student.java:

package model;

public class Student {
    private long id;
    private String name;
    private Class c;
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Class getC() {
        return c;
    }
    public void setC(Class c) {
        this.c = c;
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", c=" + c + "]";
    }
    
    
    
}

Student.hbm.xml:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="model">

<class name="Student" table="t_student">
        <id name="id" column="stuId">
            <generator class="native"></generator>
        </id>
        <property name="name" column="stuName"></property>
        
        <many-to-one name="c" column="classId" class="model.Class" cascade="save-update"></many-to-one>
    </class>

</hibernate-mapping>

service包：

NodeTest.java:

package service;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import util.HibernateUtil;
import model.Node;
public class NodeTest {

SessionFactory sessionfactory=HibernateUtil.getSessionFactory();//获取Session工厂
    private Session session;
    
    @Before
    public void setUp() throws Exception {
        session=sessionfactory.openSession();//生成一个新的session
        session.beginTransaction();//开启事务
    }

@After
    public void tearDown() throws Exception {
        session.getTransaction().commit();//提交事务
        session.close();//关闭session
    }

@Test
    public void testSaveMenu() {
        Node node=new Node();
        node.setName("根节点");
        
        Node subNode1=new Node();
        subNode1.setName("子节点1");
        
        Node subNode2=new Node();
        subNode2.setName("子节点2");
        
        subNode1.setParentNode(node);
        subNode2.setParentNode(node);
        
        session.save(node);
        session.save(subNode1);
        session.save(subNode2);
    }
}

StudentTest.java:

package service;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import util.HibernateUtil;
import model.Class;
import model.Student;
public class StudentTest {

SessionFactory sessionfactory=HibernateUtil.getSessionFactory();//获取Session工厂
    private Session session;
    
    @Before
    public void setUp() throws Exception {
        session=sessionfactory.openSession();//生成一个新的session
        session.beginTransaction();//开启事务
    }

@After
    public void tearDown() throws Exception {
        session.getTransaction().commit();//提交事务
        session.close();//关闭session
    }

@Test
    public void testSaveClassAndStudent() {
        Class c=new Class();
        c.setName("12网络");
        
        Student s1=new Student();
        s1.setName("一号");
        
        Student s2=new Student();
        s2.setName("二号");
        
        c.getStudents().add(s1);
        c.getStudents().add(s2);
        
        s1.setC(c);
        s2.setC(c);
        session.save(s1);
        session.save(s2);
        session.save(c);
    }

@Test
    public void getStudentByClass(){
        Class c=(Class) session.get(Class.class,Long.valueOf(1));
        Set<Student> students=c.getStudents();
        Iterator it=students.iterator();
        while(it.hasNext()){
            Student s=(Student) it.next();
            System.out.println(s);
        }
    }
    
    @Test
    public void testAdd(){
        Class c=new Class();
        c.setName("12物联网");
        
        Student s=new Student();
        s.setName("三号");
        
        session.save(c);
        session.save(s);
    }
    
    @Test
    public void testInverse(){
        Class c=(Class) session.get(Class.class,Long.valueOf(1));
        Student s=(Student) session.get(Student.class,Long.valueOf(1));
        
        s.setC(c);
        c.getStudents().add(s);
    }
    
    @Test
    public void testDeleteClassCascade(){
        Class c=(Class) session.get(Class.class,Long.valueOf(1));
        session.delete(c);
    }
}

util包：

HibernateUtil.java:

package util;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class HibernateUtil {
    private static final SessionFactory sessionFactory=buildSessionFactory();

private static SessionFactory buildSessionFactory() {
        Configuration configuration=new Configuration().configure();//实例化配置文件
        ServiceRegistry serviceRegistry=new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();//实例化服务登记类
        return configuration.buildSessionFactory(serviceRegistry);//获取Session工厂
    }
    
    public static SessionFactory getSessionFactory(){
        return sessionFactory;
    }
}

配置文件：

hibernate.cfg.xml:

<?xml version='1.0' encoding='utf-8'?>
<!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>

<!--数据库连接设置 -->
    <property name="connection.driver_class">
        com.mysql.jdbc.Driver
    </property>
    <property name="connection.url">
        jdbc:mysql://localhost:3306/hibernate
    </property>
    <property name="connection.username">root</property>
    <property name="connection.password">123456</property>

<!-- 方言 -->
    <property name="dialect">
        org.hibernate.dialect.MySQL5Dialect
    </property>

<!-- 控制台显示SQL -->
    <property name="show_sql">true</property>

<!-- 自动更新表结构 -->
    <property name="hbm2ddl.auto">update</property>
    <mapping resource="model/Class.hbm.xml" />
    <mapping resource="model/Node.hbm.xml" />
    <mapping resource="model/Student.hbm.xml" />
</session-factory>

</hibernate-configuration>

回顾：

虽然现在hibernate已经到了4.3的版本，但是他的兼容性还需要极大地完善，这也许就是开源框架最大的问题的地方，不过在我眼中，开源就是造福人类的一个贡献。

在使用hibernate要着重注意拼写的问题，双引号内不报错，所以一个字母的错误可能会耽误几个小时的时间。

hibernate一对多映射实现的更多相关文章

  1. hibernate 一对多映射关系

    1.   单项多对一映射       custom(顾客)与order(订单) :一个顾客可以有多个订单,一个订单只能有一个顾客       配置方法:在多的一端配置<many -to one& ...

  2. hibernate 一对多映射

    package com.entity.onetomany; import java.util.ArrayList; import java.util.List; import javax.persis ...

  3. hibernate一对多映射文件的配置

    其中一个Customer对应多个LinkMan Customer的映射文件 Customer.hbm.xml-------------->一对多 <?xml version="1 ...

  4. Hibernate一对多映射列表实例（使用xml文件）

    如果持久化类具有包含实体引用的列表(List)对象,则需要使用一对多关联来映射列表元素. 在这里,我们使用论坛应用场景,在论坛中一个问题有多个答案. 在这种情况下,一个问题可以有多个答案,每个答案可能 ...

  5. 【hibernate】<第二节>hibernate的一对多映射（基本类型）

    所需工具与前文一致! 第一部分内容:基本类型的一对多(one to many) 以部门表与员工表为例: 目录结构: hibernate.cfg.xml内容 <?xml version=" ...

  6. 【SSH系列】Hibernate映射 -- 一对多关联映射

        映射原理       一对多关联映射和多对一关联映射的映射原理是一样一样的,所以说嘛,知识都是相通的,一通百通,为什么说一对多关联映射和多对一关联映射是一样的呢?因为她们都是在多的一端加入一个 ...

  7. java使用Myeclipse创建Hibernate项目碰到的诸多问题总结

    这两天一直在搞Myeclipse创建Hibernate的1对多映射. 由于缺乏经验,可算是把我坑惨了.控制台是不停地报错啊~~~~我差点就崩溃了. 1.看的是慕课网的Hibernate一对多映射教程, ...

  8. 解决You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'order (order_name, customer)

    在学习hibernate一对多映射关系时,根据视频学习的时候,例子是顾客和订单的问题,一个顾客有多个订单.按照视频中的敲代码出现了You have an error in your SQL synta ...

  9. hibernate进阶--一对多映射配置

    hibernate作为一款优秀的ORM框架,广受大家喜爱,也被Java社区公认为持久层的首选.虽然jdbc为Java数据库操 作带来了诸多便利,但是并没有统一SQL语句的写法,而且具体操作数据库的代码 ...

随机推荐

  1. [Architect] Abp 框架原理解析(1) Module

    本节目录 Abp介绍 Abp源码分析 代码实现 Abp介绍 学习了一段时间的Abp,领略了一下前辈的架构.总结还是SOLID,降低耦合性. 虽然从架构上说甚至不依赖于DI框架,但实际上在基础框架中还是 ...

  2. 创建Google网站地图Sitemap.xml

    Sitemap.xml是google搞出来的,也就是网站地图,不过这个网站地图是用xml写的,而且要按google的标准来写,并且要将写出来的这个文件sitemap.xml上传到自己的服务器空间中去. ...

  3. Aspose.Word 操作word复杂表格 拆分单元格 复制行 插入行 文字颜色

    private void button3_Click(object sender, EventArgs e)         {             object savePathWord =&q ...

  4. c#重点[数据类型，构造方法,变量，变量,运算符，装箱，拆箱]

    1.命名规范    类  :名词 每个单词的首字母大写 Dog Student  PersonClass 字段:首个字母小写,如果有多个单词,后面的单词首字母大写 string name=" ...

  5. EF工作中踩过的坑.

    1.EF同一个linq里边不支持两个或两个以上不同dbcontext的使用,必须拆解开才能使用; ef也不支持自定义集合和dbcontext属性的混合使用. 2.如果要用用统一域账号连接databas ...

  6. sql 大数据库 插入超时问题解决

    解决的办法:1. 不要使用自动收缩, 自动收缩会定期收容数据文件的空闲空间,则处理需要的时候却要扩大数据文件,这两者相反的处理,是冲突的设置方法:ALTER DATABASE MyDataBase S ...

  7. 关于spring配置文件properties的问题

    我遇到的问题是我将properties放在src下面的包中不能被spring扫描到,会报配置文件找不到的错误.但是如果放在src目录下就能够被spring扫描到,现在还不知道为什么这样,记个笔记,留到 ...

  8. java初始化构造函数调用顺序

    类初始化时构造函数调用顺序: (1)初始化对象的存储空间为零或null值:  (2)调用父类构造函数:  (3)按顺序分别调用类成员变量和实例成员变量的初始化表达式:  (4)调用本身构造函数. 例子 ...

  9. 浅谈一下缓存策略以及memcached 、redis区别

    缓存策略三要素:缓存命中率   缓存更新策略  最大缓存容量.衡量一个缓存方案的好坏标准是:缓存命中率.缓存命中率越高,缓存方法设计的越好. 三者之间的关系为:当缓存到达最大的缓存容量时,会触发缓存更 ...

  10. 七年IT生涯的经验教训

     七年IT生涯的经验教训[转]我在IT界也拼打了有好几年了,但是现在和别人比较起来不是很如意．从天分上来说,我在属于智商不低的人:从技术上说,几乎没有我拿不下的:从见解上看,我是很有点子看法的人． ...