Spring Data jpa学习之增删改查

最新推荐文章于 2024-04-19 05:05:58 发布

柒间

最新推荐文章于 2024-04-19 05:05:58 发布

阅读量960

点赞数

分类专栏： JPA 文章标签： java jpa

本文链接：https://blog.csdn.net/qq_43663493/article/details/119090514

版权

JPA 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

jpa操作的操作步骤
	1.加载配置文件创建实体管理器工厂
		Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）
			createEntityMnagerFactory（持久化单元名称）
		作用：创建实体管理器工厂
		
	2.根据实体管理器工厂，创建实体管理器
		EntityManagerFactory ：获取EntityManager对象
		方法：createEntityManager
		* 内部维护的很多的内容
			内部维护了数据库信息，
			维护了缓存信息
			维护了所有的实体管理器对象
			再创建EntityManagerFactory的过程中会根据配置创建数据库表
		* EntityManagerFactory的创建过程比较浪费资源
		特点：线程安全的对象
			多个线程访问同一个EntityManagerFactory不会有线程安全问题
		* 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
		思路：创建一个公共的EntityManagerFactory的对象
		* 静态代码块的形式创建EntityManagerFactory
		
	3.创建事务对象，开启事务
		EntityManager对象：实体类管理器
			beginTransaction : 创建事务对象
			presist ： 保存
			merge  ： 更新
			remove ： 删除
			find/getRefrence ： 根据id查询
			
		Transaction 对象 ： 事务
			begin：开启事务
			commit：提交事务
			rollback：回滚
	4.增删改查操作
	5.提交事务
	6.释放资源

i.搭建环境的过程
	1.创建maven工程导入坐标
	2.需要配置jpa的核心配置文件
		*位置：配置到类路径下的一个叫做 META-INF 的文件夹下
		*命名：persistence.xml
	3.编写客户的实体类
	4.配置实体类和表，类中属性和表中字段的映射关系
	5.保存客户到数据库中
ii.完成基本CRUD案例
	persist ： 保存
	merge ： 更新
	remove ： 删除
	find/getRefrence ： 根据id查询
 iii.jpql查询
	 sql：查询的是表和表中的字段
	 jpql：查询的是实体类和类中的属性
		* jpql和sql语句的语法相似
	 
		1.查询全部
		2.分页查询
		3.统计查询
		4.条件查询
		5.排序

项目结构：在这里插入图片描述

依赖

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <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>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
    </dependencies>

persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--需要配置节点 persistence-unit
        持久化单元
            name：持久化单元名称
            transaction-type：事务管理的方式
                JTA：分布式事务管理
                RESOURCE_LOCAL：本地事务管理
                    -->

    <persistence-unit name="MyJpa" transaction-type="RESOURCE_LOCAL">
        <!--事务的实现-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--可选配置：配置jpa实现方式的配置信息-->
        <properties>
            <!--数据库信息
                    用户名：javax.persistence.jdbc.user
                    密码:javax.persistence.jdbc.password
                    驱动:javax.persistence.jdbc.diver
                    数据库地址:javax.persistence.jdbc.url-->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>

            <!--配置jpa实现方（hibernate）的配置信息
                显示sql：false|true
                自动创建数据库表:hibernate.hbm2ddl.auto
                create：程序运行时创建数据库表（如果有表，先删除表在创建）
                update:程序运行时穿件表（如果有表，不会删除表）
                none:不会创建表
            -->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>


        </properties>
    </persistence-unit>


</persistence>

实体类

package com.qijian.domain;

import lombok.Data;

import javax.persistence.*;

/**
 * TODO 客户实体类
 *      配置映射关系
 *          1，实体类和表的映射关系
 *          2，实体类中属性和表中字段的映射关系
 * 1,
 * @Entity:申明实体类
 * @Table：配置实体类和表的映射关系
 *      name:配置数据库表的名称
 *2,
 *
 * @author qijian.
 * @date 2021/7/25 11:17
 */
