Hibernate之注解开发快速入门

一，比较Hibernate的配置文件开发，注解开发需要多导入一个jpa包：

二，在src目录下新建一个META-INF文件夹，在该文件夹下建一个persistence.xml文件，配置内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
          http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
        version="2.1">

	<persistence-unit name="myPersisitenceUnit" transaction-type="RESOURCE_LOCAL">
		
		<properties>
			<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
			<property name="hibernate.connection.url" value="jdbc:mysql:///demo"/>
			<property name="hibernate.connection.username" value="root"/>
			<property name="hibernate.connection.password" value="root"/>
			
			<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
			<property name="hibernate.show_sql" value="true"/>
			<property name="hibernate.format_sql" value="true"/>
			<property name="hibernate.hbm2ddl.auto" value="update"/>
			<property name="hibernate.connection.provider_class" value="org.hibernate.connection.C3P0ConnectionProvider"/>
		</properties>
	</persistence-unit>

</persistence>

说明：1，文件约束头可以在导入的hibernate-entityManager包==>org.hibernate==>jpa==>persistence_*.xsd文件中：

2，该文件主要配置Hibernate核心配置文件配置的内容：

persistence-unit:持久化单元；name配置持久化单元名称，必选，可以随意取名；transaction-type：配置事务类型，可选，默认：JTA。

JTA：容器级别的事务，只能运行在J2EE服务器中。支持分布式的事务。容器托管的EntityManager对象只能采用JTA的事务。

RESOURCE_LOCAL:数据库级别的事务，只针对一种数据库。不支持分布式事务。在J2SE中，只能用该RESOURCE_LOCAL的事务。

三，实体类配置

1，基本配置

@Entity:指定当前类为实体类。在创建SessionFactory/EntityManager时，加载该映射配置

@Table:指定该实体类和表之间的对应关系，name指定数据库表名

@Id:指定当前字段为主键

@GeneratedValue:指定主键生成方式，属性strategy指定主键生成策略，主要用到IDENTITY,SEQUENCE

@Column:指定实体类和数据库表字段的对应关系，name数据库表字段名称，当属性名和字段名一样时该配置和省略

package com.myself.domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;


@Entity
@Table(name="customer",catalog="demo")
public class Customer2 {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="id")
	private Long id;
	
	@Column(name="name")
	private String name;
	private String contact;
	private String telephone;
	private String email;
	private String remark;
	
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getContact() {
		return contact;
	}
	public void setContact(String contact) {
		this.contact = contact;
	}
	public String getTelephone() {
		return telephone;
	}
	public void setTelephone(String telephone) {
		this.telephone = telephone;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getRemark() {
		return remark;
	}
	public void setRemark(String remark) {
		this.remark = remark;
	}

}

2，一对多，多对一配置

@OneToMany(targetEntity=Linkman.class,mappedBy="customer",cascade=CascadeType.ALL)
private Set<Linkman> linkmans = new HashSet<Linkman>();

targetEntity:指定对方的字节码对象；

mappedBy:从表实体类中引用主表对象的名称，一般配置在不维护外键的一方；

cascade:配置级联操作，一般配置在一的一方；

fetch：配置是否采用延迟加载

@ManyToOne(targetEntity=Customer.class)
@JoinColumn(name="lkm_cust_id",referencedColumnName="id")
private Customer customer;

@JoinColumn:定义主键字段和外键字段的对应关系。name:外键名称;referencedColumnName外键对应主表中主键的名称

3，多对多配置

@ManyToMany(targetEntity=User.class,mappedBy="roles")
private Set<User> users = new HashSet<User>();

targetEntity:指定对方的字节码对象；

mappedBy:从表实体类中引用主表对象的名称，一般配置在不维护外键的一方；

@ManyToMany(targetEntity=Role.class)
@JoinTable(name="sys_user_role",joinColumns={
	@JoinColumn(name="user_id",referencedColumnName="user_id")	
},inverseJoinColumns={
	@JoinColumn(name="role_id",referencedColumnName="role_id")	
})
private Set<Role> roles = new HashSet<Role>();

@JoinTable:中间表配置

name:中间表名称；

joinColumns:中间表外键字段对应该实体类所对应表的主键字段；

inverseJoinColumn:中间表外键字段关联对方表主键字段。

四，测试

工具类：

package com.myself.utils;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class HibernateUtils {
	private static EntityManagerFactory entityManagerFactory= null;
	static{
        //myPersisitenceUnit persistence.xml中配置的持久化单元名称
		entityManagerFactory = Persistence.createEntityManagerFactory("myPersisitenceUnit");	
	}
	public static EntityManager getEntityManager(){
		return entityManagerFactory.createEntityManager();
	}
}

测试类（一对多，其他省略）：

package com.myself.test;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;

import org.junit.Test;

import com.myself.domain.Customer;
import com.myself.domain.Linkman;
import com.myself.utils.HibernateUtils;

public class JPAOneToMany {
	@Test
	public void test01(){
		EntityManager entityManager = HibernateUtils.getEntityManager();
		EntityTransaction transaction = entityManager.getTransaction();
		transaction.begin();
		
		Customer customer = new Customer();
		customer.setName("ManytoOneJPA");
		Linkman linkman1 = new Linkman();
		Linkman linkman2 = new Linkman();
		linkman1.setName("JPALinkman1");
		linkman2.setName("JPALinkman2");
		
		customer.getLinkmans().add(linkman1);
		customer.getLinkmans().add(linkman2);
		linkman1.setCustomer(customer);
		linkman2.setCustomer(customer);
		
		entityManager.persist(customer);
		
		transaction.commit();
		entityManager.close();
		
	}
}

五，JPA操作数据方法

1，persist(Object obj) 保存对象

2，merge(Object obj) 修改对象

3，remove(Object obj) 删除对象

4，find(Class.clazz,Object obj) 立即加载 getReference(Class.clazz,Object obj) 延迟加载

5，JPQL ：查询所有

6，getSingleResult() 返回唯一结果

Hibernate之注解开发快速入门

猜你喜欢