多源数据处理（支持springboot2.0版本）

最新推荐文章于 2022-12-19 07:45:00 发布
最新推荐文章于 2022-12-19 07:45:00 发布
阅读量219 收藏
点赞数
分类专栏： 学习总结 文章标签： 多源数据 多数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43498417/article/details/99304332
版权

–dataSource-- entitymanagerfactory–PlatformTransactionManager
–springboot jpa配置*
OrderRepository和VerifyRepository在同一个包下面，扫描的时候会把所有的orderRepository,verifyRepository类配置两个，扫描两次注入容器中的名称和类型又是一样的，所以会有冲突，只会有一个生效
并不知道PrimaryConfiguration和BackupConfiguration谁先配置
repository 扫描的时候并不确定那个先扫描，查看源代码，设断点看扫描顺序

解决办法：

将orderRepository，verifyRepository分开放在两个包里。

新建configuration包，并新建java类DataAccessConfiguration
具体如下：

package com.imooc.seller.configuration;

import com.imooc.entity.Order;
import com.imooc.entity.VerificationOrder;
import com.imooc.seller.repositories.OrderRepository;
import com.imooc.seller.repositoriesbackup.DifferentOrderRepository;
import com.imooc.seller.repositoriesbackup.VerifyRepository;
import org.aspectj.weaver.ast.Or;
import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.jdbc.EmbeddedDatabaseConnection;
import org.springframework.boot.jdbc.SchemaManagement;
import org.springframework.boot.jdbc.SchemaManagementProvider;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
//import org.springframework.data.repository.config.RepositoryBeanNamePrefix;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;


/**
 * 数据库相关操作配置
 */
@Configuration
public class DataAccessConfiguration {
    @Autowired
    private JpaProperties properties;

