基于Struts2和hibernate的WebSocket聊天室的实现教程三：Hibernate个人信息管理

本文将介绍struts2和hibernate在项目中的实际应用

建立pojo类，使用注解配置hibernate映射

在需求分析的时候我们知道需要保存用户的聊天记录，那么怎么保存呢？

我有想过几种方法，比如文件存储，会话存储..但我在实际上操作大都不太可行。于是这次还是简单的把聊天记录储存到mysql数据库中…..

好的，接下来我们要建两个实体类。User和ChatRecord类。

User类用来保存用户信息，一般来说有这么几个属性：

private int id ;//用户id主键
private String name;//用户名
private String avatar;//头像路径
private int sex;//0 for male 1 for female
private Timestamp registerTime;//注册时间
private Timestamp loginTime;//登录时间

但是我们要使用hibernate进行dao层操作，因此在这个实体类中要配置一对多关系映射。毕竟一个用户的聊天记录一般不止一个，与当前用户对应的聊天记录应该是0…*

所以我们还要增加一个属性

private Set<ChatRecord> chatRecords =new HashSet<>();

当然为了方便实例化这个对象，我们还需要设计构造方法

public User() {

}

public User(String name, String avatar, int sex) {
this.name = name;
this.avatar = avatar;
this.sex = sex;
}

使用注解配置实体类的方法也特别简单，这里简单解释一下代码中使用到的注解的作用

@Entity 标注当前类为实体类

@Table 建立与数据库中表的连接

我们一般不在属性前使用注解，这里我们在get方法前添加注解

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

声明数据库表主键，设置数据自增。这里的strategy有多种策略，一般我们使用上面这种

@Column 配置列，保持类型与java类型一致

@Column(name = “registerTime”,columnDefinition = “timestamp default CURRENT_TIMESTAMP”) 对数据库对应列的类型自定义，并且设置默认值。这里是默认使用当前时间。

insertable=false表明在插入数据时无需传入当前注解配置的属性（这里指loginTime）

@OneToMany(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER,mappedBy=”sender”) 配置一对多关系映射，cascadeType设置级联操作，,mappedBy=”sender”注明外键。在ChatRecord类中我们将创建这个sender属性与之对应。

这个时候，User类的代码应该是这样的：

package cn.zipple.entity;

import javax.persistence.*;
import java.sql.Timestamp;
import java.util.HashSet;
import java.util.Set;

/**
* Created by zipple on 2017/11/13.
* 用户实体
*/
@Entity
@Table(name = "users")
public class User {
private int id ;
private String name;
private String avatar;//头像路径
private int sex;//0 for male 1 for female
private Timestamp registerTime;
private Timestamp loginTime;
private Set<ChatRecord> chatRecords =new HashSet<>();

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

@Column(name = "name")
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Column(name = "avatar")
public String getAvatar() {
return avatar;
}

public void setAvatar(String avatar) {
this.avatar = avatar;
}

@Column(name = "gender")
public int getSex() {
return sex;
}

public void setSex(int sex) {
this.sex = sex;
}

@Column(name = "registerTime",columnDefinition = "timestamp default CURRENT_TIMESTAMP")
public Timestamp getRegisterTime() {
return registerTime;
}

public void setRegisterTime(Timestamp registerTime) {
this.registerTime = registerTime;
}

@Column(name = "loginTime",insertable = false)
public Timestamp getLoginTime() {
return loginTime;
}

public void setLoginTime(Timestamp loginTime) {
this.loginTime = loginTime;
}
@OneToMany(cascade = {CascadeType.ALL}, fetch = FetchType.EAGER,mappedBy="sender")
public Set<ChatRecord> getChatRecords() {
return chatRecords;
}

public void setChatRecords(Set<ChatRecord> chatRecords) {
this.chatRecords = chatRecords;
}

public User() {

}

public User(String name, String avatar, int sex) {
this.name = name;
this.avatar = avatar;
this.sex = sex;
}
}

同理，在ChatRecord类中我们也这样设计：

@DynamicInsert 动态插入数据

@ManyToOne(cascade = CascadeType.ALL) 多对一映射

