hibernatexml方式和注解方式实现单实体映射和继承关系映射，eclipse实现

最新推荐文章于 2021-08-11 13:41:43 发布
最新推荐文章于 2021-08-11 13:41:43 发布
阅读量241 收藏
点赞数 1
分类专栏： hibernate 文章标签： hibernate java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42936836/article/details/104627495
版权

刚刚学习完hibernate持久化框架，在这里记录一下学习的过程：一共分为一下几种关系映射：

1、单实体映射
2、继承关系映射（三种）
3、一对一关系映射
4、一对多关系映射
5、多对多关系映射

这篇文章只写了前两种方式，后面三种会在下一个里面详细的写；
注意，以下代码在使用注解方式时，我都把@Column这个注解省略了，因为我的列名和属性名都是相同的；如果不一样的话，需要加上这个注解；注解的具体写法在单实体映射中有体现；

  • 单实体映射：基于xml
    基本目录
    1、导入相关jar包
    2、创建实体类Customer，以及实体类相关的配置文件(Customer.hbm.xml)

实体类相关代码：

package com.hibernate.entity;
public class Customer {
	private int id;
	private String name;
	private int age;
	private String descripe;
	public String getDescripe() {
		return descripe;
	}
	public void setDescripe(String descripe) {
		this.descripe = descripe;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Customer() {}
}

配置文件：
class中的name是实体类的名称，table是数据库表的名称，id是主键，有且只有一个，property是其他的属性，可以有多个；
其中，id中的generator子元素用来指定OID生成器，increment 采用 Hibernate 数值递增的方式；identity 采用数据库提供的自增长方式；
assigned 主键由应用逻辑产生。

<?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.hibernate.entity">
    <class name="Customer" table="customer">
       <id name="id" type="int" >
			<column name="id"></column> 
       		<generator class="increment"></generator>
       </id>
       <property name="descripe" type="java.lang.String" column="descripe"></property>
       <property name="age" type="int" column="age"></property>
       <property name="name" type="java.lang.String" column="name"></property>
    </class>
</hibernate-mapping>

3、创建hibernate工具类：所有的持久化框架都有这个工具类

package com.hibernate.util;

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

public class HibernateUtil {
	//持久化相关的接口;:对接口的实现
	private static SessionFactory sessionFactory;
	static {
		final StandardServiceRegistry registry=new StandardServiceRegistryBuilder()
		        .configure().build();
		try {
			sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
		}catch(Exception e) {
			e.printStackTrace();
			sessionFactory=null;
			StandardServiceRegistryBuilder.destroy(registry);
		}
	}
	public static SessionFactory getSessionFactory() {
		// TODO Auto-generated method stub
		return sessionFactory;
	} 
	public static void closeSessionFactory() {
	    sessionFactory.close();
	}
}

4、创建配置文件：连接到数据库，并且基于xml和注解在其中的配置不同

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <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://localhost:3306/customer</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.connection.password"></property>
  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  
<!--基于xml的配置 -->
  <mapping resource="com/hibernate/entity/Customer.hbm.xml"/>
</session-factory>
</hibernate-configuration>

5、最后进行测试

package com.hibernate.ui;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.hibernate.entity.Customer;
import com.hibernate.util.HibernateUtil;
public class Test {
	public static void main(String[] args) {
		Session session=HibernateUtil.getSessionFactory().openSession();
		Transaction tx=session.beginTransaction();
		
		Customer customer=new Customer();
		customer.setId(1);
		customer.setDescripe("可乐加冰");
		customer.setAge(22);
		customer.setName("可乐加冰");
		//增
		session.save(customer);
		//查（id=2）的数据
		Customer customer2=session.get(Customer.class, new Integer(2))
		//改
		customer2.setName("可乐不加冰");
		//删
		sission.delete(customer);
		
		tx.commit();
		session.close();
		HibernateUtil.closeSessionFactory();
	}
}

完成！

