​ Spring Data JPA

已于 2025-05-17 22:24:50 修改
阅读量1k 收藏 7
点赞数 9
分类专栏： SpringDataJpa 文章标签： java jpa spring
于 2025-05-16 23:28:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jonas80029735/article/details/148019275
版权

Spring Data JPA：Spring Data JPA 是 Spring Data 项目下的一个模块。提供了一套基于 JPA标准操作数据库的简化方案。底层默认的是依赖 Hibernate JPA 来实现的。 Spring Data JPA 的技术特点：我们只需要定义接口并集成 Spring Data JPA 中所提供的接口就可以了。不需要编写接口实现类。

一、Spring整合Hibernate

1. 创建项目

创建一个普通的Maven项目即可

2.添加相关的依赖

<dependencies>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-orm</artifactId>
             <version>5.1.6.RELEASE</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
             <version>5.1.6.RELEASE</version>
         </dependency>
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjweaver</artifactId>
             <version>1.9.2</version>
         </dependency>
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid</artifactId>
             <version>1.1.8</version>
         </dependency>
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>8.0.11</version>
         </dependency>
         <dependency>
             <groupId>org.hibernate</groupId>
             <artifactId>hibernate-core</artifactId>
             <version>5.0.7.Final</version>
         </dependency>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.12</version>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>
             <version>5.1.6.RELEASE</version>
         </dependency>
     </dependencies>

3. 添加相关的配置文件

添加数据库的配置文件和Spring的配置文件

<?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:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx"
        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/tx
        http://www.springframework.org/schema/context/spring-tx.xsd
 ">
     <!-- 引入db.properties文件 -->
     <context:property-placeholder location="classpath:db.properties" />
     <!-- 创建druid 的数据源 -->
     <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
         <property name="url" value="${jdbc.url}" />
         <property name="driverClassName" value="${jdbc.driver}" />
         <property name="username" value="${jdbc.username}" />
         <property name="password"  value="${jdbc.password}" />
     </bean>
 
     <!-- 配置Hibernate的SessionFactory对象 -->
     <bean class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" id="sessionFactory">
         <!-- 关联数据源 -->
         <property name="dataSource" ref="dataSource"/>
         <!-- 配置Hibernate的属性信息 -->
         <property name="hibernateProperties">
             <props>
                 <prop key="show_sql">true</prop>
                 <prop key="hibernate.hbm2ddl.auto">update</prop>
             </props>
         </property>
         <!-- 扫描路径 -->
         <property name="packagesToScan">
             <list>
                 <value>com.bobo.pojo</value>
             </list>
         </property>
     </bean>
 
     <!-- 配置HibernateTemplate对象 -->
     <bean class="org.springframework.orm.hibernate5.HibernateTemplate" id="hibernateTemplate">
         <property name="sessionFactory" ref="sessionFactory"/>
     </bean>
 
     <!--  配置事务管理-->
     <bean class="org.springframework.orm.hibernate5.HibernateTransactionManager" id="transactionManager">
         <property name="sessionFactory" ref="sessionFactory" />
     </bean>
 
     <!-- 配置开启事务注解 -->
     <tx:annotation-driven transaction-manager="transactionManager" />
 
     <!-- 配置扫描路径 -->
     <context:component-scan base-package="com.bobo" />
 </beans>

4. 创建POJO

和表结构中的t_user表对应即可

package com.bobo.pojo;
 
 
 import javax.persistence.*;
 import java.io.Serializable;
 
 @Entity
 @Table(name="t_user")
 public class Users implements Serializable {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     @Column(name="user_id")
     private Integer userId;
 
     @Column(name="user_name")
     private String userName;
 
     @Column(name="real_name")
     private String realName;
 
     public Integer getUserId() {
         return userId;
     }
 
     public void setUserId(Integer userId) {
         this.userId = userId;
     }
 
     public String getUserName() {
         return userName;
     }
 
     public void setUserName(String userName) {
         this.userName = userName;
     }
 
     public String getRealName() {
         return realName;
     }
 
     public void setRealName(String realName) {
         this.realName = realName;
     }
 }

5. 创建持久层

定义持久层接口，定义要实现的相关的方法

package com.bobo.dao;
 
 import com.bobo.pojo.Users;
 
 import java.util.List;
 
 public interface IUserDao {
 
     void insertUsers(Users users);
 
     void updateUsers(Users users);
 
     void deleteUsers(Users users);
 
     Users selectUsersById(Integer userId);
 
     List<Users> selectUsersByName(String userName);
 
     List<Users> selectUsersByNameUseSQL(String userName);
 
     List<Users> selectUsersByNameUseCriteria(String userName);
 }
