diff --git a/docs/CONTRIBUTING.md b/CONTRIBUTING.md similarity index 88% rename from docs/CONTRIBUTING.md rename to CONTRIBUTING.md index 67252ade773..51ed828c29f 100644 --- a/docs/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -3,7 +3,6 @@ Spring Boot is released under the non-restrictive Apache 2.0 license. If you wou to contribute something, or simply want to hack on the code this document should help you get started. - ## Working with the code If you don't have an IDE preference we would recommend that you use [Spring Tools Suite](http://www.springsource.com/developer/sts) or @@ -11,7 +10,6 @@ If you don't have an IDE preference we would recommend that you use [m2eclipe](http://eclipse.org/m2e/) eclipse plugin for maven support. Other IDEs and tools should also work without issue. - ### Building from source To build the source you will need to install [Apache Maven](http://maven.apache.org/run-maven/index.html) v3.0 or above. The project @@ -24,7 +22,6 @@ to submit a pull request: $ mvn clean install -DskipTests - ### Importing into eclipse with m2eclipse We recommend the [m2eclipe](http://eclipse.org/m2e/) eclipse plugin when working with eclipse. If you don't already have m2eclipse installed it is available from the "eclipse @@ -47,7 +44,6 @@ With the requisite eclipse plugins installed you can select `import existing maven projects` from the `file` menu to import the code. You will need to import the root `spring-boot` pom and the `spring-boot-samples` pom separately. - ### Importing into eclipse without m2eclipse If you prefer not to use m2eclipse you can generate eclipse project meta-data using the following command: @@ -60,13 +56,10 @@ from the `file` menu. ### Importing into other IDEs Maven is well supported by most Java IDEs. Refer to you vendor documentation. - ### Integration tests - -The sample application are used as integration tests during the build -(when you `mvn install`). Due to the fact that they make use of the -`spring-package-maven-plugin` they cannot be called directly, and so -instead are launched via the `maven-invoker-plugin`. If you encounter -build failures running the integration tests, check the `build.log` -file in the appropriate sample directory. +The sample application are used as integration tests during the build (when you +`mvn install`). Due to the fact that they make use of the `spring-boot-maven-plugin` +they cannot be called directly, and so instead are launched via the +`maven-invoker-plugin`. If you encounter build failures running the integration tests, +check the `build.log` file in the appropriate sample directory. diff --git a/README.md b/README.md index 08a864e0d1f..820b4f2def6 100644 --- a/README.md +++ b/README.md @@ -1,188 +1,190 @@ # Spring Boot -Spring Boot is "Spring for Snowboarders". If you are kewl, or just impatient, and you -want to use Spring, then this is the place to be. Spring Boot is the code-name for a -group of related technologies, that will get you up and running with -Spring-powered, production-grade applications and services with absolute minimum fuss. -It takes an opinionated view of the Spring family so that new and existing users can -quickly get to the bits they need. Assumes limited knowledge of the Java development -ecosystem. Absolutely no code generation and no XML (unless you really want it). +Spring Boot makes it easy to create Spring-powered, production-grade applications and +services with absolute minimum fuss. It takes an opinionated view of the Spring platform +so that new and existing users can quickly get to the bits they need. -The goals are: +You can use Spring Boot to create stand-alone Java applications that can be started using +`java -jar` or more traditional WAR deployments. We also provide a command line tool +that runs spring scripts. -* Radically faster and widely accessible getting started experience for Spring - development +Our primary goals are: + +* Provide a radically faster and widely accessible getting started experience for all + Spring development * Be opinionated out of the box, but get out of the way quickly as requirements start to diverge from the defaults * Provide a range of non-functional features that are common to large classes of projects (e.g. embedded servers, security, metrics, health checks, externalized configuration) -* First class support for REST-ful services, modern web applications, batch jobs, and - enterprise integration -* Applications that adapt their behavior or configuration to their environment -* Optionally use Groovy features like DSLs and AST transformations to accelerate the - implementation of basic business requirements +* Absolutely no code generation and no requirement for XML configuration +## Quick Start Script Example +The Spring Zero command line tool uses [Groovy](http://groovy.codehaus.org/) underneath +so that we can present simple Spring snippets that can 'just run', for example: -## Installing -You need to [build from source](#building-from-source) for now, but when it's done -instructions will look like this: - -1) Get Java. Download and install the Java SDK from [www.java.com](http://www.java.com) - -2) Get Spring - - $ curl -s initializr.cfapps.io/installer | bash - - or use the [Windows installer](#installing) - - -## Building from source -Spring Zero can be [built with maven](http://maven.apache.org/run-maven/index.html) v3.0 -or above. - - $ mvn clean install - -An `alias` can be used for the Spring Boot command line tool: - - $ alias spring="java -jar ~/.m2/repository/org/springframework/boot/spring-cli/0.5.0.BUILD-SNAPSHOT/spring-cli-0.5.0.BUILD-SNAPSHOT.jar" - -_Also see [docs/CONTRIBUTING](docs/CONTRIBUTING.md) if you want to submit pull requests._ - - -## Quick Start Example -The Spring Zero command line tool uses Groovy underneath so that we can present simple -snippets that can just run, for example: - - $ cat > app.groovy - @Controller - class ThisWillActuallyRun { - @RequestMapping("/") - @ResponseBody - String home() { - return "Hello World!" - } +```groovy +@Controller +class ThisWillActuallyRun { + + @RequestMapping("/") + @ResponseBody + String home() { + return "Hello World!" } - - $ spring run app.groovy - $ curl localhost:8080 - Hello World! + +} +``` +``` +$ spring run app.groovy +$ curl localhost:8080 +Hello World! +``` +_See [below](#installing-the-cli) for command line tool installation instructions._ + +## Quick Start Java Example If you don't want to use the command line tool, or you would rather work using Java and an IDE you can. Just add a `main()` method that calls `SpringApplication` and add `@EnableAutoConfiguration`: - import org.springframework.stereotype.*; - import org.springframework.web.bind.annotation.*; - import org.springframework.boot.context.annotation.*; +```java +import org.springframework.boot.*; +import org.springframework.boot.autoconfiguration.*; +import org.springframework.stereotype.*; +import org.springframework.web.bind.annotation.*; - @Controller - @EnableAutoConfiguration - public class SampleController { - - @RequestMapping("/") - @ResponseBody - String home() { - return "Hello World!" - } - - public static void main(String[] args) throws Exception { - SpringApplication.run(SampleController.class, args); - } +@Controller +@EnableAutoConfiguration +public class SampleController { + @RequestMapping("/") + @ResponseBody + String home() { + return "Hello World!" } -_NOTE: the above example assumes your build system has imported the `spring-starter-web` -maven pom._ + public static void main(String[] args) throws Exception { + SpringApplication.run(SampleController.class, args); + } +} +``` -## Spring Boot Components -There are a number of components in Boot. Here are the important ones: +_NOTE: the above example assumes your build system has imported the `spring-starter-web` maven pom._ -### The Spring CLI -The 'spring' command line application compiles and runs Groovy source, making it super -easy to write the absolute minimum of code to get an application running. Spring CLI -can also watch files, automatically recompiling and restarting when they change. +## Installing the CLI +You need [Java SDK v1.6](http://www.java.com) or higher to run the command line tool. You +should check your current Java installation before you begin: -*See [spring-cli/README](spring-cli/README.md).* + $ java -version + +Complete installation instructions TBD. For now you can +[build from source](#building-from-source). +## Building from source +Spring Boot can be [built with maven](http://maven.apache.org/run-maven/index.html) v3.0 +or above. -### Spring Boot -The main library providing features that support the other parts of Spring Boot. -Features include: + $ mvn clean install -* `SpringApplication` - a class with static convenience methods that make it really easy - to write a standalone Spring Application. Its sole job is to create and refresh an - appropriate Spring `ApplicationContext`. +You can use an `alias` for the Spring Boot command line tool: + + $ alias spring="java -jar ~/.m2/repository/org/springframework/boot/spring-cli/0.5.0.BUILD-SNAPSHOT/spring-cli-0.5.0.BUILD-SNAPSHOT.jar" + +_Also see [CONTRIBUTING.md] if you wish to submit pull requests._ + +## Spring Boot Modules +There are a number of modules in Spring Boot. Here are the important ones: + +### spring-boot +The main library providing features that support the other parts of Spring Boot, +these include: + +* The `SpringApplication` class, providing static convenience methods that make it easy + to write a stand-alone Spring Application. Its sole job is to create and refresh an + appropriate Spring `ApplicationContext` * Embedded web applications with a choice of container (Tomcat or Jetty for now) * First class externalized configuration support +* Convenience `ApplicationContext` initializers, including support for sensible logging + defaults. -_See [spring-boot/README](spring-boot/README.md)._ +_See [spring-boot/README.md](spring-boot/README.md)._ -### Spring Autoconfigure -Spring Zero can configure large parts of common applications based on detecting the -content of the classpath and any existing application context. A single -`@EnableAutoConfigure` annotation triggers auto-configuration of the Spring context. +### spring-boot-autoconfigure +Spring Boot can configure large parts of common applications based on the content +of their classpath. A single `@EnableAutoConfiguration` annotation triggers +auto-configuration of the Spring context. -Auto-configuration attempts to guess what beans a user might want based on their -classpath. For example, If a 'HSQLDB' is on the classpath the user probably wants an -in-memory database to be defined. Auto-configuration will back away as the user starts -to define their own beans. +Auto-configuration attempts to deduce which beans a user might need. For example, If +'HSQLDB' is on the classpath, and the user has not configured any database connections, +then they probably want an in-memory database to be defined. Auto-configuration will +always back away as the user starts to define their own beans. -_See [spring-autoconfigure/README](spring-autoconfigure/README.md)._ +_See [spring-boot-autoconfigure/README.md](spring-boot-autoconfigure/README.md)._ -### Spring Actuator -Spring Actuator uses auto-configuration to decorate your application with features that -make it instantly deployable and supportable in production. For instance if you are -writing a JSON web service then it will provide a server, security, logging, externalized -configuration, management endpoints, an audit abstraction, and more. If you want to -switch off the built in features, or extend or replace them, it makes that really easy as well. - -_See [spring-actuator/README](spring-actuator/README.md)._ - - -### Spring Starters -Spring Starters are a set of convenient dependency descriptors that you can include in +### spring-boot-starters +Starters are a set of convenient dependency descriptors that you can include in your application. You get a one-stop-shop for all the Spring and related technology that you need without having to hunt through sample code and copy paste loads of dependency descriptors. For example, if you want to get started using Spring and JPA for -database access just include one dependency in your project, and you are good to go. +database access just include the `spring-boot-starter-data-jpa` dependency in your +project, and you are good to go. -_See [spring-starters/README](spring-starters/README.md)._ +_See [spring-boot-starters/README.md](spring-boot-starters/README.md)._ -### Packaging -The [spring-launcher](spring-launcher/) and -[spring-maven-packaging-plugin](spring-maven-packaging-plugin) provide a convenient way -to package you application for release. Applications can be released as a single jar -file that can simply be launched using `java -jar`. +### spring-boot-cli +The Spring command line application compiles and runs Groovy source, making it super +easy to write the absolute minimum of code to get an application running. Spring CLI +can also watch files, automatically recompiling and restarting when they change. -_See [spring-launcher/README](spring-launcher/README.md) & -[spring-package-maven-plugin/README](spring-package-maven-plugin/README.md)._ +*See [spring-boot-cli/README.md](spring-boot-cli/README.md).* + + +### spring-boot-ops +Ops uses auto-configuration to decorate your application with features that +make it instantly deployable and supportable in production. For instance if you are +writing a JSON web service then it will provide a server, security, logging, externalized +configuration, management endpoints, an audit abstraction, and more. If you want to +switch off the built in features, or extend or replace them, it makes that really easy as +well. + +_See [spring-boot-ops/README.md](spring-boot-ops/README.md)._ + + +### spring-boot-loader +Loader provides the secret sauce that allows you to build a single jar file that can be +launched using `java -jar`. Generally you will not need to use `spring-boot-loader` +directly but instead work with the +[Gradle](spring-boot-gradle-plugin/README.md) or +[Maven](spring-boot-maven-plugin/README.md) plugin. + +_See [spring-boot-loader/README.md](spring-boot-loader/README.md)._ ## Samples Groovy samples for use with the command line application are available in -[spring-cli/samples](spring-cli/samples/#). To run the CLI samples type +[spring-boot-cli/samples](spring-boot-cli/samples/#). To run the CLI samples type `spring run .groovy` from samples directory. -Java samples are available in [spring-boot-sample](spring-boot-samples/#) and should -be build with maven and run use `java -jar target/.jar`. The following java +Java samples are available in [spring-boot-samples](spring-boot-samples/#) and should +be build with maven and run use `java -jar target/.jar`. The following java samples are provided: -* spring-boot-sample-simple - A simple command line application -* spring-boot-sample-tomcat - Embedded Tomcat -* spring-boot-sample-jetty - Embedded Jetty -* spring-boot-sample-actuator - Simple REST service with production features -* spring-boot-sample-actuator-ui - A web UI example with production features -* spring-boot-sample-web-ui - A thymeleaf web application -* spring-sample-batch - Define and run a Batch job in a few lines of code -* spring-sample-data-jpa - Spring Data JPA + Hibernate + HSQLDB -* spring-boot-sample-integration - A spring integration application -* spring-boot-sample-profile - example showing Spring's `@profile` support -* spring-boot-sample-traditional - shows Spring Zero with more traditional WAR packaging +* [spring-boot-sample-simple](spring-boot-sample-simple) - A simple command line application +* [spring-boot-sample-tomcat](spring-boot-sample-tomcat) - Embedded Tomcat +* [spring-boot-sample-jetty](spring-boot-sample-jetty) - Embedded Jetty +* [spring-boot-sample-ops](spring-boot-sample-ops) - Simple REST service with production features +* [spring-boot-sample-ops-ui](spring-boot-sample-ops-ui) - A web UI example with production features +* [spring-boot-sample-web-ui](spring-boot-sample-web-ui) - A thymeleaf web application +* [spring-boot-sample-web-static](spring-boot-sample-web-static) - A web application service static files +* [spring-sample-batch](spring-sample-batch) - Define and run a Batch job in a few lines of code +* [spring-sample-data-jpa](spring-sample-data-jpa) - Spring Data JPA + Hibernate + HSQLDB +* [spring-boot-sample-integration](spring-boot-sample-integration) - A spring integration application +* [spring-boot-sample-profile](spring-boot-sample-profile) - example showing Spring's `@profile` support +* [spring-boot-sample-traditional](spring-boot-sample-traditional) - shows more traditional WAR packaging (but also executable using `java -jar`) -* spring-boot-sample-xml - Example show how Spring Boot can be mixed with traditional XML - configuration - +* [spring-boot-sample-xml](spring-boot-sample-xml) - Example show how Spring Boot can be mixed with traditional + XML configuration (we generally recommend using Java `@Configuration` whenever possible) diff --git a/docs/SCRAPBOOK.md b/docs/SCRAPBOOK.md new file mode 100644 index 00000000000..8e76d0d3787 --- /dev/null +++ b/docs/SCRAPBOOK.md @@ -0,0 +1,153 @@ +# Docs without a home as yet :( + + +|Feature |Implementation |Notes | +|---|---|---| +|Launch Spring from Java main |SpringApplication | Plenty of convenience methods and customization opportunities | +|Server |Tomcat or Jetty | | +|Logging |Logback, Log4j or JDK | Sensible defaults configurations. | +|Externalized configuration | Properties or YAML | Support for Spring profiles. Bind automatically to @Bean. | + +For a quick introduction and to get started quickly with a new +project, carry on reading. For more in depth coverage of the features +of Spring Boot.Strap, go to the [Feature Guide](docs/Features.md). + +# Getting Started + +You will need Java (6 at least) and a build tool (Maven is what we use +below, but you are more than welcome to use gradle). These can be +downloaded or installed easily in most operating systems. For Ubuntu: + + $ sudo apt-get install openjdk-6-jdk maven + + + +## A basic project + +If you are using Maven create a really simple `pom.xml` with 2 dependencies: + +`pom.xml` + +``` + + 4.0.0 + com.mycompany + myproject + 1.0.0-SNAPSHOT + jar + + com.mycompany.Application + + + org.springframework.boot + spring-starter-parent + {{project.version}} + + + + org.springframework.boot + spring-starter + + + + + + org.springframework.boot + spring-package-maven-plugin + + + + +``` + +If you like Gradle, that's fine, and you will know what to do with +those dependencies. The one dependency adds Spring Boot.Config auto +configuration and the Tomcat container to your application. If you +prefer Jetty you can just add the embedded Jetty jars to your +classpath instead of Tomcat. + +Now write a simple main class + +`Application.java` +``` +package com.mycompany; + +import org.springframework.boot.SpringApplication; +import org.springframework.context.annotation.Configuration; + +@Configuration +public class Application { + + public static void main(String[] args) { + SpringApplication.run(Application.class, args); + } + +} +``` + +You should be able to run it already: + + $ mvn package + $ java -jar target/myproject-1.0.0-SNAPSHOT.jar + + . ____ _ __ _ _ + /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ + ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ + \\/ ___)| |_)| | | | | || (_| | ) ) ) ) + ' |____| .__|_| |_|_| |_\__, | / / / / + =========|_|==============|___/=/_/_/_/ + Spring Bootstrap + + 2013-07-19 17:13:51.673 INFO 18937 --- [ main] com.mycompany.Application ... + ... + +It doesn't do anything yet, but that's because all we did is start a +Spring `ApplicationContext` and let it close when the JVM stopped. + +To make it do something a little bit more interesting you could bind +some command line arguments to the application: + +`Application.java` +``` +@Configuration +@ConfigurationProperties +@EnableConfigurationProperties +public class Application { + + private String message; + + @Override + public void run(String... args) throws Exception { + System.err.println(message); + } + + public static void main(String[] args) { + SpringApplication.run(Application.class, args); + } + + public String getMessage() { + return message; + } + + public void setMessage(String message) { + this.message = message; + } +} +``` + +The `@ConfigurationProperties` annotation binds the Spring +`Environment` (including command line arguments) to the `Application` +instance, and `CommandLineRunner` is a marker interface for anything +you want to be executed after the content is started. So run it +again and you will see the message: + +``` + $ mvn package + $ java -jar target/myproject-1.0.0-SNAPSHOT.jar --message="Hello World" + ... + Hello World +``` + +To add more features, add some `@Bean` definitions to your +`Application` class, and read more in the +[Feature Guide](docs/Features.md). \ No newline at end of file diff --git a/spring-boot/README.md b/spring-boot/README.md index 548f11f4190..4744064ed4d 100644 --- a/spring-boot/README.md +++ b/spring-boot/README.md @@ -1,156 +1,104 @@ -# Spring Boot.Strap +# Spring Boot +Spring Boot provides the central features for the other modules in the project. It is +relatively unopinionated and it has minimal dependencies which makes it usable as a +stand-alone library for anyone whose tastes diverge from ours. -Spring Boot.Strap provides features for the other parts of Spring -Boot. It is relatively unopinionated and therefore usable as a -standalone library for anyone whose tastes diverge from ours. - -|Feature |Implementation |Notes | -|---|---|---| -|Launch Spring from Java main |SpringApplication | Plenty of convenience methods and customization opportunities | -|Server |Tomcat or Jetty | | -|Logging |Logback, Log4j or JDK | Sensible defaults configurations. | -|Externalized configuration | Properties or YAML | Support for Spring profiles. Bind automatically to @Bean. | - -For a quick introduction and to get started quickly with a new -project, carry on reading. For more in depth coverage of the features -of Spring Boot.Strap, go to the [Feature Guide](docs/Features.md). - -# Getting Started - -You will need Java (6 at least) and a build tool (Maven is what we use -below, but you are more than welcome to use gradle). These can be -downloaded or installed easily in most operating systems. For Ubuntu: - - $ sudo apt-get install openjdk-6-jdk maven - - - -## A basic project - -If you are using Maven create a really simple `pom.xml` with 2 dependencies: - -`pom.xml` - -``` - - 4.0.0 - com.mycompany - myproject - 1.0.0-SNAPSHOT - jar - - com.mycompany.Application - - - org.springframework.boot - spring-starter-parent - {{project.version}} - - - - org.springframework.boot - spring-starter - - - - - - org.springframework.boot - spring-package-maven-plugin - - - - -``` - -If you like Gradle, that's fine, and you will know what to do with -those dependencies. The one dependency adds Spring Boot.Config auto -configuration and the Tomcat container to your application. If you -prefer Jetty you can just add the embedded Jetty jars to your -classpath instead of Tomcat. - -Now write a simple main class - -`Application.java` -``` -package com.mycompany; - -import org.springframework.boot.SpringApplication; -import org.springframework.context.annotation.Configuration; - -@Configuration -public class Application { - - public static void main(String[] args) { - SpringApplication.run(Application.class, args); - } +## SpringApplication +The `SpringApplication` class provides a convenient way to bootstrap a Spring application +that will be started from a `main()` method. In many situations you can just delegate +to the static `SpringApplication.run` method: +```java +public static void main(String[] args) { + SpringApplication.run(SpringConfiguration.class, args); } ``` -You should be able to run it already: +When you application starts you should see something similar to the following: - $ mvn package - $ java -jar target/myproject-1.0.0-SNAPSHOT.jar - - . ____ _ __ _ _ - /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ - ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ - \\/ ___)| |_)| | | | | || (_| | ) ) ) ) - ' |____| .__|_| |_|_| |_\__, | / / / / - =========|_|==============|___/=/_/_/_/ - Spring Bootstrap - - 2013-07-19 17:13:51.673 INFO 18937 --- [ main] com.mycompany.Application ... - ... - -It doesn't do anything yet, but that's because all we did is start a -Spring `ApplicationContext` and let it close when the JVM stopped. - -To make it do something a little bit more interesting you could bind -some command line arguments to the application: - -`Application.java` ``` -@Configuration -@ConfigurationProperties -@EnableConfigurationProperties -public class Application { + . ____ _ __ _ _ + /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ +( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ + \\/ ___)| |_)| | | | | || (_| | ) ) ) ) + ' |____| .__|_| |_|_| |_\__, | / / / / + =========|_|==============|___/=/_/_/_/ + Spring Boot (v0.5.0.BUILD-SNAPSHOT) - private String message; +2013-07-31 00:08:16.117 INFO 56603 --- [ main] o.s.b.s.app.SampleApplication : Starting SampleApplication v0.1.0 on mycomputer with PID 56603 (/apps/myapp.jar started by pwebb) +2013-07-31 00:08:16.166 INFO 56603 --- [ main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@6e5a8246: startup date [Wed Jul 31 00:08:16 PDT 2013]; root of context hierarchy +``` - @Override - public void run(String... args) throws Exception { - System.err.println(message); - } +By default `INFO` logging messages will shown, including some relevant startup information +such as the user that started the application. - public static void main(String[] args) { - SpringApplication.run(Application.class, args); - } +### Customizing SpringApplication +If the SpringApplication defaults aren't to your taste you can instead create a local +instance and customize it. For example, to turn off the banner you would write: - public String getMessage() { - return message; - } - - public void setMessage(String message) { - this.message = message; - } +```java +public static void main(String[] args) { + SpringApplication app = new SpringApplication(SpringConfiguration.class); + app.setShowBanner(false); + app.run(args); } ``` -The `@ConfigurationProperties` annotation binds the Spring -`Environment` (including command line arguments) to the `Application` -instance, and `CommandLineRunner` is a marker interface for anything -you want to be executed after the content is started. So run it -again and you will see the message: +See the `SpringApplication` Javadoc for a complete list of the configuration options -``` - $ mvn package - $ java -jar target/myproject-1.0.0-SNAPSHOT.jar --message="Hello World" - ... - Hello World +### Accessing command line properties +By default `SpringApplication` will expose any command line arguments as Spring +Properties. This allows you to easily access arguments using by injecting them +as `@Values` + +```java +import org.springframework.stereotype.* +import org.springframework.beans.factory.annotation.* + +@Component +public class MyBean { + + @Value("${name}") + private String name; + // Running 'java -jar myapp.jar --name=Spring' will set this to "Spring" + + // ... +} ``` -To add more features, add some `@Bean` definitions to your -`Application` class, and read more in the -[Feature Guide](docs/Features.md). +### CommandLineRunner beans +If you wan't access to the raw command line argument, or you need to run some specific +code once the `SpringApplication` has started you can implement the `CommandLineRunner` +interface. The `run(String... args)` method will be called on all spring beans +implementing the interface. + +```java +import org.springframework.boot.* +import org.springframework.stereotype.* + +@Component +public class MyBean implements CommandLineRunner { + + public void run(String... args) { + // Do something... + } + +} +``` + +You can additionally implement the `org.springframework.core.Ordered` interface or use +the `org.springframework.core.annotation.Order` annotation if serveral `CommandLineRunner` +beans are defined that must be called in a specific order. + +### Application Exit + + + +## Embedded Servlet Container Support + +## External Configuration + +## Conditionals + +## ApplicationContextInitializers +