Spring Java Format

https://github.com/spring-io/spring-javaformat
Admin
Spring Java Format provides a set of plugins and tools to format Java source code and enforce...
Tokens:88,763
Snippets:713
Trust Score:9.2
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Basic SpringApplication.run() example

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Shows the typical usage of SpringApplication.run() from a main method with @Configuration and @EnableAutoConfiguration. The example includes a main method that calls SpringApplication.run(MyApplication.class, args).

```java
@Configuration
@EnableAutoConfiguration
public class MyApplication  {

// ... Bean definitions

public static void main(String[] args) throws Exception {
  SpringApplication.run(MyApplication.class, args);
}

```

--------------------------------

### Advanced SpringApplication customization example

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Shows how to create a SpringApplication instance and customize it before running. The example creates a new SpringApplication(MyApplication.class) and calls app.run(args).

```java
public static void main(String[] args) throws Exception {
  SpringApplication app = new SpringApplication(MyApplication.class);
  // ... customize app settings here
  app.run(args)
}

```

--------------------------------

### Usage Overview

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/gradle-tasks.md

Examples of how to run and configure the formatter tasks from Gradle.

```APIDOC
## Usage Overview

### Running Tasks
```groovy
// Per-source-set tasks: mainFormat, testFormat, mainCheckFormat, testCheckFormat
./gradlew format
./gradlew checkFormat
./gradlew check          # depends on checkFormat (all source sets)
```

### Configuring from Gradle
```groovy
tasks.named('checkFormat') {
    encoding = 'UTF-8'
}

tasks.withType(io.spring.javaformat.gradle.tasks.Format) {
    indentationStyle.set(io.spring.javaformat.config.IndentationStyle.SPACES)
}
```

### Failure Modes
| Failure | Raised as | Condition |
|---------|-----------|-----------|
| Format failure | `GradleException` | Any `FileFormatterException` during `format`. |
| Violations | `VerificationException` | `checkFormat` found files with edits; message also written to `reportLocation`. |
```

--------------------------------

### Usage examples for format and checkFormat tasks

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/gradle-tasks.md

Shows how to run the format and checkFormat tasks from the command line, and how to configure them from Gradle. The check task depends on checkFormat for all source sets. The configuration examples set encoding to UTF-8 and indentation style to SPACES.

```groovy
// Per-source-set tasks: mainFormat, testFormat, mainCheckFormat, testCheckFormat
./gradlew format
./gradlew checkFormat
./gradlew check          # depends on checkFormat (all source sets)

// Configure from Gradle
tasks.named('checkFormat') {
	encoding = 'UTF-8'
}

tasks.withType(io.spring.javaformat.gradle.tasks.Format) {
	indentationStyle.set(io.spring.javaformat.config.IndentationStyle.SPACES)
}
```

--------------------------------

### FileFormatter usage example

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-FileFormatter.md

Demonstrates how to instantiate FileFormatter, format a file, and save the edits if any.

```java
import io.spring.javaformat.formatter.FileFormatter;
import io.spring.javaformat.formatter.FileEdit;
import java.io.File;
import java.nio.charset.StandardCharsets;

FileFormatter formatter = new FileFormatter();
File file = new File("src/main/java/Example.java");
FileEdit edit = formatter.formatFile(file, StandardCharsets.UTF_8);
if (edit.hasEdits()) {
	edit.save();
}
```

--------------------------------

### setLogStartupInfo(boolean logStartupInfo)

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Sets if the application information should be logged when the application starts. Defaults to true.

```APIDOC
## setLogStartupInfo(boolean logStartupInfo)

### Description
Sets if the application information should be logged when the application starts. Defaults to true.

### Method
setLogStartupInfo

### Parameters
- **logStartupInfo** (boolean) - Required - If startup info should be logged.

### Return
void
```

--------------------------------

### FileEdit usage example with exception handling

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-FileFormatter.md

Demonstrates formatting and saving a file while catching FileFormatterException to report failures.

```java
import io.spring.javaformat.formatter.FileFormatter;
import io.spring.javaformat.formatter.FileFormatterException;
import java.io.File;
import java.nio.charset.StandardCharsets;

try {
	new FileFormatter().formatFile(new File("Example.java"), StandardCharsets.UTF_8).save();
}
catch (FileFormatterException ex) {
	System.err.println("Failed for " + ex.getFile() + " caused by " + ex.getCause());
}
```

--------------------------------

### Configure Checkstyle with SpringChecks

Source: https://github.com/spring-io/spring-javaformat/blob/main/README.adoc

An example XML configuration for Checkstyle using the SpringChecks module, including an example of how to exclude specific checks.

```xml
<?xml version="1.0"?>
<!DOCTYPE module PUBLIC
		"-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
		"https://checkstyle.org/dtds/configuration_1_3.dtd">
<module name="com.puppycrawl.tools.checkstyle.Checker">
	<module name="io.spring.javaformat.checkstyle.SpringChecks">
		<property name="excludes" value="io.spring.javaformat.checkstyle.check.SpringAvoidStaticImportCheck" />
	</module>
</module>
```

--------------------------------

### Get or Create Environment

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/expected/complex.txt

Returns the existing environment or creates a new StandardServletEnvironment or StandardEnvironment based on the web environment flag.

```java
	private ConfigurableEnvironment getOrCreateEnvironment() {
		if (this.environment != null) {
			return this.environment;
		}
		if (this.webEnvironment) {
			return new StandardServletEnvironment();
		}
		return new StandardEnvironment();
	}
```

