Spring Boot 高效数据聚合之道

短命女 2022-01-12 05:11 129阅读 0赞

项目地址和示例代码: [github.com/lvyahui8/sp…][github.com_lvyahui8_sp]

## 背景 ##

接口开发是后端开发中最常见的场景, 可能是RESTFul接口, 也可能是RPC接口. **接口开发往往是从各处捞出数据, 然后组装成结果, 特别是那些偏业务的接口.**

如何**方便快速的开发高性能的接口**, 是一个必须思考的问题.

例如, 我现在需要实现一个接口, 拉取`用户基础信息`\+`用户的博客列表`\+`用户的粉丝数据`的整合数据, 假设已经有如下三个接口可以使用, 分别用来获取 `用户基础信息` ,`用户博客列表`, `用户的粉丝数据`.

**用户基础信息**

@Service
    public class UserServiceImpl implements UserService {
        @Override
        public User get(Long id) {
            try {Thread.sleep(1000L);} catch (InterruptedException e) {}
            /* mock a user*/
            User user = new User();
            user.setId(id);
            user.setEmail("lvyahui8@gmail.com");
            user.setUsername("lvyahui8");
            return user;
        }
    }
    复制代码

**用户博客列表**

@Service
    public class PostServiceImpl implements PostService {
        @Override
        public List<Post> getPosts(Long userId) {
            try { Thread.sleep(1000L); } catch (InterruptedException e) {}
            Post post = new Post();
            post.setTitle("spring data aggregate example");
            post.setContent("No active profile set, falling back to default profiles");
            return Collections.singletonList(post);
        }
    }
    
    复制代码

**用户的粉丝数据**

@Service
    public class FollowServiceImpl implements FollowService {
        @Override
        public List<User> getFollowers(Long userId) {
            try { Thread.sleep(1000L); } catch (InterruptedException e) {}
            int size = 10;
            List<User> users = new ArrayList<>(size);
            for(int i = 0 ; i < size; i++) {
                User user = new User();
                user.setUsername("name"+i);
                user.setEmail("email"+i+"@fox.com");
                user.setId((long) i);
                users.add(user);
            };
            return users;
        }
    }
    复制代码

*注意, 每一个方法都sleep了1s以模拟业务耗时.*

我们需要再封装一个接口, 来拼装以上三个接口的数据.

> PS: 这样的场景实际在工作中很常见, 而且往往我们需要拼凑的数据, 是要走网络请求调到第三方去的. 另外可能有人会想, 为何不分成3个请求? 实际为了客户端网络性能考虑, 往往会在一次网络请求中, 尽可能多的传输数据, 当然前提是这个数据不能太大, 否则传输的耗时会影响渲染. 许多APP的首页, 看着复杂, 实际也只有一个接口, 一次性拉下所有数据, 客户端开发也简单.

## 串行实现 ##

**编写性能优良的接口不仅是每一位后端程序员的技术追求, 也是业务的基本诉求. 一般情况下, 为了保证更好的性能, 往往需要编写更复杂的代码实现.**

但凡人皆有惰性, 因此, 往往我们会像下面这样编写串行调用的代码

@Component
    public class UserQueryFacade {
        @Autowired
        private FollowService followService;
        @Autowired
        private PostService postService;
        @Autowired
        private UserService userService;
        
        public User getUserData(Long userId) {
            User user = userService.get(userId);
            user.setPosts(postService.getPosts(userId));
            user.setFollowers(followService.getFollowers(userId));
            return user;
        }
    }
    复制代码

**很明显, 上面的代码, 效率低下, 起码要3s才能拿到结果**, 且一旦用到某个接口的数据, 便需要注入相应的service, 复用麻烦.

## 并行实现 ##

有追求的程序员可能立马会考虑到, 这**几项数据之间并无强依赖性, 完全可以并行获取**嘛, 通过异步线程+CountDownLatch+Future实现, 就像下面这样.

@Component
    public class UserQueryFacade {
        @Autowired
        private FollowService followService;
        @Autowired
        private PostService postService;
        @Autowired
        private UserService userService;
        
        public User getUserDataByParallel(Long userId) throws InterruptedException, ExecutionException {
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            CountDownLatch countDownLatch = new CountDownLatch(3);
            Future<User> userFuture = executorService.submit(() -> {
                try{
                    return userService.get(userId);
                }finally {
                    countDownLatch.countDown();
                }
            });
            Future<List<Post>> postsFuture = executorService.submit(() -> {
                try{
                    return postService.getPosts(userId);
                }finally {
                    countDownLatch.countDown();
                }
            });
            Future<List<User>> followersFuture = executorService.submit(() -> {
                try{
                    return followService.getFollowers(userId);
                }finally {
                    countDownLatch.countDown();
                }
            });
            countDownLatch.await();
            User user = userFuture.get();
            user.setFollowers(followersFuture.get());
            user.setPosts(postsFuture.get());
            return user;
        }
    }
    复制代码

上面的代码, **将串行调用改为并行调用, 在有限并发级别下, 能极大提高性能**. 但很明显, 它过于复杂, 如果每个接口都为了并行执行都写这样一段代码, 简直是噩梦.

