Hibernate Annotation (Hibernate JPA注解) 实例

最新推荐文章于 2024-04-24 22:51:49 发布
最新推荐文章于 2024-04-24 22:51:49 发布
阅读量88 收藏
点赞数
分类专栏： SSH2 文章标签： java 数据库 开发工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangpingjing/article/details/84129499
版权

hibernate: 3.6

 

数据库 oracle

 

CUSTOMER表

-- Create table
create table CUSTOMER
(
  ID   NUMBER not null,
  NAME VARCHAR2(20)
)
tablespace FM
  pctfree 10
  initrans 1
  maxtrans 255
  storage
  (
    initial 64
    minextents 1
    maxextents unlimited
  );
-- Create/Recreate primary, unique and foreign key constraints
alter table CUSTOMER
  add constraint COUSTOMER_PKID primary key (ID)
  disable;

 

ORDERS表

-- Create table
create table ORDERS
(
  ID          NUMBER not null,
  ORDERNUMBER VARCHAR2(20),
  CUSTOMERID  NUMBER not null
)
tablespace FM
  pctfree 10
  initrans 1
  maxtrans 255
  storage
  (
    initial 64
    minextents 1
    maxextents unlimited
  );
-- Create/Recreate primary, unique and foreign key constraints
alter table ORDERS
  add constraint ORDER_PKID primary key (ID)
  disable;
alter table ORDERS
  add constraint CUSTOMER_FK foreign key (CUSTOMERID)
  references CUSTOMER (ID) on delete cascade
  disable;

 

 

hibernate.cfg.xml

 

 <!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 name="foo">
  <property name="show_sql">true</property>
  <property name="myeclipse.connection.profile">
   oraclejdbc
  </property>
  <property name="connection.url">
   jdbc:oracle:thin:@10.8.205.70:1521:orcl
  </property>
  <property name="connection.username">sspm</property>
  <property name="connection.password">sspm</property>
  <property name="connection.driver_class">
   oracle.jdbc.driver.OracleDriver
  </property>
  <property name="dialect">
   org.hibernate.dialect.Oracle9Dialect
  </property>
  <!-- 不使用JPA
  <mapping resource="com/sspm/hibernate/test/Customer.hbm.xml" />
  <mapping resource="com/sspm/hibernate/test/Order.hbm.xml" />
   -->
   <mapping class="com.hibernate.annotation.test.Customer" />
     <mapping class="com.hibernate.annotation.test.Order" />
 </session-factory>
</hibernate-configuration>

 

 

利用Hibernate的逆向工程生成：

 

 Customer.java

package com.hibernate.annotation.test;

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

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

/**
 * Customer entity.
 * 
 * @author MyEclipse Persistence Tools
 */

@Entity
@Table(name="Customer",catalog="sspm")
public class Customer implements java.io.Serializable {

	// Fields

	/**
	 * 
	 */
	private static final long serialVersionUID = 6947291600466684677L;

	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="SQ_CUSTOMER")//通过Sequence来实现表主键自增，这种方式依赖于数据库是否有SEQUENCE，如果没有就不能用
	//SequenceGenerator 的名称必须匹配其 startegy 设置为 SEQUENCE 的 GeneratedValue 的名称
	//如果oracle程序没有按照hibernater设置的sequence自增长。可以在@SequenceGenerator中加入allocationSize = 1,默认情况下，JPA 持续性提供程序使用的分配大小为 50
	@SequenceGenerator(name="SQ_CUSTOMER",sequenceName="SQ_CUSTOMER_ID",allocationSize = 1)
	@Column(name = "id", nullable = false)
	private Long id;
	
	@Column(name = "NAME")
	private String name;
	
	@OneToMany(cascade = CascadeType.ALL, mappedBy = "customer")//指向多的那方的pojo的关联外键字段对应的对象属性名称
	private Set<Order> orderses = new HashSet(0);

	// Constructors

	/** default constructor */
	public Customer() {
	}

	/** full constructor */
	public Customer(String name, Set orderses) {
		this.name = name;
		this.orderses = orderses;
	}

	// Property accessors

	public Long getId() {
		return this.id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Set getOrderses() {
		return this.orderses;
	}

	public void setOrderses(Set orderses) {
		this.orderses = orderses;
	}

}

 

