Hibernate使用笔记整理

A. Hibernate执行环境配置

1. 用到的包

antlr-2.7.6.jar
解释hibernate的查询语言，叫hibernate query Language，叫hql语句的
    commons-collections-3.1.jar 是一些集合，一些公共的集合，apache 的 公共包，
主要是支持hibernate缓存的，hibernate有各种缓存，一级缓存，二级缓存，查询缓存
    dom4j-1.6.1.jar 解析xml文件的
    hibernate3.jar  核心包
    javassist-3.11.0.GA.jar 生成一些动态代理的包
    jta-1.1.jar java事物管理，事物分布式管理
    log4j-1.2.17.jar    
    slf4j-api-1.5.8.jar jpos的日志接口，jpos是自己的产品，一般用的并不多，用的几乎都是log4j，为什么hibernate用它？可能是gemkey被jpos收编了之后，换本家了总得用点自己的东西，3.5以下需要
    slf4j-log4j12-1.5.8.jar slf4j-api的实现类，没有实现完的

1. 类路径下的log4j.properties

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=warn, stdout

1. 类路径下的hibernate.cfg.xml

    
    
        
        com.mysql.jdbc.Driver
        
        
        jdbc:mysql://127.0.0.1:3306/hibernate?createDatabaseIfNotExist=true
        root
        123

        
        org.hibernate.dialect.MySQL5Dialect
        
        
        true
    
        
        
        update
    
    

B. 创建实体类及映射文件

1. User.java

    private Integer id;
    private String username;
    private char sex;
    private Date birthday;
    private Integer age;
    private double salary;// 薪资
//各种set、get方法

1. User.hbm.xml
   放在User.java同一个包下

1. 在hibernate.cfg.xml中配置

    
……
        
        
    

C. Hibernate五大API

1. 测试Hibernate的五大API：
   Hibernate五大API：Configuration,SessionFactory,Session,Transaction,Query

public class HibernateTest {
    private Configuration cfg = null;
    private SessionFactory factory = null;
    private Session session = null;
    private Transaction trans = null;
    @Before
    public void setUp() throws Exception {
        // 解析hibernate.cfg.xml配置文件 (.configure()后才会真正解析)
        cfg = new Configuration().configure();
        // 创建SessionFactory(创建连接池)
        factory = cfg.buildSessionFactory();
        // 创建Session
        session = factory.openSession();
    }
    /**
     * 增加
     */
    @Test
    public void testAdd() {
        User user = new User();
        user.setUsername("张三");
        user.setSex('男');
        user.setAge(20);
        user.setBirthday(new Date());
        user.setSalary(2000.28);

        try {
            // 创建及开启事务对象
            trans = session.beginTransaction();
            // .....
            session.save(user);
            trans.commit();
        } catch (HibernateException e) {
            // 回滚事务
            trans.rollback();
            e.printStackTrace();
        }
    }
    /**
     * 测试Query接口，查询所有
     */
    @Test
    public void testFindAll() {

        Query query = session.createQuery("from User");
        List list = query.list();

        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            System.out.println("名字：" + user.getUsername());
            System.out.println("生日：" + user.getBirthday());
        }

    }
    /**
     * 根据ID更新
     */
    @Test
    public void testUpdate() {

        try {
            // // 创建及开启事务对象
            // trans = session.beginTransaction();
            // // .....
            // User user = (User) session.get(User.class, 5);
            // user.setUsername("李四");
            // user.setSex('女');
            // session.update(user);// 多余，可以不写
            //
            // trans.commit();

            // 创建及开启事务对象
            trans = session.beginTransaction();
            // .....
            User user = (User) session.get(User.class, 6);
            user.setUsername("赵六");
            user.setSex('女');
        
            trans.commit();

        } catch (HibernateException e) {
            // 回滚事务
            trans.rollback();
            e.printStackTrace();
        }

    }
    /**
     * 根据ID删除
     */
    @Test
    public void testDelete() {

        try {
            // 创建及开启事务对象
            trans = session.beginTransaction();
            // .....
            User user = (User) session.get(User.class, 2);
            session.delete(user);

            trans.commit();

        } catch (HibernateException e) {
            // 回滚事务
            trans.rollback();
            e.printStackTrace();
        }

    }
    /**
     * 根据ID查询(只有查询不需要开启事务)
     */
    @Test
    public void testLoad() {
        User user = (User) session.get(User.class, 6);
        System.out.println("名字：" + user.getUsername());
        System.out.println("生日：" + user.getBirthday());
    }

    @After
    public void tearDown() throws Exception {
        if (session != null) {
            session.close();
        }
    }

1. 单例SessionFactory工厂支持类
   HibernateUtil.java

/**
 * 单例SessionFactory
 * SessionFactory就是保存配置、缓存的
 */
public class HibernateUtil {

    private static Configuration cfg = null;
    private static SessionFactory factory = null;
    // 静态代码块先执行
    static {
        if (cfg == null) {
            // 解析hibernate.cfg.xml配置文件 (.configure()后才会真正解析)
            cfg = new Configuration().configure();
        }
        if (factory == null) {
            // 创建SessionFactory(创建连接池)
            factory = cfg.buildSessionFactory();
        }
    }

    /**
     * 获取session工厂
     * 
     * @return
     */
    public static SessionFactory getFactory() {
        return factory;
    }

    /**
     * 打开一个session
     * 
     * @return
     */
    public static Session getSession() {
        return factory.openSession();
    }

    /**
     * 关闭session
     * 
     * @param session
     */
    public static void closeSession(Session session) {
        if (session != null) {
            session.close();
        }
    }
}

D. 持久化对象的三种状态

    private Session session = null;
    private Transaction trans = null;
        @Test
        public void testAdd() {
        // [new]瞬时对象
        User user = new User();
        user.setUsername("王二");
        user.setSex('女');
        user.setAge(23);
user.setBirthday(new Date());
        user.setSalary(3000.56);
        
        try {
            // 创建Session
            session = HibernateUtil.getSession();
            // 创建及开启事务对象
    trans = session.beginTransaction();
            // .....
        
            session.save(user);
            trans.commit();
            // 持久化对象：对象有id值，与数据库同步（受事务、session的管理），
            // 对象的引用要在session的缓存当中
        } catch (HibernateException e) {
            // 回滚事务
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
        // 离线/托管对象，有id值，不受数据库管理（session关闭之后持久化对象变为离线/托管对象）
System.out.println(user.getUsername());
        user.setUsername("王麻子");
        
        // 将离线/托管对象重新拉入到缓存中，重新与数据库关联起来
        try {
            // 创建Session
    session = HibernateUtil.getSession();
            trans = session.beginTransaction();
        
            session.update(user);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
        HibernateUtil.closeSession(session);
        }
    }

E. 增、删、改、查各方法的区别

1. Persist和Save及Save和SaveOrUpdate方法的区别

    private Session session = null;
    private Transaction trans = null;

    // Save和SaveOrUpdate方法的区别
    @Test
    public void testSaveAndSaveOrUpdate() {
        User user = new User();
        user.setUsername("王二的范德萨方麻子");
        user.setSex('男');
        user.setAge(20);
        user.setBirthday(new Date());
        user.setSalary(3000.56);
        user.setId(5);
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();

//           无论如何也会存起来，如果配置文件id由hibernate来生成
//          （ ），设置id没用，hibernate自动生成
//           session.save(user);
            
//           有id就会更新，但是数据库中没有当前id的数据就会抛异常，没有id就会保存
            session.saveOrUpdate(user);
            // session.persist(user)和.save(user);几乎没有区别，有id值会抛异常
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

    // Save和SaveOrUpdate方法对持久化对象不起作用
    @Test
    public void testSaveAndSaveOrUpdate2() {
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // user是一个持久对象
            User user = (User) session.get(User.class, 6);
            user.setUsername("赵六");
    
            // 数据不一致就会更新
            // session.save(user);
    
            // 数据不一致也会更新
            session.saveOrUpdate(user);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

1. Merge和Update方法的区别

    private Session session = null;
    private Transaction trans = null;

// update和merge方法的区别
    @Test
    public void testUpdateAndMerge() {
        User user = new User();
        user.setUsername("东方东方打df算可风");
        user.setSex('男');
        user.setAge(44);
        user.setBirthday(new Date());
        user.setSalary(548548.56);
        user.setId(5);
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // ...
            User u = (User) session.get(User.class, 5);
            
            // session.update(user);
            // 在session缓存中有两个相同ID的实体时，更新会抛异常
            
            session.merge(user);
            // 跟update不一样，merge方法会把 要持久化的对象赋值给ID相同的实体对象
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

1. Lock(已淘汰)和Update方法的区别

    private Session session = null;
    private Transaction trans = null;
    // Update和Lock（淘汰）方法的区别
    @Test
    public void testUpdateAndLock() {
        User user = null;
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();

            user = (User) session.get(User.class, 6);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
        System.out.println(user);
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // lock方法的作用就是将没有改变属性的离线、托管对象重新拉入到持久对象当中
            // 但是如果改了属性值，就得用update方法
            session.lock(user, LockMode.OPTIMISTIC);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

1. Save、Update、Delete方法的执行顺序及flush方法

    private Session session = null;
    private Transaction trans = null;

    // 命令的执行顺序
    @Test
    public void testSessionOnFlush() {
        User user = new User();
        user.setUsername("李四");
        user.setSex('男');
        user.setAge(44);
        user.setBirthday(new Date());
        user.setSalary(548548.56);
        // user.setId(5);
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // ...
            User u = (User) session.get(User.class, 1);
            
            // 不执行flush()方法在提交后的发出的sql语句的默认顺序就是：查、曾、改、删
            // 执行flush()方法会提前发出sql语句，然后刷新缓存
            u.setUsername("王麻子");
            session.flush();
        
            session.delete(session.get(User.class, 4));
            session.flush();
        
            session.save(user);
            session.flush();
        
            user = new User();
            user.setUsername("赵六");
            user.setSex('男');
            user.setAge(44);
            user.setBirthday(new Date());
            user.setSalary(548548.56);
            session.save(user);
        
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

1. close、clear及evict方法的区别

    private Session session = null;
    private Transaction trans = null;
    // close()、clear()和evict()方法
    @Test
    public void testClearAndEvict() {
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();

            Query query = session
                    .createQuery("from com.alyshen.hibernate.domain.User");
        
            List list = query.list();
            // session.clear();//
            // 清空缓存，查询出来的对象都变成离线、托管对象的了，拉入缓存则需要：session.update(user);
            int i = 0;
            for (User user : list) {
                i++;
                if (i == 5) {
                    session.evict(user);// 驱逐
                }
                user.setUsername(user.getUsername() + "_X");
                // session.update(user);
            }
        
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            //close();session直接被回收
            HibernateUtil.closeSession(session);
        }
    }

1. get和load方法的区别

    private Session session = null;
    private Transaction trans = null;
    // get()和load()方法的区别
    @Test
    public void testGetAndLoad() {
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();

//           User user = (User) session.get(User.class, 11);

            User user = (User) session.load(User.class, 11);
            // 懒加载，创建的是一个对象的代理，如果查询出来为空则创建不了代理就抛异常
    // 如果不需要懒加载，则可以在实体映射文件配置中配置：lazy="false"，配置后跟使用get一样，
//只有在使用对象的时候，用对象的代理对象发出sql语句
            
            System.out.println(user);
            
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

1. list和iterator方法的区别

    private Session session = null;
    private Transaction trans = null;
    // list()和iterator()方法
    @Test
    public void testListAndIterator() {
        try {
            
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
        
            Query query = session.createQuery("from User");
        
             // list()全部查询出来，无法利用缓存
             List list = query.list();
             for (User user : list) {
             System.out.println("用户名：" + user.getUsername());
             }
            // list = query.list();
            //
            // for (User user : list) {
            // System.out.println("用户名：" + user.getUsername());
            // }
        
            // 先把所有id查询出来，然后有id去单个的查询，可以利用缓存
            Iterator iter = query.iterate();
            while (iter.hasNext()) {
                User user = iter.next();
                System.out.println("用户名：" + user.getUsername());
            }
            //理想是方式就是先用list查出来，再用的话就用iterate

//          iter = query.iterate();
//          while (iter.hasNext()) {
//              User user = iter.next();
//              System.out.println("用户名：" + user.getUsername());
//          }
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

F. 主键生成策略

1. 常用主键生成策略
   User.hbm.xml

1. 联合主键生成策略(不常用)
2. UserKey.java

public class UserKey implements Serializable {

    private int id;
    private String uuid;

    /**
     * 重写hashCode方法
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
        return result;
    }

    /**
     * 重写equals方法
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        UserKey other = (UserKey) obj;
        if (id != other.id)
            return false;
        if (uuid == null) {
            if (other.uuid != null)
                return false;
        } else if (!uuid.equals(other.uuid))
            return false;
        return true;
    }

    public UserKey(int id, String uuid) {
        super();
        this.id = id;
        this.uuid = uuid;
    }

    public UserKey() {
        super();
        // TODO Auto-generated constructor stub
    }
//各种set、get方法
……
}

a) User.java

    private UserKey id;
    private String username;
    private char sex;
    private Date birthday;
    private int age;
    private double salary;// 薪资
//各种set、get方法
……

b) User.hbm.xml

c) 测试联合主键

    private Session session = null;
    private Transaction trans = null;
    /**
     * 测试联合主键
     */
    @Test
    public void testStrategy() {
        User user = new User();
        user.setUsername("赵六");
        user.setSex('女');
        user.setAge(17);
        user.setBirthday(new Date());
        user.setSalary(20000.56);
        user.setId(new UserKey(12, "zhaoliou"));
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....

            session.save(user);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }
    
    @Test
    public void testLoad() {
    
        session = HibernateUtil.getSession();
        User user = (User) session.get(User.class, new UserKey(12, "zhaoliou"));
        System.out.println(user.getUsername());
    }

G. 属性的映射

1. User.java

    private int id;
    private String username;
    private String user;
    private char sex;
    private Date birthday;
    private int age;
    private double salary;// 薪资
    private String story;// 小说
    private byte[] music = null;
//各种set、get方法
……

1. User.hbm.xml

1. 测试

private Session session = null;
    private Transaction trans = null;

    /**
     * 测试映射配置
     */
    @Test
    public void testProperty() {
        User user = new User();
        user.setUsername("赵六");
        user.setSex('女');
        user.setAge(17);
        user.setBirthday(new Date());
        user.setSalary(20000.56);
        // user.setId(20);
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....

            session.save(user);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

    /**
     * 测试不能添加、更新属性的映射配置
     */
    @Test
    public void testUpdate() {

        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....

            User user = (User) session.get(User.class, 1);
            user.setUsername("李四");
            user.setSex('男');
        
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

    /**
     * 测试长字符串
     */
    @Test
    public void testStoryTypeText() {

        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
            User user = new User();
            user.setUsername("赵六");
            user.setSex('女');
            user.setAge(17);
            user.setBirthday(new Date());
            user.setSalary(20000.56);
            user.setStory("附近的扩军绿军军军军军军军军军军军军军豆腐干看见对方考虑更多附近 都是");
            session.save(user);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

    /**
     * 存入文件
     */
    @Test
    public void testMusicTypeBinary() {

        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
            User user = new User();
            user.setUsername("赵六");
            user.setSex('女');
            user.setAge(17);
            user.setBirthday(new Date());
            user.setSalary(20000.56);
            user.setStory("sfdsfkdsfdskfjkldsfdjsklfjdksjfld");
            try {
                user.setMusic(FileUtils.readFileToByteArray(new File(
                        "E:\\爱音乐\\经典金曲\\Linda - 张学友.mp3")));
            } catch (IOException e) {
                // TODO Auto-generated catch block
                throw new RuntimeException(e);
            }
            session.save(user);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

    /**
     * 取出文件
     */
    @Test
    public void testMusicTypeBinary2() {

        session = HibernateUtil.getSession();
        User user = (User) session.get(User.class, 2);
        try {
            FileUtils.writeByteArrayToFile(new File("e:/Linda.mp3"),
                    user.getMusic());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e);
        }
    }

H. 关联映射配置

理解OR映射的异构和多重性

组里有联系人的引用且联系人里有组的引用叫双向关联，找到其中一方就能找到对方

联系人到组的单向关联，联系人保存组的引用，找到联系人就能找到组，但找到组是不能找到联系人的

组到联系人的单向关联，组保存联系人的引用，找到组就能找到联系人，但找到联系人是不能不到组的

a) 多对一
组里有多个联系人，联系人只有一个组，叫多对一

ContactPerson.java

public class ContactPerson {
    private Group group;
//各种set、get方法
……
}

Group.java

public class Group {
    private Set contactPersons = new HashSet();
//各种set、get方法
……
}

b) 一对一
一个联系人有一个账号，一个账号对应一个联系人，叫一对一
Account.java

public class Account {
    private ContactPerson person;
    //各种set、get方法
……
}

ContactPerson.java

public class ContactPerson {
    private Account account;
    //各种set、get方法
……
}

c) 多对多
一个学生有多个老师，一个老师有多个学生，叫多对多
Student.java

public class Student {
    private Set teachers = new HashSet();
    //各种set、get方法
……
}

Teacher.java

public class Teacher {
    private Set students = new HashSet();
    //各种set、get方法
……

}

多对一单向关联

a) 多对一单向关联的映射配置
1) Group.java

public class Group {
    private int id;
    private String groupName;
//各种set、get方法
……
}

2) Group.hbm.xml

    
        
            
        
        
    

    3)  ContactPerson.java
public class ContactPerson {
    private int id;
    private String name;
    private Group group;
//各种set、get方法
……
}

4) ContactPerson.hbm.xml

    

        
            
        
        
        
        
        
        
    
    5)  测试
    private Session session = null;
    private Transaction trans = null;

    /**
     * Many2One单向关联
     */
    @Test
    public void testMany2OneAdd() {

        Group group = new Group();
        group.setGroupName("同学");

        ContactPerson p1 = new ContactPerson();
        p1.setName("张三");
        p1.setGroup(group);

        ContactPerson p2 = new ContactPerson();
        p2.setName("李四");
        p2.setGroup(group);

        ContactPerson p3 = new ContactPerson();
        p3.setName("王五");
        p3.setGroup(group);

        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....

            session.save(group);
            //先存组，保存联系人时才能一起将联系人的组信息保存
            session.save(p1);
            session.save(p2);
            session.save(p3);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

b) 多对一单向关联中的懒加载机制

    private Session session = null;
    private Transaction trans = null;
/**
     * Many2One单向关联
     */
    @Test
    public void testMany2OneQuery() {

        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            ContactPerson person = (ContactPerson) session.get(
                    ContactPerson.class, 1);
//           ContactPerson p = (ContactPerson)
//           session.load(ContactPerson.class,
//           1);

            System.out.println(person.getName());
            // p.getGroup()此时的group是一个代理对象，在用它的属性的时候代理对象才会发出sql查询
            // 不需要代理可以在多对一配置中配置不懒加载：lazy="false";
            System.out.println(person.getGroup().getGroupName());
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }
    /**
     * Many2One延迟加载异常
     */
    @Test
    public void testMany2OneQuery2() {
        ContactPerson person = null;
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
            person = (ContactPerson) session.get(ContactPerson.class, 1);
            // person = (ContactPerson) session.load(ContactPerson.class, 1);
    
            System.out.println(person.getName());
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
        // 这时联系人的组是一个代理对象，想得到它的名字时需要发出sql查询，但这时session已经关闭，所以会抛延迟加载异常
        // 如果配置多对一时配置：lazy="false"立即加载就不会抛延迟加载异常了，但是person必须也是立即加载
        // 也就是说懒加载session必须要开着的，链接要开着的
        System.out.println(person.getGroup().getGroupName());
    }

c) 多对一单向关联的级联配置
1) ContactPerson.hbm.xml

2) 测试级联添加及删除

    private Session session = null;
    private Transaction trans = null;

    /**
     * 级联添加
     */
    @Test
    public void testCascadeAdd() {
    
        Group group = new Group();
        group.setGroupName("同学");
    
        ContactPerson p1 = new ContactPerson();
        p1.setName("张三");
        p1.setGroup(group);
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            session.save(p1);
            
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }
    
    /**
     * 级联删除
     */
    @Test
    public void testCascadeDelete() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            ContactPerson person = (ContactPerson) session.get(
                    ContactPerson.class, 1);
            session.delete(person);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

3) 级联删除外键约束

    private Session session = null;
    private Transaction trans = null;

    /**
     * 级联删除外键约束
     */
    @Test
    public void testCascadeDelete2() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            ContactPerson person = (ContactPerson) session.get(
                    ContactPerson.class, 5);
    
            // person的组还有其他联系人时，级联删除就会抛异常，因为外键约束
            session.delete(person);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

4) 利用离线对象执行删除操作时，级联配置失效

    private Session session = null;
    private Transaction trans = null;
/**
     * 利用离线对象执行删除操作时，级联配置失效
     */
    @Test
    public void testCascadeDelete3() {

        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            ContactPerson person = new ContactPerson();
            person.setId(5);// 创建离线对象
    
            session.delete(person);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

一对多单向关联

a) 一对多单向关联配置
1) ContactPerson.java

    private int id;
    private String name;

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        ContactPerson other = (ContactPerson) obj;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
//各种set、get方法
……

2) ContactPerson.hbm.xml

    
        
            
        
        
    
    3)  Group.java
    private int id;
    private String groupName;

    private Set persons = new HashSet();
//各种set、get方法
……

4) Group.hbm.xml

    
        
            
        
        

        
        
            
            
        
    
    5)  添加及查询
    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对多单向关联——添加
     */
    @Test
    public void testOne2ManyAdd() {

        Group group = new Group();
        group.setGroupName("同学");

        ContactPerson p1 = new ContactPerson();
        p1.setName("张三");

        ContactPerson p2 = new ContactPerson();
        p2.setName("李四");

        ContactPerson p3 = new ContactPerson();
        p3.setName("王五");

        group.addPerson(p1);
        group.addPerson(p2);
        group.addPerson(p3);
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
            // 多余的更新sql语句没法去掉
            session.save(p1);
            session.save(p2);
            session.save(p3);
            session.save(group);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

    /**
     * 一对多单向关联——查询数据
     */
    @Test
    public void testOne2ManyQuery() {

        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....

            ContactPerson person = (ContactPerson) session.get(
                    ContactPerson.class, 1);
            System.out.println(person.getName());
        
            Group group = (Group) session.get(Group.class, 1);
            Iterator iter = group.getPersons().iterator();
        
            while (iter.hasNext()) {
                System.out.println(iter.next().getName());
            }
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

a) 一对多关联的重建和级联操作
1) 级联添加

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对多单向关联——级联添加
     */
    @Test
    public void testOne2ManyCascadeAdd2() {
    
        Group group = new Group();
        group.setGroupName("同事");
    
        ContactPerson p1 = new ContactPerson();
        p1.setName("王二");
    
        ContactPerson p2 = new ContactPerson();
        p2.setName("麻子");
    
        ContactPerson p3 = new ContactPerson();
        p3.setName("赵六");
    
        group.addPerson(p1);
        group.addPerson(p2);
        group.addPerson(p3);
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            session.save(group);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

2) 级联删除

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对多单向关联——级联删除
     */
    @Test
    public void testOne2ManyCascadeDelete() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            Group group = (Group) session.get(Group.class, 2);
    
            session.delete(group);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

