Build microservice framework (database persistence layer spring datajpa)

introduce

I've heard of HibernateJPA before, but I've never used it. Mybatis is always used in the project.

Spring datajpa is a set of ORM framework based on the underlying encapsulation of Hibernate. The first feeling is that the code volume is really small. Compared with the traditional Mybatis, it feels at least 60% less. Of course, most of it is embodied in xml files.

There are not many words to show in the introduction. Let's use them. 👇

use

In the squid project, we create a new squid example JPA project (since the previous example directory is deleted, we can create it according to the following hierarchical directory)

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

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
</dependency>

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

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

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

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

If you are using IDEA, you can refer to this blog Java entity generating SpringDataJPA under IDEA To generate entity information.

Because lombok is used, there is no getter setter method rendering in the generated entity. You can learn about lombok Lombok

DAO

After generating entity information, DAO files need to be generated manually by ourselves:

public interface EdocInvoiceRepository extends JpaRepository<EdocInvoice, Long> {

}

In general, we directly inherit JPA repository, which contains all JPA processing classes and basically has all the interaction methods of the persistence layer.

JPARespository:

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

    List<T> findAll(Sort var1);

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

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

    void flush();

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

    void deleteInBatch(Iterable<T> var1);

    void deleteAllInBatch();

    T getOne(ID var1);

    <S extends T> List<S> findAll(Example<S> var1);

    <S extends T> List<S> findAll(Example<S> var1, Sort var2);
}

If you have other requirements, such as the need to query according to two fields, spring datajpa fully supports:

You can also visit the official documents of spring datajpa to view: SpringDataJPA

Service & Impl & Controller

service, service.impl , controller, just write it according to the normal project. Note that if the service is to be an external interface, you can indicate @ feignclient ("squid example JPA") for reference sc-server

Post an example from the project:

public interface EdocInvoiceService {

    List<EdocInvoice> findAll();

    EdocInvoice save(EdocInvoice edocInvoice);
}

@Service
public class EdocInvoiceServiceImpl implements EdocInvoiceService {


    @Autowired
    private EdocInvoiceRepository edocInvoiceRepository;

    @Override
    public List<EdocInvoice> findAll() {
        return edocInvoiceRepository.findAll();
    }

    @Override
    public EdocInvoice save(EdocInvoice edocInvoice) {
        return edocInvoiceRepository.save(edocInvoice);
    }
}

@RestController
@RequestMapping(value = "/invoice")
public class EdocInvoiceController {

    @Autowired
    private EdocInvoiceService edocInvoiceService;

    @PostMapping(value = "/findAll")
    public List<EdocInvoice> findAll() {
        return edocInvoiceService.findAll();
    }

    @PostMapping(value = "/save")
    public EdocInvoice save(@RequestBody EdocInvoice edocInvoice) {
        return edocInvoiceService.save(edocInvoice);
    }
}

application.yaml

spring:
  application:
    name: squid-miniprogram
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://yanzhenyidai.com:3306/fapiaochi?useUnicode=true&characterEncoding=utf-8
    username: root
    password: ***
    type: com.alibaba.druid.pool.DruidDataSource
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
server:
  port: 9090

jpa.hibernate.ddl-auto :

The general DDL auto property uses update.

When complex business occurs, multi table query may be used, but JPA is not as flexible as Mybatis. It needs to create an intermediate entity to receive. My general practice is to query two tables separately and then merge them.

summary

The feeling of using spring datajpa is "fast". Compared with smaller projects, it is really recommended to use spring datajpa, which can quickly build a persistence layer, and do not care about the underlying xml files as much as Mybatis.

reference material:

SpringDataJPA-Github

SpringDataJPA-doc