userGroup

package review.hibernate.test;

import java.util.HashSet;
import java.util.Set;

public class UserGroup {
	private Integer userGroupId;
	private String userGroupName;//组名
	private Integer userGroupMax;//该组最大人数
	private Integer userGroupCurrent;//该组当前人数
	private Set<User> users=new HashSet<User>();
	public Integer getUserGroupId() {
		return userGroupId;
	}
	public void setUserGroupId(Integer userGroupId) {
		this.userGroupId = userGroupId;
	}
	public String getUserGroupName() {
		return userGroupName;
	}
	public void setUserGroupName(String userGroupName) {
		this.userGroupName = userGroupName;
	}
	public Integer getUserGroupMax() {
		return userGroupMax;
	}
	public void setUserGroupMax(Integer userGroupMax) {
		this.userGroupMax = userGroupMax;
	}
	public Integer getUserGroupCurrent() {
		return userGroupCurrent;
	}
	public void setUserGroupCurrent(Integer userGroupCurrent) {
		this.userGroupCurrent = userGroupCurrent;
	}
	public Set<User> getUsers() {
		return users;
	}
	public void setUsers(Set<User> users) {
		this.users = users;
	}
}

userGrouo.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="review.hibernate.test">
	<class name="UserGroup" table="userGroup">
		<id name="userGroupId">
			<generator class="native"></generator>
		</id>
		<property name="userGroupName" ></property>
		<property name="userGroupMax" ></property>
		<property name="userGroupCurrent" ></property>
		<!-- 
			一对多/多对一在配置文件中配置
			name:实体映射属性
			cascade:级联操作
			save-update:级联保存更新
					delete: 级联删除
					all:save-update+delete
			作用：简化操作
		 -->
		<set name="users" cascade="save-update">
			<!--key： 外键  
				column:外键字段
			-->
			<key column="user_userGroup_id"></key>
			<!-- 
				one-to-many：一对多/多对一的标识
				class:多的类
			 -->
			<one-to-many class="User"/>
		</set>
	</class>
</hibernate-mapping>

user

package review.hibernate.test;

import java.util.HashSet;
import java.util.Set;

public class User {
	private Integer userId;
	private String userName;
	private Boolean userSex;//男 true 女false
	private Double userMoney;
	private UserGroup userGroup;
	private Set<Role> roles=new HashSet<Role>();
	private Set<Links> links=new HashSet<Links>();
	
	public Set<Links> getLinks() {
		return links;
	}
	public void setLinks(Set<Links> links) {
		this.links = links;
	}
	public Set<Role> getRoles() {
		return roles;
	}
	public void setRoles(Set<Role> roles) {
		this.roles = roles;
	}
	public UserGroup getUserGroup() {
		return userGroup;
	}
	public void setUserGroup(UserGroup userGroup) {
		this.userGroup = userGroup;
	}
	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 Boolean getUserSex() {
		return userSex;
	}
	public void setUserSex(Boolean userSex) {
		this.userSex = userSex;
	}
	public Double getUserMoney() {
		return userMoney;
	}
	public void setUserMoney(Double userMoney) {
		this.userMoney = userMoney;
	}
}

user.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：hibernate 表字段与实体对象属性映射
	papackage:包名
	如果写了包名就不用写完整类名了
 -->
