关于hibernate和的jpa使用经验（关联字段与关联表OneToOne、OneToMany、ManyToMany）

一、 jpa入门使用经验小结

**********************************注解数据库表的属性**********************************
1. @Entity ：指出该Java类为实体类，将映射到指定的数据库=====>class前
2. @Table：说明该实体类在数据库中对应表名(不同名必用)=====>class前
3. @Id ：映射主键（放在getter方法之前）=====>变量属性前/getter方法之前
4. @GeneratedValue ：用于标注主键的生成策略，通过strategy属性指定=====>变量属性前
5. @Column ：映射数据表的列名，指定unique，length等(不同名必用)=====>变量属性前/getter方法之前
6. @Basic ： 表示一个简单的属性到数据库表的字段的映射,对于没有任何标注的 getXxxx() 方法,默认即为@Basic
7. @Transient ：如果该属性在数据库表中没有对应的字段，则需要添加该注解，表示该字段不需要映射，避免加载失败
8. @Temporal ：可以用来调整date精度
9. @Temporal(TemporalType.DATE):日期显示格式 ,默认为TIMESTAMP 。
   DATE：yyyy-mm-dd  
   TIME ：yyyy:mm:dd  . 
   TIMESTAMP ：yyyy-mm-dd  hh:mm:ss:SSS



1) fetch: 表示该属性的读取策略,有 EAGER 和 LAZY 两种,默认为 EAGER。EAGER 表示急加载，初始化时直接加载。LAZY 为懒加载，只有需要该字段时，才去加载。
2) optional: 表示该属性是否允许为null, 默认为true



**********************************注解表关联字段**********************************
1. @Formula：用来关联其他表的字段=====>变量属性前
	注意点：sql语句如果有where，则表需要使用别名
	
2. 关联表
1)多对一关系
   @ManyToOne(fetch = FetchType.LAZY)和@JoinColumn(name = "many表外键字段名")：用来关联其他表
   @OneToMany(mappedBy = "many表创建one表的实例变量名")：用来关联其他表
	注意点：两个需要配套使用，缺一不可
2)一对一关系
   @OneToOne(fetch = FetchType.LAZY)和@JoinColumn(name = "id")
   @OneToOne(mappedBy = "user")
3)多对对关系
   @ManyToMany
   @JoinTable(name = "S_USER_CAT", joinColumns = { @JoinColumn(name = "SSCAT") }, inverseJoinColumns = { @JoinColumn(name = "SSUSER") })
   @ManyToMany(mappedBy = "user")

二、 代码演示
用户表user

package ffcs.cn.peam.user.domain;

import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import ffcs.cn.peam.card.domain.Card;
import ffcs.cn.peam.cat.domain.Cat;
import ffcs.cn.peam.product.domain.Product;

@Entity
@Table(name = "S_USER")
public class User {
	@Id
	@GeneratedValue
	@Column(name = "ID")
	private int id;

	@Column(name = "PRODUCT_ID")
	private int productId;

	private String name;

	private String password;

	private String authority;

	// 一对多(用户-水果产品)
	@OneToMany(mappedBy = "user")
	private Set<Product> product;

	// 一对一(用户-身份号码)
	@OneToOne(mappedBy = "user")
	private Card card;

	// 多对多(用户-宠物猫)
	@ManyToMany(mappedBy = "user")
	private Set<Cat> cat;

	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;
	}

	@Column(name = "PASSWORD")
	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	@Column(name = "AUTHORITY")
	public String getAuthority() {
		return authority;
	}

	public void setAuthority(String authority) {
		this.authority = authority;
	}

	@Column(name = "PRODUCT_ID")
	public int getProductId() {
		return productId;
	}

	public void setProductId(int productId) {
		this.productId = productId;
	}

	public Card getCard() {
		return card;
	}

	public void setCard(Card card) {
		this.card = card;
	}

	public Set<Product> getProduct() {
		return product;
	}

	public void setProduct(Set<Product> product) {
		this.product = product;
	}

	public Set<Cat> getCat() {
		return cat;
	}

	public void setCat(Set<Cat> cat) {
		this.cat = cat;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", productId=" + productId + ", name=" + name
				+ ", password=" + password + ", authority=" + authority + "]";
	}

}

