XA协议详细介绍一下

发表于 2024-10-14 更新于 2025-01-17 分类于分布式事务 Valine：

XA协议详细介绍一下

XA协议是由X/Open组织定义的一种分布式事务处理协议，旨在协调多个资源管理器（如数据库）之间的分布式事务，使得跨多个系统的事务能够遵循ACID（原子性、一致性、隔离性、持久性）原则。XA协议的核心机制是两阶段提交（Two-Phase Commit, 2PC），它通过协调器来管理事务在多个资源之间的提交与回滚。

XA协议的核心概念

事务管理器（Transaction Manager, TM）：负责管理整个事务的生命周期。它协调各个资源管理器的事务状态，并决定是否提交或回滚事务。
资源管理器（Resource Manager, RM）：资源管理器通常是数据库、消息队列或其他可以进行事务操作的系统。RM负责管理资源的本地事务，并与事务管理器进行通信。
应用程序（Application, AP）：发起事务的主体，它通过事务管理器来控制整个分布式事务的开始、提交和回滚操作。

XA协议的工作流程

XA协议基于两阶段提交协议（2PC）来实现事务的一致性。它将事务的提交过程分为两个阶段：准备阶段和提交阶段。

1. 第一阶段：Prepare（准备阶段）

当应用程序请求提交事务时，事务管理器会向每个资源管理器发送prepare请求。
每个资源管理器在接到请求后，会尝试执行事务操作，并在本地记录事务日志，确保事务的可提交性。
如果资源管理器能够成功执行，则返回prepared状态；如果某个资源管理器发现问题，返回rollback状态。

2. 第二阶段：Commit/Rollback（提交/回滚阶段）

如果所有资源管理器都返回prepared状态，事务管理器会向所有资源管理器发送commit命令，要求它们真正提交事务。
如果有任何一个资源管理器返回失败，事务管理器会发送rollback命令，通知所有资源管理器回滚事务。
资源管理器在收到commit或rollback命令后，执行相应操作并返回最终状态。

XA协议的优点

一致性保证：通过两阶段提交，XA协议确保了所有参与的资源管理器要么全部提交，要么全部回滚，保证了分布式系统中事务的一致性。
标准化：XA是一个标准协议，很多数据库（如MySQL、PostgreSQL、Oracle）都原生支持XA事务，开发人员可以在多种系统间使用同样的接口进行事务处理。

XA协议的缺点

性能开销：由于两阶段提交涉及多次网络通信和磁盘操作，XA协议可能引入较高的性能开销，尤其是在大规模分布式系统中。
阻塞问题：在第二阶段，资源管理器会一直等待事务管理器的指令（提交或回滚），如果事务管理器长时间没有响应，资源管理器的事务资源可能会被锁定，导致阻塞。
单点故障：事务管理器在整个协议中扮演了核心协调角色，如果事务管理器出现故障，可能会导致分布式事务无法继续进行。

典型应用场景

跨数据库事务：当一个应用程序需要在多个数据库中同时执行事务时，可以使用XA协议确保事务的一致性。
消息队列与数据库集成：例如在金融交易系统中，消息的写入与数据库更新必须同步进行，否则可能会导致数据不一致。

常见的XA支持

许多数据库和中间件都支持XA协议：

关系型数据库：Oracle、MySQL、PostgreSQL、DB2等。
消息中间件：ActiveMQ、RabbitMQ等。
应用服务器：Tomcat、JBoss、WebLogic等支持JTA（Java Transaction API）规范的服务器。

总结

XA协议通过两阶段提交确保了分布式事务的强一致性，但其性能开销和可能的阻塞问题使得它在某些场景下并不理想。现代分布式系统中，XA事务通常会与其他分布式一致性方案（如TCC、SAGA、最终一致性等）结合使用，以实现更好的性能与可用性。

分布式事务框架有哪些

发表于 2024-10-14 更新于 2025-01-17 分类于分布式事务 Valine：

分布式事务框架有哪些

分布式事务框架是用于管理分布式系统中跨多个数据库或服务的事务一致性的工具。以下是一些常见的分布式事务框架：

