首页 > 其他分享 >Spring Data Jpa

Spring Data Jpa

时间：2022-11-25 10:24:32浏览次数：44  
标签：resume Jpa Spring JPA org Data public

SpringDataJpa学习

Spring Data Jpa 是应⽤于Dao层的⼀个框架，简化数据库开发的，作⽤和Mybatis框架⼀样，但是在使 ⽤⽅式和底层机制是有所不同的。最明显的⼀个特点，Spring Data Jpa 开发Dao的时候，很多场景我们 连sql语句都不需要开发。由Spring出品。

概述

  • 什么是Spring Data Jpa

    Spring Data JPA 是 Spring 基于JPA 规范的基础上封装的⼀套 JPA 应⽤框架，可使开发者⽤极简的 代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常⽤功能！学习并使⽤ Spring Data JPA 可以极⼤提⾼开发效率。

    说明：Spring Data JPA 极⼤简化了数据访问层代码。

    如何简化呢？ 使⽤了Spring Data JPA，我们Dao层中只需要写接⼝，不需要写实现类，就⾃动具有 了增删改查、分⻚查询等⽅法。

    使⽤Spring Data JPA 很多场景下不需要我们⾃⼰写sql语句

  • Spring Data家族

Spring Data JPA，JPA规范和Hibernate之间的关系

Spring Data JPA 是 Spring 提供的⼀个封装了JPA 操作的框架，⽽ JPA 仅仅是规范，单独使⽤规范⽆法 具体做什么，那么Spring Data JPA 、 JPA规范 以及 Hibernate （JPA 规范的⼀种实现）之间的关系是什 么？如下图：

JPA 是⼀套规范，内部是由接⼝和抽象类组成的，Hiberanate 是⼀套成熟的 ORM 框架，⽽且 Hiberanate 实现了 JPA 规范，所以可以称 Hiberanate 为 JPA 的⼀种实现⽅式，我们使⽤ JPA 的 API 编 程，意味着站在更⾼的⻆度去看待问题（⾯向接⼝编程）。

Spring Data JPA 是 Spring 提供的⼀套对 JPA 操作更加⾼级的封装，是在 JPA 规范下的专⻔⽤来进⾏数 据持久化的解决⽅案。

应⽤

  • 需求：使⽤ Spring Data JPA 完成对 tb_resume 表（简历表）的Dao 层操作（增删改查，排序， 分⻚等）

  • 数据表设计

开发步骤梳理

  • 构建工程

    • 创建⼯程导⼊坐标（Java框架于我们⽽⾔就是⼀堆jar）

    • 配置 Spring 的配置⽂件（配置指定框架执⾏的细节）

    • 编写实体类 Resume，使⽤ JPA 注解配置映射关系

    • 编写⼀个符合 Spring Data JPA 的 Dao 层接⼝（ResumeDao接⼝）

Spring Data JPA 开发实现

  • maven

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <!--spring-data-jpa相关jar包-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.3.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>3.0.1-b04</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.6</version>
        </dependency>
        <!--spring相关jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.3.20</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.20</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.3.20</version>
        </dependency>
        <!--spring对orm框架的支持包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.20</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.20</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.20</version>
        </dependency>
        <!--hibernate相关jar包-->
        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>6.1.4.Final</version>
        </dependency>
        <!--hibernate对jpa的实现-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.6.7.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.0.20.Final</version>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <!--druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.20</version>
        </dependency>
    </dependencies>

  • 配置 Spring 的配置⽂件

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
          xmlns:tx="http://www.springframework.org/schema/tool"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/data/jpa
       http://www.springframework.org/schema/data/jpa/spring-jpa.xsd http://www.springframework.org/schema/tool http://www.springframework.org/schema/tool/spring-tool.xsd">
​
    <!--对Spring和SpringDataJpa进行配置-->
​
    <!--1 创建数据库连接池druid-->
    <!--引⼊外部资源⽂件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--第三⽅jar中的bean定义在xml中-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
