Java最佳实践，提升代码可读性与可靠性

从命名变量到设计软件架构，开发人员每天都要做出许多决定，而做出正确决定的最好的办法就是经验。虽然并非每个人都具备丰富的软件开发经验，但每个人都可以从他人身上学习。下面是我对 Java 开发总结的一些技巧，希望可以有助你提高 Java 代码的可读性和可靠性。

1、编程原则

写代码不是够用就好，因为这些代码不仅需要你维护，未来某个时刻还有其他人会加入维护的行列。软件开发的“二八定律”，开发人员 80％ 的时间在阅读代码，而仅有 20％ 的时间在编写和调试。

请务必编写可读性高的代码。

这样的代码不看注释只通过代码就可以了解代码完成的功能。

下面我会列出一些重要的设计原则，可以帮助我们设计出优秀的代码。

• KISS 原则：在设计当中应当注重简约的原则。与之相对的是，在刚开始编程时就高出复杂、摸棱两可的设计。
• DRY 原则：不要做重复的工作。把重复的代码和逻辑提取出来。
• YAGNI 原则：不要过度设计。可以为将来预留扩展点，但不要仅仅因为可能需要就开始工作。
• 代码整洁更重要：没有必要为了展示聪明和学识而去“打磨”代码。
• 避免过早优化：过早的优化的问题在于，只有事后才能真正知道真正的瓶颈在哪里。
• 单一职责：一个类只负责一个功能领域中的相应职责。
• 组合优于继承：实现具有复杂行为的对象应该通过实现接口而不是继承来添加行为。
• 对象健身操：对象健身操时一组编程练习，包含了9条规则（也称为“九戒”）。
• 快速失败**原则**：快速失败原则表示一旦发生任何意外错误，应立即停止当前操作。坚持这一原则通常会带来更稳定的解决方案。

2、Package 最佳实践

1. 优先考虑按业务领域而非技术层次构组织 package。
2. 定义 package 时要考虑信息的封装和隐藏，避免按技术实现定义 package 带来的错误使用。
3. View package 作为严格的 API 对待：不要暴露内部实现。
4. 不要为只在 package 内使用的类使用 pulic。

3、Class 最佳实践

3.1 静态类

1. 静态类不允许实例化，为静态类添加一个私有构造函数。
2. 静态类必须满足：无状态、不可变、不允许继承、线程安全。
3. 确保使用静态类不会给程序带来副作用。通常静态类会作为工具类提供，例如过滤列表等。

3.2 继承

1. 优先考虑组合而不是继承。
2. 不要公开 protected 字段，可以提供一个 protected accessor。
3. 如果可以使用 final，请把类标记为 final 。
4. 如果不希望被其他类继承，同样把类标记为 final。
5. 除非允许子类覆盖方法，否则请把方法标记为 final。
6. 如果不需要构造函数，请不要创建没有实现逻辑的默认构造函数。Java 会替你创建一个默认构造函数。

4、接口最佳实践

1. 不要在接口中定义常量，这样不但无法阻止类实现该接口同时还会污染 API。请改为使用静态类。使用静态类还有一个好处，就是可以在 static 代码块中执行更复杂的对象初始化操作。
2. 不要过度使用接口。
3. 如果有且只有一个类实现接口，这可能是过度使用接口的表现。这种用法的弊大于利。
4. “面向接口编程，不要面向实现编程”并不意味着每个业务类都要有接口，这种是过度设计，违反前面提到的 YAGNI 原则。
5. 保持接口功能小而具体，这样使用的人能快速找到自己感兴趣的功能。可以参考 SOLID 六大设计原则中的 SIP 原则（接口隔离原则）。

5、Finalizer 最佳实践

1. 请谨慎使用 Object#finalize()。只用作清理资源时 fail-safe 措施（失效安全措施）使用，比如关闭文件。使用资源的时，始终提供显式的清理方法，比如 close()。
2. 在继承层次结构中，始终在 try 块中调用父类的 finalize()，在 finally 中执行清理操作。
3. 如果没有显示调用清理方法并且 finalizer 关闭了资源，要记录错误。
4. 如果没有 logger，请使用线程异常处理程序。最终会转到标准错误并记录日志。

6、通用原则

6.1 断言

断言用来检查程序执行的先决条件，是快速失败原则的一种体现。可以借助断言更快地定位错误根源。

对象的状态：

• 永远不要创建无效对象或把对象变为无效状态。
• 在构造函数和方法中，始终检查入参确保符合要求。
• 不要使用Java assert 关键字，因为它可能会被禁用。
• 使用 Assertions 类避免冗长的 if-else 检查。

6.2 泛型

下面是开发者应该注意的泛型使用典型场景。

1、尽可能使用类型推断而不是返回基类或接口：

// MySpecialObject o = MyObjectFactory.getMyObject();
public <T extends MyObject> T getMyObject(int type) { 
    return (T) factory.create(type);
}

2、当无法自动推断类型时使用 inline。