--------------------------------

### Consistent Field and Constructor Ordering

Source: https://github.com/spring-io/spring-javaformat/blob/main/README.adoc

An example of maintaining consistent ordering for fields and constructor parameters to improve readability.

```java
public class Name {

	private final String first;

	private final String last;

	public Name(String first, String last) {
		this.first = first;
		this.last = last;
	}

}
```

--------------------------------

### StreamsFormatter usage example

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-StreamsFormatter.md

Demonstrates creating a StreamsFormatter with a JavaFormatConfig and formatting a StringReader with a custom line separator.

```java
import io.spring.javaformat.config.JavaFormatConfig;
import io.spring.javaformat.formatter.StreamsFormatter;
import java.io.StringReader;

JavaFormatConfig config = JavaFormatConfig.findFrom(new java.io.File("."));
StreamsFormatter formatter = new StreamsFormatter(config);
formatter.format(new StringReader("class A { void m( ){} }"), "\n").writeTo(new StringBuilder() {
	// Appendable target
});
```

--------------------------------

### Monitors usage example

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/intellij-monitoring.md

Shows how to instantiate Monitors with a state update callback and register FileMonitor, MavenMonitor, and GradleMonitor factories. The stop() method is called to release resources. Trigger may be called from any thread; updateState is thread-safe and Monitors synchronizes state updates.

```java
import io.spring.format.formatter.intellij.monitor.*;
import io.spring.format.formatter.intellij.state.State;

Monitors monitors = new Monitors(project,
	(state) -> { state.put(project); /* update UI */ },
	FileMonitor.factory(), MavenMonitor.factory(), GradleMonitor.factory());
// ...
monitors.stop();
```

--------------------------------

### Java multi-line statement indentation example

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/multi-line-statement-indentation.txt

Example Java class demonstrating multi-line statement indentation. The method reads a file and applies chained replacements, showing the indentation style for continued expressions.

```java
package simple;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;

public class Simple {

	public String someMethod() throws MalformedURLException, IOException {
		String settingsXml = new String(Files.readAllBytes(Paths.get("src", "intTest", "projects", "settings.xml")),
				StandardCharsets.UTF_8)
						.replace("@localCentralUrl@",
								new File("build/int-test-maven-repository").toURI().toURL().toString())
						.replace("@localRepositoryPath@", new File("build/local-maven-repository").getAbsolutePath());
		return settingsXml;
	}

}
```

--------------------------------

### StreamsFormatter usage example

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-StreamsFormatter.md

Usage example for StreamsFormatter: creates a StreamsFormatter, formats an InputStream with UTF-8 encoding, and writes the formatted content to System.out.

```java
import io.spring.javaformat.formatter.StreamsFormatter;
import java.io.InputStream;
import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;

InputStream source = new ByteArrayInputStream("public class X{}".getBytes(StandardCharsets.UTF_8));
StreamsFormatter formatter = new StreamsFormatter();
formatter.format(source, StandardCharsets.UTF_8).writeTo(System.out);
```

--------------------------------

### StreamsFormatter error handling example

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-StreamsFormatter.md

Shows how to handle a RuntimeException thrown by format when the reader throws an IOException.

```java
import io.spring.javaformat.formatter.StreamsFormatter;
import java.io.Reader;

Reader broken = new Reader() {
	@Override public int read(char[] cbuf, int off, int len) throws java.io.IOException {
		throw new java.io.IOException("boom");
	}
	@Override public void close() {}
};
try {
	new StreamsFormatter().format(broken);
}
catch (RuntimeException ex) {
	// cause is the original IOException
}
```

--------------------------------

### State enum with put and get methods

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/intellij-monitoring.md

Defines the plugin state with ACTIVE and NOT_ACTIVE constants. The put method stores the state in the project's user data under a private Key<State>, while get returns the stored state or NOT_ACTIVE for null/unset.

```java
public enum State {
	ACTIVE,
	NOT_ACTIVE;
	public void put(Project project);
	public static State get(Project project);
}
```

--------------------------------

### Example: @SpringBootTest with properties and classes

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/annotation-attributes.txt

Shows a nested test class using @SpringBootTest with properties to set the web application type to reactive and specify configuration classes.

```java
class MyTest {

	@SpringBootTest(properties = "spring.main.web-application-type=reactive", classes = { WebTestClientSpringBootTestIntegrationTests.TestConfiguration.class, ExampleWebFluxApplication.class })
	static class One {}

	@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, properties = { "spring.jersey.type=filter", "server.servlet.context-path=/app", "server.servlet.register-default-servlet=true" })
	static class Two {}

}
```

--------------------------------

### Handling FileFormatterException

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-FileFormatterException.md

Example of catching a FileFormatterException when calling formatFile, allowing access to the problematic file and the underlying cause.

```java
import io.spring.javaformat.formatter.FileFormatter;
import io.spring.javaformat.formatter.FileFormatterException;
import java.io.File;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

try {
	new FileFormatter().formatFile(new File("missing/File.java"), Charset.forName("NONEXISTENT"));
}
catch (FileFormatterException ex) {
	System.err.println("File: " + ex.getFile());
	System.err.println("Cause: " + ex.getCause()); // e.g. UnsupportedCharsetException / NoSuchFileException
}
```

--------------------------------

