hibernate jpa 报错

Posted 2023-05-03

运行这句话就报错了.
EntityManagerFactory factory = Persistence.createEntityManagerFactory("bester");
不会是hibernate-annotations.jar的AnnotationConfiguration有问题吧

java.lang.NoSuchMethodError: org.hibernate.cfg.AnnotationConfiguration.setProperty(Ljava/lang/String;Ljava/lang/String;)Lorg/hibernate/cfg/AnnotationConfiguration;
at org.hibernate.ejb.Ejb3Configuration.setProperty(Ejb3Configuration.java:535)
at org.hibernate.ejb.Ejb3Configuration.configure(Ejb3Configuration.java:165)
at org.hibernate.ejb.Ejb3Configuration.configure(Ejb3Configuration.java:253)
at org.hibernate.ejb.HibernatePersistence.createEntityManagerFactory(HibernatePersistence.java:125)
at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:83)
at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:60)
at com.bestsoft.test.UsertestFacadeTest.testSave(UsertestFacadeTest.java:45)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at org.junit.internal.runners.TestMethodRunner.executeMethodBody(TestMethodRunner.java:99)
at org.junit.internal.runners.TestMethodRunner.runUnprotected(TestMethodRunner.java:81)
at org.junit.internal.runners.BeforeAndAfterRunner.runProtected(BeforeAndAfterRunner.java:34)
at org.junit.internal.runners.TestMethodRunner.runMethod(TestMethodRunner.java:75)
at org.junit.internal.runners.TestMethodRunner.run(TestMethodRunner.java:45)
at org.junit.internal.runners.TestClassMethodsRunner.invokeTestMethod(TestClassMethodsRunner.java:66)
at org.junit.internal.runners.TestClassMethodsRunner.run(TestClassMethodsRunner.java:35)
at org.junit.internal.runners.TestClassRunner$1.runUnprotected(TestClassRunner.java:42)
at org.junit.internal.runners.BeforeAndAfterRunner.runProtected(BeforeAndAfterRunner.java:34)
at org.junit.internal.runners.TestClassRunner.run(TestClassRunner.java:52)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:38)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:460)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:673)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:386)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)
问题解决了，hibernate-annotations.jar版本太多了，不知道哪个配哪个，大家有没什么办法解决版本问题。

貌似类库冲突。
请看一下你引入的hibernate类库（core、annotation、entitymanager）这些的版本是否一致。
另外，是否路径下还有其他hibernate类库（例如Jboss的lib中也含有hibernate）

最新的hibernate 3.5，已经将annotation, entitymanager融合到core中去了，这样不再有类似的版本冲突问题。
至于3.3版本，通常如下：
Hibernate 3.2.6 -->Annotation 3.2.X,3.3.X（兼容）
Hibernate 3.3.2-->Annotation 3.4.X（兼容） 参考技术A 少了hibernate-commons-annotations.jar

JPA（Hibernate）

JPA

1，JPA：Java Persistence API.JPA通过JDK 5.0注解－关系表的映射关系，并将运行期的实体对象持久化到数据库中。JPA是JavaEE中的标准。JPA标准只提供了一套规范，需要有JPA的具体实现，Hibernate实现了JPA2.0标准，所以我们在用JPA的时候，其实用的是Hibernate提供了JPA2.0规范的实现；JPA还有其他实现，比如OpenJPA，各个JPA的实现在使用细节上有一些不同，使用时需要注意；
2，JPA和Hibernate对比：
　　1)，JPA只是Hibernate的一个子集（支持JPA只是Hibernate中的一个功能），
　　2)，Hibernate在对象状态，对象映射，对象关系，查询语句上和JPA80%以上都雷同；
　　3)，Hibernate本身更依赖XML配置，而JPA完全使用Annotation实现；
　　4)，Hibernate的API和JPA的API有一些区别（关键对象，对象方法）；

 

JPA环境搭建:
1，JPA配置：
persistence.xml文件，放于classpath下META-INF/persistence.xml；
<properties>
hibernate.dialect：方言；
hibernate.show_sql:
hibernate.hbm2ddl.auto:
数据连接配置不能使用hibernate的哈;
　　javax.persistence.jdbc.driver：JPA规范的数据库驱动；
　　javax.persistence.jdbc.url：JPA规范的URL；
　　javax.persistence.jdbc.user：JPA规范的用户名；
　　javax.persistence.jdbc.password：JPA规范的密码；
　　javax.persistence.validation.mode：设置为auto，避免domain的检查；
2，创建Employee对象，并添加注解
　　1），@Entity：标在类上,标明当前实体类是需要JPA管理的一个实体对象，类似<class>
　　2），@Table：标在类上,标明当前实体类在数据库中对应的表，类似<class>元素的table属性 ；
3,配置属性,(默认情况下,JPA会管理所有的属性;要规范属性,可以在字段上,也可以在getter方法)
　　1），@Id：标明当前属性是OID，类似<id>
　　2），@GeneratedValue：标明当前OID使用的主键生成方式，类似<generator>
　　3），@Column：标明当前属性对应的列，类似<property>的column属性；
　　4），@Temporal：标明当前属性的日期类型；

 

