hibernate基本的配置-xml(实体映射)和简单使用

Java是面向对象的语言。
操作数据库本来可以直接用jdbc：
1.导入相关jar包

private static Connection getConnection() {
    String driver = "com.mysql.jdbc.Driver";
    String url = "jdbc:mysql://localhost:3306/db";
    String username = "root";
    String password = "123456";
    Connection conn = null;
    try {
        Class.forName(driver); //classLoader,加载对应驱动
        conn = (Connection) DriverManager.getConnection(url, username, password);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return conn;
}

以上用反射加载jdbc驱动，然后获取connection连接，接下来使用这个连接建立sql操作：new一个Statement，一个ResultSet，前者用来executeSQL语句，后来用来收集返回的结果，并把结果和实体类的字段一一对应。
在每次获取连接时候其实都是新建一个新的连接，非常耗性能，所以可以使用连接池来解决。
不管怎么样，以上的查询都是要自己手动一个个配置参数的，非常的不面向对象。hibernate在此基础上封装和优化，利用ORM思想，对象关系映射，把一个实体和数据库中的一个表对应起来，字段映射，所以在执行增删改查操作的时候可以不用管繁琐的字段，直接用一个方法传一个类就可以了。
对象关系映射也有一些难题，就是对象和表如何映射，之间的关系不太明了，如果创建一个实体类，和如何映射。但是它有效的提高了效率。
相关jar：

在包里建一个实体user，然后同包下建一个user.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    <!-- ORM元数据  表对象关系映射文件 
        package : 配置该配置文件中类所在的包.  -->
 <hibernate-mapping package="com.itheima.a_hello" >
    <!-- class: 配置实体与表的关系
        name : 填写实体的完整类名
        table: 与实体对应表的名称
        dynamic-insert:动态插入 默认值是false
                        true=>如果字段值为null,不参与insert语句
         dynamic-update:动态更新  默认值"false"
                        true=> 没改动过的属性,将不会生成到update语句中
     -->
    <class name="User" table="t_user"  >
        <!-- id: 配置实体与表中 id对应
            name: user对象中标识主键的属性名称
            column: 主键在表中的列名
            length: 列的数据长度
            unsaved-value(不常用): 指定主键为什么值时,当做null来处理.
            access(强烈推荐不要用):field 那么在操作属性时,会直接操作对应的字段而不是get/set方法
         -->
        <id name="id" column="id" length="255"   >
            <!-- generator:主键生成策略
                    1.increment  数据库自己生成主键. 先从数据库中查询最大的ID值,将ID值加1作为新的主键
                    2.identity  依赖于数据的主键自增功能
                    3.sequence  序列,依赖于数据中的序列功能(Oracle).
                    4.hilo(纯了解,永远用不到) : Hibernate自己实现序列的算法,自己生成主键. (hilo算法 )
                    5.native 自动根据数据库判断,三选一. identity|sequence|hilo
                    6.uuid  生成32位的不重复随机字符串当做主键
                    7.assigned 自己指定主键值. 表的主键是自然主键时使用.

             -->
            <generator class="uuid"></generator>
        </id>   
        <!-- property : 实体中属性与表中列的对应
             name : 实体中属性名称
             column : 表中列的名称
             length : 数据长度
             precision: 小数点后的精度
             scale: 有效位数
             insert(一般不用): 该属性是否加入insert语句.
             update(一般不用): 该属性是否加入update语句.
             not-null : 指定属性的约束是否使用 非空
             unique : 指定属性的约束是否使用 唯一
         -->
         <!-- 
            type: 表达该属性的类型
            可以用三种方式指定属性
            java类型               数据库类型指定            Hibernate类型指定
            java.lang.String    varchar             string
          -->
        <property name="name" column="name" update="true" type="string" ></property>
        <property name="password" column="password"></property>
         <property name="sal" column="sal" precision="2" scale="3" ></property>
    </class>
 </hibernate-mapping>

其实就是hibernate-mapping ，把类和表名对应，字段和表的列匹配。

接下来在src包下建hibernate.cfg.xml,把刚才上面的xml配置进去：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!-- property 元素用于配置Hibernate中的属性
            键:值 
          -->
          <!-- hibernate.connection.driver_class : 连接数据库的驱动  -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
          <!-- hibernate.connection.username : 连接数据库的用户名 -->
        <property name="hibernate.connection.username">root</property>
          <!-- hibernate.connection.password : 连接数据库的密码 -->
        <property name="hibernate.connection.password">1234</property>
          <!-- hibernate.connection.url : 连接数据库的地址,路径 -->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/db</property>

        <!-- show_sql: 操作数据库时,会 向控制台打印sql语句 -->
        <property name="show_sql">true</property>
        <!-- format_sql: 打印sql语句前,会将sql语句先格式化  -->
        <property name="format_sql">true</property>
        <!-- hbm2ddl.auto: 生成表结构的策略配置
             update(最常用的取值): 如果当前数据库中不存在表结构,那么自动创建表结构. 
                    如果存在表结构,并且表结构与实体一致,那么不做修改
                    如果存在表结构,并且表结构与实体不一致,那么会修改表结构.会保留原有列.
             create(很少):无论是否存在表结构.每次启动Hibernate都会重新创建表结构.(数据会丢失)
             create-drop(极少): 无论是否存在表结构.每次启动Hibernate都会重新创建表结构.每次Hibernate运行结束时,删除表结构.
             validate(很少):不会自动创建表结构.也不会自动维护表结构.Hibernate只校验表结构. 如果表结构不一致将会抛出异常.
          -->
        <property name="hbm2ddl.auto">update</property>

        <!-- 数据库方言配置 
         org.hibernate.dialect.MySQLDialect (选择最短的)
         -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>



        <!-- hibernate.connection.autocommit: 事务自动提交  -->
        <property name="hibernate.connection.autocommit">true</property>
        <!-- 将Session与线程绑定=> 只有配置了该配置,才能使用getCurrentSession -->
        <property name="hibernate.current_session_context_class">thread</property>
        <!-- 引入ORM 映射文件 
            填写src之后的路径
         -->
        <mapping resource="com/itheima/a_hello/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

配置完毕，开始写代码：
使用org.hibernate.SessionFactory.openSession()返回一个org.hibernate.Session。（SessionFactory是线程安全的）
这个session的方法有save(Object o),delete,get(class,id),load(…)等等，直接把实体类实例作为参数就可以。
方法连起来用：

List list = createQuery(queryString).setEntity(class).setString(0,id).list();

另外可以在hibernate中配置自有的或者外加的连接池。
常用：

SessionFactory工厂:
SessionFactory 相当于java web连接池，用于管理所有session。
Session 会话:
Session 相当于 JDBC的 Connection -- 会话，非线程安全
Transaction 事务:
开启事务 beginTransaction()
获得事务 getTransaction()
提交事务：commit()
回滚事务：rollback()
Query对象:
createQuery("hql")获得，然后调用方法uniqueResult()或者list（）。

Hibernate中持久化类的字段类型最好使用基本类的包装类。生成getter和setter方法。

相关方法和hql语句使用：
查询记录总数：

Query query = session.createQuery("select count(cid) from Customer");
Long numLong = (Long) query.uniqueResult();
int num = numLong.intValue();

分页查询：

        session.beginTransaction();
        Query query = session.createQuery("from Customer");
        // limit 0,10;
        query.setFirstResult(0);
        query.setMaxResults(10);
        List<User> allUser = query.list();
        session.getTransaction().commit();
        session.close();

绑定参数:

Query query = session.createQuery("from Customer where cid = :xxx");
query.setInteger("xxx", cid);
或者：
query.setParameter("xxx", cid);
query.uniqueResult();

投影查询（实体必须提供相应构造函数，可自选字段）：

Query query = session.createQuery("select new Customer(c.cid,c.cname,...) from Customer c");
List<Customer> allCustomer = query.list();

hql连接查询：
1.交叉连接 ，等效 sql 笛卡尔积
2.隐式内连接，等效 sql 隐式内连接
3.内连接，等效sql内连接
4.迫切内连接，hibernate底层使用 内连接。
5.左外连接，等效sql左外连接
6.迫切左外连接，hibernate底层使用 左外连接
7.右外连接，等效sql右外连接

QBC:Query By Criteria：面向对象的查询的方式：

List<Customer> list = session.createCriteria(Customer.class).list();

或者：

Criteria criteria =session.createCriteria(Student.class);
Criterion criterion1 = Expression.like("name","王%");
Criterion criterion2 = Expression.eq("age",newInteger(22));
criteria.add(criterion1).add(criterion2);//重点
List list = criteria.list();

另一种用法：

 session.createCriteria(Student.class)
      .add(Restrictions.eq("age",new Integer(20)).list();

常用限定方法：
Restrictions.eq –> equal,等于.

Restrictions.allEq –> 参数为Map对象,使用key/value进行多个等于的比对,相当于多个Restrictions.eq的效果

Restrictions.gt –> great-than > 大于

Restrictions.ge –> great-equal >= 大于等于

Restrictions.lt –> less-than, < 小于

Restrictions.le –> less-equal <= 小于等于

Restrictions.between –> 对应SQL的between子句

Restrictions.like –> 对应SQL的LIKE子句

Restrictions.in –> 对应SQL的in子句

Restrictions.and –> and 关系

Restrictions.or –> or 关系

Restrictions.isNull –> 判断属性是否为空,为空则返回true

Restrictions.isNotNull –> 与isNull相反