hibernate – Wishselfly's blog

这里我会以上一篇文所的的预定义的表，请对照着阅读:一些Hibernate的用法笔记（1）

在一些实际的开发环境中，我们查询一张表，可能需要关联到另外一张表的信息，不是那种已经存在于数据库表的字段中的数据，可能是需要统计的一些数据，例如我需要知道这个用户在系统下面到底有多少中角色，写成SQL可能是

select {ac.*},

(select count(*) from account_role_rel where account_role_rel.account_id=ac.id) role_count

from account ac

where

ac.id=?

对于像上述查询语句中，这种查出来为纯数字的变量，而且不存在于实体当中的变量，我们可以通过addScalar的方式捕获出来

那么我们在DAO中转换当前SQL语句查询结果的代码如下：

SQLQuery q = session.createSQLQuery(

"select {ac.*}," +

"(select count(*) from account_role_rel where account_role_rel.account_id=ac.id) role_count " +

"from account ac " +

"where" +

"ac.id=1"

);

q.addEntity("ac", AccountModel.class);

//可以通过StandardBasicTypes设置额外捕获的参数的类型

q.addScalar("role_count", StandardBasicTypes.INTEGER);

//获取到的内容为Object[]{AccountModel, role_count}

return q.uniqueResult();

StandardBasicTypes里面有很多基本类型:

还记得我们之前声明的用户和角色的关联表：

account_role_rel
列名	类型	注释
id	INT(11) NOT NULL PRIMARY KEY AUTO_INCREMENT	递增标识
account_id	INT(11) NOT NULL	用户ID
role_id	INT(11) NOT NULL	角色ID

现在我们需要声明AccountRoleRelModel.java，我需要在里面Join上RoleModel和AccountModel的实体：

