These boots are made for walking\u2026maybe running<\/h2>\n
So the greatest thing about Spring Boot is the ability to be up and running in very little time. You don\u2019t have to install a web server like JBoss, Websphere, or even Tomcat for that matter. All you need to do is pull in the proper libraries, annotate, and fire away. If you are going to do a lot of Spring Boot projects, I would highly suggest using the Spring Tool Suite that is available. It has some great features for making Boot projects really easy to manage.<\/p>\n
You can of course choose between Maven or Gradle to manage dependencies and builds. My examples will be in Maven as it is what I am familiar with. It\u2019s all about your configuration preference.<\/p>\n
Many different styles to choose from<\/h2>\n
One of the things that makes Spring Boot great is that it works really well with other Spring offerings. Wow, go figure? You can use Spring MVC, Jetty, or Thymeleaf just by adding them to your dependencies and Spring Boot automatically adds them in.<\/p>\n
Every day boots<\/h3>\n
Spring Boot wants to make things easy for you. You can do a whole host of things with it. Here is a list of some of the highlights.<\/p>\n
- \n
- Spring Boot lets you package up an application in a standalone JAR file, with a full Tomcat server embedded<\/li>\n
- Spring Boot lets you package up an application as a WAR still.<\/li>\n
- Configuration is based on what is in the classpath (MySQL DB in the path, it\u2019ll set it up for you)<\/li>\n
- It has defaults set (so you don\u2019t have to configure them)<\/li>\n
- Easily overridden by adding to the classpath (add H2 dependency and it\u2019ll switch)<\/li>\n
- Let\u2019s new devs learn the ropes in a hurry and make changes later as they learn more.<\/li>\n<\/ul>\n
Baby boots<\/h3>\n
But remember, the aim of this blog is just to get you familiar with how to get Spring Boot going on your machine. It is going to be fairly straightforward and vanilla. The goal is to get you started. We\u2019re not trying to code a new Uber app or something here. Baby steps folks! We just want to get your feet warm. We all know those tutorials that throw tons of stuff at us and just gloss over things. Not here.<\/p>\n
So to get started the easiest way is to pull down the tutorial code from Spring itself. It has a great getting-started point. It is a good for you to see what is happening without throwing the whole Spring library at you.<\/p>\n
Clone boots\u2026watch your aim!<\/h3>\n
First off, let\u2019s clone the Spring example found here<\/a>.<\/p>\n
git clone https:\/\/github.com\/spring-guides\/gs-spring-boot.git<\/pre>\n
We won\u2019t go into the steps of setting it up in an IDE as everyone will have their own preference.<\/p>\n
Construction Boots<\/h3>\n
Let\u2019s break things down a bit. What are these annotations about?<\/p>\n
@SpringBootApplication<\/code> is a convenience annotation that adds all of the following:<\/p>\n- \n
@Configuration<\/code> tags the class as a source of bean definitions for the application context.<\/li>\n@EnableAutoConfiguration<\/code> tells Spring Boot to start adding beans based on classpath settings, other beans, and various property settings.<\/li>\n- Normally you would add
@EnableWebMvc<\/code> for a Spring MVC app, but Spring Boot adds it automatically when it seesspring-webmvc<\/code> on the classpath. This flags the application as a web application and activates key behaviors such as setting up aDispatcherServlet<\/code>.<\/li>\n@ComponentScan<\/code> tells Spring to look for other components, configurations, and services in the the hello package, allowing it to find the controllers.<\/li>\n<\/ul>\nWow, I have always liked quality built-ins when looking for a new home! But what\u2019s really happening behind these shiny new items?
<\/div> <\/div><\/p>\nThe
main()<\/code> method calls out Spring Boot\u2019sSpringApplication.run()<\/code> method to launch.<\/p>\nDid we mention (or did you notice) that you didn\u2019t have to mess around with XML? What a bonus! No more
web.xml<\/code> file nonsense. No more wondering if I put the right tag in the file and wondering what the problem is with the paragraph of unreadable error message telling you just about nothing any longer. This is 100% pure Java. No configuration or plumbing needed. They have done it for you. How nice of them!<\/p>\nOnce it is set up and ready for you to begin editing, let\u2019s take a quick look at the
Application.java<\/code> file. Here you will find a runnablemain<\/code> class. It has an annotation of@SpringBootApplication<\/code>. This is the key annotation that makes this application a Boot app.<\/p>\npackage hello;\r\n\r\nimport java.util.Arrays;\r\n\r\nimport org.springframework.boot.CommandLineRunner;\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.annotation.Bean;\r\n\r\n@SpringBootApplication\r\npublic class Application {\r\n\r\n public static void main(String[] args) {\r\n SpringApplication.run(Application.class, args);\r\n }\r\n\r\n @Bean\r\n public CommandLineRunner commandLineRunner(ApplicationContext ctx) {\r\n return args -> {\r\n\r\n System.out.println(\"Let's inspect the beans provided by Spring Boot:\");\r\n\r\n String[] beanNames = ctx.getBeanDefinitionNames();\r\n Arrays.sort(beanNames);\r\n for (String beanName : beanNames) {\r\n System.out.println(beanName);\r\n }\r\n\r\n };\r\n }\r\n\r\n}<\/pre>\nNow to run it! If you are using the STS suite (and properly built it), you will see it in your Boot Dashboard. For everyone else, either right click in the IDE and Run As => Java Application, or head to your favorite command line tool. Use the following commands.<\/p>\n
Maven:<\/strong><\/p>\n
mvn package && java -jar target\/gs-spring-boot-0.1.0.jar<\/pre>\n
Gradle:<\/strong><\/p>\n
.\/gradlew build && java -jar build\/libs\/gs-spring-boot-0.1.0.jar<\/pre>\n
The output will show the normal Spring startup of the embedded server and then it will loop over all the beans and write them out for you!<\/p>\n
You did it! You tied your first pair of Spring Boots.<\/p>\n
![](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2017\/01\/SpringBoot1-1024x230.png\")
<\/a><\/p>\n![](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2017\/01\/SpringBoot2.png\")
<\/a><\/p>\nBoots on display<\/h3>\n
To make the sale or just to get your eyes on the prize, this example throws in a
CommandLineRunner<\/code> method marked as a@Bean<\/code> and this runs on startup. It retrieves all the beans that were created either by your app or were automatically added thanks to Spring Boot. It sorts them and prints them out. You can put other startup information or do some other little bit of work if you would like.<\/p>\nBoots online<\/h3>\n
While shopping for the right boot, we want the nice ones that will go with our favorite pair of jeans or for the ladies a nice skirt, right? Well Boot provides a simple way to get your boots out to the world for others to see. Well, we need to employ a
Controller<\/code> to do so. How convenient: the Spring code we downloaded has one already for us.<\/p>\npackage hello;\r\n\r\nimport org.springframework.web.bind.annotation.RestController;\r\nimport org.springframework.web.bind.annotation.RequestMapping;\r\n\r\n@RestController\r\npublic class HelloController {\r\n\r\n @RequestMapping(\"\/\")\r\n public String index() {\r\n return \"Greetings from Spring Boot!\";\r\n }\r\n\r\n}<\/pre>\nThe two things that are most important here are the
@RestController<\/code> and the@RequestMapping<\/code> annotations you see.<\/p>\nThe
@RestController<\/code> is a subliminal message that it is nap time. Errr, wait sorry, I was getting sleepy. No, it means we have a RESTful controller waiting, watching, listening to our application\u2019s call to it.<\/p>\nThe
@RequestMapping<\/code> is the url designation that calls the particular method. So in the case of the given example, it is the \u201cindex\u201d of the application. The example here is simply returning text. Here\u2019s the cool thing; we can return just about anything here that you want to return.<\/p>\nDid JSON have nice boots on the Argo?<\/h2>\n
Finally, what I think most adventurers into Spring Boot are doing now is using it as an endpoint to their applications. There are a whole host of different options as to how you can accomplish this. Either by JSON provided data or XML solutions. We\u2019ll just focus on one for now. Jackson is a nice lightweight tool for accomplishing JSON output to the calling scenario.<\/p>\n
Jackson is conveniently found on the classpath of Spring Boot by default. Check it out for yourself:<\/p>\n
mvn dependency:tree`<\/pre>\n
or<\/p>\n
.\/gradlew dependencies<\/pre>\n
Let\u2019s add some pizazz to these boots, already! Add a new class wherever you would like to in your source. Just a POJO.<\/p>\n
public class Greeting {\r\n\r\n private final long id;\r\n private final String content;\r\n\r\n public Greeting(long id, String content) {\r\n this.id = id;\r\n this.content = content;\r\n }\r\n\r\n public long getId() {\r\n return id;\r\n }\r\n\r\n public String getContent() {\r\n return content;\r\n }\r\n\r\n}<\/pre>\nNow, head back to your
<\/code>Controller and paste this in:<\/p>\nprivate static final String template = \"Ahoy, %s!\";\r\nprivate final AtomicLong counter = new AtomicLong();\r\n\r\n@RequestMapping(method=RequestMethod.GET)\r\n public @ResponseBody Greeting sayHello(@RequestParam(value=\"name\", required=false, defaultValue=\"Argonaut\") String name) {\r\n return new Greeting(counter.incrementAndGet(), String.format(template, name));\r\n }<\/pre>\nNow restart your Boot app. Go back to a browser and instead of
\/<\/code>, go tohello-world<\/code>. You should see some awesome JSON output. If you did, then you are well on your way to creating endpoints in Spring Boot and Jackson.<\/p>\nThe Argo needs another port<\/h3>\n
Since a lot of folks are writing endpoints and have multiple sites going on, you\u2019ll probably want to change the default port of 8080 to something else. So the easiest and most straightforward way is to add an
application.properties<\/code> file tosrc\/main\/resources<\/code>.<\/p>\nAll that is need is this:<\/p>\n
server.port = 8090<\/pre>\n
Easy peasy. Weigh anchor and set sail!<\/p>\n
Boot camp conclusion<\/h2>\n
So you can see how easy it is to get things going with Spring Boot. We didn\u2019t have to do much in the way of configuration to actually get up and running in a hurry. We avoided the dreaded XML files and only added a small properties file. The built-ins are extremely nice to already have in the stack. Jackson provides an easy to use JSON conversion for those of us wanting to provide endpoints for our shiny frontends.<\/p>\n
Again, Spring seems to find a way to make life simpler for the developer. This blog was kept simple on purpose. There are many different avenues to venture down in our new boots. Whether you want to leverage microservices, build a traditional monolith, or some other twist that may be out there, you can see how Spring Boot can get you started in a hurry.<\/p>\n
\n