Java 最佳实践,提升代码可读性与可靠性
(给
ImportNew
加星标,提高Java技能)
从命名变量到设计软件架构,开发人员每天都要做出许多决定,而做出正确决定的最好的办法就是经验。虽然并非每个人都具备丰富的软件开发经验,但每个人都可以从他人身上学习。下面是我对 Java 开发 总结的
一些技巧,希望可以有助你提高 Java 代码的可读性和可靠性。
1、编程原则
写代码不是够用就好,因为这些代码不仅需要你维护,未来某个时刻还有其他人会加入维护的行列。软件开发的“二八定律”, 开发人员 80% 的时间在阅读代码,而仅有 20% 的时间在编写和调试。
请务必编写可读性高的代码
。
这样的代码不看注释只通过代码就可以了解代码完成的功能。
下面我会列出一些重要的设计原则,可以帮助我们设计出优秀的代码。
-
KISS 原则
:
在设计当中应当注重简约的原则。与之相对的是,在刚开始编程时就高出复杂、摸棱两可的设计。 -
DRY 原则
:
不要做重复的工作。把重复的代码和逻辑提取出来。 -
YAGNI 原则:不要过度设计。可以为将来预留扩展点,但不要仅仅因为可能需要就开始工作。
-
代码整洁更重要
:没有必要为了展示聪明和学识而去“打磨”代码。 -
避免过早优化
:过早的优化的问题在于,只有事后才能真正知道真正的瓶颈在哪里。 -
单一职责
:一个类只负责一个功能领域中的相应职责。 -
组合优于继承
:实现具有复杂行为的对象应该通过实现接口而不是继承 来添加行为
。 -
对象健身操
:对象健身操时一组 编程练习
,包含了9条规则(也称为“九戒”)。 -
快速失败
原则
:快速失败原则表示一旦发生任何意外错误,应立即停止当前操作。坚持这一原则通常会带来更稳定的解决方案。
2、Package 最佳实践
- 优先考虑按业务领域而非技术层次构组织 package。
- 定义 package 时要考虑信息的封装和隐藏,避免按技术实现定义 package 带来的错误使用。
-
View package 作为严格的 API 对待:不要暴露内部实现。
- 不要为只在 package 内使用的类使用 pulic。
3、Class 最佳实践
3.1 静态类
-
静态类 不允许实例
化,为静态类添加一个私有构造函数。 - 静态类必须满足:无状态、不可变、不允许继承、线程安全。
- 确保使用静态类不会给程序带来副作用。通常静态类会作为工具类提供,例如过滤列表等。
3.2 继承
- 优先考虑组合而不是继承。
-
不要公开 protected
字段,可以提供一个 protected
accessor。 - 如果可以使用 final,请把类标记为 final 。
- 如果不希望被其他类继承,同样把类标记为 final。
-
除非允许子类覆盖方法, 否则请把方法标记为 final
。 -
如果不需要构造函数,请不要创建没有实现逻辑的默认构造函数。Java 会替你创建一个 默认
构造函数。
4、接口最佳实践
- 不要在接口中定义常量,这样不但无法阻止类实现该接口同时还会污染 API。请改为使用静态类。使用静态类还有一个好处,就是可以在 static 代码块中执行更复杂的对象初始化操作。
-
不要过度使用 接口
。 -
如果 有且只有一个
类实现接口,这可能是过度使用接口的表现。这种用法的弊大于利。 -
“ 面向接口编程,不要面向实现编程
”并不意味着每个业务类都要有接口,这种是过度设计,违反前面提到的 YAGNI 原则。 -
保持接口功能小而具体,这样使用的人能快速找到自己感兴趣的功能。可以参考 SOLID
六大设计原则中的 SIP 原则(接口隔离原则)。
5、Finalizer 最佳实践
- 请谨慎使用 Object#finalize()。只用作清理资源时 fail-safe 措施(失效安全措施)使用,比如关闭文件。使用资源的时,始终提供显式的清理方法,比如 close()。
-
在继承层次结构中,始终在 try 块中调用父类的 finalize(),在 finally
中执行清理操作。 - 如果没有显示调用清理方法并且 finalizer 关闭了资源,要记录错误。
- 如果没有 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());
super(Collections.emptyList());
}
}
3、通配符:
只读不可写时用 exends,只写不可读时用 super。如果需要读写,则不要用通配符。
-
大家都喜欢 PECS 原则(生产者用 extends,消费者用 super)
-
T Producer 使用 Foo
。 -
T Consumer 使用 Foo
。
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 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 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 通用原则
-
使用下面这些库的时候请当心,它们是非线程安全的。
如果在多个线程之间共享,则务必始终对对象进行同步。 - Date(非不可变):推荐使用线程安全的新 Date-time API。
-
SimpleDateFormat :
推荐使用线程安全的新 Date-time API。 -
优先使用 java.util.concurrent.atomic
类,而不是把变量标记为 volatile
。 -
原子类的行为对于普通开发人员更显而易见,而使用 volatile 需要了解 Java 内存模型。
-
原子类将
volatile
变量包装在一个更友好的接口中。 -
了解哪些场合适合使用
volatile
变量
。 - 当需要受检异常但没有返回类型时,请使用 Callable。由于 Void 无法实例化,因此可以清晰地传达意图,安全地返回 null。
13.2 线程
-
可以认为 java.lang.Thread
已过期,推荐用 java.util.concurrent
package。后者提供了更干净的解决方案。 -
不要继承 java.lang.Thread
,而是实现 Runnable
接口并在构造函数中使用实例创建一个新线程(组合优于继承)。 - 处理并发处理时,优先选择 executors 和 streams。
- 推荐自定义线程工厂,可以更好地控制创建线程时的配置。
- 在 Executors 中对非关键线程使用 DaemonThreadFactory,这样在服务器关闭时立即关闭线程池。
this.executor = Executors.newCachedThreadPool((Runnable runnable) -> {
Thread thread = Executors.defaultThreadFactory().newThread(runnable);
thread.setDaemon(true);
return thread;
});
- Java同步已经不像以前那么慢了(55–110ns)。不要使用诸如双重检查锁定之类的破坏性技巧来提高效率。
- 最好与内部对象(而不是类)同步,因为用户可能会与类或者实例同步。
- 始终按照相同的顺序同步多个对象,避免死锁。
- 与类同步并不能 100% 可靠阻止访问内部对象。访问资源时,请始终使用相同的锁。
-
当心, synchronized
关键字不是方法签名的一部分,因此不会被子类继承。 -
要避免过度使用同步,这可能导致性能下降和产生死锁。只需要同步的代码使用 synchronized
关键字。
14、集合最佳实践
- 尽可能在多线程代码中使用 Java 5 并发集合,不但安全而且性能高。
-
在合适的情况下,推荐使用 CopyOnWriteArrayList
取代 SynchronizedList。 -
推荐使用 Collections.unmodifiable list(…) 或在把集合作为参数 new ArrayList(list)
接收时复制集合。避免从 class 以外的地方修改集合。 -
始终返回集合的拷贝,避免 new ArrayList(list)
被外部修改集合。 - 每个集合都应该包装到自己的类中。这样因此与集合相关的行为就有了归属(例如,filter 方法,可以向每个元素应用规则)。
15、其它原则
-
推荐使用 lambda 而非匿名类。
-
推荐使用方法引而非 lambda。
-
推荐使用枚举而非 int 常量。
-
如果需要结果精确, 推荐使用 BigDecima
l 而非 float 或 double。 -
推荐使用原始类型而非装箱类型。
-
推荐使用常数,不要在代码中使用“魔数”。
-
使用 Optional,不要返回 Null。集合也一样:返回空数组或集合,不要返回 null。
-
避免创建不必要的对象,尽可能重用对象,避免产生不必要的 GC。
16、延迟初始化最佳实践
延迟初始化是一种性能优化。处理某些不可避免开销很大的情况。Java 8 支持 Supplier 函数式接口支持延迟初始化。
// 线程安全的延迟初始化
public final class Lazy<T> {
private volatile T value;
public T getOrCompute(Supplier supplier) {
final T result = value; // 执行一次 volatile 读取
return result == null ? maybeCompute(supplier) : result;
}
private synchronized T maybeCompute(Supplier supplier) {
if (value == null) {
value = supplier.get();
}
return value;
}
}
Lazy lazyToString= new Lazy()
return lazyToString.getOrCompute( () -> "(" + x + ", " + y + ")");
希望本文对你有所帮助!
推荐阅读
点击标题可跳转
看完本文有收获?请转发分享给更多人
关注「ImportNew」,提升Java技能
好文章,我
在看
:heart: