xml复制代码<PropertyGroup>
  <AspNetCoreHostingModel>InProcess</AspNetCoreHostingModel>
</PropertyGroup>

xml复制代码<PropertyGroup>
  <AspNetCoreHostingModel>OutOfProcess</AspNetCoreHostingModel>
</PropertyGroup>

java复制代码    private void initGM() throws Exception {
        String osName = System.getProperty("os.name").toLowerCase();
        log.info("os name: {}", osName);
        String gmPath;
        if (osName.contains("mac")) {
            gmPath = "gm/mac/gm";
        } else if (osName.contains("linux")) {
            // 初始化容器的环境
            initPodEnv();
            gmPath = "gm/linux/gm";
        } else {
            throw new RuntimeException("非法操作系统："+osName);
        }
        InputStream fisInJar = new ClassPathResource(gmPath).getInputStream();
        File file = File.createTempFile("GraphicsMagick", "_gm");
        file.setExecutable(true);
        GM_PATH = file.getAbsolutePath();
        //将jar包里的gm复制到操作系统的目录里
        OutputStream fosInOs = new FileOutputStream(file);
        byte[] buffer = new byte[1024];
        int readLength = fisInJar.read(buffer);
        while (readLength != -1) {
            fosInOs.write(buffer, 0, readLength);
            readLength = fisInJar.read(buffer);
        }
        IOUtils.closeQuietly(fosInOs);
        IOUtils.closeQuietly(fisInJar);
        log.info("gm初始化完毕");
    }

java复制代码    /**
     * 初始化容器的环境
     *
     * 安装gm所依赖的库
     */
    private void initPodEnv() throws Exception {
        log.info("============ start init pod env ============");
        Process exec1 = Runtime.getRuntime().exec("yum install -y gcc make");
        this.printLog(exec1);
        log.info("cmd 1 exec success");
       
        Process exec2 = Runtime.getRuntime().exec("yum install -y libpng-devel libjpeg-devel libtiff-devel jasper-devel freetype-devel libtool-ltdl-devel*");
        this.printLog(exec2);
        log.info("cmd 2 exec success");
        // 打水印时缺少依赖
        Process exec3 = Runtime.getRuntime().exec("yum -y install ghostscript");
        this.printLog(exec3);
        log.info("cmd 3 exec success");
        log.info("============ init pod env success ============");
    }

java复制代码/**
 * GM 进程池参数
 */
@ConfigurationProperties(prefix = "gm.pool")
@Data
public class GMPoolProperties {

    /**
     * 连接池最大活跃数
     */
    private int maxActive = 4;

    /**
     * 连接池最大空闲连接数
     */
    private int maxIdle = 4;

    /**
     * 连接池最小空闲连接数
     */
    private int minIdle = 2;

    /**
     * 资源池中资源最小空闲时间(单位为毫秒)，达到此值后空闲资源将被移
     */
    private long minEvictableIdleTimeMillis = 300000L;

    /**
     * 连接池连接用尽后执行的动作
     */
    private WhenExhaustedAction whenExhaustedAction = WhenExhaustedAction.BLOCK;

    /**
     * 连接池没有对象返回时，最大等待时间(毫秒)
     */
    private long maxWait = 5000;

    /**
     * 定时对线程池中空闲的链接进行校验
     */
    private boolean testWhileIdle = false;

    /**
     * 空闲资源的检测周期(单位为毫秒)
     */
    private long timeBetweenEvictionRunsMillis = 10000L;

}

csharp复制代码/**
 * Redisson错误示范2
 * 在同一业务中，多次使用同步查询
 */
 @Test
public void test2() {
    for (int i = 0; i < 10000; i++) {
        client.getMap("test").getOrDefault(1, 0);
    }
}

复制代码结果：同一结果多次同步查询，消耗性能

arduino复制代码/**
 * Redisson错误示范1，在异步RFuture里面用同步方法
 * 导致同时阻塞两个线程
 */
 @Test
public void test() {
    for (int i = 0; i < 1000; i++) {
        RMap<Integer, Integer> map = client.getMap("test");
        RFuture<Integer> future = map.addAndGetAsync(1, 1);
        future.onComplete((value1, throwable) -> {
            System.out.println("value1 ==============" + value1);
            Object value2 = client.getMap("test").getOrDefault(1, 0);
            System.out.println("value2 ==============" + value2);
        });
    }

vbscript复制代码new RedisTimeoutException("Command still hasn't been written into connection! Increase nettyThreads and/or retryInterval settings. Payload size in bytes: " + totalSize
        + ". Node source: " + source + ", connection: " + connectionFuture.getNow()
        + ", command: " + LogHelper.toString(command, params)
        + " after " + attempt + " retry attempts");

ini复制代码/**
 * Redisson解决方案1
 * 问题：在同一业务中，多次使用同步查询
 * 方案：如果这个请求是用于了锁，那只需要查询一次，如果有修改最后在加回去
 */
 @Test
public void solve1() {
    RLock lock = client.getLock("testLock");
    boolean isLock = lock.tryLock();
    if (isLock) {
        try {
            RMap<Integer, Integer> map = client.getMap("test");
            Integer num = map.getOrDefault(1, 0);
            Result result = new Result(num);
            for (int i = 0; i < 10000; i++) {
                result.addValue(1);
            }
            map.put(1, result.getValue());
        } finally {
            lock.unlock();
        }
    }
}

ini复制代码/**
 * Redisson解决方案2
 * 问题：在同一业务中，多次使用同步查询
 * 方案：如果改数据不是频繁修改，建议使用缓存（RLocalCachedMap）
 */
 @Test
public void solve2() {
    RLocalCachedMap<Integer, Integer> map = client.getLocalCachedMap("test", options);
    for (int i = 0; i < 1000; i++) {
        Integer value = map.getOrDefault(1, 0);
        System.out.println("value :" + value);
    }
}

ini复制代码private void init(String name, LocalCachedMapOptions<K, V> options, RedissonClient redisson, EvictionScheduler evictionScheduler) {
    // 创建监听器
    listener = new LocalCacheListener(name, commandExecutor, this, codec, options, cacheUpdateLogTime) {
        @Override
        protected void updateCache(ByteBuf keyBuf, ByteBuf valueBuf) throws IOException {
            CacheKey cacheKey = toCacheKey(keyBuf);
            Object key = codec.getMapKeyDecoder().decode(keyBuf, null);
            Object value = codec.getMapValueDecoder().decode(valueBuf, null);
            cachePut(cacheKey, key, value);
        }
    };
    // 发送监听到redis服务端
    listener.add(cache);
    }


@Override
public <M> int addListener(Class<M> type, MessageListener<? extends M> listener) {
    RFuture<Integer> future = addListenerAsync(type, (MessageListener<M>) listener);
    commandExecutor.syncSubscription(future);
    return future.getNow();
}


RLocalCachedMap.putOperationAsync(修改值)
 @Override
protected RFuture<V> putOperationAsync(K key, V value) {
    ByteBuf mapKey = encodeMapKey(key);
    CacheKey cacheKey = toCacheKey(mapKey);
    CacheValue prevValue = cachePut(cacheKey, key, value);
    broadcastLocalCacheStore(value, mapKey, cacheKey);

    if (storeMode == LocalCachedMapOptions.StoreMode.LOCALCACHE) {
        V val = null;
        if (prevValue != null) {
            val = (V) prevValue.getValue();
        }
        return RedissonPromise.newSucceededFuture(val);
    }

    ByteBuf mapValue = encodeMapValue(value);
    byte[] entryId = generateLogEntryId(cacheKey.getKeyHash());
    ByteBuf msg = createSyncMessage(mapKey, mapValue, cacheKey);
    // 向所有订阅了这个map的主题的服发生已经被修改的信息
    return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_MAP_VALUE,
              "local v = redis.call('hget', KEYS[1], ARGV[1]); "
            + "redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); "
            + "if ARGV[4] == '1' then "
                + "redis.call('publish', KEYS[2], ARGV[3]); "
            + "end;"
            + "if ARGV[4] == '2' then "
                + "redis.call('zadd', KEYS[3], ARGV[5], ARGV[6]);"
                + "redis.call('publish', KEYS[2], ARGV[3]); "
            + "end;"
            + "return v; ",
            Arrays.<Object>asList(getName(), listener.getInvalidationTopicName(), listener.getUpdatesLogName()), 
            mapKey, mapValue, msg, invalidateEntryOnChange, System.currentTimeMillis(), entryId);
}



