首页 > 编程语言 > 详细

springDataJPA笔记

时间:2020-01-21 22:17:33      阅读:42      评论:0      收藏:0      [点我收藏+]

标签:执行   ava   用户名   identity   ride   count   

springDataJPA笔记


第一 orm思想

主要目的:操作实体类就相当于操作数据库表
建立两个映射关系:
    实体类和表的映射关系
    实体类中属性和表中字段的映射关系
不再重点关注:sql语句

实现了ORM思想的框架:mybatis,hibernate

第二 hibernate框架介绍

Hibernate是一个开放源代码的对象关系映射框架,
    它对JDBC进行了非常轻量级的对象封装,
    它将POJO与数据库表建立映射关系,是一个全自动的orm框架

第三 JPA规范

jpa规范,实现jpa规范,内部是由接口和抽象类组成

第四 jpa的基本操作

案例:是客户的相关操作(增删改查)
    客户:就是一家公司
客户表:

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.排序
    
    

以上是课件的内容:

总结:
使用jpa的步骤,但是不适用springboot注解的形式,那么

第一步就需要创建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">
    <!--jpa的实现方式-->
    <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>


    <properties>
        <!--开始配置基本属性-->
        <!--需要数据库信息
            用户名:javax.persistence.jdbc.user
            密码:javax.persistence.jdbc.password
            驱动:javax.persistence.jdbc.driver
            数据库地址: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:///springdatajpa"/>
        <!--可选的配置:为了配置jpa实现方的配置信息
            hibernate:
                显示sqlhibernate.show_sql
                自动创建数据库表hibernate.hbm2ddl.auto
                        create:程序运行时创建数据库表(如果有表,先删除表再创建)
                        update:c程序运行时创建表(如果有表不会创建表)
                        none:不会创建表
        -->
        <property name="hibernate.show_sql" value="true"/>
        <property name="hibernate.hbm2ddl.auto" value="update"/>
    </properties>
</persistence-unit>
</persistence>

以上的代码进行了详细的注解,就不需要解释了。
第二步:需要创建实体类,根据实体类进行创建数据库表结构:

    package cn.itcast.domain;
    
    /**
     * @Created by Intellij IDEA.
     * @author: 陈亚萌
     * @Date: 2020/1/18
     */
    
    import javax.persistence.*;
    
    /**
     * 客户实体类:
     *  配置映射关系:
     *      1. 实体类和表的映射关系
     *      2. 实体类中属性和表中字段的映射关系
     *      @Entity声明实体列
     *      @Table:声明实体类和表的映射关系  name 属性是配置数据库的名称
     *      @Id:声明主键
     *      strategy
     *           @GeneratedValue(strategy = GenerationType.IDENTITY)  表示主键生成策略是自增 mysql
     *              * 底层数据库必须支持自动增长,底层数据库支持的自动增长方式,对id递增
     *           GenerationType.SEQUENCE: 序列  Oracle
     *                  底层数据库必须支持序列
     *           GenerationType.TABLE :
     *              jpa提供的一种机制,通过数据库表的形式帮我们完成主键自增
     *           GenerationType.AUTO:
     *              由程序自动帮我们选择主键生成策略
     *      @Column(name = 'cust_id')配置属性和字端的映射关系  name代表数据库表中的字段名
     */
    @Entity
    @Table(name = "cst_customer")
    public class Customer {
        @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_level")
        private String custLevel;
        @Column(name = "cust_industry")
        private String custIndustry;
        @Column(name = "cust_phone")
        private String custPhone;
        @Column(name = "cust_address")
        private String custAddress;
    
        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 getCustLevel() {
            return custLevel;
        }
    
        public void setCustLevel(String custLevel) {
            this.custLevel = custLevel;
        }
    
        public String getCustIndustry() {
            return custIndustry;
        }
    
        public void setCustIndustry(String custIndustry) {
            this.custIndustry = custIndustry;
        }
    
        public String getCustPhone() {
            return custPhone;
        }
    
        public void setCustPhone(String custPhone) {
            this.custPhone = custPhone;
        }
    
        public String getCustAddress() {
            return custAddress;
        }
    
        public void setCustAddress(String custAddress) {
            this.custAddress = custAddress;
        }
    
        @Override
        public String toString() {
            return "Customer{" +
                    "custId=" + custId +
                    ", custName='" + custName + '\'' +
                    ", custSource='" + custSource + '\'' +
                    ", custLevel='" + custLevel + '\'' +
                    ", custIndustry='" + custIndustry + '\'' +
                    ", custPhone='" + custPhone + '\'' +
                    ", custAddress='" + custAddress + '\'' +
                    '}';
        }
    }

以上也有对每段代码的详细注解,也可以不用手写setget方法,直接使用lombok进行@Data注解即可。

第三步,进行测试:

    package cn.itcast;

import cn.itcast.domain.Customer;
import cn.itcast.utils.JpaUtils;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;