### Getting Spring Factory Instances

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Helper methods to load and instantiate classes defined in Spring factories, ensuring they are sorted by order.

```java
	private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type) {
		return getSpringFactoriesInstances(type, new Class<?>[] {});
	}

	private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type,
			Class<?>[] parameterTypes, Object... args) {
		ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
		// Use names and ensure unique to protect against duplicates
		Set<String> names = new LinkedHashSet<String>(
				SpringFactoriesLoader.loadFactoryNames(type, classLoader));
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
				classLoader, args, names);
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}
```

--------------------------------

### Build the project from source

Source: https://github.com/spring-io/spring-javaformat/blob/main/CONTRIBUTING.adoc

Use the standard Maven command from the root directory to build the project. You may need to set MAVEN_OPTS to -Xmx512m if memory issues occur.

```bash
	$ ./mvnw clean install
```

--------------------------------

### logStartupInfo(boolean)

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Called to log startup information. Subclasses may override to add additional logging.

```APIDOC
## logStartupInfo(boolean)

### Description
Called to log startup information. Subclasses may override to add additional logging.

### Method
protected void logStartupInfo(boolean isRoot)

### Parameters
- **isRoot** (boolean) - Required - true if this application is the root of a context hierarchy
```

--------------------------------

### Bootstrap application with manual configuration

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/expected/complex.txt

For advanced scenarios, create a SpringApplication instance to customize settings before running the application.

```java
public static void main(String[] args) throws Exception {
  SpringApplication app = new SpringApplication(MyApplication.class);
  // ... customize app settings here
  app.run(args)
}
```

--------------------------------

### Get Run Listeners

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/expected/complex.txt

Retrieves the configured SpringApplicationRunListeners for the application.

```java
	private SpringApplicationRunListeners getRunListeners(String[] args) {
		Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
		return new SpringApplicationRunListeners(logger,
				getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
	}
```

--------------------------------

### Prepare Environment

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Configures the application environment, including web environment conversion if necessary.

```java
	private ConfigurableEnvironment prepareEnvironment(
			SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// Create and configure the environment
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		listeners.environmentPrepared(environment);
		if (isWebEnvironment(environment) && !this.webEnvironment) {
			environment = convertToStandardEnvironment(environment);
		}
		return environment;
	}
```

--------------------------------

### Get ResourceLoader

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Returns the ResourceLoader that will be used in the ApplicationContext, or null if the default.

```java
	/**
	 * The ResourceLoader that will be used in the ApplicationContext.
	 * @return the resourceLoader the resource loader that will be used in the
	 * ApplicationContext (or null if the default)
	 */
	public ResourceLoader getResourceLoader() {
		return this.resourceLoader;
	}
```

--------------------------------

### Startup Failure Handling

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/expected/complex.txt

Logic for handling application startup failures, reporting errors, and closing the context.

```java
	private void handleRunFailure(ConfigurableApplicationContext context, SpringApplicationRunListeners listeners,
			FailureAnalyzers analyzers, Throwable exception) {
		try {
			try {
				handleExitCode(context, exception);
				listeners.finished(context, exception);
			}
			finally {
				reportFailure(analyzers, exception);
				if (context != null) {
					context.close();
				}
			}
		}
		catch (Exception ex) {
			logger.warn("Unable to close ApplicationContext", ex);
		}
		ReflectionUtils.rethrowRuntimeException(exception);
	}

	private void reportFailure(FailureAnalyzers analyzers, Throwable failure) {
		try {
			if (analyzers != null && analyzers.analyzeAndReport(failure)) {
				registerLoggedException(failure);
				return;
			}
		}
		catch (Throwable ex) {
			// Continue with normal handling of the original failure
		}
		if (logger.isErrorEnabled()) {
			logger.error("Application startup failed", failure);
			registerLoggedException(failure);
		}
	}

	/**
	 * Register that the given exception has been logged. By default, if the running in
	 * the main thread, this method will suppress additional printing of the stacktrace.
	 * @param exception the exception that was logged
	 */
	protected void registerLoggedException(Throwable exception) {
		SpringBootExceptionHandler handler = getSpringBootExceptionHandler();
		if (handler != null) {
			handler.registerLoggedException(exception);
		}
	}
```

--------------------------------

### SpringApplication Initialization Logic

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Internal initialization method to set up sources, web environment, initializers, and listeners.

```java
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private void initialize(Object[] sources) {
		if (sources != null && sources.length > 0) {
			this.sources.addAll(Arrays.asList(sources));
		}
		this.webEnvironment = deduceWebEnvironment();
		setInitializers((Collection) getSpringFactoriesInstances(
				ApplicationContextInitializer.class));
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}
```

--------------------------------

### Main method for SpringApplication

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/expected/complex.txt

A basic main method implementation that launches an application using command line arguments.

```java
public static void main(String[] args) throws Exception {
		SpringApplication.run(new Object[0], args);
	}
```

--------------------------------

### logStartupProfileInfo(ConfigurableApplicationContext)

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Called to log active profile information. Logs active profiles or falls back to default profiles if none are active.

```APIDOC
## logStartupProfileInfo(ConfigurableApplicationContext)

### Description
Called to log active profile information. Logs active profiles or falls back to default profiles if none are active.

### Method
protected void logStartupProfileInfo(ConfigurableApplicationContext context)

### Parameters
- **context** (ConfigurableApplicationContext) - Required - The application context
```

--------------------------------