Redisson没有提供队列的缓存，我们可以根据上面的逻辑实现一个自己的带缓存的队列
public class RLocalCachedQueue<V> {
    private ConcurrentLinkedQueue<V> cQueue = new ConcurrentLinkedQueue<V>();
    private RQueue<V> rQueue;
    private RTopic rTopic;

    public RLocalCachedQueue(Class clazz, String name, RedissonClient client) {
        super();
        this.rQueue = client.getQueue(name);
        this.rTopic = client.getTopic(name);
        this.rTopic.addListener(clazz, (channel, msg) -> {
            if (msg == null) {
                return;
            }
            V v = (V) msg;
            cQueue.add(v);
        });
        this.cQueue.addAll(rQueue.readAll());
    }

    public RFuture<Boolean> add(V v) {
        RFuture<Boolean> future = rQueue.offerAsync(v);
        rTopic.publish(v);
        return future;
    }

    public ConcurrentLinkedQueue<V> getQueue() {
        return cQueue;
    }
}

ini复制代码这个比较简单，就是把几条命令合成一条命令发给redis服务端
/**
 * Redisson优化写的方案 1
 * 方案：使用redis的管道功能
 */
@Test
public void write_solve1() {
    RBatch batch = client.createBatch();
    for (int i = 0; i < 100; i++) {
        batch.getMap("test").addAndGetAsync(1, 1);
    }
    batch.executeAsync();
}

swift复制代码/**
 * Redisson优化写的方案 2
 * 方案：使用Redis的脚本
 */
@Test
public void write_solve2() {
    List<Object> keys = new ArrayList<>();
    keys.add("\"stock\"");
    keys.add("\"amount\"");
    client.getScript().evalAsync(RScript.Mode.READ_ONLY, RedisScript.STOCK_SCRIPT, RScript.ReturnType.INTEGER, keys);
}


// 扣库存脚本
public static final String STOCK_SCRIPT =
        "if (redis.call('hexists', KEYS[1], KEYS[2]) == 1) then\n" +
                "local stock = tonumber(redis.call('hget', KEYS[1], KEYS[2]));\n" +
                "if (stock > 0) then\n" +
                " redis.call('hincrby', KEYS[1], KEYS[2], -1);\n" +
                "return stock;\n" +
                "end;\n" +
                "return 0;\n" +
                "end;";

Groovy复制代码tasks.whenTaskAdded { task ->
    if (task.name=='mergeDebugNativeLibs') {
        task.doFirst {
            println("==========================================================")
            def v7a = []
            def arm64 = []
            it.inputs.files.each { file ->
                if (file.absolutePath.endsWith("/jni")) {
//                    println("==========" + file.absolutePath)
                    if (file.isDirectory()) {
                        file.listFiles().each { soFileDir ->
                            if (soFileDir.absolutePath.contains("armeabi-v7a")) {
                                if (soFileDir.isDirectory()) {
                                    soFileDir.listFiles().each {
                                        println(it.absolutePath)
                                        v7a.add(it.name)
                                    }
                                }
                            }
                            if (soFileDir.absolutePath.contains("arm64-v8a")) {
                                if (soFileDir.isDirectory()) {
                                    soFileDir.listFiles().each {
                                        println(it.absolutePath)
                                        arm64.add(it.name)
                                    }
                                }
                            }
                        }
                    }
                }
            }
            println("v7a size: ${v7a.size()}")
            println("arm64 size: ${arm64.size()}")
            println("so in v7a, but not in arm64:")
            v7a.each {
                if (!arm64.contains(it)) {
                    println("$it")
                }
            }
            println("==========================================================")
        }
    }
}

markdown复制代码> Task :app:mergeDebugNativeLibs
==========================================================
xxx\5d0e00f6a703ec622708978bebed0322\mmkv-static-1.2.8\jni\arm64-v8a\libmmkv.so
xxx\5d0e00f6a703ec622708978bebed0322\mmkv-static-1.2.8\jni\armeabi-v7a\libmmkv.so
xxx\7206efbbb5863dbe5969c1c384b81177\openDefault-4.2.7\jni\armeabi-v7a\libweibosdkcore.so
xxx\ccd11b53aab95a933b06ef9e74f9fb44\sentry-android-ndk-3.1.3\jni\arm64-v8a\libsentry-android.so
xxx\ccd11b53aab95a933b06ef9e74f9fb44\sentry-android-ndk-3.1.3\jni\arm64-v8a\libsentry.so
xxx\ccd11b53aab95a933b06ef9e74f9fb44\sentry-android-ndk-3.1.3\jni\armeabi-v7a\libsentry-android.so
xxx\ccd11b53aab95a933b06ef9e74f9fb44\sentry-android-ndk-3.1.3\jni\armeabi-v7a\libsentry.so
v7a size: 4
arm64 size: 3
so in v7a, but not in arm64:
libweibosdkcore.so
==========================================================

Groovy复制代码android {
	
	...
		
    splits {
        abi {
            enable true
            reset()
            include 'armeabi-v7a', 'arm64-v8a'
            universalApk false
        }
    }
}

php复制代码/**
 * @desc 利用递归思想 找出经纬度的二进制编码
 * @param float $place 经度或纬度
 * @param string $binary_array 每次递归拿到的bit值
 * @param int $max_separate_num递归总次数
 * @param array $section 区间值
 * @param int $num 递归次数
 * @return array
 */