package com.bobo.dao.impl;
 
 import com.bobo.dao.IUserDao;
 import com.bobo.pojo.Users;
 import jdk.nashorn.internal.ir.annotations.Reference;
 import org.hibernate.Criteria;
 import org.hibernate.Query;
 import org.hibernate.Session;
 import org.hibernate.criterion.Restrictions;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.orm.hibernate5.HibernateTemplate;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
 
 
 @Repository
 public class UserDaoImpl implements IUserDao {
 
     @Autowired
     private HibernateTemplate template;
 
     @Override
     public void insertUsers(Users users) {
         this.template.save(users);
     }
 
     @Override
     public void updateUsers(Users users) {
         this.template.update(users);
     }
 
     @Override
     public void deleteUsers(Users users) {
         this.template.delete(users);
     }
 
     @Override
     public Users selectUsersById(Integer userId) {
         return this.template.get(Users.class,userId);
     }
 
     @Override
     public List<Users> selectUsersByName(String userName) {
         // 我们要执行特殊的查询操作 我们需要获取对应的Session对象
         Session session = this.template.getSessionFactory().getCurrentSession();
         // 通过Session对象创建Query对象 HQL 语句
         Query query = session.createQuery(" from Users where userName = :abc");
         Query queryTemp = query.setString("abc", userName);
         return queryTemp.list();
     }
 
     @Override
     public List<Users> selectUsersByNameUseSQL(String userName) {
         // 我们要执行特殊的查询操作 我们需要获取对应的Session对象
         Session session = this.template.getSessionFactory().getCurrentSession();
         // 通过Session对象创建Query对象 SQL 语句
         Query query = session.createSQLQuery("select * from t_user where user_name = ?")
                 .addEntity(Users.class)
                 .setString(0, userName);
         return query.list();
     }
 
     @Override
     public List<Users> selectUsersByNameUseCriteria(String userName) {
         Session session = this.template.getSessionFactory().getCurrentSession();
         Criteria criteria = session.createCriteria(Users.class);
         criteria.add(Restrictions.eq("userName",userName));
         return criteria.list();
     }
 }

6. 单元测试

package com.bobo.test;
 
 import com.bobo.dao.IUserDao;
 import com.bobo.pojo.Users;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.annotation.Rollback;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:applicationContext.xml")
 public class Test1 {
 
     @Autowired
     private IUserDao dao;
 
     @Test
     @Transactional
     @Rollback(false)
     public void testInsertUser(){
         Users user = new Users();
         user.setUserName("Tom");
         user.setRealName("张三丰");
         dao.insertUsers(user);
     }
 
 
     @Test
     @Transactional
     public void testQuery1(){
         Users users = this.dao.selectUsersById(22);
         System.out.println(users);
     }
 
     @Test
     @Transactional
     public void testQuery2(){
         List<Users> list = this.dao.selectUsersByNameUseSQL("Tom");
         for (Users users : list) {
             System.out.println(users);
         }
     }
 
 
 }

二、Spring整合HibernateJPA

现如今的ORM框架还是比较多的比如Hibernate，TopLink以及OpenJPA等等，为了简化ORM框架的使用，JPA随之产生。

JPA是Java Persistence API的简称，中文名Java持久层API，由 Sun 公司提供了一对对于持久层操作的标准(接口+文档),说白了就是在各种ORM框架之上封装了一套API实现统一操作。同时又依赖各种ORM框架去实现。hibernate3.2版本后提供了对JPA的实现。

1. 创建项目

创建一个普通的Maven项目即可

2. 添加相关的依赖

<dependencies>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-orm</artifactId>
             <version>5.1.6.RELEASE</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
             <version>5.1.6.RELEASE</version>
         </dependency>
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjweaver</artifactId>
             <version>1.9.2</version>
         </dependency>
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid</artifactId>
             <version>1.1.8</version>
         </dependency>
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>8.0.11</version>
         </dependency>
         <dependency>
             <groupId>org.hibernate</groupId>
             <artifactId>hibernate-entitymanager</artifactId>
             <version>5.0.7.Final</version>
         </dependency>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.12</version>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>
             <version>5.1.6.RELEASE</version>
         </dependency>
     </dependencies>

3. 添加相关的配置文件

jdbc.driver=com.mysql.cj.jdbc.Driver
 jdbc.url=jdbc:mysql://localhost:3306/logistics?characterEncoding=utf-8&serverTimezone=UTC
 jdbc.username=root
 jdbc.password=123456

Spring的配置文件

<?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:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx"
        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/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
 ">
     <!-- 引入db.properties文件 -->
     <context:property-placeholder location="classpath:db.properties" />
     <!-- 创建druid 的数据源 -->
     <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
         <property name="url" value="${jdbc.url}" />
         <property name="driverClassName" value="${jdbc.driver}" />
         <property name="username" value="${jdbc.username}" />
         <property name="password"  value="${jdbc.password}" />
     </bean>
 
     <!-- 配置Hibernate的SessionFactory对象 -->
     <bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="sessionFactory">
         <!-- 关联数据源 -->
         <property name="dataSource" ref="dataSource"/>
         <!-- 配置Hibernate的属性信息 -->
         <property name="jpaVendorAdapter">
             <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                 <property name="database" value="MYSQL"/>
                 <property name="generateDdl" value="true"/>
                 <property name="showSql" value="true"/>
             </bean>
             <!--<props>
                 <prop key="show_sql">true</prop>
                 <prop key="hibernate.hbm2ddl.auto">update</prop>
             </props>-->
         </property>
         <!-- 扫描路径 -->
         <property name="packagesToScan">
             <list>
                 <value>com.bobo.pojo</value>
             </list>
         </property>
     </bean>
 
 
     <!--  配置事务管理-->
     <bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager">
         <property name="entityManagerFactory" ref="sessionFactory" />
     </bean>
 
     <!-- 配置开启事务注解 -->
     <tx:annotation-driven transaction-manager="transactionManager" />
 
     <!-- 配置扫描路径 -->
     <context:component-scan base-package="com.bobo" />
 </beans>

4. 创建POJO

