spring编写组件之分布式组件

比眉伴天荒 2022-12-29 09:11 77阅读 0赞

引入maven依赖的相关jar包

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-integration</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.integration</groupId>
        <artifactId>spring-integration-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

1.编写注解

package com.online.taxi.order.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface DistributedLock {
    
        String value() default "";
    
        int time() default 30;
    }

2.解析注解

package com.online.taxi.order.annotation;
    
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.integration.redis.util.RedisLockRegistry;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.WebApplicationContext;
    
    import java.lang.reflect.Method;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Lock;
    
    @Component
    @Aspect
    @Slf4j
    public class LockAop {
    
        private WebApplicationContext webApplicationContext;
    
        public LockAop(WebApplicationContext webApplicationContext) {
            this.webApplicationContext = webApplicationContext;
        }
    
        @Pointcut("@annotation(com.online.taxi.order.annotation.DistributedLock)")
        private void apiAop(){
    
        }
    
        @Around("apiAop()")
        public Object aroundApi(ProceedingJoinPoint point) throws Throwable {
            MethodSignature signature = (MethodSignature) point.getSignature();
            Method method = signature.getMethod();
            Object[] args = point.getArgs();
            System.out.println(args[0]);
            DistributedLock lockDistributed = method.getAnnotation(DistributedLock.class);
    
    
            RedisLockRegistry redisLockRegistry = (RedisLockRegistry) webApplicationContext.getBean(lockDistributed.value());
    
            Lock lock = redisLockRegistry.obtain(signature.getName()+"_"+args[0]);
            boolean b = false;
            for(int i =0 ; i<3;i++){
                b = lock.tryLock(lockDistributed.time(), TimeUnit.SECONDS);
                if(b){
                    break;
                }else {
                    continue;
                }
            }
            log.info("获取锁:"+b);
            Object proceed = null;
            try{
                proceed = point.proceed();
            }catch (Exception e){
                throw e;
            }finally {
                try{
                    lock.unlock();
                }catch (Exception e){
    //                log.error(e.getMessage(),e);
                    System.out.println("没锁");
                }
            }
    
    
            return proceed;
    
        }
    
    }

增加配置信息，将RedisLockRegistry 注册进来

package com.online.taxi.order.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.integration.redis.util.RedisLockRegistry;
    
    @Configuration
    public class RedisLockConfiguration {
      @Bean
      public RedisLockRegistry redisLockRegistry(RedisConnectionFactory redisConnectionFactory) {
        return new RedisLockRegistry(redisConnectionFactory, "order_lock");
      }
    }

分布式锁的接口

package com.online.taxi.order.service;
    
    public interface GrabService {
    
        /**
         * 司机抢单
         * @param orderId
         * @param driverId
         * @return
         */
        public String grabOrder(int orderId , int driverId);
    }

分布式锁的实现类

package com.online.taxi.order.service.impl;
    
    import com.online.taxi.order.annotation.DistributedLock;
    import com.online.taxi.order.annotation.DistributedLock;
    import com.online.taxi.order.service.GrabService;
    import com.online.taxi.order.service.OrderService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.concurrent.TimeUnit;
    
    
    @Service("cloudService")
    public class CloudServiceImpl implements GrabService {
    
        @Autowired
        OrderService orderService;
    
        @Override
        @DistributedLock(value = "redisLockRegistry",time = 10)
        public String grabOrder(int orderId, int driverId) {
    
            System.out.println("司机:" + driverId + " 执行抢单逻辑");
    
            boolean b = orderService.grab(orderId, driverId);
            if (b) {
                System.out.println("司机:" + driverId + " 抢单成功");
            } else {
                System.out.println("司机:" + driverId + " 抢单失败");
            }
    
            return null;
        }
    }

orderService为真正的业务类

将需要分布式锁的代码上增加该注解即可

controller层应用

package com.online.taxi.order.controller;
    
    
    import com.online.taxi.order.service.GrabService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.web.bind.annotation.*;
    
    
    @RestController
    @RequestMapping("/grab")
    public class GrabOrderController {
    
        @Autowired
        @Qualifier("cloudService")
        private GrabService grabService;
    
        @GetMapping("/do/{orderId}")
        public String grab(@PathVariable("orderId") int orderId, int driverId){
            System.out.println("order:"+orderId+",driverId:"+driverId);
            grabService.grabOrder(orderId,driverId);
            return "";
        }
    }

写组件应该注意的点：对业务代码无侵入性，增加注解即可，可插拔。引入需要的组件jar包，然后增加相应注解，就能完成对应的功能

设计分布式锁的原则：

*  互斥锁，同一个资源只能由一个线程抢占
 *  防死锁
 *  自己的锁自己释放
 *  容错性 n个redis