java复制代码public interface Cook {
	
	/**
	 * 开火
	 */
	String open();
  /**
	 * 炒菜
	 */
  String cooking();
  /**
	 * 关火
	 */
  String close();
}

java复制代码/**
 * service接口 实现类
 * 炒西红柿
 */
@Service
public class CookTomato implements Cook {
  @override
	public String open() {
		return "炒西红柿前打开油烟机并开火";
	}
  @override
  public String cooking() {
		return "炒西红柿中~";
	}
  @override
  public String close() {
		return "炒西红柿后关闭油烟机并关火";
	}
}

java复制代码/**
 * controller层
 */
@RestController
@RequestMapping("/cook")
public class CookController {
 
	@Resource
	private Cook cook;
	
	@RequestMapping("/open")
	public String open() {
		return cook.open();
	}
  
  @RequestMapping("/cooking")
	public String cooking() {
		return cook.cooking();
	}
  
  @RequestMapping("/close")
	public String close() {
		return cook.close();
	}
}

java复制代码/**
 * service接口 实现类
 * 炒土豆
 */
@Service
public class CookPatato implements Cook {
  @override
	public String open() {
		return "炒土豆丝前打开油烟机并开火";
	}
  @override
  public String cooking() {
		return "炒土豆丝中~";
	}
  @override
  public String close() {
		return "炒土豆丝后关闭油烟机并关火";
	}
}

bash复制代码2021-10-24 10:24:10.662  WARN 5592 --- [  restartedMain] ConfigServletWebServerApplicationContext : Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'CookController': Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.janeroad.annotation.service.Cook' available: expected single matching bean but found 2: CookTomato,CookPatato

java复制代码@Resource(name="cookTomato")
	private Cook cook;

java复制代码@Resource
@Qualifier("cookTomato")
	private Cook cook;

bash复制代码Description:
 
Field cook in com.janeroad.annotation.controller.CookController required a single bean, but 2 were found:
	- cookTomato: defined in file [此处省略路径名]
	- cookPatato: defined in file [此处省略路径名]
 
 
Action:
 
Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

java复制代码/**
 * service接口 实现类
 * 炒西红柿
 */
@Service
@Primary
public class CookTomato implements Cook {
  @override
	public String open() {
		return "炒西红柿前打开油烟机并开火";
	}
  @override
  public String cooking() {
		return "炒西红柿中~";
	}
  @override
  public String close() {
		return "炒西红柿后关闭油烟机并关火";
	}
}

makefile复制代码D:\Program Files\Nox\bin<每个人下载的地方是不一样的，这个是我的>

makefile复制代码C:\Users\我是王修呀>adb devices
List of devices attached
127.0.0.1:62001 device

arduino复制代码C:\Users\我是王修呀>adb connect 127.0.0.1:62001
already connected to 127.0.0.1:62001

复制代码夜神 127.0.0.1:62001

Mumu 127.0.0.1:7555

makefile复制代码C:\Users\我是王修呀>adb install C:\Users\zuoyebang.apk

Success

makefile复制代码C:\Users\我是王修呀>adb -s 127.0.0.1:62001 install  C:\Users\zuoyebang.apk
Success

makefile复制代码R11 Plus:/ # exit

C:\Users\我是王修呀>

makefile复制代码C:\Users\我是王修呀>adb uninstall com.baidu.homework
Success

makefile复制代码C:\Users\我是王修呀>adb uninstall com.baidu.homework
Success

makefile复制代码C:\Users\我是王修呀>adb uninstall com.baidu.homework
Success

kotlin复制代码
adb pull   /data/data/com.insthub.ecmobile/shared_prefs/userInfo.xml E:\remotefiles 
adb  pull  远程地址   本地地址 从模拟器获取数据

adb push  本地地址  远程地址  推送数据
adb push   E:\remotefiles  /data/data/com.insthub.ecmobile/shared_prefs/userInfo.xml

java复制代码import java.text.MessageFormat;

public class Test {

	public static void main(String[] args) {
		// 我只是想要￥，所以这里必须这么写
		Integer $1024 = 1024;
		System.out.println(MessageFormat.format("{0}的2进制表示为：{1}", $1024.toString(), Integer.toBinaryString($1024)));
	}
}

java复制代码import java.text.MessageFormat;

public class Test {

	public static void main(String[] args) {
		// 我只是想要￥，所以这里必须这么写
		Integer $powerOf2 = 2;
		final int maxDaysPerYear = 366;
		while ($powerOf2 * 2 < maxDaysPerYear) {
			$powerOf2 *= 2;
		}
		System.out.println(MessageFormat.format("2的最大幂中小于365的值是：{0}", $powerOf2.toString()));
	}
}

c复制代码typedef struct _object {
    _PyObject_HEAD_EXTRA
    Py_ssize_t ob_refcnt;
    struct _typeoject *ob_type;
} PyObject;

css复制代码    Object-specific allocators
    _____   ______   ______       ________
   [ int ] [ dict ] [ list ] ... [ string ]       Python core         |