public function binary($place = 0, $binary_array = [], $max_recursion_num = 20, $section = [], $num = 1)
{
    if (!$section) return $binary_array;

    // 获取中间值
    $count = ($section['max'] - $section['min']) / 2;

    // 左半边区间
    $left = [
        'min' => $section['min'],
        'max' => $section['min'] + $count
    ];

    // 右半边区间
    $right = [
        'min' => $section['min'] + $count,
        'max' => $section['max']
    ];

    // 假如给点的经纬度值大于右边最小值 则属于右半边区间为1 否则就是左半边区间 0
    array_push($binary_array, $place > $right['min'] ? 1 : 0);

    // 如果递归次数已经达到最大值 则直接返回结果集
    if ($max_recursion_num <= $num) return $binary_array;

    // 下一次递归我们需要传入的经纬度 区间值
    $section = $place > $right['min'] ? $right : $left;

    // 继续针对自身做的递归处理  一直到出现结果
    return $this->binary($place, $binary_array, $max_recursion_num, $section, $num + 1);
}

// 实例化调用该方法
require_once './Geohash.php';

$geohash = new Geohash();

echo  json_encode($geohash->binary(23.117596,[],$geohash->baseLengthGetNums(4, 1), $geohash->interval[0],1));

//结果集
[1,0,1,0,0,0,0,0,1,1]-> 二进制 101000 00011 这样是不是很清晰

//再看不明白的话  那么久打印出范围值：
[{"min":-90,"max":90},{"min":0,"max":90},{"min":0,"max":45},{"min":22.5,"max":45},{"min":22.5,"max":33.75},{"min":22.5,"max":28.125},{"min":22.5,"max":25.3125},{"min":22.5,"max":23.90625},{"min":22.5,"max":23.203125},{"min":22.8515625,"max":23.203125}]

lua复制代码local cjson = require("cjson")

-- 定义经纬度区间范围
local interval = {
    { min = -90,  max = 90 },
    { min = -180, max = 180 }
}

