BigFish's Blog

2022-02-03发表2025-04-16更新架构7 分钟读完 (大约1066个字)

DDD 架构思考和实践

为什么要考虑学习 DDD架构

在学习 DDD 架构前，一直觉得三层架构结构在业务复杂的场景会带来很多很多的问题，但是一直都处于模糊不清的形态，无法准确的定义。直到学习了DDD 的概念。

为了更好的学习 DDD ，我们总结一下三层架构在业务复杂的场景带来的问题，首先看下正常的项目依赖图

我们正常有 5 个模块，UI(application), Service，Repository，Entity 和 Common，每个层代表的含义，大家都非常清楚，这样会带来什么样的问题呢？

Service 层对 Repository 依赖比较乱，没有明确的规则和界限
虽然 Repository 对 Enity 是一对一的依赖，但是由于 Service 和 Repository 的依赖的 “混乱”，导致 Entity 的引用带来同样的问题
每一个层级都对 Common 都有依赖，使得 Common 层从辅助层变成了核心层。

2020-02-29发表2025-04-16更新付威几秒读完 (大约86个字)

一个秒杀系统的设计

一直想写一个秒杀系统的设计，网上有烂大街的教程，虽然有的写得很不错，但是还是自己设计的来的清楚，基本思路就是拦截+负载+缓存+异步,流程如下（文字改天补上）：

2019-10-31发表2025-04-16更新付威 4 分钟读完 (大约659个字)

分布式队列的几个名词和解释--以kafka为例

Topic 或者Subject

每一个生产者都需要向队列中生产消息，不同的生产者生产消息需要有所区别，供对应的消费者消费消息，这个是队列名称之为 Topic或者Subject

MessageLog，ConsumerLog

队列的消息需要一个存储的介质，Kafka的对应的存储为文件存储，生产者生产的消息存储在MessageLog, 然后根据不同的消费和路由规则路由，投递到对应的服务器上面，产生对应的ConsumerLog.

2019-08-10发表2025-04-16更新付威 6 分钟读完 (大约899个字)

TCP三次握手和四次挥手

三次握手–连接

在通信的过程中，Client与Server建立TCP连接需要三次握手，为什么需要三次握手呢？又是怎么握手的过程？

TCP连接是可靠的通信方式，必须要保证两端都同时有效，且线路通畅。

如同两个人通话，但并不确定对方能不能听到，经历几次才能确保通信方式可靠呢？

2019-07-20发表2025-04-16更新付威 7 分钟读完 (大约987个字)

redis分布式锁的问题和解决

分布式锁

在分布式环境中，为了保证业务数据的正常访问，防止出现重复请求的问题，会使用分布式锁来阻拦后续请求。具体伪代码如下：

public void doSomething(String userId){
    User user=getUser(userId);
    if(user==null){
        user.setUserName("xxxxx");
        user.setUserId(userId);
        insert(user);
        return;
    }
    update(user);
}

上面的代码很简单，查询db中有没有对应的user数据，如果有的话，执行更新操作，如果没有则插入。

我们知道，上面的代码是线程不安全的，在多线程的环境中，就会出现问题。为了能够保证数据的正确性，在单机环境下，我们可以使用synchronized的方法，来保证线程安全，具体修改：

public synchronized void doSomething(String userId){
    User user=getUser(userId);
    if(user==null){
        user.setUserName("xxxxx");
        user.setUserId(userId);
        insert(user);
        return;
    }
    update(user);
}

在单机器的环境下，能够解决线程安全的问题，那在分布式环境下呢？这个时候需要用到分布式锁.

分布式锁需要借助其他组件来实现，常用的有redis和zookeeper。下面我们就用redis的实现，来说明下问题，分布式锁具体的实现方法如下：

public  void doSomething(String userId){
    String lock=RedisUtils.get("xxxx"+userId);
    if(StringUtils.isNotEmpty(lock)){//说明当前userId已经被锁定
        return;
    }
    RedisUtils.set("xxxx"+userId,userId,1000);//锁定10s
    User user=getUser(userId);
    if(user==null){
        insert(user);
        RedisUtils.delete("xxxx"+userId);
        return;
    }
    update(user);
    RedisUtils.delete("xxxx"+userId);
    
}

上面的代码解决了在分布式环境中的并发的问题。但同样需要考虑一个问题，如果insert操作和update操作异常了，分布式锁不会释放，后续的请求还会被拦截。

所以我们再优化，增加对异常的捕获。

public  void doSomething(String userId){
    try {
            String lock=RedisUtils.get("xxxx"+userId);
            if(StringUtils.isNotEmpty(lock)){//说明当前userId已经被锁定
                return;
            }
            RedisUtils.set("xxxx"+userId,userId,1000);//锁定1s
            User user=getUser(userId);
            if(user==null){
                insert(user);
                return;
            }
            update(user);
    }
    catch(Exception ex){

    }
    finally{
        RedisUtils.delete("xxxx"+userId);
    }
}

现在即使是程序异常了，锁会自动释放。但redis的get和set也会存在并发问题，我们再继续优化，使用redis中的setnx方法。

public  void doSomething(String userId){
    try {
            boolean lock=RedisUtils.setnx("xxxx"+userId,userId,1000);//锁定1s
            if(!lock){//说明当前userId已经被锁定
                return;
            }
            User user=getUser(userId);
            if(user==null){
                insert(user);
                return;
            }
            update(user);
    }
    catch(Exception ex){

    }
    finally{
        RedisUtils.delete("xxxx"+userId);
    }
}

上面的代码好像没有什么问题了，但也存在很大的隐患。
我们分析下，假设第一个请求过来，执行锁定成功，程序开始运行，但是insert和update操作阻塞了1s，第二个请求过来，锁的缓存已经过期，第二个执行锁定成功，这个时候第一个请求完成了锁被释放，第二个请求的锁就被第一次请求释放了，第三次的请求就会造成线程不安全问题。

怎么再去优化呢？问题主要是出现在第一次请求误删锁的问题，所以我们在移除锁的时候要判断能否移除。

思路：我们在锁定的时候，value使用当前的时间戳，删除时判断是否过期如果不过期就不要删除，具体代码如下：

public  void doSomething(String userId){
    try {
            boolean lock=RedisUtils.setnx("xxxx"+userId,LocalDateTime.now(),1000);//锁定10s
            if(!lock){//说明当前userId已经被锁定
                return;
            }
            User user=getUser(userId);
            if(user==null){
                insert(user);
                return;
            }
            update(user);
    }
    catch(Exception ex){

    }
    finally{
        LocalDateTime lockTIme=	RedisUtils.get("xxxx"+userId);
        if(lockTIme.compare(LocalDateTime.now())<0){
            //说明已经过期，可以删除key
            RedisUtils.delete("xxxx"+userId);
        }
    }
}

这样即使出现阻塞，第二次的时间戳覆盖了第一次的锁定，这样即使第一次完成了，也不会释放锁。

为什么要考虑学习 DDD架构

Topic 或者Subject

MessageLog，ConsumerLog

三次握手–连接

分布式锁

归档

标签

最新文章

分类

Your browser is out-of-date!