/**
 * @Created by Intellij IDEA.
 * @author: 陈亚萌
 * @Date: 2020/1/18
 */
public class test {
    /*
    * 测试jpa的保存
    *   案例 保存一个客户到数据库
    * jpa操作步骤:
    *   1. 加载配置文件创建工厂(实体管理工厂)对象
    *   2. 通过实体管理类获取实体管理器
    *   3. 获取事务对象,开启事务
    *   4. 完成增删改查操作
    *   5. 提交事务(回滚事务)
    *   6. 释放资源
    * */
    @Test
    public void testSave(){
    /*    //1. 加载配置文件创建工厂(实体管理工厂)对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //2. 通过实体管理类获取实体管理器
        EntityManager em = factory.createEntityManager();*/
        EntityManager em= JpaUtils.getEntityManager();
        // 3 . 获取事务对象,开启事务
        EntityTransaction tx = em.getTransaction();
        //开启事务
        tx.begin();
        //4。完成增删改查操作
        Customer customer=new Customer();
        customer.setCustName("chenyameng");
        customer.setCustIndustry("IT");
        //保存
        em.persist(customer);
        // 5. 提交事务(回滚事务)
        tx.commit();
        // 6. 释放资源
        em.close();
        //factory.close();

    }

    /**
     * 根据id查询用户
     */
    @Test
    public void testFind(){
        //1, 通过工具类获取entityManger
        EntityManager em = JpaUtils.getEntityManager();
        //2,开启事务
        EntityTransaction tx=em.getTransaction();
        tx.begin();
        //3, 增删改查
        /**
         * find:根据id查询数据
         *      class:字节码,查询数据的结果需要包装的实体类类型的字节码
         *      id:查询的主键的取值
         *
         *      使用find方法查询
         *          1. 查询的对象就是当前客户对象本身
         *          2. 调用find方法的时候,就会发送sql请求
         */
        Customer customer = em.find(Customer.class, 1l);
        System.out.println(customer.toString());
        //4,提交事务,
        tx.commit();
        // 释放资源
        em.close();
    }

    /**
     * 根据id查询用户
     */
    @Test
    public void testReference(){
        //1, 通过工具类获取entityManger
        EntityManager em = JpaUtils.getEntityManager();
        //2,开启事务
        EntityTransaction tx=em.getTransaction();
        tx.begin();
        //3, 增删改查
        /**
         * getReference:根据id查询数据
         *      class:字节码,查询数据的结果需要包装的实体类类型的字节码
         *      id:查询的主键的取值
         *
         *      特点:
         *          获取的对象是动态代理的对象
         *          调用reference方法不会立即发送sql语句查询数据库
         *              * 当调用查询结果的时候,才会发送sql语句,什么时候用,什么时候发送sql语句
         *              延迟加载,特点:
         *                  得到的是动态代理对象
         *                  什么时候用什么时候查
         *
         */
        Customer customer = em.getReference(Customer.class, 1l);
        System.out.println(customer.toString());
        //4,提交事务,
        tx.commit();
        // 释放资源
        em.close();
    }
    /**
     * s删除客户
     */
    @Test
    public void testRemove(){
        //1, 通过工具类获取entityManger
        EntityManager em = JpaUtils.getEntityManager();
        //2,开启事务
        EntityTransaction tx=em.getTransaction();
        tx.begin();
        //3, 增删改查
        //3.1 根据id查询客户
        final Customer customer = em.find(Customer.class, 1L);
        // 3.2 调用remove  方法删除操作
       em.remove(customer);
        //4,提交事务,
        tx.commit();
        // 释放资源
        em.close();
    }
    /**
     * 更新客户
     */
    @Test
    public void testUpdate(){
        //1, 通过工具类获取entityManger
        EntityManager em = JpaUtils.getEntityManager();
        //2,开启事务
        EntityTransaction tx=em.getTransaction();
        tx.begin();
        //3, 增删改查
        //3.1 客户的更新
        final Customer customer = em.find(Customer.class, 2L);
        customer.setCustIndustry("it教育");
        // 3.2 调用update
        em.merge(customer);
        //4,提交事务,
        tx.commit();
        // 释放资源
        em.close();
    }
}

以上代码也有详细的解释。