### Log startup information

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Logs startup information using StartupInfoLogger if this application is the root of a context hierarchy. Subclasses may override to add additional logging.

```java
	/**
	 * Called to log startup information, subclasses may override to add additional
	 * logging.
	 * @param isRoot true if this application is the root of a context hierarchy
	 */
	protected void logStartupInfo(boolean isRoot) {
		if (isRoot) {
			new StartupInfoLogger(this.mainApplicationClass)
					.logStarting(getApplicationLog());
		}
	}
```

--------------------------------

### Basic plugin application in build.gradle

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/gradle-plugin.md

Standard way to apply the plugin in a Gradle build file.

```groovy
plugins {
	id "io.spring.javaformat" version "0.0.48"
}

// format and checkFormat tasks exist; checkFormat runs as part of `check`
```

--------------------------------

### Checkstyle Violation Message Catalog

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/checkstyle-header-javadoc.md

Example entries from the messages.properties file defining violation messages for header and Javadoc checks.

```properties
header.mismatch=Line does not match expected header line of ''{0}''.
header.blankLine=Blank line expected after header.
javadoc.badCase=Javadoc element descriptions should not start with an uppercase letter.
javadoc.earlierSince=Javadoc @since version ''{0}'' is earlier than @since version ''{1}'' at {2}:{3}.
deprecated.missingSince=@Deprecated has no since attribute.
```

--------------------------------

### SpringApplication Run Method

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Main entry point to run the application, creating and refreshing the ApplicationContext.

```java
	public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		FailureAnalyzers analyzers = null;
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			analyzers = new FailureAnalyzers(context);
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			listeners.finished(context, null);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass)
						.logStarted(getApplicationLog(), stopWatch);
			}
			return context;
		}
		catch (Throwable ex) {
			handleRunFailure(context, listeners, analyzers, ex);
			throw new IllegalStateException(ex);
		}
	}
```

--------------------------------

### Get Spring Factories Instances

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/expected/complex.txt

Helper methods to load and instantiate factory classes defined in Spring factories files.

```java
	private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type) {
		return getSpringFactoriesInstances(type, new Class<?>[] {});
	}

	private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
			Object... args) {
		ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
		// Use names and ensure unique to protect against duplicates
		Set<String> names = new LinkedHashSet<String>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}
```

--------------------------------

### run(Object[] sources, String[] args)

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Static helper that can be used to run a SpringApplication from the specified sources using default settings and user supplied arguments.

```APIDOC
## run(Object[] sources, String[] args)

### Description
Static helper that can be used to run a SpringApplication from the specified sources using default settings and user supplied arguments.

### Method
run

### Parameters
- **sources** (Object[]) - Required - The sources to load.
- **args** (String[]) - Required - The application arguments (usually passed from a Java main method).

### Return
ConfigurableApplicationContext - The running ApplicationContext.
```

--------------------------------

### Apply Eclipse settings

Source: https://github.com/spring-io/spring-javaformat/blob/main/CONTRIBUTING.adoc

Run this command after importing the project into an Eclipse-based distribution to apply the necessary settings.

```bash
	$ ./mvnw -Peclipse validate
```

--------------------------------

### Invalid equalsTest value example

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/checkstyle-expressions-structure.md

Shows an invalid configuration for SpringTernaryCheck with equalsTest set to 'sometimes', which triggers IllegalArgumentException during checkstyle init.

```xml
<!-- Invalid equalsTest value → IllegalArgumentException during checkstyle init -->
<module name="io.spring.javaformat.checkstyle.check.SpringTernaryCheck">
	<property name="equalsTest" value="sometimes" />
</module>
```

--------------------------------

### Get BeanDefinitionRegistry

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Returns the BeanDefinitionRegistry from the context if it implements that interface, otherwise from an AbstractApplicationContext's bean factory. Throws IllegalStateException if not determinable.

```java
	/**
	 * Get the bean definition registry.
	 * @param context the application context
	 * @return the BeanDefinitionRegistry if it can be determined
	 */
	private BeanDefinitionRegistry getBeanDefinitionRegistry(ApplicationContext context) {
		if (context instanceof BeanDefinitionRegistry) {
			return (BeanDefinitionRegistry) context;
		}
		if (context instanceof AbstractApplicationContext) {
			return (BeanDefinitionRegistry) ((AbstractApplicationContext) context)
					.getBeanFactory();
		}
		throw new IllegalStateException("Could not locate BeanDefinitionRegistry");
	}
```

--------------------------------

### Startup Class Definition

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/eclipse-plugin-core.md

The Startup class implements IStartup to initialize the plugin and attach listeners during Eclipse startup.

```java
public class Startup implements IStartup {
	@Override public void earlyStartup();
}
```

--------------------------------

### main method to launch SpringApplication

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Provides a basic main method that can be used to launch an application, especially when application sources are defined via a --spring.main.sources command line argument. Most developers will want to define their own main method that calls the run method instead.

```java
	/**
	 * A basic main that can be used to launch an application. This method is useful when
	 * application sources are defined via a {@literal --spring.main.sources} command line
	 * argument.
	 * <p>
	 * Most developers will want to define their own main method can call the
	 * {@link #run(Object, String...) run} method instead.
	 * @param args command line arguments
	 * @throws Exception if the application cannot be started
	 * @see SpringApplication#run(Object[], String[])
	 * @see SpringApplication#run(Object, String...)
	 */
	public static void main(String[] args) throws Exception {
		SpringApplication.run(new Object[0], args);
	}
```

