# enlight-spring-boot-starter

**Repository Path**: relorry/enlight-spring-boot-starter

## Basic Information

- **Project Name**: enlight-spring-boot-starter
- **Description**: 英莱特自定义starter，开箱急用。目前支持分布式id，分布锁。支付，极光推送，阿里云物联网平台后续集成中。
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 2
- **Forks**: 0
- **Created**: 2024-06-01
- **Last Updated**: 2024-07-18

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 英莱特快速开发插件
英莱特（Enlight）是一款开源快速开发插件，目前集成分布式锁和分布式 ID 生成器、队列等。它可以帮助你在分布式系统中管理分布式id、锁等，避免手动开发，不需要知道原理配置即可用。

## 集成分布式锁：

- 引入分布式锁组件： 根据英莱特提供的文档或示例，引入并配置分布式锁组件到你的项目中。 
- 使用分布式锁： 根据英莱特提供的API文档或示例代码，使用其提供的接口来实现分布式锁的功能。
1. yaml配置
```yaml
enlight:
  lock:
    enable: true
    type: zookeeper # 锁采用redis实现方式
    redis:
      address: redis://localhost:6379
      password: 1234
      database: 7
      waitTime: 30
      leaseTime: 30
    zookeeper:
      address: localhost:2181
      waitTime: 30
      leaseTime: 30
      connection-time-out: 50000 #连接超时时间 毫秒
      session-time-out: 50000 #session超时时间 毫秒
      sleep-time-out: 3000 #重试初试时间 毫秒
      max-retries: 3 #重试次数
      wait-connect-time: 20000 #连接等待时间 毫秒
      name-space: curator #命名空间
```

2. 编码加锁
```java
@RunWith(SpringRunner.class)
@SpringBootTest
@TestPropertySource(properties = "classpath:application.yaml")
@ContextConfiguration(classes = {
        EnlightLockAutoConfiguration.class,
        EnlightRedisLockAutoConfiguration.class
})
@EnableAspectJAutoProxy
public class RedisLockTest {


    @Autowired
    private ApplicationContext applicationContext;

    /**
     * 测试把 EnlightRedisLockAutoConfiguration 注释打开@Bean
     */
    @Resource
    RobRedPacket redPacket;

    @Resource
    EnlightLockContext enlightLockContext;

    /**
     * 模拟测试 100个人（类似于100个移动端）抢 98元每个人公平抢1块钱
     * <p>
     * 然后分别用分布式锁和不加锁(testRedisLockNoLock)来测试
     *
     * 线程不安全
     */
    @Test
    public void testRedisLockNoLock() {
        // 组装100个用户
        ThreadUtil.concurrencyTest(100,new Runnable() {
            @Override
            public void run() {
                redPacket.rob1(Thread.currentThread().getName());
            }
        });
    }

    /**
     * 可以锁住
     */
    @Test
    public void testRedisLockUseLock() {

        // 组装100个用户
        ThreadUtil.concurrencyTest(100,new Runnable() {
            @Override
            public void run() {
                redPacket.rob2(Thread.currentThread().getName());
            }
        });

        // 获取锁客户端工厂
        EnlightLockClientFactory enlightLockFactory = enlightLockContext.getEnlightLockFactory();
        // 获取Redis锁客户端
        EnlightLockClient client = enlightLockFactory.getClient(SourceType.REDIS.getType());
        // 设置锁信息
        LockInfo lockInfo = new LockInfo()
                .setType(LockType.Fair)
                .setName("你要锁的key")
                .setLeaseTime(5L)
                .setWaitTime(5L);
        EnlightLock lock = client.getLock(lockInfo);
        // 加锁
        if(lock.acquire()){

            //  do your business

        }
        // 释放锁
        lock.release();
    }

}
```
3. 注解加锁
```java
@ReLock(keys = {"#name"},lockType = LockType.Fair,waitTime = 3000l, leaseTime = 3000l)
public void rob2(String name) {

    if(redPacketA == 0){
        System.err.println(String.format("%s没有抢到",name));
        return;
    }
    -- redPacketA;
    System.err.println(String.format("%s抢到了1元，剩下%d", name, redPacketA));

}


@ZkLock(keys = {"#name"},lockType = LockType.Read,waitTime = 3000l, leaseTime = 3000l)
public void rob3(String name) {

    if(redPacketA == 0){
        System.err.println(String.format("%s没有抢到",name));
        return;
    }
    -- redPacketA;
    System.err.println(String.format("%s抢到了1元，剩下%d", name, redPacketA));

}

@ZkLock(keys = {"123456"},lockType = LockType.Write,waitTime = 5l, leaseTime = 5l)
public void rob4(String name) {

    if(redPacketA == 0){
//            System.err.println(String.format("%s没有抢到",name));
        return;
    }
    -- redPacketA;
    System.err.println(String.format("%s抢到了1元，剩下%d", name, redPacketA));

}
```

## 集成分布式 ID 生成器：

- 熟悉分布式 ID 生成器： 了解英莱特提供的分布式 ID 生成器的特性和用法，包括唯一 ID 的生成策略、性能特点等。
- 配置分布式 ID 生成器： 根据英莱特的文档或指南，配置并初始化分布式 ID 生成器，确保其能够在你的分布式环境中正常工作。
- 使用分布式 ID 生成器： 在你的应用程序中集成分布式 ID 生成器，使用其提供的接口来生成唯一的 ID，并确保在分布式环境下不会出现重复的 ID。
无论是集成分布式锁还是分布式 ID 生成器，都需要仔细阅读英莱特提供的文档和示例，理解其设计和用法，并根据自己的实际需求进行相应的配置和调用。最重要的是，在集成过程中要做好测试和验证，确保其在分布式环境中能够正常工作并符合预期的性能和安全要求。

1. yaml配置
```yaml
enlight:
  uuid:
    enable: true
    type: redis
    zookeeper:
      address: localhost:2181
      waitTime: 30
      leaseTime: 30
      connection-time-out: 50000 #连接超时时间 毫秒
      session-time-out: 50000 #session超时时间 毫秒
      sleep-time-out: 3000 #重试初试时间 毫秒
      max-retries: 3 #重试次数
      wait-connect-time: 20000 #连接等待时间 毫秒
      name-space: enlight-uuid #命名空间
    redis:
      address: redis://localhost:6379
      password: 1234
      database: 7
      pool-size: 10384
      step-size: 1
      threshold: 5092
      is-random: false
      max-list-length: 1024
```

2. 示例
```java
@RunWith(SpringRunner.class)
@SpringBootTest
@TestPropertySource(properties = "classpath:application.yaml")
@ContextConfiguration(classes = {
        EnlightUUIDAutoConfiguration.class,
        EnlightRedisUUIDAutoConfiguration.class
})
public class RedisUUIDTest {

    @Resource
    EnlightUUIDContext enlightUUIDContext;

    @Test
    public void redisIdTestA() throws InterruptedException {
        EnlightUUIDStrategy uuidStrategy = enlightUUIDContext.getUuidStrategy();
        Thread thread = ThreadUtil.newThread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.err.println(Thread.currentThread().getName() + "得到id:" + uuidStrategy.nextId());
                }
            }
        }, "111");
        thread.start();
    }
}
```