SpringBoot 实战：通过 BeanPostProcessor 动态注入 ID 生成器

「爱情、让人受尽委屈。」 2021-09-25 07:56 244阅读 0赞

![Spring 实战：通过 BeanPostProcessor 动态注入 ID 生成器][Spring _ BeanPostProcessor _ ID]

你好，我是看山。

在分布式系统中，我们会需要 ID 生成器的组件，这个组件可以实现帮助我们生成顺序的或者带业务含义的 ID。

目前有很多经典的 ID 生成方式，比如数据库自增列（自增主键或序列）、Snowflake 算法、美团 Leaf 算法等等，所以，会有一些公司级或者业务级的 ID 生成器组件的诞生。本文就是通过 BeanPostProcessor 实现动态注入 ID 生成器的实战。

在 Spring 中，实现注入的方式很多，比如 springboot 的 starter，在自定义的 Configuration 中初始化 ID 生成器的 Bean，业务代码中通过`@AutoWired`或者`@Resource`注入即可，开箱即用。这种方式简单直接，但是缺点也是过于简单，缺少了使用方自定义的入口。

考虑一下实际场景，在同一个业务单据中，要保持 ID 的唯一，但是在不同单据中，可以重复。而且，这些算法在生成 ID 的时候，为了保持多线程返回结果唯一，都会锁定共享资源。如果不同业务，并发情景不同，可能低并发的业务被高并发的业务阻塞获取 ID，造成一些性能的损失。所以，我们要考虑将 ID 生成器，根据业务隔离开，这样 springboot 的 starter 就会显得不够灵活了。

## 实现 ##

根据上面的需求，我们可以分几步实现我们的逻辑：

1.  自定义属性注解，用于判断是否需要注入属性对象
2.  定义 ID 生成器接口、实现类，以及工厂类，工厂类是为了根据定义创建不同的 ID 生成器实现对象
3.  定义 BeanPostProcessor，查找使用自定义注解定义的属性，实现注入

### 自定义注解 ###

首先自定义一个注解，可以定义一个`value`属性，作为隔离业务的标识：

@Retention(RetentionPolicy.RUNTIME)
    @Target({ ElementType.FIELD, ElementType.METHOD})
    public @interface IdGeneratorClient { 
        /** * ID 生成器名称 * * @return */
        String value() default "DEFAULT";
    }

### 定义 ID 生成器 ###

定义 ID 生成器的接口：

public interface IdGenerator { 
        String groupName();
    
        long nextId();
    }

实现 ID 生成器接口，偷懒使用`AtomicLong`实现自增，同时考虑 ID 生成器是分组的，通过`ConcurrentHashMap`实现 ID 生成器的持有：

class DefaultIdGenerator implements IdGenerator { 
        private static final Map<String, AtomicLong> ID_CACHE = new ConcurrentHashMap<>(new HashMap<>());
        private final String groupName;
    
        DefaultIdGenerator(final String groupName) { 
            this.groupName = groupName;
            synchronized (ID_CACHE) { 
                ID_CACHE.computeIfAbsent(groupName, key -> new AtomicLong(1));
            }
        }
    
        @Override
        public String groupName() { 
            return this.groupName;
        }
    
        @Override
        public long nextId() { 
            return ID_CACHE.get(this.groupName).getAndIncrement();
        }
    }

如前面设计的，我们需要一个工厂类来创建 ID 生成器，示例中使用最简单的实现，我们真正使用的时候，还可以通过更加灵活的 SPI 实现（关于 SPI 的实现，这里挖个坑，后面专门写一篇填坑）：

public enum IdGeneratorFactory { 
        INSTANCE;
    
        private static final Map<String, IdGenerator> ID_GENERATOR_MAP = new ConcurrentHashMap<>(new HashMap<>());
    
        public synchronized IdGenerator create(final String groupName) { 
            return ID_GENERATOR_MAP.computeIfAbsent(groupName, key -> new DefaultIdGenerator(groupName));
        }
    }

### 定义 BeanPostProcessor ###

前面都是属于基本操作，这里才是扩展的核心。我们的实现逻辑是：

1.  扫描 bean 的所有属性，然后找到定义了`IdGeneratorClient`注解的属性
2.  获取注解的`value`值，作为 ID 生成器的分组标识
3.  使用`IdGeneratorFactory`这个工厂类生成 ID 生成器实例，这里会返回新建的或已经定义的实例
4.  通过反射将 ID 生成器实例写入 bean

public class IdGeneratorBeanPostProcessor implements BeanPostProcessor { 
    
