Hibernate中的JPA写法（利用注解的形式）

最新推荐文章于 2025-11-10 16:45:36 发布
原创 最新推荐文章于 2025-11-10 16:45:36 发布 · 1.7k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Hibernate框架 #jpa

本文详细介绍Java持久化API (JPA) 的配置与使用方法，包括persistence.xml配置、工具类编写、基本CRUD操作及JPQL查询语句，并提供实体类创建示例。

首先说一点：关于配置文件，叫persistence.xml放在META-INF下边，而这个文件夹放在src/main/resources中

关于具体的用法，在代码中做了详细的说明

首先看配置文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"  
    xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">    
                             <!--此处的名字与文件加载配置文件的名字一样  -->
    <persistence-unit name="jpa-2" transaction-type="RESOURCE_LOCAL">
   <!--  指定jpa的实现厂商   -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>        
       <!--  类的全路径，注意放的位置 -->
       <!-- 即把所对应的实体应该要放到这一个配置文件中 -->
        <class>com.qf.pojo.JpaUser</class>
     <!--    数据库连接和厂商的相关信息，都要包含在这一个节点之中 -->
        <properties>
               <property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/>
               <property name="hibernate.connection.password" value="root"/>
               <property name="hibernate.connection.url" value="jdbc:mysql:///jpa"/>
               <!-- 关于乱码问题，在这儿的URL路径后边做拼接操作 -->
               <property name="hibernate.connection.username" value="root"/>
              <!--  数据库连接的相关注册 -->
               <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL55Dialect"/>
               <!-- 注意数据库的版本55 -->
               <property name="hibernate.format_sql" value="true"/> 
               <property name="hibernate.show_sql" value="true"/>
             <!--   这一句是自动创建表，再利用Hibernate.cfg.xml时，也可以自动创建 表
               ，但理论上都是先设计表结构     -->           
               <property name="hibernate.hbm2ddl.auto" value="update"/>
               <!-- 数据库厂商的相关属性   -->
        </properties>
    </persistence-unit>  
</persistence>

关于工具类的写法


package com.qf.jpaUtils;

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

public class JpaUtils {
          private static EntityManagerFactory entityManagerFactory ;
          static{                                                                                           //配置文件的名字
        	  entityManagerFactory=Persistence.createEntityManagerFactory("jpa-2");
              /*加载配置文件，获取工厂*/	  
          }      
          public static EntityManager getentityManager(){
        	  /*通过工厂得到实体对象*/
        	   return entityManagerFactory.createEntityManager();  
          }    
}
下边是基础的CRUD以及JPQL语句 

package com.qf.dao;

import java.util.List;

import javax.persistence.EntityManager;

import javax.persistence.EntityTransaction;

import javax.persistence.Query;
import javax.persistence.TypedQuery;

import com.qf.jpaUtils.JpaUtils;
import com.qf.pojo.JpaUser;