Order.java

package com.hibernate.annotation.test;

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;
import javax.persistence.Table;

/**
 * Orders entity.
 * 
 * @author MyEclipse Persistence Tools
 */

@Entity     
@Table(name = "ORDERS")
public class Order implements java.io.Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 6146682583191452711L;

	// Fields
	@Id
	@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="SQ_ORDER")//通过Sequence来实现表主键自增，这种方式依赖于数据库是否有SEQUENCE，如果没有就不能用     
	@SequenceGenerator(name="SQ_ORDER",sequenceName="SQ_ORDER_ID",allocationSize = 1)
	@Column(name = "id", nullable = false)
	private Long id;
	
	@JoinColumn(name = "CUSTOMERID", referencedColumnName = "id")//设置对应数据表的列名和引用的数据表的列名     
	@ManyToOne//设置在“一方”pojo的外键字段上 
	private Customer customer;

	@Column(name = "ORDERNUMBER")
	private String ordernumber;

	// Constructors

	/** default constructor */
	public Order() {
	}

	/** minimal constructor */
	public Order(Customer customer) {
		this.customer = customer;
	}

	/** full constructor */
	public Order(Customer customer, String ordernumber) {
		this.customer = customer;
		this.ordernumber = ordernumber;
	}

	// Property accessors

	public Long getId() {
		return this.id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public Customer getCustomer() {
		return this.customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}

	public String getOrdernumber() {
		return this.ordernumber;
	}

	public void setOrdernumber(String ordernumber) {
		this.ordernumber = ordernumber;
	}

}

 

CustomerAction.java

package com.hibernate.annotation.test;
import java.util.Iterator;
import java.util.List;

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

public class CustomerAction {
		private Customer customer;
		private List<Customer> listCustomer;

		public Customer getCustomer() {
			return customer;
		}

		public void setCustomer(Customer customer) {
			this.customer = customer;
		}

		public List<Customer> getListCustomer() {
			return listCustomer;
		}

		public void setListCustomer(List<Customer> listCustomer) {
			this.listCustomer = listCustomer;
		}

		/** * 添加客户 * */
		public void addCustomer(Customer customer) {
			Session s = null;
			Transaction tx = null;
			try {
				s = HibernateUtil.getSession();
				tx = s.beginTransaction();
				s.save(customer);
				tx.commit();
			} catch (Exception e) {
				if (tx != null) {
					tx.rollback();
				}
				e.printStackTrace();
			} finally {
				if (s != null) {
					s.close();
				}
			}
		}

		/** * 删除客户 * */
		public void deleteCustomer(Customer customer) {
			Session s = null;
			Transaction tx = null;
			try {
				s = HibernateUtil.getSession();
				tx = s.beginTransaction();
				s.delete(customer);
				tx.commit();
			} catch (Exception e) {
				if (tx != null) {
					tx.rollback();
				}
				e.printStackTrace();
			} finally {
				if (s != null) {
					s.close();
				}
			}
		}

		/** * 更新客户 * */
		public void update(Customer customer, String name) {
			Session s = null;
			Transaction tx = null;
			try {
				s = HibernateUtil.getSession();
				tx = s.beginTransaction();
				customer.setName(name);
				s.update(customer);
				tx.commit();
			} catch (Exception e) {
				if (tx != null) {
					tx.rollback();
				}
				e.printStackTrace();
			} finally {
				if (s != null) {
					s.close();
				}
			}
		}

