package cn.itcast.entity;

public class User {

    /*hibernate要求实体类有一个属性唯一的*/

//    private int uid;

    private String uid;

    private String username;

    private String password;

    private String address;

//    public int getUid() {

//        return uid;

//    }

//    public void setUid(int uid) {

//        this.uid = uid;

//    }

    public String getUsername() {

        return username;

    }

    public String getUid() {

        return uid;

    }

    public void setUid(String uid) {

        this.uid = uid;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public String getAddress() {

        return address;

    }

    public void setAddress(String address) {

        this.address = address;

    }

}

<hibernate-mapping>

    <!-- 1 配置类和表对应

        class标签

        name属性：实体类全路径

        table属性：数据库表名称

    -->

    <class name="cn.itcast.entity.User" table="t_user">

        <!-- 2 配置实体类id和表id对应

            hibernate要求实体类有一个属性唯一值

            hibernate要求表有字段作为唯一值

        -->

        <!-- id标签

            name属性：实体类里面id属性名称

            column属性：生成的表字段名称

         -->

        <id name="uid" column="uid">

            <!-- 设置数据库表id增长策略

                native:生成表id值就是主键自动增长

            -->

            <generator class="native"></generator>

        </id>

        <!-- 配置其他属性和表字段对应

            name属性：实体类属性名称

            column属性：生成表字段名称

        -->

        <property name="username" column="username"></property>

        <property name="password" column="password"></property>

        <property name="address" column="address"></property>

    </class>

</hibernate-mapping>

<?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="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

        <property name="hibernate.connection.url">jdbc:mysql:///hibernate_day01</property>

        <property name="hibernate.connection.username">root</property>

        <property name="hibernate.connection.password">root</property>

        <!-- 第二部分： 配置hibernate信息  可选的-->

        <!-- 输出底层sql语句 -->

        <property name="hibernate.show_sql">true</property>

        <!-- 输出底层sql语句格式 -->

        <property name="hibernate.format_sql">true</property>

        <!-- hibernate帮创建表，需要配置之后

            update: 如果已经有表，更新，如果没有，创建

        -->

        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 配置数据库方言

            在mysql里面实现分页 关键字 limit，只能使用mysql里面

            在oracle数据库，实现分页rownum

            让hibernate框架识别不同数据库的自己特有的语句

         -->

        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- 第三部分： 把映射文件放到核心配置文件中 必须的-->

        <mapping resource="cn/itcast/entity/User.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

@Test

    public void testAdd() {

//        第一步 加载hibernate核心配置文件

        // 到src下面找到名称是hibernate.cfg.xml

        //在hibernate里面封装对象

        Configuration cfg = new Configuration();

        cfg.configure();

//        第二步 创建SessionFactory对象

        //读取hibernate核心配置文件内容，创建sessionFactory

        //在过程中，根据映射关系，在配置数据库里面把表创建

        SessionFactory sessionFactory = cfg.buildSessionFactory();

//        第三步 使用SessionFactory创建session对象

        // 类似于连接

        Session session = sessionFactory.openSession();

//        第四步 开启事务

        Transaction tx = session.beginTransaction();

//        第五步 写具体逻辑 crud操作

        //添加功能

        User user = new User();

        user.setUsername("小王");

        user.setPassword("250");

        user.setAddress("日本");

        //调用session的方法实现添加

        session.save(user);

//        第六步 提交事务

        tx.commit();

//        第七步 关闭资源

        session.close();

        sessionFactory.close();

    }

@Test

    public void testTx() {

        SessionFactory sessionFactory = null;

        Session session = null;

        Transaction tx = null;

        try {

            sessionFactory = HibernateUtils.getSessionFactory();

            session = sessionFactory.openSession();

            //开启事务

            tx = session.beginTransaction();

            //添加

            User user = new User();

            user.setUsername("小马");

            user.setPassword("250");

            user.setAddress("美国");

            session.save(user);

            int i = 10/0;

            //提交事务

            tx.commit();

        }catch(Exception e) {

            e.printStackTrace();

            //回滚事务

            tx.rollback();

        }finally {

            //关闭操作

            session.close();

            sessionFactory.close();

        }

    }

//使用hibernate实现查询列表

