整合jpa

pom.xml

@@ -53,7 +53,24 @@
             <groupId>org.hibernate.orm</groupId>
             <artifactId>hibernate-core</artifactId>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter -->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid-spring-boot-starter</artifactId>
+            <version>1.2.18</version>
+        </dependency>
 
+        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>4.4</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-devtools</artifactId>

src/main/java/cn/lihongjie/coal/CoalApplication.java

@@ -2,8 +2,10 @@ package cn.lihongjie.coal;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 
 @SpringBootApplication
+@EnableJpaRepositories
 public class CoalApplication {
 
     public static void main(String[] args) {

src/main/java/cn/lihongjie/coal/config/DruidConfig.java

@@ -0,0 +1,20 @@
+package cn.lihongjie.coal.config;
+
+import com.alibaba.druid.pool.DruidDataSource;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import javax.sql.DataSource;
+
+@Configuration
+public class DruidConfig {
+
+
+
+    @ConfigurationProperties("spring.datasource.druid")
+    @Bean
+    public DataSource druidDataSource() {
+        return new DruidDataSource();
+    }
+}

src/main/java/cn/lihongjie/coal/config/RResponseBodyAdvice.java

@@ -2,6 +2,7 @@ package cn.lihongjie.coal.config;
 
 import cn.lihongjie.coal.dto.R;
 import org.springframework.core.MethodParameter;
+import org.springframework.data.domain.Page;
 import org.springframework.http.MediaType;
 import org.springframework.http.converter.HttpMessageConverter;
 import org.springframework.http.server.ServerHttpRequest;
@@ -10,6 +11,8 @@ import org.springframework.web.bind.annotation.ControllerAdvice;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
 
+import java.util.List;
+
 @RestControllerAdvice
 public class RResponseBodyAdvice implements ResponseBodyAdvice<Object> {
 
@@ -33,6 +36,16 @@ public class RResponseBodyAdvice implements ResponseBodyAdvice<Object> {
             return body;
         }
 
+        if (body instanceof Page<?> p) {
+            R<? extends List<?>> r = R.success(p.getContent());
+            r.setPageNo(p.getNumber());
+            r.setPageSize(p.getSize());
+            r.setTotalPage(p.getTotalPages());
+            r.setTotalCount((int) p.getTotalElements());
+            return r;
+        }
+
+
         return R.success(body);
     }
 }

src/main/java/cn/lihongjie/coal/controller/BaseController.java

@@ -0,0 +1,44 @@
+package cn.lihongjie.coal.controller;
+
+import cn.lihongjie.coal.dao.BaseRepository;
+import cn.lihongjie.coal.dto.CommonQuery;
+import cn.lihongjie.coal.dto.IdRequest;
+import cn.lihongjie.coal.entity.BaseEntity;
+import cn.lihongjie.coal.service.BaseService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+
+public abstract class BaseController<Repository extends BaseRepository<Entity>, Service extends BaseService< Entity, Repository>, Entity extends BaseEntity> {
+
+    @Autowired
+    Service service;
+
+
+    @PostMapping("/create")
+    public Entity create(Entity entity){
+
+        return service.create(entity);
+    }
+
+    @PostMapping("/update")
+    public Entity update(Entity entity){
+
+        return service.update(entity);
+    }
+
+
+    @PostMapping("/deleteAllById")
+    public Object deleteAllById(IdRequest request){
+
+        service.deleteAllById(request);
+        return null;
+    }
+
+
+    @PostMapping("/list")
+    public Object list(CommonQuery request){
+
+        return service.list(request);
+    }
+
+}

src/main/java/cn/lihongjie/coal/controller/CoalWashingDailyAnalysisController.java

@@ -0,0 +1,12 @@
+package cn.lihongjie.coal.controller;
+
+import cn.lihongjie.coal.dao.CoalWashingDailyAnalysisRepository;
+import cn.lihongjie.coal.entity.CoalWashingDailyAnalysisEntity;
+import cn.lihongjie.coal.service.CoalWashingDailyAnalysisService;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/coalWashingDailyAnalysis")
+public class CoalWashingDailyAnalysisController extends BaseController<CoalWashingDailyAnalysisRepository, CoalWashingDailyAnalysisService, CoalWashingDailyAnalysisEntity>{
+}

src/main/java/cn/lihongjie/coal/dao/BaseDao.java

@@ -1,8 +0,0 @@
-package cn.lihongjie.coal.dao;
-
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.repository.CrudRepository;
-import org.springframework.data.repository.ListPagingAndSortingRepository;
-
-public interface BaseDao<T> extends JpaRepository<T, String> {
-}

src/main/java/cn/lihongjie/coal/dao/BaseRepository.java

@@ -0,0 +1,9 @@
+package cn.lihongjie.coal.dao;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.NoRepositoryBean;
+
+@NoRepositoryBean
+public interface BaseRepository<T> extends JpaRepository<T, String>, JpaSpecificationExecutor<T> {
+}

src/main/java/cn/lihongjie/coal/dao/CoalWashingDailyAnalysisDao.java

@@ -1,6 +0,0 @@
-package cn.lihongjie.coal.dao;
-
-import cn.lihongjie.coal.entity.CoalWashingDailyAnalysis;
-
-public interface CoalWashingDailyAnalysisDao extends BaseDao<CoalWashingDailyAnalysis>{
-}

src/main/java/cn/lihongjie/coal/dao/CoalWashingDailyAnalysisRepository.java

@@ -0,0 +1,8 @@
+package cn.lihongjie.coal.dao;
+
+import cn.lihongjie.coal.entity.CoalWashingDailyAnalysisEntity;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface CoalWashingDailyAnalysisRepository extends BaseRepository<CoalWashingDailyAnalysisEntity> {
+}

src/main/java/cn/lihongjie/coal/dto/CommonQuery.java

@@ -1,13 +1,26 @@
 package cn.lihongjie.coal.dto;
 
+import io.vavr.Function3;
+import io.vavr.Function4;
+import io.vavr.Tuple;
+import io.vavr.Tuple2;
 import jakarta.persistence.criteria.CriteriaBuilder;
 import jakarta.persistence.criteria.CriteriaQuery;
 import jakarta.persistence.criteria.Predicate;
 import jakarta.persistence.criteria.Root;
+import jakarta.persistence.metamodel.Attribute;
+import jakarta.persistence.metamodel.EntityType;
 import lombok.Data;
+import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.core.convert.ConversionService;
+import org.springframework.data.domain.Sort;
 import org.springframework.data.jpa.domain.Specification;
 
-import java.util.List;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
 
 @Data
 public class CommonQuery {
@@ -18,25 +31,451 @@ public class CommonQuery {
 
     private Integer pageSize;
 
+    private List<Order> orders;
+
+    @Data
+    public static class Order{
+
+        private final Sort.Direction direction;
+        private final String property;
+    }
+
+
+    public List<Sort.Order> getOrders() {
+
+
+        if (orders == null) {
+            return new ArrayList<>();
+        }
+
+
+        return orders.stream().map(x -> new Sort.Order(x.direction, x.property)).toList();
+
+
+    }
+
     @Data
     public static class QueryItem {
         private String key;
         private String opt;
         private String value;
         private String group = "default";
+        private String min;
+        private String max;
 
     }
 
 
 
 
-    public Specification specification(){
+
+    public static Map<Tuple2<String, Class>, Function4<Root, CriteriaBuilder, QueryItem, ConversionService , Predicate>> map = new HashMap<>();
+
+
+    static {
+
+        map.put(Tuple.of("like", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.like(root.get(x.key), c.convert(x.value, String.class));
+        });
+
+
+        map.put(Tuple.of("nlike", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.notLike(root.get(x.key), c.convert(x.value, String.class));
+        });
+
+
+
+        map.put(Tuple.of("null", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNull(root.get(x.key));
+        });
+
+        map.put(Tuple.of("null", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNull(root.get(x.key));
+        });
+
+        map.put(Tuple.of("null", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNull(root.get(x.key));
+        });
+
+
+        map.put(Tuple.of("null", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNull(root.get(x.key));
+        });
+        map.put(Tuple.of("null", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNull(root.get(x.key));
+        });
+
+        map.put(Tuple.of("null", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNull(root.get(x.key));
+        });
+        map.put(Tuple.of("null", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNull(root.get(x.key));
+        });
+
+
+
+        map.put(Tuple.of("nnull", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNotNull(root.get(x.key));
+        });
+
+        map.put(Tuple.of("nnull", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNotNull(root.get(x.key));
+        });
+
+        map.put(Tuple.of("nnull", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNotNull(root.get(x.key));
+        });
+
+
+        map.put(Tuple.of("nnull", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNotNull(root.get(x.key));
+        });
+        map.put(Tuple.of("nnull", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNotNull(root.get(x.key));
+        });
+
+        map.put(Tuple.of("nnull", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNotNull(root.get(x.key));
+        });
+        map.put(Tuple.of("nnull", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.isNotNull(root.get(x.key));
+        });
+
+
+
+        map.put(Tuple.of("eq", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, String.class));
+        });
+
+        map.put(Tuple.of("eq", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, Integer.class));
+        });
+
+        map.put(Tuple.of("eq", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, Long.class));
+        });
+
+
+        map.put(Tuple.of("eq", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, Double.class));
+        });
+        map.put(Tuple.of("eq", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, BigDecimal.class));
+        });
+
+        map.put(Tuple.of("eq", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, LocalDate.class));
+        });
+        map.put(Tuple.of("eq", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.equal(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+        });
+
+
+
+
+
+
+        map.put(Tuple.of("neq", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, String.class));
+        });
+
+        map.put(Tuple.of("neq", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, Integer.class));
+        });
+
+        map.put(Tuple.of("neq", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, Long.class));
+        });
+
+
+        map.put(Tuple.of("neq", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, Double.class));
+        });
+        map.put(Tuple.of("neq", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, BigDecimal.class));
+        });
+
+        map.put(Tuple.of("neq", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, LocalDate.class));
+        });
+        map.put(Tuple.of("neq", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.notEqual(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+        });
+
+
+
+
+
+
+        map.put(Tuple.of("between", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, String.class), c.convert(x.max, String.class));
+        });
+
+        map.put(Tuple.of("between", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, Integer.class), c.convert(x.max, Integer.class));
+        });
+
+        map.put(Tuple.of("between", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, Long.class), c.convert(x.max, Long.class));
+        });
+
+
+        map.put(Tuple.of("between", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, Double.class), c.convert(x.max, Double.class));
+        });
+        map.put(Tuple.of("between", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, BigDecimal.class), c.convert(x.max, BigDecimal.class));
+        });
+
+        map.put(Tuple.of("between", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, LocalDate.class), c.convert(x.max, LocalDate.class));
+        });
+        map.put(Tuple.of("between", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.between(root.get(x.key), c.convert(x.min, LocalDateTime.class), c.convert(x.max, LocalDateTime.class));
+        });
+
+
+
+
+
+
+
+
+
+
+
+        map.put(Tuple.of("lt", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, String.class));
+        });
+
+        map.put(Tuple.of("lt", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, Integer.class));
+        });
+
+        map.put(Tuple.of("lt", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, Long.class));
+        });
+
+
+        map.put(Tuple.of("lt", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, Double.class));
+        });
+        map.put(Tuple.of("lt", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, BigDecimal.class));
+        });
+
+        map.put(Tuple.of("lt", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, LocalDate.class));
+        });
+        map.put(Tuple.of("lt", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThan(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+        });
+
+
+        map.put(Tuple.of("le", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, String.class));
+        });
+
+        map.put(Tuple.of("le", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, Integer.class));
+        });
+
+        map.put(Tuple.of("le", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, Long.class));
+        });
+
+
+        map.put(Tuple.of("le", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, Double.class));
+        });
+        map.put(Tuple.of("le", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, BigDecimal.class));
+        });
+
+        map.put(Tuple.of("le", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, LocalDate.class));
+        });
+        map.put(Tuple.of("le", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.lessThanOrEqualTo(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+        });
+
+
+
+
+
+
+
+
+
+        map.put(Tuple.of("gt", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, String.class));
+        });
+
+        map.put(Tuple.of("gt", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, Integer.class));
+        });
+
+        map.put(Tuple.of("gt", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, Long.class));
+        });
+
+
+        map.put(Tuple.of("gt", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, Double.class));
+        });
+        map.put(Tuple.of("gt", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, BigDecimal.class));
+        });
+
+        map.put(Tuple.of("gt", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, LocalDate.class));
+        });
+        map.put(Tuple.of("gt", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThan(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+        });
+
+
+        map.put(Tuple.of("ge", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, String.class));
+        });
+
+        map.put(Tuple.of("ge", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, Integer.class));
+        });
+
+        map.put(Tuple.of("ge", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, Long.class));
+        });
+
+
+        map.put(Tuple.of("ge", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, Double.class));
+        });
+        map.put(Tuple.of("ge", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, BigDecimal.class));
+        });
+
+        map.put(Tuple.of("ge", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, LocalDate.class));
+        });
+        map.put(Tuple.of("ge", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.greaterThanOrEqualTo(root.get(x.key), c.convert(x.value, LocalDateTime.class));
+        });
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        map.put(Tuple.of("in", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, String.class)).toList());
+        });
+
+        map.put(Tuple.of("in", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Integer.class)).toList());
+        });
+
+        map.put(Tuple.of("in", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Long.class)).toList());
+        });
+
+
+        map.put(Tuple.of("in", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Double.class)).toList());
+        });
+        map.put(Tuple.of("in", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, BigDecimal.class)).toList());
+        });
+
+        map.put(Tuple.of("in", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDate.class)).toList());
+        });
+        map.put(Tuple.of("in", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDateTime.class)).toList());
+        });
+
+
+
+
+
+        map.put(Tuple.of("nin", String.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, String.class)).toList()).not();
+        });
+
+        map.put(Tuple.of("nin", Integer.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Integer.class)).toList()).not();
+        });
+
+        map.put(Tuple.of("nin", Long.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Long.class)).toList()).not();
+        });
+
+
+        map.put(Tuple.of("nin", Double.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, Double.class)).toList()).not();
+        });
+        map.put(Tuple.of("nin", BigDecimal.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, BigDecimal.class)).toList()).not();
+        });
+
+        map.put(Tuple.of("nin", LocalDate.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDate.class)).toList()).not();
+        });
+        map.put(Tuple.of("nin", LocalDateTime.class), (Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService c) -> {
+            return criteriaBuilder.in(root.get(x.key)).in(Arrays.stream(x.value.split(",")).map(i -> c.convert(i, LocalDateTime.class)).toList()).not();
+        });
+
+
+
+
+
+    }
+
+
+    public Specification specification(ConversionService conversionService) {
+
+
+
 
         return new Specification() {
             @Override
             public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder criteriaBuilder) {
 
-                return criteriaBuilder.or();
+
+                if (CollectionUtils.isNotEmpty(items)) {
+
+                    Map<String, List<QueryItem>> group = items.stream().collect(Collectors.groupingBy(i -> i.group));
+
+                    List<Predicate> orPredicates = new ArrayList<>();
+                    for (List<QueryItem> queryItems : group.values()) {
+
+
+                        Predicate[] predicates = queryItems.stream().map(y -> getPredicate(root, criteriaBuilder, y, conversionService)).toArray(Predicate[]::new);
+
+                        orPredicates.add(criteriaBuilder.and(predicates));
+                    }
+
+
+                    return criteriaBuilder.or(orPredicates.toArray(new Predicate[0]));
+
+
+                } else {
+
+                    return criteriaBuilder.equal(criteriaBuilder.literal(1), 1);
+                }
 
 
             }
@@ -46,10 +485,25 @@ public class CommonQuery {
 
     }
 
+    private static Predicate getPredicate(Root root, CriteriaBuilder criteriaBuilder, QueryItem x, ConversionService conversionService) {
+        EntityType entityType = root.getModel();
+
+        Attribute attribute = entityType.getAttribute(x.key);
+
+        Class javaType = attribute.getJavaType();
+
+
+        Function4<Root, CriteriaBuilder, QueryItem, ConversionService, Predicate> function4 = map.get(Tuple.of(x.opt, javaType));
+
+        if (function4 == null) {
+            throw new RuntimeException("无法识别的查询 " + x.toString());
+        }
+
+        return function4.apply(root, criteriaBuilder, x, conversionService);
 
 
 
-
+    }
 
 
 }