public class JpaUserDao {
               /* 
                * 测试自动创建表
                *   public static void main(String[] args) {
                	  加载配置，得到实体工厂，联系Hibernate.config.xml,步骤大体相同
					EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("jpa-2");
					EntityManager entityManager = entityManagerFactory.createEntityManager();
					entityManagerFactory.close();
				}*/
	        /*  开始做crud操作*/
	        //基础的添加数据
	         public void addJpaUser(JpaUser pojo){
	        	 EntityManager manager = JpaUtils.getentityManager();
	        	 EntityTransaction transaction = manager.getTransaction();
	        	 /*需要注意一下，先要获取事务，然后再开启事务*/
	        	 transaction.begin();
	        	 manager.persist(pojo);
	        	 transaction.commit();
	        	 manager.close();        	 
	         } 
	         //基础的删除数据
	         public void delJpaUser(long id){
	        	 //关于删除的操作，首先要根据id找到数据，然后再去删除
	        	 EntityManager manager = JpaUtils.getentityManager();
	        	 EntityTransaction transaction = manager.getTransaction();
	        	 transaction.begin();
	        	JpaUser pojo = manager.find(JpaUser.class,id);
	        	 manager.remove(pojo);//根据ID去删除
	        	 transaction.commit();
	        	 manager.close();
	         }
	         //基础的查找数据
	         public JpaUser findJpaUser(long jpaid){
	        	 EntityManager manager = JpaUtils.getentityManager();
	        	 EntityTransaction transaction = manager.getTransaction();
	        	 transaction.begin();
	        	 JpaUser jpaUser = manager.find(JpaUser.class, jpaid);
	        	 transaction.commit();
	        	 manager.close();
	        	 return jpaUser;	        	 
	         }	         
	         //基础的更新数据
	         public void updateJpaUser(JpaUser pojo){
	        	 EntityManager manager = JpaUtils.getentityManager();
	        	  EntityTransaction transaction = manager.getTransaction();
	        	  transaction.begin();	        	  
	        	  JpaUser jpaUser = manager.merge(pojo);
	        	  /*更新数据的方法*/
	        	  System.err.println(jpaUser.getJpasex());	        	  
	        	  transaction.commit();
	        	  manager.close();
	         }
	    //查找全部数据
	         public void findall(){
	        	 EntityManager manager = JpaUtils.getentityManager();
	        	 String jpql="from JpaUser";
	        	 TypedQuery<JpaUser> query = manager.createQuery(jpql, JpaUser.class);
	        	 List<JpaUser> list = query.getResultList();
	        	 for (JpaUser jpaUser : list) {
					System.out.println(jpaUser.getJpaname());
				}	        	 
	        	 manager.close();
	         }
	         //根据条件查找，占位符的问题
	         public void findByName(String jpaname){
	        	 EntityManager manager = JpaUtils.getentityManager();
	        	 String jphl="from JpaUser j where j.jpaname=?1";
	        	 //此处的占位符可以把一省略，默认将是从0开始
	        	 TypedQuery<JpaUser> query = manager.createQuery(jphl,JpaUser.class);
	        	 @SuppressWarnings("unused")
				TypedQuery<JpaUser> parameter = query.setParameter(1, jpaname);
	        	 List<JpaUser> list = query.getResultList();
	        	for (JpaUser jpaUser : list) {
					System.out.println(jpaUser.getJpaname()+"\t"+jpaUser.getJpasex());
				}
	        	 manager.close();
	         }
	
	//查找部分列数据，去调试
	         public void findsome(){
	        	 EntityManager manager = JpaUtils.getentityManager();
	        	 String jpql="select j.jpaname,j.jpaage from JpaUser j";
	        	 Query query = manager.createQuery(jpql);
	        	 List<?> list = query.getResultList();
	        	 for (int i = 0; i < list.size(); i++) {
	        		 //当去查询部分数据时，利用调试的方法去看，输出的什么内容
	        		 Object[] object=   (Object[]) list.get(i);
	        		 System.out.println(object[0]+"\t"+object[1]);        		 
				}
	        	 manager.close();
	         }         
	         //模糊查询
	         public void findLike(String jpaname){
	        	 EntityManager manager = JpaUtils.getentityManager();	        	 
	        	 String jpql="from JpaUser where jpaname like ?";	        	 
	        	// String jpql="from JpaUser where jpaname like :jpaname";
	        	 //这样也可以
	        	 TypedQuery<JpaUser> query = manager.createQuery(jpql,JpaUser.class);
	        	 query.setParameter(0,"%"+ jpaname+"%");
	        	 List<JpaUser> list = query.getResultList();
	        	 for (JpaUser jpaUser : list) {
					System.out.println(jpaUser.getJpaname()+"\t"+jpaUser.getJpaage());
				}
	        	 manager.close(); 
	         }
	         //更新数据，根据id去更新数据
	         public void findUpUser(long jpaid,String jpaname){
	        	 EntityManager manager = JpaUtils.getentityManager();	 
	        	 EntityTransaction transaction = manager.getTransaction();
	        	 transaction.begin();
	        	 String jpql="update JpaUser set jpaname=:jpaname where jpaid=:jpaid";
	        	 Query createQuery = manager.createQuery(jpql);
	        	 createQuery.setParameter("jpaname", jpaname);
	        	 createQuery.setParameter("jpaid", jpaid);	       
	        	 createQuery.executeUpdate();//最容易忘记的语句
	        	 transaction.commit();
	        	 manager.close(); 	        	 
	         }
	         //根据条件去删除数据
	         public void dealUpUser(long jpaid){
	        	 EntityManager manager = JpaUtils.getentityManager();	 
	        	 EntityTransaction transaction = manager.getTransaction();
	        	 transaction.begin();
	        	 String jpql="delete from JpaUser where jpaid=:jpaid";
	        	 Query query = manager.createQuery(jpql);
	        	 query.setParameter("jpaid", jpaid);
	        	 int update = query.executeUpdate();
	        	 System.out.println(update); 
	        	 transaction.commit();
	        	 manager.close(); 	  
	         }
	         //查询总记录数
	         public void countUpUser(){
	        	 EntityManager manager = JpaUtils.getentityManager();	 
	        	 String jpql="select count(jpaid) from JpaUser";
	        	 Query query = manager.createQuery(jpql);
	        	 long sum=(Long)query.getSingleResult();
	        	 System.out.println("总条数为"+sum);	        	 	        	 
	        	 manager.close(); 	  
	         }
	         
