2021-10-20 springboot、sharding-jdbc、jpa、bootstrap.yml、postgre 实现分表

springboot、sharding-jdbc、jpa、bootstrap.yml、postgre 实现分表

• sharding-jdbc 使用YAML配置
• • 首先调通jpa、项目结构如下
  • pom引入包
  • bootstrap设置
  • 文件代码
  • 注意事项
  • • 使用sharding-jdbc，在启动项目后需要手动删除jpa创建的表。并手动创建按照设定逻辑分出的表。（10/21更新，不用删除jpa启动建表也能启动，不受影响，但必须保证序列生效）

sharding-jdbc 使用YAML配置

！！！注意 本文仅为一个测试demo，为调通分表方便，项目命名并未按照驼峰式规则。

首先调通jpa、项目结构如下

springboot+jpa项目调通启动

pom引入包

  
            io.shardingsphere
            sharding-jdbc-spring-boot-starter
            3.0.0
        
        
            com.alibaba
            druid
            1.1.21
  

bootstrap设置

部分bootstrap设置如下（未包含所有设置项）

server:
  port: 18501
spring:
	application:
    	name: sharding_test
    	dbname: test_sharding_2
    server:
    # ip: 192.168....
  jpa:
    show-sql: true
    database: postgresql
    properties:
      hibernate:
        hbm2ddl:
          auto: update #none 设置为updata jpa自动创建表，后续需要删除原表
sharding:
  jdbc:
    datasource:
      names: ds
      ds:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: org.postgresql.Driver
        url: jdbc:postgresql://${spring.server.ip}:5432/${spring.application.dbname}
        username: admin
        password: 123456
    config:
      sharding:
        tables:
          t_order:
            actual-data-nodes: ds.t_order_$->{0..1}
#            local-table: t_order_
            table-strategy:
              inline:
                sharding-column: other_id
                algorithm-expression: t_order_$->{ other_id % 2}
#            keyGenerator:
#              column: id
#              type: UUID

props:
  sql.show: true

文件代码

controller

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Map;


@RestController
@RequestMapping("/demo")
public class TOrderController {

    @Autowired
    private TOrderService tOrderService;

    @GetMapping
    public Map getList() {
        System.out.println(tOrderService.getAll());
        return null;
    }

    @PostMapping
    public void add(@RequestBody TOrderEntity tOrderEntity) {
        tOrderService.save(tOrderEntity);
    }

    @PutMapping
    public void update(@RequestBody TOrderEntity tOrderEntity) {
        tOrderService.save(tOrderEntity);
    }

    @DeleteMapping
    public void update(Long name){
        tOrderService.delete(name);}
}

entity

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


@Entity
@Data
@Table(name = "t_order")
public class TOrderEntity implements Serializable {

    @Id
    @Column(name = "order_id")
    // 此处不设置主键规则，程序启动后需要删除该表
    // 并设置分表后的新表的主键规则，需要程序启动后通过sql语句创建一个序列
    // 将所有分表设置为同一序列
//    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "other_id")
    private Long otherId;
}

repository

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;


@Repository
public interface TOrderRepository extends JpaRepository {
}

service

import java.util.List;


public interface TOrderService {

    void save(TOrderEntity tOrderEntity);

    void update(TOrderEntity tOrderEntity);

    void delete(Long id);

    List getAll();

}

serviceImpl

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;


@Service
public class TOrderServiceImpl implements TOrderService {

    @Autowired
    TOrderRepository tOrderRepository;
    @Override
    public void save(TOrderEntity tOrderEntity) {
        tOrderRepository.save(tOrderEntity);
    }

    @Override
    public void update(TOrderEntity tOrderEntity) {
        tOrderRepository.save(tOrderEntity);
    }

    @Override
    public void delete(Long id) {
        tOrderRepository.deleteById(id);
    }

    @Override
    public List getAll() {
        return tOrderRepository.findAll();
    }
}

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;


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

注意事项 使用sharding-jdbc，在启动项目后需要手动删除jpa创建的表。并手动创建按照设定逻辑分出的表。（10/21更新，不用删除jpa启动建表也能启动，不受影响，但必须保证序列生效）

创建表sql（这里使用复制表结构的sql）
sql1 复制jpa自动建表的表结构
sql3 设定所有表使用某同一序列
sq2 为数据库设定一个序列
其中originalTableName 对应的value 在bootstrap 中设置

    @Modifying
    @Transactional(rollbackFor = Exception.class)
    public Boolean createTableMin(String tableName) {
        @Value("${table.name}")
        private String originalTableName;
        String sql = "create  table " + tableName + " as select * from " + originalTableName  ;

//
//        String sql2 = "CREATE SEQUENCE "public". "序列名" " +
//                "INCREMENT 1n" +
//                "START 1n" +
//                "MINVALUE 1n" +
//                "MAXVALUE 99999999n" +
//                "CACHE 1;";
//
//
        String sql3 = "alter table " +
                tableName +
                " alter column id set default nextval('${序列名}');";
        try {
            Query nativeQuery = entityManager.createNativeQuery(sql);
            nativeQuery.executeUpdate();
//            nativeQuery = entityManager.createNativeQuery(sql2);
//            nativeQuery.executeUpdate();
            nativeQuery = entityManager.createNativeQuery(sql3);
            nativeQuery.executeUpdate();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }