# 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.

# 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

<!--FIXME: short instructions for Mac.-->

## A basic project

If you are using Maven create a really simple `pom.xml` with 2 dependencies:

`pom.xml`

```
<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mycompany</groupId>
  <artifactId>myproject</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <packaging>jar</packaging>
  <properties>
      <start-class>com.mycompany.Application</start-class>
  </properties>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-starter-parent</artifactId>
    <version>{{project.version}}</version>
  </parent>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-starter</artifactId>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-package-maven-plugin</artifactId>
     </plugin>
    </plugins>
  </build>
</project>
```

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 ...
    ... <logs showing application starting up>

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.