  • 单实体映射：基于注解
    基本目录
    1、导入相关jar包
    2、创建实体类，直接在实体类里面使用注解
package com.hibernate.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;

/*声明是一个实体类*/
/*为实体类指定对应的数据库表*/
@Entity
@Table(name="customer")
public class Customer {
	//声明实体类的OID属性
	//声明OID的生成策略
	//使用hibernate提供的生成策略
	@Id
	@GeneratedValue(generator="increment_generator")
	@GenericGenerator(name="increment_generator", strategy="increment")
	private int id;
	//当列名和属性名相同时，可以省略这个注解
	@Column(name="name")
	private String name;
	private int age;
	private String descripe;
	public String getDescripe() {
		return descripe;
	}
	public void setDescripe(String descripe) {
		this.descripe = descripe;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

3、创建hibernate工具类：所有的持久化框架都有这个工具类

package com.hibernate.util;

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

public class HibernateUtil {
	//持久化相关的接口;:对接口的实现
	private static SessionFactory sessionFactory;
	static {
		final StandardServiceRegistry registry=new StandardServiceRegistryBuilder()
		        .configure().build();
		try {
			sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
		}catch(Exception e) {
			e.printStackTrace();
			sessionFactory=null;
			StandardServiceRegistryBuilder.destroy(registry);
		}
	}
	public static SessionFactory getSessionFactory() {
		// TODO Auto-generated method stub
		return sessionFactory;
	} 
	public static void closeSessionFactory() {
	    sessionFactory.close();
	}
}

4、创建配置文件：连接到数据库，并且基于xml和注解在其中的配置不同

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <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://localhost:3306/customer</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.connection.password"></property>
  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  <!-- 基于注解的配置 -->
  <mapping class="com.hibernate.entity.Customer"/>
</session-factory>
</hibernate-configuration>

5、最后进行测试

package com.hibernate.ui;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.hibernate.entity.Customer;
import com.hibernate.util.HibernateUtil;

public class Test {
	public static void main(String[] args) {
		Customer customer=new Customer();
		customer.setId(1);
		customer.setDescripe("可乐加冰");
		customer.setAge(23);
		customer.setName("可乐加冰");
		Session session=HibernateUtil.getSessionFactory().openSession();
		Transaction tx=session.beginTransaction();
		//增
		session.save(customer);
		//查
//		Customer customer2=session.get(Customer.class, new Inter)
		//改
//		customer2.setName("yy");
		//删
//		sission.delete(customer2);
		tx.commit();
		session.close();
		HibernateUtil.closeSessionFactory();	
	}
}
  • 继承关系映射：每个具体类对应一张表（基于xml）
    员工有按日结工资和按小时结工资：
    目录结构

1、导入相关jar包
2、编写实体类：一个父类和两个子类，并且两个具体的子类都有配置文件

父类

package com.hibernate.entity;

import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;

import org.hibernate.annotations.GenericGenerator;
public class Employee {
	private int id;
	private String name;	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Employee() {}

}

子类：hourlyEmployee

package com.hibernate.entity;

import javax.persistence.Entity;
import javax.persistence.Table;
public class HourlyEmployee extends Employee {
	private Double rate;
	public Double getRate() {
		return rate;
	}
	public void setRate(Double rate) {
		this.rate = rate;
	}
}

子类的配置文件：hourlyEmployee.hbm.xml

<?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.hibernate.entity">
    <class name="HourlyEmployee" table="hourlyEmployee">
    	<id name="id" column="id">
    		<generator class="increment"></generator>
    	</id>
    	<property name="name" column="name"></property>
    	<property name="rate" column="rate"></property>
    </class>
</hibernate-mapping>

子类：salariedEmployee

package com.hibernate.entity;

import javax.persistence.Entity;
import javax.persistence.Table;
public class SalariedEmployee extends Employee{
	private Double salary;
	public Double getSalary() {
		return salary;
	}
	public void setSalary(Double salary) {
		this.salary = salary;
	}
}

子类的配置文件：salariedEmployee.hbm.xml

<?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.hibernate.entity">
    <class name="SalariedEmployee" table="salariedEmployee">
    	<id name="id" column="id">
    		<generator class="increment"></generator>
    	</id>
    	<property name="name" column="name"></property>
    	<property name="salary" column="salary"></property>
    </class>
</hibernate-mapping>

3、编写hibernate：HibernateUtil工具类

package com.hibernate.util;

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

public class HibernateUtil {
		//持久化相关的接口;:对接口的实现
		private static SessionFactory sessionFactory;
		static {
			final StandardServiceRegistry registry=new StandardServiceRegistryBuilder()
			        .configure().build();

			try {
				sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
			}catch(Exception e) {
				e.printStackTrace();
				sessionFactory=null;
				StandardServiceRegistryBuilder.destroy(registry);
			}
		}
		
		public static SessionFactory getSessionFactory() {
			// TODO Auto-generated method stub
			return sessionFactory;
		} 
		public static void closeSessionFactory() {
		    sessionFactory.close();
		}
}

4、创建配置文件：连接到数据库（hibernate.cfg.xml）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <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://localhost:3306/test</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.connection.password"></property>
  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  
  <!-- 用xml进行配置的话，是下面两行代码 -->
  <mapping resource="com/hibernate/entity/HourlyEmployee.hbm.xml"/>
  <mapping resource="com/hibernate/entity/SalariedEmployee.hbm.xml"/> 
  
</session-factory>
</hibernate-configuration>

5、编写测试类

package com.hibernate.ui;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.hibernate.entity.HourlyEmployee;
import com.hibernate.entity.SalariedEmployee;
import com.hibernate.util.HibernateUtil;

public class Test {
	public static void main(String[] args) {
		/*
		 * 
		 *继承关系映射
		 * 基于注解和基于xml实现的两个类之间的继承关系的第一种方法：
		 * 每个具体的类对应一张表，来完成继承关系（Table per concrete class）
		 * Table per concrete class
		 * Table per class hierarchy
		 * Table per class
		 * 
		 * */
		Session session=HibernateUtil.getSessionFactory().openSession();
		Transaction tx=session.beginTransaction();
		HourlyEmployee he=new HourlyEmployee();
		he.setId(1);
		he.setName("可乐");
		he.setRate(700.0);
		SalariedEmployee se=new SalariedEmployee();
		se.setId(1);
		se.setName("加冰");
		se.setSalary(5000.0);
		//增
		session.save(he);
		session.save(se);
		tx.commit();
		session.close();
		HibernateUtil.closeSessionFactory();
	}
}
  • 继承关系映射：每个具体类对应一张表（基于注解）

1、导入jar包
2、编写实体类，以及在实体类中进行配置
继承父类的一些属性，但不用父类作为映射实体时使用注解：@MappedSuperclass。

父类：

package com.hibernate.entity;

import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import org.hibernate.annotations.GenericGenerator;

@MappedSuperclass
public class Employee {
	@Id
	@GeneratedValue(generator="increment_generator")
	@GenericGenerator(name="increment_generator",strategy="increment")
	private int id;
	private String name;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Employee() {}

}

子类：hourlyEmployee

package com.hibernate.entity;

import javax.persistence.Entity;
import javax.persistence.Table;

@Entity
@Table(name="hourlyemployee")
public class HourlyEmployee extends Employee {
	private Double rate;
	public Double getRate() {
		return rate;
	
	public void setRate(Double rate) {
		this.rate = rate;
	}
}

子类：SalariedEmployee

package com.hibernate.entity;

import javax.persistence.Entity;
import javax.persistence.Table;
@Entity
@Table(name="salariedemployee")
public class SalariedEmployee extends Employee{
	private Double salary;

	public Double getSalary() {
		return salary;
	}
	public void setSalary(Double salary) {
		this.salary = salary;
	}
}

3、编写hibernate工具类

package com.hibernate.util;

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

public class HibernateUtil {
		//持久化相关的接口;:对接口的实现
		private static SessionFactory sessionFactory;
		static {
			final StandardServiceRegistry registry=new StandardServiceRegistryBuilder()
			        .configure().build();

			try {
				sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
			}catch(Exception e) {
				e.printStackTrace();
				sessionFactory=null;
				StandardServiceRegistryBuilder.destroy(registry);
			}
		}
		
		public static SessionFactory getSessionFactory() {
			// TODO Auto-generated method stub
			return sessionFactory;
		} 
		public static void closeSessionFactory() {
		    sessionFactory.close();
		}
}

4、编写配置文件：hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <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://localhost:3306/test</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.connection.password"></property>
  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  
  <!-- 基于注解的配置 -->
  <mapping class="com.hibernate.entity.HourlyEmployee"/>
  <mapping class="com.hibernate.entity.SalariedEmployee"/>
  <mapping class="com.hibernate.entity.Employee"/>
</session-factory>
</hibernate-configuration>

5、编写测试文件进行测试

package com.hibernate.ui;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.hibernate.entity.HourlyEmployee;
import com.hibernate.entity.SalariedEmployee;
import com.hibernate.util.HibernateUtil;

public class Test {
	public static void main(String[] args) {
		
		/*
		 * 
		 * 继承关系映射
		 * 基于注解和基于xml实现的两个类之间的继承关系的第一种方法：
		 * 每个具体的类对应一张表，来完成继承关系（Table per concrete class）
		 * Table per concrete class
		 * Table per class hierarchy
		 * Table per class
		 * 
		 * */
		Session session=HibernateUtil.getSessionFactory().openSession();
		Transaction tx=session.beginTransaction();
		HourlyEmployee he=new HourlyEmployee();
		he.setId(1);
		he.setName("cola");
		he.setRate(700.0);
		SalariedEmployee se=new SalariedEmployee();
		se.setId(1);
		se.setName("coll");
		se.setSalary(5000.0);
		//增
		session.save(he);
		session.save(se);
		tx.commit();
		session.close();
		HibernateUtil.closeSessionFactory();
	}
}
  • 继承关系映射：父类对应一张表（基于xml）
    结构
    1、导入jar包
    2、编写实体类以及实体类的配置文件

父类：

package com.hibernate.entity;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.MappedSuperclass;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;
public class Employee {
	private int id;
	private String name;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Employee() {}
}

父类的配置文件：

<?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.hibernate.entity">

<!-- 如果employee这个类的本身也需要被持久化，可以在class元素中设置discriminator-value属性的值 -->

    <class name="Employee" table="employeen">
    	<id name="id">
    		<generator class="increment"></generator>
    	</id>
    	<!-- 必须紧跟id元素：用于指定表中区分子类类型的字段-->
    	<discriminator column="employee_type"></discriminator>
    	<property name="name"></property>
    	<!-- subclass元素中的name 属性：子类类名；
			 discriminator-value 属性：子类中区分类型字段的取值；
			 property子元素：映射子类属性。 -->
    	<subclass name="HourlyEmployee" discriminator-value="HE">
    		<property name="rate"></property>
    	</subclass>
    	<subclass name="SalariedEmployee" discriminator-value="SE">
    		<property name="salary"></property>
    	</subclass>
    </class>
</hibernate-mapping>

子类：hourlyEmployee

package com.hibernate.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Table;
public class HourlyEmployee extends Employee {
	private Double rate;
	public Double getRate() {
		return rate;
	}
	public void setRate(Double rate) {
		this.rate = rate;
	}
}

子类：salariedEmployee

package com.hibernate.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Table;

public class SalariedEmployee extends Employee{
	private Double salary;
	public Double getSalary() {
		return salary;
	}
	public void setSalary(Double salary) {
		this.salary = salary;
	}
}

3、编写hibernate工具类

package com.hibernate.util;

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

public class HiernateUtil {
		//持久化相关的接口;:对接口的实现
		private static SessionFactory sessionFactory;
		static {
			final StandardServiceRegistry registry=new StandardServiceRegistryBuilder()
			        .configure().build();
			try {
				sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
			}catch(Exception e) {
				e.printStackTrace();
				sessionFactory=null;
				StandardServiceRegistryBuilder.destroy(registry);
			}
		}
		
		public static SessionFactory getSessionFactory() {
			// TODO Auto-generated method stub
			return sessionFactory;
		} 
		public static void closeSessionFactory() {
		    sessionFactory.close();
		}
}

4、编写配置文件：hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <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://localhost:3306/test</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.connection.password"></property>
  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  
  <!-- 用xml进行配置 -->
  <mapping resource="com/hibernate/entity/Employee.hbm.xml"/> 
  
</session-factory>
</hibernate-configuration>

5、编写测试文件进行测试

package com.hibernate.ui;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.hibernate.entity.HourlyEmployee;
import com.hibernate.entity.SalariedEmployee;
import com.hibernate.util.HiernateUtil;

public class Test {

	public static void main(String[] args) {
		/*
		 * 
		 *继承关系映射
		 * 基于xml实现的两个类之间的继承关系的第二种方法：
		 * 使用父类对应一个表来完成关系映射（Table per class hierarchy）
		 * 通过父类去映射一个表
		 * 使用的数据库是一个表
		 * Table per concrete class
		 * Table per class hierarchy
		 * Table per class
		 * 
		 * */
		Session session=HiernateUtil.getSessionFactory().openSession();
		Transaction tx=session.beginTransaction();
		HourlyEmployee he=new HourlyEmployee();
		he.setId(1);
		he.setName("cola");
		he.setRate(700.0);
		SalariedEmployee se=new SalariedEmployee();
		se.setId(1);
		se.setName("cool");
		se.setSalary(5000.0);
		//增
		session.save(he);
		session.save(se);
		tx.commit();
		session.close();
		HiernateUtil.closeSessionFactory();
	}
}
  • 继承关系映射：父类对应一张表（基于注解）
    1、导入jar包
    2、编写实体类

父类：

package com.hibernate.entity;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.MappedSuperclass;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="employeen")
/*指定策略*/
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
/*指定区分的字段名*/
@DiscriminatorColumn(name="employee_type")
public class Employee {
	@Id
	@GeneratedValue(generator="increment_generator")
	@GenericGenerator(name="increment_generator",strategy="increment")
	private int id;
	private String name;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Employee() {}
}

子类：hourlyEmployee

package com.hibernate.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Table;
@Entity

@DiscriminatorValue(value="HE")
public class HourlyEmployee extends Employee {
	private Double rate;

	public Double getRate() {
		return rate;
	}

	public void setRate(Double rate) {
		this.rate = rate;
	}
}

子类：salariedEmployee

package com.hibernate.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Table;

@Entity
@DiscriminatorValue(value="SE")
public class SalariedEmployee extends Employee{
	private Double salary;

	public Double getSalary() {
		return salary;
	}

	public void setSalary(Double salary) {
		this.salary = salary;
	}

}

3、编写hibernate工具类

package com.hibernate.util;

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

public class HiernateUtil {
		//持久化相关的接口;:对接口的实现
		private static SessionFactory sessionFactory;
		static {
			final StandardServiceRegistry registry=new StandardServiceRegistryBuilder()
			        .configure().build();

			try {
				sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
			}catch(Exception e) {
				e.printStackTrace();
				sessionFactory=null;
				StandardServiceRegistryBuilder.destroy(registry);
			}
		}
		
		public static SessionFactory getSessionFactory() {
			// TODO Auto-generated method stub
			return sessionFactory;
		} 
		public static void closeSessionFactory() {
		    sessionFactory.close();
		}
}

4、编写配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <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://localhost:3306/test</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.connection.password"></property>
  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  
  <!-- 基于注解的配置 -->
  <mapping class="com.hibernate.entity.HourlyEmployee"/>
  <mapping class="com.hibernate.entity.SalariedEmployee"/>
  <mapping class="com.hibernate.entity.Employee"/>
  
</session-factory>
</hibernate-configuration>

5、编写测试类文件

package com.hibernate.ui;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.hibernate.entity.HourlyEmployee;
import com.hibernate.entity.SalariedEmployee;
import com.hibernate.util.HiernateUtil;

public class Test {

	public static void main(String[] args) {
		/*
		 * 继承关系映射
		 * 基于注解和基于xml实现的两个类之间的继承关系的第二种方法：
		 * 使用父类对应一个表来完成关系映射（Table per class hierarchy）
		 * 通过父类去映射一个表
		 * 使用的数据库是一个表
		 * Table per concrete class
		 * Table per class hierarchy
		 * Table per class
		 * 
		 * */
		
		Session session=HiernateUtil.getSessionFactory().openSession();
		Transaction tx=session.beginTransaction();
		HourlyEmployee he=new HourlyEmployee();
		he.setId(1);
		he.setName("cola");
		he.setRate(700.0);
		SalariedEmployee se=new SalariedEmployee();
		se.setId(1);
		se.setName("coll");
		se.setSalary(5000.0);
		//增
		session.save(he);
		session.save(se);
		tx.commit();
		session.close();
		HiernateUtil.closeSessionFactory();

	}
}
  • 继承关系映射：每个类对应一张表（基于xml）
    基本目录

1、导入相关jar包

2、编写三个实体类和父类的映射文件
父类：

package com.hibernate.entity;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.MappedSuperclass;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;

public class Employee {
	private int id;
	private String name;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Employee() {}
}

子类：hourlyEmployee

package com.hibernate.entity;

import javax.persistence.Entity;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;

public class HourlyEmployee extends Employee {
	private Double rate;
	public Double getRate() {
		return rate;
	}
	public void setRate(Double rate) {
		this.rate = rate;
	}
}

子类：salariedEmployee

package com.hibernate.entity;

import javax.persistence.Entity;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;

public class SalariedEmployee extends Employee{
	private Double salary;

	public Double getSalary() {
		return salary;
	}

	public void setSalary(Double salary) {
		this.salary = salary;
	}
}

父类映射文件：

<?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.hibernate.entity">
 	<class name="Employee" table="employee1">
 		<id name="id">
 			<generator class="increment"></generator>
 		</id>
 		<property name="name"></property>
 		<joined-subclass name="HourlyEmployee" table="hourlyemployee1">
 			<key column="employeeID"></key>
 			<property name="rate"></property>
 		</joined-subclass>
 		<joined-subclass name="SalariedEmployee" table="salariedemployee1">
 			<key column="employeeID"></key>
 			<property name="salary"></property>
 		</joined-subclass>
 	</class>
</hibernate-mapping>

3、编写hibernate工具类

package com.hibernate.util;

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

public class HiernateUtil {
		//持久化相关的接口;:对接口的实现
		private static SessionFactory sessionFactory;
		static {
			final StandardServiceRegistry registry=new StandardServiceRegistryBuilder()
			        .configure().build();

			try {
				sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
			}catch(Exception e) {
				e.printStackTrace();
				sessionFactory=null;
				StandardServiceRegistryBuilder.destroy(registry);
			}
		}
		
		public static SessionFactory getSessionFactory() {
			// TODO Auto-generated method stub
			return sessionFactory;
		} 
		public static void closeSessionFactory() {
		    sessionFactory.close();
		}
}

4、编写配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <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://localhost:3306/test</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.connection.password"></property>
  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  
  <!-- 用xml进行配置 -->
   <mapping resource="com/hibernate/entity/Employee.hbm.xml"/> 
   
</session-factory>
</hibernate-configuration>

5、编写测试类

package com.hibernate.ui;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.hibernate.entity.HourlyEmployee;
import com.hibernate.entity.SalariedEmployee;
import com.hibernate.util.HiernateUtil;

public class Test {
	public static void main(String[] args) {
		
		
		/*
		 * 
		 * 继承关系映射
		 * 基于xml实现的两个类之间的继承关系的第三种方法：
		 * 每个类对应一张表，来完成继承关系（com.hibernate.ui）
		 * Table per concrete class
		 * Table per class hierarchy
		 * Table per class
		 * 
		 * */
		Session session=HiernateUtil.getSessionFactory().openSession();
		Transaction tx=session.beginTransaction();
		HourlyEmployee he=new HourlyEmployee();
		he.setId(1);
		he.setName("cola");
		he.setRate(700.0);
		SalariedEmployee se=new SalariedEmployee();
		se.setId(1);
		se.setName("cool");
		se.setSalary(5000.0);
		//增
		session.save(he);
		session.save(se);
		tx.commit();
		session.close();
		HiernateUtil.closeSessionFactory();
	}
}

  • 继承关系映射：每个类对应一张表（基于注解）

    1、导入相关jar包

    2、编写三个实体类和父类的映射文件

    父类：

package com.hibernate.entity;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.MappedSuperclass;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="employee1")
/*指定策略*/
@Inheritance(strategy=InheritanceType.JOINED)
public class Employee {
	@Id
	@GeneratedValue(generator="increment_generator")
	@GenericGenerator(name="increment_generator",strategy="increment")
	private int id;
	private String name;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Employee() {}

}

子类：hourlyEmployee

package com.hibernate.entity;

import javax.persistence.Entity;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
@Entity
@Table(name="hourlyemployee1")
@PrimaryKeyJoinColumn(name="employeeID")
public class HourlyEmployee extends Employee {
	private Double rate;

