0x00

guava提供了Lists.transform这个方法来方便地对List进行转换，原型如下：

public static <F, T> List<T> transform(List<F> fromList, Function<? super F, ? extends T> function);

这个需求在实际开发中非常常见。
最常见的就是请求和响应的转换了。用户请求的Req和后台使用的Bean一定会有差异，同时给用户返回的Resp和后台使用的Bean也一定会有差异。造成这种差异的原因很多，比如请求和响应中有敏感数据，或者数据复杂等。

使用guava的Lists.transform可以方便的处理，比如：

    List<Integer> originList = Lists.newArrayList(1, 10);
    System.out.printf("originList is %s.\n", originList);

    List<Point> pointList = Lists.transform(originList, p -> {
        Point point = new Point(p, p);
        return point;
    });
    System.out.printf("pointList list is %s.\n", pointList);

输出：

originList is [1, 10].
pointList list is [java.awt.Point[x=1,y=1], java.awt.Point[x=10,y=10]].

上面这个代码将一个整数列表，转换成了一个X坐标和Y坐标相等的Point列表。

0x01

但是Lists.transform返回的这个List是有猫腻的！

如果你想对这个返回的List进行修改，如下:

for (Point point : pointList) {
    point.x = point.x + 1;
    point.y = point.y + 1;
}
System.out.printf("after change, pointList list is %s.\n", pointList);

输出：

after change, pointList list is [java.awt.Point[x=1,y=1], java.awt.Point[x=10,y=10]].

发现pointList里的值并没有发生改变！

如果你是用List.get()进行访问元素，将元素的hashcode打印出来。会发现，每次访问同一个元素获得的hashcode是不一样的，他们是不同的元素，所以修改的不是最初的对象！

Point point = pointList.get(0);
System.out.printf("pointList[0] is %s, hashcode is %d.\n", point, System.identityHashCode(point));
Point point2 = pointList.get(0);
System.out.printf("pointList[0] is %s, hashcode is %d.\n", point2, System.identityHashCode(point2));

输出：

pointList[0] is java.awt.Point[x=1,y=1], hashcode is 2101440631.
pointList[0] is java.awt.Point[x=1,y=1], hashcode is 2109957412.

0x10

[柯南BGM响起]
真相只有一个！
就是Lists.transform返回的List有问题！

仔细看下该方法的实现：

public static <F, T> List<T> transform(List<F> fromList, Function<? super F, ? extends T> function) {
    return (List)(fromList instanceof RandomAccess ? new Lists.TransformingRandomAccessList(fromList, function) : new Lists.TransformingSequentialList(fromList, function));
}

在这个例子中，传入的fromList出一个RandomAccess的List，所以返回一个Lists.TransformingRandomAccessList，这个类声明如下：

private static class TransformingRandomAccessList<F, T> extends AbstractList<T> implements RandomAccess, Serializable

这个类的override了多个方法，其中就有get方法，看下get方法的实现：

public T get(int index) {
    return this.function.apply(this.fromList.get(index));
}

即每次get的时候，都会调用一次传进来的Function。如果你的Function每次都new一个对象返回，那么每次get获取到的必然是不同的对象！

同理，迭代器的两个方法如下：

public Iterator<T> iterator() {
        return this.listIterator();
    }

    public ListIterator<T> listIterator(int index) {
        return new TransformedListIterator<F, T>(this.fromList.listIterator(index)) {
            T transform(F from) {
                return TransformingRandomAccessList.this.function.apply(from);
            }
        };
    }

每次迭代的时候也是调用了Function方法！

咿？如果每次都调用了Function方法，那么如果源List修改了，那么岂不是获取到数据也变了？试下：

Point point = pointList.get(0);
System.out.printf("pointList[0] is %s, hashcode is %d.\n", point, System.identityHashCode(point));
originList.set(0, 100);
Point point2 = pointList.get(0);
System.out.printf("pointList[0] is %s, hashcode is %d.\n", point2, System.identityHashCode(point2));

输出：

pointList[0] is java.awt.Point[x=1,y=1], hashcode is 2101440631.
pointList[0] is java.awt.Point[x=100,y=100], hashcode is 2109957412.

果然！
凶手原来是你！

不，凶手其实是我们！

0x11

说到这里，java8提供了类似方便的方法进行这样的处理：

List<Point> pointList = originList.stream().map(p -> {
    Point point = new Point(p, p);
    return point;
}).collect(Collectors.toList());

因为这个方法返回的是ArrayList的实例。

使用注解@Profile来标识加载的对象，配合@Component注解一起使用。
同@Component类似的注解也可以一起使用，比如@Service、@Controller、@Repository、@Configuration。

如下，我们有两个HelloService的实现，一个是用于开发环境的，这个实现可以简单一点；另外一个是用于真正的生产环境的，要进行真正的处理，比如调用RPC，数据库处理等。

