02.SpringDataJPA基本使用——入门案例，各个接口用法，SpringBoot整合SpringDataJPA

最新推荐文章于 2024-06-07 14:44:56 发布
最新推荐文章于 2024-06-07 14:44:56 发布
阅读量356 收藏 2
点赞数
分类专栏： # SpringData
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44707283/article/details/117590022
版权

一、入门案例

1.创建项目

创建一个普通的Maven项目

2.添加相关的依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.13.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.0.9</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</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.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.0.RELEASE</version>
        </dependency>
    </dependencies>

3.添加配置文件

3.1 db.properties

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

3.2 applicationContext.xml

<?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 https://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.biao.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.biao"/>

    <!-- Spring Data Jpa的配置 -->
    <!-- 配置Dao的扫描 -->
    <jpa:repositories base-package="com.biao.dao"/>
</beans>

4.创建pojo对象

package com.biao.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.创建持久层

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

public interface UserDao extends JpaRepository<Users,Integer> {

}

6. 测试

package com.biao.test;

import com.biao.dao.UserDao;
import com.biao.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
    public void test1(){
        Users users = new Users();
        users.setUserName("meimei");
        users.setRealName("美美");
        dao.save(users);
    }

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

二、Repository接口

在这里插入图片描述
在这里插入图片描述

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

Repository接口是SpringData JPA中为我们提供的所有接口中的顶层接口，而且是个标志接口，Repository提供了两种查询方式的支持

  • 基于方法名称命名规则查询
  • 基于@Query注解查询

1.基于方法名称命名规则查询

在这里插入图片描述
在这里插入图片描述

1.1 接口

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

    List<Users> findByUserNameIs(String username);

    List<Users> findByUserNameLike(String username);

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

1.2 测试

@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 user :
                list) {
            System.out.println(user);
        }
    }
}

2.基于@Query注解查询

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

2.1 JPQL语句

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

2.1.1 接口类
/**
 * 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> queryUsersByNameAndRealNameJPQL(String username,String realName);

}
2.1.2 测试
@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 user :
                list) {
            System.out.println(user);
        }
    }

    @Test
    @Transactional
    @Rollback(false)
    public void query2(){
        List<Users> list = this.dao.queryUserLikeNameUseJPQL("Tom");
        for (Users user :
                list) {
            System.out.println(user);
        }
    }

    @Test
    @Transactional
    @Rollback(false)
    public void query3(){
        List<Users> list = this.dao.queryUsersByNameAndRealNameJPQL("Tom","张三丰");
        for (Users user :
                list) {
            System.out.println(user);
        }
    }
}

2.2 SQL语句

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

    @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> queryUsersByNameAndRealNameSQL(String username, String realName);

}
2.2.2 测试
@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 user :
                list) {
            System.out.println(user);
        }
    }

    @Test
    @Transactional
    @Rollback(false)
    public void query2(){
        List<Users> list = this.dao.queryUserLikeNameUseSQL("Tom");
        for (Users user :
                list) {
            System.out.println(user);
        }
    }

    @Test
    @Transactional
    @Rollback(false)
    public void query3(){
        List<Users> list = this.dao.queryUsersByNameAndRealNameSQL("Tom","张三丰");
        for (Users user :
                list) {
            System.out.println(user);
        }
    }
}

2.3 完成更新操作

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

2.3.1 接口
    @Query(value = "update Users set userName = ? where userId = ?")
    @Modifying //  被@Modifying修饰的方法是一个更新操作
    void updateUserNameById(String userName,Integer userId);
2.3.2 测试
    @Test
    @Transactional
    @Rollback(false)
    public void updateUser(){
        this.dao.updateUserNameById("Tommmer",26);

    }

三、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();
}

1.接口

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

}

2.测试

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

    @Autowired
    private UserDaoCrudRepository dao;

    /**
     * 添加数据
     */
    @Test
    public void test1(){
        Users users = new Users();
        users.setUserName("zz");
        users.setRealName("周周");
        dao.save(users);
    }

    /**
     * 批量添加数据
     */
    @Test
    public void test2(){
        List<Users> list = new ArrayList<Users>();
        for (int i = 0; i < 5; i++) {
            Users users = new Users();
            users.setUserName("mm"+i);
            users.setRealName("沫沫"+i);
            list.add(users);
        }
        dao.save(list);
    }

    /**
     * 查询单条数据
     */
    @Test
    public void test3(){
        Users users = dao.findOne(37);
        System.out.println(users);
    }

    /**
     * 查询所有数据
     */
    @Test
    public void test4(){
        Iterable<Users> list = dao.findAll();
        Iterator<Users> iterator = list.iterator();
        while (iterator.hasNext()){
            Users users = iterator.next();
            System.out.println(users);
        }
    }

    /**
     * 删除数据
     */
    @Test
    public void delete1(){
        dao.delete(33);
    }

    /**
     * 更新数据
     */
    @Test
    public void update1(){
        //根据save方法来实现 如果Users对象的userId属性不为空则update
        Users user = dao.findOne(34);
        user.setUserName("heieee");
        dao.save(user);
    }

    /**
     * 更新数据 方式二
     */
    @Test
    @Transactional
    @Rollback(false)
    public void update2(){
        Users users = dao.findOne(34);
        users.setUserName("bbbb");
    }
}

四、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);
}

1.接口

/**
 * PagingAndSortingRepository
 *  新增的功能是
 *      分页
 *      排序
 *      注意本接口不支持条件查询
 */
public interface UserDaoPageAndSortRepository extends PagingAndSortingRepository<Users,Integer> {


}

2.分页查询

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

    @Autowired
    private UserDaoPageAndSortRepository dao;

    /**
     * 分页查询
     */
    @Test
    public void test1(){
        int page = 2; // 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);
        }
    }

}

在这里插入图片描述

3.排序功能

    /**
     * 排序
     */
    @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);
        }
    }

在这里插入图片描述

4.多条件排序

    /**
     * 多条件排序
     */
    @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 user:
             list) {
            System.out.println(user);
        }
    }

在这里插入图片描述

五、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);
}

六、JpaSpecficationExecutor接口

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

1.接口

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

2.测试-单条件查询

@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
             */
            public Predicate toPredicate(Root<Users> root,
                                         CriteriaQuery<?> criteriaQuery,
                                         CriteriaBuilder criteriaBuilder) {
                Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommmer");
                return pre;
            }
        };
        List<Users> list = dao.findAll(speci);
        for (Users users :
                list) {
            System.out.println(users);
        }
    }
}

3.测试-多条件查询

    @Test
    public void test2(){
        Specification<Users> spec = new Specification<Users>() {
            /**
             * 指定条件查询
             * @param root
             * @param criteriaQuery
             * @param criteriaBuilder
             * @return
             */
            public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                List<Predicate> list = new ArrayList<Predicate>();
                list.add(criteriaBuilder.equal(root.get("userName"),"Tommmer"));
                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);
        }
    }

4.测试-分页查询

    @Test
    public void test3(){
        Specification<Users> speci = new Specification<Users>() {
            /**
             * 定义查询条件
             * @param root
             * @param criteriaQuery
             * @param criteriaBuilder
             * @return
             */
            public Predicate toPredicate(Root<Users> root,
                                         CriteriaQuery<?> criteriaQuery,
                                         CriteriaBuilder criteriaBuilder) {
                Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommmer");
                return pre;
            }
        };
        Pageable pageable =(Pageable) new PageRequest(0,3);
        Page page = dao.findAll(speci, pageable);
        System.out.println(page.getTotalElements());
        System.out.println(page.getTotalPages());
        List content = page.getContent();
        System.out.println(content);
    }

5.测试-排序

    /**
     * 单条件+排序
     */
    @Test
    public void test4(){
        Specification<Users> speci = new Specification<Users>() {
            /**
             * 定义查询条件
             * @param root
             * @param criteriaQuery
             * @param criteriaBuilder
             * @return
             */
            public Predicate toPredicate(Root<Users> root,
                                         CriteriaQuery<?> criteriaQuery,
                                         CriteriaBuilder criteriaBuilder) {
                Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommmer");
                return pre;
            }
        };

        Sort sort = new Sort(Sort.Direction.DESC,"userId");
        List<Users> list = dao.findAll(speci, sort);
        System.out.println(list);
    }

6.分页+排序

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

七、SpringBoot整合SpringDataJPA

1.创建SpringBoot项目

2.添加相关依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.13.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.0.9</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</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.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.0.RELEASE</version>
        </dependency>
    </dependencies>

在这里插入图片描述

3.添加相关的配置文件

# jdbc 的相关信息
spring.datasource.driver-class-name=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

4.创建pojo对象

package com.biao.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 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.创建接口

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

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

6.测试

@SpringBootTest
class SpringdatajpaSpringbootApplicationTests {

