private Integer customerId;private String customerName;

private Integer orderId;private String orderName;private Customer customer;

<hibernate-mapping>            <!-- 一般在表名后边加一个S，组成表名，利于order引用时，便于识别 -->    <class name="com.atguigu.hibernate.one2many.Customer" table="CUSTOMER">            <id name="customerId" type="java.lang.Integer">            <column name="CUSTOMER_ID" />            <generator class="native" />        </id>                <property name="customerName" type="java.lang.String">            <column name="CUSTOMER_NAME" />        </property>            </class></hibernate-mapping>

<hibernate-mapping package="com.atguigu.hibernate.one2many">    <class name="Order" table="ORDERS">            <id name="orderId" type="java.lang.Integer">            <column name="ORDER_ID" />            <generator class="native" />        </id>                <property name="orderName" type="java.lang.String">            <column name="ORDER_NAME" />        </property>                <!--             映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系             name: 多这一端关联的一那一端的属性的名字            class: 一那一端的属性对应的类名            column: 一那一端在多的一端对应的数据表中的外键的名字        -->        <!-- class=》Customer类的全类名，上边package中写了包名，所以这就不用写了 -->        <many-to-one name="customer" class="Customer" column="CUSTOMER_ID"></many-to-one>            </class>    </hibernate-mapping>

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"><hibernate-configuration>    <session-factory>        <!-- Hibernate连接数据库的基本信息 -->    <property name="connection.username">root</property>    <property name="connection.password">lxn123</property>    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>    <property name="connection.url">jdbc:mysql:///hibernate4</property>        <!-- Hibernate的基本配置 -->    <!-- Hibernate使用的数据库方言 -->    <property name="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>        <!-- 运行时是否执行sql语言 -->    <property name="show_sql">true</property>        <!-- 运行时是否格式化 -->    <property name="format_sql">true</property>        <!-- 生成数据表的策略，有四种，一般使用update -->    <property name="hbm2ddl.auto">update</property>        <!-- 设置hibernate事物的隔离级别 ,2为可读，可提交-->    <property name="connection.isolation">2</property>        <!-- 删除对象后，使其OID为null -->    <property name="use_identifier_rollback">true</property>        <!-- 配置c3p0数据源 -->    <!-- 数据库连接池的最大连接数 -->    <property name="hibernate.c3p0.max_size">10</property>        <!-- 数据库连接池的最小连接数 -->    <property name="hibernate.c3p0.min_size">5</property>         <!-- 当数据库连接池中的连接耗尽时, 同一时刻获取多少个数据库连接 -->    <property name="c3p0.acquire_increment">2</property>        <!-- 表示连接池检测线程多长时间检测一次池内的所有链接对象是否超时. -->    <property name="c3p0.idle_test_period">2000</property>            <!-- 数据库连接池中连接对象在多长时间没有使用过后，就应该被销毁 -->    <property name="c3p0.timeout">2000</property>        <property name="c3p0.max_statements">10</property>        <!-- 设定 JDBC 的 Statement 读取数据的时候每次从数据库中取出的记录条数 -->    <property name="hibernate.jdbc.fetch_size">100</property>        <!-- 设定 JDBC 的 Statement 读取数据的时候每次从数据库中取出的记录条数 -->    <property name="jdbc.batch_size">30</property>        <!-- 需要关联的hibernate关联文件 -->    <!--      <mapping resource="com/atguigu/hibernate/one2many/Order.hbm.xml"/>    <mapping resource="com/atguigu/hibernate/one2many/Customer.hbm.xml"/>    <mapping resource="com/atguigu/hibernate/one2many/both/Customer.hbm.xml"/>    <mapping resource="com/atguigu/hibernate/one2many/both/Order.hbm.xml"/>    <mapping resource="com/atguigu/hibernate/many2many/Category.hbm.xml"/>    <mapping resource="com/atguigu/hibernate/many2many/Item.hbm.xml"/>    -->    <mapping resource="com/atguigu/hibernate/subclass/Person.hbm.xml"/>        </session-factory></hibernate-configuration>