package com.bobo.pojo;
 
 
 import javax.persistence.*;
 import java.io.Serializable;
 
 @Entity
 @Table(name="t_user")
 public class Users implements Serializable {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     @Column(name="user_id")
     private Integer userId;
 
     @Column(name="user_name")
     private String userName;
 
     @Column(name="real_name")
     private String realName;
 
     public Integer getUserId() {
         return userId;
     }
 
     public void setUserId(Integer userId) {
         this.userId = userId;
     }
 
     public String getUserName() {
         return userName;
     }
 
     public void setUserName(String userName) {
         this.userName = userName;
     }
 
     public String getRealName() {
         return realName;
     }
 
     public void setRealName(String realName) {
         this.realName = realName;
     }
 
     @Override
     public String toString() {
         return "Users{" +
                 "userId=" + userId +
                 ", userName='" + userName + '\'' +
                 ", realName='" + realName + '\'' +
                 '}';
     }
 }

5. 创建持久层

package com.bobo.dao;
 
 import com.bobo.pojo.Users;
 
 import java.util.List;
 
 public interface IUserDao {
 
     void insertUsers(Users users);
 
     void updateUsers(Users users);
 
     void deleteUsers(Users users);
 
     Users selectUsersById(Integer userId);
 
     List<Users> selectUsersByName(String userName);
 
     List<Users> selectUsersByNameUseSQL(String userName);
 
     List<Users> selectUsersByNameUseCriteria(String userName);
 }

实现类

package com.bobo.dao.impl;
 
 import com.bobo.dao.IUserDao;
 import com.bobo.pojo.Users;
 import org.hibernate.Criteria;
 import org.hibernate.Query;
 import org.hibernate.Session;
 import org.hibernate.criterion.Restrictions;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.orm.hibernate5.HibernateTemplate;
 import org.springframework.stereotype.Repository;
 
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import javax.persistence.TypedQuery;
 import javax.persistence.criteria.CriteriaBuilder;
 import javax.persistence.criteria.CriteriaQuery;
 import javax.persistence.criteria.Predicate;
 import javax.persistence.criteria.Root;
 import java.util.List;
 
 
 @Repository
 public class UserDaoImpl implements IUserDao {
 
 
     @PersistenceContext(name = "entityManagerFactory")
     private EntityManager manager;
 
     @Override
     public void insertUsers(Users users) {
         manager.persist(users);
     }
 
     @Override
     public void updateUsers(Users users) {
         manager.merge(users);
     }
 
     @Override
     public void deleteUsers(Users users) {
         users = this.selectUsersById(users.getUserId());
         manager.remove(users);
     }
 
     @Override
     public Users selectUsersById(Integer userId) {
         return manager.find(Users.class,userId);
     }
 
     @Override
     public List<Users> selectUsersByName(String userName) {
         return manager.createQuery(" from Users where userName = :abc")
                 .setParameter("abc",userName)
                 .getResultList();
     }
 
     @Override
     public List<Users> selectUsersByNameUseSQL(String userName) {
         return manager.createNativeQuery("select * from t_user where user_name = ?",Users.class)
                 .setParameter(1,userName)
                 .getResultList();
     }
 
     @Override
     public List<Users> selectUsersByNameUseCriteria(String userName) {
 
         CriteriaBuilder builder = manager.getCriteriaBuilder();
         CriteriaQuery<Users> query = builder.createQuery(Users.class);
         Root<Users> root = query.from(Users.class);
         Predicate cate = builder.equal(root.get("userName"), userName);
         query.where(cate);
         TypedQuery<Users> typedQuery = manager.createQuery(query);
         return typedQuery.getResultList();
     }
 }

6. 单元测试

package com.bobo.test;

import com.bobo.dao.IUserDao;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test1 {

    @Autowired
    private IUserDao dao;

    @Test
    @Transactional
    @Rollback(false)
    public void testInsertUser(){
        Users user = new Users();
        user.setUserName("Mic");
        user.setRealName("李逵");
        dao.insertUsers(user);
    }


    @Test
    @Transactional
    public void testQuery1(){
        Users users = this.dao.selectUsersById(22);
        System.out.println(users);
    }

    @Test
    @Transactional
    public void testQuery2(){
        List<Users> list = this.dao.selectUsersByNameUseSQL("Tom");
        for (Users users : list) {
            System.out.println(users);
        }
    }


}

三、SpringDataJPA介绍

1. 入门案例

1.1 创建项目

创建一个普通的Maven项目

1.2 添加相关的依赖

<dependencies>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-orm</artifactId>
             <version>5.1.6.RELEASE</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
             <version>5.1.6.RELEASE</version>
         </dependency>
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjweaver</artifactId>
             <version>1.9.2</version>
         </dependency>
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid</artifactId>
             <version>1.1.8</version>
         </dependency>
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>8.0.11</version>
         </dependency>
         <dependency>
             <groupId>org.hibernate</groupId>
             <artifactId>hibernate-entitymanager</artifactId>
             <version>5.0.7.Final</version>
         </dependency>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.12</version>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>
             <version>5.1.6.RELEASE</version>
         </dependency>
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-jpa</artifactId>
             <version>1.9.0.RELEASE</version>
         </dependency>
     </dependencies>

1.3 添加配置文件

jdbc.driver=com.mysql.cj.jdbc.Driver
 jdbc.url=jdbc:mysql://localhost:3306/logistics?characterEncoding=utf-8&serverTimezone=UTC
 jdbc.username=root
 jdbc.password=123456

Spring的配置文件