3) 离线对象级联删除失效

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对多单向关联——离线对象级联删除失效
     */
    @Test
    public void testOne2ManyCascadeDelete2() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            Group group = new Group();
            group.setId(1);// 创建离线对象
    
            session.delete(group);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

a) 一对多关联的延迟加载、修改、删除及清空
1) 不懒加载

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对多单向关联——不懒加载
     */
    @Test
    public void testOne2ManyLazyDoFalse() {
        Group group = null;
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            group = (Group) session.get(Group.class, 2);
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    
        System.out.println(group.getGroupName());
        for (ContactPerson person : group.getPersons()) {
            System.out.println(person.getName());
        }
    }

2) 修改

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对多单向关联——修改
     */
    @Test
    public void testOne2ManyUpdate() {
        Group group = null;
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            group = (Group) session.get(Group.class, 2);
            ContactPerson person = (ContactPerson) session.get(
                    ContactPerson.class, 1);
            group.addPerson(person);
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
        System.out.println(group.getGroupName());
        for (ContactPerson person : group.getPersons()) {
            System.out.println(person.getName());
        }
    }

3) 从组里清除

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对多单向关联——从组里清除
     */
    @Test
    public void testOne2ManyRemove() {
        Group group = null;
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            group = (Group) session.get(Group.class, 2);
            ContactPerson person = (ContactPerson) session.get(
                    ContactPerson.class, 4);
            group.getPersons().remove(person);
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    
        System.out.println(group.getGroupName());
        for (ContactPerson person : group.getPersons()) {
            System.out.println(person.getName());
        }
    }