+3 | <----- Object-specific memory -----> | <-- Non-object memory --> |
    _______________________________       |                           |
   [   Python's object allocator   ]      |                           |
+2 | ####### Object memory ####### | <------ Internal buffers ------> |
    ______________________________________________________________    |
   [          Python's raw memory allocator (PyMem_ API)          ]   |
+1 | <----- Python memory (under PyMem manager's control) ------> |   |
    __________________________________________________________________
   [    Underlying general-purpose allocator (ex: C library malloc)   ]
 0 | <------ Virtual memory allocated for the python process -------> |
   =========================================================================
    _______________________________________________________________________
   [                OS-specific Virtual Memory Manager (VMM)               ]
-1 | <--- Kernel dynamic storage allocation & management (page-based) ---> |
    __________________________________   __________________________________
   [                                  ] [                                  ]
-2 | <-- Physical memory: ROM/RAM --> | | <-- Secondary storage (swap) --> |

c复制代码PyDict_New()             ----3层
  PyObject_GC_New()      ----2层
  PyObject_Malloc()      ----2层
    new_arena()          ----1层
      malloc()           ----0层

Python复制代码for x in range(100):
  print(x)

c复制代码#ifndef PyDict_MAXFREELIST
#define PyDict_MAXFREELIST 80
#endif
static PyDictObject *free_list[PyDict_MAXFREELIST];
static int numfree = 0;

c复制代码#define Py_INCREF(op) (                  \
    ((PyObject*)(op))->ob_refcnt++)

c复制代码#define Py_DECREF(op)                          \
    if (--((PyObject*)(op))->ob_refcnt != 0)        \
        _Py_CHECK_REFCNT(op)                  \
     else                                \
        _Py_Dealloc((PyObject*)(op))


# define _Py_Dealloc(op) (              \
        (*Py_TYPE(op)->tp_dealloc)((PyObject*)(op)))

c复制代码static void
tupledealloc(register PyTupleObject *op)
{
    register Py_ssize_t i;
    register Py_ssize_t len = Py_Size(op);
    
    if (len > 0) {
        i = len;
        /* 将元组内的元素进行减量 */
        while(--i >= 0)
            Py_XDECREF(op->ob_item[i]);
    }
    /* 释放元组对象 */
    Py_TYPE(op)->tp_free((PyObject *)op);
    
    Py_TRASHCAN_SAFE_END(OP);
}

c复制代码void
PyObject_GC_Del(void *op)
{
    PyGC_Head *g = AS_GC(op);
    /* ... */
    Pyobject_FREE(g)
}

c复制代码Py_DECREF
  _Py_Dealloc              ———— 减量操作
    tupledealloc
      PyObject_GC_Del      ———— 元组释放处理
        PyObject_FREE
          PyObject_Free    ———— 释放内存

c复制代码PyObject *dict = PyDict_New();
/* 进行一些操作， 结束后*/
Py_DECREF(dict);
dict = NULL;

c复制代码PyObject *
PyTuple_GetItem(register PyObject *op, register Py_ssize_t i)
{
    /*检查操作*/
    return ((PyTupleObject *)op) -> ob_item[i]
}

c复制代码PyObject *tuple, *dict;

tuple = PyTuple_New(3);
dict = PyDict_New();    /*用所有权返回给了dict*/
PyTuple_SetItem(tuple, 0, dict);    /*引用所有权被tuple占据了*/
dict = NULL;

c复制代码tyepdef union _gc_head {
    struct {
        union _ge_head *gc_next; /*用于双向链表*/
        union _gc_head *gc_prev; /*用于双向链表*/
        Py_ssize_t gc_refs;      /*用于复制计数*/
    } gc;
    long double dummy;
} PyGC_Head;

c复制代码PyObject *
PyDict_New(void)
{
    regiseter PyDictObject *mp;
    /*生成对象的操作*/
    _PyObject_GC_TRACK(mp);
    return (PyObject *)mp;

}

c复制代码#define _PyObject_GC_TRACK(o) do { \
    PyGC_Head *g = _Py_AS_GC(o); \
    g->gc.gc_refs = _PyGC_REFS_REACHABLE;  \
    g->gc.gc_next = _PyGC_generation0; \
    g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
    g->gc.gc_prev ->gc.gc_next = g;  \
    _PyGC_generation0->gc.gc_prev = g; \
    } while (0);

c复制代码struct gc_generation {
    PyGC_Head head;   /* 头指正 */
    int threshold;    /* 开始GC的阈值 */
    int count;        /* 改代的对象数 */
}

# define GEN_HEAD(n) (&generations[n].head)

PyGC_Head *_PyGC_generation0 = GEN_HEAD(0); /* 0代的容器对象 */

c复制代码static void
move_finalizers(PyGC_Head *unreachable, PyGC_Head *finalizers)
{
    PyGC_Head *gc;
    PyGC_Head *next;
    
    for (gc = unreachable->gc.gc_next; gc != unreachable; gc = next) {
        PyObject *op = FROM_GC(gc);
        next = gc->gc.gc_next;
        if (has_finalizer(op)) {
            gc_list_move(gc, finalizers);
            gc->gc.gc_refs = GC_REACHABLE;
        }
    }
}

Python复制代码import gc
gc.grabage

java复制代码List<Map<String,String>> list = restTemplate.getForObject(url, List.class,"first param","two param");

java复制代码Map<String,String> map = new HashMap<>;
map.put("Frist","first param");
map.put("Two","two param");
List<Map<String,String>> list = restTemplate.getForObject(url, List.class, map);

java复制代码ResponseEntity<List> entity = restTemplate.getForEntity(url, List.class,"first param","two param");
System.out.println(entity.getBody());

java复制代码Map<String,String> map = new HashMap<>;
map.put("Frist","first param");
map.put("Two","two param");
ResponseEntity<List> entity = restTemplate.getForEntity(url, List.class, map);
System.out.println(entity.getBody());

conf复制代码systemLog:
   destination: file
   # 下面地址都不能使用\反斜杠, 而要使用斜杠/
   # 修改为日志log目录地址
   path: "D:/mongodb-win32-x86_64-2008plus-ssl-4.0.12/log/mongod.log"
   logAppend: true
net:
   port: 27017
   bindIp: "127.0.0.1"
storage:
   # 修改成为自己数据库db地址
   dbPath: "D:/mongodb-win32-x86_64-2008plus-ssl-4.0.12/data/db"
   journal:
      enabled: true

java复制代码package com.demo.spring.mongoDB;

import com.mongodb.BasicDBList;
import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import org.bson.Document;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import sun.net.www.content.audio.basic;

/**
 * @Description:
 * @Author: cf
 * @Date: 2021/10/9
 */
public class TestDemo {

    private MongoClientURI mongoClientURI;
    private MongoClient mongoClient;

    @Before
    public void init() {
        // 无密码模式
//        mongoClientURI = new MongoClientURI("mongodb://localhost:27017/mycol");
        // 有密码模式
        mongoClientURI = new MongoClientURI("mongodb://cf:123456@localhost:27017/mycol");
        mongoClient = new MongoClient(mongoClientURI);
        System.out.println("mongoClient 对象生成");
//        // 连接到 mongodb 服务
//        mongoClient = new MongoClient("localhost", 27017);

    }

    @After
    public void drop() {
        mongoClient.close();
        System.out.println("mongoClient 对象销毁");
    }