API使用
一,JPA框架的启动:
创建EntityManagerUtil；
　　1），使用Persistence.createEntityManagerFactory("com._520it.jpa")创建EntityManagerFactory；
　　(按照persistence.xml中的persistence-unit的name属性加载的)
　　2），EntityManagerFactory类似SessionFactory，通过createEntityManager方法创建EntityManager；
　　3），EntityManager类似Session，实体类的持久化方法由EntityManager提供
2，完成CRUD；
　　1，getTransaction：得到事务对象，并调用begin方法开启事务；

　　2，persist：持久化对象；

　　3，find：得到对象，相当于get方法；

　　4，merge：修改对象，相当于update方法；

　　5，createQuery：创建一个Query对象；

　　6，调用Query对象的getResultList方法执行查询；

　　7，remove：删除一个对象，相当于delete方法；(注意,JPA中只能把持久化对象变为删除状态)

 

1，配置文件：

　　1），JPA的配置文件默认从META-INF/persistence.xml加载；
　　hibernate(classpath:hibernate.cfg.xml)
　　2），JPA配置文件中，可以配置hibernate的相关配置项（只针对HIBERNATE的JPA实现）；

　　注意,有些配置只能使用javax.xxx
　　3），JPA配置文件中，默认查询classpath下所有实体类，如果需要引入外部的类，才需要配置；

hibernate:要让hibernate管理的实体类,必须把映射文件配置在hibernate.cfg.xml的mapping中;
2，实体对象：

　　1），JPA也是ORM框架，不同的是使用注解来完成映射；
　　2），JPA中，O直接体现在对象中，所以一般情况下，在注解中一般不写配置或者只配置R部分；
　　3），JPA中，最大的好处是不需要给所有属性配置，按需配置；
3，API代码：

　　1），JPA的启动方式几乎和Hibernate相同，包括类结构基本一致；
　　Persistence --- Configuration;
　　EntityManagerFactory --- SessionFactory;
　　EntityManager ---- Session

　　2），EntityManager上的API和Session基本一致；
　　使用entityManager.getDelegate()查看EntityManager的真实实现SessionImpl；
　　EntityManager的的委托类其实就是SessionImpl，所以，Hibernate其实就是使用Session来实现了JPA的EntityManager；

 

单对象映射细节:
persistence.xml：
　　1，class：引入需要扫描的类，
　　2，exclude-unlisted-classes：是否只扫描配置的类；
　　3，jar-file：引入需要扫描的jar包；

		<!-- 手动告诉JPA需要管理那些类 -->
		<class>com.rk1632._12_second_level_cache.Employee</class> 
		<!-- exclude-unlisted-classes设置为false,JPA便只会管理class标签引入的实体类 -->
		<exclude-unlisted-classes>false</exclude-unlisted-classes>

对象:
　　4，@Entity和@Table；entity的name属性可以为对象起别名；table的name为对象指定表名；
　　5，默认情况下，根据@Id标签的位置确定access的方式；可以通过@Access来改变access方式（field）；
　　6，@Column标签；name属性；
　　7，@Temporal标签；设置日期格式；
　　8，@Transient标签；设置一个字段不需要持久化；
　　9，@Lob标签：设置text类型；相当于hibernate <property type="text">

 

主键映射细节:

使用JPA内置的主键生成策略：

　　1，@GeneratedValue(strategy=GenerationType.AUTO)；---- native
　　2，@GeneratedValue(strategy=GenerationType.IDENTITY)； ------identity
　　3，@GeneratedValue(strategy=GenerationType.SEQUENCE)； ------sequence
　　4，@GeneratedValue(strategy=GenerationType.TABLE)；---- TableGenerator
　　5,   @Id --- assigned

 

JPA--HIBERNATE

核心对象对比
　　1，EntityManagerFactory: 类似SessionFactory，线程安全，主要用于产生EntityManager，对于一个应用+数据库，一个实例就够了
　　2，EntityManager：类似Session，在Hibernate中就是Session的包装类，使用方式和Session相同；线程不安全；
　　3，Query/TypedQuery：类似Query对象，部分API有区别；
　　4，EntityTransaction：类似Tansaction对象，API相同；

 