	         //分页   开始的页数       和一页中显示的数量
	         public void findPag(int startIndex,int size){
	        	 EntityManager manager = JpaUtils.getentityManager();
	        	 String jpql="from JpaUser";
	        	TypedQuery<JpaUser> query = manager.createQuery(jpql,JpaUser.class);
	        	 query.setFirstResult(startIndex);
	        	 //关于这两个方法
	        	 query.setMaxResults(size);
	        	 List<JpaUser> list = query.getResultList();
	           	 for (JpaUser jpaUser : list) {
					System.out.println(jpaUser.getJpaname()+"\t"+jpaUser.getJpaage());
				}
	        	 manager.close(); 	  
	         }                 
}

关于实体类的创建，使用注解的方式去创建（这是在单表） 

package com.qf.pojo;

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="jpa_user")
/*数据库中表的表名*/
public class JpaUser {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	/*关于主键的自动生成*/
         private long jpaid;
	@Column(name="jpa_name")
         private String jpaname;
         private int jpaage;
         @Column(name="jpa_sex")
       /*  @里边中name的属性都是数据库表中的字段的名字*/
         private String jpasex;
		public long getJpaid() {
			return jpaid;
		}
		public void setJpaid(long jpaid) {
			this.jpaid = jpaid;
		}
		public String getJpaname() {
			return jpaname;
		}
		public void setJpaname(String jpaname) {
			this.jpaname = jpaname;
		}
		public int getJpaage() {
			return jpaage;
		}
		public void setJpaage(int jpaage) {
			this.jpaage = jpaage;
		}
		public String getJpasex() {
			return jpasex;
		}
		public void setJpasex(String jpasex) {
			this.jpasex = jpasex;
		}
         
}

若是在关联表中，请看下边的代码（配置文件中只需做这两个类的映射，即class标签） 


package com.qf.pojo;

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

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@Entity
@Table(name="friendtype")
public class Friendtype {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
       private long ftypeid;
	@OneToMany(mappedBy="friendtype")
       private Set friendinfo = new HashSet(0);//在主表中有一个set集合
	public long getFtypeid() {
		return ftypeid;
	}
	public void setFtypeid(long ftypeid) {
		this.ftypeid = ftypeid;
	}
	public Set getFriendinfo() {
		return friendinfo;
	}
	public void setFriendinfo(Set friendinfo) {
		this.friendinfo = friendinfo;
	}
	public Friendtype(long ftypeid, Set friendinfo) {
		super();
		this.ftypeid = ftypeid;
		this.friendinfo = friendinfo;
	}
	public Friendtype() {
		super();
	}
       
}

package com.qf.pojo;

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.Table;