    public List<Customer> findAll() {

        SessionFactory sessionFactory = null;

        Session session = null;

        Transaction tx = null;

        try {

            //得到sessionFactory

            sessionFactory = HibernateUtils.getSessionFactory();

            //得到session

            session = sessionFactory.openSession();

            //开启事务

            tx = session.beginTransaction();

            //查询所有记录

            Criteria criteria = session.createCriteria(Customer.class);

            List<Customer> list = criteria.list();

            //提交事务

            tx.commit();

            return list;

        }catch(Exception e) {

            tx.rollback();

        }finally {

            session.close();

            //sessionFactory不需要关闭

//            sessionFactory.close();

        }

        return null;

    }

//演示一对多级联保存

    @Test

    public void testAddDemo1() {

        SessionFactory sessionFactory = null;

        Session session = null;

        Transaction tx = null;

        try {

            //得到sessionFactory

            sessionFactory = HibernateUtils.getSessionFactory();

            //得到session

            session = sessionFactory.openSession();

            //开启事务

            tx = session.beginTransaction();

            // 添加一个客户，为这个客户添加一个联系人

            //1 创建客户和联系人对象

            Customer customer = new Customer();

            customer.setCustName("传智播客");

            customer.setCustLevel("vip");

            customer.setCustSource("网络");

            customer.setCustPhone("110");

            customer.setCustMobile("999");

            LinkMan linkman = new LinkMan();

            linkman.setLkm_name("lucy");

            linkman.setLkm_gender("男");

            linkman.setLkm_phone("911");

            //2 在客户表示所有联系人，在联系人表示客户

            // 建立客户对象和联系人对象关系

            //2.1 把联系人对象 放到客户对象的set集合里面

            customer.getSetLinkMan().add(linkman);

            //2.2 把客户对象放到联系人里面

            linkman.setCustomer(customer);

            //3 保存到数据库

            session.save(customer);

            session.save(linkman);

            //提交事务

            tx.commit();

        }catch(Exception e) {

            tx.rollback();

        }finally {

            session.close();

            //sessionFactory不需要关闭

            sessionFactory.close();

        }

    }

//演示一对多级联保存

    @Test

    public void testAddDemo2() {

        SessionFactory sessionFactory = null;

        Session session = null;

        Transaction tx = null;

        try {

            //得到sessionFactory

            sessionFactory = HibernateUtils.getSessionFactory();

            //得到session

            session = sessionFactory.openSession();

            //开启事务

            tx = session.beginTransaction();

            // 添加一个客户，为这个客户添加一个联系人

            //1 创建客户和联系人对象

            Customer customer = new Customer();

            customer.setCustName("百度");

            customer.setCustLevel("普通客户");

            customer.setCustSource("网络");

            customer.setCustPhone("110");

            customer.setCustMobile("999");

            LinkMan linkman = new LinkMan();

            linkman.setLkm_name("小宏");

            linkman.setLkm_gender("男");

            linkman.setLkm_phone("911");

            //2 把联系人放到客户里面

            customer.getSetLinkMan().add(linkman);

            //3 保存客户

            session.save(customer);

            //提交事务

            tx.commit();

        }catch(Exception e) {

            tx.rollback();

        }finally {

            session.close();

            //sessionFactory不需要关闭

            sessionFactory.close();

        }

    }

//演示多对多修级联保存

    @Test

    public void testSave() {

        SessionFactory sessionFactory = null;

        Session session = null;

        Transaction tx = null;

        try {

            //得到sessionFactory

            sessionFactory = HibernateUtils.getSessionFactory();

            //得到session

            session = sessionFactory.openSession();

            //开启事务

            tx = session.beginTransaction();

            //添加两个用户，为每个用户添加两个角色

            //1 创建对象

            User user1 = new User();

            user1.setUser_name("lucy");

            user1.setUser_password("123");

            User user2 = new User();

            user2.setUser_name("mary");

            user2.setUser_password("456");

            Role r1 = new Role();

            r1.setRole_name("总经理");

            r1.setRole_memo("总经理");

            Role r2 = new Role();

            r2.setRole_name("秘书");

            r2.setRole_memo("秘书");

            Role r3 = new Role();

            r3.setRole_name("保安");

            r3.setRole_memo("保安");

            //2 建立关系，把角色放到用户里面

            // user1 -- r1/r2

            user1.getSetRole().add(r1);

            user1.getSetRole().add(r2);

            // user2 -- r2/r3

            user2.getSetRole().add(r2);

            user2.getSetRole().add(r3);

            //3 保存用户

            session.save(user1);

            session.save(user2);

            //提交事务

            tx.commit();

        }catch(Exception e) {

            tx.rollback();

        }finally {

            session.close();

            //sessionFactory不需要关闭

            sessionFactory.close();

        }

    }