public class MySpecialObject extends MyObject<SpecialType> {
  public MySpecialObject() {
   super(Collections.emptyList());   // 这种写法很丑陋，还丢弃了类型
   super(Collections.EMPTY_LIST();    // 这种写法很蠢
   // 推荐写法
   super(new ArrayList<SpecialType>());    
   super(Collections.<SpecialType>emptyList());
  }
}

3、通配符：

只读不可写时用 exends，只写不可读时用 super。如果需要读写，则不要用通配符。

1. 大家都喜欢 PECS 原则（生产者用 extends，消费者用 super）
2. T Producer 使用 Foo<? extends T>。
3. T Consumer 使用 Foo<? super T>。

7、单例最佳实践

不要原封不动地照抄经典“设计模式”代码实现单例。虽然在 C++ 中有效，但在 Java 中不合适。

1、下面的代码尽管线程安全，但请不要这么做（当心性能瓶颈）。

public final class MySingleton {
  private static MySingleton instance;

  private MySingleton() {
    // 单例
  }

  public static synchronized MySingleton getInstance() {
    if (instance == null) {
      instance = new MySingleton();
    }
    return instance;
  }
}

2、如果确实需要延迟初始化，则可以像下面这样结合使用：

public final class MySingleton {
  private MySingleton() {
    // singleton
  }

  private static final class MySingletonHolder {
    static final MySingleton instance = new MySingleton();
  }

  public static MySingleton getInstance() {
    return MySingletonHolder.instance;
  }
}

3、Spring 中的单例没有性能瓶颈。默认情况下，创建的 bean 会加入 singleton scope，然后提供给所有的使用者。

8、异常最佳实践

1、可恢复的情况下用受检异常，编程中的错误用运行时异常。

例如将字符串转为整数：

• 错误：NumberFormatException 继承自 RuntimeException，这是一种编程错误。
• 不要像下面这样做：

// String str = input string
Integer value = null;

try {
   value = Integer.valueOf(str);
} catch (NumberFormatException e) {
    // 非字符串 string
}

if (value == null) {
    // 处理错误的 string
} else {
    // 业务逻辑
}

• 正确做法：

// String str = input string
// string 只包含数字和开始的负号
if ( (str != null) && str.matches("-?\\d++") ) {  
   Integer value = Integer.valueOf(str);
  // 业务逻辑
} else {
  // 处理错误的 string
}

2、在正确的地方处理异常，通常是业务层。

• 错误做法：发生数据库异常时，数据对象层不知道如何处理。

class UserDAO{
    public List<User> getUsers(){
        try{
            ps = conn.prepareStatement("SELECT * from users");
            rs = ps.executeQuery();
            //return result
        }catch(Exception e){
            log.error("exception")
            return null
        }finally{
            // 释放资源
        }
    }}

• 推荐方式：数据层只要抛出异常，接下来交由合适的层次来处理。

// 推荐方法
// 数据层只管抛出异常交由其他层处理
class UserDAO{
    public List<User> getUsers(){
       try{
          ps = conn.prepareStatement("SELECT * from users");
          rs = ps.executeQuery();
          //return result
       }catch(Exception e){
        throw new DataLayerException(e);
       }finally{
          // 释放资源
       }
   }
}

3、通常，异常不应在触发异常时记录，而应当在实际处理时记录。抛出或重新抛出异常时记录日志，往往会让日志文件看起来杂乱无章。

另外请注意，异常堆栈跟踪会捕获生成异常的位置。

4、推荐使用标准异常。

5、推荐使用异常而非返回码。

9、Equals 与 HashCode 最佳实践

---

实现 Equals 和 HashCode 的时候有许多要注意的地方。简单起见，可以用 java.util.Object 的 equals 10和 hash。

public final class User {
  private final String firstName;
  private final String lastName;
  private final int age;

  ...

  public boolean equals(Object o) {
    if (this == o) {
      return true;
    } else if (!(o instanceof User)) {
      return false;
    }

    User user = (User) o;
    return Objects.equals(getFirstName(), user.getFirstName()) &&                                 
     Objects.equals(getLastName(),user.getLastName()) &&
     Objects.equals(getAge(), user.getAge());
  }