@Entity
@Table(name="friendinfo")
public class Friendinfo {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
      private long friendid;
      private String friendname;
      private String friendage;
      private String friendsex;
      private String friendhobby;
      @ManyToOne
      @JoinColumn(name="ftypeid")
      private Friendtype friendtype;//子表中有一个这个属性（关于主表的）
	public long getFriendid() {
		return friendid;
	}
	public void setFriendid(long friendid) {
		this.friendid = friendid;
	}
	public String getFriendname() {
		return friendname;
	}
	public void setFriendname(String friendname) {
		this.friendname = friendname;
	}
	public String getFriendage() {
		return friendage;
	}
	public void setFriendage(String friendage) {
		this.friendage = friendage;
	}
	public String getFriendsex() {
		return friendsex;
	}
	public void setFriendsex(String friendsex) {
		this.friendsex = friendsex;
	}
	public String getFriendhobby() {
		return friendhobby;
	}
	public void setFriendhobby(String friendhobby) {
		this.friendhobby = friendhobby;
	}
	public Friendtype getFriendtype() {
		return friendtype;
	}
	public void setFriendtype(Friendtype friendtype) {
		this.friendtype = friendtype;
	}
	public Friendinfo(long friendid, String friendname, String friendage, String friendsex, String friendhobby,
			Friendtype friendtype) {
		super();
		this.friendid = friendid;
		this.friendname = friendname;
		this.friendage = friendage;
		this.friendsex = friendsex;
		this.friendhobby = friendhobby;
		this.friendtype = friendtype;
	}
	public Friendinfo() {
		super();
	}
      
}