<?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:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:jpa="http://www.springframework.org/schema/data/jpa"
        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/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/data/jpa
        http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
 ">
     <!-- 引入db.properties文件 -->
     <context:property-placeholder location="classpath:db.properties" />
     <!-- 创建druid 的数据源 -->
     <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
         <property name="url" value="${jdbc.url}" />
         <property name="driverClassName" value="${jdbc.driver}" />
         <property name="username" value="${jdbc.username}" />
         <property name="password"  value="${jdbc.password}" />
     </bean>
 
     <!-- 配置Hibernate的SessionFactory对象 id必须得是 ： entityManagerFactory -->
     <bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
           id="entityManagerFactory">
         <!-- 关联数据源 -->
         <property name="dataSource" ref="dataSource"/>
         <!-- 配置Hibernate的属性信息 -->
         <property name="jpaVendorAdapter">
             <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                 <property name="database" value="MYSQL"/>
                 <property name="generateDdl" value="true"/>
                 <property name="showSql" value="true"/>
             </bean>
             <!--<props>
                 <prop key="show_sql">true</prop>
                 <prop key="hibernate.hbm2ddl.auto">update</prop>
             </props>-->
         </property>
         <!-- 扫描路径 -->
         <property name="packagesToScan">
             <list>
                 <value>com.bobo.pojo</value>
             </list>
         </property>
     </bean>
 
 
     <!--  配置事务管理-->
     <bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager">
         <property name="entityManagerFactory" ref="entityManagerFactory" />
     </bean>
 
     <!-- 配置开启事务注解 -->
     <tx:annotation-driven transaction-manager="transactionManager" />
 
     <!-- 配置扫描路径 -->
     <context:component-scan base-package="com.bobo" />
 
     <!--  Spring Data Jpa 配置-->
     <!-- 配置Dao的扫描 -->
     <jpa:repositories base-package="com.bobo.dao" />
 </beans>

1.4 创建POJO对象

package com.bobo.pojo;
 
 
 import javax.persistence.*;
 import java.io.Serializable;
 
 @Entity
 @Table(name="t_user")
 public class Users implements Serializable {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     @Column(name="user_id")
     private Integer userId;
 
     @Column(name="user_name")
     private String userName;
 
     @Column(name="real_name")
     private String realName;
 
     public Integer getUserId() {
         return userId;
     }
 
     public void setUserId(Integer userId) {
         this.userId = userId;
     }
 
     public String getUserName() {
         return userName;
     }
 
     public void setUserName(String userName) {
         this.userName = userName;
     }
 
     public String getRealName() {
         return realName;
     }
 
     public void setRealName(String realName) {
         this.realName = realName;
     }
 
     @Override
     public String toString() {
         return "Users{" +
                 "userId=" + userId +
                 ", userName='" + userName + '\'' +
                 ", realName='" + realName + '\'' +
                 '}';
     }
 }

1.5 创建持久层

import com.bobo.pojo.Users;
 import org.springframework.data.jpa.repository.JpaRepository;
 
 public interface UserDao extends JpaRepository<Users,Integer> {
 
 }

1.6 单元测试

package com.bobo.test;
 
 import com.bobo.dao.UserDao;
 import com.bobo.pojo.Users;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.annotation.Rollback;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.transaction.annotation.Transactional;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:applicationContext.xml")
 public class Test1 {
 
     @Autowired
     private UserDao dao;
 
 
     @Test
     @Transactional
     @Rollback(false)
     public void test1(){
         Users user = new Users();
         user.setUserName("admin-jpa");
         user.setRealName("测试");
         dao.save(user);
     }
 }

2. Repository接口

public interface Repository<T, ID extends Serializable> {
}

Repository 接口是 Spring Data JPA 中为我我们提供的所有接口中的顶层接口,而且是个标志接口，Repository 提供了两种查询方式的支持1）基于方法名称命名规则查询2）基于@Query 注解查询

2.1 基于方法名称命名规则查询

package com.bobo.dao;

import com.bobo.pojo.Users;
import org.springframework.data.repository.Repository;

import javax.persistence.criteria.CriteriaBuilder;
import java.util.List;

/**
 * Repository接口的使用
 */
public interface UserDaoRepository extends Repository<Users, Integer> {

    List<Users> findByUserNameIs(String string);

    List<Users> findByUserNameLike(String username);

    List<Users> findByUserNameAndRealNameIs(String name,String realName);
}

测试代码

package com.bobo.test;
 
 import com.bobo.dao.UserDaoRepository;
 import com.bobo.pojo.Users;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.annotation.Rollback;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:applicationContext.xml")
 public class Test2 {
 
     @Autowired
     private UserDaoRepository dao;
 
     @Test
     @Transactional
     @Rollback(false)
     public void query1(){
         List<Users> list = this.dao.findByUserNameIs("Tom");
         for (Users users : list) {
             System.out.println(users);
         }
     }
 
     @Test
     @Transactional
     @Rollback(false)
     public void query2(){
         List<Users> list = this.dao.findByUserNameLike("Tom");
         for (Users users : list) {
             System.out.println(users);
         }
     }
 
     @Test
     @Transactional
     @Rollback(false)
     public void query3(){
         List<Users> list = this.dao.findByUserNameAndRealNameIs("Tom","张三丰");
         for (Users users : list) {
             System.out.println(users);
         }
     }
 }

2.2 基于@Query 注解查询

通过上面的命令的方式使用的情况，如果查询条件比较复杂的情况下，那么方法的名称会很长，不是很方便而且容易出错，这时我们可以通过@Query注解来实现

2.2.1 JPQL语句

JPQL：是通过Hibernate的HQL语句演变而来的，他和HQL语句很相似

/**
 * Repository接口的使用
 * @Query
 *    JPQL语句
 *    SQL语句
 *    更新操作
 */
