代码重构：Java经典设计模式下的代码重写示例及优化思路

原创蔚落 2024-11-15 20:42 37阅读 0赞

代码重构是改善软件内部结构的过程，主要目的是提高代码的可读性、可维护性和性能。在Java经典设计模式下进行代码重写，通常会涉及到以下几种模式：

1. **工厂模式**：重构代码以实现面向对象的方式创建对象。例如，从工厂类中获取实例。

```java
// 旧代码
Product product = ProductFactory.create(ProductType.A);

// 新代码（使用工厂方法）
public static Product createProduct(ProductType type) {
    switch (type) {
        case A:
            return new ProductA();
        // 其他类型...
        default:
            throw new IllegalArgumentException("Invalid product type: " + type);
    }
}

Product product = ProductFactory.create(ProductType.A);
```

2. **单例模式**：重构代码以确保类只有一个实例，并提供全局访问点。例如，使用双重检查锁定（DCLOK）来实现。

```java
// 旧代码
public class Singleton {
    private static Singleton instance;

private Singleton() {}

public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// 新代码（使用双重检查锁定）
public class SingletonWithDCLOK {
    private static volatile SingletonWithDCLOK instance;

private SingletonWithDCLOK() {}

public static SingletonWithDCLOK getInstance() {
        if (instance == null) {
            synchronized (SingletonWithDCLOK.class) {
                if (instance == null) {
                    instance = new SingletonWithDCLOK();
                }
            }
        }
        return instance;
    }
}
```

3. **观察者模式**：重构代码以创建一个发布/订阅模型，以便对象之间的通信。

```java
// 旧代码（使用回调方式）
public interface EventPublisher {
    void subscribe(EventListener listener);
    void publish(String message);
}

public class Event {
    private String message;

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

// Getters and setters
}

public class EventListener {
    @Override
    public void onEvent(Event event) {
        System.out.println("Received event: " + event.getMessage());
    }
}

// 新代码（使用Java 8的事件发布/订阅模式）
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class EventPublisherWithExecutor {
    private final ExecutorService executor;

public EventPublisherWithExecutor() {
        this.executor = Executors.newFixedThreadPool(10);
    }

// 订阅事件
    public CompletableFuture<Void> subscribe(EventListener listener) {
        return CompletableFuture.runAsync(() -> {
            executor.execute(() -> listener.onEvent(new Event("Test event"))));
        }));
    }

// 发布事件
    public void publish(String message) {
        executor.submit(() -> {
            System.out.println("Publishing event: " + message);
        }));
    }
}
```

优化思路：

1. **复用设计**：避免重复代码，可以使用工厂模式、单例模式等来实现。

2. **模块化编程**：将代码分解为小的可重用模块，这样可以使代码更易于理解和维护。

3. **性能优化**：针对具体场景进行性能分析和优化，例如减少不必要的计算、提高数据结构的效率等。

4. **遵循设计原则**：如DRY（Don't Repeat Yourself）、SOLID（单一职责原则、开放封闭原则等）等，确保代码质量。