阅读全文

⭐⭐⭐ Spring Boot 项目实战	⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》	《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》	《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》	《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》	《Java 面试题 + Java 学习指南》

摘要: 原创出处 juejin.cn/post/7263760831052906552 「一只叫煤球的猫」欢迎转载，保留摘要，谢谢！

• 前言
• 正文
  • 实现更多的接口
  • 重写 equals 和 hashcode 方法
  • 增加配置项和参数
  • 增加监听回调
  • 构建通用工具类
  • 添加新的异常类型
  • 实现更多设计模式
  • 扩展注释和文档
• 结语

---

🙂🙂🙂关注微信公众号：【芋道源码】有福利：

1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
4. 新的源码解析文章实时收到通知。每周更新一篇左右。
5. 认真的源码交流微信群。

---

如果按代码量算工资，也许应该这样写！

前言

假如有一天我们要按代码量来算工资，那怎样才能写出一手漂亮的代码，同时兼顾代码行数和实际意义呢？

要在增加代码量的同时提高代码质量和可维护性，能否做到呢？

答案当然是可以，这可难不倒我们这种摸鱼高手。

耐心看完，你一定有所收获。

正文

实现更多的接口

给每一个方法都实现各种“无关痛痒”的接口，比如Serializable、Cloneable等，真正做到不影响使用的同时增加了相当数量的代码。

为了这些代码量，其中带来的性能损耗当然是可以忽略的。

public class ExampleClass implements Serializable, Comparable<ExampleClass>, Cloneable, AutoCloseable {

    @Override
    public int compareTo(ExampleClass other) {
        // 比较逻辑
        return 0;
    }

    // 实现 Serializable 接口的方法
    private void writeObject(ObjectOutputStream out) throws IOException {
        // 序列化逻辑
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // 反序列化逻辑
    }

    // 实现 Cloneable 接口的方法
    @Override
    public ExampleClass clone() throws CloneNotSupportedException {
        // 复制对象逻辑
        return (ExampleClass) super.clone();
    }

    // 实现 AutoCloseable 接口的方法
    @Override
    public void close() throws Exception {
        // 关闭资源逻辑
    }

}

除了示例中的Serializable、 Comparable、 Cloneable、 AutoCloseable，还有Iterable

重写 equals 和 hashcode 方法

重写 equals 和 hashCode 方法绝对是上上策，不仅增加了代码量，还为了让对象在相等性判断和散列存储时能更完美的工作，确保代码在处理对象相等性时更准确、更符合业务逻辑。

public class ExampleClass {
    private String name;
    private int age;

    // 重写 equals 方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }

        ExampleClass other = (ExampleClass) obj;
        return this.age == other.age && Objects.equals(this.name, other.name);
    }
    
    // 重写 hashCode 方法
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

增加配置项和参数

不要管能不能用上，梭哈就完了，问就是为了健壮性和拓展性。

public class AppConfig {
    private int maxConnections;
    private String serverUrl;
    private boolean enableFeatureX;

    // 新增配置项
    private String emailTemplate;
    private int maxRetries;
    private boolean enableFeatureY;

    // 写上构造函数和getter/setter
}

增加监听回调

给业务代码增加监听回调，比如执行前、执行中、执行后等各种Event，这里举个完整的例子。

比如创建个 EventListener ，负责监听特定类型的事件，事件源则是产生事件的对象。通过EventListener 在代码中增加执行前、执行中和执行后的事件。

首先，我们定义一个简单的事件类 Event：

public class Event {
    private String name;

