A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 甘为伊一 初级黑马   /  2019-5-9 13:56  /  768 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

SpringdataJPA

springDataJpa的入门操作

            案例:客户的基本CRUD
            i.搭建环境
                    创建工程导入坐标
                    配置spring的配置文件(配置spring Data jpa的整合)
                    编写实体类(Customer),使用jpa注解配置映射关系
            ii.编写一个符合springDataJpa的dao层接口
                    * 只需要编写dao层接口,不需要编写dao层接口的实现类
                    * dao层接口规范
                            1.需要继承两个接口(JpaRepository,JpaSpecificationExecutor)
                            2.需要提供响应的泛型
            *
                findOne(id) :根据id查询
                save(customer):保存或者更新(依据:传递的实体类对象中,是否包含id属性)
                delete(id) :根据id删除
                findAll() : 查询全部

springDataJpa的运行过程和原理剖析

            1.通过JdkDynamicAopProxy的invoke方法创建了一个动态代理对象
            2.SimpleJpaRepository当中封装了JPA的操作(借助JPA的api完成数据库的CRUD)
            3.通过hibernate完成数据库操作(封装了jdbc)

复杂查询               

            i.借助接口中的定义好的方法完成查询
                    findOne(id):根据id查询
            ii.jpql的查询方式
                    jpql : jpa query language  (jpq查询语言)
                    特点:语法或关键字和sql语句类似
                            查询的是类和类中的属性        * 需要将JPQL语句配置到接口方法上
                    1.特有的查询:需要在dao接口上配置方法
                    2.在新添加的方法上,使用注解的形式配置jpql查询语句
                    3.注解 : @Query
   
            iii.sql语句的查询
                    1.特有的查询:需要在dao接口上配置方法
                    2.在新添加的方法上,使用注解的形式配置sql查询语句
                    3.注解 : @Query
                            value :jpql语句 | sql语句
                            nativeQuery :false(使用jpql查询) | true(使用本地查询:sql查询)
                                    是否使用本地查询
                                   
            iiii.方法名称规则查询
                    *是对jpql查询,更加深入一层的封装
                    *我们只需要按照SpringDataJpa提供的方法名称规则定义方法,不需要再配置jpql语句,完成查询
                    *
                            findBy开头:        代表查询
                                    对象中属性名称(首字母大写)
                    *含义:根据属性名称进行查询



Specifications动态查询

    JpaSpecificationExecutor 方法列表
   
            T findOne(Specification<T> spec);  //查询单个对象
   
            List<T> findAll(Specification<T> spec);  //查询列表
   
            //查询全部,分页
            //pageable:分页参数
            //返回值:分页pageBean(page:是springdatajpa提供的)
            Page<T> findAll(Specification<T> spec, Pageable pageable);
   
            //查询列表
            //Sort:排序参数
            List<T> findAll(Specification<T> spec, Sort sort);
   
            long count(Specification<T> spec);//统计查询
           
    * Specification :查询条件
            自定义我们自己的Specification实现类
                    实现
                            //root:查询的根对象(查询的任何属性都可以从根对象中获取)
                            //CriteriaQuery:顶层查询对象,自定义查询方式(了解:一般不用)
                            //CriteriaBuilder:查询的构造器,封装了很多的查询条件
                            Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb); //封装查询条件

###多表之间的关系和操作多表的操作步骤

    表关系
            一对一
            一对多:
                    一的一方:主表
                    多的一方:从表
                    外键:需要再从表上新建一列作为外键,他的取值来源于主表的主键
            多对多:
                    中间表:中间表中最少应该由两个字段组成,这两个字段做为外键指向两张表的主键,又组成了联合主键
   
    讲师对学员:一对多关系
                   
    实体类中的关系
            包含关系:可以通过实体类中的包含关系描述表关系
            继承关系
   
    分析步骤
            1.明确表关系
            2.确定表关系(描述 外键|中间表)
            3.编写实体类,再实体类中描述表关系(包含关系)
            4.配置映射关系