    // 正则查询
    @Test
    public void getByPattern() {
        // 连接到 mongodb 服务
//        MongoClient mongoClient = new MongoClient("localhost", 27017);
        MongoDatabase articledb = mongoClient.getDatabase("mycol");
        MongoCollection<Document> users = articledb.getCollection("test");

        /**
         * 左匹配：Pattern.compile("^王.*$", Pattern.CASE_INSENSITIVE);
         * 右匹配：Pattern.compile("^.*王$", Pattern.CASE_INSENSITIVE);
         * 完全匹配：Pattern.compile("^王$", Pattern.CASE_INSENSITIVE);
         * 模糊匹配：Pattern.compile("^.*王.*$", Pattern.CASE_INSENSITIVE);
         */
        // 正则查询：查询所有以王开头的用户姓名
        Pattern pattern = Pattern.compile("^王.*$", Pattern.CASE_INSENSITIVE);
        BasicDBObject searchCond = new BasicDBObject("description",
                new BasicDBObject("$regex", pattern));
        MongoCursor<Document> cursor = users.find(searchCond).iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    // 包含查询
    @Test
    public void getByInOrNin() {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        MongoDatabase articledb = mongoClient.getDatabase("mycol");
        MongoCollection<Document> users = articledb.getCollection("test");

        // 包含查询：查询likes = 2、3、10的信息
        List<Integer> searchList = new ArrayList<Integer>();
        searchList.add(2);
        searchList.add(3);
        searchList.add(10);
        BasicDBObject searchCond = new BasicDBObject("likes",
                new BasicDBObject("$in", searchList));
        MongoCursor<Document> cursor = users.find(searchCond).iterator();

        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    // 统计查询
    @Test
    public void getByCount() {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        MongoDatabase articledb = mongoClient.getDatabase("mycol");
        MongoCollection<Document> users = articledb.getCollection("test");

        // 统计查询：查看密码为likes的一共有多少人
        BasicDBObject filter = new BasicDBObject("likes", 2);
        long count = users.countDocuments(filter);
        System.out.println(count);
    }

    // 排序查询
    @Test
    public void getByOrder() {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        MongoDatabase articledb = mongoClient.getDatabase("mycol");
        MongoCollection<Document> users = articledb.getCollection("test");

        // 排序查询：排序规则：1（升序）、-1（降序）
        MongoCursor<Document> cursor = users.find().sort(new BasicDBObject("likes", 1)).iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    // 投影查询
    @Test
    public void getByProjection() {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        MongoDatabase articledb = mongoClient.getDatabase("mycol");
        MongoCollection<Document> users = articledb.getCollection("test");

        // 投影查询：只显示_id和指定字段信息   value值无意义
        MongoCursor<Document> cursor = users.find().projection(new BasicDBObject("likes", 1))
                .iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    // 分页查询
    @Test
    public void getByPage() {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        MongoDatabase articledb = mongoClient.getDatabase("mycol");
        MongoCollection<Document> users = articledb.getCollection("test");

        // 分页查询：跳过第一条，查询两条数据
        MongoCursor<Document> cursor = users.find().skip(1).limit(2).iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    // 类型查询
    @Test
    public void getByType() {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        MongoDatabase articledb = mongoClient.getDatabase("mycol");
        MongoCollection<Document> users = articledb.getCollection("test");

        // 类型查询：查询所有用户名是字符串类型的用户信息
        BasicDBObject searchCond = new BasicDBObject();
//        searchCond.append("likes", new BasicDBObject("$type", "string"));
        searchCond.append("likes", new BasicDBObject("$type", "int"));

        MongoCursor<Document> cursor = users.find(searchCond).iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    // 连接查询: OR查询
    @Test
    public void getByORCondition() {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        MongoDatabase articledb = mongoClient.getDatabase("mycol");
        MongoCollection<Document> users = articledb.getCollection("test");

        BasicDBList condList = new BasicDBList();
        condList.add(new BasicDBObject("likes", new BasicDBObject("$gt", 50)));
        condList.add(new BasicDBObject("likes", new BasicDBObject("$lt", 40)));

        // 条件查询：likes小于200大于50的用户信息
        BasicDBObject searchCond = new BasicDBObject();
        searchCond.put("$or", condList);
        MongoCursor<Document> cursor = users.find(searchCond).iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    // 连接查询: AND查询
    @Test
    public void getByANDCondition() {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        MongoDatabase articledb = mongoClient.getDatabase("mycol");
        MongoCollection<Document> users = articledb.getCollection("test");

        BasicDBList condList = new BasicDBList();
        condList.add(new BasicDBObject("likes", new BasicDBObject("$gt", 50)));
        condList.add(new BasicDBObject("likes", new BasicDBObject("$lt", 200)));

        // 条件查询：likes小于200大于50的用户信息
        BasicDBObject searchCond = new BasicDBObject();
        searchCond.put("$and", condList);
        MongoCursor<Document> cursor = users.find(searchCond).iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    // 条件查询    常见操作符：等于、$ne、$gte、$lte、$gt、$lt
    // TODO 等于怎么表示? 直接进行比较, 不用添加操作符(如下)
    @Test
    public void getByCondition() {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("localhost", 27017);

        // 如果存在articledb，返回articledb，如果不存在articledb，创建articledb
        MongoDatabase articledb = mongoClient.getDatabase("mycol");
        // 如果存在users，返回users，如果不存在，创建users
        MongoCollection<Document> users = articledb.getCollection("test");
        // 条件查询：查询likes不等于200的用户信息
        BasicDBObject searchCond = new BasicDBObject();

        // 常见操作符：等于、$ne、$gte、$lte、$gt、$lt
        searchCond.append("likes", new BasicDBObject("$ne", 200));

        // 等于
//        searchCond.append("likes", 100);
        MongoCursor<Document> cursor = users.find(searchCond).iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    // 删除文档, 符合条件的第一个/符合条件的所有文档
    @Test
    public void deleteDocument() {
        try {
            // 连接到 mongodb 服务
            MongoClient mongoClient = new MongoClient("localhost", 27017);

            // 连接到数据库
            MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
            System.out.println("Connect to database successfully");

            MongoCollection<Document> collection = mongoDatabase.getCollection("test");
            System.out.println("集合 test 选择成功");

            // deleteMany  删除多条
            // deleteOne   删除一条
            //删除符合条件的第一个文档
            collection.deleteOne(Filters.eq("likes", 200));
            //删除所有符合条件的文档
            collection.deleteMany(Filters.eq("likes", 200));
            //检索查看结果
            FindIterable<Document> findIterable = collection.find();
            MongoCursor<Document> mongoCursor = findIterable.iterator();
            while (mongoCursor.hasNext()) {
                System.out.println(mongoCursor.next());
            }

        } catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }
    }

    // 更新文档
    @Test
    public void updateDocument() {
        try {
            // 连接到 mongodb 服务
            MongoClient mongoClient = new MongoClient("localhost", 27017);

            // 连接到数据库
            MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
            System.out.println("Connect to database successfully");

            MongoCollection<Document> collection = mongoDatabase.getCollection("test");
            System.out.println("集合 test 选择成功");

            // 如果我们只想修改文档的某个字段请使用$set操作符修改，否则其它字段都会不见了
            // updateMany 修改所有符合条件的
            // updateOne  修改符合条件的一条
            //更新文档   将文档中likes=100的文档修改为likes=200
            collection.updateMany(
                    Filters.eq("likes", 100), new Document("$set", new Document("likes", 200)));
            //检索查看结果
            FindIterable<Document> findIterable = collection.find();
            MongoCursor<Document> mongoCursor = findIterable.iterator();
            while (mongoCursor.hasNext()) {
                System.out.println(mongoCursor.next());
            }

        } catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }
    }

    // 查询文档
    @Test
    public void getDocument() {
        try {
            // 连接到 mongodb 服务
            MongoClient mongoClient = new MongoClient("localhost", 27017);

            // 连接到数据库
            MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
            System.out.println("Connect to database successfully");

            MongoCollection<Document> collection = mongoDatabase.getCollection("test");
            System.out.println("集合 test 选择成功");

            //检索所有文档
            /**
             * 1. 获取迭代器FindIterable<Document>
             * 2. 获取游标MongoCursor<Document>
             * 3. 通过游标遍历检索出的文档集合
             * */
            FindIterable<Document> findIterable = collection.find();
            MongoCursor<Document> mongoCursor = findIterable.iterator();
            while (mongoCursor.hasNext()) {
                System.out.println(mongoCursor.next());
            }

        } catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }
    }

    // 插入文档$
    @Test
    public void insertDocument() {
        try {
            // 连接到 mongodb 服务
            MongoClient mongoClient = new MongoClient("localhost", 27017);

            // 连接到数据库
            MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
            System.out.println("Connect to database successfully");

            MongoCollection<Document> collection = mongoDatabase.getCollection("test");
            System.out.println("集合 test 选择成功");
            //插入文档
            /**
             * 1. 创建文档 org.bson.Document 参数为key-value的格式
             * 2. 创建文档集合List<Document>
             * 3. 将文档集合插入数据库集合中 mongoCollection.insertMany(List<Document>) 插入单个文档可以用 mongoCollection.insertOne(Document)
             * */
            Document document = new Document("title", "MongoDB").
                    append("description", "database").
                    append("likes", 100).
                    append("by", "Fly");
            List<Document> documents = new ArrayList<Document>();
            documents.add(document);
            collection.insertMany(documents);
            System.out.println("文档插入成功");
        } catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }
    }

    // 获取集合
    @Test
    public void getCollection() {
        try {
            // 连接到 mongodb 服务
            MongoClient mongoClient = new MongoClient("localhost", 27017);

            // 连接到数据库
            MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
            System.out.println("Connect to database successfully");

            MongoCollection<Document> collection = mongoDatabase.getCollection("test");
            System.out.println("集合 test 选择成功");
        } catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }
    }

    // 创建集合
    @Test
    public void createCollection() {
        try {
            // 连接到 mongodb 服务
            MongoClient mongoClient = new MongoClient("localhost", 27017);

            // 连接到数据库
            MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
            System.out.println("Connect to database successfully");
            mongoDatabase.createCollection("test");
            System.out.println("集合创建成功");

        } catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }
    }

    // 连接服务2
    @Test
    public void test2() {
        try {
            //连接到MongoDB服务 如果是远程连接可以替换“localhost”为服务器所在IP地址
            //ServerAddress()两个参数分别为 服务器地址 和 端口
            ServerAddress serverAddress = new ServerAddress("localhost", 27017);
            List<ServerAddress> addrs = new ArrayList<ServerAddress>();
            addrs.add(serverAddress);

            //MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码
            MongoCredential credential = MongoCredential
                    .createScramSha1Credential("username", "databaseName",
                            "password".toCharArray());
            List<MongoCredential> credentials = new ArrayList<MongoCredential>();
            credentials.add(credential);

            //通过连接认证获取MongoDB连接
            MongoClient mongoClient = new MongoClient(addrs, credentials);

            //连接到数据库
            MongoDatabase mongoDatabase = mongoClient.getDatabase("databaseName");
            System.out.println("Connect to database successfully");
        } catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }
    }

    // 连接服务1
    @Test
    public void test1() {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("localhost", 27017);

        // 连接到数据库
        MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
        System.out.println("Connect to database successfully");
    }

}

ini复制代码message C_DRAW{
   required int32  rewardType = 1;  // 抽奖类型 1单抽 2 10连抽
}
message S_DRAW{
   required int32  rewardType = 1;  // 抽奖类型 1单抽 2 10连抽
   required string  rewardContent = 2;  // 抽奖结果
   optional string  specialReward = 3;  // 比如十连抽送的奖励
}

typescript复制代码​
import javafx.util.Pair;
​
import java.util.*;
​
/**
 * 奖励池的配置
 * @author 香菜
 */
public class RewardPoolConfig {
    Map<Integer, ConfigPair> rewardConfigMap;
    public RewardPoolConfig config;
​
    public RewardPoolConfig() {
        readConfig();
    }
    private void readConfig() {
        //  TODO readFromSource();
        //  根据自己项目的不同进行
        rewardConfigMap = new HashMap<>();
        //  模拟下
        rewardConfigMap.put(1, new ConfigPair("A_1", "A_50#B_50#C_50#D_50#E_50#F_50#G_50#H_50"));
        rewardConfigMap.put(2, new ConfigPair("B_1", "A_50#B_50#C_50#D_50#E_50#F_50#G_50#H_50"));
    }
​
    public RewardPoolConfig getInstance() {
        if (config == null) {
            config = new RewardPoolConfig();
        }
        return config;
    }
​
    public Map<Integer, ConfigPair> getRewardConfigMap() {
        return rewardConfigMap;
    }
​
    /**
     * 单个奖励池的解析
     */
    static class ConfigPair {
        //  消耗的资源
        String cost;
        //  权重列表
        List<Pair<String, Integer>> weightList;
​
        public ConfigPair(String cost, String data) {
            this.cost = cost;
            String[] split = data.split("#");
            List<Pair<String, Integer>> tmpList = new ArrayList<>();
            for (String itemPair : split) {
                int i = itemPair.lastIndexOf("_");
                String reward = itemPair.substring(0, i);
                String weightStr = itemPair.substring(i + 1);
                tmpList.add(new Pair<>(reward, Integer.valueOf(weightStr)));
            }
            weightList = Collections.unmodifiableList(tmpList);
        }
​
        public List<Pair<String, Integer>> getWeightList() {
            return weightList;
        }
​
        public String getCost() {
            return cost;
        }
    }
​
    public static void main(String[] args) {
        ConfigPair a_1 = new ConfigPair("A_1", "A_50#B_50#C_50#D_50#E_50#F_50#G_50#H_50");
        System.out.println();
    }
}

java复制代码import com.google.common.collect.Lists;
import javafx.util.Pair;
​
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;
​
/**
* 权重随机
* @author 香菜
* @param <K>
* @param <V>
*/
public class WeightRandom<K, V extends Number> {
   private TreeMap<Double, K> weightMap = new TreeMap<>();
   public WeightRandom(List<Pair<K, V>> list) throws Exception {
       if (list == null || list.size() == 0) {
           throw new Exception("list is null");
       }
       for (Pair<K, V> pair : list) {
           if (pair.getValue().doubleValue() <= 0) {
               throw new Exception("weight is wrong");
           }
           double lastWeight = this.weightMap.size() == 0 ? 0 : this.weightMap.lastKey().doubleValue();//统一转为double
           this.weightMap.put(pair.getValue().doubleValue() + lastWeight, pair.getKey());//权重累加
       }
   }
​
   public K random() {
       double randomWeight = this.weightMap.lastKey() * Math.random();
       SortedMap<Double, K> tailMap = this.weightMap.tailMap(randomWeight, false);
       return this.weightMap.get(tailMap.firstKey());
   }
​
   public static void main(String[] args) throws Exception {
       List<Pair<String, Integer>> weighList = Lists.newArrayList();
       weighList.add(new Pair<>("AAA", 10));
       weighList.add(new Pair<>("BBB", 10));
       weighList.add(new Pair<>("CCC", 10));
       weighList.add(new Pair<>("DDD", 10));
       String random = new WeightRandom<>(weighList).random();
       System.out.println(random);
   }
​
}
4、调用逻辑
import javafx.util.Pair;
import java.util.List;
import java.util.Map;
​
/**
* 模拟抽奖
* @author 香菜
*/
public class Aain {
​
   public static void main(String[] args) throws Exception {
       int rewardType = 1;
       Map<Integer, RewardPoolConfig.ConfigPair> rewardConfigMap = RewardPoolConfig.getInstance().getRewardConfigMap();
       //1、检查客户端发送的抽奖类型是否合法，如果不是定义1 和 2 ，则报错，因为有人传递非法的数据。
       if (!rewardConfigMap.containsKey(rewardType)) {
           //  非法的抽奖类型
           return;
       }
       //2、检查对应抽奖类型的次数是否足够，如果次数不足则报错
       //  TODO checkPlayerData();
       RewardPoolConfig.ConfigPair configPair = rewardConfigMap.get(rewardType);
       //3、检查对应的抽奖类型需要的资源是否足够，如果资源不足则报错给客户端。
       String cost = configPair.getCost();
       //  TODO checkResource();
       //4、获取对应的抽奖类型的基础数据配置，检查下是否异常，异常则报错
       //  在最开始的时候检测了，这不忽略
       //5、执行对应的抽奖逻辑
       List<Pair<String, Integer>> weightList = configPair.getWeightList();
       String reward = new WeightRandom<>(weightList).random();
       //6、将抽取的资源加入到玩家身上
       //  TODO addResource(reward);
       //7、将抽取的资源组装成消息传递给客户端，进行页面展示。
       //  sendResultToClient(reward)
       System.out.println(reward);
   }
​
}

bash复制代码5.1 十连抽，只要改动抽奖循环就可以了

5.2 十连抽额外送，只要在基础数据配一下送的道具，最后加资源到玩家身上的时候直接加上

5.3 十连抽不重复，只要在抽完一次直接从池子里移除道具

5.4 免费次数抽完进行cd ,则直接记录玩家的抽取时间就可以了，下次判断时间间隔是否大于cd时间就可以了

xml复制代码<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>shardingsphere-jdbc-core</artifactId>
    <version>5.0.0-alpha</version>
</dependency>
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>3.4.1</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

java复制代码@Data
public class Order implements Serializable {

    private static final long serialVersionUID = 661434701950670670L;

    private long orderId;

    private int userId;

    private long addressId;

    private String status;
}

java复制代码public interface OrderRepository {

    void createTableIfNotExists() throws SQLException;

    Long insert(final Order order) throws SQLException;
}

public class OrderRepositoryImpl implements OrderRepository {

    private final DataSource dataSource;

    public OrderRepositoryImpl(final DataSource dataSource) {
        this.dataSource = dataSource;
    }
    @Override
    public void createTableIfNotExists() throws SQLException {
        String sql = "CREATE TABLE IF NOT EXISTS t_order (order_id BIGINT NOT NULL AUTO_INCREMENT, user_id INT NOT NULL, address_id BIGINT NOT NULL, status VARCHAR(50), PRIMARY KEY (order_id))";
        try (Connection connection = dataSource.getConnection();
             Statement statement = connection.createStatement()) {
            statement.executeUpdate(sql);
        }
    }
    @Override
    public Long insert(final Order order) throws SQLException {
        String sql = "INSERT INTO t_order (user_id, address_id, status) VALUES (?, ?, ?)";
        try (Connection connection = dataSource.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
            preparedStatement.setInt(1, order.getUserId());
            preparedStatement.setLong(2, order.getAddressId());
            preparedStatement.setString(3, order.getStatus());
            preparedStatement.executeUpdate();
            try (ResultSet resultSet = preparedStatement.getGeneratedKeys()) {
                if (resultSet.next()) {
                    order.setOrderId(resultSet.getLong(1));
                }
            }
        }
        return order.getOrderId();
    }
}

java复制代码public interface ExampleService {
    /**
     * 初始化表结构
     *
     * @throws SQLException SQL exception
     */
    void initEnvironment() throws SQLException;

    /**
     * 执行成功
     *
     * @throws SQLException SQL exception
     */
    void processSuccess() throws SQLException;
}

java复制代码public class OrderServiceImpl implements ExampleService {
    private final OrderRepository orderRepository;
    Random random=new Random();

    public OrderServiceImpl(final DataSource dataSource) {
        orderRepository=new OrderRepositoryImpl(dataSource);
    }

    @Override
    public void initEnvironment() throws SQLException {
        orderRepository.createTableIfNotExists();
    }

    @Override
    public void processSuccess() throws SQLException {
        System.out.println("-------------- Process Success Begin ---------------");
        List<Long> orderIds = insertData();
        System.out.println("-------------- Process Success Finish --------------");
    }
    private List<Long> insertData() throws SQLException {
        System.out.println("---------------------------- Insert Data ----------------------------");
        List<Long> result = new ArrayList<>(10);
        for (int i = 1; i <= 10; i++) {
            Order order = insertOrder(i);
            result.add(order.getOrderId());
        }
        return result;
    }
    private Order insertOrder(final int i) throws SQLException {
        Order order = new Order();
        order.setUserId(random.nextInt(10000));
        order.setAddressId(i);
        order.setStatus("INSERT_TEST");
        orderRepository.insert(order);
        return order;
    }
}

java复制代码public class DataSourceUtil {

    private static final String HOST = "192.168.221.128";

    private static final int PORT = 3306;

    private static final String USER_NAME = "root";

    private static final String PASSWORD = "123456";

    public static DataSource createDataSource(final String dataSourceName) {
        HikariDataSource result = new HikariDataSource();
        result.setDriverClassName("com.mysql.jdbc.Driver");
        result.setJdbcUrl(String.format("jdbc:mysql://%s:%s/%s?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8", HOST, PORT, dataSourceName));
        result.setUsername(USER_NAME);
        result.setPassword(PASSWORD);
        return result;
    }
}

java复制代码public class ShardingDatabasesAndTableConfiguration {
    //创建两个数据源
    private static Map<String,DataSource> createDataSourceMap(){
        Map<String, DataSource> dataSourceMap=new HashMap<>();
        dataSourceMap.put("ds0",DataSourceUtil.createDataSource("shard01"));
        dataSourceMap.put("ds1",DataSourceUtil.createDataSource("shard02"));
        return dataSourceMap;
    }

    private static ShardingRuleConfiguration createShardingRuleConfiguration(){
        ShardingRuleConfiguration configuration=new ShardingRuleConfiguration();
        configuration.getTables().add(getOrderTableRuleConfiguration());
//        configuration.getBindingTableGroups().add("t_order,t_order_item");
        //
        //
        /**
         * 设置数据库的分片规则
         * inline表示行表达式分片算法，它使用groovy的表达式，支持单分片键，比如 t_user_$->{uid%8} 表示t_user表根据u_id%8分成8张表
         */
        configuration.setDefaultDatabaseShardingStrategy(
                new StandardShardingStrategyConfiguration("user_id","inline"));
        /**
         * 设置表的分片规则
         */
        configuration.setDefaultTableShardingStrategy(new StandardShardingStrategyConfiguration("order_id","order_inline"));
        Properties props=new Properties();
        props.setProperty("algorithm-expression","ds${user_id%2}"); //表示根据user_id取模得到目标表
        /**
         * 定义具体的分片规则算法，用于提供分库分表的算法规则
         */
        configuration.getShardingAlgorithms().put("inline",new ShardingSphereAlgorithmConfiguration("INLINE",props));
        Properties properties=new Properties();
        properties.setProperty("algorithm-expression","t_order_${order_id%2}");
        configuration.getShardingAlgorithms().put("order_inline",new ShardingSphereAlgorithmConfiguration("INLINE",properties));
        configuration.getKeyGenerators().put("snowflake",new ShardingSphereAlgorithmConfiguration("SNOWFLAKE",getProperties()));
        return configuration;
    }
    private static Properties getProperties(){
        Properties properties=new Properties();
        properties.setProperty("worker-id","123");
        return properties;
    }
    //创建订单表的分片规则
    private static ShardingTableRuleConfiguration getOrderTableRuleConfiguration(){
        ShardingTableRuleConfiguration tableRule=new ShardingTableRuleConfiguration("t_order","ds${0..1}.t_order_${0..1}");
        tableRule.setKeyGenerateStrategy(new KeyGenerateStrategyConfiguration("order_id","snowflake"));
        return tableRule;
    }

    public static DataSource getDataSource() throws SQLException {
        return ShardingSphereDataSourceFactory.createDataSource(createDataSourceMap(), Collections.singleton(createShardingRuleConfiguration()),new Properties());
    }
}

java复制代码public class ExampleMain {
    public static void main(String[] args) throws SQLException {
        DataSource dataSource=ShardingDatabasesAndTableConfiguration.getDataSource();
        ExampleService exampleService=new OrderServiceImpl(dataSource);
        exampleService.initEnvironment();
        exampleService.processSuccess();
    }
}

xml复制代码<dependencies>    <dependency>        <groupId>org.springframework.boot</groupId>        <artifactId>spring-boot-starter-web</artifactId>    </dependency>    <dependency>        <groupId>mysql</groupId>        <artifactId>mysql-connector-java</artifactId>        <scope>runtime</scope>    </dependency>    <dependency>        <groupId>com.baomidou</groupId>        <artifactId>mybatis-plus-boot-starter</artifactId>        <version>3.4.3</version>    </dependency>    <dependency>        <groupId>com.baomidou</groupId>        <artifactId>mybatis-plus-generator</artifactId>        <version>3.4.1</version>    </dependency>    <dependency>        <groupId>org.projectlombok</groupId>        <artifactId>lombok</artifactId>        <version>1.18.12</version>    </dependency>    <dependency>        <groupId>org.apache.shardingsphere</groupId>        <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>        <version>5.0.0-alpha</version>    </dependency>    <dependency>        <groupId>com.zaxxer</groupId>        <artifactId>HikariCP</artifactId>        <version>3.4.2</version>    </dependency></dependencies>

properties复制代码#配置数据源名称spring.shardingsphere.datasource.names=ds-0,ds-1spring.shardingsphere.datasource.common.type=com.zaxxer.hikari.HikariDataSourcespring.shardingsphere.datasource.common.driver-class-name=com.mysql.jdbc.Driver# 分别配置多个数据源的详细信息spring.shardingsphere.datasource.ds-0.username=rootspring.shardingsphere.datasource.ds-0.password=123456spring.shardingsphere.datasource.ds-0.jdbc-url=jdbc:mysql://192.168.221.128:3306/shard01?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8spring.shardingsphere.datasource.ds-1.username=rootspring.shardingsphere.datasource.ds-1.password=123456spring.shardingsphere.datasource.ds-1.jdbc-url=jdbc:mysql://192.168.221.128:3306/shard02?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8# 配置数据库的分库策略，其中database-inline会在后面声明spring.shardingsphere.rules.sharding.default-database-strategy.standard.sharding-column=user_idspring.shardingsphere.rules.sharding.default-database-strategy.standard.sharding-algorithm-name=database-inline# 配置t_order表的分表策略，其中t-order-inline会在后面声明# 行表达式标识符可以使用 ${...} 或 $->{...}，但前者与 Spring 本身的属性文件占位符冲突，因此在 Spring 环境中使用行表达式标识符建议使用 $->{...}spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=ds-$->{0..1}.t_order_$->{0..1}spring.shardingsphere.rules.sharding.tables.t_order.table-strategy.standard.sharding-column=order_idspring.shardingsphere.rules.sharding.tables.t_order.table-strategy.standard.sharding-algorithm-name=t-order-inline# 配置order_id采用雪花算法生成全局id策略spring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.column=order_idspring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.key-generator-name=snowflake# 配置具体的分库分表规则spring.shardingsphere.rules.sharding.sharding-algorithms.database-inline.type=INLINEspring.shardingsphere.rules.sharding.sharding-algorithms.database-inline.props.algorithm-expression=ds-$->{user_id % 2}spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-inline.type=INLINEspring.shardingsphere.rules.sharding.sharding-algorithms.t-order-inline.props.algorithm-expression=t_order_$->{order_id % 2}spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-item-inline.type=INLINEspring.shardingsphere.rules.sharding.sharding-algorithms.t-order-item-inline.props.algorithm-expression=t_order_item_$->{order_id % 2}# 配置雪花算法spring.shardingsphere.rules.sharding.key-generators.snowflake.type=SNOWFLAKEspring.shardingsphere.rules.sharding.key-generators.snowflake.props.worker-id=123

java复制代码@Update("CREATE TABLE IF NOT EXISTS t_order (order_id BIGINT AUTO_INCREMENT, user_id INT NOT NULL, address_id BIGINT NOT NULL, status VARCHAR(50), PRIMARY KEY (order_id))")void createTableIfNotExists();

java复制代码@Servicepublic class TOrderServiceImpl extends ServiceImpl<TOrderMapper, TOrder> implements ITOrderService {    @Autowired    TOrderMapper orderMapper;    Random random=new Random();    @Override    public void initEnvironment() throws SQLException {        orderMapper.createTableIfNotExists();    }    @Override    public void processSuccess() throws SQLException {        System.out.println("-------------- Process Success Begin ---------------");        List<Long> orderIds = insertData();        System.out.println("-------------- Process Success Finish --------------");    }    private List<Long> insertData() throws SQLException {        System.out.println("---------------------------- Insert Data ----------------------------");        List<Long> result = new ArrayList<>(10);        for (int i = 1; i <= 10; i++) {            TOrder order = new TOrder();            order.setUserId(random.nextInt(10000));            order.setAddressId(i);            order.setStatus("INSERT_TEST");            orderMapper.insert(order);            result.add(order.getOrderId());        }        return result;    }}

java复制代码@RestController@RequestMapping("/t-order")public class TOrderController {    @Autowired    ITOrderService orderService;    @GetMapping    public void init() throws SQLException {        orderService.initEnvironment();        orderService.processSuccess();    }}

properties复制代码spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=ds-$->{0..1}.t_order_$->{0..1}

properties复制代码# 广播表, 其主节点是ds0spring.shardingsphere.sharding.broadcast-tables=t_configspring.shardingsphere.sharding.tables.t_config.actual-data-nodes=ds$->{0}.t_config

properties复制代码# 绑定表规则，多组绑定规则使用数组形式配置spring.shardingsphere.rules.sharding.binding-tables=t_order,t_order_item

properties复制代码spring.shardingsphere.rules.sharding.binding-tables[0]= # 绑定表规则列表spring.shardingsphere.rules.sharding.binding-tables[1]= # 绑定表规则列表spring.shardingsphere.rules.sharding.binding-tables[x]= # 绑定表规则列表

properties复制代码# database-mod是自定义字符串名字spring.shardingsphere.rules.sharding.default-database-strategy.standard.sharding-algorithm-name=database-mod# MOD表示取模算法类型spring.shardingsphere.rules.sharding.sharding-algorithms.database-mod.type=MOD# 表示分片数量spring.shardingsphere.rules.sharding.sharding-algorithms.database-mod.props.sharding-count=2

properties复制代码# database-mod是自定义字符串名字spring.shardingsphere.rules.sharding.default-database-strategy.standard.sharding-algorithm-name=database-hash-modspring.shardingsphere.rules.sharding.sharding-algorithms.database-hash-mod.type=HASH_MODspring.shardingsphere.rules.sharding.sharding-algorithms.database-hash-mod.props.sharding-count=2

txt复制代码(0~199)保存到表0[200~399]保存到表1[400~599)保存到表2

properties复制代码server.port=8080spring.mvc.view.prefix=classpath:/templates/spring.mvc.view.suffix=.htmlspring.shardingsphere.datasource.names=ds-0spring.shardingsphere.datasource.common.type=com.zaxxer.hikari.HikariDataSourcespring.shardingsphere.datasource.common.driver-class-name=com.mysql.jdbc.Driverspring.shardingsphere.datasource.ds-0.username=rootspring.shardingsphere.datasource.ds-0.password=123456spring.shardingsphere.datasource.ds-0.jdbc-url=jdbc:mysql://192.168.221.128:3306/shard01?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8spring.shardingsphere.rules.sharding.tables.t_order_volume_range.actual-data-nodes=ds-0.t_order_volume_range_$->{0..2}spring.shardingsphere.rules.sharding.tables.t_order_volume_range.table-strategy.standard.sharding-column=user_idspring.shardingsphere.rules.sharding.tables.t_order_volume_range.table-strategy.standard.sharding-algorithm-name=t-order-volume-rangespring.shardingsphere.rules.sharding.tables.t_order_volume_range.key-generate-strategy.column=order_idspring.shardingsphere.rules.sharding.tables.t_order_volume_range.key-generate-strategy.key-generator-name=snowflakespring.shardingsphere.rules.sharding.sharding-algorithms.t-order-volume-range.type=VOLUME_RANGE#最小的范围，0-200spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-volume-range.props.range-lower=200#最大的范围，600 ，如果超过600，会报错spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-volume-range.props.range-upper=600# 表示每张表的容量为200spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-volume-range.props.sharding-volume=200spring.shardingsphere.rules.sharding.key-generators.snowflake.type=SNOWFLAKEspring.shardingsphere.rules.sharding.key-generators.snowflake.props.worker-id=123

txt复制代码(0~1000)保存到表0[1000~20000]保存到表1[20000~300000)保存到表2[300000~无穷大)保存到表3

properties复制代码# BOUNDARY_RANGE 表示分片算法类型spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-boundary-range.type=BOUNDARY_RANGE# 分片的范围边界，多个范围边界以逗号分隔spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-boundary-range.props.sharding-ranges=1000,20000,300000

txt复制代码(1970-01-01 23:59:59 ~ 2020-01-01 23:59:59) 表0[2020-01-01 23:59:59 ~ 2021-01-01 23:59:59) 表1[2021-01-01 23:59:59 ~ 2021-02-01 23:59:59) 表2[2022-01-01 23:59:59 ~ 2024-01-01 23:59:59) 表3

properties复制代码spring.shardingsphere.rules.sharding.tables.t_order_volume_range.actual-data-nodes=ds-0.t_order_volume_range_$->{0..2}spring.shardingsphere.rules.sharding.tables.t_order_volume_range.table-strategy.standard.sharding-column=create_datespring.shardingsphere.rules.sharding.tables.t_order_volume_range.table-strategy.standard.sharding-algorithm-name=t-order-auto-intervalspring.shardingsphere.rules.sharding.tables.t_order_volume_range.key-generate-strategy.column=order_idspring.shardingsphere.rules.sharding.tables.t_order_volume_range.key-generate-strategy.key-generator-name=snowflakespring.shardingsphere.rules.sharding.sharding-algorithms.t-order-auto-interval.type=AUTO_INTERVAL# 分片的起始时间范围，时间戳格式：yyyy-MM-dd HH:mm:ssspring.shardingsphere.rules.sharding.sharding-algorithms.t-order-auto-interval.props.datetime-lower=2010-01-01 23:59:59# 分片的结束时间范围，时间戳格式：yyyy-MM-dd HH:mm:ssspring.shardingsphere.rules.sharding.sharding-algorithms.t-order-auto-interval.props.datetime-upper=2021-01-01 23:59:59# 单一分片所能承载的最大时间，单位：秒，下面的数字表示1年spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-auto-interval.props.sharding-seconds='31536000'

sql复制代码select * from t_order where to_date(create,'yyyy-mm-dd')=''

properties复制代码spring.shardingsphere.rules.sharding.sharding-algorithms.database-inline.type=INLINEspring.shardingsphere.rules.sharding.sharding-algorithms.database-inline.props.algorithm-expression=ds-$->{user_id % 2}spring.shardingsphere.rules.sharding.sharding-algorithms.t-order-inline.type=INLINEspring.shardingsphere.rules.sharding.sharding-algorithms.t-order-inline.props.algorithm-expression=t_order_$->{order_id % 2}

java复制代码public interface ShardingStrategy {    Collection<String> getShardingColumns();    ShardingAlgorithm getShardingAlgorithm();    Collection<String> doSharding(Collection<String> var1, Collection<ShardingConditionValue> var2, ConfigurationProperties var3);}

java复制代码public class StandardModTableShardAlgorithm implements StandardShardingAlgorithm<Long> {    private Properties props=new Properties();    /**     * 用于处理=和IN的分片。     * @param collection 表示目标分片的集合     * @param preciseShardingValue 逻辑表相关信息     * @return     */    @Override    public String doSharding(Collection<String> collection, PreciseShardingValue<Long> preciseShardingValue) {        for(String name:collection){            //根据order_id的值进行取模，得到一个目标值            if(name.endsWith(String.valueOf(preciseShardingValue.getValue()%4))){                return name;            }        }        throw new UnsupportedOperationException();    }    /**     * 用于处理BETWEEN AND分片，如果不配置RangeShardingAlgorithm，SQL中的BETWEEN AND将按照全库路由处理     * @param collection     * @param rangeShardingValue     * @return     */    @Override    public Collection<String> doSharding(Collection<String> collection, RangeShardingValue<Long> rangeShardingValue) {        Collection<String> result=new LinkedHashSet<>(collection.size());        for(Long i=rangeShardingValue.getValueRange().lowerEndpoint();i<=rangeShardingValue.getValueRange().upperEndpoint();i++){            for(String name:collection){                if(name.endsWith(String.valueOf(i%4))){                    result.add(name);                }            }        }        return result;    }    /**     * 初始化对象的时候调用的方法     */    @Override    public void init() {    }    /**     * 对应分片算法（sharding-algorithms）的类型     * @return     */    @Override    public String getType() {        return "STANDARD_MOD";    }    @Override    public Properties getProps() {        return this.props;    }    /**     * 获取分片相关属性     * @param properties     */    @Override    public void setProps(Properties properties) {        this.props=properties;    }}

txt复制代码  com.gupao.sharding.example.StandardModTableShardAlgorithm

properties复制代码spring.shardingsphere.rules.sharding.tables.t_order_standard.actual-data-nodes=ds-0.t_order_standard_$->{0..3}spring.shardingsphere.rules.sharding.tables.t_order_standard.table-strategy.standard.sharding-column=order_idspring.shardingsphere.rules.sharding.tables.t_order_standard.table-strategy.standard.sharding-algorithm-name=standard-modspring.shardingsphere.rules.sharding.tables.t_order_standard.key-generate-strategy.column=order_idspring.shardingsphere.rules.sharding.tables.t_order_standard.key-generate-strategy.key-generator-name=snowflakespring.shardingsphere.rules.sharding.sharding-algorithms.standard-mod.type=STANDARD_MODspring.shardingsphere.rules.sharding.sharding-algorithms.standard-mod.props.algorithm-class-name=com.gupao.sharding.example.StandardModTableShardAlgorithm