4) 清空组

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对多单向关联——清空组
     */
    @Test
    public void testOne2ManyClear() {
        Group group = null;
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            group = (Group) session.get(Group.class, 2);
    
            group.getPersons().clear();
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    
        System.out.println(group.getGroupName());
        for (ContactPerson person : group.getPersons()) {
            System.out.println(person.getName());
        }
    }

b) 聪明的extra(推荐一对多延迟加载策略)
1) Group.hbm.xml

2) 测试Extra

    private Session session = null;
    private Transaction trans = null;

    /**
     * 这个测试Extra和普通延迟加载没区别
     */
    @Test
    public void testQuery() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            Group group = (Group) session.get(Group.class, 1);
            System.out.println(group.getGroupName());
            for (ContactPerson p : group.getPersons()) {
                System.out.println(p.getName());
            }
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }
    
    /**
     * 这个测试Extra加载获取条数
     */
    @Test
    public void testQueryCount() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            Group group = (Group) session.get(Group.class, 1);
            // 普通延迟加载就会把联系人全部查出来，再算大小
            // 而extra加载直接去查条数
            System.out.println(group.getGroupName() + "组里有联系人："
                    + group.getPersons().size() + "个!");
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }
    
    /**
     * 这个测试Extra加载是否包含某个联系人
     */
    @Test
    public void testCheckContains() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            Group group = (Group) session.get(Group.class, 1);
            ContactPerson p = new ContactPerson();
            p.setId(3);
            //普通懒加载加载为false，extra懒加载为true
            System.out.println(group.getPersons().contains(p));
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

一对多双向关联

a) 一对多双向关联及inverse的用法
1) Group.java

    private int id;
    private String groupName;

    private Set persons = new HashSet();
//各种set、get方法
……
    2)  Group.hbm.xml
    
        
            
        
        

        
        
            
            
        
    

3) ContactPerson.java

    private int id;
    private String name;
    private Group group;

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        ContactPerson other = (ContactPerson) obj;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
//各种set、get方法
……

4) ContactPerson.hbm.xml