@Data
@Entity
@Table(name = "cst_customer")
public class Customer {

    /**
     * 客户主键
     * @Id:申明是主键的配置
     * @GeneratedValue配置主键的生成策略
     *          strategy = GenerationType.IDENTITY:自增
     *              public enum GenerationType{
     *                  TABLE,
     *                  SEQUENCE,
     *                  IDENTITY,
     *                  AUTO
     *             }
     *          JPA提供的四种标准用法为TABLE，SEQUENCE，IDENTITY，AUTO。
     *              a，TABLE：使用一个特定的数据库表格来保存主键。
     *              b，SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。
     *              c，IDENTITY：主键由数据库自动生成（主要是自动增长型） mysql数据库
     *              d，AUTO：主键由程序控制
     * @Column:配置属性和字段的映射关系
     *         name:数据库中字段的名称
     *
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId;

    /**
     * 客户姓名
     */
    @Column(name = "cust_name")
    private String custName;

    /**
     * 客户来源
     */
    @Column(name = "cust_source")
    private String custSource;

    /**
     * 客户所属行业
     */
    @Column(name = "cust_industry")
    private String custIndustry;

    /**
     * 客户级别
     */
    @Column(name = "cust_level")
    private String custLevel;

    /**
     * 客户地址
     */
    @Column(name = "cust_address")
    private String custAddress;

    /**
     * 客户联系方式
     */
    @Column(name = "cust_phone")
    private String custPhone;

}

工具类

package com.qijian.utils;

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

/**
 * TODO 解决实体管理器工厂的浪费资源和消耗
 *      通过静态代码块的形式，当程序第一次访问工具类时，创建一个公共的实体类管理器工厂对象
 *
 * 第一次访问getEntityManager方法，经过静态代码块创建factory对象，再调用方法创建一个EntityManager对象
 * 第二次访问getEntityManager方法，直接通过一个已经创建的factory对象，再创建一个EntityManager对象
 * @author qijian.
 * @date 2021/7/25 19:34
 */
public class JpaUtils {

    private static EntityManagerFactory factory;

    static {
        //1，加载配置文件，创建entityMangerFactory
        factory = Persistence.createEntityManagerFactory("MyJpa");

    }
    /**
     * 获取EntityManager对象
     */
    public static EntityManager  getEntityMaanger(){
        return   factory.createEntityManager();
    }
}

测试

测试jpa的保存
案例：保存一个客户到数据库中
jpa的操作
1，加载配置文件穿件工厂（实体管理工厂）对象
2，通过试题管理工厂获取实体管理器
3，获取食物对象，开启事务
4，完成增删改查的操作
5，提交事务
6，释放资源

    @Test
    public void test2(){
//        //     *      1，加载配置文件穿件工厂（实体管理工厂）对象
//        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa");
//        //     *      2，通过试题管理工厂获取实体管理器
//        EntityManager em = factory.createEntityManager();

        EntityManager em =   JpaUtils.getEntityMaanger();
        //     *      3，获取食物对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();//开启事务
        Customer customer = new Customer();
        customer.setCustName("qijian");
        customer.setCustPhone("12345678");
        //保存你
        em.persist(customer);
        tx.commit();//提交事务
        //释放资源
        em.close();
//        factory.close();//使用JpaUtils后factory就是公共的不能关闭，关闭后下次就不能使用了

    }

