如何写出更好的Java代码

from: http://it.deepinmind.com/java/2014/05/21/better-java.html

Java是最流行的编程语言之一，但似乎并没有人喜欢使用它。好吧，实际上Java是一门还不错的编程语言，由于最近Java 8发布了，我决定来编辑一个如何能更好地使用Java的列表，这里面包括一些库，实践技巧以及工具。

这篇文章在GitHub上也有。你可以随时在上面贡献或者添加你自己的Java使用技巧或者最佳实践。

• 编码风格

  • 结构体

    *   builder模式
    

    • 依赖注入
  • 避免null值
  • 不可变
  • 避免过多的工具类

  • 格式

    *   文档
    

    • Stream

• 部署

  • 框架

  • Maven

    *   依赖收敛
    

    • 持续集成
  • Maven仓储
  • 配置管理

• 库

  • 遗失的特性

    *   Apache Commons
    

    • Guava
    • Gson
    • Java Tuples
    • Joda-Time
    • Lombok
    • Play framework
    • SLF4J

    • jOOQ

    • 测试

      • jUnit 4
    • jMock
    • AssertJ

• 工具

  • IntelliJ IDEA

    *   Chronon
    

    • JRebel
  • 校验框架
  • Eclipse Memory Analyzer

• 资源

  • 书籍
  • 播客

编码风格

传统的Java编码方式是非常啰嗦的企业级JavaBean的风格。新的风格更简洁准确，对眼睛也更好。

结构体

我们这些码农干的最简单的事情就是传递数据了。传统的方式就是定义一个JavaBean:

public class DataHolder {
    private String data;

    public DataHolder() {
    }

    public void setData(String data) {
        this.data = data;
    }

    public String getData() {
        return this.data;
    }
}

public class DataHolder {
    public final String data;

    public DataHolder(String data) {
        this.data = data;
    }
}

public class ComplicatedDataHolder {
    public final String data;
    public final int num;
    // lots more fields and a constructor

    public class Builder {
        private String data;
        private int num;

        public Builder data(String data) {
            this.data = data;
            return this;
        }

        public Builder num(int num) {
            this.num = num;
            return this;
        }

        public ComplicatedDataHolder build() {
            return new ComplicatedDataHolder(data, num); // etc
        }
    }
}

final ComplicatedDataHolder cdh = new ComplicatedDataHolder.Builder()
    .data(“set this”)
    .num(523)
    .build();

public class FooWidget {
    private final String data;
    private final Optional<Bar> bar;

    public FooWidget(String data) {
        this(data, Optional.empty());
    }

    public FooWidget(String data, Optional<Bar> bar) {
        this.data = data;
        this.bar = bar;
    }

    public Optional<Bar> getBar() {
        return bar;
    }
}

final Optional<FooWidget> fooWidget = maybeGetFooWidget();
final Baz baz = fooWidget.flatMap(FooWidget::getBar)
                         .flatMap(BarWidget::getBaz)
                         .orElse(defaultBaz);

final FooWidget fooWidget;
if (condition()) {
    fooWidget = getWidget();
} else {
    try {
        fooWidget = cachedFooWidget.get();
    } catch (CachingException e) {
        log.error(“Couldn’t get cached value”, e);
        throw e;
    }
}
// fooWidget is guaranteed to be set here

public class MiscUtil {
    public static String frobnicateString(String base, int times) {
        // … etc
    }

    public static void throwIfCondition(boolean condition, String msg) {
        // … etc
    }
}

public interface Thrower {
    public void throwIfCondition(boolean condition, String msg) {
        // …
    }

    public void throwAorB(Throwable a, Throwable b, boolean throwA) {
        // …
    }
}

final List<String> filtered = list.stream()
    .filter(s -> s.startsWith(“s”))
    .map(s -> s.toUpperCase());