1. 用户表与用户产品表（一对多、关联字段查询）

package ffcs.cn.peam.product.domain;

import java.util.Date;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import org.hibernate.annotations.Formula;

import ffcs.cn.peam.user.domain.User;


@Entity
@Table(name = "PRODUCT")
public class Product {
	@Id
	@GeneratedValue
	@Column(name = "ID")
	private int id;

	@Column(name = "NAME")
	private String name;

	@Column(name = "PRICE")
	private float price;

	@Column(name = "TIME")
	private Date time;

	@Column(name = "OWNER")
	private int owner;

	@Formula("(select t.name from s_user t where t.id=OWNER)")
	private String ownerName;

   @ManyToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "owner")
	private User user;

	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 float getPrice() {
		return price;
	}

	public void setPrice(float price) {
		this.price = price;
	}

	public Date getTime() {
		return time;
	}

	public void setTime(Date time) {
		this.time = time;
	}

	public int getOwner() {
		return owner;
	}

	public void setOwner(int owner) {
		this.owner = owner;
	}



	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}

	public String getOwnerName() {
		return ownerName;
	}

	public void setOwnerName(String ownerName) {
		this.ownerName = ownerName;
	}

	@Override
	public String toString() {
		return "Product [id=" + id + ", name=" + name + ", price=" + price
				+ ", time=" + time + ", owner=" + owner + "]";
	}

}

2. 用户表与身份号码表（一对一）

package ffcs.cn.peam.card.domain;

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

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import ffcs.cn.peam.product.domain.Product;
import ffcs.cn.peam.user.domain.User;

@Entity
@Table(name = "S_CARD")
public class Card {
	@Id
	@GeneratedValue
	private int id;

	@Column(name = "CARD_NUMBER")
	private String cardNumber;

	@OneToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "id")
	private User user;

	public int getId() {
		return id;
	}

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

	public String getCardNumber() {
		return cardNumber;
	}

	public void setCardNumber(String cardNumber) {
		this.cardNumber = cardNumber;
	}


	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}




}

3. 用户表和宠物猫表（多对多）

package ffcs.cn.peam.cat.domain;

import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import ffcs.cn.peam.product.domain.Product;
import ffcs.cn.peam.user.domain.User;

@Entity
@Table(name = "S_CAT")
public class Cat {
	@Id
	@GeneratedValue
	@Column(name = "ID")
	private int id;

	@Column(name = "NAME")
	private String name;

	@ManyToMany
	@JoinTable(name = "S_USER_CAT", joinColumns = { @JoinColumn(name = "SSCAT") }, inverseJoinColumns = { @JoinColumn(name = "SSUSER") })
	private Set<User> user;

	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 Set<User> getUser() {
		return user;
	}

	public void setUser(Set<User> user) {
		this.user = user;
	}

}

三、 测试代码
这里是使用criteria进行测试的，具体配置看我前篇博客

		Resource resource = new ClassPathResource(	"ffcs/cn/system/applicationContext.xml");
		BeanFactory factory = new XmlBeanFactory(resource);
		SessionFactory sessionFactory = (SessionFactory) factory
				.getBean("sessionFactory");
		Session s = sessionFactory.openSession();
		s.beginTransaction();
		Criteria c = s.createCriteria(Cat.class);

		List<Cat> ps = c.list();

		for (Cat p : ps) {
			System.out.println(p.getUser());
		}
		s.getTransaction().commit();
		s.close();
		sessionFactory.close();

		
	

使用过后，发现与jdbc相比，jpa更为便捷，而且jpa是面向对象的操作语句，可以直接通过操作对象就可以实现数据库的操作。但同时，jpa的灵活性没有jdbc高，对于较为复杂的逻辑，jpa较难实现。而且jpa只适合小型数据的使用，如果一个类嵌入太多jpa查询对象，查询效率将会变得特别低！