Java ORM框架深度对决：Hibernate vs MyBatis vs JPA，如何用代码决胜性能与灵活性？
墨夶的博客
04-30 1470
/ 方法名查询：findByNameAndAge注释说明自定义查询：通过@Query使用HQL语句。方法名查询：Spring Data JPA自动解析方法名生成SQL。在ORM框架的选择中，没有绝对的“最优解”，只有最适合业务场景的“最佳解”。通过本文的代码深度解析与性能对比，希望你能掌握各框架的核心特性，从而在复杂项目中做出精准决策。立即行动，用代码征服数据库！注：本文代码已在Java 17 + MySQL 8.0环境下验证，生产环境需根据业务需求调整配置参数。
spring JPA写法一种
weixin_33800463的博客
04-24 352
第一次用，搞了半天，终于知道了大概。 基于ORM的JPA还是蛮好用的， 这次是实现一个MANGODB的日志存储和检索。 PRISM用的。 repository的写法： package paic.stock.ops.repository; import java.util.List; import org.springframework.data.mongodb.repos...
JPA（Hibernate）
11-04 313
JPA 1，JPA：Java Persistence API.JPA通过JDK 5.0注解－关系表的映射关系，并将运行期的实体对象持久化到数据库中。JPA是JavaEE中的标准。JPA标准只提供了一套规范，需要有JPA的具体实现，Hibernate实现了JPA2.0标准，所以我们在用JPA的时候，其实用的是Hibernate提供了JPA2.0规范的实现；JPA还有其他实现，比如Open...
JPA 的详细介绍和使用
最新发布
修行者Java的博客
11-10 339
选择JPA。
详解Spring Data JPA动态条件查询的写法
08-30
本篇文章主要介绍了Spring Data JPA动态条件查询的写法 ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
前后端-SpringBoot-JPA的简单写法（配合前端vue）
qq_37644182的博客
03-26 915
前后端-SpringBoot-JPA的简单写法（配合前端vue）一、JAP的简单使用1、实体类2、接口3、Mapper二、配合前端的axios的写法第一种：配合分页机制第二种：一般使用方法第三种：使用Book这种对象的传参 一、JAP的简单使用 1、实体类 //JPA的实体类注解 @Entity @Data public class Book { //ID设置和保持ID自增 @Id ...
Hibernate JPA简介
weixin_34072637的博客
01-11 148
Hibernate除了是一个ORM框架之外，同时还实现了Java EE的一项标准JPA。我们在前面已经看到了Hibernate可以在注解方面直接使用JPA。现在我们来看看如何在Hibernate中使用JPA。 关于JPA注解前面已经做了一定介绍，所以这里只用一个最简单的实体类。 @Entity public ...
在JPA的@Query注解中使用limit条件(详解)
08-30
JPA @Query 注解中使用 Limit 条件详解 在 Java 持久层 API（JPA）中使用 @Query 注解时，需要注意 Limit 条件的使用。在本文中，我们将详细介绍如何在 JPA 的 @Query 注解中使用 Limit 条件。 Limit 条件的使用 ...
解决Hibernate5.1整合JPA注解异常方法
Hibernate5.1 final 版本中引入了对 JPA 2.1 的完整支持，使得开发者可以使用注解的方式来简化数据持久化层的代码。 ### 知识点一：JPA 注解介绍 1. **@Entity**：标注一个类为实体类，用于表示数据库中的一个表。...
Hibernate JPA入门
heima201907的博客
03-24 261
Hibernate JPA入门1. JPA 介绍JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。Sun引入新JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一 。 其实在5.0出现发布之...
Spring整合Hibernate、Hibernate JPA、Spring Data JPA、Spring Data Redis
HiterCoder
05-24 362
环境说明，使用Jdk1.8版本，spring4.2.0.RELEASE版本、hibernate5.0.7.Final版本，spring-data-jpa-1.9.0.RELEASE版本、spring-data-redis-1.6.0.RELEASE版本。 1、Spring整合Hibernate的依赖jar包配置，修改pom.xml配置如下所示： 1 <?xml version...
jpa Repository的常用写法总结
BHSZZY的博客
11-06 2220
之前项目在xml中写sql，感觉标签有很多，比较灵活；最近在写新项目，使用了jpa，只能在java中写sql了，感觉不太灵活，但是也得凑付用。以下总结下常用入参出参写法。
常用的spring-data-jpa 规范
razeSpirit的专栏
09-19 8604
常用的spring-data-jpa 规范
idea JPA写法
wsf0001的博客
01-08 840
无参数查询： //无参的查找 @Query("select id,folderName from FolderEntity ") public List<FolderEntity> findIdAndFolderName(); 查找方法可以使用自定义findIdAndFolderName()调用，也可使用findAll()及jdk8新方法使用： ...
Hibernate注解方式JPA（速成解析hibernate注解）
OrangeChenZ的博客
02-14 687
Hibernate注解方式JPA 文章目录**JPA**分类一、类级别注解二、属性级别注解三、映射关系注解 ORM映射文件之前使用的是配置方式，但是通过JPA规范，把ORM映射使用注解来替代配置方式。 JPA 介绍 JPA全称为Java persistence API，Java持久化API是Sun公司在Java EE5规范中提出的Java持久化接口。 JPA吸取了目前Java持久化技术的优点，旨...
总结下SpringData JPA 的常用语法
l688899886的博客
06-16 1893
SpringData JPA常用有两种写法，一个是用Jpa自带方法进行CRUD，适合简单查询场景、例如查询全部数据、根据某个字段查询，根据某字段排序等等。另一种是使用注解方式，@Query、@Modifying。接口方法如下，方法作用见注释： 例子 一般dao实现JpaRepository接口，直接调用JpaRepository中的方法就可以实现了简单查询，例如查询User实例列表： 2.注解方式 jpa实现CRUD的主要注解是@Query@Query注解主要有以下参数，参数作用如下：@Quer
Hibernate学习笔记六（JPA入门）
水中无名鱼的博客
05-23 250
注:这是笔者在学习过程的一些知识记录,有可能有些地方写得不对,仅供参考 JPA的简介 JPA是Java Persistence API的简称，中文名Java持久层API，在ORM框架中,我们一直需要自己编写很多配置文件,例如在Hibernate中,每一个持久化类都对应一个映射文件,这样导致程序员编写任务过于繁重,而JPA能够使用简洁的注解来代替映射文件，这减少了代码编写量，同时由于市面上有很...
JPA 常见用法
Dily_Su的博客
12-22 2301
JPA 使用中的常见用法
jpa入门
zhangtong_1227的博客
05-17 157
JPA(java persistent api) 是sun公司推出的一个对象/关系（ORM）标准，常见的orm厂商有Hibernate, Toplink,jdo等，这些产品都有各自的实现方式，sun 公司为了统一ORM 持久化技术提高代码的灵活性（面向接口编程）推出了这一标准，这套标准只定义了一些接口，具体实现有各个厂商自己决定(类似于jdbc标准,sun提供接口，各个数据库厂商提供具体实现）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值