--- @desc 利用递归思想 找出经纬度的二进制编码
--- @param place string 经度或纬度
--- @param binary_array table 每次递归拿到的bit值
--- @param max_separate_num number 递归总次数
--- @param section table 区间值
--- @param num number 递归次数
function binary(place, binary_array, max_recursion_num, section, num)
    -- body
    place        = tonumber(place) or 0
    binary_array = binary_array and binary_array or {}
    max_recursion_num = tonumber(max_recursion_num) or 20
    section      =  section and section or {}
    num          = tonumber(num) or 1

    if not next(section) then
       return binary_array
    end
    print(cjson.encode(section))
    -- 获取中间值
    local count = (section["max"] - section["min"]) / 2
    -- 左半边区间
    local left = {
        min = section["min"],
        max = section["min"] + count
    }
    -- 右半边区间
    local right = {
        min = section["min"] + count,
        max = section["max"]
    }

    -- 假如给点的经纬度值大于右边最小值 则属于右半边区间为1 否则就是左半边区间 0
    binary_array[#binary_array+1] = place > right["min"] and 1 or 0

    -- 如果递归次数已经达到最大值 则直接返回结果集
    if max_recursion_num <= num then
        return binary_array
    end

    -- 下一次递归我们需要传入的经纬度 区间值
    local _section = place > right["min"] and right or left

    return binary(place, binary_array, max_recursion_num, _section, num + 1)
end


local res = binary(113.326059, {}, _base_length_get_nums(4, 1), interval[2], 1)

print(cjson.encode(res))

//打印结果
{"max":180,"min":-180}
{"max":180,"min":0}
{"max":180,"min":90}
{"max":135,"min":90}
{"max":135,"min":112.5}
{"max":123.75,"min":112.5}
{"max":118.125,"min":112.5}
{"max":115.3125,"min":112.5}
{"max":113.90625,"min":112.5}
{"max":113.90625,"min":113.203125}
[1,1,0,1,0,0,0,0,1,0]

perl复制代码--- @desc 根据指定编码长度获取经纬度的 二分层数
--- @param int $length 编码精确度
--- @param int $type 类型 0-纬度；1-经度
--- @return mixed
local function _base_length_get_nums(length, typ)
    -- 第一种方法写死
    local list = { {2, 3}, {5, 5}, {7, 8}, {10, 10}, {12, 13}, {15, 15}, {17, 18}, {20, 20}, {22, 23}, {25, 25}, {27, 28}, {30, 30} }
    
    -- 第二种通过规律计算纬度位数组合成list
    local cycle_num = 12
    local list_res  = {}
    local lat, lng  = 0, 0
    for i = 1, 12, 1 do
        lat = i % 2 == 0 and lat + 3 or lat + 2
        lng = i % 2 == 0 and lng + 2 or lng + 3
        list_res[#list_res + 1] = {lat, lng}
    end
   
    return list[length][typ]
end

复制代码整体的计算方式：
latitude的范围是：-90° 到 90°
longitude范围是：-180° 到 180°
地球参考球体的周长：40075016.68米

php复制代码/**
 * @desc 编码组合
 * @param $latitude_str 纬度
 * @param $longitude_str 经度
 * @return string
 */
public function combination($latitude_str, $longitude_str)
{
    $result = '';
    //循环经度数字 作为偶数位置
    for ($i = 0; $i < strlen($longitude_str); $i++) {
         // 拼接经度作为偶数位置
        $result .= $longitude_str{$i};
        // 维度存在则拼接字符串
        if (isset($latitude_str{$i})) $result .= $latitude_str{$i};
    }
    return $result;
}
// 结果集
var_dump($geohash->combination('1010000011', '1101000010'));
11100110000000001101

lua复制代码function combination(latitude_arr, longitude_arr)
    local result = ''
    for i = 1, #longitude_arr do
        result = result..longitude_arr[i]
        if latitude_arr[i] then
            result = result..latitude_arr[i]
        end
    end
    return result
end
//结果集
print(cjson.encode(combination({1,0,1,0,0,0,0,0,1,1}, {1,1,0,1,0,0,0,0,1,0})))
11100110000000001101

css复制代码又会有小伙们问了为啥要去掉(a, i, l, o)这四个字母？ 有没有疑问的，有的请下方扣1！！！！！

ini复制代码11100 = 2^4+2^3+2^2 = 16+8+4 = 28  也就是对应w字符串；看下下面对应的维基百科的字典表

php复制代码/**
 * @desc 将二进制字符串转为十进制 再转换为对应的编码
 * @param $str
 * @return string
 */
public function encode($str = '')
{
    $string = '';

    // 按照5位分割字符串
    $array    = str_split($str, 5);
    if (!$array) return $string;
    foreach ($array as $va) {
        //二进制转换为十进制
        $decimal    = bindec($va);
        $string .= $this->base_32[$decimal];
    }
    return $string;
}
// 结果集是ws0e
var_dump($geohash->encode('11100110000000001101'));

sql复制代码CREATE TABLE `user_place` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `user_id` int(10) DEFAULT NULL DEFAULT '0' COMMENT '用户id',
  `longitude` double DEFAULT NULL DEFAULT '' COMMENT '经度',
  `latitude` double DEFAULT NULL  DEFAULT ''COMMENT '纬度',
  `create_time` int(10) DEFAULT NULL DEFAULT '0' COMMENT '创建时间',
  PRIMARY KEY (`id`),
  KEY `idx_longe_lat` (`longitude`,`latitude`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

sql复制代码SELECT * FROM `user_place` WHERE (longitude BETWEEN minlng(最小经度) AND maxlng(最大经度)) AND (latitude BETWEEN minlat(最小纬度) AND maxlat(最大纬度))

查询之后结果集之后，通过经纬度计算距离

sql复制代码// 当前自己的经纬度坐标
$latitude  = 23.117596
$longitude = 113.326059
//一系列的复杂计算用到了 mysql中的 三角函数 ASIN函数：反正弦值； POWER函数：用于计算 x 的 y 次方。其他的小伙伴们百度查吧  正弦、余弦
fields = "user_id,ROUND(6378.138*2*ASIN(SQRT(POW(SIN(($latitude*PI()/180-latitude*PI()/180)/2),2)+COS($latitude*PI()/180)*COS(latitude*PI()/180)*POW(SIN(($longitude*PI()/180-longitude*PI()/180)/2),2)))*1000,2) AS distance";

selecet fields from `user_place` having distance <= 10 order by distance asc limit 10

sql复制代码 1、ST_GeoHash(longitude, latitude, max_length -- 生成geohash值
 
mysql> SELECT ST_GeoHash(116.336506,39.978729,10);
+-------------------------------------+
| ST_GeoHash(116.336506,39.978729,10) |
+-------------------------------------+
| wx4ermcsvp                          |
+-------------------------------------+
1 row in set (0.00 sec)
 
 2、ST_LongFromGeoHash() -- 从geohash值返回经度
 
 mysql> SELECT ST_LongFromGeoHash('wx4ermcsvp');
+----------------------------------+
| ST_LongFromGeoHash('wx4ermcsvp') |
+----------------------------------+
|                        116.33651 |
+----------------------------------+
1 row in set (0.00 sec)
 
 3、ST_LatFromGeoHash()  -- 从geohash值返回纬度
 
 mysql> SELECT ST_LatFromGeoHash('wx4ermcsvp');
+---------------------------------+
| ST_LatFromGeoHash('wx4ermcsvp') |
+---------------------------------+
|                        39.97873 |
+---------------------------------+
1 row in set (0.00 sec)
 
 4、ST_PointFromGeoHash() -- 将geohash值转换为point值
 
 mysql> SELECT ST_AsText(ST_PointFromGeoHash('wx4ermcsvp',0));
+------------------------------------------------+
| ST_AsText(ST_PointFromGeoHash('wx4ermcsvp',0)) |
+------------------------------------------------+
| POINT(116.33651 39.97873)                      |
+------------------------------------------------+
1 row in set (0.00 sec)

具体用法其实都差不多的，小伙伴们可以查查相关资料看看！用的不是很多

sql复制代码-- 先添加字段 geohash
alter table `user` add `geohash` varchar(64) NOT NULL DEFAULT NULL COMMENT '经纬度对应geohash码值',
-- 再添加geohash的普通索引
 alter table `user` add index idx_geohash ( `geohash` )
-- 查询sql
select * from `user` where `geohash` like 'geohash%' order by id asc limit 100

sql复制代码-- 例如有一下8个值 geohash1、geohash2、geohash3、geohash4、geohash5、geohash6、geohash7、geohash8
-- 查询sql
select * from `user` where `geohash` regexp 'geohash1|geohash2|geohash3|geohash4' order by id asc limit 100

less复制代码1、geopos指令：geopos key member [member ...] 获取指定key里返回所有指定名称的位置(经度和纬度)；时间复杂度O(log(n))，n是排序集中的元素数

注意事项：
① geopos命令返回的是一个数组，每个数组中的都由两个元素组成：第一个是位置的经度， 而第二个是位置的纬度。 
② 若给定的元素不存在，则对应的数组项为nil(不要搞错以为是一个空数组)。

2、geodist指令：geodist key member1 member2 [m|km|ft|mi] 获取两个给定位置之间的距离；时间复杂度O(log(n))，n是排序集中的元素数

注意事项：
① member1和member2 为两个地理位置名称，例如用户id标识。
② [m|km|ft|mi]尾部参数：
    m  ：米，默认单位
    km ：千米
    mi ：英里
    ft ：英尺

③ 计算出的距离会以双精度浮点数的形式被返回；位置不存在，则返回nil。

3、georadius指令：georadius key longitude latitude radius [m|km|ft|mi] [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC] [STORE key] [STOREDIST key] 

根据用户给定的经纬度坐标来获取指定范围内的地理位置集合；时间复杂度： O(n+log(m))，n是圆形区域的边界框内的元素数，该元素由中心和半径定界，m是索引内的项数。

注意事项：
① 以给定的经纬度为中心
② [m|km|ft|mi]单位说明
    m ：米，默认单位
    km ：千米
    mi ：英里
    ft ：英尺
③ withdist: 在返回位置元素的同时， 将位置元素与中心之间的距离也一并返回。
④ withcoord: 将位置元素的经度和维度也一并返回。
⑤ withhash: 以 52 位有符号整数的形式，返回位置元素经过原始geohash编码的有序集合分值。这个选项主要用于底层应用或者调试， 实际中的作用并不大。
⑥ count 限定返回的记录数。
⑦ asc: 查找结果根据距离从近到远排序。
⑧ desc: 查找结果根据从远到近排序。

4、georadiusbymember指令：georadiusbymember  key member radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC] [STORE key] [STOREDIST key]
获取指定范围内的元素数据，中心点是由给定的位置元素决定的，不是使用经度和纬度来决定中心点。时间复杂度： O(n+log(m))，n是圆形区域的边界框内的元素数，该元素由中心和半径定界，m是索引内的项数。

注意事项同上面georadius指令！！！

5、geohash指令：geohash key member [member ...] 获取一个或多个位置元素的geohash值；时间复杂度O(log(n))，n是排序集中的元素数

注意事项：
① 该命令返回的是一个数组格式，位置不存在则返回nil
② 数组结果集的值跟给出位置一一对应，说白了就是下标一致

sql复制代码geoadd指令：geoadd key longitude latitude member [longitude latitude member ...] 
添加地理位置的坐标；时间复杂度O(log(n))，n是排序集中的元素数。

注意事项：
① 实际存储的数据类型是zset，member是zset的value，score是根据经纬度计算出geohash
② geohash是52bit的长整型，计算距离使用的公式是Haversine
③ geoadd添加的坐标会有少许的误差，因为geohash对二维坐标进行一维映射是有损耗的

scss复制代码① O(1)解析：

O(1)就是最低的时空复杂度了，也就是耗时/耗空间与输入数据大小无关，无论输入数据增大多少倍，耗时/耗空间都不变。

② O(n)解析：
比如时间复杂度为O(n)，就代表数据量增大几倍，耗时也增大几倍。比如常见的遍历算法。 

要找到一个数组里面最大的一个数，你要把n个变量都扫描一遍，操作次数为n，那么算法复杂度是O(n).

③ O(n^2)解析：

比如时间复杂度O(n^2)，就代表数据量增大n倍时，耗时增大n的平方倍，这是比线性更高的时间复杂度。比如冒泡排序，就是典型的O(n^2)的算法，对n个数排序，需要扫描n×n次。 

用冒泡排序排一个数组，对于n个变量的数组，需要交换变量位置次，那么算法复杂度就是O().

③ O(logn)解析：

比如O(logn)，当数据增大n倍时，耗时增大logn倍（这里的log是以2为底的，比如，当数据增大256倍时，耗时只增大8倍，是比线性还要低的时间复杂度)，二分查找就是O(logn)的算法，每找一次排除一半的可能，256个数据中查找只要找8次就可以找到目标。 


④ O(nlogn)解析：
O(nlogn)同理，就是n乘以logn，当数据增大256倍时，耗时增大256*8=2048倍。这个复杂度高于线性低于平方。归并排序就是O(nlogn)的时间复杂度。

php复制代码/**
 * @desc 添加用户地理位置 可以添加多个 大家可以测试下 修改下方法
 * @param int $user_id
 * @param int $latitude
 * @param int $longitude
 * @return int
 */
public function insert($user_id = 0, $latitude = 0, $longitude = 0)
{
    $result = $this->redis->geoAdd($this->key, $longitude, $latitude, $user_id);

    return $result;
}

/**
 * @desc 搜索附近人结果集
 * @param int $distance
 * @param int $latitude
 * @param int $longitude
 * @return mixed
 */
public function searchNearby($distance = 300, $latitude = 0, $longitude = 0)
{
    $result = $this->redis->georadius(
        $this->key,
        $longitude,
        $latitude,
        $distance,
        'mi',
        ['WITHDIST','count' => 10,'DESC']
    );
    return $result;
}

// 调用 获取结果集
$res = new GeoRedis();
var_dump($res->searchNearby(300, 21.306,-157.858));
array(2) {
  [0]=>
  array(2) {
    [0]=>
    string(4) "1001" //用户id
    [1]=>
    string(8) "104.5615" //距离
  }
  [1]=>
  array(2) {
    [0]=>
    string(4) "1002"
    [1]=>
    string(8) "104.5615"
  }
}

redis复制代码localhost:6379> zrange user:nearby 0 10 withscores
 1) "1001"
 2) "1184565520453603"
 3) "1002"
 4) "1184565520453603"
 5) "1003"
 6) "1231646528010636"
 7) "1004"
 8) "1231732998886639"
 9) "1005"