		/** * 查询客户 * */
		public Customer findCustomer(Long id) {
			Session s = null;
			Transaction tx = null;
			try {
				s = HibernateUtil.getSession();
				tx = s.beginTransaction();
				customer = (Customer) s.get(Customer.class, id);
				tx.commit();
			} catch (Exception e) {
				if (tx != null) {
					tx.rollback();
				}
				e.printStackTrace();
			} finally {
				if (s != null) {
					s.close();
				}
			}
			return customer;
		}

		/** * 查找所有的客户 * */
		public List<Customer> findAll() {
			Session s = null;
			Transaction tx = null;
			try {
				s = HibernateUtil.getSession();
				tx = s.beginTransaction();
				Query query = s
						.createQuery("from Customer as a order by id asc");
				listCustomer = query.list();
				for (Iterator iter = listCustomer.iterator(); iter.hasNext();) {
					Customer customer = (Customer) iter.next();
					System.out.println("客户ID是：" + customer.getId() + "客户姓名是："
							+ customer.getName());
				}
				tx.commit();
			} catch (Exception e) {
				if (tx != null) {
					tx.rollback();
				}
				e.printStackTrace();
			} finally {
				if (s != null) {
					s.close();
				}
			}
			return listCustomer;
		}
}

 

 

OrderAction.java

package com.hibernate.annotation.test;

import java.util.Iterator;
import java.util.List;

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

public class OrderAction {
	private Order order;
	private List<Order> listorder;

	public Order getorder() {
		return order;
	}

	public void setorder(Order order) {
		this.order = order;
	}

	public List<Order> getListorder() {
		return listorder;
	}

	public void setListorder(List<Order> listorder) {
		this.listorder = listorder;
	}

	public void addorder(Order order) {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			s.save(order);
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
			e.printStackTrace();
		} finally {
			if (s != null) {
				s.close();
			}
		}
	}

	/** * 删除用户 * */
	public void deleteorder(Order order) {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			s.delete(order);
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
			e.printStackTrace();
		} finally {
			if (s != null) {
				s.close();
			}
		}
	}

	public void update(Order order, String number) {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			order.setOrdernumber(number);
			s.update(order);
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
			e.printStackTrace();
		} finally {
			if (s != null) {
				s.close();
			}
		}
	}

	public Order findorder(Long id) {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			order = (Order) s.get(Order.class, id);
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
			e.printStackTrace();
		} finally {
			if (s != null) {
				s.close();
			}
		}
		return order;
	}

	public List<Order> findAll() {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			Query query = s.createQuery("from Order as a order by id asc");
			listorder = query.list();
			for (Iterator iter = listorder.iterator(); iter.hasNext();) {
				Order order = (Order) iter.next();
				System.out.println("订单ID是：" + order.getId() + "订单数目是："
						+ order.getOrdernumber());
			}
			tx.commit();
		} catch (Exception e) {
			if (tx != null) {
				tx.rollback();
			}
			e.printStackTrace();
		} finally {
			if (s != null) {
				s.close();
			}
		}
		return listorder;
	}
}

 

测试test.java

package com.hibernate.annotation.test;

public class Test {
	public static void main(String args[]) {
		Customer customer = new Customer();
		customer.setName("baidu6");
		CustomerAction ca = new CustomerAction();
		/**
		 * * 添加对象 *
		 */
		ca.addCustomer(customer);

		OrderAction oa = new OrderAction();
		Order order = new Order();
		order.setOrdernumber("6zz");
		order.setCustomer(customer);
		oa.addorder(order);
	}
}

 

 