jqpl语言的简单讲解:

    package cn.itcast;
    
    import cn.itcast.utils.JpaUtils;
    import org.junit.Test;
    
    import javax.persistence.EntityManager;
    import javax.persistence.EntityTransaction;
    import javax.persistence.Query;
    import java.util.List;
    
    /**
     * @Created by Intellij IDEA.
     * @author: 陈亚萌
     * @Date: 2020/1/18
     * jpql测试
     */
    public class JpqlTest {
        /**
         * 查询全部:
         *      jqpl:from cn.itcast.domain.Customer
         *      sql:select * from cst_customer
         */
        @Test
        public void testFindAll(){
            //1, 获取Entitymanager对象
            EntityManager em=JpaUtils.getEntityManager();
            //2 开启事务
            final EntityTransaction transaction = em.getTransaction();
            transaction.begin();
            //3 查询全部
            String jpql="from Customer";
            //创建Query对象,query对象才是执行spql对象
            Query query = em.createQuery(jpql);
            //发送查询,并封装结果集
            List list = query.getResultList();
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
            // 4.提交事务
            transaction.commit();
    
            // 释放资源
            em.close();
        }
        /**
         * 排序查询:
         *      jqpl:from cn.itcast.domain.Customer order by custId
         *      sql:select * from cst_customer order by cust_id DESC
         *  进行jpql查询:
         *      1. 创建query对象
         *      2. 对参数进行复制
         *      3. 查询并返回结果
         */
        @Test
        public void testOrder(){
            //1, 获取Entitymanager对象
            EntityManager em=JpaUtils.getEntityManager();
            //2 开启事务
            final EntityTransaction transaction = em.getTransaction();
            transaction.begin();
            //3 查询全部
            String jpql="from cn.itcast.domain.Customer order by custId DESC";
            //创建Query对象,query对象才是执行spql对象
            Query query = em.createQuery(jpql);
            //发送查询,并封装结果集
            List list = query.getResultList();
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
            // 4.提交事务
            transaction.commit();
    
            // 释放资源
            em.close();
        }
        /**
         * 计数查询:
         *
         *     使用jpql查询,统计客户的总数:
         *      sql:select count(cus_id) from customer
         *      jpql:select count(custId) from Customer
         */
        @Test
        public void testCount(){
            //1, 获取Entitymanager对象
            EntityManager em=JpaUtils.getEntityManager();
            //2 开启事务
            final EntityTransaction transaction = em.getTransaction();
            transaction.begin();
            //3 查询全部
    
            //1 根据jpql语句创建query对象
            String jpql="select count(custId) from Customer";
            //2 参数赋值
            // 3 发送查询,并封装结果
            Query query = em.createQuery(jpql);
            //发送查询,并封装结果集
            /**
             * getResultList:直接将查询结果封装成为list集合
             * getSingleResult:得到唯一的结果集
             */
            final Object singleResult = query.getSingleResult();
            System.out.println(singleResult);
    
            // 4.提交事务
            transaction.commit();
    
            // 释放资源
            em.close();
        }
        /**
         * 分页查询:
         * sql:select * from cst_customer limit ?,?
         * jpql:from Customer
         */
        @Test
        public void testPage(){
            //1, 获取Entitymanager对象
            EntityManager em=JpaUtils.getEntityManager();
            //2 开启事务
            final EntityTransaction transaction = em.getTransaction();
            transaction.begin();
            //3 查询全部
    
            //1 根据jpql语句创建query对象
            String jpql="from Customer";
    
            // 3 发送查询,并封装结果
            Query query = em.createQuery(jpql);
            //发送查询,并封装结果集
            /**
             * getResultList:直接将查询结果封装成为list集合
             * getSingleResult:得到唯一的结果集
             */
            final List resultList = query.getResultList();
            for (Object o : resultList) {
                System.out.println(o);
            }
            //2 参数赋值
            //起始索引,
            query.setFirstResult(0);
            //每页查询的条数
            query.setMaxResults(2);
            // 4.提交事务
            transaction.commit();
    
            // 释放资源
            em.close();
        }
        /**
         * 条件查询:
         *  查询客户名称以“传值”开头的
         *      sql: select * from cst_customer where cust_name like '搜索%'
         *      jpql: from Customer where custName like ?
         */
        @Test
        public void testCondition(){
            //1, 获取Entitymanager对象
            EntityManager em=JpaUtils.getEntityManager();
            //2 开启事务
            final EntityTransaction transaction = em.getTransaction();
            transaction.begin();
            //3 查询全部
    
            //1 根据jpql语句创建query对象
            String jpql="from Customer where custName like ?";
    
            // 3 发送查询,并封装结果
            Query query = em.createQuery(jpql);
            //发送查询,并封装结果集
            /**
             * getResultList:直接将查询结果封装成为list集合
             * getSingleResult:得到唯一的结果集
             */
    
            //2 参数赋值  占位符参数
            // 第一个参数: 占位符的索引位置:(从1开始) 第二个参数:取值
            final Query query1 = query.setParameter(1, "chenya%");
            final List resultList = query.getResultList();
            for (Object o : resultList) {
                System.out.println(o);
            }
            // 4.提交事务
            transaction.commit();
    
            // 释放资源
            em.close();
        }
    }

这种方法一般不常用,常用的是已经封装好的,但是底层源码应该就是这样的,初步理解,如果错误,指出更正。
代码上传到git:
"springdatajpa"

springDataJPA笔记

标签:执行   ava   用户名   identity   ride   count   

原文:https://www.cnblogs.com/chenyameng/p/12227145.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号