10) "1235058932387089"

sql复制代码-- 创建索引
db.coll.createIndex({'location':'2dsphere'})

-- 空间查询语法
① 位置相交 db.coll.map.find({'location':{'$geoIntersects':{'$geometry':area}})
② 位置包含 db.coll.map.find({'location':{'$within':{'$geometry':area}})
③ 位置接近 db.coll.map.find({'location':{'$near':{'$geometry':area}})

sql复制代码-- 创建索引  索引的精度通过bits来指定，bits越大，索引的精度就越高
db.coll.createIndex({'location':"2d"}, {"bits":30})

-- 查询语法
① 位置包含  db.coll.map.find({'location':{'$within':[[10,10],[20,20]]})    
② 矩形包含  db.coll.map.find({'location':{'$within':{'$box':[[10,10],[20,20]]}})   
③ 中心包含  db.coll.map.find({'location':{'$within':{'$center':[[20,20],5]}})  
④ 多边形包含 db.coll.map.find({'location':{'$within':{'$polygon':[[20,20],[10,10],[10,18],[13,21]]}})   
⑤ 位置接近 db.coll.map.find({'location':{'$near':[10,20]})

sql复制代码db.user.insertMany([
     {'user_id':1001, 'user_name':'阿沐1', loc:[122.431, 37.773]},
     {'user_id':1002, 'user_name':'阿沐2', location:[157.858, 21.315]},
     {'user_id':1003, 'user_name':'阿沐3', location:[155.331, 21.798]},
     {'user_id':1004, 'user_name':'阿沐4', location:[157.331,22.798]},
     {'user_id':1005, 'user_name':'阿沐5', location:[151.331, 25.798]},
     {'user_id':1006, 'user_name':'阿沐6', location:[147.942428, 28.67652]},
])

sql复制代码db.coll.createIndex({'location':"2d"}, {"bits":30})

sql复制代码db.user.aggregate({
    $geoNear:{
        near: [157.858, 21.306],     // 当前自己坐标
        spherical: true,             // 计算球面距离
        distanceMultiplier: 6378137, // 地球半径，单位是米，默认6378137
        maxDistance: 300/6378137,    // 过滤条件300米内，需要弧度
        distanceField: "distance"    // 距离字段别名
    }
})

sql复制代码//当前结果集为模拟结果，因本机电脑docker没有安装mongo
{ "_id" : ObjectId("4e96b3c91b8d4ce765381e58"), 'user_id':1001, 'user_name':'阿沐1', "location" : [ 122.431, 37.773 ], "distance" : 5.10295397457355 }
{ "_id" : ObjectId("4e96b5c91b8d4ce765381e51"), 'user_id':1002, 'user_name':'阿沐2', "location" : [ 157.858, 21.315 ], "distance" : 255.81213803417531 }

sql复制代码GET api/query/search/
{
  "query": {
    "geo_distance": {
      "distance": "1km",
      "location": {
        "lat": 21.306,
        "lon": 157.858
      }
    }
  }
}

java复制代码C- DataSourceTransactionManager
C- JdoTransactionManager
C- JpaTransactionManager
C- HibernateTransactionManager
C- JtaTransactionManager
C- OC4JjtaTransactionManager
C- WebSphereUowTransactionManager
C- WebLogicJtaTransactionManager

java复制代码C01- TransactionInterceptor
    E- TransactionAspectSupport -> PS:001
    M01_01- invoke(MethodInvocation invocation)
    
    
// M01_01
@Override
@Nullable
public Object invoke(MethodInvocation invocation) throws Throwable {
    // 向TransactionAttributeSource传递目标类和方法
    Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

    // 此处调用 invokeWithinTransaction 正式处理
    return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}

java复制代码C02- TransactionAspectSupport
    M02_01- invokeWithinTransaction(Method method,  Class<?> targetClass, InvocationCallback invocation)
        P- method : 当前原始方法
        P- targetClass : 当前原始类
        P- invocation : 代理对象
        // 1- 属性准备 
            - getTransactionAttributeSource() : 获取 TransactionAttributeSource
            - tas.getTransactionAttribute(method, targetClass) : 获取 TransactionAttribute
            - determineTransactionManager(txAttr) : 获取 PlatformTransactionManager
            - methodIdentification(method, targetClass, txAttr) : 
        // 类型 A : -------------
        A2- 主调操作
            - createTransactionIfNecessary(tm, txAttr, joinpointIdentification)
                ?- 如果需要，根据给定的TransactionAttribute创建一个事务 -> M02_02
            - invocation.proceedWithInvocation() : 核心接口 -> PS:M02_01_01
                ?- 进行目标调用的简单回调接口 , 具体的拦截器/方面由它们的调用机制决定
        A3- catch 操作
            - completeTransactionAfterThrowing(txInfo, ex)
        A4- finally 操作
            - cleanupTransactionInfo(txInfo) -> PS:M02_04_01
        A5- 提交事务
             - commitTransactionAfterReturning(txInfo) -> PS:M02_05_01
         // 类型 B :------------------------ 
        B2- CallbackPreferringPlatformTransactionManager.execute
        B3- prepareTransactionInfo(tm, txAttr, joinpointIdentification, status) : 构建 TransactionInfo 
        B4- invocation.proceedWithInvocation()  
    M02_02- createTransactionIfNecessary(PlatformTransactionManager tm,TransactionAttribute txAttr, String joinpointIdentification)
        1- tm.getTransaction(txAttr) : 获取 TransactionStatus -> M03_01
        2- prepareTransactionInfo(tm, txAttr, joinpointIdentification, status)
             ?- 处理 
    M02_03- prepareTransactionInfo
        1- new TransactionInfo(tm, txAttr, joinpointIdentification) : 构建一个 TransactionInfo
        2- txInfo.newTransactionStatus(status) : 如果不兼容的tx已经存在，事务管理器将标记一个错误
        3- txInfo.bindToThread() : 即使没有在这里创建一个新的事务 , 也会将TransactionInfo绑定到线程
             ?- 这保证了即使这个方面没有创建任何事务，TransactionInfo堆栈也将被正确管理
    M02_04- cleanupTransactionInfo : 重置TransactionInfo ThreadLocal
        - txInfo.restoreThreadLocalStatus() -> PS:M02_04_01 
             
// PS:M02_01_01 核心处理
// 该方法会执行最终的 state 方法 , 主要流程为

C- RepositoryComposition # invoke(Method method, Object... args)
C- RepositoryFactorySupport # doInvoke           
C- SimpleJpaRepository # save 
C- Loader # loadEntity             
C- Loader # doQuery
C- ConnectionImpl # prepareStatement
        
        
// PS:M02_04_01  的作用
TODO : 这个属性的作用
protected void cleanupTransactionInfo(@Nullable TransactionInfo txInfo) {
    if (txInfo != null) {
        txInfo.restoreThreadLocalStatus();
    }
}

java复制代码    protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
            final InvocationCallback invocation) throws Throwable {

        // Step 1 : 属性准备
        TransactionAttributeSource tas = getTransactionAttributeSource();
        final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
        final PlatformTransactionManager tm = determineTransactionManager(txAttr);
        final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

        if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
            // Standard transaction demarcation with getTransaction and commit/rollback calls.
            TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            Object retVal = null;
            try {
                // This is an around advice: Invoke the next interceptor in the chain.
                // This will normally result in a target object being invoked.
                retVal = invocation.proceedWithInvocation();
            }
            catch (Throwable ex) {
                // target invocation exception
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            }
            finally {
                cleanupTransactionInfo(txInfo);
            }
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }

        else {
            final ThrowableHolder throwableHolder = new ThrowableHolder();

            // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
            try {
                Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> {
                    TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
                    try {
                        return invocation.proceedWithInvocation();
                    }
                    catch (Throwable ex) {
                        if (txAttr.rollbackOn(ex)) {
                            // A RuntimeException: will lead to a rollback.
                            if (ex instanceof RuntimeException) {
                                throw (RuntimeException) ex;
                            }
                            else {
                                throw new ThrowableHolderException(ex);
                            }
                        }
                        else {
                            // A normal return value: will lead to a commit.
                            throwableHolder.throwable = ex;
                            return null;
                        }
                    }
                    finally {
                        cleanupTransactionInfo(txInfo);
                    }
                });

                // Check result state: It might indicate a Throwable to rethrow.
                if (throwableHolder.throwable != null) {
                    throw throwableHolder.throwable;
                }
                return result;
            }
            catch (ThrowableHolderException ex) {
                throw ex.getCause();
            }
            catch (TransactionSystemException ex2) {
                if (throwableHolder.throwable != null) {
                    logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                    ex2.initApplicationException(throwableHolder.throwable);
                }
                throw ex2;
            }
            catch (Throwable ex2) {
                if (throwableHolder.throwable != null) {
                    logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                }
                throw ex2;
            }
        }
    }

java复制代码
protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
			@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
    
    // 如果没有指定名称，则将方法标识应用为事务名称
    if (txAttr != null && txAttr.getName() == null) {
        txAttr = new DelegatingTransactionAttribute(txAttr) {
            @Override
            public String getName() {
                return joinpointIdentification;
            }
        };
    }

    TransactionStatus status = null;
    if (txAttr != null) {
        if (tm != null) {
            // txAttr 和 tm 均存在时 , 调用 AbstractPlatformTransactionManager
            status = tm.getTransaction(txAttr);
        } else {
            // 仅打 log
        }
    }
    return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}

java复制代码C03- AbstractPlatformTransactionManager
    M03_01- getTransaction(TransactionDefinition definition) 
        1- doGetTransaction() : 调用子类事务管理 -> M04_01
        2- newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources) -> PS:M03_01_01
        3- doBegin(transaction, definition)
            ?- 根据给定的事务定义，使用语义开始一个新的事务 -> PS:M03_01_02
        4- prepareSynchronization(status, definition)
    M03_02- commit(TransactionStatus status)    
        1- processRollback(defStatus, false) : 处理回调操作 -> M03_03
        2- processCommit(defStatus) : -> M03_04 
    M03_04- processCommit(defStatus) : 主要的 commit 流程
        1- 前置处理
            - prepareForCommit(status);
            - triggerBeforeCommit(status);
            - triggerBeforeCompletion(status);
        2- 通过不同的 DefaultTransactionStatus 执行不同的逻辑
        3- 在commit后触发回调，并将在那里抛出的异常传播给调用方，但事务仍被视为已提交
            - triggerAfterCommit(status)
             - triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED)
         4-  完成后进行清理，必要时清除同步，并调用doCleanupAfterCompletion
             - cleanupAfterCompletion(status)    
       
// 调用子类事务管理 , 此处使用 JpaTransactionManager
C04- JpaTransactionManager
    M04_01- doGetTransaction()
        ?- 该方法主要是对 JpaTransactionObject 的创建和处理
        1- setSavepointAllowed
        - TransactionSynchronizationManager.getResource  : 获取 EntityManagerHolder
        2- setEntityManagerHolder : 
        - TransactionSynchronizationManager.getResource(getDataSource()) : ConnectionHolder
        3- setConnectionHolder : 包装JDBC的资源持有者
    M04_02- doBegin(Object transaction, TransactionDefinition definition)
        1- 获取 M04_01 创建的 JpaTransactionObject
        2- txObject.getEntityManagerHolder().getEntityManager() : 获取 EntityManager
        3- determineTimeout(definition) : 准备超时时间
        4- getJpaDialect().beginTransaction : 委托给JpaDialect以开始实际的事务 -> PS:M04_02_05
        5- txObject.getEntityManagerHolder().setTimeoutInSeconds(timeoutToUse) : 如果超时 , 设置超时时间
        6-IF- 如果设置了JPA EntityManager的JDBC连接 
            - getJpaDialect().getJdbcConnection(em, definition.isReadOnly()) : 获取 ConnectionHandle
            - 通过 ConnectionHandle 生成 ConnectionHolder
            - TransactionSynchronizationManager.bindResource(getDataSource(), conHolder) : 
            - txObject.setConnectionHolder(conHolder)
         7- txObject.getEntityManagerHolder().setSynchronizedWithTransaction(true) : 将资源标记为与事务同步
      

// PS:M04_02_05 实际事务处理流程 : 主要是2句话
Object transactionData = getJpaDialect().beginTransaction(em,new JpaTransactionDefinition(definition, timeoutToUse, txObject.isNewEntityManagerHolder()));
txObject.setTransactionData(transactionData);


 // 流程处理的参数情况关注类
C- NativeSession # execSQL
// 1 
select orgentity0_.id as id1_0_0_, orgentity0_.org_name as org_name2_0_0_, orgentity0_.org_type as org_type3_0_0_ from org orgentity0_ where orgentity0_.id=?
select userentity0_.userid as userid1_1_0_, userentity0_.isactive as isactive2_1_0_, userentity0_.orgid as orgid3_1_0_, userentity0_.remark as remark4_1_0_, userentity0_.userlink as userlink5_1_0_, userentity0_.username as username6_1_0_, userentity0_.usertype as usertype7_1_0_ from user userentity0_ where userentity0_.userid=2177281
    
select orgentity0_.id as id1_0_0_, orgentity0_.org_name as org_name2_0_0_, orgentity0_.org_type as org_type3_0_0_ from org orgentity0_ where orgentity0_.id=5052474
select userentity0_.userid as userid1_1_0_, userentity0_.isactive as isactive2_1_0_, userentity0_.orgid as orgid3_1_0_, userentity0_.remark as remark4_1_0_, userentity0_.userlink as userlink5_1_0_, userentity0_.username as username6_1_0_, userentity0_.usertype as usertype7_1_0_ from user userentity0_ where userentity0_.userid=4412226

.......

java复制代码protected DefaultTransactionStatus newTransactionStatus(TransactionDefinition definition, @Nullable Object transaction, boolean newTransaction,boolean newSynchronization, boolean debug, @Nullable Object suspendedResources) {

    boolean actualNewSynchronization = newSynchronization &&!TransactionSynchronizationManager.isSynchronizationActive();
    return new DefaultTransactionStatus(transaction, newTransaction, actualNewSynchronization,
                definition.isReadOnly(), debug, suspendedResources);
}

java复制代码C03- AbstractPlatformTransactionManager
    M03_02- commit(TransactionStatus status)
    
    
// commit 主要逻辑
public final void commit(TransactionStatus status) throws TransactionException {
        if (status.isCompleted()) {
            throw new IllegalTransactionStateException(".....");
        }

        DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
        if (defStatus.isLocalRollbackOnly()) {
            processRollback(defStatus, false);
            return;
        }

        if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
            processRollback(defStatus, true);
            return;
        }
        
        // 核心调用逻辑 , 提交 commit 处理
        processCommit(defStatus);
}

java复制代码// 事务的回退主流程
C03- AbstractPlatformTransactionManager
    M03_03- processRollback(DefaultTransactionStatus status, boolean unexpected) : 处理实际回退, 检查已完成标志
        // Type 1 : 正常执行情况下的 Rollback
        1- triggerBeforeCompletion(status)
        2- triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK) 
        // Type 2 : 调用 doCallback 回滚的情况
        1- triggerBeforeCompletion(status)
        2- doRollback(status)
        3- triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK) 
    M03_05- triggerBeforeCompletion(status)
        1- TransactionSynchronizationUtils.triggerBeforeCompletion()
    M03_06- triggerAfterCompletion(status)
    M03_07- doRollback(status)
        ?- 这是一个需要子类实现的接口 , 以 JPA 为例 , 这里使用的 JpaTransactionManager
    