EntityManager方法对比:

session ---> jpa

save; ---> persist:persist方法必须运行在事务中;

update; ---> merge:merge方法必须运行在事务中;

saveOrUpdate ---> erge方法可以把临时对象或者游离对象都变成持久化对象;

delete ---> remove:remove方法必须运行在事务中;

get ---> find:find返回对象类型不是Object;

load ---> getReference:使用延迟加载;

getTransaction; ---> getTranscation:得到的对象是EntityTransaction;

createQuery; ---> createQuery:javax.xxx.Query;TypedQuery

clear ---> clear;

evict ---> detach:把一个指定的持久化对象变成游离对象;

close ---> close;

 

单向的many2one:

	//<many2one name="dept" column="dept_id">
	//EAGER:迫切的	LAZY:懒,此处fetch设置延迟加载或者不延迟加载
	@ManyToOne(fetch=FetchType.LAZY)
	@JoinColumn(name="DEPT_ID")
	private Department dept;

1,Employee
2,@JoinColumn相当于在many-to-one元素中的column;
3,默认情况下,得many方,JPA会直接使用LEFT JOIN 把one方查询出来;相当于没有延迟加载;
4,@ManyToOne(fetch=FetchType.LAZY)
   @Fetch(FetchMode.SELECT)
　　1）,manytoone标签上的fetch属性代表是否延迟加载,默认是FetchType.EAGER;如果使用延迟加载,FetchType.LAZY;
　　2）,fetch标签代表怎么去拿关联的对象,默认情况使用left join直接把many方对应的one方拿到,也可以设置为select,使用两条SQL分别加载many和one;

 

单向的one2many:
1,JPA中,one2many是使用三张表完成的;
2,从one方拿many,使用延迟加载,仍然使用的PersistenceSet,所以,还是只能使用接口;
3,只能使用集合的size方法来判断是否有many方和one方关联;
4,在关闭EntityManager之前实例化集合;

集合:
1,JPA能够自动根据集合的类型来完成集合的映射;
2,如果集合是Set相当于默认使用<set>来映射;
3,如果集合是List相当于默认使用<bag>来映射;
4,可以使用@OrderBy标签来排序(让JPA按照集合中的类型的某个属性排序)

 

双向的many2one和one2many;

	//1,one方放弃去维护和many方的关系;---->inverse=true
	//2,one方查询many方的表结构按照many方对应的属性配置查询(one方放弃中间表结构)
	@OneToMany(mappedBy="dept")
	private Set<Employee> es = new HashSet<>();

1,在many方直接使用@ManyToOne标签;
2,在one方,使用@OneToMany(mappedBy="")
　　1）,mappedBy代表one方放弃对many方关系的维护;
　　2）,one方放弃自己的中间表结构,使用many方对应的属性的表结构;
3,双向的many2one,one2many就和hibernate中的是一样的了;

 

JPA级联:

MERGE:
REMOVE:
all:额外的包含了DETACH和PERSIST
在hibernate中的delete-orphan变成了@OneToMany的一个属性:orphanRemoval=true;

DETACH:代表,在主对象上面调用detach方法(把持久化对象变成游离对象,相当于evict),级联的对所有子对象调用detach方法;
PERSIST:代表,在主对象上面调用persist方法,级联的对所有子对象调用persist方法;

 

many2many:

@Entity
public class Teacher {

	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private Long id;
	private String name;
	
	@ManyToMany
	private Set<Student> students = new HashSet<>();
        //省略get/set  ...
}


@Entity
public class Student {

	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private Long id;
	private String name;
	
	@ManyToMany(mappedBy="students")
	private Set<Teacher> teachers = new HashSet<>();
        //省略get/set  ...
}

自定义中间表

	@ManyToMany
	//类似于<set table="">
	//name表示中间表的名称
	//joinColumns代表在中间表里面对应自己主键的外键列
	//				name:中间列的外键列的名称
	//				referencedColumnName:参照自己的哪个列(主键列),可以不写
	//inverseJoinColumns代表在中间表里面对应对方主键的外键列
	//				name:中间列的外键列的名称
	//				referencedColumnName:参照对方的哪个列(主键列),可以不写
	@JoinTable(name="TEA_STU",
				joinColumns=@JoinColumn(referencedColumnName="id",name="TEA_ID"),
				inverseJoinColumns=@JoinColumn(referencedColumnName="id",name="STU_ID"))
	private Set<Student> students = new HashSet<>();

　　

组件关系:

//组合对象
//可嵌入对象,代表这个对象不是一个实体对象,是一个需要嵌入到宿主对象中才有意义的对象
@Embeddable
public class Address {