	public Double getRate() {
		return rate;
	}

	public void setRate(Double rate) {
		this.rate = rate;
	}
}

子类：salariedEmplyee

package com.hibernate.entity;

import javax.persistence.Entity;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
@Entity
@Table(name="salariedemployee1")
@PrimaryKeyJoinColumn(name="employeeID")
public class SalariedEmployee extends Employee{
	private Double salary;

	public Double getSalary() {
		return salary;
	}
	public void setSalary(Double salary) {
		this.salary = salary;
	}
}

3、编写hibernate工具类

package com.hibernate.util;

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

public class HiernateUtil {
		//持久化相关的接口;:对接口的实现
		private static SessionFactory sessionFactory;
		static {
			final StandardServiceRegistry registry=new StandardServiceRegistryBuilder()
			        .configure().build();

			try {
				sessionFactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
			}catch(Exception e) {
				e.printStackTrace();
				sessionFactory=null;
				StandardServiceRegistryBuilder.destroy(registry);
			}
		}
		
		public static SessionFactory getSessionFactory() {
			// TODO Auto-generated method stub
			return sessionFactory;
		} 
		public static void closeSessionFactory() {
		    sessionFactory.close();
		}
	    


}

4、编写配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <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://localhost:3306/test</property>
  <property name="hibernate.connection.username">root</property>
  <property name="hibernate.connection.password"></property>
  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.format_sql">true</property>
  
