设为首页收藏本站京东联盟微信公众号京东商城有优惠
京东6.18大促主会场领京享红包更优惠

 找回密码
 立即注册

QQ登录

只需一步，快速开始

梦想之都-俊月星空 › 门户 ›站长分享› java相关技术 › 查看内容

Spring Data JPA入门

2021-3-22 22:55| 发布者: zhaojun917| 查看: 992| 评论: 0

摘要: SpringData JPA是spring基于ORM框架、JPA规范的基础上封装的一套JPA应用框架，可以使开发者使用极简的代码实现对数据库的访问和操作。它提供了包括增删改查等在内的基本功能，且易于扩展。 springdata jpa、jpa和hi ...

SpringData JPA是spring基于ORM框架、JPA规范的基础上封装的一套JPA应用框架，可以使开发者使用极简的代码实现对数据库的访问和操作。它提供了包括增删改查等在内的基本功能，且易于扩展。

springdata jpa、jpa和hibernate三者关系

通俗来讲springdata jpa是对jpa规范的一层封装，hibernate实现了jpa规范。

java代码----->springdata jpa ------>jpa规范------>hibernate------>jdbc ----->mysql数据库

graph LR
A[java代码] -->B(spring data jpa)
B --> |jpa规范| C(hibernate)
C -->|jdbc| D(mysql数据库)

我们使用java代码调用springdata jpa的api，springdata jpa封装了jpa规范，并且内部使用的是hibernate实现，hibernate封装了jdbc进行数据库操作。

入门案例

1、创建工程，导入依赖

    compile group: 'org.hibernate', name: 'hibernate-core', version: '5.4.3.Final'
    compile group: 'org.hibernate', name: 'hibernate-c3p0', version: '5.4.3.Final'
    compile group: 'mysql', name: 'mysql-connector-java', version: '8.0.16'
    compile group: 'org.springframework.data', name: 'spring-data-jpa', version: '2.1.9.RELEASE'
    testCompile group: 'org.springframework', name: 'spring-test', version: '5.1.8.RELEASE'

2、编写spring配置文件

  • 配置spring相关

  • 数据源信息

  • jpa的实现方式

  • 配置要用到的实体类

  • 配置jpa实现方的配置信息

  • 配置事务管理器

  • 声明式事务

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--spring-->
    <!--配置spring的注解扫描-->
    <context:component-scan base-package="com.lxf"/>


    <!--spring data jpa-->
    <!--整合spring data jpa-->
    <jpa:repositories base-package="com.lxf.dao" entity-manager-factory-ref="entityManagerFactory" transaction-manager-ref="transactionManager" />

    <!--创建实体管理器工厂,交给spring管理-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置要扫描的包，实体所在包-->
        <property name="packagesToScan" value="com.lxf.entity"/>
        <!--配置jpa的实现方-->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>

        <!--jpa的实现方的配置-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--数据库类型-->
                <property name="database" value="MYSQL"/>
                <!--控制台显示sql语句-->
                <property name="showSql" value="true"/>
                <!--是否自动创建数据库表-->
                <property name="generateDdl" value="true"/>
                <!--数据库方言-->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
            </bean>
        </property>

        <!--jpa方言:高级特性-->

    </bean>

    <!--数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/study?serverTimezone=GMT"/>
        <property name="user" value="root"/>
        <property name="password" value="crystal1024"/>
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
    </bean>

    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!--声明式事务-->
    
</beans>

3、创建实体类，编写实体类和数据库表关系映射

参考JPA规范。

4、编写dao层接口

  • 需要继承两个接口

    • JpaRepository：封装了增删改查分页排序等基本操作，具体可以看JpaRepository的父类
    graph TB
A[Repository] -->B(CrudRepository)
B --> C(PagingAndSortingRepository)
C -->D(JpaRepository)
    • JpaSpecificationExecutor：封装了标准查询

  • 提供相应的泛型

    • JpaRepository
      • 操作的实体类型
      • 实体中主键类型
    • JpaSpecificationExecutor
      • 操作的实体类型
public interface UserDao extends JpaRepository<User,Integer>, JpaSpecificationExecutor<User> {
}
  • 会通过动态代理自动生成相应方法

5、测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring_data_jpa.xml")
public class Test {
    @Autowired
    private UserDao userDao;