<hibernate-mapping package="review.hibernate.test">
	<!-- 
		class 映射实体类
		name：完整类名
		table:表名
		lazy:延迟加载 类级别
			true 默认 
			一般情况默认就可以了
	 -->
	<class name="User" table="user" lazy="false">
		<!-- 
			实体类id/表id
			name:实体属性名/默认表字段名
		 -->
		<id name="userId">
			<!-- 
				generator:Hibernate 主键生成器是负责生成数据表记录的主键，通常有如下几种常见的主键生成方式
				class:
				identity:用于MySql数据库。特点：递增
					注：对于MySql数据库使用递增序列时需要在建表时对主键指定为auto_increment属性。
					<id name="id" column="id">  
					< generator class="identity"/>  
					</id>  
				sequence：用于Oracle数据库
					<id name="id" column="id">  
					<generator class="sequence">  
					<param name="sequence">序列名</param>  
					</generator>  
					</id>   
				native：跨数据库时使用，由底层方言产生。 
					Default.sequence为hibernate_sequence
					注：使用native时Hibernate默认会去查找Oracle中的hibernate_sequence序列。 
						如果Oracle中没有该序列，连Oracle数据库时会报错。
						<id name="id" column="id">  
						<generator class="native"/>  
						</id> 
				hilo：通过高低位合成id，先建表hi_value，再建列next_value。必须要有初始值。
				<id name="id" column="id">  
				<generator class="hilo">  
				<param name="table">high_val</param>  
				<param name="column">nextval</param>  
				<param name="max_lo">5</param>  
				</generator>  
				</id>   
				sequencehilo：同过高低位合成id，建一个sequence序列，不用建表。
				<id name="id" column="id">  
				<generator class="hilo">  
				<param name="sequence">high_val_seq</param>  
				<param name="max_lo">5</param>  
				</generator>  
				</id>  
				assigned：用户自定义id;
				id name="id" column="id">   
				<generator class="assigned"/>  
				</id>  
			 -->
			<generator class="native"></generator>
		</id>
		<!-- 
			属性：
			name:实体属性名/默认表字段名
		 -->
		<property name="userName"></property>
		<property name="userSex"></property>
		<property name="userMoney"></property>
		<!-- 一对多/多对一配置 
			name:实体映射对象属性名
			column:外键字段
			class:一的类
			fetch:抓取策略
				select:默认
				join:迫切左连接
		-->
		<many-to-one name="userGroup" column="user_userGroup_id" class="UserGroup" fetch="join"></many-to-one>
		
		<set name="roles">
			<key column="user_role_id"></key>
			<one-to-many class="review.hibernate.test.Role"/>
		</set>
		<!-- 
			多对多
			name:实体映射对象属性名
			table:中间表名
			inverse:如果遇到多对多关系，一定要选择一方放弃维护更新。
			看业务需求，例如：录入员工时需要为员工指定所属角色，那么业务方向就是由员工来维护角色，
				角色不需要维护与员工的关系，角色放弃维护
			lazy:延迟加载 关联级别
				true 默认 （如果session关闭就有no-session问题）
				false：立即加载
				extra:及其懒惰
				fetch：抓取策略
					select 默认值
					join：迫切左外连接
					subselect:子查询
				注：全部使用默认
		 -->
		<set name="links" table="user_links" inverse="true" fetch="select">
			<!-- 
				key 主键
				column：当前表主键/当前映射对象id
			 -->
			<key column="userId"></key>
			<!-- 
				many-to-many:多对多
				class:多对多的另一个类
				column：另一个类的id/另一个表的主键
				lazy:延迟加载 关联级别
					false 默认  是否采用延迟加载取决与一的一方类上的lazy属性的值
					proxy：关联对象时不采用延迟加载
					extra:及其懒惰
				
			 -->
			<many-to-many class="review.hibernate.test.Links" column="linksId" ></many-to-many>
		</set>
	</class>
</hibernate-mapping>

role

package review.hibernate.test;

import java.util.HashSet;
import java.util.Set;

public class Role {
	private Integer roleId;
	private String roleName;
	private User user;
	private Role role;
	private Set<Role> childen=new HashSet<Role>();
	private Set<Responsibility> responsibilitys=new HashSet<Responsibility>();
	
	
	public Set<Responsibility> getResponsibilitys() {
		return responsibilitys;
	}
	public void setResponsibilitys(Set<Responsibility> responsibilitys) {
		this.responsibilitys = responsibilitys;
	}
	public Role getRole() {
		return role;
	}
	public void setRole(Role role) {
		this.role = role;
	}
	public Set<Role> getChilden() {
		return childen;
	}
	public void setChilden(Set<Role> childen) {
		this.childen = childen;
	}
	public Integer getRoleId() {
		return roleId;
	}
	public void setRoleId(Integer roleId) {
		this.roleId = roleId;
	}
	public String getRoleName() {
		return roleName;
	}
	public void setRoleName(String roleName) {
		this.roleName = roleName;
	}
	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
}