/**

* 用户与角色的关联表的实体

@Entity

@Table(name = "account_role_rel")

public class AccountRoleRelModel {

private Integer id;

private AccountModel account;

private RoleModel role;

@Id

@Column(name = "id")

@GeneratedValue(strategy = GenerationType.IDENTITY)

public Integer getId() {

returnn this.id;

}

@OneToOne //这里可以改成ManyToOne，相对，下面的JoinColumn需要加上insertable=false, updatable=false

@JoinColumn(name = "account_id", referencedColumnName = "id")

public AccountModel getAccount() {

return this.account;

}

@OneToOne

@JoinColumn(name = "account_id", referencedColumnName = "id")

public RoleModel getRole() {

return this.role;

}

//setter省略

}

这种时候，我们在编写DAO的时候，我们可以通过addJoin加入对应实体的映射：

@Repository()

public class AccountRoleRelDAO {

@PersistenceContext

public EntityManager em;

@Transactional(readOnly = true)

public List<Object[]> getCashAccount(int accountId) {

Session session = em.unwrap(Session.class);

SQLQuery q = session.createSQLQuery(

"select {account_role_rel.*}," +

"{account.*}," +

"{role.*} " +

"from account_role_rel " +

"inner join role on " +

"role.id=account_role_rel.role_id " +

"inner join account on " +

"account.id=account_role_rel.account_id " +

"where account_role_rel.account_id=:accountId"

);

q.setParameter("accountId", accountId);

q.addEntity("account_role_rel", AccountRoleRelModel.class);

/* public abstract SQLQuery addJoin(String tableAlias, String path)

* Declare a join fetch result.

* Parameters:

* tableAlias - The SQL table alias for the data to be mapped to this fetch

* path - The association path ([owner-alias].[property-name]).

//根据上述定义，addJoin的第一个参数，应该是需要join的表在SQL语句中的名字，如果我们给对应表声明了别名的话，这里填的应该是别名

//后面应该是主表在SQL中的名字，有别名用别名，然后.后面接实体中，Join的模型的变量的名字

//例如AccountRelModel中我们声明AccountModel Join的变量名为account

//因此这里填的是account_role_rel.account

q.addJoin("account", "account_role_rel.account");

//同上

q.addJoin("role", "account_role_rel.role");

//返回的内容List<Object[AccountRelModel, AccountModel, RoleModel]>，顺序根据上面addEntity、addJoin的顺序产生对应的Object[]内用的顺序

return (List<Object[]>) q.list();

}

我的公司的老板对新的项目的后台的架构下了非常重的力度，所以很多东西希望能够抽取出来重用，特别是对于一些很多项目都会重用到的模块进行抽出。开发中，一些封装的功能甚至关联的表都是未知的，因此对Hibernate用法进行了一次比较深入的研究。我们希望针对自己的业务，形成一套系统，让以后的开发效率更高。并且能够能增强封装出来的东西的重用性。有时候非常庆幸有一个搞技术的老板，真的能够学到很多好东西。

这里总结一下，做下记录。虽然hibernate的ORM的注解很强大，包括和spring jpa一起使用的时候真的非常爽。但是这些功能，虽然用着爽，却容易对业务造成很大的耦合度。

好了，转入正题。

例如我们有一个用户表：

account
列名	类型	注释
id	INT(11) NOT NULL PRIMARY KEY AUTO_INCREMENT	递增标识
account	VARCHAR(25) NOT NULL	用户名
password	VARCHAR(64) NOT NULL	密码

角色表:

role
列名	类型	注释
id	INT(11) NOT NULL PRIMARY KEY AUTO_INCREMENT	递增标识
role_name	VARCHAR(25) NOT NULL	角色名

用户角色关联表:

account_role_rel
列名	类型	注释
id	INT(11) NOT NULL PRIMARY KEY AUTO_INCREMENT	递增标识
account_id	INT(11) NOT NULL	用户ID
role_id	INT(11) NOT NULL	角色ID

因此我们可能需要生成两个实体

AccountModel、RoleModel

至于中间那个account_role_rel的表，因为开发中要用hibernate转换出它的实体，实在多此一举，因此就直接省略掉对应的实体了。

/**

* 用户实体

@Entity

@Table(name = "account")

public class AccountModel {

private Integer id;

private String account;

private String password;

@Id

@Column(name = "id", nullable = false)

public Integer getId() {

return this.id;

}

@Basic

@Column(name = "account", nullable = false)

public String getAccount() {

return this.account;

}

@Basic

@Column(name = "password", nullable = false)

public String getPassword() {

return this.password;

}

//Setter省略

}

/**

* 角色实体

@Entity

@Table(name = "role")

public class RoleModel {

private Integer id;

private String roleName;

@Id

@Column(name = "id", nullable = false)

public Integer getId() {

return this.id;

}

@Basic

@Column(name = "role_name", nullable = false)

public String getRoleName() {

return this.roleName;

}

//Setter省略

}

现在假设我们建了Account和Role这两张表的实体，而且没有使用@JoinColumn一类的注解，但是我们需要动态的把两张表关联在一起
我们需要DAO

/**

* 获取账号和角色集合的DAO

@Repository

public class AccountRolesDAO {

@PersistenceContext

public EntityManager em;

public Map<AccountModel, List<RoleModel> findAccountRoles(int accountId) {

Session session = em.unwrap(Session.class);

SQLQuery q = session.createSQLQuery("SELECT {ac.*},{ro.*} from " +

"account ac" +

" left join " +

"account_role_rel rorel " +

"on rorel.account_id=ac.id " +

"left join " +

"role ro " +

"on ro.id=rorel.role_id");

q.addEntity("ac", AccountModel.class);

q.addEntity("ro", RoleModel.class);

//返回的东西是{[AccountModel,RoleModel],[AccounrModel,RoleModel]}

List<Object[]> result = q.list();

Map<AccountModel, List<RoleModel>> map = new HashMap<AccountModel, List<RoleModel>>();

for (Object[] entities : result) {

List<RoleModel> list = map.get(entities[0]);

if (list == null) {

list = new ArrayList<RoleModel>();

map.put(entities[0], list);

}

list.add(entities[1]);

}

return map;

}

上面的东西，如果我们关联表是未知的，我可以很方便的通过上面代码的变形，传入对应实体类型和参数，就能够实现自动关联，不像Hibernate注解声明的实体，实体之间的关系必须在实体内声明。即使在不清楚另一个实体是什么的情况下进行关联，能够很好的把一些业务重复的逻辑抽取出来，再跟项目或者功能特定业务的表关联，这样就不用每次开发都特地的写一遍这些功能。

Wishselfly's blog

Wishselfly's blog

标签：hibernate

一些Hibernate的用法笔记（2）

一些Hibernate的用法笔记（1）