public interface UserDaoRepository2 extends Repository<Users, Integer> {

    @Query(value = " from Users where userName =?")
    List<Users> queryUsersByNameUseJPQL(String name);

    @Query(value = " from Users where userName like ?")
    List<Users> queryUserLikeNameUseJPQL(String name);

    @Query(value = " from Users where userName= ? and realName = ?")
    List<Users> queryUserByNameAndRealName(String userName,String realName);

}

单元测试

package com.bobo.test;
 
 import com.bobo.dao.UserDaoRepository;
 import com.bobo.dao.UserDaoRepository2;
 import com.bobo.pojo.Users;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.annotation.Rollback;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:applicationContext.xml")
 public class Test3 {
 
     @Autowired
     private UserDaoRepository2 dao;
 
     @Test
     @Transactional
     @Rollback(false)
     public void query1(){
         List<Users> list = this.dao.queryUsersByNameUseJPQL("Tom");
         for (Users users : list) {
             System.out.println(users);
         }
     }
 
     @Test
     @Transactional
     @Rollback(false)
     public void query2(){
         List<Users> list = this.dao.queryUserLikeNameUseJPQL("Tom");
         for (Users users : list) {
             System.out.println(users);
         }
     }
 
     @Test
     @Transactional
     @Rollback(false)
     public void query3(){
         List<Users> list = this.dao.queryUserByNameAndRealName("Tom","张三丰");
         for (Users users : list) {
             System.out.println(users);
         }
     }
 }
2.2.2 SQL语句

声明接口

package com.bobo.dao;
 
 import com.bobo.pojo.Users;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.Repository;
 
 import java.util.List;
 
 /**
  * Repository接口的使用
  * @Query
  *    JPQL语句
  *    SQL语句
  *    更新操作
  */
 public interface UserDaoRepository3 extends Repository<Users, Integer> {
 
     // 在使用@Query注解 查询SQL语句的时候 nativeQuery默认是false，我们需要设置为true
     @Query(value = "select * from t_user where user_name=?",nativeQuery = true)
     List<Users> queryUsersByNameUseSQL(String name);
 
     @Query(value = "select * from t_user where user_name like ?" ,nativeQuery = true)
     List<Users> queryUserLikeNameUseSQL(String name);
 
     @Query(value = "select * from t_user where user_name = ? and real_name = ?" , nativeQuery = true)
     List<Users> queryUserByNameAndRealName(String userName,String realName);
 
 }

单元测试

package com.bobo.test;
 
 import com.bobo.dao.UserDaoRepository2;
 import com.bobo.dao.UserDaoRepository3;
 import com.bobo.pojo.Users;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.annotation.Rollback;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:applicationContext.xml")
 public class Test4 {
 
     @Autowired
     private UserDaoRepository3 dao;
 
     @Test
     @Transactional
     @Rollback(false)
     public void query1(){
         List<Users> list = this.dao.queryUsersByNameUseSQL("Tom");
         for (Users users : list) {
             System.out.println(users);
         }
     }
 
     @Test
     @Transactional
     @Rollback(false)
     public void query2(){
         List<Users> list = this.dao.queryUserLikeNameUseSQL("Tom");
         for (Users users : list) {
             System.out.println(users);
         }
     }
 
     @Test
     @Transactional
     @Rollback(false)
     public void query3(){
         List<Users> list = this.dao.queryUserByNameAndRealName("Tom","张三丰");
         for (Users users : list) {
             System.out.println(users);
         }
     }
 }

2.2.3 完成更新数据

@Query注解可以完成数据更新操作，但是不能实现数据的添加和删除操作

@Query(value = "update Users set userName = ? where userId=?")
    @Modifying// 被@Modifying修饰的方法是一个更新操作
    void updateUserNameById(String userName,Integer userId);

测试

@Test
    @Transactional
    @Rollback(false)
    public void updateTest(){
        this.dao.updateUserNameById("Tommm",25);
    }

3. CrudRepository接口

CrudRepository接口继承自Repository接口，所以Repository接口具有的功能CrudRepository接口都具有，而且又扩展了CRUD相关的功能

@NoRepositoryBean
 public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {
     <S extends T> S save(S var1);
 
     <S extends T> Iterable<S> save(Iterable<S> var1);
 
     T findOne(ID var1);
 
     boolean exists(ID var1);
 
     Iterable<T> findAll();
 
     Iterable<T> findAll(Iterable<ID> var1);
 
     long count();
 
     void delete(ID var1);
 
     void delete(T var1);
 
     void delete(Iterable<? extends T> var1);
 
     void deleteAll();
 }

应用声明接口

/**
  * CrudRepository接口的使用
  */
 public interface UserDaoCrudRepository extends CrudRepository<Users,Integer> {
 }

单元测试

