Stage 12: Create beans with explicit factory methods

Download spring-products-bean-config.zip · Complete file-by-file guide

CatalogSettings settings = new CatalogSettings("INR", 20);

@Bean
public JsonMapper jsonMapper() {
    return JsonMapper.builder().build();
}

JsonMapper mapper = JsonMapper.builder().build();
ProductFileReader firstReader = new ProductFileReader(mapper);
ProductFileReader secondReader = new ProductFileReader(mapper);

1. Use a standalone file-based example

   This stage builds on Stage 10 so you can focus on bean configuration without starting MongoDB. It runs on 8090 and retains the original getInputStream() and try-with-resources reading method.

2. Separate a class from its managed object

   CatalogSettings is an ordinary class with currency and minimumStock fields. It has no @Component annotation. new CatalogSettings("INR", 20) creates an ordinary Java object. Returning that object from an @Bean method lets Spring register and manage that particular object as a bean.

3. Read the factory methods

   CatalogConfig has @Configuration. Its jsonMapper() method builds and returns a library JsonMapper. Its catalogSettings() method constructs and returns our settings object. A factory method is simply a method whose job is to produce an object. Here @Bean tells Spring to call these methods and register their returned objects. The default bean names are the method names.

4. Inject the results

   ProductFileReader asks for JsonMapper in its constructor instead of building its own mapper. ProductService asks for CatalogSettings and uses minimumStock as the filtering threshold. The controller adds settings to Model so the page can show INR and 20. These are references to the managed objects, not copies of their source classes.

5. Change one setting and observe the rule

   All products shows 30 rows. The policy link selects products whose stock is at least 20, including exactly 20. Change the factory’s minimumStock from 20 to 30, restart and compare the filtered page. A code change takes effect after rebuilding/restarting.

6. Inspect the registry and scope

   Open /bean-info. The page checks bean definitions for jsonMapper, catalogSettings, productFileReader, fileProductRepository, productService and productController. A bean definition is the container’s registration information; a bean is the actual object. The registry keeps these named definitions. Two context lookups of catalogSettings return the same object because its default scope is singleton.

7. Avoid accidental extra objects

   @Configuration(proxyBeanMethods=false) is used here. Calling a factory method directly in ordinary Java would be an ordinary method call. This example obtains the managed objects through constructor injection and context lookup, rather than calling one factory method from another.

Run this stage

Use JDK 21+ and Maven 3.9+. Extract spring-products-bean-config.zip and open a terminal in the spring-products-bean-config folder containing pom.xml. Keep the source files in their supplied paths.

mvn spring-boot:run

Open http://localhost:8090/products. Keep the terminal open. Stop with Ctrl+C. If the port is occupied, change server.port in src/main/resources/application.properties, restart and use the new port in the browser.

# Choose another available port if this port is busy.
server.port=8090

Expected output and checks

Open /products and confirm currency INR and minimum stock 20. Use the policy link. Open /bean-info: all six registrations and singleton checks are true, and the two settings lookups are identical. Stop the app and change the threshold to 30 for the exercise.

Read the changed Java files

The downloadable project includes every file, the 30-product text file, templates, CSS, pom.xml and a standalone README.html with all source files. These are the key changes from the preceding example.

package com.edupoly.products;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import tools.jackson.databind.json.JsonMapper;

@Configuration(proxyBeanMethods = false)
public class CatalogConfig {
    @Bean
    public JsonMapper jsonMapper() {
        return JsonMapper.builder().build();
    }

    @Bean
    public CatalogSettings catalogSettings() {
        return new CatalogSettings("INR", 20);
    }
}

package com.edupoly.products;

public class CatalogSettings {
    private final String currency;
    private final int minimumStock;

    public CatalogSettings(String currency, int minimumStock) {
        this.currency = currency;
        this.minimumStock = minimumStock;
    }

    public String getCurrency() { return currency; }
    public int getMinimumStock() { return minimumStock; }
}

package com.edupoly.products;

import java.io.IOException;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Component;
import tools.jackson.databind.json.JsonMapper;

@Component
public class ProductFileReader {
    private final Product[] products;

    public ProductFileReader(JsonMapper mapper) throws IOException {
        var resource = new ClassPathResource("data/products.txt");
        try (var input = resource.getInputStream()) {
            products = mapper.readValue(input, Product[].class);
        }
        System.out.println("Created ProductFileReader");
    }

    public Product[] getProducts() {
        return products;
    }
}

package com.edupoly.products;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.springframework.stereotype.Service;

@Service
public class ProductService {
    private final ProductRepository repository;
    private final CatalogSettings settings;

    public ProductService(ProductRepository repository, CatalogSettings settings) {
        this.repository = repository;
        this.settings = settings;
    }

    public List<Product> findAll(boolean inStockOnly) {
        List<Product> selected = new ArrayList<>();
        for (Product product : repository.findAll()) {
            if (!inStockOnly || product.getStock() >= settings.getMinimumStock()) {
                selected.add(product);
            }
        }
        return selected;
    }

    public Optional<Product> findById(int id) {
        return repository.findById(id);
    }
}

package com.edupoly.products;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class BeanInfoController {
    private final ConfigurableApplicationContext context;

    public BeanInfoController(ConfigurableApplicationContext context) {
        this.context = context;
    }

    @GetMapping(value = "/bean-info", produces = "text/plain")
    @ResponseBody
    public String beanInfo() {
        StringBuilder text = new StringBuilder();
        for (String name : new String[] {"jsonMapper", "catalogSettings", "productFileReader",
                "fileProductRepository", "productService", "productController"}) {
            text.append(name)
                .append(" | definition registered: ").append(context.containsBeanDefinition(name))
                .append(" | singleton: ").append(context.isSingleton(name)).append("\n");
        }
        text.append("Same settings bean on two lookups: ")
            .append(context.getBean(CatalogSettings.class) == context.getBean(CatalogSettings.class));
        return text.toString();
    }
}

Practice

Change minimumStock from 20 to 30, restart and compare the filtered list. Explain why CatalogSettings is a bean even though its class has no @Component.

References: Spring constructor injection, Spring Data MongoDB repositories.

Follow the factory method in concrete steps

1. Spring reads CatalogConfig. 2. Spring calls its @Bean factory method with the dependencies it needs. 3. The Java statements in that method create or configure the object. 4. The method returns that object to Spring. 5. Spring manages it as a bean and supplies it where requested. CatalogSettings is a separate settings object, not the container. A library mapper can be registered this way without changing the library class to add @Component. Using new inside a factory method does not create a new mapper on every service call; the bean definition has singleton scope by default.