## 优雅的注解实现 ##

熟悉java的都知道, java有一种非常便利的特性 ~~ 注解. 简直是黑魔法. 往往只需要给类或者方法上添加一些注解, 便可以实现非常复杂的功能.

有了注解, 再结合Spring依赖自动注入的思想, 那么我们可不可以通过注解的方式, 自动注入依赖, 自动并行调用接口呢? 答案是肯定的.

首先, 我们先定义一个聚合接口 (当然也可以不定义聚合类, 所有代码写在原Service类中同样可以)

@Component
    public class UserAggregate {
        @DataProvider("userFullData")
        public User userFullData(@DataConsumer("user") User user,
                                 @DataConsumer("posts") List<Post> posts,
                                 @DataConsumer("followers") List<User> followers) {
            user.setFollowers(followers);
            user.setPosts(posts);
            return user;
        }
    }
    复制代码

其中

*  `@DataProvider` 表示这个方法是一个数据提供者, 数据Id为 `userFullData`
 *  `@DataConsumer` 表示这个方法的参数, 需要消费数据, 数据Id分别为 `user` ,`posts`, `followers`.

当然, 原来的3个原子服务 `用户基础信息` ,`用户博客列表`, `用户的粉丝数据`, 也分别需要添加一些注解

@Service
    public class UserServiceImpl implements UserService {
        @DataProvider("user")
        @Override
        public User get(@InvokeParameter("userId") Long id) {
    复制代码

@Service
    public class PostServiceImpl implements PostService {
        @DataProvider("posts")
        @Override
        public List<Post> getPosts(@InvokeParameter("userId") Long userId) {
    复制代码

@Service
    public class FollowServiceImpl implements FollowService {
        @DataProvider("followers")
        @Override
        public List<User> getFollowers(@InvokeParameter("userId") Long userId) {
    复制代码

其中

*  `@DataProvider` 与前面的含义相同, 表示这个方法是一个数据提供者
 *  `@InvokeParameter` 表示方法执行时, 需要**手动传入的参数**

**这里注意 `@InvokeParameter` 和 `@DataConsumer`的区别, 前者需要用户在最上层调用时手动传参; 而后者, 是由框架自动分析依赖, 并异步调用取得结果之后注入的.**

最后, 仅仅只需要调用一个统一的门面(Facade)接口, 传递数据Id, Invoke Parameters,以及返回值类型. **剩下的并行处理, 依赖分析和注入, 完全由框架自动处理.**

@Component
    public class UserQueryFacade {
        @Autowired
        private DataBeanAggregateQueryFacade dataBeanAggregateQueryFacade;
    
        public User getUserFinal(Long userId) throws InterruptedException, 
        			IllegalAccessException, InvocationTargetException {
            return dataBeanAggregateQueryFacade.get("userFullData",
                    Collections.singletonMap("userId", userId), User.class);
        }
    }
    复制代码

## 如何用在你的项目中 ##

上面的功能, 笔者已经封装为一个spring boot starter, 并发布到maven中央仓库.

只需在你的项目引入依赖.

<dependency>
      <groupId>io.github.lvyahui8</groupId>
      <artifactId>spring-boot-data-aggregator-starter</artifactId>
      <version>1.0.2</version>
    </dependency>
    复制代码

并在 `application.properties` 文件中声明注解的扫描路径.

# 替换成你需要扫描注解的包
    io.github.lvyahui8.spring.base-packages=io.github.lvyahui8.spring.example
    复制代码

之后, 就可以使用如下注解和 Spring Bean 实现聚合查询

*  `@DataProvider`
 *  `@DataConsumer`
 *  `@InvokeParameter`
 *  Spring Bean `DataBeanAggregateQueryFacade`

注意, `@DataConsumer` 和 `@InvokeParameter` 可以混合使用, 可以用在同一个方法的不同参数上. 且方法的所有参数必须有其中一个注解, 不能有没有注解的参数.

项目地址和上述示例代码: [github.com/lvyahui8/sp…][github.com_lvyahui8_sp]. 感谢给予star, 欢迎一起参与完善

## 特性 ##

*  **异步获取依赖**
    
    所有 `@DataConsumer` 定义的依赖将异步获取. 当provider方法参数中的所有依赖获取完成, 才执行provider方法
 *  **不限级嵌套**
    
    依赖关系支持深层嵌套. 上面的示例只有一层
 *  **异常处理**
    
    目前支持两种处理方式: 忽略or终止
    
    忽略是指provider方法在执行时, 忽略抛出的异常并return null值; 终止是指一旦有一个provider方法抛出了异常, 将逐级向上抛出, 终止后续处理.
    
    配置支持consumer级或者全局, 优先级 : consumer级 > 全局
 *  **超时控制** (待实现)

## 后期计划 ##

后续笔者将继续完善 \#超时处理,\#缓存,\#提高吞吐量 并进一步提高插件的易用性, 高可用性, 扩展性

转载于:https://juejin.im/post/5d064b90e51d45777540fda7

[github.com_lvyahui8_sp]: https://link.juejin.im?target=https%3A%2F%2Fgithub.com%2Flvyahui8%2Fspring-boot-data-aggregator