Hibernate常见操作一

Hibernate是一种ORM框架，对JDBC进行了轻量级的封装，Hibernate充当持久层，通过配置XML文件来描述对象之间的关系。

单表手动配置Hibernate:

1.导入Hibernate Jar包（可选择自动生成SessionFactory类，可选择自动生成hibernate.cfg.xml文件）

2.建立POJO表(包含getset方法，当涉及数据传输时可继承Serializable接口实现序列化)

3.建立XML文件来映射POJO对象和数据库的表的关系

hibernate.cfg.xml:

<?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>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.username">root</property>
<property name="connection.password">admin</property>
<property name="connection.url">jdbc:mysql://127.0.0.1:3306/test</property>

<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 显示出对于sql -->
    <property name="show_sql">true</property>
    <!-- 让hibernate给我们自动创建表 create :如果没有该表则创建. -->
    <property name="hbm2ddl.auto">update</property>
    <!-- 关联xml文件 -->
<mapping resource="com/wsy/domain/Employee.hbm.xml"/>
</session-factory>
</hibernate-configuration>

POJO:

package com.wsy.domain;

import java.util.Date;

public class Employee {
private int id;
private String name;
private String email;
public int getId() {
    return id;
}
public void setId(int id) {
    this.id = id;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public String getEmail() {
    return email;
}
public void setEmail(String email) {
    this.email = email;
}

}

 

Emloyee对象相应的xml文件

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    
    <hibernate-mapping package="com.wsy.domain"> <!-- package默认为xml文件所在文件夹 -->
    <class name="Employee" table="employee">     <!-- name属性为对象名，table为数据库表名 -->
    <id name="id" column="id" type="java.lang.Integer"> <!-- id为主键  -->
    <generator class="increment"></generator>          <!-- mysql中使用increment来设定主键增长 -->
    </id>
    <property name="name" type="java.lang.String">      <!-- 配置其它属性,此处name为对象成员名 -->
    <column name="name" not-null="false"></column>        <!-- 此处name为数据库表的列名 -->
    </property>
    <property name="email" type="java.lang.String">
    <column name="email" not-null="false"></column>
    </property>
    </class>
    </hibernate-mapping>

配置完成，测试程序如下:

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.wsy.domain.Employee;

public class Test {
    public static void main(String[] args) {
        //创建Configuration对象，读取hibernate.cfg.xml文件，并进行初始化
        Configuration configuration=new Configuration().configure();
        //创建会话工厂
        SessionFactory sessionFactory=configuration.buildSessionFactory();
        //创建一个Session会话
        Session session=sessionFactory.openSession();
        //查询不需要事务，增删改需要使用事务提交
        Transaction transaction=session.beginTransaction();
        //创建对象
        Employee employee=new Employee();
        employee.setName("wsy");
        employee.setEmail("949724126@qq.com");
        //持久化该对象，保存至数据库中
        session.save(employee);
        //事务提交
        transaction.commit();
        //关闭Session会话
        session.close();
    }
}

 

---

 

单表自动配置Hibernate:

1.导入Hibernate,自动生成Hibernate.cfg.xml文件,自动生成SessionFactory

2.在数据库中建立表

3.此处应如此选择。

 

---

 

单表增删改查:

代码如下:

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.wsy.SessionFactory.HibernateSessionFactory;
import com.wsy.domain.Course;
import com.wsy.domain.Employee;
import com.wsy.domain.Stucourse;
import com.wsy.domain.Student;

public class Test {

    /**
     * @param args
     */
    public static Transaction t=null;
    public static Session session=null;
    public static void main(String[] args) {
            System.exit(0);
    }
    
    public static int Add(ArrayList<Employee> list) //增(批量)
    {
        int flag=0;
        try {
            session=HibernateSessionFactory.getSession();
            t=session.beginTransaction();
            if(list.isEmpty())
            {
                flag=0;
                System.out.println("数据集没有数据");
            }
            else {
                flag=1;
                for (Employee employee : list) {
                    session.save(employee);
                }
                t.commit();
            }
        } catch (Exception e) {
            flag=0;
            e.printStackTrace();
            if(t!=null)
            {
                t.rollback();
            }
        }finally
        {
            if(session!=null&session.isOpen())
            {
                session.close();
            }
            return flag;
        }
        
    }
    
