面试题：Java抽象类工厂模式与依赖注入的结合及优化

1. 将抽象类的工厂模式与依赖注入相结合的方式

在Java中，我们可以通过在工厂类中使用依赖注入来实现这种结合。例如，假设有一个抽象产品类 Product 和具体产品类 ConcreteProduct，以及一个抽象工厂类 AbstractFactory 和具体工厂类 ConcreteFactory。同时，使用依赖注入框架（如Spring）来管理对象的创建和依赖关系。

// 抽象产品类
abstract class Product {
    public abstract void operation();
}

// 具体产品类
class ConcreteProduct extends Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProduct operation");
    }
}

// 抽象工厂类
abstract class AbstractFactory {
    public abstract Product createProduct();
}

// 具体工厂类
class ConcreteFactory extends AbstractFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct();
    }
}

// 使用依赖注入，这里以Spring框架为例
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
class AppConfig {
    @Bean
    public AbstractFactory abstractFactory() {
        return new ConcreteFactory();
    }
}

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        AbstractFactory factory = context.getBean(AbstractFactory.class);
        Product product = factory.createProduct();
        product.operation();
    }
}

2. 结合带来的优势

解耦依赖关系：通过依赖注入，对象之间的依赖关系由外部容器管理，使得代码更加松耦合。例如在上述代码中，Main 类无需知道 ConcreteFactory 的具体实现，只依赖 AbstractFactory 接口。
提高可维护性和可扩展性：如果需要更换具体的产品或工厂实现，只需在依赖注入配置中修改，而无需在大量使用这些对象的代码中修改。比如，如果要换成另一种 Product 的实现，只需要在 AppConfig 中修改 abstractFactory 方法的返回值。
便于代码复用：工厂模式本身就提供了对象创建的复用，结合依赖注入，使得工厂对象可以被多个地方复用，同时依赖注入容器也可以复用已创建的对象。

3. 潜在问题

配置复杂性：依赖注入框架（如Spring）的配置可能会变得复杂，尤其是在大型项目中，大量的配置文件或注解可能会增加维护成本。例如，如果配置错误，可能导致对象创建失败或依赖关系错误。
性能开销：依赖注入框架在创建对象和管理依赖关系时会有一定的性能开销，特别是在应用启动时，容器需要扫描和创建大量的对象。

4. 性能和可测试性优化措施

性能优化

懒加载：对于不常用的对象，可以使用懒加载的方式，只有在真正需要时才创建对象。在Spring中，可以通过 @Lazy 注解实现。

@Configuration
class AppConfig {
    @Bean
    @Lazy
    public AbstractFactory abstractFactory() {
        return new ConcreteFactory();
    }
}

对象池：对于频繁创建和销毁的对象，可以使用对象池技术。例如，使用 commons-pool2 库来实现对象池。

可测试性优化

使用Mock对象：在测试依赖注入的代码时，使用Mock对象来代替真实的依赖对象，这样可以隔离测试，提高测试的准确性和速度。例如，使用Mockito框架来创建Mock对象。

import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;

public class MainTest {
    @Test
    public void testProductCreation() {
        AbstractFactory mockFactory = mock(AbstractFactory.class);
        Product mockProduct = mock(Product.class);
        when(mockFactory.createProduct()).thenReturn(mockProduct);

        // 这里可以测试依赖于AbstractFactory的代码逻辑
        verify(mockFactory).createProduct();
    }
}

单元测试独立：确保每个单元测试都是独立的，不依赖于外部环境或其他测试。在测试依赖注入的代码时，通过创建独立的测试上下文（如Spring的 ApplicationContext）来进行测试。

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;

@SpringBootTest
public class MainSpringTest {
    @Autowired
    private ApplicationContext context;

    @Test
    public void testContextLoads() {
        // 测试Spring上下文是否正确加载
        assert context != null;
    }
}

星途面试题库

面试题：Java抽象类工厂模式与依赖注入的结合及优化

知识考点

面试题答案

1. 将抽象类的工厂模式与依赖注入相结合的方式

2. 结合带来的优势

3. 潜在问题

4. 性能和可测试性优化措施

性能优化

可测试性优化