package com.bobo.test;
 
 import com.bobo.dao.UserDaoCrudRepository;
 import com.bobo.dao.UserDaoRepository3;
 import com.bobo.pojo.Users;
 import org.junit.Test;
 import org.junit.experimental.theories.suppliers.TestedOn;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.jdbc.support.CustomSQLErrorCodesTranslation;
 import org.springframework.test.annotation.Rollback;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:applicationContext.xml")
 public class Test5 {
 
     @Autowired
     private UserDaoCrudRepository dao;
 
     /**
      * 添加数据
      */
     @Test
     public void test1(){
         Users user = new Users();
         user.setRealName("成龙");
         user.setUserName("chengnong");
         dao.save(user);
     }
 
     /**
      * 批量添加数据
      */
     @Test
     public void test2(){
         List<Users> list = new ArrayList<>();
         for (int i = 0; i < 10; i++) {
             Users user = new Users();
             user.setRealName("成龙"+i);
             user.setUserName("chengnong"+i);
             list.add(user);
         }
         dao.save(list);
     }
 
     /**
      * 查询单条数据
      */
     @Test
     public void test3(){
         Users user = dao.findOne(25);
         System.out.println(user);
     }
 
     /**
      * 查询所有的数据
      */
     @Test
     public void test4(){
         Iterable<Users> list = dao.findAll();
         Iterator<Users> iterator = list.iterator();
         while(iterator.hasNext()){
             Users user = iterator.next();
             System.out.println(user);
         }
     }
 
     /**
      * 删除数据
      */
     @Test
     public void delete1(){
         dao.delete(32);
     }
 
     /**
      * 更新数据
      */
     @Test
     public void update1(){
         // 根据save方法来实现 如果Users对象的userId属性不为空则update
         Users user = dao.findOne(34);
         user.setUserName("hahahaha");
         dao.save(user);
     }
 
     /**
      * 更新数据 方式二
      */
     @Test
     @Transactional
     @Rollback(false)
     public void update2(){
         Users user = dao.findOne(34);
         user.setUserName("aaaa"); // User 是一个持久化的状态
     }
 }

4.PagingAndSortingRepository接口

PagingAndSortingRepository继承自CrudRepository接口，那么显然PagingAndSortingRepository就具备了CrudRepository接口的相关的功能，同时也扩展了分页和排序的功能

@NoRepositoryBean
 public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {
     // 排序的支持
     Iterable<T> findAll(Sort var1);
     // 分页的支持
     Page<T> findAll(Pageable var1);
 }

创建接口文件

package com.bobo.dao;
 
 import com.bobo.pojo.Users;
 import org.springframework.data.repository.PagingAndSortingRepository;
 
 /**
  * PagingAndSortingRepository接口的使用
  *    新增的功能是
  *       分页
  *       排序
  *    注意本接口不支持条件查询
  */
 public interface UserDaoPageAndSortRepository extends PagingAndSortingRepository<Users,Integer> {
 }

分页测试

package com.bobo.test;
 
 import com.bobo.dao.UserDaoCrudRepository;
 import com.bobo.dao.UserDaoPageAndSortRepository;
 import com.bobo.pojo.Users;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.test.annotation.Rollback;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:applicationContext.xml")
 public class Test6 {
 
     @Autowired
     private UserDaoPageAndSortRepository dao;
 
     /**
      * 分页查询
      */
     @Test
     public void test1(){
         int page = 1; // page:当前分页的索引  从0开始
         int size = 5; // size:每页显示的条数
         PageRequest pageable = new PageRequest(page,size);
         Page<Users> pages = dao.findAll(pageable);
         System.out.println("总的条数:" + pages.getTotalElements());
         System.out.println("总的页数:" + pages.getTotalPages());
         List<Users> list = pages.getContent();
         for (Users user : list) {
             System.out.println(user);
         }
     }
 }

排序功能

/**
      * 排序
      */
     @Test
     public void test2(){
 
         // Sort.Direction.DESC 降序 ASC 升序
         Sort sort = new Sort(Sort.Direction.DESC,"userId");
         List<Users> list = (List<Users>) this.dao.findAll(sort);
         for (Users users : list) {
             System.out.println(users);
         }
     }

多条件排序

/**
     * 多条件排序
     */
    @Test
    public void test3(){
        Sort.Order order1 = new Sort.Order(Sort.Direction.DESC,"realName");
        Sort.Order order2 = new Sort.Order(Sort.Direction.ASC,"userId");
        Sort sort = new Sort(order1,order2);
        List<Users> list = (List<Users>) this.dao.findAll(sort);
        for (Users users : list) {
            System.out.println(users);
        }

    }

5. JpaRepository接口

JpaRepository接口是我们开发时使用最多接口，其特点是可以帮助我们将其他接口的方法的返回值做适配处理，可以使我们在开发的时候更方便的使用这些方法

@NoRepositoryBean
public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID> {
    List<T> findAll();

    List<T> findAll(Sort var1);

    List<T> findAll(Iterable<ID> var1);

    <S extends T> List<S> save(Iterable<S> var1);

    void flush();

    <S extends T> S saveAndFlush(S var1);

    void deleteInBatch(Iterable<T> var1);

    void deleteAllInBatch();

    T getOne(ID var1);
}

6. JpaSpecificationExecutor

提供的有多条件查询，并支持分页和排序功能，此接口不能单独使用，需要和其他的接口一块使用

/**
 * JpaSpecificationExecutor的使用
 *    JpaSpecificationExecutor 是不能够单独使用的。需要配置JPA中的其他的接口一块来使用
 */
public interface UserDaoSpecfication extends JpaRepository<Users,Integer>, JpaSpecificationExecutor {
}

6.1 单条件查询

