从命名变量到设计软件架构,开发人员每天都要做出许多决定,而做出正确决定的最好的办法就是经验。虽然并非每个人都具备丰富的软件开发经验,但每个人都可以从他人身上学习。下面是我对 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
- 如果可以使用 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 断言
断言用来检查程序执行的先决条件,是快速失败原则的一种体现。可以借助断言更快地定位错误根源。
对象的状态:
- 永远不要创建无效对象或把对象变为无效状态。
- 在构造函数和方法中,始终检查入参确保符合要求。
- 不要使用Javaassert
- 使用Assertions
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。如果需要读写,则不要用通配符。
- 大家都喜欢 PECS 原则(生产者用 extends,消费者用 super)
- T Producer 使用Foo<? extends T>。
- 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 通用原则
- 使用下面这些库的时候请当心,它们是非线程安全的。如果在多个线程之间共享,则务必始终对对象进行同步。
- Date(非不可变):推荐使用线程安全的新 Date-time API。
- SimpleDateFormat :推荐使用线程安全的新 Date-time API。
- 优先使用java.util.concurrent.atomic类,而不是把变量标记为volatile。
- 原子类的行为对于普通开发人员更显而易见,而使用 volatile 需要了解 Java 内存模型。
- 原子类将volatile
- 了解哪些场合适合使用volatile
- 当需要受检异常但没有返回类型时,请使用 Callable<Void>。由于 Void 无法实例化,因此可以清晰地传达意图,安全地返回 null。
13.2 线程
- 可以认为java.lang.Thread已过期,推荐用java.util.concurrentpackage。后者提供了更干净的解决方案。
- 不要继承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)
- 始终返回集合的拷贝,避免new ArrayList(list)
- 每个集合都应该包装到自己的类中。这样因此与集合相关的行为就有了归属(例如,filter 方法,可以向每个元素应用规则)。
15、其它原则
- 推荐使用 lambda 而非匿名类。
- 推荐使用方法引而非 lambda。
- 推荐使用枚举而非 int 常量。
- 如果需要结果精确,推荐使用 BigDecimal 而非 float 或 double。
- 推荐使用原始类型而非装箱类型。
- 推荐使用常数,不要在代码中使用“魔数”。
- 使用 Optional,不要返回 Null。集合也一样:返回空数组或集合,不要返回 null。
- 避免创建不必要的对象,尽可能重用对象,避免产生不必要的 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 + ")");
希望本文对你有所帮助!
原作者: 大白