final List<String> filtered = Lists.newArrayList();
for (String str : list) {
    if (str.startsWith(“s”) {
        filtered.add(str.toUpperCase());
    }
}

<dependencies>
    <dependency>
        <groupId>org.third.party</groupId>
        <artifactId>some-artifact</artifactId>
    </dependency>
</dependencies>

Foo library depends on Bar library v1.0
Widget library depends on Bar library v0.9

// Instead of
final Map<String, Widget> map = new HashMap<String, Widget>();

// You can use
final Map<String, Widget> map = Maps.newHashMap();

final Gson gson = new Gson();
final String json = gson.toJson(fooWidget);

final FooWidget newFooWidget = gson.fromJson(json, FooWidget.class);

Pair<String, Integer> func(String input) {
    // something…
    return Pair.with(stringResult, intResult);
}

Joda-Time

Joda-Time是我用过的最好的时间库了。简直，直接，容易测试。你还想要什么？

这个库里我最喜欢的一个类就是Duration，因为我用它来告诉说我要等待多长时间，或者过多久我才进行重试。

Lombok

Lombok是一个非常有趣的库。它通过注释来减少了Java中的饱受诟病的样板代码（注：setter,getter之类的）。

想给你类中的变量增加setter， getter方法？太简单了：

public class Foo {
    @Getter @Setter private int var;
}

final Foo foo = new Foo();
foo.setVar(5);

Play框架

备选方案：Jersey或者Spark

在Java中实现REST风格的WEB服务有两大阵营：JAX-RS和其它。

JAX-RS是传统的方式。你使用像Jersey这样的东西来将注解和接口，实现组合到一起来实现WEB服务。这样做的好处就是，你可以通过一个接口就能很容易创建出一个调用的客户端来。

Play框架是在JVM上实现WEB服务的截然不同的一种方式：你有一个routes文件，然后你去实现routes中那些规则所引用到的类。它其实就是个完整的MVC框架，不过你可以只用它来实现REST服务。

它同时支持Java和Scala。它优先使用Scala这点可能有点令人沮丧，但是用Java进行开发的话也非常不错。

如果你习惯了Python里的Flask这类的微框架，那么你应该会对Spark感到很熟悉。有了Java 8它简直如虎添翼。

SLF4J

Java打印日志有许多不错的解决方案。我个人最喜欢的是SLF4J，因为它是可挺插拔的，并且可以同时混合不同的日志框架中输出的日志。有个奇怪的工程同时使用了java.util.logging, JCL, 和log4j？没问题，SLF4J就是为它而生的。

想入门的话，看下它的这个两页的手册就足够的了。

jOOQ

我不喜欢很重的ORM框架，因为我喜欢SQL。因此我写了许多的JDBC模板，但它们很难维护。jOOQ是个更不错的解决方案。

你可以在Java中以一种类型安全的方式来书写SQL语句：

// Typesafely execute the SQL statement directly with jOOQ
Result<Record3<String, String, String>> result =
create.select(BOOK.TITLE, AUTHOR.FIRST_NAME, AUTHOR.LAST_NAME)
    .from(BOOK)
    .join(AUTHOR)
    .on(BOOK.AUTHOR_ID.equal(AUTHOR.ID))
    .where(BOOK.PUBLISHED_IN.equal(1948))
    .fetch();

测试

测试对软件来说至关重要。下面这些库能让测试变得更加容易。

jUnit 4

jUnit就不用介绍了。它是Java中单元测试的标准工具。

不过可能你还没有完全发挥jUnit的威力。jUnit还支持参数化测试，以及能让你少写很多样板代码的测试规则，还有能随机测试代码的Theory,以及Assumptions。

jMock

如果你已经完成了依赖注入，那么它回报你的时候来了：你可以mock出带副作用的代码（就像和REST服务器通信那样），并且仍然能对调用它的代码执行断言操作。

jMock是Java中标准的mock工具。它的使用方式是这样的：

public class FooWidgetTest {
    private Mockery context = new Mockery();

@Test
public void basicTest() {
    final FooWidgetDependency dep = context.mock(FooWidgetDependency.class);

    context.checking(new Expectations() {
        oneOf(dep).call(with(any(String.class)));
        atLeast(0).of(dep).optionalCall();
    });

    final FooWidget foo = new FooWidget(dep);

    Assert.assertTrue(foo.doThing());
    context.assertIsSatisfied();
}

}

这段代码通过jMock设置了一个FooWidgetDependency ，然后添加了一些期望的操作。我们希望dep的call方法被调用一次而dep的optionalCall 方法会被调用0或更多次。

如果你反复的构造同样的FooWidgetDependency，你应该把它放到一个测试设备（Test Fixture）里，然后把assertIsSatisfied放到一个@After方法中。

AssertJ

你是不是用jUnit写过这些？

final List<String> result = some.testMethod();
assertEquals(4, result.size());
assertTrue(result.contains(“some result”));
assertTrue(result.contains(“some other result”));
assertFalse(result.contains(“shouldn’t be here”));

assertThat(some.testMethod()).hasSize(4)
                             .contains(“some result”, “some other result”)
                             .doesNotContain(“shouldn’t be here”);

工具

IntelliJ IDEA

备选方案： Eclipse and Netbeans

最好的Java IDE当然是 IntelliJ IDEA。它有许多很棒的特性，我们之所以还能忍受Java这些冗长的代码，它起了很大的作用。自动补全很棒，< a href=”http://i.imgur.com/92ztcCd.png“ target=”_blank”>代码检查也超赞，重构工具也非常实用。

免费的社区版对我来说已经足够了，不过在旗舰版中有许多不错的特性比如数据库工具，Srping框架的支持以及Chronon等。

Chronon

GDB 7中我最喜欢的特性就是调试的时候可以按时间进行遍历了。有了IntelliJ IDEA的Chronon插件后，这个也成为现实了。当然你得是旗舰版的。

你可以获取到变量的历史值，跳回前面执行的地方，获取方法的调用历史等等。第一次使用的话会感觉有点怪，但它能帮忙你调试一些很棘手的BUG。

JRebel

持续集成通常都是SaaS产品的一个目标。你想想如果你甚至都不需要等到编译完成就可以看到代码的更新？

这就是JRebel在做的事情。只要你把你的服务器挂到某个JRebel客户端上，代码一旦有改动你马上就能看到效果。当你想快速体验一个功能的话，这个的确能节省不少时间。

验证框架

Java的类型系统是相当弱的。它不能区分出普通字符串以及实际上是正则的字符串，也不能进行