/**
* 根据id查询客户
* 使用find方法查询（立即加载）
* 1，查询的对象就是当前客户对象本身
* 2，在调用find方法的时候，就发送sql语句查询数据库
*/

    @Test
    public void testFind(){
        //     *      1，加载配置文件穿件工厂（实体管理工厂）对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa");
        //     *      2，通过试题管理工厂获取实体管理器
        EntityManager em = factory.createEntityManager();
        //     *      3，获取事务·对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        /**
         * 增删改查  -- 根据id查询客户
         * find:根据id查询数据库
         *  class：查询数据结构需要包装的实体类型的字节码
         *  id:插叙主键的值
         *
         */
        Customer customer = em.find(Customer.class,1l);
        System.out.println(customer);

        tx.commit();
        factory.close();


//        Hibernate:
//        select
//        customer0_.cust_id as cust_id1_0_0_,
//        customer0_.cust_address as cust_add2_0_0_,
//        customer0_.cust_industry as cust_ind3_0_0_,
//        customer0_.cust_level as cust_lev4_0_0_,
//        customer0_.cust_name as cust_nam5_0_0_,
//        customer0_.cust_phone as cust_pho6_0_0_,
//        customer0_.cust_source as cust_sou7_0_0_
//        from
//        cst_customer customer0_
//        where
//        customer0_.cust_id=?

//        Customer(custId=1, custName=qijian, custSource=null, custIndustry=学生, custLevel=null, custAddress=深圳, custPhone=12345678)


    }

/**
* 根据id查询客户
* getReference方法
* 1，获取的对象时一个动态代理对象
* 2，调用getReference方法不会立即发送sql查询数据库
* *当调用查询结果对象的时候，才会发送sql语句，也就是说，什么时候用什么时候发送sql语句查询数据库
*/

    @Test
    public void testReference() {
        //     *      1，加载配置文件穿件工厂（实体管理工厂）对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa");
        //     *      2，通过试题管理工厂获取实体管理器
        EntityManager em = factory.createEntityManager();
        //     *      3，获取事务·对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        /**
         * 增删改查  -- 根据id查询客户
         * getReference:根据id查询数据库(延迟加载)
         *  class：查询数据结构需要包装的实体类型的字节码
         *  id:插叙主键的值
         *
         */
        Customer customer = em.getReference(Customer.class, 1l);
        System.out.println(customer);

        tx.commit();
        factory.close();

    }

/**
* 删除客户
*/

 @Test
    public void testmove(){
        //通过工厂获取EntityManager对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa");
        EntityManager em =  factory.createEntityManager();
        //开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3,删除客户
        // 1,查询用户
        Customer customer = em.getReference(Customer.class,1l);
        //2,删除用户
        em.remove(customer);
        //提交事务
        tx.commit();
        //释放资源
        em.close();
        factory.close();
    }

查询用户

    @Test
    public void testUpdate(){
        //通过工厂获取entityManager
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa");
        EntityManager em = factory.createEntityManager();
        //2，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3,增删改查 更新操作
        //i,查询用户
        Customer customer = em.find(Customer.class,1l);
        //ii,更新客户
        customer.setCustIndustry("IT");
        em.merge(customer);
        //4,事务提交
        tx.commit();
        //释放资源
        em.close();
        factory.close();
    }

测试jpql查询

/**
* 查询全部
* jpql:from cn.qijian.domain.Customer
* sql:select * from cst_customer
*/

    @Test
    public void testFindall(){
        //1，获取EntityManger对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa");
        EntityManager em = factory.createEntityManager();
        //2,开启事务
        EntityTransaction et = em.getTransaction();
        et.begin();
        //3，查询全部
        String jqpl = "from  com.qijian.domain.Customer";
        Query query = em.createQuery(jqpl);//创建查询对象，query对象才是执行jqpl对象
        //发送查询，并封装结果集
        List list = query.getResultList();
        System.out.println(list.size());
        for (Object o:list ) {
            System.out.println(o);
        }
        //4，提交事务
        et.commit();
        //5,释放资源
        em.close();

    }