role.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>
	<class name="review.hibernate.test.Role" table="role">
		<id name="roleId">
			<generator class="native"></generator>
		</id>
		<property name="roleName"></property>
		<many-to-one name="user" column="user_role_id" class="review.hibernate.test.User"></many-to-one>
		<many-to-one name="role" column="role_role_id" class="review.hibernate.test.Role"></many-to-one>
		<set name="childen">
			<key column="role_role_id"></key>
			<one-to-many class="review.hibernate.test.Role"/>
		</set>
		<set name="responsibilitys">
			<key column="role_responsibilitys_id"></key>
			<one-to-many class="review.hibernate.test.Responsibility"/>
		</set>
	</class>
</hibernate-mapping>

links

package review.hibernate.test;

import java.util.HashSet;
import java.util.Set;

public class Links {
	private Integer linksId;
	private String linksName;
	private Set<User> users=new HashSet<User>();
	public Integer getLinksId() {
		return linksId;
	}
	public void setLinksId(Integer linksId) {
		this.linksId = linksId;
	}
	public String getLinksName() {
		return linksName;
	}
	public void setLinksName(String linksName) {
		this.linksName = linksName;
	}
	public Set<User> getUsers() {
		return users;
	}
	public void setUsers(Set<User> users) {
		this.users = users;
	}
}

links.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>
	<class	name="review.hibernate.test.Links" table="links">
		<id name="linksId">
			<generator class="native"></generator>
		</id>
		<property name="linksName"></property>
		
		<set name="users" table="user_links">
			<key column="linksId"></key>
			<many-to-many class="review.hibernate.test.User" column="userId"></many-to-many>
		</set>
	</class>

</hibernate-mapping>

Responsibility

package review.hibernate.test;

public class Responsibility {
	private Integer responsibilityId;
	private String responsibilityName;
	private Role role;
	public Integer getResponsibilityId() {
		return responsibilityId;
	}
	public void setResponsibilityId(Integer responsibilityId) {
		this.responsibilityId = responsibilityId;
	}
	public String getResponsibilityName() {
		return responsibilityName;
	}
	public void setResponsibilityName(String responsibilityName) {
		this.responsibilityName = responsibilityName;
	}
	public Role getRole() {
		return role;
	}
	public void setRole(Role role) {
		this.role = role;
	}
}

Responsibility.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>
	<class name="review.hibernate.test.Responsibility">
		<id name="responsibilityId">
			<generator class="native"></generator>
		</id>
		<property name="responsibilityName"></property>
		<many-to-one name="role" column="role_responsibilitys_id" class="review.hibernate.test.Role"></many-to-one>
	</class>