XA协议：XA协议是一种标准的分布式事务协议，通过两阶段提交（Two-Phase Commit）来实现事务的一致性，常用于关系型数据库的分布式事务管理。
Spring Cloud 分布式事务：Spring Cloud提供了多种分布式事务解决方案，如Spring Cloud Netflix中的Hystrix、Feign等，以及Spring Cloud Alibaba中的Seata等。
Atomikos：Atomikos是一个Java事务管理器，支持JTA（Java Transaction API）标准，用于管理分布式事务的提交和回滚。
Bitronix：Bitronix也是一个流行的Java事务管理器，支持JTA，并提供了用于Web容器和应用服务器的集成。
Narayana（前身为JBoss Transactions）：Narayana是一个开源的Java事务管理器，提供了广泛的分布式事务支持，包括XA事务和高可用性配置。
Seata：Seata是阿里巴巴开源的一款分布式事务解决方案，支持AT（原子操作）、TCC（Try-Confirm-Cancel）和XA三种事务模式，适用于云原生场景。
TCC-Transaction：TCC（Try-Confirm-Cancel）是一种逻辑事务模式，通过分阶段执行来保证分布式系统的事务一致性，一般在微服务架构中使用较多。

这些框架和协议各有特点，选择时需要考虑系统架构、性能需求、支持的技术栈以及对事务一致性的具体要求。

挑战leetcode前50道

发表于 2024-10-12 更新于 2025-01-17 分类于 leetcode Valine：

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

示例 1：

1
2
3

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

1 2	输入：nums = [3,2,4], target = 6 输出：[1,2]

示例 3：

1 2	输入：nums = [3,3], target = 6 输出：[0,1]

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

思路：

简单直观的思路是，两轮循环，暴力枚举所有可能的组合，相加判断是否等于目标值，但是题目要求时间复杂度小于 O(n2)，因此这种方法不行。换一种思路一次遍历值为x，如何在o(1)时间复杂度寻找target-x，使用哈希表可以做到，使用空间换时间，时间复杂度为O(n)，空间复杂度也为O(n)。

解法：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {
            if (!hashMap.containsKey(target - nums[i])) {
                hashMap.put(nums[i], i);
            } else {
                return new int[]{hashMap.get(target - nums[i]), i};
            }
        }
        return new int[]{};
    }
}

java中将json字符串转化成对象

发表于 2024-10-11 更新于 2025-01-17 分类于 java Valine：

java中将json字符串转化成对象

在 Java 中将 JSON 转化为对象，通常使用 JSON 解析库来实现。最常用的 JSON 解析库是 Jackson 和 Gson。下面介绍如何使用 Jackson 和 Gson 将 JSON 字符串转换为 Java 对象。

1. 使用 Jackson 将 JSON 转化为对象

Jackson 是一个功能强大的 JSON 处理库。它的 ObjectMapper 类可以轻松地将 JSON 转化为 Java 对象。

步骤：

添加 Jackson 依赖（Maven 项目）：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.3</version>
</dependency>

定义 Java 类（假设 JSON 表示一个 Person 对象）：

public class Person {
    private String name;
    private int age;