--------------------------------

### Get application log

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Returns the Log for the application. By default, it is deduced; if mainApplicationClass is null, returns the logger field, otherwise uses LogFactory.getLog.

```java
	/**
	 * Returns the {@link Log} for the application. By default will be deduced.
	 * @return the application log
	 */
	protected Log getApplicationLog() {
		if (this.mainApplicationClass == null) {
			return logger;
		}
		return LogFactory.getLog(this.mainApplicationClass);
	}
```

--------------------------------

### run(Object source, String... args)

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Static helper that can be used to run a SpringApplication from the specified source using default settings.

```APIDOC
## run(Object source, String... args)

### Description
Static helper that can be used to run a SpringApplication from the specified source using default settings.

### Method
run

### Parameters
- **source** (Object) - Required - The source to load.
- **args** (String...) - Required - The application arguments (usually passed from a Java main method).

### Return
ConfigurableApplicationContext - The running ApplicationContext.
```

--------------------------------

### FileEdit class declaration

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-FileFormatter.md

Shows the public API of the FileEdit class, including methods to get the file, save changes, and retrieve formatted content.

```java
public class FileEdit extends Edit {
	public File getFile();
	public void save();
	@Override
	public String getFormattedContent() throws Exception;
}
```

--------------------------------

### Prepare Context

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Performs post-processing on the application context and applies initializers.

```java
	private void prepareContext(ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
		context.setEnvironment(environment);
		postProcessApplicationContext(context);
		applyInitializers(context);
		listeners.contextPrepared(context);
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}
```

--------------------------------

### Get ClassLoader

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Returns the ClassLoader to use: from the resource loader if set, otherwise the context class loader, or the Spring ClassUtils default. Never returns null.

```java
	/**
	 * Either the ClassLoader that will be used in the ApplicationContext (if
	 * {@link #setResourceLoader(ResourceLoader) resourceLoader} is set, or the context
	 * class loader (if not null), or the loader of the Spring {@link ClassUtils} class.
	 * @return a ClassLoader (never null)
	 */
	public ClassLoader getClassLoader() {
		if (this.resourceLoader != null) {
			return this.resourceLoader.getClassLoader();
		}
		return ClassUtils.getDefaultClassLoader();
	}
```

--------------------------------

### Register plugin extensions in plugin.xml

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/intellij-formatting-service.md

Registers the startup activity and formatting service for the IntelliJ IDEA plugin in plugin.xml.

```xml
<extensions defaultExtensionNs="com.intellij">
	<postStartupActivity implementation="io.spring.format.formatter.intellij.startup.SpringJavaFormatStartupActivity" />
	<formattingService implementation="io.spring.format.formatter.intellij.formatting.SpringJavaFormatFormattingService"/>
</extensions>
```

--------------------------------

### VisualStudioCodeFormatter class

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/vscode-extension.md

The Java CLI entry point invoked by the extension. main() calls run(args) and exits with code 1 on any exception. run() resolves JavaFormatConfig from the current working directory, logs to stderr, and formats stdin to stdout using StreamsFormatter.

```java
public final class VisualStudioCodeFormatter {
	private VisualStudioCodeFormatter();
	private void run(String[] args) throws Exception;
	public static void main(String[] args);
}
```

--------------------------------

### Switch statement for include binding errors

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/switch.txt

Example of a switch statement over an enum-like property to determine whether binding errors should be included in the response. The method returns true for ALWAYS, delegates to getErrorsParameter for ON_PARAM, and defaults to false.

```java
public class SwitchExample {
	protected boolean isIncludeBindingErrors(HttpServletRequest request, MediaType produces) {
	switch (getErrorProperties().getIncludeBindingErrors()) {
	case ALWAYS:
	return true;
	case ON_PARAM:
	return getErrorsParameter(request);
	default:
	return false;
	}
	}
}
```

--------------------------------

### getApplicationLog()

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Returns the Log for the application. By default will be deduced.

```APIDOC
## getApplicationLog()

### Description
Returns the Log for the application. By default will be deduced.

### Method
protected Log getApplicationLog()

### Returns
- **Log** - The application log
```

--------------------------------

### Locate Eclipse project settings files with ProjectSettingsFilesLocator

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/eclipse-project-settings.md

Use this snippet to locate project settings files for an Eclipse project. It creates a ProjectSettingsFilesLocator with a project directory and calls locateSettingsFiles() to get the files. The commented line shows how to apply the files to an Eclipse project.

```java
import io.spring.javaformat.eclipse.projectsettings.ProjectSettingsFiles;
import io.spring.javaformat.eclipse.projectsettings.ProjectSettingsFilesLocator;
import java.io.File;

ProjectSettingsFiles files = new ProjectSettingsFilesLocator(new File("/path/to/project")).locateSettingsFiles();
for (var file : files) {
	System.out.println(file.getName());
}
// files.applyToProject(eclipseProject, monitor);
```

--------------------------------

### Configure Environment

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/expected/complex.txt

Template method to configure property sources and profiles for the environment.

```java
	/**
	 * Template method delegating to
	 * {@link #configurePropertySources(ConfigurableEnvironment, String[])} and
	 * {@link #configureProfiles(ConfigurableEnvironment, String[])} in that order.
	 * Override this method for complete control over Environment customization, or one of
	 * the above for fine-grained control over property sources or profiles, respectively.
	 * @param environment this application's environment
	 * @param args arguments passed to the {@code run} method
	 * @see #configureProfiles(ConfigurableEnvironment, String[])
	 * @see #configurePropertySources(ConfigurableEnvironment, String[])
	 */
	protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
		configurePropertySources(environment, args);
		configureProfiles(environment, args);
	}
```

