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

最新推荐文章于 2023-12-22 13:17:39 发布
最新推荐文章于 2023-12-22 13:17:39 发布
阅读量1.6k 收藏
点赞数
分类专栏： 框架阶段 文章标签： Hibernate框架 jpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XXSession/article/details/77816948
版权

首先说一点：关于配置文件，叫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();
	}
      
}



XXSession
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java、Hibernate(JPA)常用注解整理
简约人生的博客
01-15 4773
Java、Hibernate(JPA)常用注解整理
Hibernate JPA
weixin_42248522的博客
11-12 248
一.JPA 1.添加依赖 //hibernate实体管理者，对接JPA规范的管理员 这是hibernate为了迎合JPA的规范做出来的。 compile group: 'org.hibernate', name: 'hibernate-entitymanager', version: '4.3.9.Final' 2.定义实体类 3.定义配置文件 必须要说明一点，配置文件的名字需要固定，必须叫：persistence.xml , 而且也必须放在 META-INF下面，不能直接放在resource下面。需
详解Spring Data JPA动态条件查询的写法
08-30
本篇文章主要介绍了Spring Data JPA动态条件查询的写法 ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring JPA写法一种
weixin_33800463的博客
04-24 303
第一次用，搞了半天，终于知道了大概。 基于ORM的JPA还是蛮好用的， 这次是实现一个MANGODB的日志存储和检索。 PRISM用的。 repository的写法： package paic.stock.ops.repository; import java.util.List; import org.springframework.data.mongodb.repos...
JPA（Hibernate）
11-04 230
JPA 1，JPA：Java Persistence API.JPA通过JDK 5.0注解－关系表的映射关系，并将运行期的实体对象持久化到数据库中。JPA是JavaEE中的标准。JPA标准只提供了一套规范，需要有JPA的具体实现，Hibernate实现了JPA2.0标准，所以我们在用JPA的时候，其实用的是Hibernate提供了JPA2.0规范的实现；JPA还有其他实现，比如Open...
Hibernate JPA简介
weixin_34072637的博客
01-11 106
Hibernate除了是一个ORM框架之外，同时还实现了Java EE的一项标准JPA。我们在前面已经看到了Hibernate可以在注解方面直接使用JPA。现在我们来看看如何在Hibernate中使用JPA。 关于JPA注解前面已经做了一定介绍，所以这里只用一个最简单的实体类。 @Entity public ...
前后端-SpringBoot-JPA的简单写法（配合前端vue）
qq_37644182的博客
03-26 789
前后端-SpringBoot-JPA的简单写法（配合前端vue）一、JAP的简单使用1、实体类2、接口3、Mapper二、配合前端的axios的写法第一种：配合分页机制第二种：一般使用方法第三种：使用Book这种对象的传参 一、JAP的简单使用 1、实体类 //JPA的实体类注解 @Entity @Data public class Book { //ID设置和保持ID自增 @Id ...
在JPA的@Query注解中使用limit条件(详解)
08-30
JPA @Query 注解中使用 Limit 条件详解 在 Java 持久层 API（JPA）中使用 @Query 注解时，需要注意 Limit 条件的使用。在本文中，我们将详细介绍如何在 JPA 的 @Query 注解中使用 Limit 条件。 Limit 条件的使用 ...
Hibernate JPA入门
heima201907的博客
03-24 189
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出现发布之...
hibernate之JPA入门篇
dimples_qian的博客
07-02 477
所谓JPA就是Java  persistence api----java持久化标准。由来：大家都知道hibernate是持久层框架都先驱，出世备受瞩目，一个东西出名就就会有无数的追随者，于是市面上出现了很多持久层框架，但各自的方法名称都不同，你的更新方法叫update，我就叫change!这样到最后搞得很乱，给开发者带来很多问题。于是sun公司（当然现在是oracle了）就让hibernate带头...
HibernateDAO的写法
03-05
**标题：“HibernateDAO的写法”** 在Java开发中，Hibernate是一个非常流行的持久化框架，它简化了数据库操作，使得开发者可以专注于业务逻辑，而不用过多地关注SQL语句的编写。这篇博客主要探讨了如何在项目中实现...
hibernate(jpa)+spring
qq_33854869的博客
07-13 538
项目中用到了hibernate,抽个时间记录下(前面有个简陋的介绍spring+redis+hibernate,此篇对hibernate有个更为详细的使用). Hibernate是一种ORM(Object Relational Mapping)映射工具，能够建立面向对象的域模型和关系数据模型之间的映射 Object Mapping（Hibernate） Relational 面向对象领域
jpa Repository的常用写法总结
BHSZZY的博客
11-06 1888
之前项目在xml中写sql，感觉标签有很多，比较灵活；最近在写新项目，使用了jpa，只能在java中写sql了，感觉不太灵活，但是也得凑付用。以下总结下常用入参出参写法。
常用的spring-data-jpa 规范
razeSpirit的专栏
09-19 8504
常用的spring-data-jpa 规范
idea JPA写法
wsf0001的博客
01-08 770
无参数查询： //无参的查找 @Query("select id,folderName from FolderEntity ") public List<FolderEntity> findIdAndFolderName(); 查找方法可以使用自定义findIdAndFolderName()调用，也可使用findAll()及jdk8新方法使用： ...
Hibernate注解方式JPA（速成解析hibernate注解）
OrangeChenZ的博客
02-14 600
Hibernate注解方式JPA 文章目录**JPA**分类一、类级别注解二、属性级别注解三、映射关系注解 ORM映射文件之前使用的是配置方式，但是通过JPA规范，把ORM映射使用注解来替代配置方式。 JPA 介绍 JPA全称为Java persistence API，Java持久化API是Sun公司在Java EE5规范中提出的Java持久化接口。 JPA吸取了目前Java持久化技术的优点，旨...
总结下SpringData JPA 的常用语法
l688899886的博客
06-16 1643
SpringData JPA常用有两种写法，一个是用Jpa自带方法进行CRUD，适合简单查询场景、例如查询全部数据、根据某个字段查询，根据某字段排序等等。另一种是使用注解方式，@Query、@Modifying。接口方法如下，方法作用见注释： 例子 一般dao实现JpaRepository接口，直接调用JpaRepository中的方法就可以实现了简单查询，例如查询User实例列表： 2.注解方式 jpa实现CRUD的主要注解是@Query@Query注解主要有以下参数，参数作用如下：@Quer
Hibernate学习笔记六（JPA入门）
水中无名鱼的博客
05-23 180
注:这是笔者在学习过程的一些知识记录,有可能有些地方写得不对,仅供参考 JPA的简介 JPA是Java Persistence API的简称，中文名Java持久层API，在ORM框架中,我们一直需要自己编写很多配置文件,例如在Hibernate中,每一个持久化类都对应一个映射文件,这样导致程序员编写任务过于繁重,而JPA能够使用简洁的注解来代替映射文件，这减少了代码编写量，同时由于市面上有很...
JPA 常见用法
最新发布
Dily_Su的博客
12-22 1350
JPA 使用中的常见用法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值