        @Override
        public Object postProcessBeforeInitialization(final Object bean, final String beanName) throws BeansException { 
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException { 
            parseFields(bean);
            return bean;
        }
    
        private void parseFields(final Object bean) { 
            if (bean == null) { 
                return;
            }
            Class<?> clazz = bean.getClass();
            parseFields(bean, clazz);
    
            while (clazz.getSuperclass() != null && !clazz.getSuperclass().equals(Object.class)) { 
                clazz = clazz.getSuperclass();
                parseFields(bean, clazz);
            }
        }
    
        private void parseFields(final Object bean, Class<?> clazz) { 
            if (bean == null || clazz == null) { 
                return;
            }
    
            for (final Field field : clazz.getDeclaredFields()) { 
                try { 
                    final IdGeneratorClient annotation = AnnotationUtils.getAnnotation(field, IdGeneratorClient.class);
                    if (annotation == null) { 
                        continue;
                    }
    
                    final String groupName = annotation.value();
    
                    final Class<?> fieldType = field.getType();
                    if (fieldType.equals(IdGenerator.class)) { 
                        final IdGenerator idGenerator = IdGeneratorFactory.INSTANCE.create(groupName);
                        invokeSetField(bean, field, idGenerator);
                        continue;
                    }
    
                    throw new RuntimeException("未知字段类型无法初始化，bean: " + bean + "，field: " + field);
                } catch (Throwable t) { 
                    throw new RuntimeException("初始化字段失败，bean=" + bean + "，field=" + field, t);
                }
            }
        }
    
        private void invokeSetField(final Object bean, final Field field, final Object param) { 
            ReflectionUtils.makeAccessible(field);
            ReflectionUtils.setField(field, bean, param);
        }
    }

实现`BeanPostProcessor`接口需要完成`postProcessBeforeInitialization`和`postProcessAfterInitialization`两个方法的定义。下图是 Spring 中 Bean 的实例化过程：

![Spring 中 Bean 的实例化过程图示][Spring _ Bean]

从图中可以知道，Spring 调用`BeanPostProcessor`的这两个方法时，bean 已经被实例化，所有能注入的属性都已经被注入了，是一个完整的 bean。而且两个方法的返回值，可以是原来的 bean 实例，也可以是包装后的实例，这就要看我们的定义了。

### 测试我们的代码 ###

写一个测试用例，验证我们的实现是否生效：

@SpringBootTest
    class SpringBeanPostProcessorApplicationTests { 
        @IdGeneratorClient
        private IdGenerator defaultIdGenerator;
        @IdGeneratorClient("group1")
        private IdGenerator group1IdGenerator;
    
        @Test
        void contextLoads() { 
            Assert.notNull(defaultIdGenerator, "注入失败");
            System.out.println(defaultIdGenerator.groupName() + " => " + defaultIdGenerator.nextId());
    
            Assert.notNull(group1IdGenerator, "注入失败");
            for (int i = 0; i < 5; i++) { 
                System.out.println(defaultIdGenerator.groupName() + " => " + defaultIdGenerator.nextId());
                System.out.println(group1IdGenerator.groupName() + " => " + group1IdGenerator.nextId());
            }
        }
    
    }

运行结果为：

DEFAULT => 1
    DEFAULT => 2
    group1 => 1
    DEFAULT => 3
    group1 => 2
    DEFAULT => 4
    group1 => 3
    DEFAULT => 5
    group1 => 4
    DEFAULT => 6
    group1 => 5

可以看到，默认的 ID 生成器与定义名称为 group1 的 ID 生成器是分别生成的，符合预期。

## 文末思考 ##

我们实现了通过`BeanPostProcessor`实现自动注入自定义的业务对象，上面的实现还比较简单，有很多可以扩展的地方，比如工厂方法实现，可以借助 SPI 的方式更加灵活的创建 ID 生成器对象。同时，考虑到分布式场景，我们还可以在 ID 生成器实现类中，通过注入 rpc 实例，实现远程 ID 生成逻辑。

玩法无限，就看我们的想象了。

## 源码 ##

附上源码：[https://github.com/howardliu-cn/effective-spring/tree/main/spring-beanpostprocessor][https_github.com_howardliu-cn_effective-spring_tree_main_spring-beanpostprocessor]

## 参考 ##

*  [Spring BeanPostProcessor Example][]
 *  [Spring BeanPostProcessor][]

## 推荐阅读 ##

*  [SpringBoot 实战：一招实现结果的优雅响应][SpringBoot]
 *  [SpringBoot 实战：如何优雅的处理异常][SpringBoot 1]
 *  [SpringBoot 实战：通过 BeanPostProcessor 动态注入 ID 生成器][SpringBoot _ BeanPostProcessor _ ID]

--------------------

你好，我是看山，公众号：看山的小屋，10 年老猿，Apache Storm、WxJava、Cynomys 开源贡献者。游于码界，戏享人生。

个人主页：[https://www.howardliu.cn][https_www.howardliu.cn]  
个人博文：[SpringBoot 实战：通过 BeanPostProcessor 动态注入 ID 生成器][SpringBoot _ BeanPostProcessor _ ID]  
CSDN 主页：[http://blog.csdn.net/liuxinghao][http_blog.csdn.net_liuxinghao]  
CSDN 博文：[SpringBoot 实战：通过 BeanPostProcessor 动态注入 ID 生成器][SpringBoot _ BeanPostProcessor _ ID 1]

![公众号：看山的小屋][21785bb43b333b0ff8efda479e715378.png]

[Spring _ BeanPostProcessor _ ID]: /images/20210923/acc1341acb6d41c48fd804655eb6e6fc.png
[Spring _ Bean]: /images/20210923/98e82ee5bcbb4a1d90c6cfff65d6af5a.png
[https_github.com_howardliu-cn_effective-spring_tree_main_spring-beanpostprocessor]: https://github.com/howardliu-cn/effective-spring/tree/main/spring-beanpostprocessor
[Spring BeanPostProcessor Example]: https://howtodoinjava.com/spring-core/spring-bean-post-processors/
[Spring BeanPostProcessor]: https://www.baeldung.com/spring-beanpostprocessor
[SpringBoot]: https://www.howardliu.cn/springboot-action-gracefully-response/
[SpringBoot 1]: https://www.howardliu.cn/springboot-action-gracefully-response-exception/
[SpringBoot _ BeanPostProcessor _ ID]: https://www.howardliu.cn/spring-beanpostprocessor/
[https_www.howardliu.cn]: https://www.howardliu.cn
[http_blog.csdn.net_liuxinghao]: http://blog.csdn.net/liuxinghao
[SpringBoot _ BeanPostProcessor _ ID 1]: https://blog.csdn.net/liuxinghao/article/details/116139540
[21785bb43b333b0ff8efda479e715378.png]: /images/20210923/e4245e322d8f4ceeb96c173be0e03cd1.png