--------------------------------

### Enum with varargs constructor and multiple constants

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/enum-constructor.txt

Example enum with two constants, each passing fourteen string arguments to a private varargs constructor. The second constant is preceded by a Javadoc comment. Useful for testing formatter behavior on enum constructors with long argument lists.

```java
package sample;

public enum ExampleEnum {

	ONE("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen"),

	/**
	 * Two
	 */
	TWO("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen");

	private ExampleEnum(String... args) {

	}

}
```

--------------------------------

### Registering Singleton Beans and Loading Sources

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Registers application arguments and banners as singleton beans, then loads sources into the provided context.

```java
		// Add boot specific singleton beans
		context.getBeanFactory().registerSingleton("springApplicationArguments",
				applicationArguments);
		if (printedBanner != null) {
			context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
		}

		// Load the sources
		Set<Object> sources = getSources();
		Assert.notEmpty(sources, "Sources must not be empty");
		load(context, sources.toArray(new Object[sources.size()]));
		listeners.contextLoaded(context);
	}
```

--------------------------------

### Spring Boot Application Lifecycle Hook Methods

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

These Java methods are part of a Spring Boot application's lifecycle hooks. They are protected methods that subclasses can override to customize property sources, active profiles, banner printing, application context creation, and post-processing of the application context. The code shows typical Spring Boot internals for environment configuration and context setup.

```java
	/**
	 * Add, remove or re-order any {@link PropertySource}s in this application's
	 * environment.
	 * @param environment this application's environment
	 * @param args arguments passed to the {@code run} method
	 * @see #configureEnvironment(ConfigurableEnvironment, String[])
	 */
	protected void configurePropertySources(ConfigurableEnvironment environment,
			String[] args) {
		MutablePropertySources sources = environment.getPropertySources();
		if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {
			sources.addLast(
					new MapPropertySource("defaultProperties", this.defaultProperties));
		}
		if (this.addCommandLineProperties && args.length > 0) {
			String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
			if (sources.contains(name)) {
				PropertySource<?> source = sources.get(name);
				CompositePropertySource composite = new CompositePropertySource(name);
				composite.addPropertySource(new SimpleCommandLinePropertySource(
						name + "-" + args.hashCode(), args));
				composite.addPropertySource(source);
				sources.replace(name, composite);
			}
			else {
				sources.addFirst(new SimpleCommandLinePropertySource(args));
			}
		}
	}
```

```java
	/**
	 * Configure which profiles are active (or active by default) for this application
	 * environment. Additional profiles may be activated during configuration file
	 * processing via the {@code spring.profiles.active} property.
	 * @param environment this application's environment
	 * @param args arguments passed to the {@code run} method
	 * @see #configureEnvironment(ConfigurableEnvironment, String[])
	 * @see org.springframework.boot.context.config.ConfigFileApplicationListener
	 */
	protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {
		environment.getActiveProfiles(); // ensure they are initialized
		// But these ones should go first (last wins in a property key clash)
		Set<String> profiles = new LinkedHashSet<String>(this.additionalProfiles);
		profiles.addAll(Arrays.asList(environment.getActiveProfiles()));
		environment.setActiveProfiles(profiles.toArray(new String[profiles.size()]));
	}
```

```java
	private Banner printBanner(ConfigurableEnvironment environment) {
		if (this.bannerMode == Banner.Mode.OFF) {
			return null;
		}
		ResourceLoader resourceLoader = this.resourceLoader != null ? this.resourceLoader
				: new DefaultResourceLoader(getClassLoader());
		SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(
				resourceLoader, this.banner);
		if (this.bannerMode == Mode.LOG) {
			return bannerPrinter.print(environment, this.mainApplicationClass, logger);
		}
		return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
	}
```

```java
	/**
	 * Strategy method used to create the {@link ApplicationContext}. By default this
	 * method will respect any explicitly set application context or application context
	 * class before falling back to a suitable default.
	 * @return the application context (not yet refreshed)
	 * @see #setApplicationContextClass(Class)
	 */
	protected ConfigurableApplicationContext createApplicationContext() {
		Class<?> contextClass = this.applicationContextClass;
		if (contextClass == null) {
			try {
				contextClass = Class.forName(this.webEnvironment
						? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Unable create a default ApplicationContext, "
								+ "please specify an ApplicationContextClass",
						ex);
			}
		}
		return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
	}
```

```java
	/**
	 * Apply any relevant post processing the {@link ApplicationContext}. Subclasses can
	 * apply additional processing as required.
	 * @param context the application context
	 */
	protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
		if (this.beanNameGenerator != null) {
			context.getBeanFactory().registerSingleton(
					AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
					this.beanNameGenerator);
		}
		if (this.resourceLoader != null) {
			if (context instanceof GenericApplicationContext) {
				((GenericApplicationContext) context)
						.setResourceLoader(this.resourceLoader);
			}
			if (context instanceof DefaultResourceLoader) {
				((DefaultResourceLoader) context)
						.setClassLoader(this.resourceLoader.getClassLoader());
			}
		}
	}
```

--------------------------------