  <!-- 基于注解的配置 -->
   <mapping class="com.hibernate.entity.HourlyEmployee"/>
   <mapping class="com.hibernate.entity.SalariedEmployee"/>
   <mapping class="com.hibernate.entity.Employee"/>
   
</session-factory>
</hibernate-configuration>

5、编写测试类


package com.hibernate.ui;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.hibernate.entity.HourlyEmployee;
import com.hibernate.entity.SalariedEmployee;
import com.hibernate.util.HiernateUtil;

public class Test {
	public static void main(String[] args) {
		
		
		/*
		 * 
		 * 继承关系映射
		 * 基于注解l实现的两个类之间的继承关系的第三种方法：
		 * 每个类对应一张表，来完成继承关系（com.hibernate.ui）
		 * Table per concrete class
		 * Table per class hierarchy
		 * Table per class
		 * 
		 * */
		Session session=HiernateUtil.getSessionFactory().openSession();
		Transaction tx=session.beginTransaction();
		HourlyEmployee he=new HourlyEmployee();
		he.setId(1);
		he.setName("cola");
		he.setRate(700.0);
		SalariedEmployee se=new SalariedEmployee();
		se.setId(1);
		se.setName("cool");
		se.setSalary(5000.0);
		//增
		session.save(he);
		session.save(se);
		tx.commit();
		session.close();
		HiernateUtil.closeSessionFactory();

	}
}
可乐加冰灬
关注
专栏目录
让Hibernate同时支持xml和注解两种映射方式
10-18
让Hibernate同时支持xml和注解两种映射方式
Hibernate框架学习之注解映射实体类
weixin_30258027的博客
11-13 237
前面的相关文章中，我们已经介绍了使用XML配置文件映射实体类及其各种类型的属性的相关知识。然而不论是时代的潮流还是臃肿繁杂的配置代码告诉我们，注解配置才是更人性化的设计，于是学习了基本的映射实体类的基本注解，此处做一点总结，后续文章将陆续更新使用注解的方式管理配置各种映射关联关系。本篇主要涉及以下内容： 使用最基本的注解映射一个实体类 使用注解映射属性 使用注解映射主键 其他特殊类型的...
hibernate Xml 方式
小程序
01-28 1万+
A 标签解析:  (1) dynamic-insert="false" 和 dynamic-update="false"             1.这两者的意思为,如果字段没有赋值,那么这个字段不会被更新或者增加.  (2) outer-join="true" 和 fetch="join/select"             1.antype.class的外键是被引入的,设置了oute
Hibernate--使用xml配置映射关系
weixin_30408309的博客
10-27 128
写在前面： 　　配置实体类与数据库的映射关系，有两种方式： 　　1.使用*.hbm.xml 　　2.使用@注解 　　二：xml的配置方式： eg:员工的xml配置文件: <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC ...
hibernate--Xml关系映射
热门推荐
雾里看花
11-30 1万+
一、一对一关联 1、主键关联：两表共用同一ID Example：每个人拥有一张身份证。 （1）单向 public class Person { //人类 private int id; private String userId; private String name; private String email; private IdentityCard identi
Hibernate映射关系配置：XML方式和注解方式
03-27
这种映射有两种主要的实现方式：XML配置和注解配置。 **XML方式** 1. **hibernate.cfg.xml**：这是Hibernate的全局配置文件，用于配置数据源、方言、缓存等信息。 2. **实体类映射文件**：如`User.hbm.xml`，它将...
eclipse hibernate 反向生成带注解的实体类-步骤说明--详细
10-07
### Eclipse Hibernate 反向生成带注解的实体类——步骤详解 #### 一、创建数据库管理器 在开始之前，我们需要确保已经安装了Eclipse IDE，并且具备基本的数据库操作能力。下面详细介绍如何在Eclipse中创建数据库...
Hibernate关系映射XML生成工具
02-08
此外，随着技术的发展，许多现代ORM框架如JPA和Spring Data JPA提供了更高级的抽象，可以完全摆脱XML映射，转而使用注解来描述对象关系映射。 总的来说，"Middlegen-Hibernate-r5"是面向Hibernate用户的一款实用...
jpa/hibernate继承注解
03-22
在Java Persistence API (JPA) 和 Hibernate ORM 框架中，继承注解是用于处理对象关系映射（ORM）中的类继承结构的关键概念。这些注解帮助开发者将数据库表的设计与面向对象的代码结构相匹配，使得在复杂的业务场景...
java实体映射
08-19
Java实体映射，通常指的是...在实际项目中，如MySQL这样的关系型数据库通常会结合Java ORM框架，如Hibernate或MyBatis，实现数据表和POJO类之间的映射。通过理解并熟练掌握这一技术，可以更好地进行企业级应用的开发。
整理笔记---Hibernate的xml与Annotation配置映射关系
好看的皮囊千篇一律有趣的灵魂万里挑一
08-03 1374
有三个java类,分别用Hibernate的xml配置方法和Annotation注解方法实现这三个类之间的映射关系 - 班级和专业之间（一对多） - 专业和班级之间（多对一） - 学生和班级之间（多对一） - 班级和学生之间（一对多）Hibernate的Annotation方法ClassRoom.javapackage com.xing.hibernate_hql_annotat
ssh和mysql配置xml_SSH整合之Hibernate配置：xml方式
weixin_42190623的博客
02-03 105
XML方式：1.导入hibernate包，以及数据库驱动文件。2.生成hibernate配置文件：hibernate.cfg.xml/p>"-//Hibernate/Hibernate Configuration DTD//EN""http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">trueorg.hibe...
利用XML配置实体列表
weixin_33796177的博客
05-07 153
Xml的好处自然有很多，在软件中用xml可以让软件方便的实现多语言版，在数据传输中它能够以很好的组织结构交换信息，同时利用xpath可以方便的解析，在持久化中它能很好的描述业务数据……          本文主要讲通过读取xml配置实现对不同数据实体的统一处理，生成表现table，当然生成div也是可以的。以table为例。 代码中没有进行异常处理，请见谅，只是写出了思路！      xm...
hibernate的继承映射(xml版)
qq_38777614的博客
04-06 248
所有子类映射到一张表（1张表） UML图 （1）实体类 public class Person { //使用uuid,必须是String类型,int类型不支持 private Integer pid; private String name; //省了get/set } public class Programmer extends Person { private Strin...
eclipse通过hibernate tools逆向工程生成hbm.xml和实体类
07-29 272
1.给自己的eclipse添加hibernate tools plugin添加方式：http://download.jboss.org/jbosstools/updates/stable/kepler/—》 * Abridged JBoss Tools --》hibernate tools 3.7.1 2.右上角open perspective（视图菜单） 添加Databas...
Hibernate实体关系映射
Julyraining的博客
12-05 413
Hibernate的实体关系映射包括一对多、多对一、多对多这三种类型。 一般前两种是组合使用，成为一个双向多对一映射。（上一篇文章中的情况） 而多对多则分两种情况： 1.多对多只是为了表明二者的联系，不包含其他属性。 2.多对多不只是表明二者联系，而且这个联系也有自身的属性。 如职工Employee和项目Project是多对多的关系。 对于第一种情况，可以直接使用Hiberna
Hibernate继承映射详解（xml版本）
aiwokache的博客
08-11 142
参考：csdn(25条消息) Hibernate继承映射详解_鹏霄万里展雄飞-CSDN博客 https://blog.csdn.net/wangpeng047/article/details/7280981 https://blog.csdn.net/qq_21225505/article/details/81809776
java hibernate用注解 mysql例子_【译】Spring 4 + Hibernate 4 + Mysql + Maven集成例子（注解 + XML）...
weixin_42324688的博客
01-18 91
前言本文将基于注解配置, 集成Spring 4和Hibernate 4，开发一个增删改查应用，涉及以下内容：创建Hibernate实体保存数据到mysql数据库中在事务transaction内部执行增删改查操作典型企业应用中不同层之间的交互基于注解配置当然，我们也会给出XML配置作为对比。涉及的技术及开发工具Spring 4.0.6.RELEASEHibernate Core 4.3.6.Fina...
Eclipse Hibernate: 新手指南-反向生成带注解实体类详细步骤
在这个过程中，Hibernate会自动生成带有注解的实体类，这些注解用于描述数据之间的关系和映射规则。 5. 配置Hibernate配置文件：完成表的映射后，还需要创建或编辑Hibernate配置文件（通常是hibernate.cfg.xml）。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值