package com.atguigu.hibernate.test;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.After;import org.junit.Before;import org.junit.Test;import com.atguigu.hibernate.one2many.Customer;import com.atguigu.hibernate.one2many.Order;import com.mysql.jdbc.Connection;public class HibernateTest {        private SessionFactory sessionFactory;    private Session session;    private Transaction transaction;        @Before    public void init(){        Configuration configuration=new Configuration().configure();        ServiceRegistry serviceRegistry=                new ServiceRegistryBuilder().applySettings(configuration.getProperties())                                            .buildServiceRegistry();        sessionFactory=configuration.buildSessionFactory(serviceRegistry);        session=sessionFactory.openSession();        transaction=session.beginTransaction();    }        @After    public void destroy(){        transaction.commit();        session.close();        sessionFactory.close();    }        @Test    public void testDelect(){        //在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象        Customer customer=(Customer) session.get(Customer.class, 1);        session.delete(customer);    }        public void testUpdate(){        Order order=(Order) session.get(Order.class, 3);        order.getCustomer().setCustomerName("AAAAAA");            }        public void many2oneTget(){        //1. 若查询多的一端的一个对象, 则默认情况下, 只查询了多的一端的对象. 而没有查询关联的        //1 的那一端的对象!        Order order=(Order) session.get(Order.class, 3);        System.out.println(order.getOrderName());                System.out.println(order.getCustomer().getClass().getName());                Customer customer=(Customer) session.get(Customer.class, 1);        System.out.println(customer.getCustomerName());    }        public void many2OneTsave(){                Customer customer = new Customer();        customer.setCustomerName("panpan");                Order order= new Order();        order.setOrderName("ggg");                Order order2=new Order();        order2.setOrderName("drrr");                //设定关联关系        order.setCustomer(customer);        order2.setCustomer(customer);                session.save(order);        session.save(order2);        session.save(customer);    }}

private Integer customerId;private String customerName;    /** 1. 声明集合类型时, 需使用接口类型, 因为 hibernate 在获取* 集合类型时, 返回的是 Hibernate 内置的集合类型, 而不是 JavaSE 一个标准的* 集合实现. * 2. 需要把集合进行初始化, 可以防止发生空指针异常*/private Set<Order> orders=new HashSet<Order>();

private Integer orderId;private String orderName;private Customer customer;

<hibernate-mapping package="com.atguigu.hibernate.one2many.both">    <class name="Customer" table="CUSTOMERS">            <id name="customerId" type="java.lang.Integer">            <column name="CUSTOMER_ID" />            <generator class="native" />        </id>                <property name="customerName" type="java.lang.String">            <column name="CUSTOMER_NAME" />        </property>                <!-- 映射 1 对多的那个集合属性 -->        <!-- set: 映射 set 类型的属性, table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 -->        <!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 -->        <!-- cascade 设定级联操作. 开发时不建议设定该属性. 建议使用手工的方式来处理 -->        <!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名  -->        <set name="orders" table="ORDERS" inverse="true" order-by="ORDER_NAME DESC">            <!-- 执行多的表中的外键列的名字 -->            <key><column name="CUSTOMER_ID" /></key>            <!-- 指定映射类型 ,即映射类的全类名，上边package中已经添加了包，这儿只写映射的类名-->            <one-to-many class="Order" />        </set>            </class></hibernate-mapping>

<hibernate-mapping package="com.atguigu.hibernate.one2many.both">    <class name="Order" table="ORDERS">            <id name="orderId" type="java.lang.Integer">            <column name="ORDER_ID" />            <generator class="native" />        </id>                <property name="orderName" type="java.lang.String">            <column name="ORDER_NAME" />        </property>                <!--             映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系             name: 多这一端关联的一那一端的属性的名字            class: 一那一端的属性对应的类名            column: 一那一端在多的一端对应的数据表中的外键的名字        -->        <many-to-one name="customer" class="Customer" column="CUSTOMER_ID"></many-to-one>            </class></hibernate-mapping>

    @Test    public void testDelete(){        //在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象        Customer customer = (Customer) session.get(Customer.class, 1);        session.delete(customer);     }        @Test    public void testUpdat2(){        Customer customer = (Customer) session.get(Customer.class, 1);        customer.getOrders().iterator().next().setOrderName("GGG");     }        @Test    public void testUpdate(){        Order order = (Order) session.get(Order.class, 1);        order.getCustomer().setCustomerName("AAA");    }        @Test    public void testOne2ManyGet(){        //1. 对 n 的一端的集合使用延迟加载        Customer customer = (Customer) session.get(Customer.class, 7);        System.out.println(customer.getCustomerName());         //2. 返回的多的一端的集合时 Hibernate 内置的集合类型.         //该类型具有延迟加载和存放代理对象的功能.         System.out.println(customer.getOrders().getClass());                 //session.close();        //3. 可能会抛出 LazyInitializationException 异常                 System.out.println(customer.getOrders().size());                 //4. 再需要使用集合中元素的时候进行初始化.     }        @Test    public void testMany2OneGet(){        //1. 若查询多的一端的一个对象, 则默认情况下, 只查询了多的一端的对象. 而没有查询关联的        //1 的那一端的对象!        Order order = (Order) session.get(Order.class, 1);        System.out.println(order.getOrderName());                 System.out.println(order.getCustomer().getClass().getName());                session.close();                //2. 在需要使用到关联的对象时, 才发送对应的 SQL 语句.         Customer customer = order.getCustomer();        System.out.println(customer.getCustomerName());                 //3. 在查询 Customer 对象时, 由多的一端导航到 1 的一端时,         //若此时 session 已被关闭, 则默认情况下        //会发生 LazyInitializationException 异常                //4. 获取 Order 对象时, 默认情况下, 其关联的 Customer 对象是一个代理对象!            }        public void testBoth(){        Customer customer=new Customer();        Order order=new Order();        Order order2=new Order();                 customer.setCustomerName("AAAAA");        order.setOrderName("aaaaa");        order2.setOrderName("bbbbb");                //设定关联关系        order.setCustomer(customer);        order2.setCustomer(customer);                customer.getOrders().add(order);        customer.getOrders().add(order2);                session.save(customer);        session.save(order);        session.save(order2);            }

private Integer manId;private String manName;    private Department dep;

private Integer depId;private String depName;    private Manager man;

<hibernate-mapping package="com.atguigu.hibernate.one2one.foreign">    <class name="Manager" table="MANAGERS">            <id name="manId" type="java.lang.Integer">            <column name="MAN_ID" />            <generator class="native" />        </id>                <property name="manName" type="java.lang.String">            <column name="MAN_NAME" />        </property>                <!-- 映射 1-1 的关联关系: 在对应的数据表中已经有外键了, 当前持久化类使用 one-to-one 进行映射 -->        <!--         没有外键的一端需要使用one-to-one元素，该元素使用 property-ref 属性指定使用被关联实体主键以外的字段作为关联字段         -->        <one-to-one name="dep" class="Department"></one-to-one>        </class></hibernate-mapping>

<hibernate-mapping package="com.atguigu.hibernate.one2one.foreign">    <class name="Department" table="DEPARTMENTS">            <id name="depId" type="java.lang.Integer">            <column name="DEP_ID" />            <generator class="native" />        </id>                <property name="depName" type="java.lang.String">            <column name="DEP_NAME" />        </property>                <!-- 使用 many-to-one 的方式来映射 1-1 关联关系 ,使用外键的方式，且外键唯一-->        <many-to-one name="man" class="Manager" column="MAN_ID" unique="true"></many-to-one>    </class></hibernate-mapping>

    @Test    public void testGet2(){        //在查询没有外键的实体对象时, 使用的左外连接查询, 一并查询出其关联的对象        //并已经进行初始化.         Manager mgr = (Manager) session.get(Manager.class, 1);        System.out.println(mgr.getManName());         System.out.println(mgr.getDep().getDepId());     }        @Test    public void testGet(){        //1. 默认情况下对关联属性使用懒加载        Department dept = (Department) session.get(Department.class, 1);        System.out.println(dept.getDepName());                 //2. 所以会出现懒加载异常的问题. //        session.close();//        Manager mgr = dept.getMgr();//        System.out.println(mgr.getClass()); //        System.out.println(mgr.getMgrName());                 //3. 查询 Manager 对象的连接条件应该是 dept.manager_id = mgr.manager_id        //而不应该是 dept.dept_id = mgr.manager_id        Manager mgr = dept.getMan();        System.out.println(mgr.getManName());                     }        @Test    public void testone2onesave(){        Department department=new Department();        Manager manager=new Manager();                department.setDepName("AAAAA");        manager.setManName("aaaaaa");                //设定关联关系        department.setMan(manager);        manager.setDep(department);                //保存操作        //建议先保存没有外键列的那个对象. 这样会减少 UPDATE 语句        session.save(manager);        session.save(department);    }

private Integer depId;private String depName;    private Manager man;

private Integer manId;private String manName;    private Department dep;

<hibernate-mapping package="com.atguigu.hibernate.one2one.primary">    <class name="Department" table="DEPARTMENTS">            <id name="depId" type="java.lang.Integer">            <column name="DEPID" />            <!-- 使用外键的方式来生成当前的主键 -->            <generator class="foreign">                <!-- property 属性指定使用当前持久化类的哪一个属性的主键作为外键 -->                <param name="property">man</param>            </generator>        </id>                <property name="depName" type="java.lang.String">            <column name="DEPNAME" />        </property>                <!--          采用 foreign 主键生成器策略的一端增加 one-to-one 元素映射关联属性,        其 one-to-one 节点还应增加 constrained=true 属性, 以使当前的主键上添加外键约束        -->        <one-to-one name="man" class="Manager" constrained="true"></one-to-one>        </class></hibernate-mapping>

<hibernate-mapping package="com.atguigu.hibernate.one2one.primary">    <class name="Manager" table="MANAGERS">            <id name="manId" type="java.lang.Integer">            <column name="MAN_ID" />            <generator class="native" />        </id>                <property name="manName" type="java.lang.String">            <column name="MAN_NAME" />        </property>                <one-to-one name="dep" class="Department"></one-to-one>        </class></hibernate-mapping>

    @Test    public void testGet2(){        //在查询没有外键的实体对象时, 使用的左外连接查询, 一并查询出其关联的对象        //并已经进行初始化.         Manager mgr = (Manager) session.get(Manager.class, 1);        System.out.println(mgr.getManName());         System.out.println(mgr.getDep().getDepId());     }        @Test    public void testGet(){        //1. 默认情况下对关联属性使用懒加载        Department dept = (Department) session.get(Department.class, 1);        System.out.println(dept.getDepId());                 //2. 所以会出现懒加载异常的问题.         Manager mgr = dept.getMan();        System.out.println(mgr.getManName());     }        @Test    public void testSave(){                Department department = new Department();        department.setDepName("DEPT-DD");                Manager manager = new Manager();        manager.setManName("MGR-DD");                //设定关联关系        manager.setDep(department);        department.setMan(manager);                //保存操作        //先插入哪一个都不会有多余的 UPDATE        session.save(department);        session.save(manager);            }

private Integer id;private String name;    private Set<Item> items=new HashSet<Item>();

private Integer id;private String name;    private Set<Category> categorys=new HashSet<Category>();

<hibernate-mapping package="com.atguigu.hibernate.many2many">    <class name="Category" table="CATEGORYS">            <id name="id" type="java.lang.Integer">            <column name="ID" />            <generator class="native" />        </id>                <property name="name" type="java.lang.String">            <column name="NAME" />        </property>                <!-- table: 指定中间表 -->        <set name="items" table="CATEGORY_ITEM">            <key>                <column name="CATEGORY_ID" />            </key>             <!-- 使用 many-to-many 指定多对多的关联关系.              column 执行 Set 集合中的持久化类在中间表的外键列的名称  -->            <many-to-many class="Item" column="ITEM_ID"></many-to-many>        </set>    </class></hibernate-mapping>

<hibernate-mapping package="com.atguigu.hibernate.many2many">    <class name="Item" table="ITEMS">            <id name="id" type="java.lang.Integer">            <column name="ID" />            <generator class="native" />        </id>                <property name="name" type="java.lang.String">            <column name="NAME" />        </property>                <!-- table: 指定中间表 ,inverse="true"维护关联关系-->        <set name="categorys" table="CATEGORY_ITEM" inverse="true">            <key>                <column name="ITEM_ID" />            </key>            <!-- 使用 many-to-many 指定多对多的关联关系.              column 执行 Set 集合中的持久化类在中间表的外键列的名称  -->            <many-to-many class="Category" column="CATEGORY_ID"></many-to-many>        </set>            </class></hibernate-mapping>

    @Test    public void testGet(){        Category category = (Category) session.get(Category.class, 1);        System.out.println(category.getName());                 //需要连接中间表        Set<Item> items = category.getItems();        System.out.println(items.size());     }        @Test    public void testSave(){        Category category1 = new Category();        category1.setName("C-AA");        Category category2 = new Category();        category2.setName("C-BB");                Item item1 = new Item();        item1.setName("I-AA");                Item item2 = new Item();        item2.setName("I-BB");                //设定关联关系        category1.getItems().add(item1);        category1.getItems().add(item2);                category2.getItems().add(item1);        category2.getItems().add(item2);                item1.getCategorys().add(category1);        item1.getCategorys().add(category2);                item2.getCategorys().add(category1);        item2.getCategorys().add(category2);                //执行保存操作        session.save(category1);        session.save(category2);                session.save(item1);        session.save(item2);    }

private Integer id;private String name;private int age;

package com.atguigu.hibernate.subclass;public class Student extends Person{        private String school;    public String getSchool() {        return school;    }    public void setSchool(String school) {        this.school = school;    }    }

<hibernate-mapping package="com.atguigu.hibernate.subclass">    <class name="Person" table="PERSON_STUDENT" discriminator-value="http://www.mamicode.com/PERSON">            <id name="id" type="java.lang.Integer">            <column name="ID" />            <generator class="native" />        </id>                 <!-- 配置辨别者列 -->         <discriminator column="TYPE" type="string"></discriminator>                <property name="name" type="java.lang.String">            <column name="NAME" />        </property>                <property name="age" type="int">            <column name="AGE" />        </property>                <!-- 映射子类 Student, 使用 subclass 进行映射 -->        <subclass name="Student" discriminator-value="http://www.mamicode.com/STUDENT">            <property name="school" type="string" column="SCHOOL"></property>        </subclass>    </class></hibernate-mapping>

    /**     * 缺点:     * 1. 使用了辨别者列.     * 2. 子类独有的字段不能添加非空约束.     * 3. 若继承层次较深, 则数据表的字段也会较多.      */        /**     * 查询:     * 1. 查询父类记录, 只需要查询一张数据表     * 2. 对于子类记录, 也只需要查询一张数据表     */    @Test    public void testQuery(){        List<Person> persons = session.createQuery("FROM Person").list();        System.out.println(persons.size());                 List<Student> stus = session.createQuery("FROM Student").list();        System.out.println(stus.size());     }        /**     * 插入操作:      * 1. 对于子类对象只需把记录插入到一张数据表中.     * 2. 辨别者列有 Hibernate 自动维护.      */    @Test    public void testSave(){                Person person = new Person();        person.setAge(11);        person.setName("AA");                session.save(person);                Student stu = new Student();        stu.setAge(22);        stu.setName("BB");        stu.setSchool("ATGUIGU");                session.save(stu);            }

private Integer id;private String name;private int age;

package com.atguigu.hibernate.joined.subclass;public class Student extends Person{    private String school;    public String getSchool() {        return school;    }    public void setSchool(String school) {        this.school = school;    }    }

<hibernate-mapping package="com.atguigu.hibernate.joined.subclass">    <class name="Person" table="PERSONS">        <id name="id" type="java.lang.Integer">            <column name="ID" />            <generator class="native" />        </id>                <property name="name" type="java.lang.String">            <column name="NAME" />        </property>                <property name="age" type="int">            <column name="AGE" />        </property>                <joined-subclass name="Student" table="STUDENTS">            <key column="STUDENT_id"></key>            <property name="school" type="string" column="SCHOOL"></property>        </joined-subclass>            </class></hibernate-mapping>

/**     * 优点:     * 1. 不需要使用了辨别者列.     * 2. 子类独有的字段能添加非空约束.     * 3. 没有冗余的字段.      */        /**     * 查询:     * 1. 查询父类记录, 做一个左外连接查询     * 2. 对于子类记录, 做一个内连接查询.      */    @Test    public void testQuery(){        List<Person> persons = session.createQuery("FROM Person").list();        System.out.println(persons.size());                 List<Student> stus = session.createQuery("FROM Student").list();        System.out.println(stus.size());     }        /**     * 插入操作:      * 1. 对于子类对象至少需要插入到两张数据表中.      */    @Test    public void testSave(){                Person person = new Person();        person.setAge(11);        person.setName("AA");                session.save(person);                Student stu = new Student();        stu.setAge(22);        stu.setName("BB");        stu.setSchool("ATGUIGU");                session.save(stu);            }

private Integer id;private String name;private int age;

package com.atguigu.hibernate.joined.subclass;public class Student extends Person{    private String school;    public String getSchool() {        return school;    }    public void setSchool(String school) {        this.school = school;    }    }

<hibernate-mapping package="com.atguigu.hibernate.union.subclass">    <class name="Person" table="PERSONS">        <id name="id" type="java.lang.Integer">            <column name="ID" />            <generator class="hilo" />        </id>                <property name="name" type="java.lang.String">            <column name="NAME" />        </property>                <property name="age" type="int">            <column name="AGE" />        </property>            <union-subclass name="Student" table="STUDENTS">            <property name="school" column="SCHOOL" type="string"></property>        </union-subclass>                    </class></hibernate-mapping>

@Test    public void testUpdate(){        String hql = "UPDATE Person p SET p.age = 20";        session.createQuery(hql).executeUpdate();    }        /**     * 优点:     * 1. 无需使用辨别者列.     * 2. 子类独有的字段能添加非空约束.     *      * 缺点:     * 1. 存在冗余的字段     * 2. 若更新父表的字段, 则更新的效率较低     */        /**     * 查询:     * 1. 查询父类记录, 需把父表和子表记录汇总到一起再做查询. 性能稍差.      * 2. 对于子类记录, 也只需要查询一张数据表     */    @Test    public void testQuery(){        List<Person> persons = session.createQuery("FROM Person").list();        System.out.println(persons.size());                 List<Student> stus = session.createQuery("FROM Student").list();        System.out.println(stus.size());     }        /**     * 插入操作:      * 1. 对于子类对象只需把记录插入到一张数据表中.     */    @Test    public void testSave(){                Person person = new Person();        person.setAge(11);        person.setName("AA");                session.save(person);                Student stu = new Student();        stu.setAge(22);        stu.setName("BB");        stu.setSchool("ATGUIGU");                session.save(stu);            }