@Service
@Profile({"dev"})
public class HelloServiceDevImpl implements HelloService {
    // ...
}

@Service
@Profile({"pro"})
public class HelloServiceImpl implements HelloService {
    // ...
}

application.yml的配置，如果要使用HelloServiceDevImpl，要激活对应的profile，可以使用：

spring:
  profiles:
    active: dev

类似的正式环境的配置，可以使用：

spring:
  profiles:
    active: pro

如果对象依赖于多个profile，也可以传入多个：

@Service
@Profile({"pro", "A", "B"})
public class HelloServiceImpl implements HelloService {
    // ...
}

这样只有当pro、A、B者三个profile都激活的时候才会启用：

spring:
  profiles:
    active: pro,A,B

扩展开来，控制对象的加载的注解父类为@Conditional，使用该注解的话要自己编写一个类实现org.springframework.context.annotation.Condition来进行处理。
spring-boot提供了多个已经实现好的注解可以用，@Profile只是其中一个，其他类似的还有@ConditionalOnBean，@ConditionalOnClass，@ConditionalOnExpression，@ConditionalOnJava，@ConditionalOnProperty等。

在使用RPC过程中，经常会调用多个RPC服务来获取数据。

比如获取用户个人主页的时候，就要去用户服务获取用户的头像、昵称等基本信息，还要去访问服务获取用户最近访问的信息，还有去关系服务获取用户新增的粉丝或关注的主播的消息。

值得注意的是，这些服务之间并没有依赖，即并不需要先获取用户的头像才能获取用户的访问信息。

如果一个一个地调用这些RPC服务，那么消耗的总时间就是这些RPC调用耗时之和。

因为这些服务之间并没有依赖，所以可以并行地调用，那么消耗的总时间就是耗时最长的那个RPC调用的时间。特别是当调用的RPC服务众多时，并且调用可以大幅度减少时间，提高效率。

如何并行调用呢？

采用线程池和Future就可以，样例如下。
进行两个计算任务，每个需要耗时3秒，如果按照往常调用，那么总共需要6秒时间。但如果并行调用，只需3秒。

import java.time.LocalDateTime;
import java.util.concurrent.*;

public class FutureTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {


        ExecutorService executorService =
                Executors.newFixedThreadPool(4);

        Callable<Integer> calculateA = new SumCalculateTask(3, 4);
        Callable<Integer> calculateB = new SumCalculateTask(4, 6);

        System.out.println("START AT " + LocalDateTime.now());
        Future<Integer> futureA = executorService.submit(calculateA);
        Future<Integer> futureB = executorService.submit(calculateB);

        Integer resultA = futureA.get(4, TimeUnit.SECONDS);
        System.out.println(resultA);
        Integer resultB = futureB.get(4, TimeUnit.SECONDS);
        System.out.println(resultB);

        System.out.println("END AT " + LocalDateTime.now());
        executorService.shutdown();
    }


    static class SumCalculateTask implements Callable<Integer> {

        private Integer a;
        private Integer b;

        public SumCalculateTask(Integer a, Integer b) {
            this.a = a;
            this.b = b;
        }

        @Override
        public Integer call() throws Exception {
            Thread.sleep(3000);
            return a + b;
        }
    }
}

Github源码示例：https://github.com/chengjf/java-snippet/blob/master/src/main/java/com/chengjf/future/ConcurrentCalculatorTest.java

一行参数就完事了。
在VM参数里添加：

-Duser.timezone=GMT+08

其实我自己一直想搭建这么一个工具，可以放一些常用的小工具，比如Json字符串美化，亦或者是查询今日天气，更或者是Base64之类的编解码。

最初我的想法是整一个客户端出来，那时候我看了AWT、Swing，后面有了JavaFX，但这个东西写起来实在麻烦就放弃了。

接下来想用Android来整，有了这个项目SharpPM25和SharpWeather，但后来实在觉得丑，也放弃了。

也用Python写过一个，database-interface-doc-management，用的是flask和emberjs。

也用Go写过一个，mymoney。

但是都好景不长，基本上是写了一个能跑起来的demo后就没管了。

最近工作时，又发现了经常使用这些东西，特别是查看Json。所以这个想法又涌现出来了。
我基本上是非常不愿意写前端代码的，那些样式、兼容性之类的东西使我很烦。所以我找了一个框架vaadin来写第一版的helper，先用的是vaadin10。但是这个vaadin10太新了，以至于safari和ie的支持都不算太好，我跑起来后就放弃了。

接下来有了这个helper-vue，使用spring-boot和vue。这个spring-boot就是现在工作使用的，vue以前就写过一点。这样项目就搭建起来了，虽然页面样式什么的丑了一点，但是不在乎么，只希望以后不要荒废这个项目。

所以我开了个子域名https://helper.chengjf.com给这个项目。