SpringBoot整合SpringDataJPA使用

博主个人主页

前言

今天我们来看一下 Springboot 整合 SpringData JPA 使用JPA对单表的操作还是非常便捷的链表可能会稍微难受一点吧 相信尽然您都来看这个了 应该知道JPA是什么了 其实就是一种规范 只不过有好多框架对其进行了实现 今天主要说的就是在当下非常火热的Springboot框架中继承SpringData Jpa 好了 废话不多说 我们直接看如何使用吧

使用

依赖

不管什么 依赖总是第一步 创建项目的就不演示了吧 创建一个SpringBoot项目即可 因为我们是SpringBoot整合的吗 肯定要创建SpringBoot项目啦

 <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.26</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

配置

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3307/test?characterEncoding=utf-8&useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
# 正向工程   update 不会每一次都创建新表 如果存在就会修改
spring.jpa.hibernate.ddl-auto=update
# 显示SQL语句
spring.jpa.show-sql=true

创建我们对应的包和对应的mapper以及实体类

mapper

这里我们如果要使用jpa就需要继承两个接口
JpaRepository<Test,Integer> 泛型第一个是实体类 第二个主键类型
JpaSpecificationExecutor 泛型第一个是实体类
其实相对应的还有其他三个接口 不过这些接口都是继承了其他几个的 所以这里就不提了 因为基本常用的就是这两个了 一个提供复杂查询 一个简单查询常用功能都继承好了

在下面有两个方法 这是jpa可以选择的一种方式 就是可以根据属性名来规定方法名 取数据查询数据
但是要求比较严格 是有一定的规律的 例如 属性必须大写开头等 想了解的可以去百度一下 如果你使用idea开发工具 会有非常智能的提示

package top.liwenxiang.jpa.jpademo.top.liwenxiang.jpa.mapper;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import top.liwenxiang.jpa.jpademo.top.liwenxiang.jpa.domin.Test;

import java.util.List;

public interface TestMapper extends JpaRepository<Test,Integer> , JpaSpecificationExecutor<Test> {
    /**
     * 根据名称查询
     * @param name
     * @return
     */
    List<Test> findByName(String name);

    List<Test> findByNameLikeAndAge(String name,Integer age);
}

实体类

对应数据库中的某一张表

@Transient 标识该字段不和数据库表进行映射 就是数据库表中没有这一个字段
其他的注解都有解释 相信你看一下注解名字就知道什么意思了吧

package top.liwenxiang.jpa.jpademo.top.liwenxiang.jpa.domin;

import lombok.*;
import lombok.experimental.Accessors;
import org.hibernate.annotations.GenericGenerator;

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


@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@ToString
@Accessors(chain = true)
@Entity
@Table(name="test")
public class Test implements Serializable {

    /**
     * 主键生成策略
     * @GeneratedValue(strategy= GenerationType.IDENTITY)   支持自增的数据库   MYSQL使用
     * @GeneratedValue(strategy= GenerationType.SEQUENCE)   支持序列的数据库   ORACLE使用
     * @GeneratedValue(strategy= GenerationType.AUTO)       程序自动维护       了解
     * @GeneratedValue(strategy= GenerationType.TABLE)      JPA 自动生成ID     了解
     */
    @GeneratedValue(strategy= GenerationType.IDENTITY)
    @Column(name = "id")
    @Id
    private Integer id;
    @Column(name="name")
    private String name;
    @Column(name="age")
    private Integer age;
  @Transient  
  private String[] typeNames;

    public Test(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

启动类
我们可以开启事务管理的
在SpringData Jpa 中会自动帮助我们进行提交 而在JPA中是需要我们自己提交的

@SpringBootApplication
@EnableTransactionManagement
public class JpaDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(JpaDemoApplication.class, args);
    }

}

具体使用

