Jpa和Jpql的基本使用(一)

最新推荐文章于 2023-09-15 20:38:30 发布

若尘

最新推荐文章于 2023-09-15 20:38:30 发布

阅读量524

点赞数 1

本文链接：https://blog.csdn.net/weixin_43902527/article/details/89516484

版权

本文介绍了JPA的使用步骤，从导入依赖、配置核心文件到实现保存操作，详细讲解了主键生成策略和JPA API，包括Persistence、EntityManagerFactory、EntityManager及EntityTransaction。还探讨了JPAUtil工具类的创建，并举例展示了JPA中的复杂查询，如JPQL的使用。

摘要由CSDN通过智能技术生成

第一步，在maven中导入坐标依赖

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.hibernate.version>5.0.7.Final</project.hibernate.version>
    </properties>

    <dependencies>
    <!-- junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

    <!-- hibernate对jpa的支持包 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>${project.hibernate.version}</version>
    </dependency>

    <!-- c3p0 -->
    <dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-c3p0</artifactId>
    <version>${project.hibernate.version}</version>
    </dependency>

        <!-- log日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- Mysql and MariaDB -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
    </dependencies>

第二步.配置jpa的核心配置文件

在java工程的src路径下创建一个名为META-INF的文件夹，在此文件夹下创建一个名为persistence.xml的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence 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"
	version="2.0">
	<!--配置持久化单元 
		name：持久化单元名称 
		transaction-type：事务类型
		 	RESOURCE_LOCAL：本地事务管理 
		 	JTA：分布式事务管理 -->
	<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
		<!--配置JPA规范的服务提供商 -->
		<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
		<properties>
			<!-- 数据库驱动 -->
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
			<!-- 数据库地址 -->
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/ssh" />
			<!-- 数据库用户名 -->
			<property name="javax.persistence.jdbc.user" value="root" />
			<!-- 数据库密码 -->
			<property name="javax.persistence.jdbc.password" value="111111" />

			<!--jpa提供者的可选配置：我们的JPA规范的提供者为hibernate，所以jpa的核心配置中兼容hibernate的配 -->
			<property name="hibernate.show_sql" value="true" />
			<property name="hibernate.format_sql" value="true" />
			<property name="hibernate.hbm2ddl.auto" value="create" />
		</properties>
	</persistence-unit>
</persistence>

第三步. 编写实体类和数据库表的映射配置

/**
*		* 所有的注解都是使用JPA的规范提供的注解，
 *		* 所以在导入注解包的时候，一定要导入javax.persistence下的
 */
@Entity //声明实体类
@Table(name="cst_customer") //建立实体类和表的映射关系
public class Customer {
	
	@Id//声明当前私有属性为主键
	@GeneratedValue(strategy=GenerationType.IDENTITY) //配置主键的生成策略
	@Column(name="cust_id") //指定和表中cust_id字段的映射关系
	private Long custId;
	
	@Column(name="cust_name") //指定和表中cust_name字段的映射关系
	private String custName;
	
	@Column(name="cust_source")//指定和表中cust_source字段的映射关系
	private String custSource;
	
	@Column(name="cust_industry")//指定和表中cust_industry字段的映射关系
	private String custIndustry;
	
	@Column(name="cust_level")//指定和表中cust_level字段的映射关系
	private String custLevel;
	
	@Column(name="cust_address")//指定和表中cust_address字段的映射关系
	private String custAddress;
	
	@Column(name="cust_phone")//指定和表中cust_phone字段的映射关系
	private String custPhone;
	
	public Long getCustId() {
		return custId;
	}
	public void setCustId(Long custId) {
		this.custId = custId;
	}
	public String getCustName() {
		return custName;
	}
	public void setCustName(String custName) {
		this.custName = custName;
	}
	public String getCustSource() {
		return custSource;
	}
	public void setCustSource(String custSource) {
		this.custSource = custSource;
	}
	public String getCustIndustry() {
		return custIndustry;
	}
	public void setCustIndustry(String custIndustry) {
		this.custIndustry = custIndustry;
	}
	public String getCustLevel() {
		return custLevel;
	}
	public void setCustLevel(String custLevel) {
		this.custLevel = custLevel;
	}
	public String getCustAddress() {
		return custAddress;
	}
	public void setCustAddress(String custAddress) {
		this.custAddress = custAddress;
	}
	public String getCustPhone() {
		return custPhone;
	}
	public void setCustPhone(String custPhone) {
		this.custPhone = custPhone;
	}
}

NOTICE:如果实体类中的属性名与表中的字段名相同则可省略@Column中的name属性

第四步实现保存操作

在单元测试模块创建测试类

import com.itcast.pojo.Customer;
import org.junit.Test;

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

public class JpaTest {

    @Test
    //测试保存一个客户信息到数据库中
    public void save(){
        //加载配置文件创建工厂（实体管理器工厂）对象
        EntityManagerFactory factory= Persistence.createEntityManagerFactory("myJpa");
        //通过工厂对象获取实体管理器
        EntityManager entityManager = factory.createEntityManager();
        //通过实体管理器获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();//开启事务

        try {
            //通过实体管理器完成crud操作
            Customer customer=new Customer();
            customer.setCustName("1111");
            customer.setCustIndustry("2222");
            entityManager.persist(customer);//完成保存操作
            //提交事务
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //出现异常，回滚事务
            transaction.rollback();
        }
        //释放资源
        entityManager.close();
        factory.close();
    }
}