</hibernate-mapping>

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>
		<!-- 
			#hibernate.dialect org.hibernate.dialect.MySQLDialect
			#hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
			#hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect
			#hibernate.connection.driver_class com.mysql.jdbc.Driver
			#hibernate.connection.url jdbc:mysql:///test
			#hibernate.connection.username gavin
			#hibernate.connection.password
		 -->
		 <!-- 数据库方言 -->
		<property name="hibernate.dialect" >org.hibernate.dialect.MySQLDialect</property>
		<!-- 驱动类 -->
		<property name="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</property>
		<!-- 数据库连接路径 -->
		<property name="hibernate.connection.url" >jdbc:mysql:///test?useUnicode=true&amp;characterEncoding=UTF-8</property>
		<!--  用户名-->
		<property name="hibernate.connection.username" >root</property>
		<!-- 用户密码 -->
		<property name="hibernate.connection.password" >root</property>
		<!-- #hibernate.show_sql true 显示sql-->
		<property name="hibernate.show_sql">true</property>
		<!-- hibernate.format_sql true 格式化sql-->
		<property name="hibernate.format_sql">true</property>
		<!-- 
			## auto schema export
			作用：自动创建|更新|验证数据库表结构。如果不是此方面的需求建议set value=”none”。 
			#hibernate.hbm2ddl.auto create-drop：每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。
			#hibernate.hbm2ddl.auto create：每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，
				哪怕两次没有任何改变也要这样执行，这就是导致数据库表数据丢失的一个重要原因。 
			#hibernate.hbm2ddl.auto update：最常用的属性，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），
				以后加载hibernate时根据 model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，
				表结构是不会被马上建立起来的，是要等 应用第一次运行起来后才会。
			#hibernate.hbm2ddl.auto validate：每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，
				但是会插入新值。
		 -->
		 <property name="hibernate.hbm2ddl.auto">update</property>
		 <!-- 开启线程绑定配置 -->
		<property name="hibernate.current_session_context_class">thread</property>
		 <!-- 映射表 -->
		 <mapping resource="review/hibernate/test/user.hbm.xml"/>
		 <mapping resource="review/hibernate/test/userGroup.hbm.xml"/>
		 <mapping resource="review/hibernate/test/role.hbm.xml"/>
		 <mapping resource="review/hibernate/test/responsibility.hbm.xml"/>
		 <mapping resource="review/hibernate/test/links.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

测试

package review.hibernate.test;


import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import zr.utils.core.Reflex;

public class Main {
	private Session session;
	private Transaction transaction;
	public Main() {
		session();
	}
	private void test() {
		User user = new User();
		user.setUserName("user21");
		user.setUserSex(true);
		user.setUserMoney(100000.0);
		
		
		
		
		User user2 = new User();
		user2.setUserName("user22");
		user2.setUserSex(true);
		user2.setUserMoney(100000.0);
		
		Links links1=new Links();
		links1.setLinksName("link5");
		Links links2=new Links();
		links2.setLinksName("link6");
		
		/*user.getLinks().add(links1);
		user.getLinks().add(links2);
		user2.getLinks().add(links1);
		user2.getLinks().add(links2);
		
		links1.getUsers().add(user);
		links1.getUsers().add(user2);
		links2.getUsers().add(user);
		links2.getUsers().add(user2);*/
		
		/*UserGroup group = new UserGroup();
		group.setUserGroupName("group3");
		group.setUserGroupMax(100);
		Set<User> set = group.getUsers();
		set.add(user);
		set.add(user2);
		group.setUserGroupCurrent(set.size());*/
		
		/*UserGroup group = session.get(UserGroup.class, 1);
		Set<User> set = group.getUsers();
		set.add(user);
		set.add(user2);
		user.setUserGroup(group);
		user2.setUserGroup(group);
		group.setUserGroupCurrent(set.size());*/
		
		/*session.update(group);
		session.save(user);
		session.save(role1);
		session.save(responsibility1);
		session.save(responsibility2);
		session.save(role2);
		session.save(user2);*/
		
		/*session.save(links1);
		session.save(links2);
		session.save(user);
		session.save(user2);*/
		
		Criteria criteria = session.createCriteria(User.class);
		
		criteria.add(Restrictions.eq("userId", 6));
		
		User result = (User) criteria.uniqueResult();
		
		System.out.println(result);
		
//		User user3 = session.get(User.class, 1);
//		UserGroup userGroup = session.get(UserGroup.class, user3.getUserGroup().getUserGroupId());
		
		close();
	}
	
	public Session session() {
		session = new Configuration().configure().buildSessionFactory().openSession();
		transaction=session.beginTransaction();
		transaction.begin();
		return session;
	}
	public void close() {
		if(session!=null && transaction!=null) {
			transaction.commit();
			session.close();
		}
	}
	public static void main(String[] args) {
		Main main = new Main();
		try {
			Reflex.function(main, "test").run();
		} catch (Exception e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}finally {
			System.exit(0);
		}
		
	}
}

附件