编程基础-代码优化示例一(Builder模式、Stream及面向对象）

以你之姓@ 2024-04-17 22:40 12阅读 0赞

编码其实是一个可以做到非常精致的事情，每次回头看自己以前写的代码，总是觉得可以采用更好的方式去实现。从好的方面来说自己一直在进步，但从差的方面来说就是自己一直都做的不够好。

在日常编码过程中有时候灵机一动的念头，可能就是对于解决某些场景非常有用的方案，因此我决定将一些编码过程中的优化记录下来，总结后真正的变成自己的东西，这样在往后的编码过程中就可以做到更好。当然代码优化是一个永无止境的事情，总结也是永无止境。

本文讲的就是一个简单的应用场景，如何从最常规的实现，一步步的完成代码层面的优化。

# 1. 场景描述 #

应用场景：有一个用户清单，包含有用户信息及客户信息，需要按客户编号+客户名称汇总用户数据；

假设1：用户对象定义如下：

/** * 用户信息 * * @author LiuQi 2019/8/20-9:11 * @version V1.0 **/
    public class User { 
        private Long id;
        private String name;
        private Long customerId;
        private String customerName;
    
        public Long getId() { 
            return id;
        }
    
        public void setId(Long id) { 
            this.id = id;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public Long getCustomerId() { 
            return customerId;
        }
    
        public void setCustomerId(Long customerId) { 
            this.customerId = customerId;
        }
    
        public String getCustomerName() { 
            return customerName;
        }
    
        public void setCustomerName(String customerName) { 
            this.customerName = customerName;
        }
    }

这是一个简单的Java Bean对象，包含有客户相关属性及用户相关属性，并提供有Setter与Getter方法。

假设2：有一个List，需要将其转换成以下存储方式：

[
    	{ 
    		"customerId": 1,
    		"customerName": "1",
    		"users": [
    			{ 
    				"userId": 1,
    				"userName": "LiuQi"
    			},
    			{ 
    				"userId": 2,
    				"userName": "ShenYu"
    			}
    		]
    	},
    	{ 
    		"customerId": 2,
    		"customerName": "2",
    		"users": [
    			{ 
    				"userId": 3,
    				"userName": "ZhangSan"
    			},
    			{ 
    				"userId": 4,
    				"userName": "LiSi"
    			}
    		]
    	}
    ]

# 2. 常规实现 #

这是一个很简单的需求，拿到需求后我们就开搞，先来看最常规的实现，也是多数人会采用的实现：

public class Test { 
        public static void main(String[] args) { 
            List<User> users = init();
    
            // 先将用户按客户编号汇聚，同时保存客户编号与客户名称的关系
            Map<Long, List<Map<String, Object>>> customerUserMap = new HashMap<>(16);
            Map<Long, String> customerNameMap = new HashMap<>(16);
            for (User user : users) { 
                Long customerId = user.getCustomerId();
                String customerName = user.getCustomerName();
                if (!customerNameMap.containsKey(customerId)) { 
                    customerNameMap.put(customerId, customerName);
                }
    
                List<Map<String, Object>> customerUserList = customerUserMap.get(customerId);
                if (null == customerUserList) { 
                    customerUserList = new ArrayList<>(16);
                    customerUserMap.put(customerId, customerUserList);
                }
    
                Map<String, Object> userInfoMap = new HashMap<>(16);
                userInfoMap.put("userId", user.getId());
                userInfoMap.put("userName", user.getName());
                customerUserList.add(userInfoMap);
            }
    
            // 遍历所有客户，组装结果
            List<Map<String, Object>> resultList = new ArrayList<>(16);
            Iterator<Long> it = customerNameMap.keySet().iterator();
            while (it.hasNext()) { 
                Long customerId = it.next();
                String customerName = customerNameMap.get(customerId);
                List<Map<String, Object>> customerUserList = customerUserMap.get(customerId);
    
                Map<String, Object> customerMap = new HashMap<>(16);
                customerMap.put("customerId", customerId);
                customerMap.put("customerName", customerName);
                customerMap.put("users", customerUserList);
    
                resultList.add(customerMap);
            }
    
            System.out.println(resultList);
        }
    
        private static List<User> init() { 
            List<User> list = new ArrayList<>(16);
    
            User user = new User();
            user.setId(1L);
            user.setName("1");
            user.setCustomerId(1L);
            user.setCustomerName("1");
            list.add(user);
    
            user = new User();
            user.setId(2L);
            user.setName("2");
            user.setCustomerId(1L);
            user.setCustomerName("1");
            list.add(user);
    
            user = new User();
            user.setId(3L);
            user.setName("3");
            user.setCustomerId(2L);
            user.setCustomerName("2");
            list.add(user);
    
            return list;
        }
    }

下面来对这些代码进行一步步的优化 。

# 3. 针对初始化代码的优化 #

先来看下初始化用户清单的代码：

private static List<User> init() { 
            List<User> list = new ArrayList<>(16);
    
            User user = new User();
            user.setId(1L);
            user.setName("1");
            user.setCustomerId(1L);
            user.setCustomerName("1");
            list.add(user);
    
            user = new User();
            user.setId(2L);
            user.setName("2");
            user.setCustomerId(1L);
            user.setCustomerName("1");
            list.add(user);
    
            user = new User();
            user.setId(3L);
            user.setName("3");
            user.setCustomerId(2L);
            user.setCustomerName("2");
            list.add(user);
    
            return list;
        }

这个代码有一个非常不友好的地方，创建对象并给其属性赋值的过程，可以看到我们调用了很多的Setter方法，一直在重复user.set这个过程，写起来非常痛苦，这种情况可以采用Builder的方式进行优化。默认情况下，IDEA生成的Setter方法是不包含有返回值的，但我们在生成Setter方法的时候可以选择Builder方式生成，生成结果如下：

public class User { 
        private Long id;
        private String name;
        private Long customerId;
        private String customerName;
    
        public Long getId() { 
            return id;
        }
    
        public User setId(Long id) { 
            this.id = id;
            return this;
        }
    
        public String getName() { 
            return name;
        }
    
        public User setName(String name) { 
            this.name = name;
            return this;
        }
    
        public Long getCustomerId() { 
            return customerId;
        }
    
        public User setCustomerId(Long customerId) { 
            this.customerId = customerId;
            return this;
        }
    
        public String getCustomerName() { 
            return customerName;
        }
    
        public User setCustomerName(String customerName) { 
            this.customerName = customerName;
            return this;
        }
    }

然后之前的初始化代码可以修改成以下样子：

private static List<User> init() { 
            List<User> list = new ArrayList<>(16);
    
            list.add(new User()
                    .setId(1L)
                    .setName("1")
                    .setCustomerId(1L)
                    .setCustomerName("1")
            );
    
            list.add(new User()
                    .setId(2L)
                    .setName("2")
                    .setCustomerId(1L)
                    .setCustomerName("1")
            );
    
            list.add(new User()
                    .setId(3L)
                    .setName("3")
                    .setCustomerId(2L)
                    .setCustomerName("2")
            );
    
            return list;
        }

Builder方式主要是写起来实在是太爽了，写完一个Setter后可以直接继续写下一下Setter，尤其对于字段很多的情况下非常有用。

上面的代码写起来也还是有不爽的，每次都要使用list.add的方式来新增一个元素，那List的Add方法是否也可以使用Builder方式来添加呢？

由于List是JDK中提供的接口，我们没有办法直接修改接口的方法，另外，即使我们继承于ArrayList等对象，也不能直接增加一个返回类型为List的add方法，除非换一个名称，如addItem。这样处理后使用上会有很多的限制，如新创建的List对象都要是我们新增加的实现类等。这个时候我们就可以引入一个额外的Builder类来专门对List进行扩展了，实现如下：

/** * @author LiuQi 2019/8/20-12:20 * @version V1.0 **/
    public class ListBuilder<T> { 
        private List<T> list;
    
        public static <T> ListBuilder<T> of(int size) { 
            ListBuilder<T> builder = new ListBuilder<>();
            builder.list = new ArrayList<>(size);
            return builder;
        }
    
        public static <T> ListBuilder<T> of(List<T> list) { 
            ListBuilder<T> builder = new ListBuilder<>();
            builder.list = null != list ? list : new ArrayList<>(16);
            return builder;
        }
    
        public ListBuilder<T> add(T t) { 
            this.list.add(t);
            return this;
        }
    
        public ListBuilder<T> addAll(Collection<T> c) { 
            if (null != c) { 
                this.list.addAll(c);
            }
            return this;
        }
    
        public List<T> builder() { 
            return this.list;
        }
    }

再对上面初始化的代码使用ListBuilder进行优化，优化结果如下：

private static List<User> init() { 
            return ListBuilder.<User>of(3)
                    .add(new User()
                            .setId(1L)
                            .setName("1")
                            .setCustomerId(1L)
                            .setCustomerName("1"))
                    .add(new User()
                            .setId(2L)
                            .setName("2")
                            .setCustomerId(1L)
                            .setCustomerName("1"))
                    .add(new User()
                            .setId(3L)
                            .setName("3")
                            .setCustomerId(2L)
                            .setCustomerName("2"))
                    .builder();
        }

是不是写起来要方便很多了？

然而，实际上我们可以直接使用Arrays.asList的方法来进行初始化，会要更加简洁：

return Arrays.asList(new User()
                            .setId(1L)
                            .setName("1")
                            .setCustomerId(1L)
                            .setCustomerName("1"),
                    new User()
                            .setId(2L)
                            .setName("2")
                            .setCustomerId(1L)
                            .setCustomerName("1"),
                    new User()
                            .setId(3L)
                            .setName("3")
                            .setCustomerId(2L)
                            .setCustomerName("2"));

第一步针对初始化过程的优化就到这。实现过程总是多种多样的，如果有更好的实现可以一起讨论下。

# 4. 优化2-业务处理逻辑优化 #

## 4.2 Map操作优化 ##

现在回到我们的业务处理过程代码中，第一眼就看到代码中存在很多的对map的操作，如：

Map<String, Object> customerMap = new HashMap<>(16);
    customerMap.put("customerId", customerId);
    customerMap.put("customerName", customerName);
    customerMap.put("users", customerUserList);

根据第3节中对List优化的经验，Map实际上也可以进行Builder模式的改造，定义的MapBuilder类如下所示：

public class MapBuilder<V> { 
        private Map<String, V> map;
    
        private MapBuilder() { }
    
        /** * 创建一个Map构建器 * @param <V> Value类型 * @return 构建器 */
        public static <V> MapBuilder<V> of() { 
            MapBuilder<V> mapBuilder = new MapBuilder<>();
            mapBuilder.map = new HashMap<>(16);
            return mapBuilder;
        }
    
        /** * 创建一个Map构建器 * @param <V> Value类型 * @return 构建器 */
        public static <V> MapBuilder<V> of(int size) { 
            MapBuilder<V> mapBuilder = new MapBuilder<>();
            mapBuilder.map = new HashMap<>(size);
            return mapBuilder;
        }
    
        /** * 根据指定的Map创建一个Map构建器 * @param <V> Value类型 * @return 构建器 */
        public static <V> MapBuilder<V> of(Map<String, V> map) { 
            MapBuilder<V> mapBuilder = new MapBuilder<>();
            mapBuilder.map = null == map ? new HashMap<>(16) : map;
            return mapBuilder;
        }
    
        public MapBuilder<V> put(String k, V value) { 
            this.map.put(k, value);
            return this;
        }
    
        public MapBuilder<V> putAll(Map<String, V> map) { 
            if (null != map) { 
                this.map.putAll(map);
            }
            return this;
        }
    
        public MapBuilder<V> changeValue(String k, Function<V, V> changeFunction) { 
            this.map.put(k, changeFunction.apply(map.get(k)));
    
            return this;
        }
    
        public MapBuilder<V> putNotNull(String k, V value) { 
            if (null != value) { 
                this.map.put(k, value);
            }
    
            return this;
        }
    
        public MapBuilder<V> putIf(String k, V value, BooleanSupplier supplier) { 
            if (supplier.getAsBoolean()) { 
                this.map.put(k, value);
            }
    
            return this;
        }
    
        public MapBuilder<V> clear() { 
            this.map.clear();
            return this;
        }
    
        public MapBuilder<V> remove(String k) { 
            this.map.remove(k);
            return this;
        }
    
        public Map<String, V> build() { 
            return map;
        }
    }

然后我们对业务代码使用MapBuilder按以下方式进行第一次优化：

// 优化前
    Map<String, Object> customerMap = new HashMap<>(16);
    customerMap.put("customerId", customerId);
    customerMap.put("customerName", customerName);
    customerMap.put("users", customerUserList);
    resultList.add(customerMap);
    
    // 优化后
    resultList.add(MapBuilder.of(6)
                   .put("customerId", customerId)
                   .put("customerName", customerName)
                   .put("users", customerUserList)
                   .build()

优化后的业务代码：

public static void main(String[] args) { 
            List<User> users = init();
    
            // 先将用户按客户编号汇聚，同时保存客户编号与客户名称的关系
            Map<Long, List<Map<String, Object>>> customerUserMap = new HashMap<>(16);
            Map<Long, String> customerNameMap = new HashMap<>(16);
            for (User user : users) { 
                Long customerId = user.getCustomerId();
                String customerName = user.getCustomerName();
                if (!customerNameMap.containsKey(customerId)) { 
                    customerNameMap.put(customerId, customerName);
                }
    
                List<Map<String, Object>> customerUserList = customerUserMap.get(customerId);
                if (null == customerUserList) { 
                    customerUserList = new ArrayList<>(16);
                    customerUserMap.put(customerId, customerUserList);
                }
    
                customerUserList.add(MapBuilder.of(16)
                        .put("userId", user.getId())
                        .put("userName", user.getName())
                        .build()
                );
            }
    
            // 遍历所有客户，组装结果
            List<Map<String, Object>> resultList = new ArrayList<>(16);
            Iterator<Long> it = customerNameMap.keySet().iterator();
            while (it.hasNext()) { 
                Long customerId = it.next();
                String customerName = customerNameMap.get(customerId);
                List<Map<String, Object>> customerUserList = customerUserMap.get(customerId);
    
                resultList.add(MapBuilder.of(6)
                        .put("customerId", customerId)
                        .put("customerName", customerName)
                        .put("users", customerUserList)
                        .build()
                );
            }
    
            System.out.println(resultList);
        }

Map操作的第二次优化，集中在以下代码处：

List<Map<String, Object>> customerUserList = customerUserMap.get(customerId);
    if (null == customerUserList) { 
        customerUserList = new ArrayList<>(16);
        customerUserMap.put(customerId, customerUserList);
    }
    
    customerUserList.add(MapBuilder.of(16)
                         .put("userId", user.getId())
                         .put("userName", user.getName())
                         .build()

可以看到主要逻辑是从customerUserMap中获取customerId对应的UserList；实际上这个地方可以使用Map的computeIfAbsent方法来进行优化，优化后代码如下：

customerUserMap.computeIfAbsent(customerId, k -> new ArrayList<>(16))
        .add(MapBuilder.of(16)
             .put("userId", user.getId())
             .put("userName", user.getName())
             .build()
            );

computeIfAbsent的意思是，如果对应Key的Value存在，那么返回这个Value，如果不存在，则使用传入的函数生成Value，然后put到Map中，再返回生成的Value； 具体使用请参考官方文档。

## 4.3 代码逻辑优化 ##

那到这一步，代码可以了么？并不是，我们看到有这一段代码：

Map<Long, List<Map<String, Object>>> customerUserMap = new HashMap<>(16);
    Map<Long, String> customerNameMap = new HashMap<>(16);
    for (User user : users) { 
        Long customerId = user.getCustomerId();
        String customerName = user.getCustomerName();
        if (!customerNameMap.containsKey(customerId)) { 
            customerNameMap.put(customerId, customerName);
        }
    
        customerUserMap.computeIfAbsent(customerId, k -> new ArrayList<>(16))
            .add(MapBuilder.of(16)
                 .put("userId", user.getId())
                 .put("userName", user.getName())
                 .build()
                );
    }

就是需要遍历所有用户，然后保存所有客户编号与名称的对应关系，同时保存客户编号与用户列表的对应关系，因此我们使用了两个集合来存储这两个关系。

实际上客户编号与名称是一一对应的，与用户列表是一对多的关系，我们理想的存储方式应该是customerId + customerName + userList这样的对应关系。

因此可以进行一次改造，使用一个Map来存储结果，其Key通过CustomerID与CustomerName拼装而成，优化结果如下：

// 先将用户按客户编号汇聚，同时保存客户编号与客户名称的关系
            Map<String, List<Map<String, Object>>> customerUserMap = new HashMap<>(16);
            for (User user : users) { 
                Long customerId = user.getCustomerId();
                String customerName = user.getCustomerName();
                String key = customerId + "." + customerName;
    
                customerUserMap.computeIfAbsent(key, k -> new ArrayList<>(16))
                        .add(MapBuilder.of(16)
                                .put("userId", user.getId())
                                .put("userName", user.getName())
                                .build()
                        );
            }
    
            // 遍历所有客户，组装结果
            List<Map<String, Object>> resultList = new ArrayList<>(16);
            customerUserMap.forEach((key, list) -> { 
                int idx = key.indexOf(".");  
                Long customerId = Long.parseLong(key.substring(0, idx));  
                String customerName = key.substring(idx + 1);
    
                resultList.add(MapBuilder.of(6)
                        .put("customerId", customerId)
                        .put("customerName", customerName)
                        .put("users", list)
                        .build()
                );  
            });
    
            System.out.println(resultList);

## 4.4 引入双值对象对代码逻辑进行优化 ##

按照上一节的方式优化后，相对来说代码要简单了不少，但需要对Map中存储的Key进行拼装与解析，额外增加了一些工作量，并且修改代码的时候需要保持拼装与解析的逻辑一致性，很容易出现改动一处另外一处没改动而导出故障的情况。我们也可以使用使用Map<String, Map<String, List<Map<String, Object>>>>的方式进行存储，但又增加了一层处理逻辑，代码的清晰度上面会有一个下降，理解代码变得更加困难。

我们可以定义一个一一对应的BiValue对象来使用。这个对象的定义如下：

/** * 双重值对象 * 典型应用场景：如需要 * * @author LiuQI 2019/5/8 15:53 * @version V1.0 **/
    public class BiValue<K, V> { 
        private K key;
        private V value;
    
        public K getKey() { 
            return key;
        }
    
        public BiValue<K, V> setKey(K key) { 
            this.key = key;
            return this;
        }
    
        /** * 根据函数修改Key * 如果对象中Key为空，则将其赋值成传入的Key； 否则，根据传入的函数对值进行处理后赋值给对象的key * @param key 新key * @param change 修改函数 * @return 当前对象 */
        public BiValue<K, V> changeKey(K key, Function<K, K> change) { 
            if (null == this.key) { 
                this.key = key;
            } else { 
                this.key = change.apply(this.key);
            }
    
            return this;
        }
    
        /** * 根据函数修改Value * 如果对象中Value为空，则将其赋值成传入的Value； * 否则，根据传入的函数对Value进行处理后赋值成对象的Value * @param value 新Value * @param change 修改函数 * @return 当前对象 */
        public BiValue<K, V> changeValue(V value, Function<V, V> change) { 
            if (null == this.value) { 
                this.value = value;
            } else { 
                this.value = change.apply(this.value);
            }
    
            return this;
        }
    
        public V getValue() { 
            return value;
        }
    
        public BiValue<K, V> setValue(V value) { 
            this.value = value;
            return this;
        }
    
        @Override
        public boolean equals(Object o) { 
            if (this == o) { 
                return true;
            }
    
            if (o == null || getClass() != o.getClass()) { 
                return false;
            }
    
            BiValue<?, ?> biValue = (BiValue<?, ?>) o;
    
            return new EqualsBuilder()
                    .append(key, biValue.key)
                    .append(value, biValue.value)
                    .isEquals();
        }
    
        @Override
        public int hashCode() { 
            return new HashCodeBuilder(17, 37)
                    .append(key)
                    .append(value)
                    .toHashCode();
        }
    
        @Override
        public String toString() { 
            return key + ":" + value;
        }
    }

使用BIValue优化结果如下：

// 先将用户按客户编号汇聚，同时保存客户编号与客户名称的关系
            Map<BiValue<Long, String>, List<Map<String, Object>>> customerUserMap = new HashMap<>(16);
            for (User user : users) { 
                Long customerId = user.getCustomerId();
                String customerName = user.getCustomerName();
                BiValue<Long, String> key = new BiValue<Long, String>()
                        .setKey(customerId)
                        .setValue(customerName);  
    
                customerUserMap.computeIfAbsent(key, k -> new ArrayList<>(16))
                        .add(MapBuilder.of(16)
                                .put("userId", user.getId())
                                .put("userName", user.getName())
                                .build()
                        );
            }
    
            // 遍历所有客户，组装结果
            List<Map<String, Object>> resultList = new ArrayList<>(16);
            customerUserMap.forEach((key, list) -> { 
                Long customerId = key.getKey();
                String customerName = key.getValue();  
    
                resultList.add(MapBuilder.of(6)
                        .put("customerId", customerId)
                        .put("customerName", customerName)
                        .put("users", list)
                        .build()
                );
            });

## 4.5 使用Stream优化ForEach ##

最后我们还可以使用Stream来优化Map的forEach:

// 先将用户按客户编号汇聚，同时保存客户编号与客户名称的关系
    Map<BiValue<Long, String>, List<Map<String, Object>>> customerUserMap = new HashMap<>(16);
    for (User user : users) { 
        Long customerId = user.getCustomerId();
        String customerName = user.getCustomerName();
        BiValue<Long, String> key = new BiValue<Long, String>()
            .setKey(customerId)
            .setValue(customerName);
    
        customerUserMap.computeIfAbsent(key, k -> new ArrayList<>(16))
            .add(MapBuilder.of(16)
                 .put("userId", user.getId())
                 .put("userName", user.getName())
                 .build()
                );
    }
    
    // 遍历所有客户，组装结果
    List<Map<String, Object>> resultList = customerUserMap.keySet()
        .stream()
        .map(key -> MapBuilder.of(6)
             .put("customerId", key.getKey())
             .put("customerName", key.getValue())
             .put("users", customerUserMap.get(key))
             .build()
            ).collect(Collectors.toList());

## 4.6 终极优化：定义对象 ##

怎么样，是不是看起来很完美了？新的代码相对于之前的代码要简洁一些了，而且多是使用流式处理的方式编写的，在编写代码的过程中尤其爽快！

但但但，仍旧有更直接简单粗暴的方式，就是定义一个Customer对象：

/** * * * @author LiuQi 2019/8/20-13:45 * @version V1.0 **/
    public class Customer { 
        private Long customerId;
        private String customerName;
    
        private List<User> users;
    
        public Customer customerId(Long customerId) { 
            this.customerId = customerId;
            return this;
        }
    
        public void setCustomerId(Long customerId) { 
            this.customerId = customerId;
        }
    
        public Long getCustomerId() { 
            return this.customerId;
        }
    
        public Customer customerName(String customerName) { 
            this.customerName = customerName;
            return this;
        }
    
        public void setCustomerName(String customerName) { 
            this.customerName = customerName;
        }
    
        public String getCustomerName() { 
            return this.customerName;
        }
    
        public Customer users(List<User> users) { 
            this.users = users;
            return this;
        }
    
        public void setUsers(List<User> users) { 
            this.users = users;
        }
    
        public List<User> getUsers() { 
            return this.users;
        }
    }

然后我们的主业务代码可以优化成以下这样：

Map<Long, Customer> customerMap = new HashMap<>(16);
    users.forEach(user -> { 
        Long customerId = user.getCustomerId();
        Customer customer = customerMap.computeIfAbsent(customerId, n -> new Customer()
                                                        .customerId(customerId)
                                                        .customerName(user.getCustomerName())
                                                       );
    
        List<User> userList = customer.getUsers();
        if (null == userList) { 
            userList = new ArrayList<>(16);
            customer.setUsers(userList);
        }
    
        userList.add(user);
    });
    
    Collection<Customer> resultList = customerMap.values();

面向对象的优势一下就体现出来了，瞬间感觉自己之前的优化白做，有没有！关键我们还引入了很多的如ListBuilder、MapBuilder、BiValue等对象！

当然不是白做，我们所引入的这些对象，在很多场景下都非常有用处，有很多场景就是要对这些集合类做各种加工处理的，并不是所有的场景使用面向对象的方式都更为简单，因此在工程中引入这些类是非常有用处的。而且关键的是，通过这一示例我们能够学习到Builder模式、流式处理以及Map的computeIfAbsent方法，能够知道一点怎样一步步的对自己的代码进行优化，甚至了解到在一些应用场景中，定义一些Bean能够大大简化我们的工作量，这还不够么？

从上述优化过程我们也可以看到，代码的复杂性与所选择的数据存储方式有着必然的关联性，这个数据存储方式不单单是数据库中数据的存储，也包含内存对象的存储，到底采用Map还是Bean的方式存储数据，或者所定义的Bean中包含有哪些属性，这些都对代码逻辑有着非常直接的影响。因此，写一段业务代码逻辑，最好是先确定他的数据存储：业务数据在数据库中如何存储、在内存中如何存储、返回的数据如何存储等。一个好的数据存储方式能够极大的简化代码逻辑，降低Bug率。