二.JPA中的主键生成策略

通过annotation（注解）来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法。

JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO。

具体说明如下：

1.IDENTITY:主键由数据库自动生成（主要是自动增长型），需要底层数据库支持主键的自增,主要应用于mysql

    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    private Long custId;

2.SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。主要应用于orcale数据库

@Id  
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator="payablemoney_seq")  
@SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")  
private Long custId;

3.AUTO：主键由程序控制

@Id  
@GeneratedValue(strategy = GenerationType.AUTO)  
private Long custId;

4.TABLE：使用一个特定的数据库表格来保存主键

@Id  
    @GeneratedValue(strategy = GenerationType.TABLE, generator="payablemoney_gen")  
    @TableGenerator(name = "pk_gen",  
        table="tb_generator",  
        pkColumnName="gen_name",  
        valueColumnName="gen_value",  
        pkColumnValue="PAYABLEMOENY_PK",  
        allocationSize=1  
    ) 
private Long custId;

三.JPA的API介绍

3.1 Persistence对象
Persistence对象主要作用是用于获取EntityManagerFactory对象的。通过调用该类的createEntityManagerFactory静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory。

//1. 创建 EntitymanagerFactory
String unitName = "myJpa";
EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);

3.2 EntityManagerFactory
EntityManagerFactory 接口主要用来创建 EntityManager 实例

//2.创建实体管理类
EntityManager em = factory.createEntityManager();

由于EntityManagerFactory 是一个线程安全的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题），并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个EntityManagerFactory 即可

3.3 EntityManager
在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象，只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。

我们可以通过调用EntityManager的方法完成获取事务，以及持久化数据库的操作

方法说明：

getTransaction : 获取事务对象
persist ： 保存操作
merge ： 更新操作
remove ： 删除操作
find/getReference ： 根据id查询

3.4 EntityTransaction

在 JPA 规范中, EntityTransaction是完成事务操作的核心对象，对于EntityTransaction在我们的java代码中承接的功能比较简单

begin：开启事务
commit：提交事务
rollback：回滚事务

四.抽取JPAUtil工具类

静态代码块的模式
//Jpa的工具包
public class JPaUtil {
private static EntityManagerFactory entityManagerFactory;
static {
// 注意：该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
entityManagerFactory= Persistence.createEntityManagerFactory(“myJpa”);
}

    //定义一个方法获取entitymanager对象
    public static EntityManager getEntityManager(){
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        return entityManager;
    }
}

五.JPA中的复杂查询

JPQL全称Java Persistence Query Language

基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起•使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。

其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。

查询所有客户

//测试查询全部客户
    @Test
    public void selectAll(){
        EntityManager entityManager = JPaUtil.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        try {
	                String jpql = "from Customer";
	                Query query = entityManager.createQuery(jpql);
	                List resultList = query.getResultList();
	                for (Object o : resultList) {
	                    System.out.println(o);
	                }
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }
        entityManager.close();
    }

排序查询所有客户

//测试降序查询全部客户
    @Test
    public void selectAllDesc(){
        EntityManager entityManager = JPaUtil.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        try {
            String jpql = "from Customer order by custId desc";
            Query query = entityManager.createQuery(jpql);
            List resultList = query.getResultList();
            for (Object o : resultList) {
                System.out.println(o);
            }
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }
        entityManager.close();
    }

统计查询所有客户

//测试统计查询全部客户
    @Test
    public void selectAllCount(){
        EntityManager entityManager = JPaUtil.getEntityManager();//获取实体管理器对象
        EntityTransaction transaction = entityManager.getTransaction();//获取事务管理器对象
        transaction.begin();
        try {
            String jpql = "select count(custId) from Customer";
            Query query = entityManager.createQuery(jpql);//根据sql语句创建query查询对象
            long singleResult = (long)query.getSingleResult();
            System.out.println(singleResult);
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }
        entityManager.close();
    }

分页查询所有用户

//测试分页查询全部客户
    @Test
    public void selectAllByPage(){
        EntityManager entityManager = JPaUtil.getEntityManager();//获取实体管理器对象
        EntityTransaction transaction = entityManager.getTransaction();//获取事务管理器对象
        transaction.begin();
        try {
            String jpql = "from Customer";
            Query query = entityManager.createQuery(jpql);//根据sql语句创建query查询对象
            query.setFirstResult(0);//起始索引
            query.setMaxResults(5);//每页查询的条数
            List<Customer> resultList = query.getResultList();
            for (Customer customer : resultList) {
                System.out.println(customer);
            }
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }
        entityManager.close();
    }

根据条件查询用户

//条件查询
    @Test
    public void selectCondition(){
        EntityManager entityManager = JPaUtil.getEntityManager();//获取实体管理器对象
        EntityTransaction transaction = entityManager.getTransaction();//获取事务管理器对象
        transaction.begin();
        try {
            String jpql = "from Customer where custId= ?";
            Query query = entityManager.createQuery(jpql);//根据sql语句创建query查询对象
            query.setParameter(1,2l);//给参数赋值
            List<Customer> resultList = query.getResultList();
            for (Customer customer : resultList) {
                System.out.println(customer);
            }
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }
        entityManager.close();
    }

若尘

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Jpa和Jpql的基本使用(一)

第一步，在maven中导入坐标依赖<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.hibernate.version>5.0.7.Final</project.hibernate.v...
复制链接

扫一扫