C04- JpaTransactionManager    
    F04_01- EntityManagerFactory entityManagerFactory;
    M04_03- doRollback  
         // Step 1 : 属性获取 -> PS:M04_03_01
         1- status.getTransaction() : 获取 JpaTransactionObject
         // Step 2 : 执行 EntityTransaction    
         2- txObject.getEntityManagerHolder().getEntityManager().getTransaction() -> PS:M04_03_02
         3- tx.rollback() -> PS:M04_03_03
            - 主要调用对象
         // Step 3 : finally 强制处理
         4- txObject.getEntityManagerHolder().getEntityManager().clear() 
        
        
C05- TransactionImpl
    M05_01- rollback
        - TransactionStatus status = getStatus() : 获取 TransactionStatus --> PS:M05_01_01
        - status.canRollback() : 是否可以回退 , 不可则抛出异常 --> PS:M05_01_02
        - internalGetTransactionDriverControl().rollback() : 执行回退 --> PS:M05_01_03
        
// 发起命令 callback

java复制代码C11- JdbcResourceLocalTransactionCoordinatorImpl
    M- rollback()

C12- AbstractLogicalConnectionImplementor
    M- rollback()
        - getConnectionForTransactionManagement().rollback()
            ?- 调用 ProxyConnection 
        - status = TransactionStatus.ROLLED_BACK
        