    @org.junit.Test
    public void textSave(){
        User user = new User();
        user.setName("小红");
        user.setAge(22);
        User userResult = userDao.save(user);
        System.out.println(userResult);
    }
}

User{id=4, name='小红', age=22, sex=null, address='null', phone='null'}

操作数据库

调用spring data jpa的api

插入/更新

  • save方法：传入的实体对象有主键则更新，没有主键则插入。
    @org.junit.Test
    public void testSave(){
        User user = new User();
        user.setName("小红");
        user.setAge(22);
        User userResult = userDao.save(user);
        System.out.println(userResult);
    }

删除

  • delete系列方法
    @org.junit.Test
    public void testDelete(){
        userDao.deleteById(2);
    }

查询

  • count：统计

  • exists系列方法：数据库中是否存在

  • find系列方法：立即加载

  • getOne：延迟加载，返回的是一个动态代理对象

    @org.junit.Test
    public void testFindOne(){
//        Optional<User> user = userDao.findById(2);
//        System.out.println(user.get());
        User user = userDao.getOne(2);
        System.out.println(user);
    }

    @org.junit.Test
    public void testApi(){
        long count = userDao.count();
        boolean b = userDao.existsById(2);
    }

语句操作

除了调用spring data jpa内置的api，我们也可以在dao接口中定义我们自己的方法，通过@Query声明jpql或sql语句。

  • @Query
    • value：数据库操作语句
    • nativeQuery：是否是原生查询，默认false，即默认使用jpql查询
  • @Modifying：声明当前是一个更新操作，需要修改数据库数据。
    • 只能用于void或int/Integer的返回类型
    • 因为需要修改数据库数据，未防止修改失败造成未知后果，需要搭配事务管理来是使用
  • @Transactional：添加事务管理支持
    • 一般需要设置rollbackFor或者noRollbackFor，来表示什么情况下进行事务回滚
  • @Rollback：是否可以回滚，默认true

jpql查询

public interface UserDao extends JpaRepository<User, Integer>, JpaSpecificationExecutor<User> {

    @Query(value = "from User where name = :name and age = :age")
    public User findUserByName(@Param("name") String userName,@Param("age") int age);
}

jpql更新

@Query(value = "update User set name = :name where id = :id")
@Modifying
public Integer updateNameById(@Param("id") int id,@Param("name") String userName);


    @org.junit.Test
    @Transactional(rollbackFor = Exception.class)
    //@Rollback(value = false)//如果设置为fasle，即使发生异常也不会回滚
    public void testJpql(){
        User user = userDao.findUserByName("lili",18);
        System.out.println(user);

        userDao.updateNameById(user.getId(),"lili_2");
    }

原生sql语句查询

public interface UserDao extends JpaRepository<User, Integer>, JpaSpecificationExecutor<User> {
    @Query(value = "select * from user where name = :name and age = :age",nativeQuery = true)
    public User findUserByName(@Param("name") String userName,@Param("age") int age);
}

约定规则查询

spring data jpa制定了一些约定，如果按照这些约定来定义方法名，则会自动解析出sql语句。

findBy + 属性名 + 查询方式 + （And|Or） + 属性名 + 查询方式...

查询方式 方法命名 sql where字句
And findByNameAndPwd where name= ? and pwd =?
Or findByNameOrSex where name= ? or sex=?
Is,Equals findById,findByIdEquals where id= ?
Between findByIdBetween where id between ? and ?
LessThan findByIdLessThan where id < ?
LessThanEquals findByIdLessThanEquals where id <= ?
GreaterThan findByIdGreaterThan where id > ?
GreaterThanEquals findByIdGreaterThanEquals where id > = ?
After findByIdAfter where id > ?
Before findByIdBefore where id < ?
IsNull findByNameIsNull where name is null
isNotNull,NotNull findByNameNotNull where name is not null
Like findByNameLike where name like ?
NotLike findByNameNotLike where name not like ?
StartingWith findByNameStartingWith where name like '?%'
EndingWith findByNameEndingWith where name like '%?'
Containing findByNameContaining where name like '%?%'
OrderBy findByIdOrderByXDesc where id=? order by x desc
Not findByNameNot where name <> ?
In findByIdIn(Collection<?> c) where id in (?)
NotIn findByIdNotIn(Collection<?> c) where id not in (?)
True findByAaaTue where aaa = true
False findByAaaFalse where aaa = false
IgnoreCase findByNameIgnoreCase where UPPER(name)=UPPER(?)