/**排序查询：倒叙查询全部用户（根据id）
* sql: SELECT * FROM cst_customer ORDER BY cust_id DESC;
* jpql:from Customer order by custId
*/


    @Test
    public void testOrder(){
        //1，获取EntityManger对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa");
        EntityManager em = factory.createEntityManager();
        //2,开启事务
        EntityTransaction et = em.getTransaction();
        et.begin();
        //3，查询全部
        String jqpl = "from  com.qijian.domain.Customer order by custId desc ";
        Query query = em.createQuery(jqpl);//创建查询对象，query对象才是执行jqpl对象
        //发送查询，并封装结果集
        List list = query.getResultList();
        System.out.println(list.size());
        for (Object o:list ) {
            System.out.println(o);
        }
        //4，提交事务
        et.commit();
        //5,释放资源
        em.close();
    }

/**
* 使用jpql统计客户的总人数
* sql:SELECT COUNT(cust_id) FROM cst_customer ;
* jpql:SELECT COUNT(cust_id) FROM Customer ;
*/

    @Test
    public void testCount(){
        //1，获取EntityManger对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa");
        EntityManager em = factory.createEntityManager();
        //2,开启事务
        EntityTransaction et = em.getTransaction();
        et.begin();
        //3，查询全部
        String jqpl = "SELECT COUNT(custId) FROM Customer ";
        Query query = em.createQuery(jqpl);//创建查询对象，query对象才是执行jqpl对象
        //发送查询，并封装结果集
        /**
         * getResultList:直接将查询结果封装为list集合1
         * getSingleResult：的到唯一的结果集
         */
        Object result =query.getSingleResult();
        System.out.println(result);
        //4，提交事务
        et.commit();
        //5,释放资源
        em.close();
    }

/**
* 分页查询
* sql SELECT * FROM cst_customer LIMIT ？;
* jqpl: from Customer
*/

    @Test
    public void testPaged(){
        //1，获取EntityManger对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa");
        EntityManager em = factory.createEntityManager();
        //2,开启事务
        EntityTransaction et = em.getTransaction();
        et.begin();
        //3，查询全部
        //i,根据jpql语句创建Query查询对象
        String jqpl = "FROM Customer ";
        Query query = em.createQuery(jqpl);//创建查询对象，query对象才是执行jqpl对象
        //ii,对参数赋值 - 分页查询
        //起始索引
        query.setFirstResult(0);
        //分页查询的条数
        query.setMaxResults(2);
        /**
         * getResultList:直接将查询结果封装为list集合1
         * getSingleResult：的到唯一的结果集
         */
        List list = query.getResultList();
        for (Object obj : list){
            System.out.println(obj);
        }
        //4，提交事务
        et.commit();
        //5,释放资源
        em.close();
    }

/**
* 条件查询
* 案例：
* sql：select * from cst_customer where cust_name like ?
* jpql:from Customer where custName like ?
*/

    @Test
    public void testCondition(){
        //1，获取EntityManger对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa");
        EntityManager em = factory.createEntityManager();
        //2,开启事务
        EntityTransaction et = em.getTransaction();
        et.begin();
        //3，查询全部
        //i,根据jpql语句创建Query查询对象
        String jqpl = "from Customer where custAddress like ?";
        Query query = em.createQuery(jqpl);//创建查询对象，query对象才是执行jqpl对象
        //ii,对参数赋值 - 占位符参数
        //第一个参数：占位符索引的位置（从1开始），第二各参数 ； 取值
        query.setParameter(1,"北_");

        /**
         * getResultList:直接将查询结果封装为list集合1
         * getSingleResult：的到唯一的结果集
         */
        List list = query.getResultList();
        for (Object obj : list){
            System.out.println(obj);
        }
        //4，提交事务
        et.commit();
        //5,释放资源
        em.close();
    }

柒间

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
Spring Data jpa学习之增删改查

jpa操作的操作步骤 1.加载配置文件创建实体管理器工厂 Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂） createEntityMnagerFactory（持久化单元名称）作用：创建实体管理器工厂 2.根据实体管理器工厂，创建实体管理器 EntityManagerFactory ：获取EntityManager对象方法：createEntityManager * 内部维护的很多的内容内部维护了数据库信息，维护了缓存信息
复制链接

扫一扫