C13- ProxyConnection
    M13_01- rollback()

// M13_01 rollback() 源代码
public void rollback() throws SQLException{
      delegate.rollback();
      isCommitStateDirty = false;
      lastAccess = currentTime();
}
    
// 这里就涉及到 com.mysql.cj.jdbc
C14- ConnectionImpl
    M14_01- rollback()
        - rollbackNoChecks()
    
private void rollbackNoChecks() throws SQLException {
    synchronized (getConnectionMutex()) {
        if (this.useLocalTransactionState.getValue()) {
            if (!this.session.getServerSession().inTransactionOnServer()) {
                return; // effectively a no-op
            }
        }
        // 回退核心逻辑
        this.session.execSQL(null, "rollback", -1, null, false, this.nullStatementResultSetFactory, this.database, null, false);
    }
}
    

// 最终处理
C- NativeProtocol # sendQueryString
return sendQueryPacket(callingQuery, sendPacket, maxRows, streamResults, catalog, cachedMetadata, getProfilerEventHandlerInstanceFunction,
                resultSetFactory);

sendPacket -> rollback
    
// PS : 这里就涉及到 MySQL 的事务了 
MySQL的 ROLLBACK 命令用来回退（撤销）MySQL语句
    
START TRANSACTION or BEGIN 启动新事务.
COMMIT 提交当前事务，使其更改永久化.
ROLLBACK  回滚当前事务，取消其更改
SET 自动提交禁用或启用当前会话的默认自动提交模式。
    
默认情况下，MySQL 运行时启用了自动提交模式。这意味着，如果事务中没有其他语句，那么每个语句都是原子的，就好像它被 START TRANSACTION 和 COMMIT 包围了一样。不能使用 ROLLBACK 撤消该效果; 但是，如果在语句执行期间发生错误，将回滚该语句。
    
// 若要对一系列语句隐式禁用自动提交模式，请使用 START TRANSACTION 语句:
    
START TRANSACTION;
SELECT @A:=SUM(salary) FROM table1 WHERE type=1;
UPDATE table2 SET summary=@A WHERE type=1;
COMMIT;  
    
// 具体的可以参考官方文档 : https://dev.mysql.com/doc/refman/5.7/en/commit.html