### exit method to close SpringApplication context and get exit code

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Static helper that exits a SpringApplication and obtains a code indicating success (0) or otherwise. It does not throw exceptions but prints stack traces of any encountered. Applies the specified ExitCodeGenerator in addition to any Spring beans that implement ExitCodeGenerator. In the case of multiple exit codes, the highest value is used (or if all values are negative, the lowest value is used).

```java
	/**
	 * Static helper that can be used to exit a {@link SpringApplication} and obtain a
	 * code indicating success (0) or otherwise. Does not throw exceptions but should
	 * print stack traces of any encountered. Applies the specified
	 * {@link ExitCodeGenerator} in addition to any Spring beans that implement
	 * {@link ExitCodeGenerator}. In the case of multiple exit codes the highest value
	 * will be used (or if all values are negative, the lowest value will be used)
	 * @param context the context to close if possible
	 * @param exitCodeGenerators exist code generators
	 * @return the outcome (0 if successful)
	 */
	public static int exit(ApplicationContext context,
			ExitCodeGenerator... exitCodeGenerators) {
		Assert.notNull(context, "Context must not be null");
		int exitCode = 0;
		try {
			try {
				ExitCodeGenerators generators = new ExitCodeGenerators();
				Collection<ExitCodeGenerator> beans = context
						.getBeansOfType(ExitCodeGenerator.class).values();
				generators.addAll(exitCodeGenerators);
				generators.addAll(beans);
				exitCode = generators.getExitCode();
				if (exitCode != 0) {
					context.publishEvent(new ExitCodeEvent(context, exitCode));
				}
			}
			finally {
				close(context);
			}

		}
		catch (Exception ex) {
			ex.printStackTrace();
			exitCode = (exitCode == 0 ? 1 : exitCode);
		}
		return exitCode;
	}
```

--------------------------------

### Usage: findFrom and of

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/spring-javaformat-config.md

Shows how to obtain a JavaFormatConfig: either by searching for a .springjavaformatconfig file from a given path (falling back to DEFAULT) or by building one explicitly with of(). The resulting config can be passed to a Formatter.

```java
import io.spring.javaformat.config.JavaFormatConfig;
import io.spring.javaformat.config.JavaBaseline;
import io.spring.javaformat.config.IndentationStyle;
import io.spring.javaformat.formatter.Formatter;
import java.nio.file.Path;

// 1. Find project config (falls back to JavaFormatConfig.DEFAULT)
JavaFormatConfig config = JavaFormatConfig.findFrom(Path.of("src/main/java/Example.java"));
Formatter formatter = new Formatter(config);

// 2. Build a config explicitly
JavaFormatConfig spaces = JavaFormatConfig.of(JavaBaseline.V17, IndentationStyle.SPACES);
```

--------------------------------

### format(int kind, String source, int offset, int length, int indentationLevel, String lineSeparator) method signature

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-Formatter.md

Full low-level overload. kind is the Eclipse CodeFormatter format kind bitmask (e.g. 0x08 compilation unit, use DEFAULT_COMPONENTS semantics: compilation unit + include comments). indentationLevel is the starting indentation level. Deprecated in intent: prefer the convenience overloads.

```java
public TextEdit format(int kind, String source, int offset, int length, int indentationLevel, String lineSeparator)
```

--------------------------------

### Managing Application Environment

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Methods to retrieve, configure, and convert the application environment based on the web environment setting.

```java
	private ConfigurableEnvironment getOrCreateEnvironment() {
		if (this.environment != null) {
			return this.environment;
		}
		if (this.webEnvironment) {
			return new StandardServletEnvironment();
		}
		return new StandardEnvironment();
	}

	/**
	 * Template method delegating to
	 * {@link #configurePropertySources(ConfigurableEnvironment, String[])} and
	 * {@link #configureProfiles(ConfigurableEnvironment, String[])} in that order.
	 * Override this method for complete control over Environment customization, or one of
	 * the above for fine-grained control over property sources or profiles, respectively.
	 * @param environment this application's environment
	 * @param args arguments passed to the {@code run} method
	 * @see #configureProfiles(ConfigurableEnvironment, String[])
	 * @see #configurePropertySources(ConfigurableEnvironment, String[])
	 */
	protected void configureEnvironment(ConfigurableEnvironment environment,
			String[] args) {
		configurePropertySources(environment, args);
		configureProfiles(environment, args);
	}

	private boolean isWebEnvironment(ConfigurableEnvironment environment) {
		try {
			Class<?> webEnvironmentClass = ClassUtils
					.forName(CONFIGURABLE_WEB_ENVIRONMENT_CLASS, getClassLoader());
			return (webEnvironmentClass.isInstance(environment));
		}
		catch (Throwable ex) {
			return false;
		}
	}

	private ConfigurableEnvironment convertToStandardEnvironment(
			ConfigurableEnvironment environment) {
		StandardEnvironment result = new StandardEnvironment();
		removeAllPropertySources(result.getPropertySources());
		result.setActiveProfiles(environment.getActiveProfiles());
		for (PropertySource<?> propertySource : environment.getPropertySources()) {
			if (!SERVLET_ENVIRONMENT_SOURCE_NAMES.contains(propertySource.getName())) {
				result.getPropertySources().addLast(propertySource);
			}
		}
		return result;
	}

	private void removeAllPropertySources(MutablePropertySources propertySources) {
		Set<String> names = new HashSet<String>();
		for (PropertySource<?> propertySource : propertySources) {
			names.add(propertySource.getName());
		}
		for (String name : names) {
			propertySources.remove(name);
		}
	}
```