5) 测试一对多双向关联

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对多双向关联，由一的一端维护数据，所以多的一端多了update语句
     */
    @Test
    public void testOne2ManyAdd() {

        Group group = new Group();
        group.setGroupName("同学");

        ContactPerson p1 = new ContactPerson();
        p1.setName("张三");

        ContactPerson p2 = new ContactPerson();
        p2.setName("李四");

        ContactPerson p3 = new ContactPerson();
        p3.setName("王五");

        group.addPerson(p1);
        group.addPerson(p2);
        group.addPerson(p3);
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....

            session.save(group);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

    /**
     * 一对多双向关联，由多的一端维护数据
     */
    @Test
    public void testOne2ManyAdd2() {

        Group group = new Group();
        group.setGroupName("同事");

        ContactPerson p1 = new ContactPerson();
        p1.setName("王二");

        ContactPerson p2 = new ContactPerson();
        p2.setName("麻子");

        ContactPerson p3 = new ContactPerson();
        p3.setName("赵六");

        p1.setGroup(group);
        p2.setGroup(group);
        p3.setGroup(group);

        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....

            session.save(p1);
            session.save(p2);
            session.save(p3);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

6) inverse的用法

    private Session session = null;
    private Transaction trans = null;
    /**
     * 一对多双向关联，由两端维护数据，多了update语句
     * ，set集合的inverse="true":一的一端放弃维护数据的统一，只有添加sql语句，
*  一的一端不再更新其他有关联的数据
     */
    @Test
    public void testOne2ManyAdd3() {

        Group group = new Group();
        group.setGroupName("朋友");
        
        ContactPerson p1 = new ContactPerson();
        p1.setName("李三");
        
        ContactPerson p2 = new ContactPerson();
        p2.setName("王五");
        
        ContactPerson p3 = new ContactPerson();
        p3.setName("赵七");
        
        p1.setGroup(group);
        p2.setGroup(group);
        p3.setGroup(group);
        
        group.addPerson(p1);
        group.addPerson(p2);
        group.addPerson(p3);
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
        
            session.save(group);
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

b) 一对多双向关联重建及外键定义不一致导致的问题
1) 关联重建

    private Session session = null;
    private Transaction trans = null;

    /**
     * 测试一对多双向关联关联重建
     */
    @Test
    public void testOne2ManyQuery() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            Group group = (Group) session.get(Group.class, 2);
            System.out.println(group.getGroupName() + "当中有元素：");
            
            for (ContactPerson person : group.getPersons()) {
                System.out.println(person.getName() + "，所属组："
                        + person.getGroup().getGroupName());
            }
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

2) 外键定义不一致导致的问题

c) 一对多双向自关联
1) Employee.java

    private int id;
    private String name;
    private Employee manager;
    private Set puisnes = new HashSet();

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
//各种set、get方法
……

2) Employee.hbm.xml

    

        
            
        
        
    
        
        
        
            
            
        
    
在hibernate.cfg.xml文件中在注明一下：
       
……

    

3) 测试一对多自关联

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一的一端放弃维护数据
     */
    @Test
    public void testAddEmployee() {
    
        /**
         * 员工加上司，存底层员工
         */
        Employee root = new Employee();
        root.setName("董事长");
    
        Employee manager1 = new Employee();
        manager1.setName("周总");
        Employee manager2 = new Employee();
        manager2.setName("王总");
    
        Employee e1 = new Employee();
        e1.setName("张三");
        Employee e2 = new Employee();
        e2.setName("李四");
        Employee e3 = new Employee();
        e3.setName("王五");
        Employee e4 = new Employee();
        e4.setName("赵六");
        Employee e5 = new Employee();
        e5.setName("周七");
        Employee e6 = new Employee();
        e6.setName("王二");
    
        // root.addPuisne(manager1);
        // root.addPuisne(manager2);
        // 上司加下属没用，因为上司放弃维护数据（一的一端放弃维护数据）
    
        e1.setManager(manager1);
        e2.setManager(manager1);
        e3.setManager(manager1);
        e4.setManager(manager1);
    
        e5.setManager(manager2);
        e6.setManager(manager2);
    
        manager1.setManager(root);
        manager2.setManager(root);
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
            // session.save(root);
            // 这时存root没用，因为一的一端已经放弃维护数据
    
            session.save(e1);
            session.save(e2);
            session.save(e3);
            session.save(e4);
            session.save(e5);
            session.save(e6);
            // 多的一方维护数据
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

4) 一对多自关联的重建

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对多自关联——重建
     */
    @Test
    public void testQueryEmployee() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            Employee root = (Employee) session.get(Employee.class, 3);
    
            out(root, 1);
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }
    
    /**
     * 通过递归算法重建（递归算法要有结束循环的条件）
     * @param e
     * @param level
     */
    private void out(Employee e, int level) {
    
        if (e != null) {
            for (int i = 0; i < level; i++) {
                System.out.print("   ");
            }
            System.out.println(level + "级：" + e.getName());
    
            if (e.getPuisnes() != null && e.getPuisnes().size() > 0) {
    
                for (Employee e1 : e.getPuisnes()) {
                    out(e1, level + 1);
                }
            }
        }
    }

一对一关联

a) 一对一共享主键关联
1) Employee.java

    private int id;
    private String name;
    
    // 加了user属性就是一对一双向关联 ，没有user属性就是单向关联
    private User user;
//各种set、get方法
……

2) Employee.hbm.xml

    

        
            
        
        
        
        
        
    
3)  User.java
    private int id;
    private String username;
    private String password;
    private Employee emp;
//各种set、get方法
……

4) User.hbm.xml

    

        
        
            
                emp
            
        
    
        
        
    
        
        
    

5) 测试一对一共享主键关联

    private Session session = null;
    private Transaction trans = null;

    /**
     * 一对一单向关联及双向关联
     */
    @Test
    public void testAdd2() {
        Employee emp = new Employee();
        emp.setName("赵六");
    
        User user = new User();
        user.setUsername("zhaoliou");
        user.setPassword("123456");
        user.setEmp(emp);
        // emp.setUser(user);双向关联时用不了，会抛异常
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            session.save(user);
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }
    
    /**
     * 一对一双向关联关联重建
     */
    @Test
    public void testQuery() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            Employee emp = (Employee) session.get(Employee.class, 1);
            System.out.println("员工名：" + emp.getName() + ",员工账号："
                    + emp.getUser().getUsername());
    
            System.out.println("员工名："
                    + emp.getUser().getEmp().getUser().getEmp().getName());
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

