qilixiang012

hibernate 关联关系映射配置

Hibernate关联关系映射配置

一、一对一单向外键关联：

1.1目录结构

1.2 Annotation方式

1.2.1 类图

1.2.2数据库表结构

1.2.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HUSBAND_")
@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1)
public class Husband {
	private BigDecimal id;
	private String name;
	private Wife wife;
	@Id
	@Column(precision=4, scale=0)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	@OneToOne
//@JoinColumn(name="wife_id")//不写也没问题，自动生成的字段也叫wife_id
	public Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity(name="H_WIFE_")
@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")
public class Wife {
	private BigDecimal id;
	private String name;
	@Id
	@Column(precision=4)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

1.3 XML方式

1.3.1 类图

1.3.2 数据库表结构

1.3.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Husband {
	private BigDecimal id;
	private String name;
	private XML_Wife wife;
	public BigDecimal getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public XML_Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(XML_Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Wife {
	private BigDecimal id;
	private String name;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

1.3.4 对象关系映射文件

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Husband" table="H_HUSBAND_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30"></property>
		<many-to-one name="wife" column="wife_id" unique="true" not-null="true" />
		<!--many-to-one是站在当前类XML_Husband的角度来看，XML_Husband与wife是多对一-->
    </class>
</hibernate-mapping>

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Wife" table="H_Wife_XML" dynamic-update="true">
		<id name="id">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30" />
    </class>
</hibernate-mapping>

1.4 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>
		<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
		<property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:silence</property>
		<property name="connection.username">cnuser</property>
		<property name="connection.password">cn830306</property>
		<property name="connection.pool_size">1</property>
		<property name="current_session_context_class">thread</property>
		<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
		<property name="show_sql">true</property>
		<property name="format_sql">true</property>
		<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
		<!--<property name="hbm2ddl.auto">update</property>-->
		<mapping class="com.rongqq.hibernate3.annotation.entity.Husband" />
		<mapping class="com.rongqq.hibernate3.annotation.entity.Wife" />
		<mapping resource="com/rongqq/hibernate3/xml/entity/XML_Husband.hbm.xml" />
		<mapping resource="com/rongqq/hibernate3/xml/entity/XML_Wife.hbm.xml" />
	</session-factory>
</hibernate-configuration>

二、一对一双向外键关联

2.1 Annotation方式

2.1.1 类图

2.1.2 数据库结构图

2.1.3 实体类

@Entity(name="H_HUSBAND_")
@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1)
public class Husband {
	private BigDecimal id;
	private String name;
	private Wife wife;
	@Id
	@Column(precision=4, scale=0)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	@OneToOne
	//@JoinColumn(name="wife_id")//不写也没问题，自动生成的字段也叫wife_id
	public Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

@Entity(name="H_WIFE_")
@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")
public class Wife {
	private BigDecimal id;
	private String name;
	private Husband husband;
	@Id
	@Column(precision=4)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToOne(mappedBy="wife")
	public Husband getHusband() {
		return husband;
	}
	public void setHusband(Husband husband) {
		this.husband = husband;
	}
}

2.2 XML方式

2.2.1 类图

2.2.2 数据库结构图

2.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Husband {
	private BigDecimal id;
	private String name;
	private XML_Wife wife;
	public BigDecimal getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public XML_Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(XML_Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Wife {
	private BigDecimal id;
	private String name;
	private XML_Husband husband;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public XML_Husband getHusband() {
		return husband;
	}
	public void setHusband(XML_Husband husband) {
		this.husband = husband;
	}
}

2.2.4 对象关系映射文件

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Husband" table="H_HUSBAND_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30"></property>
			<many-to-one name="wife" unique="true" not-null="true" >
				<column name="wife_id" precision="4"></column>
		</many-to-one>
    </class>
</hibernate-mapping>

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Wife" table="H_Wife_XML" dynamic-update="true">
		<id name="id">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30" />
		<!-- 这里的wife是XML_Husband类中的属性名，表示这里的关联关系已经由Husband的对象
		映射文件的wife属性上定义过了 -->
		<one-to-one name="husband" property-ref="wife" />
    </class>
</hibernate-mapping>

三、一对一单向主键关联（不重要）

3.1 Annotation方式

3.1.1 类图

3.1.2 数据库表结构

3.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HUSBAND_")
@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1)
public class Husband {
	private BigDecimal id;
	private String name;
	private Wife wife;
	@Id
	@Column(precision=4, scale=0)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	@OneToOne
	@PrimaryKeyJoinColumn
	public Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity(name="H_WIFE_")
@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")
public class Wife {
	private BigDecimal id;
	private String name;
	@Id
	@Column(precision=4)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

注：只生成了表，但是没有外键约束，具体实现还需要查找

3.2 XML方式

3.2.1 类图

3.2.2 数据库表结构

3.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Husband {
	private BigDecimal id;
	private String name;
	private XML_Wife wife;
	public BigDecimal getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public XML_Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(XML_Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import com.rongqq.hibernate3.annotation.entity.Husband;
public class XML_Wife {
	private BigDecimal id;
	private String name;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

3.2.4 对象映射文件

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Husband" table="H_HUSBAND_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="id" precision="4" scale="0" />
			<generator class="foreign">
				<!--  指明具体参考哪一个外键，因为一张表可能存在多个外键 -->
				<param name="property">wife</param>
			</generator>
		</id>
		<property name="name" length="30"></property>
		<one-to-one name="wife" constrained="true"></one-to-one>
    </class>
</hibernate-mapping>

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Wife" table="H_Wife_XML" dynamic-update="true">
		<id name="id">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30" />
    </class>
</hibernate-mapping>

四、一对一双向主键关联（不重要）

4.1 Annotation方式

4.1.1 类图

4.1.2 数据库表结构

4.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HUSBAND_")
@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1)
public class Husband {
	private BigDecimal id;
	private String name;
	private Wife wife;
	@Id
	@Column(precision=4, scale=0)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	@OneToOne
	@PrimaryKeyJoinColumn
	public Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.SequenceGenerator;
@Entity(name="H_WIFE_")
@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")
public class Wife {
	private BigDecimal id;
	private String name;
	private Husband husband;
	@Id
	@Column(precision=4)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToOne
	@PrimaryKeyJoinColumn
	public Husband getHusband() {
		return husband;
	}
	public void setHusband(Husband husband) {
		this.husband = husband;
	}
}

注：同样不产生关联关系，具体实现待查

4.2 XML方式

4.2.1 类图

4.2.2 数据库表结构

4.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Husband {
	private BigDecimal id;
	private String name;
	private XML_Wife wife;
	public BigDecimal getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public XML_Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(XML_Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Wife {
	private BigDecimal id;
	private String name;
	private XML_Husband husband;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public XML_Husband getHusband() {
		return husband;
	}
	public void setHusband(XML_Husband husband) {
		this.husband = husband;
	}
}

4.2.4 对象映射文件

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Husband" table="H_HUSBAND_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="id" precision="4" scale="0" />
			<generator class="foreign">
				<param name="property">wife</param>
			</generator>
		</id>
		<property name="name" length="30"></property>
		<one-to-one name="wife" constrained="true"></one-to-one>
    </class>
</hibernate-mapping>

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Wife" table="H_Wife_XML" dynamic-update="true">
		<id name="id">
			<column name="id" precision="4" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_STUDENT_SEQ_XML</param>
			</generator>
		</id>
		<property name="name" length="30" />
		<one-to-one name="husband" property-ref="wife"></one-to-one>
    </class>
</hibernate-mapping>

五、组件映射

5.1 Annotation方式

5.1.1 类图

5.1.2 数据库表结构

5.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HUSBAND_")
@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1)
public class Husband {
	private BigDecimal id;
	private String name;
	private Wife wife;
	@Id
	@Column(precision=4, scale=0)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")
	public BigDecimal getId() {
		return id;
	}
	@Column(length=30)
	public String getName() {
		return name;
	}
	@Embedded
	public Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
public class Wife {
	private String name;
	private BigDecimal age;
	@Column(name="wifeName")
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Column(precision=3)
	public BigDecimal getAge() {
		return age;
	}
	public void setAge(BigDecimal age) {
		this.age = age;
	}
}

5.2 XML方式

5.2.1 类图

5.2.2 数据库表结构

5.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Husband {
	private BigDecimal id;
	private String name;
	private XML_Wife wife;
	public BigDecimal getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public XML_Wife getWife() {
		return wife;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(XML_Wife wife) {
		this.wife = wife;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Wife {
	private String name;
	private BigDecimal age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public BigDecimal getAge() {
		return age;
	}
	public void setAge(BigDecimal age) {
		this.age = age;
	}
}

5.2.4 对象映射文件

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Husband" table="H_HUSBAND_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="id" precision="4" scale="0" />
			<generator class="foreign">
				<param name="property">wife</param>
			</generator>
		</id>
		<property name="name" length="30"></property>
		<component name="wife">
			<property name="name" column="WIFENAME" />
			<property name="age" column="AGE" precision="3" />
		</component>
    </class>
</hibernate-mapping>

六、多对一单向关联

6.1 Annotation方式

6.1.1 类图（说明：一个人具备多套房子的所有权，这么多套房子属于这个人）

6.1.2 数据库表结构

6.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
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.ManyToOne;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HOUSE_")
@SequenceGenerator(name="HouseGene", sequenceName="H_HOUSE_SEQ", allocationSize=1)
public class House {
	private BigDecimal id;
	private String position;
	private Person person;//House(多)-Person(一)，一个人可以有多个房子，而这些房子属于这一个人
	@Id
	@Column(precision=20)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="HouseGene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	@ManyToOne
	//@JoinColumn(name=””)//可以指定外键名称
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity(name="H_PERSON_")
@SequenceGenerator(name="PersonGene", sequenceName="H_PERSON_SEQ", allocationSize=1)
public class Person {
	private BigDecimal Id;
	private String name;
	@Id
	@Column(precision=21)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="PersonGene")
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

6.2 XML方式

6.2.1 类图（说明：一个人具备多套房子的所有权，这么多套房子属于这个人）

6.2.2 数据库表结构

6.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_House {
	private BigDecimal id;
	private String position;
	private XML_Person person;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	public XML_Person getPerson() {
		return person;
	}
	public void setPerson(XML_Person person) {
		this.person = person;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Person {
	private BigDecimal Id;
	private String name;
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

6.2.4 对象映射文件

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_House" table="H_HOUSE_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="20" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_HOUSE_XML_SEQ</param>
			</generator>
		</id>
		<property name="position"></property>
		<many-to-one name="person">
			<column name="PERSON_ID" precision="21" scale="0" />
		</many-to-one>
    </class>
</hibernate-mapping>

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Person" table="H_PERSON_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="21" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_XML_PERSON_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
    </class>
</hibernate-mapping>

注：（表）设计原则，在多的一方加外键

七、一对多单向关联

7.1 Annotation方式

7.1.1 类图（说明：一个人具备多套房子的所有权，这么多套房子属于这个人）

7.1.2 数据库表结构

7.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
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.OneToMany;
import javax.persistence.SequenceGenerator;
@Entity(name="H_PERSON_")
@SequenceGenerator(name="PersonGene", sequenceName="H_PERSON_SEQ", allocationSize=1)
public class Person {
	private BigDecimal Id;
	private String name;
	private Set<House> houses = new HashSet<House>();
	@Id
	@Column(precision=21)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="PersonGene")
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToMany
	@JoinColumn(name="HOUSE_ID")//不加会生成由一张中间表连接的共三张表
	public Set<House> getHouses() {
		return houses;
	}
	public void setHouses(Set<House> houses) {
		this.houses = houses;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HOUSE_")
@SequenceGenerator(name="HouseGene", sequenceName="H_HOUSE_SEQ", allocationSize=1)
public class House {
	private BigDecimal id;
	private String position;
	@Id
	@Column(precision=20)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="HouseGene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
}

7.2 XML方式

7.2.1 类图（说明：一个人具备多套房子的所有权，这么多套房子属于这个人）

7.2.2 数据库表结构

7.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
public class XML_Person {
	private BigDecimal Id;
	private String name;
	private Set<XML_House> houses = new HashSet<XML_House>();
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<XML_House> getHouses() {
		return houses;
	}
	public void setHouses(Set<XML_House> houses) {
		this.houses = houses;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_House {
	private BigDecimal id;
	private String position;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
}

7.2.4 对象映射文件

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Person" table="H_PERSON_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="21" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_XML_PERSON_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
		<set name="houses">
			<key><!-- 指定H_HOUSE_XML表中的外键字段名，也可以<key column="PERSON_ID" /> -->
				<column name="PERSON_ID" precision="21" />
			</key>
			<one-to-many class="XML_House"/>
		</set>
    </class>
</hibernate-mapping>

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_House" table="H_HOUSE_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="20" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_HOUSE_XML_SEQ</param>
			</generator>
		</id>
		<property name="position"></property>
    </class>
</hibernate-mapping>

八、一对多、多对一双向关联

8.1 Annotation方式

8.1.1 类图

8.1.2 数据库表结构

8.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.SequenceGenerator;
@Entity(name="H_HOUSE_")
@SequenceGenerator(name="HouseGene", sequenceName="H_HOUSE_SEQ", allocationSize=1)
public class House {
	private BigDecimal id;
	private String position;
	private Person person;
	@Id
	@Column(precision=20)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="HouseGene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	@ManyToOne//如果需要指定外键字段使用@JoinColumn(name="PERSON_ID")
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.SequenceGenerator;
@Entity(name="H_PERSON_")
@SequenceGenerator(name="PersonGene", sequenceName="H_PERSON_SEQ", allocationSize=1)
public class Person {
	private BigDecimal Id;
	private String name;
	private Set<House> houses = new HashSet<House>();
	@Id
	@Column(precision=21)
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="PersonGene")
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToMany(mappedBy="person")//参考了对方的属性名
	public Set<House> getHouses() {
		return houses;
	}
	public void setHouses(Set<House> houses) {
		this.houses = houses;
	}
}

8.2 XML方式

8.2.1 类图

8.2.2 数据库表结构

8.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_House {
	private BigDecimal id;
	private String position;
	private XML_Person person;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	public XML_Person getPerson() {
		return person;
	}
	public void setPerson(XML_Person person) {
		this.person = person;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
public class XML_Person {
	private BigDecimal Id;
	private String name;
	private Set<XML_House> houses = new HashSet<XML_House>();
	public BigDecimal getId() {
		return Id;
	}
	public void setId(BigDecimal id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<XML_House> getHouses() {
		return houses;
	}
	public void setHouses(Set<XML_House> houses) {
		this.houses = houses;
	}
}

8.2.4 对象映射文件

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Person" table="H_PERSON_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="21" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_XML_PERSON_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
		<set name="houses">
			<key>
<!—关联表中指向当前类对应表的外键字段名，也可以<key column="PERSON_ID" /> -->
				<column name="PERSON_ID" precision="21" />
			</key>
			<one-to-many class="XML_House"/>
		</set>
    </class>
</hibernate-mapping>

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_House" table="H_HOUSE_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="20" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_HOUSE_XML_SEQ</param>
			</generator>
		</id>
		<property name="position"/>
		<many-to-one name="person" column="PERSON_ID"/>
		<!-- 字段名与对应的XML_Person.hbm.xml中配置的set的key中column的值必须一致 -->
    </class>
</hibernate-mapping>

九、多对多单向关联

9.1 Annotation方式

9.1.1 类图

9.1.2 数据库表结构

9.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
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.SequenceGenerator;
import javax.persistence.Table;
@Entity(name="T")//name是用来在HQL语句中应用的本类的名字
@Table(name="H_TEACHER_")//数据库中当前类对应的表名
@SequenceGenerator(name="Teacher_Gene", sequenceName="H_TEACHER_SEQ", allocationSize=1)
public class Teacher {
	private BigDecimal id;
	private String name;
	private Set<Student> students = new HashSet<Student>();
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="Teacher_Gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@ManyToMany
	@JoinTable(
			name="H_T_S",//指明中间表的名字
			joinColumns={@JoinColumn(name="TEACHER_ID", referencedColumnName="ID")},
//指明中间表参考当前类对应数据库表中的字段ID的外键名为TEACHER_ID
		inverseJoinColumns={@JoinColumn(name="STUDENT_ID",referencedColumnName="ID")}
//指明中间表参考另外一张表中的字段ID的外键名为STUDENT_ID
	)
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
@Entity(name="S")
@Table(name="H_STUDENT_")
@SequenceGenerator(name="Student_Gene", sequenceName="H_STUDENT_SEQ", allocationSize=1)
public class Student {
	private BigDecimal id;
	private String name;
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="Student_Gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

9.2 XML方式

9.2.1 类图

9.2.2 数据库表结构

9.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
public class XML_Teacher {
	private BigDecimal id;
	private String name;
	private Set<XML_Student> students = new HashSet<XML_Student>();
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<XML_Student> getStudents() {
		return students;
	}
	public void setStudents(Set<XML_Student> students) {
		this.students = students;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
public class XML_Student {
	private BigDecimal id;
	private String name;
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

9.2.4 对象映射文件

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Teacher" table="H_TEACHER_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="20" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_TEACHER_XML_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
		<set name="students" table="H_XML_T_S">
			<key column="TEACHER_ID"/>
<!--中间表中指向当前类对应表的外键字段名为TEACHER_ID -->
			<many-to-many class="XML_Student" column="SUTDNET_ID"/>
			<!-- 中间表中指向XML_Student类对应表的外键字段名为STUDENT_ID -->
		</set>
    </class>
</hibernate-mapping>

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Student" table="H_STUDENT_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="21" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_XML_STUDENT_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
    </class>
</hibernate-mapping>

十、多对多双向关联

10.1 Annotation方式

10.1.1 类图

10.1.2 数据库表结构

10.1.3 实体类

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
@Entity(name="S")
@Table(name="H_STUDENT_")
@SequenceGenerator(name="Student_Gene", sequenceName="H_STUDENT_SEQ", allocationSize=1)
public class Student {
	private BigDecimal id;
	private String name;
	private Set<Teacher> teachers = new HashSet<Teacher>();
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="Student_Gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@ManyToMany(mappedBy="students")
	public Set<Teacher> getTeachers() {
		return teachers;
	}
	public void setTeachers(Set<Teacher> teachers) {
		this.teachers = teachers;
	}
}

package com.rongqq.hibernate3.annotation.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
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.SequenceGenerator;
import javax.persistence.Table;
@Entity(name="T")
@Table(name="H_TEACHER_")
@SequenceGenerator(name="Teacher_Gene", sequenceName="H_TEACHER_SEQ", allocationSize=1)
public class Teacher {
	private BigDecimal id;
	private String name;
	private Set<Student> students = new HashSet<Student>();
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="Teacher_Gene")
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@ManyToMany
	@JoinTable(
			name="H_T_S",//指明中间表的名字
		joinColumns={@JoinColumn(name="TEACHER_ID", 
referencedColumnName="ID")},
//指明中间表参考当前类对应数据库表中的字段ID的外键名为TEACHER_ID
			inverseJoinColumns={@JoinColumn(name="STUDENT_ID", 
referencedColumnName="ID")}
//指明中间表参考另外一张表中的字段ID的外键名为STUDENT_ID
	)
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
}

10.2 XML方式

10.2.1 类图

10.2.2 数据库表结构

10.2.3 实体类

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
public class XML_Teacher {
	private BigDecimal id;
	private String name;
	private Set<XML_Student> students = new HashSet<XML_Student>();
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<XML_Student> getStudents() {
		return students;
	}
	public void setStudents(Set<XML_Student> students) {
		this.students = students;
	}
}

package com.rongqq.hibernate3.xml.entity;
import java.math.BigDecimal;
import java.util.HashSet;
import java.util.Set;
public class XML_Student {
	private BigDecimal id;
	private String name;
	private Set<XML_Teacher> teachers = new HashSet<XML_Teacher>();
	public BigDecimal getId() {
		return id;
	}
	public void setId(BigDecimal id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<XML_Teacher> getTeachers() {
		return teachers;
	}
	public void setTeachers(Set<XML_Teacher> teachers) {
		this.teachers = teachers;
	}
}

10.2.4 对象映射文件

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Teacher" table="H_TEACHER_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="20" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_TEACHER_XML_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
		<set name="students" table="H_XML_T_S">
			<key column="TEACHER_ID"/>
			<!-- 中间表中指向当前类对应表的外键字段名为TEACHER_ID -->
			<many-to-many class="XML_Student" column="STUDENT_ID"/>
			<!-- 中间表中指向XML_Student类对应表的外键字段名为STUDENT_ID -->
		</set>
    </class>
</hibernate-mapping>

<?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 package="com.rongqq.hibernate3.xml.entity">
	<class name="XML_Student" table="H_STUDENT_XML" dynamic-update="true">
		<id name="id" type="big_decimal">
			<column name="ID" precision="21" scale="0" />
			<generator class="sequence">
				<param name="sequence">H_XML_STUDENT_SEQ</param>
			</generator>
		</id>
		<property name="name"/>
		<set name="teachers" table="H_XML_T_S">
		<!-- 相关联的类的映射文件两侧定义的中间表名字必须一致 -->
			<key column="STUDENT_ID" />
<!-- 中间表中指向当前类对应表的外键字段名 -->
			<many-to-many class="XML_Teacher" column="TEACHER_ID" />
			<!-- 中间表中指向与当前类关联的另外一个类所对应表的外键字段名 -->
		</set>
    </class>
</hibernate-mapping>

参考链接：

http://wenku.baidu.com/link?url=mNEhY-Z75gbW63N71g8S2WI6cI96eG3DC2IuDswSVjA94Y3Tf74_ZJfQUuO_-FtTHDf6QgotdLj9vhGMa1Q0_U5U6ENJFxv-j84WE7XtRda

http://blog.csdn.net/zzjjiandan/article/details/20456495

http://jinnianshilongnian.iteye.com/blog/1522591

你可能感兴趣的:(Hibernate)

Spring Boot 配置文件常用配置属性详解（application.properties / application.yml）
前言SpringBoot的一大优势就是通过简单的配置文件即可快速定制应用行为，而无需编写大量XML配置或Java代码。SpringBoot使用application.properties或application.yml作为核心配置文件，支持丰富的配置属性。本文将详细介绍SpringBoot常用的配置属性，包括：服务器配置数据源配置JPA/Hibernate配置日志配置Thymeleaf/模板引擎配
Spring技术内幕——深入解析Spring架构与设计原理（一）IOC实现原理 Eric_xiaoQ 框架 spring
转自：http://www.javaeye.com/topic/493282?page=1简单来说，自己的软件产品是一个基于互联网的SaaS协同软件平台,操作简单，支持流程定义，管理和多种客户端-像短信，MSN，智能手机什么的（我这里就不多做什么广告了），也有一个企业版的版本，使用的技术框架是hibernate+Spring+Wicket，下面是Linux和MySQL，还有云计算的平台的使用，以支
Java 开发必备：Hibernate 实战技巧大揭秘 AI开发架构师 java hibernate 开发语言 ai
Java开发必备：Hibernate实战技巧大揭秘关键词：Hibernate、ORM、Session、事务管理、缓存优化、HQL、延迟加载摘要：本文从实战角度出发，结合生活案例与代码示例，深度解析Hibernate核心机制与开发技巧。无论你是Hibernate新手还是需要进阶的开发者，都能通过本文掌握从概念理解到项目落地的全流程技能，重点解决N+1查询、缓存优化、事务管理等高频问题，助你成为Jav
Java 反射（Reflection） YiHanXii java后端开发 java 开发语言
什么是反射？反射（Reflection）是Java提供的一种机制，允许程序在运行时动态地检查类的信息，以及操作类的属性、方法和构造器。通过反射，程序可以动态地访问和修改对象的行为，而不需要在编译时确定具体的类型或行为。反射是Java的动态性特性之一，常用于框架（如Spring、Hibernate等）和工具类库中，实现高度灵活的功能。反射的核心类反射的核心类和接口都在java.lang.reflec
hibernate中session增删改操作及事务提交的问题
一、问题回顾Sessionsession=MySessionFactory.getSession();//Transactiontx=null;//try{//Stringhql="deleteformtd_reportwhereID=1";//tx=session.beginTransaction();//Connectioncon=session.connection();//Prepared
Spring @Repository注解深度解析与实践 bemyrunningdog spring boot sql 数据库
以下是在您提供的@Repository注解解析基础上补充完善的系统化学习笔记，结合核心机制、实践细节及扩展场景，保留原有框架的同时增强深度与实用性：一、核心作用与定位（增强解析）组件注册与异常转换的双重角色Bean注册：继承自@Component，被@ComponentScan扫描后注册为SpringBean。异常统一化：通过AOP代理捕获JDBC/JPA/Hibernate等原生异常，转换为Sp
存储过程都有什么替代方案? 瑞信卡券提货系统存储过程
存储过程的替代方案主要有以下几种：ORM（对象关系映射）：ORM框架，如Hibernate、EntityFramework等，在客户端逻辑和数据库之间插入了一个层。这些框架能够生成SQL语句以在数据库上执行，从而避免了直接编写存储过程。使用ORM，开发人员可以在应用层表达复杂的业务逻辑，而无需将逻辑分散到存储过程中。ORM框架允许开发人员使用面向对象的方式操作数据库，提供了更高层次的抽象，使得代码
《MyBatis的运行原理》
一.MyBatis是什么？MyBatis是⼀个开源、轻量级的数据持久化框架，是JDBC和Hibernate的替代⽅案，MyBatis内部封装了JDBC，简化了加载驱动、创建连接、创建statement等繁杂的过程，开发者只需要关注SQL语句本身。二.MyBatis执行流程1.MyBatis与JDBC想要学习了解MyBatis，我们首先需要从JDBC入手并立足于JDBC，才能深入的理解MyBatis
高校毕业设计选题管理系统的SSH框架实现 Kiki-2189
本文还有配套的精品资源，点击获取简介：该系统基于SSH架构（Struts2、Spring和Hibernate）建立，旨在简化和优化高校毕业设计的选题流程，提高教学管理效率。系统根据角色（管理员、教师、学生）分配不同功能与权限，涵盖用户管理、课题发布与审核、文档提交和评估等。采用了JSP技术进行用户界面的构建，并利用SSH框架的特性简化了开发流程，提高了系统的稳定性和交互性。1.SSH框架应用于Ja
spring-data-jpa+spring+hibernate+druid配置
参考链接：http://doc.okbase.net/liuyitian/archive/109276.htmlhttp://my.oschina.net/u/1859292/blog/312188最新公司的web项目需要用到spring-data-jpa作为JPA的实现框架，同时使用阿里巴巴的开源数据库连接池druid。关于这两种框架的介绍我在这里就不多赘述。直接进入配置页面：spring的配置
ORM框架实战：MyBatis与JPA深度对比及企业级开发全攻略（终极优化版） Android洋芋 mybatis tomcat java ORM框架数据库优化
一、ORM框架技术演进与选型策略1.1ORM框架的演进史JDBC时代：手动管理连接池、事务、SQL注入风险。Hibernate/JPA：2006年JPA标准化，推动ORM框架自动化。MyBatis：2010年诞生，强调SQL控制权，解决Hibernate“过度自动化”问题。2020年后趋势：MyBatis-Plus：提供Lambda表达式、自动分页等功能。SpringDataJPA：通过方法名自动
JAVA——JAVA知识点集锦（下） Faith_chao JAVA基础 JAVA基础知识点
转自：http://blog.csdn.net/Scythe666/article/details/51994782这部分主要是开源JavaEE框架方面的内容，包括Hibernate、MyBatis、Spring、SpringMVC等，由于Struts2已经是明日黄花，在这里就不讨论Struts2的面试题，如果需要了解相关内容，可以参考我的另一篇文章《Java面试题集（86-115）》。此外，这篇
数据库面试题06为什么要用MyBatis框架？
MyBatis是一个优秀的持久层框架（虽然常被归类为“半自动化”ORM，但其核心更侧重于SQL映射），它在Java开发中广泛应用，尤其在需要精细控制SQL、处理复杂查询或与遗留数据库交互的场景中备受青睐。选择MyBatis的主要原因可以总结为以下几点：对SQL的完全控制权（核心优势）:开发者手写SQL：MyBatis要求开发者直接编写SQL语句（在XML映射文件或注解中）。这与Hibernate/
Java 领域 Hibernate 的事务传播行为详解 Java大师兄学大数据AI应用开发 java hibernate 开发语言 ai
Java领域Hibernate的事务传播行为详解关键词：Hibernate、事务传播、Spring事务、PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、事务隔离级别、数据库事务摘要：本文将深入探讨Hibernate框架中的事务传播行为机制。我们将从基础概念出发，详细解析七种标准的事务传播行为类型，包括REQUIRED、SUPPORTS、MANDATORY
01.SpringBoot集成持久层框架MyBatis详细指南全栈凯哥全栈项目 spring boot mybatis 后端
文章目录1.MyBatis简介1.1什么是MyBatis？1.2MyBatis的核心特点1.3MyBatisvsJPA/Hibernate1.3.1MyBatis的优势1.3.2JPA/Hibernate的优势1.4MyBatis核心组件1.4.1SqlSessionFactory1.4.2SqlSession1.4.3Mapper接口1.4.4Configuration2.SpringBoot集
MyBatis初识：为什么选择它？双力臂404 mybatis基础 mybatis 开发语言
前言在Java持久层框架的江湖中，MyBatis像一位特立独行的侠客——它既不像JDBC那样需要开发者赤手空拳打天下，也不似Hibernate般用ORM大法将SQL完全封装。这种"中间派"的定位，恰恰解决了开发者在两个极端之间的长期困扰。JDBC的"三座大山"//典型JDBC代码片段Connectionconn=null;PreparedStatementps=null;ResultSetrs=n
application.yml 文件配置解析前端小努力 spring boot
application.yml文件配置解析application.yml文件是SpringBoot应用程序中用于配置各种属性的主要文件之一。它可以配置的内容非常广泛，包括但不限于以下几类：服务器配置端口号服务器地址会话管理SSL配置数据源配置数据库URL用户名和密码JDBC驱动类名连接池配置JPA和Hibernate配置DDL自动更新策略SQL显示方言配置日志配置日志级别日志文件路径安全性配置基本
Java 里 Hibernate 的多租户架构实现 AI大模型应用实战 java hibernate 架构 ai
Java里Hibernate的多租户架构实现关键词：Java、Hibernate、多租户架构、多租户实现、数据隔离摘要：本文深入探讨了在Java中利用Hibernate实现多租户架构的相关技术。首先介绍了多租户架构的背景和意义，包括目的、预期读者、文档结构以及相关术语。接着阐述了Hibernate多租户的核心概念，给出了原理和架构的文本示意图与Mermaid流程图。详细讲解了核心算法原理，通过Py
Hibernate中save与saveOrUpdate的差异解析代码的余温 hibernate oracle 数据库
在Hibernate中，save()和saveOrUpdate()都是用于持久化对象的方法，但它们的适用场景和行为有显著差异：1.save()方法核心行为：仅适用于瞬时态（Transient）对象（即新创建、未与Session关联的对象）。会立即为对象分配一个标识符（ID），并计划在事务提交时执行INSERT操作。若尝试对已持久化（Persistent）或游离态（Detached）对象调用save
Java：动态代理Proxy 十秒耿直拆包选手 Java Programming up java
动态代理在Java中有着广泛的应用，比如SpringAOP、Hibernate数据查询、测试框架的后端mock、RPC远程调用、Java注解对象获取、日志、用户鉴权、全局性异常处理、性能监控，甚至事务处理等。基本概念假设有一个表示接口的Class对象(有可能只包含一个接口)，它的确切类型在编译时无法知道。要想构造一个实现这些接口的类，就需要使用newInstance方法或反射找出这个类的构造器。但
MyBatis 简介 hweiyu00 技术栈杂谈 mybatis
MyBatis简介MyBatis是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射，能够帮助开发者将Java对象与数据库表进行灵活映射，简化数据持久化操作。以下从多个维度详细介绍MyBatis：一、核心定位与优势轻量级框架：相比Hibernate等全自动ORM框架，MyBatis更“轻”，开发者需手动编写SQL语句，灵活性更高，便于优化性能。ORM映射功能：通过XML或注解方式，将J
No row with the given identifier exists 解决方法 dazhong2012
博客分类：异常、错误处理Hibernate有两张表,a和b.产生此问题的原因就是a里做了关联或者(特殊的多对一映射,实际就是一对一)来关联b.当hibernate查找的时候,b里的数据没有与a相匹配的,这样就会报Norowwiththegivenidentifierexists这个错.(一句话,就是数据的问题!)假如说,a里有自身的主键id1,还有b的主键id2,这两个字段.如果hibenrate
Hibernate ORM 映射深度解析后端
在Java持久层技术体系中，Hibernate作为经典的ORM（对象关系映射）框架，通过自动化对象与数据库表的映射关系，显著提升了数据访问层的开发效率。本文从核心映射机制、高级特性、性能优化及面试高频问题四个维度，结合源码与工程实践，系统解析Hibernate的ORM映射原理与最佳实践。一、核心映射机制1.1基础映射类型映射类型描述示例注解实体映射将Java类映射到数据库表@Entity,@Tab
分库分表之-ShardingJDBC技术详解
ShardingJDBC技术详解一、ShardingJDBC简介ShardingJDBC是一款轻量级的分布式数据库中间件，定位为在Java的JDBC层提供额外服务。它以客户端直连数据库的方式，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。适用于任何基于JDBC的ORM框架，如JPA、Hibernate、Mybatis、SpringJDB
基于 SSH 框架的保险业务管理系统设计与实现：从需求到落地的全栈解析
一、引言：保险行业数字化转型的迫切需求随着保险行业竞争的白热化，传统手工管理模式在客户信息处理、订单跟踪、赔偿审核等环节暴露出效率低下、数据安全隐患等问题。据统计，国内中小型保险公司平均每天需处理数千条客户数据，手工录入错误率高达5%，严重影响业务效率。在此背景下，基于SSH框架（Struts+Spring+Hibernate）和B/S架构的保险业务管理系统应运而生，通过信息化手段实现业务流程规范
掌握Spring Boot数据库集成：用JPA和Hibernate构建高效数据交互与版本控制 2的n次方_ spring boot 数据库 hibernate
在现代应用开发中，数据库操作是核心环节之一。SpringBoot提供了简化数据库集成的强大工具，而JPA（JavaPersistenceAPI）和Hibernate是两种非常流行的ORM（对象关系映射）框架，可以帮助我们将对象与数据库表关联，实现自动化的持久化操作。本文将详细介绍如何通过SpringBoot集成JPA和Hibernate，构建高效的数据交互系统，并讨论数据迁移与版本控制的最佳实践。
【java】乐观锁的实现和注意细节 CC大煊技术方案 java 数据库
文章目录1.前言乐观锁vs.悲观锁：基本概念对比使用场景及优势简述2.基于版本号的乐观锁实现代码示例注意事项3.基于CAS机制的乐观锁实现核心思想代码示例关键点说明4.框架中的乐观锁实践MyBatis中基于版本号的乐观锁实现示例代码JPA（Hibernate）中的乐观锁@Version注解关键点与底层原理示例代码5.乐观锁使用中的注意细节并发冲突后的重试机制与失败处理事务管理中的注意事项数据持久化
Spring Boot 参数验证阿乾之铭 Spring Boot Spring MVC mysql java 数据库
一、依赖配置首先确保在pom.xml中添加了以下依赖：org.springframework.bootspring-boot-starter-validation这个依赖包含了HibernateValidator（JSR-380规范的实现）和必要的Spring验证支持。验证执行流程：当请求到达Controller方法时，Spring会检查方法参数上的@Valid或@Validated注解触发Met
Java ORM框架深度解析：Hibernate、MyBatis与Spring Data JPA对比樽酒ﻬق java面试 java hibernate mybatis
目录JavaORM框架深度解析：Hibernate、MyBatis与SpringDataJPA对比引言：ORM在Java开发中的作用理解对象关系映射（ORM）主流JavaORM框架概览HibernateMyBatisSpringDataJPAEclipseLinkOpenJPA其他值得注意的框架主要特性综合比较易用性和学习曲线性能特点灵活性和定制选项社区支持和文档事务管理缓存机制延迟加载和即时加载
Hibernate简介 yuren_xia 前端技术 hibernate java 后端
Hibernate是一个开源的对象关系映射（ORM）框架，用于将Java对象映射到关系型数据库，简化数据库操作。它避免了直接编写SQL的繁琐，通过面向对象的方式操作数据。核心概念对象关系映射（ORM）将Java类映射到数据库表，类的属性映射到表的字段。SessionFactory线程安全的全局对象，用于创建Session（类似数据库连接池）。Session数据库操作的核心接口，提供CRUD方法（非
Spring的注解积累 yijiesuifeng spring 注解
用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。如：在base-package指明一个包 <context:component-sc
传感器百合不是茶 android 传感器
android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件下面就以重力传感器为例; 1,在onCreate中获得传感器服务 private SensorManager sm;// 获得系统的服务 private Sensor sensor;// 创建传感器实例 @Override protected void
[光磁与探测]金吕玉衣的意义 comsci
这是一个古代人的秘密:现在告诉大家信不信由你们: 穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星这就是为什么古代
精简的反序打印某个数沐刃青蛟打印
以前看到一些让求反序打印某个数的程序。比如：输入123，输出321。记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。似乎最后是用到%和/方法解决的。而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）代码如下： long num, num1=0;
PHP：6种方法获取文件的扩展名 IT独行者 PHP 扩展名
PHP：6种方法获取文件的扩展名 1、字符串查找和截取的方法 1 $extension = substr ( strrchr ( $file , '.' ), 1); 2、字符串查找和截取的方法二 1 $extension = substr
面试111 文强chu 面试
1事务隔离级别有那些，事务特性是什么（问到一次） 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问） 3 struts默认提供了那些拦截器（一次） 4 过滤器和拦截器的区别（频率也挺高） 5 final，finally final
XML的四种解析方式小桔子 dom jdom dom4j sax
在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。　　预备　　测试环境：　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server
wordpress中常见的操作 aichenglong 中文注册 wordpress 移除菜单
1 wordpress中使用中文名注册解决办法 1)使用插件 2)修改wp源代码进入到wp-include/formatting.php文件中找到 function sanitize_user( $username, $strict = false
小飞飞学管理-1 alafqq 管理
项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。结合我自己经历写下心得对于公司选拔和培养项目经理的制度有什么毛病呢？ 1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 3，公司对项目经理的工作缺乏进行指
IO输入输出部分探讨百合不是茶 IO
//文件处理在处理文件输入输出时要引入java.IO这个包； /* 1，运用File类对文件目录和属性进行操作 2，理解流，理解输入输出流的概念 3，使用字节/符流对文件进行读/写操作 4，了解标准的I/O 5，了解对象序列化 */ //1，运用File类对文件目录和属性进行操作 //在工程中线创建一个text.txt
getElementById的用法 bijian1013 element
getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。返回具有指定ID属性值的第一个对象的一个引用。语法： &n
励志经典语录 bijian1013 励志人生
经典语录1: 哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
[MongoDB学习笔记三]MongoDB分片 bit1129 mongodb
MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。本篇介绍MongoDB的切片(Sharding) 1.何时需要分片 &nbs
【Spark八十三】BlockManager在Spark中的使用场景 bit1129 manager
1. Broadcast变量的存储，在HttpBroadcast类中可以知道 2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
yum方式部署zabbix ronin47 yum方式部署zabbix
安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
Hibernate4和MySQL5.5自动创建表失败问题解决方法 byalias J2EE Hibernate4
今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： ①创建hibernate.cfg.xml文件 ②创建持久化对象 ③创建*.hbm.xml映射文件 ④编写hibernate相应代码在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
Netty源码学习-FrameDecoder bylijinnan java netty
Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 为什么每次有新数据到达时，都会调用decode方法？ 2.Dec
SQL行列转换方法 chicony 行列转换
create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) insert into tb values('三星' , '0-5' , 74) insert into tb values('三星' , '10-15' , 83) insert into tb values('苹果' , '0-5' , 93)
中文编码测试 ctrain 编码
循环打印转换编码 String[] codes = { "iso-8859-1", "utf-8", "gbk", "unicode" }; for (int i = 0; i < codes.length; i++) { for (int j
hive 客户端查询报堆内存溢出解决方法 daizj hive 堆内存溢出
hive> select * from t_test where ds=20150323 limit 2; OK Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 问题原因： hive堆内存默认为256M 这个问题的解决方法为：修改/us
人有多大懒，才有多大闲 (评论『卓有成效的程序员』) dcj3sjt126com 程序员
卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
Eclipse简单有用的配置 dcj3sjt126com eclipse
1、显示行号 Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers 2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
在tomcat上面安装solr4.8.0全过程 eksliang Solr solr4.0后的版本安装 solr4.8.0安装
转载请出自出处： http://eksliang.iteye.com/blog/2096478 首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了第一步：当然是下载去官网上下载最新的solr版本，下载地址
Android APP通用型拒绝服务、漏洞分析报告 gg163 漏洞 android APP 分析
点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。 0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。针对序列化对象而出现的拒绝服务主要
HoverTree项目已经实现分层 hvt 编程 .net Web C#ASP.ENT
HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
Google Maps API v3: Remove Markers 移除标记天梯梦 google maps api
Simply do the following: I. Declare a global variable: var markersArray = []; II. Define a function: function clearOverlays() { for (var i = 0; i < markersArray.length; i++ )
jQuery选择器总结 lq38366 jquery 选择器
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
基础数据结构和算法六：Quick sort sunwinner Algorithm Quicksort
Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作刘星宇 html Web
今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。方法如下：
Mybatis实用Mapper SQL汇总示例 wdmcygah sql mysql mybatis 实用
Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，