完成多表操作

    i.一对多操作
            案例:客户和联系人的案例(一对多关系)
                    客户:一家公司
                    联系人:这家公司的员工
           
                    一个客户可以具有多个联系人
                    一个联系人从属于一家公司
                   
            分析步骤
                    1.明确表关系
                            一对多关系
                    2.确定表关系(描述 外键|中间表)
                            主表:客户表
                            从表:联系人表
                                    * 再从表上添加外键
                    3.编写实体类,再实体类中描述表关系(包含关系)
                            客户:再客户的实体类中包含一个联系人的集合
                            联系人:在联系人的实体类中包含一个客户的对象
                    4.配置映射关系
                            * 使用jpa注解配置一对多映射关系
   
            级联:
                    操作一个对象的同时操作他的关联对象
                   
                    级联操作:
                            1.需要区分操作主体
                            2.需要在操作主体的实体类上,添加级联属性(需要添加到多表映射关系的注解上)
                            3.cascade(配置级联)
                   
                    级联添加,
                            案例:当我保存一个客户的同时保存联系人
                    级联删除
                            案例:当我删除一个客户的同时删除此客户的所有联系人
                           
    ii.多对多操作
            案例:用户和角色(多对多关系)
                    用户:
                    角色:
   
            分析步骤
                    1.明确表关系
                            多对多关系
                    2.确定表关系(描述 外键|中间表)
                            中间间表
                    3.编写实体类,再实体类中描述表关系(包含关系)
                            用户:包含角色的集合
                            角色:包含用户的集合
                    4.配置映射关系

配置文件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">
            <!--jpa的实现方式 -->
            <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
   
            <!--可选配置:配置jpa实现方的配置信息-->
            <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.cj.jdbc.Driver"/>
                <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa?characterEncoding=utf8&amp;serverTimezone=UTC"/>
   
                <!--配置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 itcast.gwy.domain;
   
    import javax.persistence.*;
   
    /**
     * Author:Octavia‘G
     * CreateTime:四月 2019
     */
   
    @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;
        }
   
   
    }
   

测试类

    package itcast.gwy.test;
   
    import itcast.gwy.domain.Customer;
    import org.junit.Test;
   
    import javax.persistence.EntityManager;
    import javax.persistence.EntityManagerFactory;
    import javax.persistence.EntityTransaction;
    import javax.persistence.Persistence;
   
    /**
     * Author:Octavia‘G
     * CreateTime:四月 2019
     */
   
   
   
    public class JpaTest {
   
        /**
         * 测试JPA的保存
         *
         * JPA的操作步骤
         *      1.加载配置文件创建工厂(实体管理类工厂)对象
         *      2.通过实体管理类工厂获取实体管理器
         *      3.获取事务对象,开启事务。
         *      4.通过事务对象完成(CRUD)操作
         *      5.提交事务(回滚事务)
         *      6.释放资源
         *
         */
        @Test
        public void testSave(){
            //1.加载配置文件创建工厂(实体管理类工厂)对象
            EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
   
            //2.通过实体管理类工厂获取实体管理器
            EntityManager em = factory.createEntityManager();
   
            //3.获取事务对象
            EntityTransaction tx = em.getTransaction();
   
            //4.开启事务
            tx.begin();
   
            Customer c = new Customer();
            c.setCustName("name");
            c.setCustSource("source");
            c.setCustLevel("level");
            c.setCustIndustry("Industry");
            c.setCustPhone("phone");
            c.setCustAddress("address");
   
            em.persist(c);
            //提交事务
            tx.commit();
   
            //释放资源
            em.close();
            factory.close();
        }
    }
   



     * JPA的操作步骤
              * 1.加载配置文件创建工厂(实体管理类工厂)对象
                         Persistence:静态方法createEntityManagerFactory
         *2.通过实体管理类工厂获取实体管理器
                        
         *3.获取事务对象,开启事务。
         *4.通过事务对象完成(CRUD)操作
         *5.提交事务(回滚事务)
         *6.释放资源


0 个回复

您需要登录后才可以回帖 登录 | 加入黑马