  public int hashCode() {
    return Objects.hash(getFirstName(),getLastName(),getAge());
  }
}

10、资源管理最佳实践

安全释放资源的方法：

• try-with-resources 语句可确保在语句执行结束关闭所有资源。
• 实现 java.lang.AutoCloseable 接口（java.io.Closeable）的对象都可以作为资源使用。

private doSomething() {
    try (BufferedReader br = new BufferedReader(new FileReader(path))) {
        try {
        // 业务逻辑
    }
}

11、**提供 Java 关闭钩子**

---

如果 JVM 正常终止会调用提供的关闭钩子函数。当然了，这无法解决由于断电引起的突然终止。

下面是 finalize() 的一种替代方法，仅在 System.runFinalizersOnExit() 为 true（默认为 false）时调用。

public final class SomeObject {
  var distributedLock = new ExpiringGeneralLock ("SomeObject", "shared");

  public SomeObject() {
    Runtime
      .getRuntime()
      .addShutdownHook(new Thread(new LockShutdown(distributedLock)));
  }

  /** 从不同的服务器上获取锁 */
  ...
  /** 安全地释放分布式锁 */
  private static final class LockShutdown implements Runnable {
    private final ExpiringGeneralLock distributedLock;

    public LockShutdown(ExpiringGeneralLock distributedLock) {
      if (distributedLock == null) {
        throw new IllegalArgumentException("ExpiringGeneralLock is null");
      }
      this.distributedLock = distributedLock;
    }

    public void run() {
      if (isLockAlive()) {
        distributedLock.release();
      }
    }
    /** @return True 如果获得锁成功且没有过期 */
    private boolean isLockAlive() {
      return distributedLock.getExpirationTimeMillis() > System.currentTimeMillis();
    }
  }
}

服务器之间可以共享过期或新创建的资源，这样可以支持从突然终止的情况下恢复（例如断电）。

在上面的示例代码中，使用了在系统之间共享的锁 ExpiringGeneralLock。

12、日期日期最佳实践

Java 8 在 java.time package 中引入了新的日期时间 API，弥补了早期 API 的一些缺点：例如非线程安全、设计不良，时区处理困难等。

13、并发最佳实践

13.1 通用原则

1. 使用下面这些库的时候请当心，它们是非线程安全的。如果在多个线程之间共享，则务必始终对对象进行同步。
2. Date（非不可变）：推荐使用线程安全的新 Date-time API。
3. SimpleDateFormat ：推荐使用线程安全的新 Date-time API。
4. 优先使用 java.util.concurrent.atomic 类，而不是把变量标记为 volatile。
5. 原子类的行为对于普通开发人员更显而易见，而使用 volatile 需要了解 Java 内存模型。
6. 原子类将 volatile 变量包装在一个更友好的接口中。
7. 了解哪些场合适合使用 volatile 变量。
8. 当需要受检异常但没有返回类型时，请使用 Callable。由于 Void 无法实例化，因此可以清晰地传达意图，安全地返回 null。

13.2 线程

1. 可以认为 java.lang.Thread 已过期，推荐用 java.util.concurrent package。后者提供了更干净的解决方案。
2. 不要继承 java.lang.Thread，而是实现 Runnable 接口并在构造函数中使用实例创建一个新线程（组合优于继承）。
3. 处理并发处理时，优先选择 executors 和 streams。
4. 推荐自定义线程工厂，可以更好地控制创建线程时的配置。
5. 在 Executors 中对非关键线程使用 DaemonThreadFactory，这样在服务器关闭时立即关闭线程池。

this.executor = Executors.newCachedThreadPool((Runnable runnable) -> {
    Thread thread = Executors.defaultThreadFactory().newThread(runnable);
    thread.setDaemon(true);
    return thread;
});

1. Java同步已经不像以前那么慢了（55–110ns）。不要使用诸如双重检查锁定之类的破坏性技巧来提高效率。
2. 最好与内部对象（而不是类）同步，因为用户可能会与类或者实例同步。
3. 始终按照相同的顺序同步多个对象，避免死锁。
4. 与类同步并不能 100% 可靠阻止访问内部对象。访问资源时，请始终使用相同的锁。
5. 当心，synchronized 关键字不是方法签名的一部分，因此不会被子类继承。
6. 要避免过度使用同步，这可能导致性能下降和产生死锁。只需要同步的代码使用 synchronized 关键字。

14、集合最佳实践

1. 尽可能在多线程代码中使用 Java 5 并发集合，不但安全而且性能高。
2. 在合适的情况下，推荐使用 CopyOnWriteArrayList 取代 SynchronizedList。
3. 推荐使用 Collections.unmodifiable list(…) 或在把集合作为参数 new ArrayList(list) 接收时复制集合。避免从 class 以外的地方修改集合。
4. 始终返回集合的拷贝，避免 new ArrayList(list) 被外部修改集合。
5. 每个集合都应该包装到自己的类中。这样因此与集合相关的行为就有了归属（例如，filter 方法，可以向每个元素应用规则）。

15、其它原则

1. 推荐使用 lambda 而非匿名类。
2. 推荐使用方法引而非 lambda。
3. 推荐使用枚举而非 int 常量。
4. 如果需要结果精确，推荐使用 BigDecimal 而非 float 或 double。
5. 推荐使用原始类型而非装箱类型。
6. 推荐使用常数，不要在代码中使用“魔数”。
7. 使用 Optional，不要返回 Null。集合也一样：返回空数组或集合，不要返回 null。
8. 避免创建不必要的对象，尽可能重用对象，避免产生不必要的 GC。

16、延迟初始化最佳实践

延迟初始化是一种性能优化。处理某些不可避免开销很大的情况。Java 8 支持 Supplier 函数式接口支持延迟初始化。

// 线程安全的延迟初始化
public final class Lazy<T> {
    private volatile T value;

    public T getOrCompute(Supplier<T> supplier) {
        final T result = value; // 执行一次 volatile 读取
        return result == null ? maybeCompute(supplier) : result;
    }

    private synchronized T maybeCompute(Supplier<T> supplier) {
        if (value == null) {
            value = supplier.get();
        }
        return value;
    }
}
Lazy<String> lazyToString= new Lazy<>()
return lazyToString.getOrCompute( () -> "(" + x + ", " + y + ")");