    public static int Delete(ArrayList<Integer> list)//删除(批量)
    {
        int flag=0;
        try {
            session=HibernateSessionFactory.getSession();
            t=session.beginTransaction();
            if(list.isEmpty())
            {
                flag=0;
                System.out.println("程序集中没有数据");
            }
            else {
                flag=1;
                for (Integer integer : list) {
                    Employee emp=(Employee) session.get(Employee.class, integer);
                    session.delete(emp);
                }
                t.commit();
            }
        } catch (Exception e) {
            flag=0;
            e.printStackTrace();
            if(t!=null)
            {
                t.rollback();
            }
        }finally
        {
            if(session!=null&session.isOpen())
            {
                session.close();
            }
            return flag;
        }
    }
    
    public static int Update(int num)//修改(单)
    {
        int flag=0;
        try {
            session=HibernateSessionFactory.getSession();
            t=session.beginTransaction();
            Employee employee=(Employee) session.load(Employee.class, num);
            employee.setEmail("1244014227@qq.com");
            session.update(employee);
            t.commit();
            flag=1;
        } catch (Exception e) {
            flag=0;
            e.printStackTrace();
            if(t!=null)
            {
                t.rollback();
            }
        }finally
        {
            if(session!=null&session.isOpen())
            {
                session.close();
            }
            return flag;
        }
    }
    
    public static ArrayList<Employee> Select(String hql)//查询
    {
        ArrayList<Employee> list=new ArrayList<Employee>();
        try {
            session=HibernateSessionFactory.getSession();
            t=session.beginTransaction();
            Query query=session.createQuery(hql);
            list=(ArrayList<Employee>) query.list();
            t.commit();
        } catch (Exception e) {
            e.printStackTrace();
            if(t!=null)
            {
                t.rollback();
            }
        }finally
        {
            if(session!=null&session.isOpen())
            {
                session.close();
            }
            return list;
        }
    }
    
}

---

 

Hibernate对象的关系映射通常情况下有3种，one to one ,many to one(one to many),many to many

One to One

1.基于主键的One to One模型，此情况较为少见。

POJO表如下:

IdCard:

package com.wsy.domain;

import java.io.Serializable;
import java.util.Date;

public class IdCard implements Serializable{
/**
     * 
     */
    private static final long serialVersionUID = 1L;
private Integer id;
private Date validateDte;
private Person person;
public Integer getId() {
    return id;
}
public void setId(Integer id) {
    this.id = id;
}
public Date getValidateDte() {
    return validateDte;
}
public void setValidateDte(Date validateDte) {
    this.validateDte = validateDte;
}
public Person getPerson() {
    return person;
}
public void setPerson(Person person) {
    this.person = person;
}
}

Person:

package com.wsy.domain;

import java.io.Serializable;

public class Person implements Serializable{
/**
     * 
     */
    private static final long serialVersionUID = 1L;
private Integer id;
private String name;
private IdCard idCard;
public Integer getId() {
    return id;
}
public void setId(Integer id) {
    this.id = id;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public IdCard getIdCard() {
    return idCard;
}
public void setIdCard(IdCard idCard) {
    this.idCard = idCard;
}
}

IdCard.hbm.xml:

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.wsy.domain">
<class name="IdCard" table="idCard">
<id name="id" type="java.lang.Integer">
<!-- 此处为基于主键的one to one 配置 -->
<!-- <generator class="foreign">
<param name="property">person</param>
</generator> -->
<!-- 此处为基于外键的one to one 配置，设置id为主键，自增长 -->
<generator class="assigned"></generator>
</id>
<property name="validateDte" type="java.util.Date">
<column name="validateDte"></column>
</property>
<!-- 此处为基于主键的one to one配置，constrained是设置是否生成外键 -->
<!-- <one-to-one name="person" constrained="true"></one-to-one> -->
<!-- 此处是基于外键的one to one配置,注意person是指IdCard对象中的成员名 -->
<many-to-one name="person" unique="true"></many-to-one>
</class>
</hibernate-mapping>

Person.hbm.xml:

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.wsy.domain">
<class name="Person" table="person">
<id name="id" type="java.lang.Integer">
<generator class="increment"></generator>
</id>
<property name="name" type="java.lang.String">
<column name="name"></column>
</property>
<!-- idCard是Person类中成员名 -->
<one-to-one name="idCard"></one-to-one>
</class>
</hibernate-mapping>

---

以上代码经测试可以直接运行