​
    <!--2 配置jpa非常重要的一个对象，entityManagerFactory
    entityManager类似于mybatis中的SqlSession
    entityManagerFactory类似于Mybatis中的SqlSessionFactory-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置包扫描-->
        <property name="packagesToScan" value="com.yun.demo.pojo"/>
        <!--指定jpa具体实现，也就是hibernate-->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"></bean>
        </property>
        <!--指定jpa方言，不同的jpa方言实现对于类似于beginTransaction等细节实现起来是不一样的，
                                                    所以传入jpaDialect具体的实现类-->
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"></bean>
        </property>
        <!--配置具体provider，hibernate框架的执行细节-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--定义hibernate框架的一些细节-->
                <!--配置数据库表是否自动创建（因为我们会建⽴pojo和数据表之间的映射关系
                        程序启动时，如果数据表还没有创建，是否要程序给创建⼀下）-->
                <property name="generateDdl" value="false"/>
                <!--指定数据库的类型（hibernate本身是个dao层框架，可以⽀持多种数据库类型
                                            的，这⾥就指定本次使⽤的什么数据库）-->
                <property name="database" value="MYSQL"/>
                <!--配置数据库的方言（hiberante可以帮助我们拼装sql语句，但是不同的数据库sql
                                        语法是不同的，所以需要我们注⼊具体的数据库⽅⾔）-->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
                <!--是否显示sql（操作数据库时，是否打印sql）-->
                <property name="showSql" value="true"/>
            </bean>
        </property>
    </bean>
​
    <!--3 引用上面创建的entityManagerFactory
            <jpa:repositories> 配置jpa的dao层细节
            base-package:指定dao层接⼝所在包-->
    <jpa:repositories base-package="com.yun.demo.dao" entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="transactionManager"/>
​
    <!--4 事务管理器配置 (jdbcTemplate/mybatis 使⽤的是DataSourceTransactionManager
                                            jpa规范：JpaTransactionManager)-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <!--5 声明式事务配置-->
​
    <!--6 配置spring包扫描-->
    <context:component-scan base-package="com.yun.demo"/>
​
</beans>

  • resume实体

    /**
 * @author: Shaoyun_Wang
 * @create: 2022/11/24 16:46
 * @Description: 简历实体(在类中要使用注解建立实体类和数据表之间的映射关系以及属性和字段的映射关系)
 * 1,实体类和数据表映射关系
 * @Entity
 * @Table
 * 2,实体类属性和表字段的映射关系
 * @Id 标识主键
 * @GeneratedValue 标识主键的生成车策略
 * @Column 建立属性和字段映射
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "tb_resume")
public class Resume {
​
    /**
     * GenerationType.SEQUENCE:依靠序列来产⽣主键 Oracle
     * GenerationType.IDENTITY:依赖数据库中主键⾃增功能 Mysql
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
​
    @Column(name = "address")
    private String address;
​
    @Column(name = "name")
    private String name;
​
    @Column(name = "phone")
    private String phone;
​
}

  • ResumeDao 接⼝

    /**
 * @author: Shaoyun_Wang
 * @create: 2022/11/24 17:23
 * @Description:
 * 一个符合SpringDATaJpa要求的Dao层接口是需要继承 JpaRepository 和 JpaSpecificationExecutor
 * JpaRepository<操作的实体类类型,主键类型>封装了基本的CRUD操作
 * JpaSpecificationExecutor<操作的实体类类型>封装了复杂的查询（分⻚、排序等）
 */
public interface ResumeDao extends JpaRepository<Resume, Long>, JpaSpecificationExecutor<Resume> {
}

  • 调用继承的接口中的方法

    /**
 * @author: Shaoyun_Wang
 * @create: 2022/11/24 19:53
 * @Description: 
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class ResumeDaoTest {
​
    @Autowired
    private ResumeDao dao;
​
    //selectall
    @Test
    public void testFindAll(){
        List<Resume> all = dao.findAll();
        all.forEach(System.out::println);
​
    }
​
    //delete
    @Test
    public void testDeleteById(){
     dao.deleteById(1l);
​
    }
​
    //create&update
    @Test
    public void testSave(){
        //新增和更新都是用save()，没有主键信息的就是新增，有主键信息的就是更新
        Resume resume = new Resume();
        resume.setId(4l);
        resume.setAddress("西京");
        resume.setName("平安");
        resume.setPhone("1000010");
        Resume save = dao.save(resume);
        System.out.println(save);
    }
​
    //selectone
    @Test
    public void testFindOne(){
        Resume resume = new Resume();
        resume.setId(1l);
        Example<Resume> of = Example.of(resume);
        Resume resume1 = dao.findOne(of).get();
        System.out.println(resume1);
    }
​
    //selectone
    @Test
    public void testFindById(){
        Resume resume = dao.findById(1l).get();
        System.out.println(resume);
​
    }
​
}

  • 引入Jpql语句进行查询===>jpql语句类似sql，只不过sql操作的是数据库表和字段，jpql操作的是对象和属性

    public interface ResumeDao extends JpaRepository<Resume, Long>, JpaSpecificationExecutor<Resume> {
​
    @Query("from Resume where id=?1")
    public Resume getByJpql(Long id);
​
    @Query("from Resume where id=?1 and name=?2")
    public List<Resume> getByJpqlList(Long id,String name);
}
​
@Test
public void testjpqlLsit(){
    List<Resume> list = dao.getByJpqlList(1l, "刘二");
    list.forEach(System.out::println);
}
​
@Test
public void testjpql(){
    Resume byJpql = dao.getByJpql(1l);
    System.out.println(byJpql);
}

  • 引入原生的sql语句

    /**
 * 使用原生sql语句查询，需要将nativeQuery属性设置为true
 * @param name
 * @param address
 * @return
 */
