因为要实现用户-角色-权限管理，所以需要多对多映射实现。经过一整天的学习与调试，终于简单的实现了该功能。以下是写的测试类，以供大家理解。
1、编写Entity Bean
package com.javaeye.sunjiesh.hibernate.annotation.entity;
import java.io.Serializable;
import java.util.LinkedHashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
@Entity
@Table(name = "USER")
public class User implements Serializable {
private static final long serialVersionUID = -171549061113198199L;
private int id;
private String username;
private String password;
private Set<Role> roles = new LinkedHashSet<Role>();
public User() {
}
@Id
@Column(name = "id", nullable = false, unique = true)
@GeneratedValue(strategy = GenerationType.AUTO)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name = "username")
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
@Column(name = "password")
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@ManyToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE })
@JoinTable(name = "USER_ROLE", joinColumns = { @JoinColumn(name = "USER_ID") }, inverseJoinColumns = { @JoinColumn(name = "ROLE_ID") })
// @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
}
package com.javaeye.sunjiesh.hibernate.annotation.entity;
import java.io.Serializable;
import java.util.LinkedHashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
@Entity
@Table(name = "ROLE")
public class Role implements Serializable {
private static final long serialVersionUID = 3196247728974978243L;
private int id;
private String name;
private Set<User> users=new LinkedHashSet<User>();
public Role() {
}
@Id
@Column(name = "id", nullable = false, unique = true)
@GeneratedValue(strategy = GenerationType.AUTO)
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;
}
@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE }, fetch = FetchType.LAZY, mappedBy="roles")
public Set<User> getUsers() {
return users;
}
public void setUsers(Set<User> users) {
this.users = users;
}
}
2、编写Hibernate配置文件
<?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 name="foo">
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
<property name="hibernate.connection.username">*</property>
<property name="hibernate.connection.password">*</property>
<property name="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</property>
<property name="show_sql">true</property>
<mapping class="com.javaeye.sunjiesh.hibernate.annotation.entity.User"/>
<mapping class="com.javaeye.sunjiesh.hibernate.annotation.entity.Role"/>
</session-factory>
</hibernate-configuration>
3、编写HibernateSessionFactory类（与MyEclipse自动生成的有少量变动）
package com.javaeye.sunjiesh.util;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
/**
* Configures and provides access to Hibernate sessions, tied to the
* current thread of execution. Follows the Thread Local Session
* pattern, see {@link http://hibernate.org/42.html }.
*/
public class HibernateSessionFactory {
/**
* Location of mysqlhibernate.cfg.xml file.
* Location should be on the classpath as Hibernate uses
* #resourceAsStream style lookup for its configuration file.
* The default classpath location of the hibernate config file is
* in the default package. Use #setConfigFile() to update
* the location of the configuration file for the current session.
*/
private static String CONFIG_FILE_LOCATION = "mysqlhibernate.cfg.xml";
private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
//private static Configuration configuration = new Configuration();
private static AnnotationConfiguration configuration=new AnnotationConfiguration();
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 HibernateSessionFactory() {
}
/**
* Returns the ThreadLocal Session instance. Lazy initialize
* the <code>SessionFactory</code> if needed.
*
* @return Session
* @throws HibernateException
*/
public static synchronized Session getSession() throws HibernateException {
Session session = (Session) threadLocal.get();
if (session == null || !session.isOpen()) {
if (sessionFactory == null) {
rebuildSessionFactory();
}
session = (sessionFactory != null) ? sessionFactory.openSession()
: null;
threadLocal.set(session);
}
return session;
}
/**
* Rebuild hibernate session factory
*
*/
public static void rebuildSessionFactory() {
try {
configuration.configure(configFile);
sessionFactory = configuration.buildSessionFactory();
} catch (Exception e) {
System.err
.println("%%%% Error Creating SessionFactory %%%%");
e.printStackTrace();
}
}
/**
* Close the single hibernate session instance.
*
* @throws HibernateException
*/
public static void closeSession() throws HibernateException {
Session session = (Session) threadLocal.get();
threadLocal.set(null);
if (session != null) {
session.close();
}
}
/**
* return session factory
*
*/
public static org.hibernate.SessionFactory getSessionFactory() {
return sessionFactory;
}
/**
* return session factory
*
* session factory will be rebuilded in the next call
*/
public static void setConfigFile(String configFile) {
HibernateSessionFactory.configFile = configFile;
sessionFactory = null;
}
/**
* return hibernate configuration
*
*/
public static Configuration getConfiguration() {
return configuration;
}
}
4、编写DAO类
package com.javaeye.sunjiesh.dao;
import java.io.Serializable;
import org.apache.log4j.Logger;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.javaeye.sunjiesh.util.HibernateSessionFactory;
public abstract class BaseDAO<T> {
private static Logger log =Logger.getLogger(BaseDAO.class);
/**
* 获取Hibernate的Session对象
*/
public Session getSession(){
return HibernateSessionFactory.getSession();
}
/**
* 根据主键得到对象
*/
public T getObject(Class clazz, Serializable id){
return (T)getSession().get(clazz, id);
}
/**
* 保存对象
*/
public void saveObject(T t) {
Session session = getSession();
Transaction tx = beginTransaction(session);
try{
session.saveOrUpdate(t);
tx.commit();
}catch(Exception e){
tx.rollback();
log.error("保存对象失败");
}
}
/**
* 创建事务
*/
private Transaction beginTransaction(Session session){
return session.beginTransaction();
}
}
package com.javaeye.sunjiesh.dao;
import com.javaeye.sunjiesh.hibernate.annotation.entity.Role;
public class RoleDAO extends BaseDAO<Role> {
}
package com.javaeye.sunjiesh.dao;
import com.javaeye.sunjiesh.hibernate.annotation.entity.User;
public class UserDAO extends BaseDAO<User>{
}
5、编写测试类
package com.javaeye.sunjiesh.hibernate.annotation;
import com.javaeye.sunjiesh.dao.RoleDAO;
import com.javaeye.sunjiesh.dao.UserDAO;
import com.javaeye.sunjiesh.hibernate.annotation.entity.Role;
import com.javaeye.sunjiesh.hibernate.annotation.entity.User;
public class AnnotationMain {
public AnnotationMain() {
// TODO Auto-generated constructor stub
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
User user=new User();
user.setUsername("username");
user.setPassword("password");
Role role=new Role();
role.setName("管理员");
UserDAO userDao=new UserDAO();
RoleDAO roleDao=new RoleDAO();
userDao.saveObject(user);
roleDao.saveObject(role);
user.getRoles().add(role);
role.getUsers().add(user);
userDao.saveObject(user);
roleDao.saveObject(role);
}
}
备注：此篇文章为双向多对多关系。
分享到：
相关推荐
已经不用*.hbm.xml这种映射文件了，都是用Annotation（注解）方式来完成实体与表之间的映射关系，这样看起来比用xml文件来映射更具有可读性，自我感觉以后Hibernate Annotation的映射方式将代替hibernate 的*.hbm....
《Hibernate Annotation 中文文档》是Java开发者们的重要参考资料，它详细介绍了如何在Hibernate框架中使用注解进行对象关系映射（ORM）。Hibernate是一款强大的开源Java持久化框架，它简化了数据库与Java对象之间的...
《Hibernate注解与Hibernate3深度解析》 在Java开发领域，Hibernate作为一种强大的对象关系映射（ORM）框架...通过熟练掌握这些注解，开发者可以更好地运用Hibernate进行数据持久化操作，实现高效、灵活的数据库交互。
在Hibernate中，注解（Annotation）是一种声明式的方法，用于配置实体类、属性以及它们与数据库表之间的映射关系。本文将深入探讨“最全的Hibernate Annotation API文档”中的关键知识点。 一、实体类（Entity） 在...
随着Java社区对注解的广泛接受，Hibernate Annotation已经成为现代Java应用开发的标准实践，逐渐取代了传统的XML映射方式。 以上是对Hibernate Annotation的简要介绍，深入理解和熟练应用这些注解，将有助于提升你...
Hibernate Annotation库是Java开发中用于简化对象关系映射（ORM）的一个重要组件，它使得开发者能够在Java类上直接使用注解来定义数据库映射，从而避免了传统的XML配置文件。这三个特定的jar包是Hibernate ORM框架中...
《Hibernate Annotation 学习笔记》 在Java的持久化框架中，Hibernate以其强大的功能和易用性成为开发者首选之一。...在后续的学习笔记中，我们将继续探索更多关于Hibernate Annotation的实用技巧和高级特性。
而Hibernate Annotation是Hibernate的一个重要特性，它通过在Java类和字段上添加注解来简化数据库表和实体类之间的映射配置。这篇博文将带你了解如何使用Hibernate Annotation进行开发。 首先，我们需要理解Java...
在本主题中，我们将深入探讨使用Hibernate注解来实现JPA的一对多、多对多和多对一的关系映射。 1. **一对多关系**： 在现实世界中，一个老师可以教多个学生，或者一个班级可以包含多个学生，这就是典型的一对多...
Hibernate Annotation API是Hibernate ORM的一种扩展，允许开发者使用Java注解（Annotations）来定义对象-关系映射。这种API避免了传统的Hibernate XML配置文件，使得ORM配置更加内聚且易于维护。 2. **核心注解**...
2. **映射机制**： Hibernate支持XML映射文件（hbm.xml）和注解映射两种方式，让对象与数据库表之间建立映射关系。 3. **Session和Transaction**： Session是Hibernate的主要工作单元，负责保存、更新和检索对象。...
本文将深入探讨如何结合 Spring 的注解配置与 Hibernate 实现数据持久化，通过一个实际的 demo 示例来阐述整个过程。 首先，Spring 框架以其依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented ...
在Hibernate 3.x版本中，引入了Annotation注解，这是一种元数据的方式，可以替代XML配置文件来描述对象与数据库表之间的映射关系。 **Hibernate Annotation注解** 在Hibernate 3.x之前，对象到数据库的映射通常...
### HibernateAnnotation ...通过上述介绍，我们可以看到HibernateAnnotation技术不仅简化了配置过程，而且提供了一种更加灵活的方式来管理对象与数据库之间的映射关系。这对于提高开发效率和维护性都有着重要的意义。
Hibernate Annotation是Hibernate框架的一个重要特性，它允许开发者直接在Java类上使用注解来定义对象的数据库映射，从而避免了传统的XML配置文件。这种做法提高了代码的可读性和维护性，同时也使得开发流程更为简洁...
本文将深入探讨如何使用Hibernate注解实现基于外键的一对多双向关联。我们将通过具体实例来解析这个主题，并结合源码分析其工作原理。 首先，我们要明白一对多关联意味着一个实体可以拥有多个关联的实体。在数据库...
和其它许多批注一样，在多对多关联中很多值是自动生成，党双向多对多关联中没有定义任何物理映射时，Hibernate根据以下规则生成相应的值，关联表名：主表表名+下划线+从表表名，关联到主表的外键名：主表名+下划线+...
6. `@OneToMany`, `@ManyToOne`, `@OneToOne`, `@ManyToMany`：这些注解用于描述多对一、一对多、一对一和多对多的关联关系。例如，一个用户可以有多个订单： ```java @Entity public class User { @Id private ...
借助新的 Hibernate Annotation 库，即可一次性地分配所有旧映射文件，一切都会按照您的想法来定义——注释直接嵌入到您的 Java 类中，并提供一种强大及灵活的方法来声明持久性映射。 Hibernate Annotation 的优点...