@JoinColumn(name=”senderId”) 设置外键（数据库将显示senderId这一列，但是在通过hibernate查询的时候会查询出整个sender对象）

package cn.zipple.entity;

import org.hibernate.annotations.DynamicInsert;

import javax.persistence.*;
import java.sql.Timestamp;

/**
* Created by zipple on 2017/11/13.
* 聊天记录
*/
@Entity
@Table(name = "chatRecord")
@DynamicInsert
public class ChatRecord {
private int id;
private User sender;
private int receiver;//指定id
private String content;
private Timestamp time;

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}
//不需要懒加载
@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name="senderId")
public User getSender() {
return sender;
}

public void setSender(User sender) {
this.sender = sender;
}

@Column(name = "receiverId")
public int getReceiver() {
return receiver;
}

public void setReceiver(int receiver) {
this.receiver = receiver;
}

@Column(name = "content",columnDefinition = "LONGTEXT")
public String getContent() {
return content;
}

public void setContent(String content) {
this.content = content;
}

@Column(name = "time",columnDefinition = "timestamp default CURRENT_TIMESTAMP")
public Timestamp getTime() {
return time;
}

public void setTime(Timestamp time) {
this.time = time;
}

public ChatRecord() {
}

public ChatRecord(User sender, int receiver, String content) {
this.sender = sender;
this.receiver = receiver;
this.content = content;
this.time=new Timestamp(System.currentTimeMillis());
}
}

由于我们在第一篇文章中添加hibernate.cfg.xml的时候直接指定了数据库为chatroom，为此我们必须保证mysql中有这个数据库。

所以我们在mysql命令行中使用这句命令创建数据库并且要防止中文乱码，注意事项传送门：

CREATE DATABASE IF NOT EXISTS chatroom DEFAULT CHARSET utf8 COLLATE utf8_general_ci;

好的，后面的表什么的就不用我们自己创建了，hibernate在运行时会自动创建。

最后还有一步，我们需要在hibernate.cfg.xml中注册这两个实体类，如下图

编写DAO层方法

使用Hibernate的方法也特别简单，先加载hibernate.cfg.xml这个文件，然后获取SessionFactory获取session，建立事务，进行CRUD，再提交事务即可。详情请点击

我们在util包中建立HibernateUtil类帮助我们获取session

package cn.zipple.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

/**
* Created by zipple on 2017/10/12.
* hibernate 工具类
*/
public class HibernateUtil {
/**
* 连接数据库
* @return 返回session
*/
public static Session getHibernateSession(){
StandardServiceRegistry serviceRegistry=new StandardServiceRegistryBuilder().configure().build();
SessionFactory sessionFactory=new MetadataSources(serviceRegistry).buildMetadata().buildSessionFactory();
return sessionFactory.openSession();
}
}

在dao包里面，添加HibernateDao作为基类，以方便代码复用。

package cn.zipple.dao;

import cn.zipple.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;

import java.util.List;

/**
* Created by zipple on 2017/10/12.
* 父类提供基本的公共操作
*/
public class HibernateDao {
/**
* 增加一条记录
* @param object 持久化类
*/
public void save(Object object){
Session session =  HibernateUtil.getHibernateSession();
Transaction tr =session.beginTransaction();
//        session.save(object);
session.saveOrUpdate(object);
tr.commit();
session.close();
}

/**
* 删除记录
* @param object 持久化类
*/
public void del(Object object){
Session session =  HibernateUtil.getHibernateSession();
Transaction tr =session.beginTransaction();
session.delete(object);
tr.commit();
session.close();
}

/**
* 修改对象信息
* @param object 持久化对象
*/
public void upd(Object object){
Session session =  HibernateUtil.getHibernateSession();
Transaction tr =session.beginTransaction();
session.merge(object);//使用merge防止从数据库中查询出来的持久化对象再被查询一次，从而导致异
// 常：illegally attempted to associate a proxy with two open Sessions
//向修改过后的对象 合并
//session.saveOrUpdate(stu);
tr.commit();
session.close();
}

/**
* 获取数据库中所有对象
* @param extra 额外条件--附加条件
* @return 返回对象列表
*/
public List getAllObject(String entityClass,String extra){
Session session = HibernateUtil.getHibernateSession();
String hql = "from "+entityClass+extra;
System.out.println("hql:"+hql);
List studentList = session.createQuery(hql).list();
session.close();
return studentList;
}

/**
* 根据id获取对象
* @param id id
* @return 返回对象
*/
public Object getObjetcById(int id){
Session session = HibernateUtil.getHibernateSession();
Transaction tr =session.beginTransaction();
session.close();
Object obj = session.get(Object.class, id);
tr.commit();
session.close();
return obj;
}
}