b) 一对一唯一外键关联
1) Employee.hbm.xml

2) User.hbm.xml

3) 测试跟一对一共享主键关联一样

多对多关联

a) 多对多单双向关联
1) Student.java

    private int id;
    private String name;

    // 加了teachers就是双向关联
    private Set teachers = new HashSet();
//各种set、get方法
……
//hashCode和equals方法
……

2) Student.hbm.xml

3) Teacher.java

    private int id;
    private String name;
    private Set students = new HashSet();
//各种set、get方法
……
//hashCode和equals方法
……

4) Teacher.hbm.xml

5) 测试多对多单双向关联

    private Session session = null;
    private Transaction trans = null;
    
    /**
     * 多对多单向关联
     */
    @Test
    public void testAdd() {
        Student s1 = new Student();
        s1.setName("张三同学");
        Student s2 = new Student();
        s2.setName("李四同学");
        Student s3 = new Student();
        s3.setName("王二同学");
        Student s4 = new Student();
        s4.setName("赵六同学");
    
        Teacher t1 = new Teacher();
        t1.setName("王老师");
        Teacher t2 = new Teacher();
        t2.setName("李老师");
        
        t1.getStudents().add(s1);
        t1.getStudents().add(s2);
        t1.getStudents().add(s3);
        
        t2.getStudents().add(s1);
        t2.getStudents().add(s3);
        t2.getStudents().add(s4);
        
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            // 由哪一端维护数据就由哪一端加对方，级联时就保存哪一端
            session.save(t1);
            session.save(t2);
        
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }
    
    /**
     * 多对多双向关联
     */
    @Test
    public void testAdd2() {
        
        Student s1 = new Student();
        s1.setName("张三同学");
        Student s2 = new Student();
        s2.setName("李四同学");
        Student s3 = new Student();
        s3.setName("王二同学");
        Student s4 = new Student();
        s4.setName("赵六同学");
    
        Teacher t1 = new Teacher();
        t1.setName("王老师");
        Teacher t2 = new Teacher();
        t2.setName("李老师");
        
        t1.getStudents().add(s1);
        t1.getStudents().add(s2);
        t1.getStudents().add(s3);
    
        s1.getTeachers().add(t1);
        s2.getTeachers().add(t1);
        s3.getTeachers().add(t1);
    
        t2.getStudents().add(s1);
        t2.getStudents().add(s3);
        t2.getStudents().add(s4);
    
        s1.getTeachers().add(t2);
        s3.getTeachers().add(t2);
        s4.getTeachers().add(t2);
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            // 双方都维护数据时报错，因为共同维护数据就会插入一次相同的数据，因为关系表不能重复所以存在争议
            // 所以需要一端放弃维护数据，此列学生端放弃维护数据
            session.save(t1);
            session.save(t2);
        
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

6) 多对多双向关联重建

    private Session session = null;
    private Transaction trans = null;
    /**
     * 多对多双向关联关联重建
     */
    @Test
    public void testQuery() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            Teacher t1 = (Teacher) session.get(Teacher.class, 1);
            System.out.println(t1.getName() + "的学生有：");
            for (Student s : t1.getStudents()) {
                System.out.println("     " + s.getName());
            }
        
            Teacher t2 = (Teacher) session.get(Teacher.class, 2);
            System.out.println(t2.getName() + "的学生有：");
            for (Student s : t2.getStudents()) {
                System.out.println("     " + s.getName());
            }
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

b) 改良后的两个一对多替代多对多关联
1) StudentTeacher.java

    private int id;
    private Student student;
    private Teacher teacher;
    private Date startTime;
//各种set、get方法
……
//hashCode和equals方法
……

2) StudentTeacher.hbm.xml

3) Student.java

    private int id;
    private String name;
    private Set studentTeachers = new HashSet();
//各种set、get方法
……
//hashCode和equals方法
……

4) Student.hbm.xml

5) Teacher.java

    private int id;
    private String name;
    private Set studentTeachers = new HashSet();
HashSet();
//各种set、get方法
……
//hashCode和equals方法
……

6) Teacher.hbm.xml

7) 测试改良的多对多

    private Session session = null;
    private Transaction trans = null;

    /**
     * 改良的多对多关联（两个一对多，一个学生对应多个老师，一个老师对应多个学生，）
     */
    @Test
    public void testAdd2() {
        Student s1 = new Student();
        s1.setName("张三同学");
        Student s2 = new Student();
        s2.setName("李四同学");
        Student s3 = new Student();
        s3.setName("王二同学");
        Student s4 = new Student();
        s4.setName("赵六同学");
    
        StudentTeacher st1 = new StudentTeacher();
        StudentTeacher st2 = new StudentTeacher();
        StudentTeacher st3 = new StudentTeacher();
        
        Teacher t1 = new Teacher();
        t1.setName("王老师");
    
        st1.setStartTime(new Date());
        st2.setStartTime(new Date());
        st3.setStartTime(new Date());
    
        st1.setTeacher(t1);
        st1.setStudent(s1);
    
        st2.setTeacher(t1);
        st2.setStudent(s2);
    
        st3.setTeacher(t1);
        st3.setStudent(s3);
    
        t1.getStudentTeachers().add(st1);
        t1.getStudentTeachers().add(st2);
        t1.getStudentTeachers().add(st3);

//      s3.getStudentTeachers().add(st1);

        StudentTeacher st4 = new StudentTeacher();
        StudentTeacher st5 = new StudentTeacher();
        StudentTeacher st6 = new StudentTeacher();
    
        Teacher t2 = new Teacher();
        t2.setName("李老师");
    
        st4.setStartTime(new Date());
        st5.setStartTime(new Date());
        st6.setStartTime(new Date());
    
        st4.setTeacher(t2);
        st4.setStudent(s2);
    
        st5.setTeacher(t2);
        st5.setStudent(s3);
    
        st6.setTeacher(t2);
        st6.setStudent(s4);
    
        t2.getStudentTeachers().add(st4);
        t2.getStudentTeachers().add(st5);
        t2.getStudentTeachers().add(st6);
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            session.save(t1);
            session.save(t2);
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

8) 改良的多对多重建

    private Session session = null;
    private Transaction trans = null;

    /**
     * 改良的多对多双向关联关联重建
     */
    @Test
    public void testQuery() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            Teacher t1 = (Teacher) session.get(Teacher.class, 1);
            System.out.println(t1.getName() + "的学生有：");
            for (StudentTeacher st : t1.getStudentTeachers()) {
                System.out.println("     " + st.getStudent().getName());
            }
    
            Student s2 = (Student) session.get(Student.class, 2);
            System.out.println(s2.getName() + "的老师有：");
            for (StudentTeacher st : s2.getStudentTeachers()) {
                System.out.println("     " + st.getTeacher().getName());
            }
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