	private String provice;
	private String city;
	private String street;
        //省略get/set
}

//宿主对象
@Entity
public class Company {

	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private Long id;
	private String name;

	private Address address;
	
	//多个相同类型的嵌入对象,需要重写属性列名
	@AttributeOverrides({
			@AttributeOverride(name="city",column=@Column(name="REG_CITY")),
			@AttributeOverride(name="provice",column=@Column(name="REG_PROVICE")),
			@AttributeOverride(name="street",column=@Column(name="REG_STREET"))
	})
	private Address regAddress;
        //省略get/set
}

　　

继承关系:
1,默认情况下,JPA使用ONE TABLE的方式来自动完成继承的映射
　　1）,只需要在整个继承体系的根对象上面添加@Entity和主键映射;
　　2）,其他所有的子类只需要加上@Entity标签就可以了;
　　3）,会创建一个鉴别器列,DTYPE,使用类名作为鉴别器的值;
　　4）,如果要自定义鉴别器列,在根类型上加上@DiscrimnatorColumn
　　5）,如果自定义了鉴别器列,根类型及所有子类必须添加@DiscriminatorValue

 

2,使用PER TABLE的方式:
　　1）,在父类（根类）上使用@Inheritance标签,使用TABLE_PER_CLASS的继承策略;
　　2）,id的生成策略不能是AUTO或者IDENTITY;
　　3）,子类只需要添加@Entity,如果要修改子类的表名,@Table;

 

查询:
1,TypedQuery和Query的区别;TypedQuery主要用于查询一个实体对象,不能使用投影查询;
2,分页:同样使用setFristResult和setMaxResult两个方法;
3,注意,如果使用JPA的查询,使用位置参数,参数的索引是从[1]开始的 (hibernate从[0]开始的)
4,查询总条数之类的只有一条结果的,可以使用getSingleResult方法;
5,如果要使用原生的SQL,直接使用createNativeQuery()

		//如果只查询一种实体对象,建议使用TyedQuery
		TypedQuery query = em.createQuery("select e from Employee e where name like ?", Employee.class);
		//分页的两个方法和Hibernate的query相同
		//List<Employee> list = query.setFirstResult(5).setMaxResults(5).getResultList();
		//System.out.println(list);
		
		//如果确定结果集只有一行,使用getSingleResult==Hibernate中的uniqueResult
		//query.getSingleResult();
		
		//JPA中,查询参数的顺序从1开始
		//List<Employee> list = query.setParameter(1, "%松鼠%").getResultList();
		
		List<Object[]> objs = em.createNativeQuery("select * from Employee", Employee.class).getResultList();
		System.out.println(objs);

　　

JPA中的锁;

1,悲观锁;
select for update可以阻止:除了SELECT之外的其他SQL(FOR UPDATE,DML,LOCK IN SHARE MODE);
select lock in share mode可以阻止:DML和FOR UPDATE,LOCK IN SHARE MODE;

在JPA中使用悲观锁,
em.find(Class,id,LockModeType),
LockModeType一般有两种方式:
　　1,PESSIMISTIC_READ:LOCK IN SHARE MODE:会通过造成死锁来阻止并发事务执行;
　　2,PESSIMISTIC_WRITE:SELECT FOR UPDATE:会延迟另一个事务的执行;(一般使用这种)

在JPA中使用乐观锁.
在对象中添加一个version属性,在上面添加@Version标签就可以了

 

二级缓存的配置:
1,拷贝二级缓存的jar包;
2,拷贝二级缓存的hibernate的配置文件,

			<!-- 告诉hibernate使用哪个缓存框架作为二级缓存框架 -->
			<property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
			<!-- 设置二级缓存前缀 -->
			<property name="hibernate.cache.region_prefix" value="hibernate"/>

3,拷贝ehcache的配置文件(classpath);
4,在需要二级缓存的对象上面加上标签;
　　1）,Cacheable标签是JPA提供的;
　　2）,Cache标签,是hibernate提供的,提供了更多的二级缓存控制相关的配置;

@Entity
//Cacheable标签表示需要二级缓存的实体类
@Cacheable
@Cache(usage=CacheConcurrencyStrategy.READ_WRITE,region="hibernate.EMPLOYEE")
public class Employee {
      //省略  
}

　　

二级缓存的操作:
1,在JPA中,二级缓存是放在EntityManagerFactory上的;
2,entityManagerFactory.getCache()方法得到二级缓存对象;
3,evict(Class):清除指定类型所有数据;
   evict(Class,Object id):清除指定对象;
   evictALL:清除所有二级缓存对象