下面的方式 使用了常见的增删改查方法 以及最后一个方法实现了 复杂查询 包括了分页和排序 忘记代码的都可以过来查看哦~ 里面的Optional是Java8中的新容器类 目的是为了防止NULL指针的 可以百度一下 其他的无所谓 就是复杂查询的方式比较麻烦一些

package top.liwenxiang.jpa.jpademo;


import org.hibernate.criterion.Example;
import org.hibernate.criterion.Order;
import org.hibernate.sql.ordering.antlr.OrderingSpecification;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.querydsl.QPageRequest;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.junit4.SpringRunner;
import top.liwenxiang.jpa.jpademo.top.liwenxiang.jpa.mapper.TestMapper;
import top.liwenxiang.jpa.jpademo.top.liwenxiang.jpa.domin.Test;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.*;

@RunWith(SpringRunner.class)
@SpringBootTest
public class JpaDemoApplicationTests {

    @Autowired
    TestMapper testMapper;

    @Autowired
    JdbcTemplate jdbcTemplate;

    @org.junit.Test
    public void select() {
        Optional<Test> byId = testMapper.findById(1);
        Test test = byId.orElseGet(Test::new);
        System.out.println(test);
    }

    @org.junit.Test
    public void save01() {
        Test lwx = testMapper.save(new Test("lwx", 28));
        System.out.println(lwx);
    }

    @org.junit.Test
    public void save02(){
        String[] s = {"INSERT INTO test (name,age) VALUES ('job',18)","INSERT INTO test (name,age) VALUES ('lusn',20)"};
        jdbcTemplate.batchUpdate(s);
    }

    @org.junit.Test
    public void save03(){
        String name = jdbcTemplate.queryForObject("SELECT name FROM test WHERE id = 1", String.class);
        System.out.println(name);
    }

    @org.junit.Test
    public void select02(){
        List<Test> allById = testMapper.findAllById(Arrays.asList(1, 2, 3, 4, 5));
        System.out.println(allById);
    }

    @org.junit.Test
    public void opa(){
        Optional<Test> test = checkDemo(new Test(1, "123", 100));
        Test test1 = test.get();
        System.out.println(test1);
    }

    @org.junit.Test
    public void paging(){
        Sort sort = new Sort(Sort.Direction.DESC,"age");
        Pageable pageable = PageRequest.of(1,2,sort);
        Page<Test> all = testMapper.findAll(pageable);
        List<Test> content = all.getContent();
        content.forEach(System.out::println);
    }

    @org.junit.Test
    public void sort(){
        Sort s = new Sort(Sort.Direction.DESC,"age","id");
        List<Test> all = testMapper.findAll(s);
        Collections.sort(all,(x,y) -> x.getAge() - y.getAge());
        all.forEach(System.out::print);
    }

    @org.junit.Test
    public void count(){
        long count = testMapper.count();
        System.out.println(count);
    }

    @org.junit.Test
    public void dyncSelect(){
        List<Test> job = testMapper.findByName("job");
        System.out.println(job);
        List<Test> job1 = testMapper.findByNameLikeAndAge("%o%", 18);
        System.out.println(job1);
    }

    @org.junit.Test
    public void dync(){
        Test t = new Test();
        t.setName("o");

        List<Test> tests = testMapper.findAll(new Specification<Test>() {
            @Override
            public Predicate toPredicate(Root<Test> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
                Predicate conjunction = criteriaBuilder.conjunction();
                if (t != null) {
                    if (t.getName() != null && !t.getName().equals("")) {
                        conjunction.getExpressions().add(criteriaBuilder.like(root.get("name"), "%" + t.getName() + "%"));
                    }
                }
                return conjunction;
            }
        });

        System.out.println(tests);
    }

    public <T extends Serializable> Optional<T> checkDemo(T t){
        return Optional.of(t);
    }



}

结语

那么SpringDataJPA的整合就到这里咯 以及基本的使用方式都实现了 其他的还需要小伙伴们多去百度哦 对应的 还有@Query注解的使用 这里没有涉及到 还有 @Modifying 修改的 谢谢大家阅读~~