package com.bobo.test;
 
 import com.bobo.dao.UserDaoSpecfication;
 import com.bobo.pojo.Users;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.domain.Specification;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
 import javax.persistence.criteria.CriteriaBuilder;
 import javax.persistence.criteria.CriteriaQuery;
 import javax.persistence.criteria.Predicate;
 import javax.persistence.criteria.Root;
 import java.util.List;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:applicationContext.xml")
 public class Test7 {
 
     @Autowired
     private UserDaoSpecfication dao;
 
     @Test
     public void test1(){
         Specification<Users> speci = new Specification<Users>() {
             /**
              * 定义查询条件
              * @param root 根对象  封装查询条件的对象
              * @param criteriaQuery 基本的查询
              * @param criteriaBuilder 创建查询条件
              * @return
              */
             @Override
             public Predicate toPredicate(Root<Users> root
                     , CriteriaQuery<?> criteriaQuery
                     , CriteriaBuilder criteriaBuilder) {
                 Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");
                 return pre;
             }
         };
 
         List<Users> list = dao.findAll(speci);
         for (Users users : list) {
             System.out.println(users);
         }
     }
 }

6.2 多条件

/**
      * 多条件查询
      */
     @Test
     public void test2(){
         Specification<Users> spec = new Specification<Users>() {
             /**
              * 指定查询的条件
              * @param root
              * @param criteriaQuery
              * @param criteriaBuilder
              * @return
              */
             @Override
             public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                 List<Predicate> list = new ArrayList<>();
                 list.add(criteriaBuilder.equal(root.get("userName"),"Tommm"));
                 list.add(criteriaBuilder.equal(root.get("realName"),"张三丰"));
                 Predicate[] arr = new Predicate[list.size()];
                 return criteriaBuilder.and(list.toArray(arr));
             }
         };
         List<Users> list = dao.findAll(spec);
         for (Users users : list) {
             System.out.println(users);
         }
     }

6.3 分页

/**
      * 单条件+分页
      */
     @Test
     public void test3(){
         Specification<Users> speci = new Specification<Users>() {
             /**
              * 定义查询条件
              * @param root 根对象  封装查询条件的对象
              * @param criteriaQuery 基本的查询
              * @param criteriaBuilder 创建查询条件
              * @return
              */
             @Override
             public Predicate toPredicate(Root<Users> root
                     , CriteriaQuery<?> criteriaQuery
                     , CriteriaBuilder criteriaBuilder) {
                 Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");
                 return pre;
             }
         };
 
         Pageable pagealbe = (Pageable) new PageRequest(0,3);
         Page page = dao.findAll(speci, pagealbe);
         System.out.println(page.getTotalElements());
         System.out.println(page.getTotalPages());
         List content = page.getContent();
         System.out.println(content);
 
     }

6.4 排序

/**
      * 单条件+排序
      */
     @Test
     public void test4(){
         Specification<Users> speci = new Specification<Users>() {
             /**
              * 定义查询条件
              * @param root 根对象  封装查询条件的对象
              * @param criteriaQuery 基本的查询
              * @param criteriaBuilder 创建查询条件
              * @return
              */
             @Override
             public Predicate toPredicate(Root<Users> root
                     , CriteriaQuery<?> criteriaQuery
                     , CriteriaBuilder criteriaBuilder) {
                 Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");
                 return pre;
             }
         };
 
         Sort sort = new Sort(Sort.Direction.DESC,"userId");
         List<Users> list = dao.findAll(speci, sort);
         System.out.println(list);
 
     }

6.5 分页和排序

/**
      * 单条件+分页 + 排序
      */
     @Test
     public void test5(){
         Specification<Users> speci = new Specification<Users>() {
             /**
              * 定义查询条件
              * @param root 根对象  封装查询条件的对象
              * @param criteriaQuery 基本的查询
              * @param criteriaBuilder 创建查询条件
              * @return
              */
             @Override
             public Predicate toPredicate(Root<Users> root
                     , CriteriaQuery<?> criteriaQuery
                     , CriteriaBuilder criteriaBuilder) {
                 Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");
                 return pre;
             }
         };
         Sort sort = new Sort(Sort.Direction.DESC,"userId");
         // 封装分页对象的时候我们可以直接指定 排序的规则
         Pageable pagealbe = (Pageable) new PageRequest(0,3,sort);
         Page page = dao.findAll(speci, pagealbe);
         System.out.println(page.getTotalElements());
         System.out.println(page.getTotalPages());
         List content = page.getContent();
         System.out.println(content);
 
     }

四、SpringBoot整合SpringDataJPA

1. 添加依赖

2. 添加配置文件

# jdbc 的相关信息
 spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
 spring.datasource.url=jdbc:mysql://localhost:3306/logistics?characterEncoding=utf-8&serverTimezone=UTC
 spring.datasource.username=root
 spring.datasource.password=123456
 
 # 配置连接池信息
 spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
 
 # 配置jpa的相关参数
 spring.jpa.hibernate.ddl-auto=update
 spring.jpa.show-sql=true

3. 创建POJO

package com.bobo.pojo;

import javax.persistence.*;
import java.io.Serializable;

@Table(name = "t_user")
@Entity
public class Users implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="user_id")
    private Integer userId;

    @Column(name="user_name")
    private String usreName;

    @Column(name="real_name")
    private String realName;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUsreName() {
        return usreName;
    }

    public void setUsreName(String usreName) {
        this.usreName = usreName;
    }

    public String getRealName() {
        return realName;
    }

    public void setRealName(String realName) {
        this.realName = realName;
    }
}

4. 创建接口

package com.bobo.dao;

import com.bobo.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UsersRepository extends JpaRepository<Users,Integer> {
}

5. 测试

package com.bobo;

import com.bobo.dao.UsersRepository;
import com.bobo.pojo.Users;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringdatajpaSpringbootApplicationTests {

    @Autowired
    private UsersRepository dao;

    @Test
    void contextLoads() {
        Users users = new Users();
        users.setUsreName("test1");
        users.setRealName("测试数据");
        dao.save(users);
    }

}

