第二章 策略及对象增删改查操作

Generator 主键生成器
increment
用于为long, short或者int类型生成 唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用。 在集群下不要使用。
identity
对DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的内置标识字段提供支持。 返回的标识符是long, short 或者int类型的。
sequence
在DB2,PostgreSQL, Oracle, SAP DB, McKoi中使用序列（sequence)， 而在Interbase中使用生成器(generator)。返回的标识符是long, short或者 int类型的。
hilo
使用一个高/低位算法高效的生成long, short 或者 int类型的标识符。给定一个表和字段（默认分别是 hibernate_unique_key 和next_hi）作为高位值的来源。 高/低位算法生成的标识符只在一个特定的数据库中是唯一的。
seqhilo
使用一个高/低位算法来高效的生成long, short 或者 int类型的标识符，给定一个数据库序列（sequence)的名字。
uuid
用一个128-bit的UUID算法生成字符串类型的标识符， 这在一个网络中是唯一的（使用了IP地址）。UUID被编码为一个32位16进制数字的字符串。
guid
在MS SQL Server 和 MySQL 中使用数据库生成的GUID字符串。
native
根据底层数据库的能力选择identity, sequence 或者hilo中的一个。
assigned
让应用程序在save()之前为对象分配一个标示符。这是 <generator>元素没有指定时的默认生成策略。
select
通过数据库触发器选择一些唯一主键的行并返回主键值来分配一个主键。
foreign
使用另外一个相关联的对象的标识符。通常和<one-to-one>联合起来使用。
sequence-identity
一种特别的序列生成策略,使用数据库序列来生成实际值,但将它和JDBC3的getGeneratedKeys结合在一起,使得在插入语句执行的时候就返回生成的值。目前为止只有面向JDK 1.4的Oracle 10g驱动支持这一策略。注意，因为Oracle驱动程序的一个bug，这些插入语句的注释被关闭了。

我们需要掌握的主键生成器
uuid
用一个128-bit的UUID算法生成字符串类型的标识符， 这在一个网络中是唯一的（使用了IP地址）。UUID被编码为一个32位16进制数字的字符串。 UUID包含：IP地址，JVM的启动时间（精确到1/4秒），系统时间和一个计数器值（在JVM中唯一）。 在Java代码中不可能获得MAC地址或者内存地址，所以这已经是我们在不使用JNI的前提下的能做的最好实现了。

native
根据底层数据库的能力选择identity, sequence 或者hilo中的一个。 如果数据库对应的字段是自增型的,可以用此主键策略.

assigned
让应用程序在save()之前为对象分配一个标示符。这是 <generator>元素没有指定时的默认生成策略。

需要注意的地方:
<!-- 是否自动创建对应的数据库表-->
<property name="hbm2ddl.auto">create</property>
这个开关,我们现在暂时最好不要用,因为每次程序启动,会先执行drop table语句.会将先前的数据删除掉.