简单挑几个示例：

public interface UserDao extends JpaRepository<User, Integer>, JpaSpecificationExecutor<User> {
    public User findByName(String name);

    public User findByNameLike(String name);

    public User findByNameLikeAndAge(String name, int age);

    public List<User> findByIdBetween(int idMin, int idMax);
}



    @org.junit.Test
    public void testName(){
        User user1 = userDao.findByName("tom");
        System.out.println(user1);

        User user2 = userDao.findByNameLike("t%");
        System.out.println(user2);

        User user3 = userDao.findByNameLikeAndAge("tom",18);
        System.out.println(user3);

        List<User> users = userDao.findByIdBetween(1, 3);
        users.forEach(new Consumer<User>() {
            @Override
            public void accept(User user) {
                System.out.println(user);
            }
        });
    }

Hibernate: select user0_.id as id1_0_, user0_.address as address2_0_, user0_.age as age3_0_, user0_.name as name4_0_, user0_.phone as phone5_0_, user0_.sex as sex6_0_ from user user0_ where user0_.name=?
User{id=3, name='tom', age=18, sex=1, address='null', phone='null'}
Hibernate: select user0_.id as id1_0_, user0_.address as address2_0_, user0_.age as age3_0_, user0_.name as name4_0_, user0_.phone as phone5_0_, user0_.sex as sex6_0_ from user user0_ where user0_.name like ? escape ?
User{id=3, name='tom', age=18, sex=1, address='null', phone='null'}
Hibernate: select user0_.id as id1_0_, user0_.address as address2_0_, user0_.age as age3_0_, user0_.name as name4_0_, user0_.phone as phone5_0_, user0_.sex as sex6_0_ from user user0_ where (user0_.name like ? escape ?) and user0_.age=?
User{id=3, name='tom', age=18, sex=1, address='null', phone='null'}
Hibernate: select user0_.id as id1_0_, user0_.address as address2_0_, user0_.age as age3_0_, user0_.name as name4_0_, user0_.phone as phone5_0_, user0_.sex as sex6_0_ from user user0_ where user0_.id between ? and ?
User{id=2, name='lili2', age=18, sex=1, address='null', phone='null'}
User{id=3, name='tom', age=18, sex=1, address='null', phone='null'}

标准查询（Specification）

我们上面提到过，springdata jpa的dao层一般继承2个接口JpaRepository和JpaSpecificationExecutor。JpaRepository封装了crud、统计、排序、分页的常见操作，而JpaSpecificationExecutor基于JPA的criteria查询封装了另一种查询方式，我们之前一直在使用JpaRepositoru中的方法，下面来看下JpaSpecificationExecutor接口，它里面只提供了5个方法：

public interface JpaSpecificationExecutor<T> {
    //查询一个
    Optional<T> findOne(@Nullable Specification<T> spec);
    //查询全部
    List<T> findAll(@Nullable Specification<T> spec);
    //查询全部  提供分页功能
    Page<T> findAll(@Nullable Specification<T> spec, Pageable pageable);
    //查询全部，提供排序功能
    List<T> findAll(@Nullable Specification<T> spec, Sort sort);
    //统计
    long count(@Nullable Specification<T> spec);
}

可以看到，这5个方法有个共同点，接收一个Specification参数。

Specification

Specification是对JPA规范中Root、CriteriaQuery、CriteriaBuilder的一层封装，用于构建过滤条件。实例化Specification需要实现它的toPerdicate方法：

//参数含义在我的另一文JPA规范中有介绍，简单说来Root用于获得查询属性，CriteriaBuilder用于构建过滤条件，CriteriaQuery用于指定最终查询语句，这里一般不会使用，默认为where语句。
Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder);

注意这里创建出来的是where查询语句。

来个简单示例，查询表中年龄大于等于18的所有河南人：

收藏 分享 邀请
上一篇：eclipse中项目太多怎样分类存放下一篇：为什么使用Spring的@autowired注解后就不用写setter了？

相关分类

关闭

站长推荐上一条 /6 下一条

QQ|手机版|小黑屋|梦想之都-俊月星空 ( 粤ICP备18056059号 )|网站地图

GMT+8, 2025-7-1 19:16 , Processed in 0.033278 second(s), 18 queries .

Powered by Mxzdjyxk! X3.5

© 2001-2025 Discuz! Team.