@Query(value = "select * from tb_resume where name like ?1 and address like ?2",nativeQuery = true)
public List<Resume> getBySql(String name,String address);
​
@Test
public void testgetBySql(){
    List<Resume> bySql = dao.getBySql("刘%", "北%");
    bySql.forEach(System.out::println);
}

标签：resume,Jpa,Spring,JPA,org,Data,public
From： https://www.cnblogs.com/wangshaoyun/p/16924294.html

相关文章

  • Spring Security（5）
    您好，我是湘王，这是我的博客园，欢迎您来，欢迎您再来～ 经常上网的人都应该有这样的体验：很多网站或者APP只需要第一次登录时输入用户名和密码之后，后面很长一段时间内就不需要再......
  • SpringCloud-OpenFeign-使用细节
    1.openfeign调用HttpServletRequest作为参数报错..（主要针对请求头信息透传）https://blog.csdn.net/qq_44783283/article/details/1135309102.OpenFeign传输文件（针对文件......
  • parseable datadog &splunk& elk 可选开源方案
    parseable是基于rust编写的datadog&splunk&elk可选开源方案，提供了方便的restapi能力支持的特性云原生（无状态）开放模式（基于parquet）简单数据访问（/基于sql兼容的......
  • springboot笔记
    微服务阶段javase:OOPmysql:持久化html+css+js+jquery+框架：视图，框架不熟练，css不好；Javaweb：独立开发MVC三层架构的网站了：原始ssm：框架：简化了我们的开发流程，配置也开始较......
  • 在Spring Security中如何获取AuthenticationManager对象？
    有时需要使用AuthenticationManager（以下简称Manager）对象，可是这个对象不是Bean，没有直接保存在Spring的Bean库中。那么如何获取SpringSecurity中的这个对象呢？在SpringSecu......
  • SpringBoot整合Quartz
    1.Quartz1.1.Quartz简介Quartz是OpenSymphony开源组织在JobScheduling领域又一个开源项目，是完全由Java开发的一个开源任务日程管理系统，“任务进度管理器”就......
  • Spring 5 中文解析之测试篇-Spring测试介绍和单元测试
    微信公众号：测试本章介绍了Spring对集成测试的支持以及单元测试的最佳实践。Spring团队提倡测试驱动开发（TDD）。Spring的团队发现,正确使用控制反转(IoC)的确是简化单元测试和......
  • Spring 5 中文解析之测试篇-集成测试(下)
    3.6SpringMVC测试框架SpringMVC测试框架提供了一流的支持，可使用可与JUnit、TestNG或任何其他测试框架一起使用的流畅API测试SpringMVC代码。它基于​​spring-test​​......
  • Spring 5 中文解析之测试篇-集成测试(上)
    本节（本章其余部分）涵盖了Spring应用程序的集成测试。它包括以下主题：​​概要​​​​集成测试目标​​​​JDBC测试支持​​​​注解​​​​SpringTestContext框架​​​​......
  • Spring5全栈知识体系分享计划安排表
    Spring5全栈知识体系分享计划安排表第一阶段：翻译编号任务开始时间结束时间执行人完成进度1Spring52020-05-052020-10-01青年IT男已完成Spring-CoreSpring-TestingSpring-Da......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99