wangpingjing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate annotation JPA 一对多，多对多
11-04
使用学生（student）、老师（teacher）、班级（class）反映出Hibernate annotation JPA 的一对多、多对多、多对一的关联。或许对您有用
学习JPA——Hibernate Annotation使用实例
zznj1123的专栏
12-16 88
目前，JPA（Java Persistence API）的使用范围越来越广，作为Java EE 5.0平台标准的ORM规范，得到了诸如：Hibernate、TopLink、OpenJpa等ORM框架的支持，同时还是EJB 3.0的重要组成部分。JPA的宗旨是为POJO提供持久化标准规范。它能够脱离容器独立运行，方便开发和测试。本文将通过一个小实例来说明如何在Hibernate中使用JPA，来达到简...
hibernate使用jpa进行注解开发
liao0801_123的博客
04-28 509
今天开发的时候，对于这两个注解使用情况不是很了解，所以特意在此记录下下班后自己学习的成果。 在进入今天的主题前，我们先来了解下，关于一些定义的解释。什么是JPA？ JPA全称Java Persistence API，其通过JDK 5.0（或以上版本）的注解或XML配置方式来描述 对象－关系表 的映射关系，并将运行期的实体对象持久化到数据库中。JPA与Hibernate的关系是怎样的？ JPA的总体...
@Column注解及属性详解
热门推荐
别样的风采是我
05-17 20万+
@Column注解用来标识实体类中属性与数据表中字段的对应关系（1）源码：/* * Copyright (c) 2008, 2009, 2011 Oracle, Inc. All rights reserved. * * This program and the accompanying materials are made available under the * terms of t...
Hibernate JPA 注解分析
路边烧卖
09-09 750
Hibernate JPA 注解分析 1、常用注解 @Entity（必须） 应用于实体类，并且使用默认的ORM规则，即 Class 名对应数据库表中表名，Class 字段名即表中的字段名（如想改变这种默认的ORM规则，就要使用 @Table 来改变 Class 名与数据库中表名的映射规则，@Column 来改变 Class 字段名与DB中表的字段名的映射规则） 元数据属性说明： name（可选）：表名 下面的代码说明，Customer类对应数据库中的Customer表，其中name为可选，缺省类名即表名
Hibernate的Annotation版Hello world实例
09-02
主要介绍了Hibernate的Annotation版Hello world实现方法,详细分析了Annotation的具体使用步骤与Hello world实现方法,需要的朋友可以参考下
hibernate 注解 annotation 教程
10-24
hibernate 注解 annotation 教程
学习JPA——Hibernate_Annotation使用实例
04-17
学习JPA——Hibernate_Annotation使用实例学习JPA——Hibernate_Annotation使用实例学习JPA——Hibernate_Annotation使用实例
Hibernate Annotation库
03-19
hibernate annotation库所需要引入的三个jar包。
hibernate annotation hibernate3
07-09
hibernate annotation hibernate3
string模拟实现
m0_73969414的博客
04-23 934
c++中string的模拟实现，面试必会知识点
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
qq_251836457的博客
04-18 903
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
PageHelper实现分页查询
m0_63849044的博客
04-24 694
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
javaweb-SpringBoot基础
kussm_的博客
04-20 1124
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
2.8 构建gradle环境
蚊者逆袭的博客
04-18 2271
Gradle是一种现代化的构建工具，用于自动化地构建、测试和部署软件项目。它是一种基于JVM（Java虚拟机）的构建工具，最初是为了解决Apache Ant和Apache Maven等传统构建工具的一些限制而开发的。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 109
待更新。
Web前端 Javascript笔记5
cycyzh的博客
04-18 994
script>'console.log("哈哈哈佳人们好困")'}, 3000)​let t1 = setTimeout('console.log("你们看到这句话的时候我早已身价百万！！")', 4000)​</script>3秒，四秒后出来的东西，出现前会返回计时器编号。
Java | 冒泡排序算法实现
最新发布
yingzix688的博客
04-24 502
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
Annotation有什么注解
07-15
在Java中，有许多已经定义好的注解（Annotation），用于在代码中添加元数据信息或提供特定的行为。以下是一些常见的Java注解： 1. `@Override`：用于标记方法覆盖父类或实现接口中的方法。如果标记的方法没有正确地...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值