    @Autowired
    private ObjectProvider<List<SchemaManagementProvider>> providers;
    @Autowired
    private ObjectProvider<PhysicalNamingStrategy> physicalNamingStrategy;
    @Autowired
    private ObjectProvider<ImplicitNamingStrategy> implicitNamingStrategy;
    //配置数据源 dataSource-- entitymanagerfactory--PlatformTransactionManager--springboot jpa配置
    //主库数据源
    @Bean
    @Primary
    @ConfigurationProperties("spring.datasource.primary")
    public DataSourceProperties primaryDataSourceProperties() {
        return new DataSourceProperties();
    }
    @Bean
    @Primary
    public DataSource primaryDataSource() {
        return primaryDataSourceProperties().initializeDataSourceBuilder().build();
    }
    //备份库数据源
    @Bean
    @ConfigurationProperties("spring.datasource.backup")
    public DataSourceProperties backupDataSourceProperties() {
        return new DataSourceProperties();
    }
    @Bean
    public DataSource backupDataSource() {
        return  backupDataSourceProperties().initializeDataSourceBuilder().build();
    }
    //主库LocalContainerEntityManagerFactoryBean
    @Bean
    @Primary
    public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory(
            EntityManagerFactoryBuilder builder,@Qualifier("primaryDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages(Order.class)
                .properties(getVendorProperties(dataSource))
                .persistenceUnit("primary")
                .build();
    }
    //备库LocalContainerEntityManagerFactoryBean
    @Bean
    public LocalContainerEntityManagerFactoryBean backupEntityManagerFactory(
            EntityManagerFactoryBuilder builder,@Qualifier("backupDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages(Order.class)
                .properties(getVendorProperties(dataSource))
                .persistenceUnit("backup")
                .build();
    }
    //主库PlatformTransactionManager
    @Bean
    @Primary
    public PlatformTransactionManager primaryTransactionManager(@Qualifier("primaryEntityManagerFactory") LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory) {
        JpaTransactionManager transactionManager = new JpaTransactionManager(primaryEntityManagerFactory.getObject());
        return transactionManager;
    }
    //备库PlatformTransactionManager
    @Bean
    public PlatformTransactionManager backupTransactionManager(@Qualifier("backupEntityManagerFactory") LocalContainerEntityManagerFactoryBean backupEntityManagerFactory) {
        JpaTransactionManager transactionManager = new JpaTransactionManager(backupEntityManagerFactory.getObject());
        return transactionManager;
    }


    //OrderRepository和VerifyRepository在同一个包下面，扫描的时候会把所有的orderRepository,verifyRepository类配置两个，扫描两次注入容器中的名称和类型又是一样的，所以会有冲突，只会有一个生效
   //并不知道PrimaryConfiguration和BackupConfiguration谁先配置
   //repository 扫描的时候并不确定那个先扫描，查看源代码，设断点看扫描顺序
    @EnableJpaRepositories(basePackageClasses = {OrderRepository.class},
            entityManagerFactoryRef = "primaryEntityManagerFactory",transactionManagerRef = "primaryTransactionManager")
    @Primary
    public class PrimaryConfiguration {
    }



    @EnableJpaRepositories(basePackageClasses = {VerifyRepository.class,DifferentOrderRepository.class},
            entityManagerFactoryRef = "backupEntityManagerFactory",transactionManagerRef = "backupTransactionManager")
    public class BackupConfiguration {
    }

    protected Map<String, Object> getVendorProperties(DataSource dataSource) {
        Map<String, Object> vendorProperties = new LinkedHashMap<String, Object>();
        String defaultDdlMode = new  HibernateDefaultDdlAutoProvider(
                providers.getIfAvailable(Collections::emptyList))
                .getDefaultDdlAuto(dataSource);
        vendorProperties.putAll(properties.getHibernateProperties(
                new HibernateSettings().ddlAuto(defaultDdlMode).physicalNamingStrategy(physicalNamingStrategy.getIfAvailable())
                        .implicitNamingStrategy(implicitNamingStrategy.getIfAvailable())
        ));
        return vendorProperties;
    }

    class HibernateDefaultDdlAutoProvider implements SchemaManagementProvider {

        private final List<SchemaManagementProvider> providers;

        HibernateDefaultDdlAutoProvider(List<SchemaManagementProvider> providers) {
            this.providers = providers;
        }

        public String getDefaultDdlAuto(DataSource dataSource) {
            if (!EmbeddedDatabaseConnection.isEmbedded(dataSource)) {
                return "none";
            }
            SchemaManagement schemaManagement = getSchemaManagement(dataSource);
            if (SchemaManagement.MANAGED.equals(schemaManagement)) {
                return "none";
            }
            return "create-drop";

        }

        @Override
        public SchemaManagement getSchemaManagement(DataSource dataSource) {
            for (SchemaManagementProvider provider : this.providers) {
                SchemaManagement schemaManagement = provider.getSchemaManagement(dataSource);
                if (SchemaManagement.MANAGED.equals(schemaManagement)) {
                    return schemaManagement;
                }
            }
            return SchemaManagement.UNMANAGED;
        }

    }

}

按库分离
在这里插入图片描述

在jpa配置时实现按库分离
OrderRepository—主库
VerifyRepository，DifferentOrderRepository—备库
在这里插入图片描述
在这里插入图片描述

application.yml

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT
  datasource:
    primary:
      url: jdbc:mysql:///seller?useUnicode=true&characterEncoding=utf-8
      username: root
      password: 915099
      driverClassName: com.mysql.jdbc.Driver
    backup:
      url: jdbc:mysql:///seller-backup?useUnicode=true&characterEncoding=utf-8
      username: root
      password: 915099
      driverClassName: com.mysql.jdbc.Driver
  jpa:
    database: mysql
    show-sql: true

OrderRepository
在这里插入图片描述

package com.imooc.seller.repositories;

import com.imooc.entity.Order;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;

import java.util.Date;
import java.util.List;

/**
 * 订单管理，继承接口
 */

public interface OrderRepository extends JpaRepository<Order, String> , JpaSpecificationExecutor<Order> {
    @Query(value = "SELECT CONCAT_WS('|', order_id,outer_order_id,chan_id,chan_user_id,product_id,order_type,amount,DATE_FORMAT( create_at,'%Y-%m-%d %H:%i:%s')) FROM order_t WHERE order_status = 'success' AND chan_id = ?1 AND create_at >= ?2 AND create_at < ?3",nativeQuery = true)
    List<String> queryVerificationOrders(String chanId, Date start, Date end);

}

在这里插入图片描述
VerifyRepository

package com.imooc.seller.repositoriesbackup;

import com.imooc.entity.VerificationOrder;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;

import java.util.Date;
import java.util.List;

/**
 * 对账相关
 */
public interface VerifyRepository extends JpaRepository<VerificationOrder, String>, JpaSpecificationExecutor<VerificationOrder> {

    /**
     * 查询某段时间[start,end)内的某个渠道chanId的对账数据
     * @param chanId
     * @param start
     * @param end
     * @return 对账数据列表
     */
//    //生成对账文件的sql语句实现
//    @Query(value = "SELECT CONCAT_WS('|', order_id,outer_order_id,chan_id,chan_user_id,product_id,order_type,amount,DATE_FORMAT( create_at,'%Y-%m-%d %H:%i:%s')) FROM order_t WHERE order_status = 'success' AND chan_id = ?1 AND create_at >= ?2 AND create_at < ?3",nativeQuery = true)
//    List<String> queryVerificationOrders(String chanId, Date start,Date end);
//    //长款 (left join 左连接，以t为准)左边有，右边没有
//    @Query(value = "SELECT t.`order_id` FROM order_t t LEFT JOIN verification_order v ON t.`chan_id` = ?1 AND t.`outer_order_id` = v.`order_id` WHERE v.`order_id` IS NULL AND v.create_at >= ?2 AND v.create_at < ?3",nativeQuery = true)
//    List<String> queryExcessOrders(String chanId, Date start,Date end);
//    //漏单 左边有，右边没有
//    @Query(value = "SELECT v.`order_id` FROM verification_order v LEFT JOIN order_t t ON t.`chan_id` = ?1 AND v.`outer_order_id` = t.`order_id` WHERE t.`order_id` IS NULL AND t.create_at >= ?2 AND t.create_at < ?3",nativeQuery = true)
//    List<String> queryMissOrders(String chanId, Date start,Date end);
//    //不一致 ,CONCAT_WS(separator,str1,str2,...),以什么连接字段
//    @Query(value = "SELECT t.order_id ,t.chan_id,t.product_id,t.chan_user_id,t.order_type,t.outer_order_id,t.amount,DATE_FORMAT( t.create_at,'%Y-%m-%d %H:%i:%s'))FROM order_t t JOIN verification_order v ON t.`chan_id` = ?1 AND t.`outer_order_id` = v.`order_id` WHERE CONCAT_WS('|',t.chan_id,t.chan_user_id,t.product_id,t.order_type,t.amount,DATE_FORMAT( t.create_at,'%Y-%m-%d %H:%i:%s')) != CONCAT_WS('|',v.chan_id,v.chan_user_id,v.product_id,v.order_type,v.amount,DATE_FORMAT( v.create_at,'%Y-%m-%d %H:%i:%s')) AND t.create_at >= ?2 AND t.create_at < ?3",nativeQuery = true)
//    List<String> queryDifferentOrders(String chanId, Date start,Date end);

    @Query(value = "SELECT CONCAT_WS('|', order_id,outer_order_id,chan_id,chan_user_id,product_id,order_type,amount,DATE_FORMAT( create_at,'%Y-%m-%d %H:%i:%s')) FROM order_t WHERE order_status = 'success' AND chan_id = ?1 AND create_at >= ?2 AND create_at < ?3",nativeQuery = true)
    List<String> queryVerificationOrders(String chanId, Date start, Date end);

    @Query(value = "SELECT t.`order_id` FROM order_t t LEFT JOIN verification_order v ON t.`chan_id` = ?1 AND t.`outer_order_id` = v.`order_id` WHERE v.`order_id` IS NULL AND t.create_at >= ?2 AND t.create_at < ?3",nativeQuery = true)
    List<String> queryExcessOrders(String chanId, Date start, Date end);

    @Query(value = "SELECT v.`order_id` FROM verification_order v LEFT JOIN order_t t ON t.`chan_id` = ?1 AND v.`outer_order_id` = t.`order_id` WHERE t.`order_id` IS NULL AND v.create_at >= ?2 AND v.create_at < ?3",nativeQuery = true)
    List<String> queryMissOrders(String chanId, Date start, Date end);
//
//    @Query(value = "SELECT t.`order_id` ,t.`chan_id`,t.`product_id`,t.`chan_user_id`,t.`outer_order_id`,t.`amount`,DATE_FORMAT( t.`create_at`,'%Y-%m-%d %H:%i:%s'))FROM order_t t JOIN verification_order v ON t.`chan_id` = ?1 AND t.`outer_order_id` = v.`order_id` WHERE CONCAT_WS('|',t.chan_id,t.chan_user_id,t.product_id,t.order_type,t.amount,DATE_FORMAT( t.create_at,'%Y-%m-%d %H:%i:%s')) != CONCAT_WS('|',v.chan_id,v.chan_user_id,v.product_id,v.order_type,v.amount,DATE_FORMAT( v.create_at,'%Y-%m-%d %H:%i:%s')) AND t.create_at >= ?2 AND t.create_at < ?3",nativeQuery = true)

    //先用'|'连接起来，之后才好分割
//    @Query(value = "SELECT CONCAT_WS('|',t.order_id,t.chan_id,t.product_id,t.chan_user_id,t.order_type,t.outer_order_id,t.amount,DATE_FORMAT(t.create_at,'%Y-%m-%d %H:%i:%s')) FROM order_t t JOIN verification_order v ON t.`chan_id` = ?1 AND t.`outer_order_id` = v.`order_id` WHERE CONCAT_WS('|',t.chan_id,t.chan_user_id,t.product_id,t.order_type,t.amount,DATE_FORMAT( t.create_at,'%Y-%m-%d %H:%i:%s')) != CONCAT_WS('|',v.chan_id,v.chan_user_id,v.product_id,v.order_type,v.amount,DATE_FORMAT( v.create_at,'%Y-%m-%d %H:%i:%s')) AND t.create_at >= ?2 AND t.create_at < ?3",nativeQuery = true)
//    //@Query(value = "SELECT t.order_id,t.chan_id,t.chan_user_id,t.product_id,t.outer_order_id,t.amount,DATE_FORMAT(t.create_at,'%Y-%m-%d %H:%i:%s') FROM order_t t JOIN verification_order v on t.chan_id = ?1 AND t.outer_order_id = v.order_id WHERE CONCAT_WS('|', t.chan_id,t.chan_user_id,t.product_id,t.order_type,t.amount,DATE_FORMAT(t.create_at,'%Y-%m-%d %H:%i:%s')) != CONCAT_WS('|', v.chan_id,v.chan_user_id,v.product_id,v.order_type,v.amount,DATE_FORMAT(v.create_at,'%Y-%m-%d %H:%i:%s')) AND create_at >= ?2 AND create_at <= ?3;\n",nativeQuery = true)
//    List<String> queryDifferentOrders(String chanId, Date start, Date end);
    //多库多表查询
    @Query(value = "SELECT CONCAT_WS('|',t.order_id,t.chan_id,t.product_id,t.chan_user_id,t.order_type,t.outer_order_id,t.amount,DATE_FORMAT(t.create_at,'%Y-%m-%d %H:%i:%s')) FROM order_t t JOIN verification_order v ON t.`chan_id` = ?1 AND t.`outer_order_id` = v.`order_id` WHERE CONCAT_WS('|',t.chan_id,t.chan_user_id,t.product_id,t.order_type,t.amount,DATE_FORMAT( t.create_at,'%Y-%m-%d %H:%i:%s')) != CONCAT_WS('|',v.chan_id,v.chan_user_id,v.product_id,v.order_type,v.amount,DATE_FORMAT( v.create_at,'%Y-%m-%d %H:%i:%s')) AND t.create_at >= ?2 AND t.create_at < ?3",nativeQuery = true)
        //@Query(value = "SELECT t.order_id,t.chan_id,t.chan_user_id,t.product_id,t.outer_order_id,t.amount,DATE_FORMAT(t.create_at,'%Y-%m-%d %H:%i:%s') FROM order_t t JOIN verification_order v on t.chan_id = ?1 AND t.outer_order_id = v.order_id WHERE CONCAT_WS('|', t.chan_id,t.chan_user_id,t.product_id,t.order_type,t.amount,DATE_FORMAT(t.create_at,'%Y-%m-%d %H:%i:%s')) != CONCAT_WS('|', v.chan_id,v.chan_user_id,v.product_id,v.order_type,v.amount,DATE_FORMAT(v.create_at,'%Y-%m-%d %H:%i:%s')) AND create_at >= ?2 AND create_at <= ?3;\n",nativeQuery = true)
    List<String> queryDifferentOrders(String chanId, Date start, Date end);
}

entity类
在这里插入图片描述
order

package com.imooc.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;

import javax.persistence.Entity;
import javax.persistence.Id;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;

/**
 * 订单
 */
@Entity(name = "order_t")
public class Order implements Serializable {
    @Id
    private String orderId;

    //渠道id
    private String chanId;

    private String chanUserId;

    /**
     * @see com.imooc.entity.enums.OrderType
     */
    private String orderType;

    private String productId;

    private BigDecimal amount;

    private String outerOrderId;

    /**
     * @see com.imooc.entity.enums.OrderStatus
     */
    private String orderStatus;

    private String memo;

    @JsonFormat(pattern = "YYYY-MM-DD HH:mm:ss")
    private Date createAt;

    @JsonFormat(pattern = "YYYY-MM-DD HH:mm:ss")
    private Date updateAt;

    @Override
    public String toString() {
        return ReflectionToStringBuilder.toString(this);
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getChanId() {
        return chanId;
    }

    public void setChanId(String chanId) {
        this.chanId = chanId;
    }

    public String getChanUserId() {
        return chanUserId;
    }

    public void setChanUserId(String chanUserId) {
        this.chanUserId = chanUserId;
    }

    public String getOrderType() {
        return orderType;
    }

    public void setOrderType(String orderType) {
        this.orderType = orderType;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public BigDecimal getAmount() {
        return amount;
    }

    public void setAmount(BigDecimal amount) {
        this.amount = amount;
    }

    public String getOuterOrderId() {
        return outerOrderId;
    }

    public void setOuterOrderId(String outerOrderId) {
        this.outerOrderId = outerOrderId;
    }

    public String getOrderStatus() {
        return orderStatus;
    }

    public void setOrderStatus(String orderStatus) {
        this.orderStatus = orderStatus;
    }

    public String getMemo() {
        return memo;
    }

    public void setMemo(String memo) {
        this.memo = memo;
    }

    public Date getCreateAt() {
        return createAt;
    }

    public void setCreateAt(Date createAt) {
        this.createAt = createAt;
    }

    public Date getUpdateAt() {
        return updateAt;
    }

    public void setUpdateAt(Date updateAt) {
        this.updateAt = updateAt;
    }
}

VerificationOrder

package com.imooc.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;

import javax.persistence.Entity;
import javax.persistence.Id;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;

/**
 * 订单
 */
@Entity(name = "verification_order")
public class VerificationOrder implements Serializable {
    @Id
    private String orderId;

    //渠道id
    private String chanId;

    private String chanUserId;

    /**
     * @see com.imooc.entity.enums.OrderType
     */
    private String orderType;

    private String productId;

    private BigDecimal amount;

    private String outerOrderId;


    @JsonFormat(pattern = "YYYY-MM-DD HH:mm:ss")
    private Date createAt;

    @Override
    public String toString() {
        return "VerificationOrder{" +
                "orderId='" + orderId + '\'' +
                ", chanId='" + chanId + '\'' +
                ", chanUserId='" + chanUserId + '\'' +
                ", orderType='" + orderType + '\'' +
                ", productId='" + productId + '\'' +
                ", amount=" + amount +
                ", outerOrderId='" + outerOrderId + '\'' +
                ", createAt=" + createAt +
                '}';
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getChanId() {
        return chanId;
    }

    public void setChanId(String chanId) {
        this.chanId = chanId;
    }

    public String getChanUserId() {
        return chanUserId;
    }

    public void setChanUserId(String chanUserId) {
        this.chanUserId = chanUserId;
    }

    public String getOrderType() {
        return orderType;
    }

    public void setOrderType(String orderType) {
        this.orderType = orderType;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public BigDecimal getAmount() {
        return amount;
    }

    public void setAmount(BigDecimal amount) {
        this.amount = amount;
    }

    public String getOuterOrderId() {
        return outerOrderId;
    }

    public void setOuterOrderId(String outerOrderId) {
        this.outerOrderId = outerOrderId;
    }

    public Date getCreateAt() {
        return createAt;
    }

    public void setCreateAt(Date createAt) {
        this.createAt = createAt;
    }
}

测试类

在这里插入图片描述

package com.imooc.seller;

import com.imooc.entity.DifferentOrder;
import com.imooc.seller.repositories.OrderRepository;
import com.imooc.seller.repositoriesbackup.DifferentOrderRepository;
import com.imooc.seller.repositoriesbackup.VerifyRepository;
import com.imooc.seller.service.VerifyService;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.MethodSorters;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.File;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * 对账测试
 */
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class VerifyTest {
 
    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private VerifyRepository verifyRepository;
  
    @Test
    public void queryOrder(){
  // 月份减一， 2018.12.31 ---2018.11.31
        Date day = new GregorianCalendar(2018,11,31).getTime();
        Date start = getStartOfDay(day);
        Date end = add24Hours(start);
        System.out.println(orderRepository.queryVerificationOrders("10001", start, end));
        System.out.println(verifyRepository.queryVerificationOrders("10001", start, end));
    }
    private Date add24Hours(Date start) {
        return new Date(start.getTime() + 1000 * 60 *60 *24);
    }

    private static DateFormat DAY_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
    private Date getStartOfDay(Date day) {
        String start_str = DAY_FORMAT.format(day);
        Date start = null;
        try {
            start = DAY_FORMAT.parse(start_str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return start;
    }
}

数据库文件：

在这里插入图片描述

在这里插入图片描述

结果：
在这里插入图片描述

Hibernate: SELECT CONCAT_WS(’|’, order_id,outer_order_id,chan_id,chan_user_id,product_id,order_type,amount,DATE_FORMAT( create_at,’%Y-%m-%d %H:%i:%s’)) FROM order_t WHERE order_status = ‘success’ AND chan_id = ? AND create_at >= ? AND create_at < ?
[14ef49d1d3f04851bdb6d0ca62f96790|000003|10001|001|002|APPLY|100.000|2018-12-31 01:15:48, 169c5ac94c594e2b834a30db2bbd4f3d|000004|10001|002|002|APPLY|100.000|2018-12-31 23:15:48]
Hibernate: SELECT CONCAT_WS(’|’, order_id,outer_order_id,chan_id,chan_user_id,product_id,order_type,amount,DATE_FORMAT( create_at,’%Y-%m-%d %H:%i:%s’)) FROM order_t WHERE order_status = ‘success’ AND chan_id = ? AND create_at >= ? AND create_at < ?
[0000088|000003|10001|001|002|APPLY|100.000|2018-12-31 01:15:48, 0000099|000004|10001|002|002|APPLY|100.000|2018-12-31 23:15:48]

有兴趣可以试一下，哈哈哈。

RLiBin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于多源数据融合的Java代码知识图谱构建方法研究.pdf
06-27
基于多源数据融合的Java代码知识图谱构建方法研究.pdf
Spring Boot Jpa 配置多个数据源，并读取其中一个表的具体数据
u011441473的专栏
01-18 4780
总体简介： Spring Boot Jpa配置多个数据源（此次两个mysql数据库），访问其中一个库 alime_counsel_assign_log下的assign_data_backflow表，实现查询某个id的数据 一、整体项目目录： 二、数据库配置及数据源初始化 1）、main/resources目录下application.yml配置文件配置数据库相关信息： 定义了 项目的各种配置文件，包括多个数据源的链接信息 #1.内容格式比较： .properties文件，通..
多源信息处理
weixin_45405408的博客
05-03 1513
1.前提： 1.信号、信息、消息 消息：指的是信号要传递的内容，是本质。 信号：是消息传递的形式，比如电信号、光信号等，是载体。 信息：是传达给给人的消息，能消除受信者某些不确定性。 2.信息融合就是一种多层次、多方面的处理过程，包括对多源数据进行检测、相关、组合和估计，从而提高状态和身份估计的精度。 3.多源信息融合，主要是指利用计算机进行多源信息处理，从而得到可综合利用信息的理论和方法。其关键问题就是提出一些理论和方法，对具有相似或不同特征模式的多源信息进行处理，以获得具有相关和集成特性的融合信息。研究
多数据源处理
十年磨一剑，沉淀……
01-20 1087
文章目录预备知识-ThreadLocal关键抽象类-AbstractRoutingDataSource逻辑思路实现多数据源关于事务使用经验 预备知识-ThreadLocal ThreadLocal是线程局部变量，所谓的线程局部变量，就是仅仅只能被本线程访问，不能在线程之间进行共享访问的变量。 关键抽象类-AbstractRoutingDataSource 官方注释如下： Abstract {@...
一文了解SpringBoot 自动化配置
学海无涯，行者无疆
12-19 534
前面说过，自动化配置实现了组件的“自治”，由组件自行管理配置项，以及依赖的其他组件、资源等。当多个组件进行拼装与整合时，则面临一个新的挑战，不同组件配置项与依赖项，可能会重复，不需要也不应该重复加载，并且还可能存在冲突，这问题如何解决呢？同时，还有另外一个重要意义，就是实现了组件的“自治”，即组件的配置选项以及依赖的其他组件、资源等，由其自行管理，进而才能实现“积木化”的组件拼装与整合。其他不常用条件注解，仅做了解，某些特定场景下还是有大作用，例如判断目标平台的java版本。
多源数据分析处理平台成金融科技“新利器”
商业云的博客
12-04 1050
我国金融科技正蓬勃发展，证券机构正处于一个前所未有的新时期。大数据、人工智能、云计算等技术为金融业的转型提供了充分的动能，也考验着证券机构的业务管理与服务响应能力。 据某权威机构的调研显示，认为自身数据价值挖掘能力欠缺、数据孤岛较为严重的金融企业占比逾55%。究其数据治理难点痛点，主要体现在以下几个方面：一、而数据投入较大，却未沉淀为资产；二、没有建立以人为本的过程管理体系，实现系统对人赋能；三、缺乏实现灵活数据接续与功能无缝对接的多源数据分析处理平台。 以某证券企业为例，客户账户数据、交易数据、产品与服
多元数据时代，如何破解数据流转难题？
m0_54979897的博客
04-25 243
在数字化转型的推动下，随着数据量的不断增多，数据的整体通用性和管理成本大大增加。针对传统数据仓库管理存在的问题，HashData采用湖仓一体架构，能够实现数据仓库和数据湖的数据无缝打通和自由流动，减少重复建设，最大化降低数据流转和迁移成本。
springboot（五、多源数据库【静态】）
zs_is_me的博客
01-05 1434
有时候项目需要访问多个数据库，就需要搭建多源数据库，这里先搭建静态的，就是一个数据库，一个dao层，一个DataSource 一个sqlsessionfactory 1、主要的架构呈现下面这样，一个数据库一个dao层，同时一个mapper   另外 我单独写出 com.example.exam1包下面的东西 2、application.properties 3、DataSou
Springboot+mybatis+mysql+注解+AOP配置多源数据库
Oldsong的博客
08-28 237
Springboot+mybatis+mysql+注解+AOP配置多源数据库 1.创建springboot项目 2.向pom.xml导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <!--<version>2.5.4</versi
基于边缘计算的低压配电网多源数据处理与融合技术研究.pdf
08-15
#资源达人分享计划#
CGIS多源数据处理研究.pdf
08-15
#资源达人分享计划#
面向生产管控的多源数据处理技术
05-06
为了解决流程型生产车间数据种类多、数据质量参差不齐影响生产管控的问题, 提出了面向多源数据的数据分类处理技术, 采用数据分类与滑动窗口相结合的方式进行数据处理. 首先, 根据生产数据特点建立数据模型, 然后进行...
SD-6000多源数据处理方法.pdf
08-15
#资源达人分享计划#
城市地理信息多源数据处理研究.pdf
08-15
#资源达人分享计划#
Line 14: Char 22: runtime error: signed integer overflow: 1000000000 * 9 cannot be represented
热门推荐
RLiBin的博客
06-29 2万+
Line 14: Char 22: runtime error: signed integer overflow: 1000000000 * 9 cannot be represented in type ‘int’ (solution.cpp) 第14行：char 22:运行时错误：有符号整数溢出：1000000000*9不能用类型“int”（solution.cpp）表示 也就是说 int 溢...
7种次序的重写new comparator（）比较器
RLiBin的博客
09-01 1万+
import java.util.*; /** * */ public class Main { public static class Node{ private int num; private String val; public Node(int num, String val){ this.n...
JPA-style positional param was not an integral ordinal; nested exception is java.lang.IllegalArgumen
RLiBin的博客
08-10 1513
在用jpa nativequery语句中，用spring junit测试发现报错：JPA-style positional param was not an integral ordinal; nested exception is java.lang.IllegalArgumen 多是sql之间的空格问题，或者sql拼接问题，还有可能是sql语句后面不能有分号。 @Query(value = ...
慕课网 《轻松愉快之玩转SpringData》学习总结1
RLiBin的博客
05-05 982
时间：2019年05月05日星期日 说明：本文内容均来自慕课网。@慕课网：http://www.imooc.com 部分参 https://segmentfault.com/a/1190000009211986 仅个人学习总结。如产生异议，请联系[email protected]。 第一章：课程介绍 Spring Data 概览 什么是Spring Data 主旨：provide a fam...
ArrayLIst LinkedList list.toArray() , list.addAll();
RLiBin的博客
09-01 589
** list.toArray() , list.addAll(); ** import java.util.ArrayList; import java.util.Arrays; /** * */ public class Main { public static class Node{ private int num; private Strin...
大模型的多源异构数据处理技术
最新发布
01-06
大模型的多源异构数据处理技术主要包括数据集成、数据清洗与转换以及数据降维等关键技术。 1. 数据集成：数据集成是整合来自多个数据源的数据，屏蔽数据之间类型和结构上的差异，实现对数据的统一存储、管理和分析...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值