--------------------------------

### applyInitializers(ConfigurableApplicationContext)

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/source/complex.txt

Applies any ApplicationContextInitializers to the context before it is refreshed. This method is protected and intended for subclasses to customize initialization.

```APIDOC
## applyInitializers(ConfigurableApplicationContext)

### Description
Applies any ApplicationContextInitializers to the context before it is refreshed. This method is protected and intended for subclasses to customize initialization.

### Method
protected void applyInitializers(ConfigurableApplicationContext context)

### Parameters
- **context** (ConfigurableApplicationContext) - Required - The configured ApplicationContext (not refreshed yet)

### Notes
- See ConfigurableApplicationContext#refresh() for the refresh lifecycle.
```

--------------------------------

### format(String source, String lineSeparator)

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-Formatter.md

Formats the whole source with a specified line separator. Returns a TextEdit describing the edits.

```APIDOC
## Method: format(String source, String lineSeparator)

### Description
Formats the whole source with a specified line separator. Returns a TextEdit describing the edits.

### Signature
```java
public TextEdit format(String source, String lineSeparator)
```

### Parameters
- **source** (String) - Required - Source content to format.
- **lineSeparator** (String) - Required - Line separator (`"\n"`, `"\r"`, `"\r\n"`); `null` = detect.

### Returns
- **TextEdit** - The edits to apply to the input.

### Example
```java
TextEdit edits = formatter.format(sourceCode, "\n");
```
```

--------------------------------

### Instantiate and configure EclipseJdk17CodeFormatter

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-eclipse-delegates.md

Demonstrates how to manually instantiate the EclipseJdk17CodeFormatter using default configuration, create an indentation string, and set options.

```java
import io.spring.javaformat.config.JavaFormatConfig;
import io.spring.javaformat.formatter.eclipse.EclipseCodeFormatter;
import io.spring.javaformat.formatter.eclipse.Options;
import io.spring.javaformat.formatter.jdk17.eclipse.EclipseJdk17CodeFormatter;

EclipseCodeFormatter formatter = new EclipseJdk17CodeFormatter(JavaFormatConfig.DEFAULT);
String indent = formatter.createIndentationString(2); // "\t\t"
formatter.setOptions(Map.of()); // re-instates Spring formatter.prefs options
```

--------------------------------

### format(String source)

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-Formatter.md

Formats the whole source with the default line separator (auto-detected). Returns a TextEdit describing the edits.

```APIDOC
## Method: format(String source)

### Description
Formats the whole source with the default line separator (auto-detected). Returns a TextEdit describing the edits.

### Signature
```java
public TextEdit format(String source)
```

### Parameters
- **source** (String) - Required - The source content to format.

### Returns
- **TextEdit** - The edits to apply to the input.

### Example
```java
TextEdit edits = formatter.format(sourceCode);
```
```

--------------------------------

### Options class definition

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/formatter-eclipse-delegates.md

Utility class to load formatter options from the bundled `formatter.prefs` resource. The constructor takes a prefix, and `load(JavaFormatConfig)` reads the resource, prefixes each key, and applies the config, e.g., switching to `space` tab character for `IndentationStyle.SPACES`. Returns an unmodifiable `Map<String,String>` and throws `IllegalStateException` wrapping `IOException`.

```java
public class Options {
	public Options(String prefix);
	public Map<String, String> load(JavaFormatConfig javaFormatConfig);
}
```

--------------------------------

### Bootstrap application using static run method

Source: https://github.com/spring-io/spring-javaformat/blob/main/spring-javaformat/spring-javaformat-formatter-tests/src/test/resources/expected/complex.txt

The static run method is the standard way to bootstrap a Spring application directly from a main method.

```java
@Configuration
@EnableAutoConfiguration
public class MyApplication  {

// ... Bean definitions

public static void main(String[] args) throws Exception {
  SpringApplication.run(MyApplication.class, args);
}
```

--------------------------------

### Checkstyle integration configuration

Source: https://github.com/spring-io/spring-javaformat/blob/main/_autodocs/api-reference/gradle-plugin.md

Configuring the plugin to work with the standard Gradle Checkstyle plugin.

```groovy
plugins {
	id "io.spring.javaformat" version "0.0.48"
	id "checkstyle"
}

checkstyle {
	toolVersion = "9.3"
}

springJavaFormat {
	checkstyle {
		applyDefaultConfig()              // or provide your own checkstyle.xml
	}
}
```

--------------------------------

### Apply Gradle Plugin

Source: https://github.com/spring-io/spring-javaformat/blob/main/README.adoc

Add the io.spring.javaformat plugin to your build.gradle file.

```groovy
plugins {
	id "io.spring.javaformat" version "0.0.48"
}
```

--------------------------------

### Configure Checkstyle with SpringChecks

Source: https://github.com/spring-io/spring-javaformat/blob/main/README.adoc

Create a Checkstyle configuration file using the SpringChecks module to integrate Spring formatting rules into IntelliJ IDEA.

```xml
	<?xml version="1.0"?>
	<!DOCTYPE module PUBLIC
			"-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
			"https://checkstyle.org/dtds/configuration_1_3.dtd">
	<module name="com.puppycrawl.tools.checkstyle.Checker">
		<module name="io.spring.javaformat.checkstyle.SpringChecks" />
	</module>
```
Tokens:
Raw