下面我们来看这几种主键生成器的用法
CREATE TABLE `users` (
`userId` int NOT NULL auto_increment, 
`userName` varchar(255) default NULL, 
`userPwd` varchar(255) default NULL, 
PRIMARY KEY  (`userId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
在MySQL中建立此表, 注意userId在这里是int型,并自增.

编写User.hbm.xml, hibernate.cfg.xml两个配置文件,配置文件中这里变动一下:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
<class name="chapter1.model.User" table="Users">
<id name="userId" type="java.lang.Integer" column="userId">
<generator class="native" />
</id>
<property name="userName" type="java.lang.String" column="userName" />
<property name="userPwd" type="java.lang.String" column="userPwd" />
</class>
</hibernate-mapping>
注意,因为type这里我们用到了Integer,所以我们在Model类中也应该用Integer,其实用int也可以,因为Java有自动的装箱拆箱操作.
package chapter1.model;

public class User {
private Integer userId;
private String userName;
private String userPwd;

public User() {
super();
}

public User(String userName, String userPwd) {
super();
this.userName = userName;
this.userPwd = userPwd;
}

public Integer getUserId() {
return userId;
}

public void setUserId(Integer userId) {
this.userId = userId;
}

public String getUserName() {
return userName;
}

public void setUserName(String userName) {
this.userName = userName;
}

public String getUserPwd() {
return userPwd;
}

public void setUserPwd(String userPwd) {
this.userPwd = userPwd;
}
}
Dao层我们不动:
package chapter1.dao;
import org.hibernate.Session;
import chapter1.model.User;
import commons.util.HibernateUtil;
public class UserDao {
public void create(User user) {
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
session.save(user);
session.getTransaction().commit();
}

public static void main(String[] args) {
UserDao userDao = new UserDao();
User user = new User("zhanghaidang2", "791126");
userDao.create(user);
}
}
可以看到主键按自增方式增长,符合我们平时的习惯.
但是从现在开始,我建议大家使用uuid.hex方式生成主键.

Hibernate的Session中几个常用的方法
save:保存对象
update:更新对象
delete:删除对象
get:获取单个对象
createQuery:获取对象的集合
saveOrUpdate: 根据ID的值是否为空,自动调用save或update方法来更新对象.

注意的地方:Hibernate中事务的使用规则, save,update,delete这些操作涉及到数据库中数据的更改,一定要用事务进行提交, get, createQuery用于查询对象,可以不用事务.

 下面我们来看一下对单张表的增删改查的操作.
首先,我们得更换我们HibernateUtil类为MyEclipse生成的类
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
private static Configuration configuration = new Configuration();
private static org.hibernate.SessionFactory sessionFactory;
private static String configFile = CONFIG_FILE_LOCATION;

static {
try {
configuration.configure(configFile);
sessionFactory = configuration.buildSessionFactory();
} catch (Exception e) {
System.err.println("%%%% Error Creating SessionFactory %%%%");
e.printStackTrace();
}
}

private HibernateUtil() {
}

public static Session getSession() throws HibernateException {
Session session = (Session) threadLocal.get();

if (session == null || !session.isOpen()) {
if (sessionFactory == null) {
rebuildSessionFactory();
}
session = (sessionFactory != null) ? sessionFactory
.getCurrentSession() : null;
threadLocal.set(session);
}

return session;
}

public static void rebuildSessionFactory() {
try {
configuration.configure(configFile);
sessionFactory = configuration.buildSessionFactory();
} catch (Exception e) {
System.err.println("%%%% Error Creating SessionFactory %%%%");
e.printStackTrace();
}
}

public static void closeSession() throws HibernateException {
Session session = (Session) threadLocal.get();
threadLocal.set(null);

if (session != null) {
session.close();
}
}

public static org.hibernate.SessionFactory getSessionFactory() {
return sessionFactory;
}

public static void setConfigFile(String configFile) {
HibernateUtil.configFile = configFile;
sessionFactory = null;
}

public static Configuration getConfiguration() {
return configuration;
}
}

首先在MySQL中建一个student表
CREATE TABLE `students` ( 
`id` varchar(32) NOT NULL, 
`name` varchar(32) default NULL, 
`age` int(11) default NULL, 
`birthday` datetime default NULL, 
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

 增
public class StudentDao {
public void insertStudent(Student student) {
Session session = HibernateUtil.getSessionfactory().getCurrentSession();
try {
session.beginTransaction();
session.save(student);
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
}
}

public static void main(String[] args) throws ParseException {
StudentDao sd = new StudentDao();
// 方式一:
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse("1988-10-22");
Student student1 = new Student("张三", 22, new java.sql.Date(date
.getTime()));
sd.insertStudent(student1);

// 方式二:
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR, 1988);
calendar.set(Calendar.MONTH, 0);
calendar.set(Calendar.DAY_OF_MONTH, 21);
Student student2 = new Student("李四", 22, new java.sql.Date(calendar
.getTimeInMillis()));

sd.insertStudent(student2);
}
}

 删
public boolean deleteStudent(Student student) {
Session session = HibernateUtil.getSession();
try {
session.beginTransaction();
session.delete(student);
session.getTransaction().commit();
return true;
} catch (Exception e) {
session.getTransaction().rollback();
return false;
}
}

public static void main(String[] args) throws ParseException {
StudentDao sd = new StudentDao();
Student student = new Student();
student.setId("40285c812789f09c012789f09e9c0002");
sd.deleteStudent(student);
}

 改
public boolean updateStudent(Student student) {
Session session = HibernateUtil.getSession();
try {
session.beginTransaction();
session.update(student);
session.getTransaction().commit();
return true;
} catch (Exception e) {
session.getTransaction().rollback();
return false;
}
}

public Student findStudentById(Student student) {
Session session = HibernateUtil.getSession();
Student temp = null;
try {
session.beginTransaction();
temp = (Student) session.get(Student.class, student.getId());
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
}
return temp;
}

public static void main(String[] args) throws ParseException {
StudentDao sd = new StudentDao();
Student student = new Student();
student.setId("40285c812789f09c012789f09e9c0002");
Student temp = sd.findStudentById(student);
temp.setName("张亚当");
sd.updateStudent(temp);
}

 查
HQL查询所有的学生信息:
public List<Student> findStudentAll() {
List<Student> list = null;
Session session = HibernateUtil.getSession();
try {
session.beginTransaction();
list = session.createQuery("from Student").list();
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
}
return list;
}

public static void main(String[] args) throws ParseException {
StudentDao sd = new StudentDao();
List<Student> list = sd.findStudentAll();

for (Student s : list) {
System.out.println(s);
}
}
HQL基本查询语句有以下几种：
1.from 类名；
2.from 类名 as 别名；
3.from 类名 别名；
4.select 别名 from 类名 别名；
注意：HQL不支持“select * from 表名”这种查询语句。


SQL查询所有学生(建议不要使用)
public List<Student> findStudentAllBySQL() {
List<Student> list = null;
Session session = HibernateUtil.getSession();
try {
session.beginTransaction();
SQLQuery sqlQuery = session.createSQLQuery("select * from students");
list = sqlQuery.addEntity(Student.class).list();
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
}
return list;
}

public static void main(String[] args) throws ParseException {
StudentDao sd = new StudentDao();
List<Student> list = sd.findStudentAllBySQL();

for (Student s : list) {
System.out.println(s);
}
}

带条件查询:
占位符的使用:
public List<Student> findStudentAllByAge(int age1, int age2) {
List<Student> list = null;
Session session = HibernateUtil.getSession();
try {
session.beginTransaction();
Query query = session
.createQuery("from Student where age>:a and age<:b");
query.setParameter("a", age1);
query.setParameter("b", age2);
list = query.list();
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
}
return list;
}

public static void main(String[] args) throws ParseException {
StudentDao sd = new StudentDao();
List<Student> list = sd.findStudentAllByAge(19, 22);

for (Student s : list) {
System.out.println(s);
}
}

Criteria查询法(面向对象的方式)
public List<Student> findStudentByCriteria(int age){
List<Student> list = null;
Session session = HibernateUtil.getSession();
try {
session.beginTransaction();
Criteria c = session.createCriteria(Student.class);
c.add(Restrictions.gt("age", age));
c.add(Restrictions.between("age", 18, 33));
c.addOrder(Order.asc("age"));
list = c.list();
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
}
return list;
}

public static void main(String[] args) throws ParseException {
StudentDao sd = new StudentDao();
List<Student> list = sd.findStudentByCriteria(22);
for(Student s : list){
System.out.println(s);
}
}

查询指定字段:
public List<Student> findStudentByNameAndAge() {
List<Student> listmp = new ArrayList<Student>();
Session session = HibernateUtil.getSession();
try {
session.beginTransaction();
Query query = session
.createQuery("select s.name,s.age from Student as s");
List<Object[]> list = query.list();
for (Object[] obj : list) {
Student student = new Student();
student.setName((String) obj[0]);
student.setAge((Integer) obj[1]);
listmp.add(student);
}
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
}
return listmp;
}

public static void main(String[] args) throws ParseException {
StudentDao sd = new StudentDao();
List<Student> listmp = sd.findStudentByNameAndAge();
for (Student s : listmp) {
System.out.println(s.getName() + " " + s.getAge());
}
}

Hibernate中返回记录条数:
public Long findStudentNumber() {
Session session = HibernateUtil.getSession();
Long number = null;
try {
session.beginTransaction();
number = (Long) session.createQuery("select count(*) from Student").iterate().next();
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
}
return number;
}

public static void main(String[] args) throws ParseException {
StudentDao sd = new StudentDao();
System.out.println(sd.findStudentNumber());
}

 使用hql来删除(可作批量删除)
public int batchDelete() {
Session session = HibernateUtil.getSession();
int back_val = 0;
try {
session.beginTransaction();
String hql = "delete Student where age<22";
Query query = session.createQuery(hql);
back_val = query.executeUpdate();
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
}
return back_val;
}

public static void main(String[] args) throws ParseException {
StudentDao sd = new StudentDao();
System.out.println(sd.batchDelete());
}
可以看到executeUpdate()方法返回了影响行数.