Master Spring’s Core: Resource Management, Environment, Type Conversion, and More

Resource Management

Spring provides its own resource abstraction on top of Java's standard java.net.URL handling. Resources can be accessed via URL.openConnection() for network resources, file:// for local files, or other protocols.

Java Resource Management Demo

<code>public class JavaResourceDemo {
    public static void main(String[] args) throws IOException {
        URL url = new URL("http://www.baidu.com");
        URLConnection urlConnection = url.openConnection();
        InputStream inputStream = urlConnection.getInputStream();
        String content = IoUtil.read(new InputStreamReader(inputStream));
        System.out.println(content);
    }
}
</code>

The above code reads the Baidu homepage using Java's URL API.

Spring Resource Management

Spring abstracts resources with two main interfaces: Resource (read‑only) and WritableResource (read‑write). Common implementations include FileSystemResource , UrlResource , ClassPathResource , and ByteArrayResource .

<code>// Load a URL resource via Spring
Resource resource = new UrlResource("http://www.baidu.com");
InputStream inputStream = resource.getInputStream();
</code>

Environment

The Environment interface abstracts configuration sources. It extends PropertyResolver and provides methods to retrieve properties by key, convert them to target types, and resolve placeholders.

<code>@SpringBootApplication
public class EnvironmentDemo {
    public static void main(String[] args) {
        ConfigurableApplicationContext ctx = SpringApplication.run(EnvironmentDemo.class, args);
        ConfigurableEnvironment env = ctx.getEnvironment();
        String name = env.getProperty("name");
        System.out.println("name = " + name);
    }
}
</code>

Running this prints the value defined in application.yml .

Type Conversion

Spring supports several conversion APIs:

PropertyEditor (JDK API for String→Object conversion)

Converter (generic S→T conversion)

GenericConverter (handles generic collections)

ConversionService (facade that delegates to Converter/GenericConverter)

TypeConverter (combines PropertyEditor and ConversionService)

Example using ConversionService to convert a String to Boolean:

<code>ConversionService cs = DefaultConversionService.getSharedInstance();
Boolean b = cs.convert("true", Boolean.class);
System.out.println("b = " + b);
</code>

Data Binding

Data binding maps configuration values to bean properties, using PropertyValues , BeanWrapper , and DataBinder . The process involves converting source values to target types via TypeConverter before setting them.

<code>User user = new User();
BeanWrapper bw = new BeanWrapperImpl(user);
bw.setPropertyValue(new PropertyValue("username", "三友的java日记"));
System.out.println("username = " + user.getUsername());
</code>

Generic Handling

Spring’s ResolvableType utility enables runtime inspection of generic types. Example: extracting the generic arguments of a custom MyMap class that extends HashMap<Integer, List<String>> .

<code>ResolvableType myMapType = ResolvableType.forClass(MyMap.class);
ResolvableType hashMapType = myMapType.getSuperType();
Class<?> keyClass = hashMapType.getGeneric(0).resolve(); // Integer
Class<?> valueGeneric = hashMapType.getGeneric(1).getGeneric(0).resolve(); // String
</code>

Internationalization (i18n)

Spring wraps Java’s Locale , ResourceBundle , and MessageFormat via MessageSource . Resource bundles are named basename_lang_country.properties . Example:

<code>ResourceBundleMessageSource ms = new ResourceBundleMessageSource();
ms.setDefaultEncoding("UTF-8");
ms.addBasenames("message");
String welcome = ms.getMessage("welcome", new Object[]{"张三"}, Locale.SIMPLIFIED_CHINESE);
System.out.println(welcome);
</code>

BeanFactory

The core IoC container interface. Key sub‑interfaces include ListableBeanFactory , HierarchicalBeanFactory , ConfigurableBeanFactory , and AutowireCapableBeanFactory . Bean definitions are represented by BeanDefinition and loaded via BeanDefinitionReader or ClassPathBeanDefinitionScanner . All definitions are stored in a BeanDefinitionRegistry .

DefaultListableBeanFactory

This concrete class implements BeanFactory and BeanDefinitionRegistry . Example of registering and retrieving a bean:

<code>DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
AnnotatedBeanDefinitionReader reader = new AnnotatedBeanDefinitionReader(bf);
reader.register(BeanFactoryDemo.class);
BeanFactoryDemo demo = bf.getBean(BeanFactoryDemo.class);
System.out.println("beanFactoryDemo = " + demo);
</code>

ApplicationContext

ApplicationContext extends BeanFactory and adds resource loading, Environment access, and event publishing. Implementations delegate to DefaultListableBeanFactory and other helpers. The abstract base AbstractApplicationContext defines the crucial refresh() lifecycle method.

Events

Spring implements the observer pattern via ApplicationEvent , ApplicationListener , and ApplicationEventPublisher . Custom events extend ApplicationEvent ; listeners implement ApplicationListener&lt;YourEvent&gt; . Events propagate from child to parent contexts.

<code>public class FireEvent extends ApplicationEvent {
    public FireEvent(String source) { super(source); }
}

public class Call119FireEventListener implements ApplicationListener<FireEvent> {
    @Override public void onApplicationEvent(FireEvent e) { System.out.println("打119"); }
}

public class SavePersonFireEventListener implements ApplicationListener<FireEvent> {
    @Override public void onApplicationEvent(FireEvent e) { System.out.println("救人"); }
}

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(Call119FireEventListener.class, SavePersonFireEventListener.class);
ctx.refresh();
ctx.publishEvent(new FireEvent("着火了"));
</code>

Spring events also support built‑in events such as ContextRefreshedEvent , ContextStartedEvent , ContextStoppedEvent , and ContextClosedEvent , which are emitted during the application lifecycle.

The article concludes with a recap of the covered core features: resource management, environment, type conversion, data binding, generic handling, internationalization, BeanFactory, ApplicationContext, and events.