    // Getters and Setters
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

使用 Jackson 的 ObjectMapper 将 JSON 字符串转换为 Java 对象：

import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) {
        String json = "{\"name\":\"John\", \"age\":30}";

        ObjectMapper objectMapper = new ObjectMapper();
        try {
            Person person = objectMapper.readValue(json, Person.class);
            System.out.println("Name: " + person.getName());
            System.out.println("Age: " + person.getAge());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出：

1 2	Name: John Age: 30

2. 使用 Gson 将 JSON 转化为对象

Gson 是由 Google 提供的轻量级 JSON 处理库，它可以很方便地将 JSON 转化为 Java 对象。

步骤：

添加 Gson 依赖（Maven 项目）：

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
</dependency>

定义 Java 类（与 Jackson 示例中的 Person 类相同）。
使用 Gson 将 JSON 字符串转换为 Java 对象：

import com.google.gson.Gson;

public class Main {
    public static void main(String[] args) {
        String json = "{\"name\":\"John\", \"age\":30}";

        Gson gson = new Gson();
        Person person = gson.fromJson(json, Person.class);

        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

输出：

1 2	Name: John Age: 30

总结：

Jackson：功能强大、广泛使用，支持更多的高级功能（如流处理、注解等）。
Gson：轻量级，简单易用，适合基础的 JSON 解析。

两者都可以轻松将 JSON 转换为 Java 对象，具体使用哪一个可以根据项目需求来选择。

3. 使用 fastjson将 JSON 转化为对象

fastjson 是阿里巴巴开发的一款高效 JSON 解析库，它比 Jackson 和 Gson 更加轻量级和高效。使用 fastjson 可以快速将 JSON 字符串转换为 Java 对象。

使用 fastjson 将 JSON 转化为对象

步骤：

添加 fastjson 依赖（Maven 项目）：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>

定义 Java 类（与之前示例中的 Person 类相同）：

public class Person {
    private String name;
    private int age;

    // Getters and Setters
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

使用 fastjson 将 JSON 字符串转换为 Java 对象：

import com.alibaba.fastjson.JSON;

public class Main {
    public static void main(String[] args) {
        String json = "{\"name\":\"John\", \"age\":30}";

        // 使用 Fastjson 的 JSON 类将 JSON 字符串转换为 Java 对象
        Person person = JSON.parseObject(json, Person.class);

        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

输出：

1 2	Name: John Age: 30

使用 fastjson 将对象转换为 JSON 字符串

Fastjson 还支持将 Java 对象转换为 JSON 字符串，类似于其他 JSON 解析库的 toJson() 方法。

import com.alibaba.fastjson.JSON;

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("John");
        person.setAge(30);

        // 将对象转换为 JSON 字符串
        String jsonString = JSON.toJSONString(person);

        System.out.println("JSON String: " + jsonString);
    }
}

输出：

1	JSON String: {"age":30,"name":"John"}

总结：

Fastjson 提供了高效的 JSON 解析能力，并且使用方式简洁易懂。
和 Jackson、Gson 一样，Fastjson 也可以快速将 JSON 字符串转换为 Java 对象，并且能将对象转换回 JSON 字符串。

kaka从入门到精通（window版本）—图文详细

发表于 2022-05-08 更新于 2025-01-17 分类于中间件 Valine：

kaka从入门到精通（window版本）—图文详细

kafka在分布式消息中间件中具有举足轻重的地位，能够实时收集大量的数据，下面我们开始详细介绍。

下载kafka

访问网站https://kafka.apache.org/downloads

点击下载 kafka_2.12-3.1.0.tgz这个版本

阅读全文 »

Double Pointer

发表于 2022-05-06 更新于 2025-01-17 分类于博客 Valine：

双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。

Two Sum

Input array is sorted (Easy)

题目描述

　　在一个增序的整数数组里找到两个数，使它们的和为给定值。已知有且只有一对解。

输入输出样例

　　输入是一个数组和一个给定值。输出是两个数的位置，从１开始计数。

1 2	Input: numbers = [2, 7, 11, 15], target = 9 Output: [1, 2]

c++:

vector<int> twoSum(vector<int>& numbers, int target) {
    int l = 0, r = numbers.size() - 1, sum;
    while (l < r) {
        sum = numbers[l] + numbers[r];
	if (sum == target) break;
	if (sum < target) ++l;
 	else --r;
    }
    return vector<int>{l + 1, r + 1};

java:

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int[] indexs = new int[2];
        int left = 0;
        int right = numbers.length - 1;
        while (left < right) {
            if ((numbers[left] + numbers[right]) == target) {
                indexs[0] = left + 1;
                indexs[1] = right + 1;
                break;
            } else if ((numbers[left] + numbers[right]) > target) {
                right--;
            } else {
                left++;
            }
        }
        return indexs;
    }
}

归并两个有序数组

Merge Sorted Array (Easy)

题目描述

　　给定两个有序数组，把两个合并成一个。

输入输出样例

　　输入是两个数组和他们分别的长度m和n。其中第一个数组的长度被延长至m+n,多出的n位被0填充。题目要求把第二个数组归并到第一个数组上，不需要开辟额外空间。

1 2	Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2, 5, 6], n = 3 Output: nums1 = [1,2,2,3,5,6]

c++:

void merge(vector<int>& nums1, vector<int>& nums2, int m, int n) {
    int pos = m-- + n-- - 1;
    while (m >= 0 && n >= 0) {
        nums1[pos--] = nums1[m] > nums2[n] ? nums1[m--] : nums2[n--];
    }
    while (n >=0) {
        nums1[pos--] = num2[n--];
    }
}

java:

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int len = m + n;
        for (int i = len - 1; i >= 0; i--) {
            if (m == 0 && n == 0) {
                return;
            }
            if (n <= 0 && m > 0) {
                nums1[i] = nums1[m - 1];
                m--;
                continue;
            }
            if (m <= 0 & n > 0) {
                nums1[i] = nums2[n - 1];
                n--;
                continue;
            }
            if (nums1[m - 1] > nums2[n - 1]) {
                nums1[i] = nums1[m - 1];
                m--;
            } else {
                nums1[i] = nums2[n - 1];
                n--;
            }
        }
    }
}

快慢指针

Linked List Cycle (Medium)

题目描述

给定一个链表，如果有环路，找出环路的开始点。

输入输出样例

　　输入是一个链表，输出是链表的一个节点，如果没有环路，返回一个空指针。
　　链表数据结构:

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

c++:

ListNode *detectCycle(ListNode *head) {
    ListNode *fast = head, *slow = head;
    do {
        if (!fast || !fast->next) return nullptr;
        fast = fast -> next -> next;
	slow = slow -> next;
    } while (fast != slow);

    while (fast != next) {
        fast = fast -> next;
        slow = slow -> slow;
    }
    return fast;
}

java:

/**
 * f=2s
 * f=s+nb
 * s=nb
 * f=2nb
 * k=a+nb
 * 简直就是数学题
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode slow = head;
        ListNode fast = head;
        ListNode result = null;
//        第一次相遇
        while (true) {
            slow = slow.next;
            fast = fast.next;
            if (fast == null) {
                return null;
            } else {
                fast = fast.next;
            }
            if (fast == null) {
                return null;
            }
            if (slow == fast) {
                break;
            }
        }
        fast = head;
//        第二次相遇
        while (true) {
            if (slow == fast) {
                return slow;
            }
            slow = slow.next;
            fast = fast.next;
        }
    }
}

滑动窗口

Minimum Window Substring (Hard)

题目描述

给定两个字符串S和T,求S中包含T所有字符的最短连续子字符串的长度, 同时要求时间复杂度不得超过O(n)。

输入输出样例

输入是两个字符串S和T,输出是一个S字符串的子串。

Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"

c++:
```c++
string minWindow(string S, string T) {
    //先统计T中的字符情况
    vector<int> chars(128, 0);
    vector<bool> flags(128, false);
    for (auto i : T) {
        ++chars[i];
        flags[i] = true;
    }
    //先确定S是否包含T,再滑动窗口
    int cnt = 0, l = 0, min_l = 0, min_size = S.size() + 1;
    for (auto r : S) {
        if (flags[r]) {
            if (--chars[r] > 0)
                ++cnt;
        //s都包含T后，探索最短字符串
            while (cnt == T.size()) {
                if (r - l + 1 < min_size) {
                    min_l = l;
                    min_size = r - l + 1;
                }
                if (flags[S[l]] && ++chars[S[l]] > 0) {
                    --cnt;
                }
                ++l;
            }
        }            
    }
    return min_size < S.size() ? "" : S.substr(min_l, min_size);
}

java:

class Solution {
    public String minWindow(String s, String t) {
        HashMap<Character, Integer> hs = new HashMap<Character, Integer>();
        HashMap<Character, Integer> ht = new HashMap<Character, Integer>();
        String ans = "";
        for (int i = 0; i < t.length(); i++) {
            ht.put(t.charAt(i), ht.getOrDefault(t.charAt(i), 0) + 1);
        }
        Integer cnt = 0;
        Integer max = Integer.MAX_VALUE;
        for (int i = 0, j = 0; j < s.length(); j++) {
            hs.put(s.charAt(j), hs.getOrDefault(s.charAt(j), 0) + 1);
            if (ht.containsKey(s.charAt(j)) && ht.get(s.charAt(j)) >= hs.get(s.charAt(j))) {
                cnt++;
            }
            while (i < j && (!ht.containsKey(s.charAt(i)) || ht.get(s.charAt(i)) < hs.get(s.charAt(i)))) {
                hs.put(s.charAt(i), hs.get(s.charAt(i)) - 1);
                i++;
            }
            if (cnt == t.length()) {
                Integer cur = j - i + 1;
                if (cur < max) {
                    max = cur;
                    ans = s.substring(i, j + 1);
                }
            }
        }
        return ans;
    }
}

springboot-swagger

发表于 2022-04-26 更新于 2025-01-17 分类于日志 Valine：

springboot集成Swagger（springdoc-openapi-ui版本）—图文详细

对于快速迭代的软件开发，会导致软件文档中的API不能及时更新，不同项目组之间的代码协同问题出现了较大的挑战，因此本文简单实验springboot集成swagger动态生成文档，可以边开发代码边生成文档，由于springfox版本老旧已经不在维护，本文使用springdoc方式集成。

使用IDEA快速搭建springboot项目

如果已经搭建好了springboot项目可以跳过这一步

点击左上角菜单New，选择Project

使用Spring Initializr方式创建springboot项目，选择jdk为本地安装的1.8版本，点击下一步

阅读全文 »

elk-log-window

发表于 2022-04-23 更新于 2025-01-17 分类于日志 Valine：

ELK搭建开源日志系统（window版本）—图文详细

日志对于排查错误非常重要，使用linux命令awk sed grep find等命令查询日志非常麻烦，而且很难做数据分析，使用免费开源的ELK可以支撑大规模的日志检索，本文将一步步教怎么快速搭建一个window版本的ELK日志收集系统。

下载elasticsearch、logstash、kibana、filebeat

注意同一系列的版本要一样，防止出现版本不兼容问题，本文使用7.16.0版本，在window系统演示

下载elasticsearch

访问地址为：https://www.elastic.co/cn/downloads/past-releases

点击Donload下载

阅读全文 »

Greddy Algorithm

发表于 2022-04-22 更新于 2025-01-17 分类于博客 Valine：

贪心算法采用贪心的策略，保证每步都是局部最优，最终达到全局最优

分配问题

455.Assign Cookies (Easy)

题目描述

　　有一群孩子和一堆饼干，每个孩子都有一个饥饿度，每个饼干都有一个大小，每个孩子只能吃最多一个饼干，且只有饼干的大小大于孩子的饥饿度时，这个孩子才能吃饱。求解最多有多少孩子可以吃饱。

输入输出样例

　　输入两个数组，分别代表孩子们的饥饿度和饼干的大小。输出最多有多少孩子可以吃饱的数量。

1 2	Input: [1, 2], [1, 2, 3] Output: 2

c++:

int findContentChildren(vector<int>& children, vector<int>& cookies) {
    sort(children.begin(), children.end());
    sort(cookies.begin(), cookies.end());
    int child = 0, cookie = 0;
    while (child < children.size() && cookie < cookies.size()) {
        if (children[child] <= cookies[cookie]) ++child;
        ++cookie;
    }
    return child;
}

java:

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        int max = 0;
        Arrays.sort(g);
        Arrays.sort(s);
        for (int i = 0, j = 0; i < s.length & j < g.length; i++) {
            if (g[j] <= s[i]) {
                max++;
                j++;
            }
        }
        return max;
    }
}

阅读全文 »

idea-debug-spring

发表于 2022-01-05 更新于 2025-01-17 分类于源码 Valine：

IDEA调试spring框架源码—图文详细

spring源码是java学习的核心，如果我们想要修改源码，例如加一些注释什么的，需要会编译源码，因此本文一步步教大家如何编译spring框架源码。

下载spring框架源码到本地

由于github比较慢，使用码云Spring-Framework拉取代码
阅读全文 »