组合映射

a) Contact.java

    private String tel;
    private String phone;
    private String qq;
    private String email;

    @Override
    public String toString() {
        return "Contact [tel=" + tel + ", phone=" + phone + ", qq=" + qq
                + ", email=" + email + "]";
    }
//各种set、get方法
    b)  Address.java
    private String busiAddress;
    private String homeAddress;
    private Contact contact;

    @Override
    public String toString() {
        return "Address [busiAddress=" + busiAddress + ", homeAddress="
                + homeAddress + ", contact=" + contact + "]";
    }
//各种set、get方法
User.java
    private int id;
    private String username;
    private String password;
    private Address address;

    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password="
                + password + ", address=" + address + "]";
    }
//各种set、get方法

c) User.hbm.xml

    

        
            
        
        
        
        
        
        
            
            
        
            
            
                
                
                
                
            
        
    
    d)  测试组合映射
    private Session session = null;
    private Transaction trans = null;

    /**
     * 测试组合映射
     */
    @Test
    public void testAdd() {

        User user = new User();
        user.setUsername("zhaoliou");
        user.setPassword("123456");

        Address addr = new Address();
        addr.setBusiAddress("北京");
        addr.setHomeAddress("上海");
        user.setAddress(addr);

        Contact con = new Contact();
        con.setTel("458185544");
        con.setPhone("18580505055");
        con.setQq("992555181");
        con.setEmail("[email protected]");
        addr.setContact(con);

        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....

            session.save(user);
            
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

    /**
     * 测试组合映射
     */
    @Test
    public void testQuery() {

        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....

            User user = (User) session.get(User.class, 1);
            System.out.println(user.toString());
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

继承映射

a) 继承映射（单表继承）
1) Substance.java

public interface Substance {

}

2) Person.java

public class Person implements Substance {
    private int id;
    private String name;
//各种set、get方法
……
}

3) Person.hbm.xml

4) Animal.java

public class Animal implements Substance {

    private int id;
    private String name;
//各种set、get方法
……
}

5) Dog.java

public class Dog extends Animal implements Substance {
    private double speed;
//各种set、get方法
……
}

6) Pig.java

public class Pig extends Animal implements Substance {
    private double weight;
//各种set、get方法
……
}

7) Extends.hbm.xml

8) 测试继承映射

i. 添加及重建

    private Session session = null;
    private Transaction trans = null;

    /**
     * 测试继承映射
     */
    @Test
    public void testAdd() {
    
        Pig p = new Pig();
        p.setName("大白猪");
        p.setWeight(350.6);
    
        Dog d = new Dog();
        d.setName("哈巴狗");
        d.setSpeed(12.3);
    
        Person per = new Person();
        per.setName("张三");
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            session.save(d);
            session.save(p);
            session.save(per);
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }
    
    /**
     * 测试继承映射的重建
     */
    @Test
    public void testQuery() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
            // 多态查询
            Animal a = (Animal) session.get(Animal.class, 1);
            Dog d = (Dog) a;
            System.out.println(d.getName() + "，速度：" + d.getSpeed());
    
            Animal a2 = (Pig) session.get(Pig.class, 2);
            Pig p = (Pig) a2;
            System.out.println(p.getName() + "，体重：" + p.getWeight());
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

ii. 继承映射中的问题（load方法无法实现多态查询）

    private Session session = null;
    private Transaction trans = null;

    /**
     * 测试继承映射——懒加载
     */
    @Test
    public void testLoadQuery() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            // 懒加载无法执行多态查询，Animal的代理子类无法转换成Dog类型
            // Animal a = (Animal) session.load(Animal.class, 1);
            // Dog d = (Dog) a;
            // System.out.println(d.getName() + "，速度：" + d.getSpeed());
    
            // 这个可以
            // Animal a2 = (Pig) session.load(Pig.class, 2);
            Animal a2 = (Animal) session.load(Pig.class, 2);
            Pig p = (Pig) a2;
            System.out.println(p.getName() + "，体重：" + p.getWeight());
    
            trans.commit();
        } catch (HibernateException e) {
            trans.rollback();
            e.printStackTrace();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

iii. 基于接口及对象的隐式多态查询

    private Session session = null;
    private Transaction trans = null;

    /**
     * 基于接口的隐式多态查询
     */
    @Test
    public void testSubstanceQuery() {
    
        try {
            session = HibernateUtil.getSession();
            trans = session.beginTransaction();
            // .....
    
            String hql = "from com.alyshen.hibernate.domain.Substance";
            Query query = session.createQuery(hql);
    
            List