【原创】纯干货，Spring-data-jpa详解，全方位介绍。
weixin_33955681的博客
02-01 8309
本篇进行Spring-data-jpa的介绍，几乎涵盖该框架的所有方面，在日常的开发当中，基本上能满足所有需求。这里不讲解JPA和Spring-data-jpa单独使用，所有的内容都是在和Spring整合的环境中实现。如果需要了解该框架的入门，百度一下，很多入门的介绍。在这篇文章的接下来一篇，会有一个系列来讲解mybatis，这个系列从mybatis的入门开始，到基本使用，和spring整合，和第...
Spring Data JPA API（Spring Data JPA 开发文档）.CHM
08-31
Spring Data JPA API。 Spring Data JPA 开发文档。 官网 Spring Data JPA API。
SpringDataJpa
07-04
SpringDataJpa+SpringMVC集成：在网上找了好久都没有找到个完整的例子，闲着没事自己做个例子放上去吧！例子比较糙但是作为入门足够了，数据库是用的是mysql 自带的test数据库部署之前请修改数据库连接，用户名和密码
spring data jpa（一）
weixin_30399871的博客
01-09 399
第1章 Spring Data JPA的快速入门 1.1 需求说明 Spring Data JPA完成客户的基本CRUD操作 1.2 搭建Spring Data JPA的开发环境 1.2.1 引入Spring Data JPA的坐标 使用Spring Data JPA，需要整合Spring与Spring Data JPA，并且需要提供JPA的服务提供者...
spring data jpa
AdamCafe的博客
04-01 255
1.新建spring的配置文件： 新建单元测试 测试数据源： 配置jpa 测试jpa配置成功，创建对应的测试类 然后配置spring data 上下两种等效
SpringDataJPA
GuanHao的博客
06-28 722
注解的方式 更新删除等事务操作需要加上Transactional 方式一 @Transactional @Modifying(clearAutomatically = true) @Query(value = "UPDATE User u SET u.status =?1 WHERE u.id = ?2") Integer updateStatusById(String status, Lo...
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
**Spring Data JPA** 是一个基于 **Java** 的开源框架，它是 **Spring Framework** 的一个模块，主要用于简化 **Java Persistence API (JPA)** 的使用。JPA 是 Java 平台上的一个标准，用于管理和持久化应用程序的...
Spring Data JPA的优点和难点.pdf
12-05
Spring Data JPA是Spring生态中的一个强大ORM框架，它极大地提高了Java开发者在处理数据库操作时的效率。Spring Data JPA的主要优点在于其高度的开发效率、成熟的语法结构以及与Spring框架的紧密集成。 1. **开发...
spring注解+spring data jpa文档+JPA文档.rar
04-05
Spring框架的核心特性包括依赖注入（DI）和面向切面编程（AOP），并且它还提供了对数据库操作的支持，这主要通过Spring Data JPA和Java Persistence API（JPA）实现。 Spring注解是Spring框架中的一大特色，它极大...
Spring Data JPA 笔记
04-16
Spring Data JPA 是一个强大的框架，它简化了Java应用程序与数据库之间的交互，是Spring生态中的重要组成部分。通过使用Spring Data JPA，开发者可以避免编写大量的JPA（Java Persistence API）和SQL代码，专注于...
SpringDataJPA（二）
第五个世界的博客
10-03 218
1.Spring Data JPA 介绍 1.1 Spring Data JPA概述 Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用 Spring Data JPA 可以极大提高开发效率！ Sprin...
Springdatajpa
y1770464784的博客
09-27 543
springdatajpa的增删改查 （1）定义一个接口,继承 JpaRepository （2）配置applicationComtext.xml <!-- springdatajpa配置 引入事务和实体管理工厂--> <jpa:repositories base-package="cn.itsource.aisell.repository" ...
Spring-data-JPA
qq_45420103的博客
10-28 319
Spring-data-JPA 一、是什么 Spring-data-jpa是一个spring简化jdbc对数据库操作的一个框架，可以做到几乎不用书写sql语句，即可完成对数据库表的增删改查操作。 二、怎么用 1、导入依赖 2、yml文件配置 这里暂时不清楚，但springboot会自动装配创建对象，需要指定数据源等配置 3、实体类 一般的话，是实体类上加@Entity,@Table 使用的是java提供的注解import javax.persistence.*; 当表中的字段与实体类对应不上时使用@Tran
Spring-data-jpa
行云的博客
08-21 681
这里有个无关的小问题，由于下面的例子中使用到的素材里有个表名为 order，这与数据库关键字冲突，因此为了『告知』Hibernate/JPA 在『帮』我们执行 SQL 语句时要为它加返单引号，因此在 Entity 的。并且，@JoinColumn 的 name 指的就是外键列的列名。Page 接口扩展了 Slice 接口，添加了获取总页数和元素总数量的方法，因此，返回 Page 接口时，必须执行两条 SQL，一条复杂查询分页数据，另一条负责统计数据数量。这里的关键还是也延迟加载有关。
Spring Data JPA
专治八阿哥的孟老师
03-25 1871
/自定义查询 @Query("select count(distinct E.name) from Employee E") Integer countDistinctName();按位置绑定参数 //按位置传参数。注意参数的?占位符后面要写数字，代表的是方法的()中参数的位置。按名称绑定参数： //按名称传参数，参数用:参数名占位。@param(“查询语句中的参数名”)。自定义增删改使用@Modifying//增删改用@Modifying，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

埃泽漫笔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值