java复制代码官方文档 @ https://dev.mysql.com/doc/refman/8.0/en/innodb-autocommit-commit-rollback.html

SQL复制代码CREATE TABLE customer (a INT, b CHAR (20), INDEX (a));

# 这里可以看到 , 此时运行可以直接插入
INSERT INTO customer VALUES (10, 'Heikki');

SQL复制代码
# Step 1 ：开启事务和自动提交
# 启用自动提交的会话可以通过以显式的 START TRANSACTION 或 BEGIN 语句开始并以 COMMIT 或 ROLLBACK 语句结束来执行多语句事务。
START TRANSACTION;


# Step 2 : 插入一条记录 , 在自动提交的前提下 , 一个 SQL 就是一个事务
INSERT INTO customer VALUES (10, 'Heikki');


# Step 3 : 提交 (提交之后 , 数据才正式添加)
# 如果一个禁用自动提交的会话在没有显式提交最终事务的情况下结束，MySQL 将回滚该事务。
# COMMIT 意味着当前事务中所做的更改是永久性的，并且对其他会话可见
COMMIT;

SQL复制代码# Step 1 : 设置非自动提交
# 如果在 setautocommit = 0的会话中禁用自动提交模式，则会话始终打开一个事务。COMMIT 或 ROLLBACK 语句结束当前事务并启动新事务。
SET autocommit=0;

# Step 2 : 插入所有的数据
INSERT INTO customer VALUES (15, 'John');
INSERT INTO customer VALUES (20, 'Paul');
DELETE FROM customer WHERE b = 'Heikki';

# Step 3 : 回滚事务
ROLLBACK;

# 可以看到 , DELETE Heikki 没有执行 , 第一条 插入成功
SELECT * FROM customer;

sql复制代码START TRANSACTION;
SET autocommit=0;
# Step 2 : 插入一条记录 , 在自动提交的前提下 , 一个 SQL 就是一个事务
INSERT INTO org VALUES (10,'111', 'Heikki');
INSERT INTO org VALUES (20,'222','Paul');
#DELETE FROM org WHERE id = 'Heikki';

# Step 3 : 回滚事务
ROLLBACK;

# 可以看到 , DELETE Heikki 没有执行 , 第一条 插入成功
SELECT * FROM org;

sql复制代码# 项目启动时
SET autocommit=1

# Step 1 : 进入方法
SET autocommit=0

# Step 2 : 执行 SQL
select userentity0_.userid as userid1_1_0_, userentity0_.isactive as isactive2_1_0_, userentity0_.orgid as orgid3_1_0_, userentity0_.remark as remark4_1_0_, userentity0_.userlink as userlink5_1_0_, userentity0_.username as username6_1_0_, userentity0_.usertype as usertype7_1_0_ from user userentity0_ where userentity0_.userid=3138559
select orgentity0_.id as id1_0_0_, orgentity0_.org_name as org_name2_0_0_, orgentity0_.org_type as org_type3_0_0_ from org orgentity0_ where orgentity0_.id=7614913tity0_.userlink as userlink5_1_0_, userentity0_.username as username6_1_0_, userentity0_.usertype as usertype7_1_0_ from user userentity0_ where userentity0_.userid=3138559

// Step 3 : 插入操作
insert into user .....
insert into org ........

commit
SET autocommit=1


// 如果出现异常 , 会调用 rollback
// PS : 若要保留自动提交 (SET autocommit=1)，请以 start transaction 开始每个事务，并以 COMMIT 或 ROLLBACK 结束

java复制代码protected Object doGetTransaction() {
    JpaTransactionObject txObject = new JpaTransactionObject();
    txObject.setSavepointAllowed(isNestedTransactionAllowed());
    // JPA中资源持有者的封装
    EntityManagerHolder emHolder = (EntityManagerHolder)
    // 管理每个线程的资源和事务同步的中央委托
    TransactionSynchronizationManager.getResource(obtainEntityManagerFactory());
    if (emHolder != null) {
        txObject.setEntityManagerHolder(emHolder, false);
    }
    
    if (getDataSource() != null) {
        // ConnectionHolder :包装JDBC的资源持有者
        // 对于特定的javax.sql. datasource，将这个类的实例绑定到线程。
        // 注意:这是一个SPI类，不打算被应用程序使用。
        ConnectionHolder conHolder = (ConnectionHolder)
        TransactionSynchronizationManager.getResource(getDataSource());
        txObject.setConnectionHolder(conHolder);
    }

    return txObject;
}

java复制代码protected void doBegin(Object transaction, TransactionDefinition definition) {
    
    // JPA事务对象，表示EntityManagerHolder。JpaTransactionManager用作事务对象。
    JpaTransactionObject txObject = (JpaTransactionObject) transaction;

    if (txObject.hasConnectionHolder() && !txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
        throw new IllegalTransactionStateException(....);
    }

    try {
        if (!txObject.hasEntityManagerHolder() ||txObject.getEntityManagerHolder().isSynchronizedWithTransaction()) {
            // 实体类管理器
            EntityManager newEm = createEntityManagerForTransaction();
            txObject.setEntityManagerHolder(new EntityManagerHolder(newEm), true);
        }

        EntityManager em = txObject.getEntityManagerHolder().getEntityManager();
        final int timeoutToUse = determineTimeout(definition);
        // 开始一个事务
        Object transactionData = getJpaDialect().beginTransaction(em,new JpaTransactionDefinition(definition, timeoutToUse, txObject.isNewEntityManagerHolder()));
        // 为当前事务对象标明事务属性
        txObject.setTransactionData(transactionData);

        if (timeoutToUse != TransactionDefinition.TIMEOUT_DEFAULT) {
            // 控制超时时间
            txObject.getEntityManagerHolder().setTimeoutInSeconds(timeoutToUse);
        }

        if (getDataSource() != null) {
            // 连接管理 , 执行相关的连接操作
            ConnectionHandle conHandle = getJpaDialect().getJdbcConnection(em, definition.isReadOnly());
            if (conHandle != null) {
                ConnectionHolder conHolder = new ConnectionHolder(conHandle);
                    if (timeoutToUse != TransactionDefinition.TIMEOUT_DEFAULT) {
                        conHolder.setTimeoutInSeconds(timeoutToUse);
                    }
                    // 这里绑定了资源 , 把一个数据库数据绑定为了映射对象
                    // TODO : 这里应该就是三态变化的核心 , 以后看看
                    TransactionSynchronizationManager.bindResource(getDataSource(), conHolder);
                    txObject.setConnectionHolder(conHolder);
            } else {
                //log.....
            }
        }

        if (txObject.isNewEntityManagerHolder()) {
            TransactionSynchronizationManager.bindResource(obtainEntityManagerFactory(), txObject.getEntityManagerHolder());
        }
        // 将资源标记为与事务同步
        txObject.getEntityManagerHolder().setSynchronizedWithTransaction(true);
    } catch (TransactionException ex) {
        closeEntityManagerAfterFailedBegin(txObject);
        throw ex;
    } catch (Throwable ex) {
        closeEntityManagerAfterFailedBegin(txObject);
        throw new CannotCreateTransactionException("Could not open JPA EntityManager for transaction", ex);
    }
}