    @Autowired
    private UsersRepository dao;

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

}
一鸭一鸭唷
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringMVC以及SpringBoot整合SpringDataJPA简单入门
mashizhong521的博客
08-15 603
1.Spring Data JPA的概述 Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用 Spring Data JPA 可以极大提高开发效率！ Spring Data JPA 让我们解脱了DAO层的操作...
SpringDataJpa整理
csdn_lxfy的博客
08-27 398
首先什么是JPA？ JPA是一种ORM框架的规范 什么是SpringDataJpa？ 其是Spring封装了JPA的规范，提供了在Repository层（接口层）的实现 Hibernate与SpringDataJpa的关系？ Hibernate是SpringDataJpa的服务提供者，最终SpringDataJpa调用服务提供者完成对数据库持久化的操作，服务提供者可以替换成其他 废话不多说，开始基...
springBoot集成Hbase（spring-data-hadoop-boot版）
zwrlj527的专栏
06-06 4917
序 最近开始一步一步走进大数据，当然是作为程序员。今天就来说说Hbase的集成，首先今天先说下通过spring-data-hadoop-boot的集成吧。老规矩，废话不多说，加班快下班了，就抽20分钟分享。 一、maven引包 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-hadoop-boot&l
Spring集成Elasticsearch
xulong5000的专栏
07-15 1825
依赖组件 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-elasticsearch</artifactId> </dependency> 配置 spring: elasticsearch: rest: uris: - ip1:port
JPA的使用
最新发布
拾玖的博客
06-07 783
Jpa 是一套ORM 的规范hibernate 不就是一个 ORM 框架也提供了对于 JPA 的实现：java 持久化 API。
Spring练习-CRUD操作[1]-环境搭建
万锦
10-17 283
Spring练习-用户CURD操作[1]-环境搭建 文章目录Spring练习-用户CURD操作[1]-环境搭建Spring 环境搭建1. 创建工程（Project&Module）2.导入静态页面（见资料jsp页面）3.导入需要坐标（见资料中的pom.xml）4.创建包结构（controller、service、dao、domain、utils）6.创建POJO类（User.java和Role.java）7.创建配置文件 Spring 环境搭建 ① 创建工程（Project&Module） ②
Spring Data ElasticSearch 常用API调用
hikktn的博客
05-08 1109
1.创建一个maven工程 my-es pom <dependencies> <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <version>5.6.8</version>
Spring项目依赖管理
HaiMeng一起奋斗
06-25 141
Spring框架依赖管理，里面包括常用的mybatis依赖、spring依赖、springmvc依赖、以及tomcat插件依赖
idea下整合springboot+spring data jpa
02-02
Spring Boot提供了快速启动和配置的机制，而Spring Data JPA则是Spring框架的一部分，专注于数据库交互，使得开发者可以使用更加高级、抽象的方式来操作数据库，无需编写大量的JDBC代码。本文将详细介绍如何在...
仓库管理系统，SpringBoot+Spring Data JPA.zip
03-09
仓库管理系统，SpringBoot+Spring Data JPA.zip仓库管理系统，SpringBoot+Spring Data JPA.zip仓库管理系统，SpringBoot+Spring Data JPA.zip仓库管理系统，SpringBoot+Spring Data JPA.zip仓库管理系统，SpringBoot...
SpringBoot整合持久层技术之搭建并整合Spring Data JPA项目
06-17
SpringBoot整合Spring Data JPA是现代Java开发中的常见实践，它极大地简化了数据库操作，让开发者可以更加专注于业务逻辑而不是繁琐的数据访问层实现。本文将详细介绍如何使用Spring Boot搭建一个基于Spring Data ...
SpringBoot如何整合SpringDataJPA
08-24
SpringBoot如何整合SpringDataJPA SpringBoot是一个基于Java的开源框架，提供了许多便捷的功能来简化Web应用程序的开发， 而SpringDataJPA则是一个Java持久化规范的实现，提供了一个统一的访问数据库的接口。 ...
springboot.zip+springboot使用+spring thymeleaf+semantic UI使用+spring data jpa
08-20
总之，这个压缩包提供了一个完整的SpringBoot项目示例，涵盖了SpringBoot的基本使用、Thymeleaf模板引擎的应用、Semantic UI的前端界面设计，以及Spring Data JPA的数据持久化操作。学习并理解这些内容，对于构建...
SpringMVC：环境搭建与常用注解
少年啦飞啦的博客
12-30 132
1、导入依赖 需要导入spring依赖和web相关依赖 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version&...
spring框架的使用
PDyee的博客
02-20 786
spring的使用 1、导入依赖 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.2.RELEASE</version> </dependency>
springboot依赖管理和自动配置源码分析
m0_54355172的博客
05-08 3337
源码追踪写得很详细，可以跟着走一遍。 也可以直接跳过，看结论。
springdata操作es
诗琪芮的博客
03-30 1448
1、创建一个maven项目 项目结构： 2、导入依赖 <dependencies> <!-- 测试用 --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test&l
spring-data-JPA和spring-data-mongodb依赖包版本冲突解决办法
lydia4me的博客
03-19 1247
项目之前用的spring-data-jpa，版本是1.1.0.RELEASE，依赖关系如下：   &lt;dependency&gt; &lt;groupId&gt;org.springframework.data&lt;/groupId&gt; &lt;artifactId&gt;spring-data-jpa&lt;/artifactId&gt; &lt;version&g...
一个完整的springboot项目所需要导入的依赖合集（方便查找）
m0_67401382的博客
07-31 2237
四、lombok依赖（用来简化对类的操作包括set、get以及构造函数等，只需要一个注解）导入lombok依赖后还需要进行一步操作，下载lombok插件，方法点击File—>Setting—>Plugins然后再搜索框搜索Lombok，安装插件即可。导入了mysql依赖后需要连接数据库，在application.yaml配置文件中配置连入数据库的参数，url六、配置日志，查看sql输出日志（在application.yaml配置文件中配置）文件，然后在里边添加如下依赖九、fastjson依赖。...
SpringBoot整合SpringDataJPA实战教程
"该资源是关于SpringDataJPA的PDF文档，主要讲解了SpringDataJPA的使用，包括与JDK8、MySQL6.0和SpringBoot2.1.13的集成，提供了数据库操作的各种示例。内容涵盖SpringDataJPA的介绍、SpringBoot如何整合SpringData...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值