同时，我们为这两个实体类建立接口，如下图所示



BaseDaoImpl类实际上只是单纯的继承了HibernateDao这个基类，为什么要建立这个BaseDaoImpl呢，实际上是为了便于对父类进行补充和修改。如下：

package cn.zipple.dao.impl;

import cn.zipple.dao.HibernateDao;

/**
* Created by zipple on 2017/11/13.
* 基类
*/
public class BaseDaoImpl  extends HibernateDao {
}

在ChatRecordDao接口中，没有其他的什么需求需要自定义数据库操作方法，使用常规的CRUD方法即可。于是这个接口这样定义：

package cn.zipple.dao;

/**
* Created by zipple on 2017/11/13.
*/
public interface ChatRecordDao {
}

在impl包中需要实现这个接口，虽然是个空的：

package cn.zipple.dao.impl;

import cn.zipple.dao.ChatRecordDao;

/**
* Created by zipple on 2017/11/18.
*/
public class ChatRecordDaoImpl extends BaseDaoImpl implements ChatRecordDao {
}

但是在UserDao中，我们要补充一个方法，用于用户注册和查询

package cn.zipple.dao;

import cn.zipple.entity.User;

/**
* Created by zipple on 2017/11/13.
*/
public interface UserDao {
/**
* 根据用户名获取用户对象
* @param username 用户名
* @return 返回对象
*/
User getUserByUsername(String username);
}

在impl包中这样实现接口

package cn.zipple.dao.impl;

import cn.zipple.dao.UserDao;
import cn.zipple.entity.User;
import cn.zipple.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.query.Query;

import java.util.List;

/**
* Created by zipple on 2017/11/13.
*/
public class UserDaoImpl extends BaseDaoImpl implements UserDao {
@Override
public User getUserByUsername(String username) {
Session session = HibernateUtil.getHibernateSession();
String hql = "from User where name =:username";//User代表的是User实体类而不是表名
Query query = session.createQuery(hql);
query.setParameter("username",username);
System.out.println("hql:"+hql);
List userList = query.list();
session.close();
if (userList.size()!=0){
return (User) userList.get(0);
}
return null;
}
}

上面的代码中我们使用到了hql，是Hibernate方便我们自定义sql操作而定义的。

下面我们测试HIbernate是否正常工作。

Intellij连接数据库

首先我们检查IDE右侧边栏是否有database一项，如图



有的话就双击

没有的话双击shift打开database界面



选择mysql连接



连接



第一次连接可能没有驱动包，让IDE自动帮你下载即可。

连接成功以后

我们在test包中新建测试类

package cn.zipple.test;

import cn.zipple.dao.impl.BaseDaoImpl;
import cn.zipple.entity.ChatRecord;
import cn.zipple.entity.User;
import cn.zipple.util.Constant;

/**
* Created by zipple on 2017/11/13.
* 测试
*/
public class UserTest {
private BaseDaoImpl baseDao = new BaseDaoImpl();

public static void main(String[] args) {
System.out.println("测试hibernate是否正常工作");
new UserTest().testAdd();
}

private void testAdd(){
User user1 = new User("邹博","01.jpg", Constant.MALE);
User user2 = new User("李欣雨","02.jpg", Constant.FEMALE);
System.out.println("储存用户1");
baseDao.save(user1);//先保存没有维护关系的那一方
System.out.println("储存用户2");
baseDao.save(user2);
ChatRecord temp = new ChatRecord(user1,user2.getId(),"这是第一条测试信息");
System.out.println("储存聊天信息");
baseDao.save(temp);
}
}

测试成功运行