    public Event(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

然后，我们定义一个监听器接口 EventListener：

public interface EventListener {
    void onEventStart(Event event);

    void onEventInProgress(Event event);

    void onEventEnd(Event event);
}

接下来，我们定义一个事件源类 EventSource，在执行某个业务方法时，触发事件通知：

public class EventSource {
    private List<EventListener> listeners = new ArrayList<>();

    public void addEventListener(EventListener listener) {
        listeners.add(listener);
    }

    public void removeEventListener(EventListener listener) {
        listeners.remove(listener);
    }

    public void businessMethod() {
        Event event = new Event("BusinessEvent");

        // 通知监听器：执行前事件
        for (EventListener listener : listeners) {
            listener.onEventStart(event);
        }

        // 模拟执行业务逻辑
        System.out.println("Executing business method...");

        // 通知监听器：执行中事件
        for (EventListener listener : listeners) {
            listener.onEventInProgress(event);
        }

        // 模拟执行业务逻辑
        System.out.println("Continuing business method...");

        // 通知监听器：执行后事件
        for (EventListener listener : listeners) {
            listener.onEventEnd(event);
        }
    }
}

现在，我们可以实现具体的监听器类，比如 BusinessEventListener，并在其中定义事件处理逻辑：

public class BusinessEventListener implements EventListener {
    @Override
    public void onEventStart(Event event) {
        System.out.println("Event Start: " + event.getName());
    }

    @Override
    public void onEventInProgress(Event event) {
        System.out.println("Event In Progress: " + event.getName());
    }

    @Override
    public void onEventEnd(Event event) {
        System.out.println("Event End: " + event.getName());
    }
}

最后，我们写个main函数来演示监听事件：

public class Main {
    public static void main(String[] args) {
        EventSource eventSource = new EventSource();
        eventSource.addEventListener(new BusinessEventListener());

        // 执行业务代码，并触发事件通知
        eventSource.businessMethod();

        // 移除监听器
        eventSource.removeEventListener(businessEventListener);
    }
}

如此这般那般，代码量猛增，还顺带实现了业务代码的流程监听。当然这只是最简陋的实现，真实环境肯定要比这个复杂的多。

构建通用工具类

同样的，甭管用不用的上，定义更多的方法，都是为了健壮性。

比如下面这个StringUtils，可以从ApacheCommons、SpringBoot的StringUtil或HuTool的StrUtil中拷贝更多的代码过来，美其名曰内部工具类。

public class StringUtils {
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    public static boolean isBlank(String str) {
        return str == null || str.trim().isEmpty();
    }

    // 新增方法：将字符串反转
    public static String reverse(String str) {
        if (str == null) {
            return null;
        }
        return new StringBuilder(str).reverse().toString();
    }

    // 新增方法：判断字符串是否为整数
    public static boolean isInteger(String str) {
        try {
            Integer.parseInt(str);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }
}

添加新的异常类型

添加更多异常类型，对不同的业务抛出不同的异常，每种异常都要单独去处理

public class CustomException extends RuntimeException {
    // 构造函数
    public CustomException(String message) {
        super(message);
    }

    // 新增异常类型
    public static class NotFoundException extends CustomException {
        public NotFoundException(String message) {
            super(message);
        }
    }

    public static class ValidationException extends CustomException {
        public ValidationException(String message) {
            super(message);
        }
    }
}
// 示例：添加不同类型的异常处理
public class ExceptionHandling {
    public void process(int value) {
        try {
            if (value < 0) {
                throw new IllegalArgumentException("Value cannot be negative");
            } else if (value == 0) {
                throw new ArithmeticException("Value cannot be zero");
            } else {
                // 正常处理逻辑
            }
        } catch (IllegalArgumentException e) {
            // 异常处理逻辑
        } catch (ArithmeticException e) {
            // 异常处理逻辑
        }
    }
}

实现更多设计模式

在项目中运用更多设计模式，也不失为一种合理的方式，比如单例模式、工厂模式、策略模式、适配器模式等各种常用的设计模式。

比如下面这个单例，大大节省了内存空间，虽然它存在线程不安全等问题。

public class SingletonPattern {
    // 单例模式
    private static SingletonPattern instance;

    private SingletonPattern() {
        // 私有构造函数
    }

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

}

还有下面这个策略模式，能避免过多的if-else条件判断，降低代码的耦合性，代码的扩展和维护也变得更加容易。

// 策略接口
interface Strategy {
    void doOperation(int num1, int num2);
}

// 具体策略实现类
class AdditionStrategy implements Strategy {
    @Override
    public void doOperation(int num1, int num2) {
        int result = num1 + num2;
        System.out.println("Addition result: " + result);
    }
}

class SubtractionStrategy implements Strategy {
    @Override
    public void doOperation(int num1, int num2) {
        int result = num1 - num2;
        System.out.println("Subtraction result: " + result);
    }
}

// 上下文类
class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy(int num1, int num2) {
        strategy.doOperation(num1, num2);
    }
}

// 测试类
public class StrategyPattern {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 5;

        // 使用加法策略
        Context context = new Context(new AdditionStrategy());
        context.executeStrategy(num1, num2);

        // 使用减法策略
        context = new Context(new SubtractionStrategy());
        context.executeStrategy(num1, num2);
    }
}

对比下面这段条件判断，高下立判。

public class Calculator {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 5;
        String operation = "addition"; // 可以根据业务需求动态设置运算方式

        if (operation.equals("addition")) {
            int result = num1 + num2;
            System.out.println("Addition result: " + result);
        } else if (operation.equals("subtraction")) {
            int result = num1 - num2;
            System.out.println("Subtraction result: " + result);
        } else if (operation.equals("multiplication")) {
            int result = num1 * num2;
            System.out.println("Multiplication result: " + result);
        } else if (operation.equals("division")) {
            int result = num1 / num2;
            System.out.println("Division result: " + result);
        } else {
            System.out.println("Invalid operation");
        }
    }
}

扩展注释和文档

如果要增加代码量，写更多更全面的注释也不失为一种方式。

/**
 * 这是一个示例类，用于展示增加代码数量的技巧和示例。
 * 该类包含一个示例变量 value 和示例构造函数 ExampleClass(int value)。
 * 通过示例方法 getValue() 和 setValue(int newValue)，可以获取和设置 value 的值。
 * 这些方法用于展示如何增加代码数量，但实际上并未实现实际的业务逻辑。
 */
public class ExampleClass {

    // 示例变量
    private int value;

    /**
     * 构造函数
     */
    public ExampleClass(int value) {
        this.value = value;
    }

    /**
     * 获取示例变量 value 的值。
     * @return 示范变量 value 的值
     */
    public int getValue() {
        return value;
    }

    /**
     * 设置示例变量 value 的值。
     * @param newValue 新的值，用于设置 value 的值。
     */
    public void setValue(int newValue) {
        this.value = newValue;
    }
}

结语

哪怕是以代码量算工资，咱也得写出高质量的代码，合理合法合情的赚票子。