src/main/java/cn/lihongjie/coal/dto/IdRequest.java

@@ -0,0 +1,13 @@
+package cn.lihongjie.coal.dto;
+
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class IdRequest {
+
+    @NotEmpty(message = "ids不能为空")
+    private List<String> ids;
+}

src/main/java/cn/lihongjie/coal/dto/PagedData.java

@@ -0,0 +1,13 @@
+package cn.lihongjie.coal.dto;
+
+import java.util.List;
+
+public class PagedData <T>{
+
+    private List<T> data;
+
+    private Integer pageNo;
+    private Integer pageSize;
+    private Integer totalCount;
+
+}

src/main/java/cn/lihongjie/coal/dto/R.java

@@ -10,6 +10,11 @@ public class R<T> {
 
     private String msg;
 
+    private Integer pageNo;
+    private Integer pageSize;
+    private Integer totalPage;
+    private Integer totalCount;
+
 
     public R(T data, String code, String msg) {
         this.data = data;

src/main/java/cn/lihongjie/coal/entity/CoalWashingDailyAnalysisEntity.java

@@ -8,7 +8,7 @@ import java.time.LocalDate;
 
 @Entity
 @Data
-public class CoalWashingDailyAnalysis extends BaseEntity {
+public class CoalWashingDailyAnalysisEntity extends BaseEntity {
 
     @Comment("显示名称")
     private String name;

src/main/java/cn/lihongjie/coal/service/BaseService.java

@@ -1,51 +1,59 @@
 package cn.lihongjie.coal.service;
 
-import cn.lihongjie.coal.dao.BaseDao;
+import cn.lihongjie.coal.dao.BaseRepository;
+import cn.lihongjie.coal.dto.CommonQuery;
+import cn.lihongjie.coal.dto.IdRequest;
+import cn.lihongjie.coal.dto.PagedData;
 import cn.lihongjie.coal.entity.BaseEntity;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.convert.ConversionService;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
 
-public abstract class BaseService<Dao, Entity extends BaseEntity> {
+public abstract class BaseService<Entity extends BaseEntity, Repository extends BaseRepository<Entity>> {
 
     @Autowired
-    BaseDao<Entity> dao;
+    Repository dao;
+
+    @Autowired
+    ConversionService conversionService;
 
 
-
-    public String create(Entity entity){
+    public Entity create(Entity entity){
 
 
         dao.save(entity);
 
-        return entity.getId();
+        return entity;
 
     }
 
-    public void update(Entity entity){
+    public Entity update(Entity entity){
 
 
         dao.save(entity);
 
+        return entity;
 
     }
 
 
-    public void deleteById(String id){
 
 
-        dao.deleteById(id);
-
+    public void deleteAllById(IdRequest idRequest){
+         dao.deleteAllById(idRequest.getIds());
 
     }
 
-    public void deleteAllById(Iterable<String> id){
-        dao.deleteAllById(id);
-    }
+
+    public Page<Entity> list(CommonQuery query){
+
+        Page<Entity> page = dao.findAll(query.specification(conversionService), PageRequest.of(query.getPageNo(), query.getPageSize(), Sort.by(query.getOrders())));
 
 
-    public Object list(){
-
-
-        return null;
+        return page;
 
 
     }

src/main/java/cn/lihongjie/coal/service/CoalWashingDailyAnalysisService.java

@@ -0,0 +1,11 @@
+package cn.lihongjie.coal.service;
+
+import cn.lihongjie.coal.dao.CoalWashingDailyAnalysisRepository;
+import cn.lihongjie.coal.entity.CoalWashingDailyAnalysisEntity;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+@Service
+@Slf4j
+public class CoalWashingDailyAnalysisService extends BaseService< CoalWashingDailyAnalysisEntity,CoalWashingDailyAnalysisRepository>{
+}

src/main/resources/application.yaml

@@ -1,2 +1,24 @@
 geolite2:
-  url: 'https://download.maxmind.com/app/geoip_download?edition_id=GeoLite2-City&license_key=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&suffix=tar.gz'
+  url: 'https://download.maxmind.com/app/geoip_download?edition_id=GeoLite2-City&license_key=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&suffix=tar.gz'
+
+
+spring:
+  jpa:
+    hibernate:
+      ddl-auto: update
+    show-sql: true
+  datasource:
+
+    druid:
+      driver-class-name: org.postgresql.Driver
+      url: jdbc:postgresql://localhost:5432/coal
+      username: postgres
+      password: 'abc@123'
+      initial-size: 10
+      max-active: 200
+      min-idle: 10
+      validation-query: "select 1"
+      validation-query-timeout: 1000
+      test-on-borrow: true
+      test-on-return: true
+      enable: true