lication using Spring MSpring is a very popular Java based framework for building web and enterprise applications. Unlike many other frameworks which focuses on only one area, Spring framework provides a wide verity of features addressing the modern business needs via its portfolio projects.<\/p>\n
Spring framework provides flexibility to configure the beans in multiple ways such as XML<\/b>, Annotations <\/b>and JavaConfig<\/b>. With the number of features increased the complexity also gets increased and configuring Spring applications becomes tedious and error-prone.<\/p>\n
Spring team created SpringBoot to address the complexity of configuration. But before diving into SpringBoot, we will take a quick look at Spring framework and see what kind of problems SpringBoot is trying to address.<\/p>\n
In this article we will cover: <\/b><\/p>\n If you are a Java developer then there is a high chance that you might have heard about Spring framework and probably have used it in your projects. Spring framework was created primarily as a Dependency Injection container but it is much more than that.<\/p>\n Spring is very popular because of several reasons: <\/b><\/p>\n Along with Spring framework there are many other Spring sister projects which helps to build applications addressing modern business needs:<\/p>\n There are many other interesting projects addressing various other modern application development needs. For more information take a look at http:\/\/spring.io\/projects<\/a>.<\/p>\n In the initial days, Spring framework provides XML based approach for configuring beans. Later Spring introduced XML based DSLs, Annotations and JavaConfig based approaches for configuring beans.<\/p>\n Let us take a quick look at how each of those configuration styles looks like.<\/p>\n XML based configuration <\/b><\/p>\n Annotation based configuration <\/b><\/p>\n JavaConfig based configuration <\/b><\/p>\n Wow\u2026 Spring provides many approaches for doing the same thing and we can even mix the approaches as well like you can use both JavaConfig and Annotation based configuration styles in the same application.<\/p>\n That is a lot of flexibility and it is one way good and one way bad. People new to Spring framework may gets confused But there is no one-size fits all kind of solution. One has to choose the approach based on their own application needs.<\/p>\n OK, now that you had a glimpse of how various styles of Spring bean configurations looks like.<\/p>\n Let us take a quick look at the configuration of a typical SpringMVC + JPA\/Hibernate web application configuration looks like.<\/p>\n Before getting to know what is SpringBoot and what kind of features it provides, let us take a look at how a typical Spring web application configuration looks like, what are the pain points and then we will discuss about how SpringBoot addresses those problems.<\/p>\n Step 1: Configure Maven Dependencies <\/b><\/p>\n First thing we need to do is configure all the dependencies required in our pom.xml<\/b>.<\/p>\n We have configured all our Maven jar dependencies to include Spring MVC, Spring Data JPA, JPA\/Hibernate, Thymeleaf and Log4j. Step 2: Configure Service\/DAO layer beans using JavaConfig. <\/b><\/p>\n In our AppConfig.java configuration class we have done the following:<\/p>\n we need to configure property placeholder values in application.properties<\/b> as follows:<\/p>\n we can create a simple sql script data.sql<\/b> to populate sample data into USER <\/b>table.<\/p>\n We can create log4j.properties<\/b> file with basic configuration as follows:<\/p>\n Step 3: Configure Spring MVC web layer beans <\/b><\/p>\n We will have to configure Thymeleaf ViewResolver<\/b>, static ResourceHandlers<\/b>, MessageSource <\/b>for i18n etc.<\/p>\n In our WebMvcConfig.java<\/b> configuration class we have done the following:<\/p>\n For now we do not have any messages to be configured, so create an empty messages.properties<\/b> file in src\/main\/resources<\/b> folder.<\/p>\n Step 4: Register Spring MVC FrontController servlet DispatcherServlet. <\/b><\/p>\n Prior to Servlet 3.x specification we have to register Servlets\/Filters in web.xml<\/b>. Since Servlet 3.x specification we can register Servlets\/Filters programatically using ServletContainerInitializer<\/b>.<\/p>\n Spring MVC provides a convenient class AbstractAnnotationConfigDispatcherServletInitializer <\/b>to register DispatcherServlet<\/b>.<\/p>\n In our SpringWebAppInitializer.java <\/b>configuration class we have done the following:<\/p>\n Step 5: Create a JPA Entity and Spring Data JPA Repository <\/b><\/p>\n Create a JPA entity User.java<\/b> and a Spring Data JPA repository for User entity.<\/p>\n Step 6: Create a SpringMVC Controller <\/b><\/p>\n Create a SpringMVC controller to handle URL \u201c\/\u201d <\/b>and render list of users.<\/p>\n Step 7: Create a thymeleaf view \/WEB-INF\/views\/index.html to render list of Users. <\/b><\/p>\n We are all set now to run the application. But before that we need to download and configure the server like Tomcat <\/b>orJetty <\/b>or Wildfly <\/b>etc in your IDE.<\/p>\n You can download Tomcat 8 and configure in your favourite IDE,run the application and point your browser to http:\/\/localhost:8080\/springmvcjpa-demo<\/b>. You should see the list of users details in a table. Yay\u2026We did it.<\/p>\n But wait..Isn\u2019t it too much work to just show a list of user details pulled from a database table? Let us be honest and fair. All this configuration is not just for this one use-case. This configuration is basis for rest of the application also. Apart from writing the same configuration again and again, do you see any other problems here?<\/p>\n Well, let me list our what are the problems I am seeing here. <\/b><\/p>\n If Spring can automatically do it for me that would be awesome!!!.<\/p>\n<\/blockquote>\n Imagine, what if Spring is capable of configuring beans automatically? What if you can customize the automatic configuration using simple customizable properties?<\/p>\n For example, instead of mapping DispatcherServlet url-pattern to \u201c\/\u201d you want to map it to \u201c\/app\/\u201d. Instead of putting thymeleaf views in \u201c\/WEB-INF\/views\u201d folder you may want to place them in \u201c\/WEB-INF\/templates\/\u201d folder.<\/p>\n So basically you want Spring to do things automatically but provide the flexibility to override the default configuration in a simpler way?<\/p>\n Well, you are about to enter into the world of SpringBoot where your dreams come true!!!<\/p>\n Welcome to SpringBoot!. SpringBoot do what exactly you are looking for. It will do things automatically for you but allows you to override the defaults if you want to.<\/p>\n Instead of explaining in theory I prefer to explain by example.<\/p>\n So let us implement the same application that we built earlier but this time using SpringBoot.<\/p>\n Step 1: Create a Maven based SpringBoot Project <\/b><\/p>\n Create a Maven project and configure the dependencies as follows:<\/p>\n Wow our pom.xml<\/b> suddenly become so small!!.<\/p>\n Step 2: Configure datasource\/JPA properties in application.properties as follows. <\/b><\/p>\n you can copy the same data.sql<\/b> file into src\/main\/resources<\/b> folder.<\/p>\n Step 3: Create a JPA Entity and Spring Data JPA Repository Interface for the entity. <\/b><\/p>\n Create User.java, UserRepository.java<\/b> and HomeController.java<\/b> same as in springmvc-jpa-demo<\/b> application.<\/p>\n Step 4: Create Thymeleaf view to show list of users <\/b><\/p>\n Copy \/WEB-INF\/views\/index.html<\/b> that we created in springmvc-jpa-demo<\/b> application into src\/-main\/resources\/templates<\/b> folder in our new project.<\/p>\n Step 5: Create SpringBoot EntryPoint Class. <\/b><\/p>\n Create a Java class Application.java<\/b> with main method as follows:<\/p>\n Now run Application.java <\/b>as a Java Application and point your browser to http:\/\/localhost:8080\/<\/b>. You should see the list of users in table format. Coool!!!<\/p>\n Ok ok, I hear you are shouting \u201cWhat is going on???\u201d.<\/p>\n Let me explain what just happened.<\/p>\n 1. Easy dependency Management <\/b><\/p>\n 2. Auto Configuration <\/b><\/p>\n 3. Embedded Servlet Container Support<\/b><\/p>\n The most important and surprising thing is we have created a simple Java class annotated with some magical annotation Where is the servlet container comes from? <\/b><\/p>\n We have added spring-boot-starter-web<\/b> which pull the spring-boot-starter-tomcat<\/b> automatically and when we run the main() method it started tomcat as an embedded container <\/b>so that we don\u2019t have to deploy our application on any externally installed tomcat server.<\/p>\n By the way have you observe that our packaging type in pom.xml<\/b> is \u2018jar\u2019 not \u2018war\u2019<\/b>. Wonderful!<\/p>\n Ok, but what if I want to use Jetty server instead of tomcat? <\/b><\/p>\n Simple, exclude spring-bootstarter-tomcat<\/b> from spring-boot-starter-web<\/b> and include spring-boot-starter-jetty<\/b>.<\/p>\n That\u2019s it. But, this looks all magical!!!<\/p>\n I can imagine what you are thinking. You are thinking like SpringBoot looks cool and it is doing lot of things automatically for me. But still I am not fully understand how it is all really working behind the scenes. Right?<\/p>\n I can understand. Watching magic show is fun normally, but not in Software Development. Don\u2019t worry, we will be looking at each of those things and explain in-detail how things are happening behind the scenes in future articles. But I don\u2019t want to overwhelm you by dumping everything on to your hear right now in this article.<\/p>\n In this article we had a quick overview of various Spring configuration styles and understand the complexity of configuring Spring applications. Also, we had a quick look at SpringBoot by creating a simple web application. In next article we will deep dive into SpringBoot and understand how it works.<\/p>\n\n
Overview of Spring framework<\/h2>\n
\n
\n
<bean id=\"userService\" class=\"com.sivalabs.myapp.service.UserService\">\r\n <property name=\"userDao\" ref=\"userDao\"\/>\r\n<\/bean>\r\n\r\n<bean id=\"userDao\" class=\"com.sivalabs.myapp.dao.JdbcUserDao\">\r\n <property name=\"dataSource\" ref=\"dataSource\"\/>\r\n<\/bean>\r\n\r\n<bean id=\"dataSource\" class=\"org.apache.commons.dbcp.BasicDataSource\" destroy-method=\"close\">\r\n <property name=\"driverClassName\" value=\"com.mysql.jdbc.Driver\"\/>\r\n <property name=\"url\" value=\"jdbc:mysql:\/\/localhost:3306\/test\"\/>\r\n <property name=\"username\" value=\"root\"\/>\r\n <property name=\"password\" value=\"secret\"\/>\r\n<\/bean><\/pre>\n
@Service\r\npublic class UserService\r\n{\r\n private UserDao userDao;\r\n\r\n @Autowired\r\n public UserService(UserDao dao){\r\n this.userDao = dao;\r\n }\r\n ...\r\n ...\r\n}<\/pre>\n@Repository\r\npublic class JdbcUserDao\r\n{\r\n private DataSource dataSource;\r\n\r\n @Autowired\r\n public JdbcUserDao(DataSource dataSource){\r\n this.dataSource = dataSource;\r\n }\r\n ...\r\n ...\r\n}<\/pre>\n@Configuration\r\npublic class AppConfig\r\n{\r\n @Bean\r\n public UserService userService(UserDao dao){\r\n return new UserService(dao);\r\n }\r\n\r\n @Bean\r\n public UserDao userDao(DataSource dataSource){\r\n return new JdbcUserDao(dataSource);\r\n }\r\n\r\n @Bean\r\n public DataSource dataSource(){\r\n BasicDataSource dataSource = new BasicDataSource();\r\n dataSource.setDriverClassName(\"com.mysql.jdbc.Driver\");\r\n dataSource.setUrl(\"jdbc:mysql:\/\/localhost:3306\/test\");\r\n dataSource.setUsername(\"root\");\r\n dataSource.setPassword(\"secret\");\r\n return dataSource;\r\n }\r\n}<\/pre>\n\n
\nabout which approach to follow. As of now the Spring team is suggesting to follow JavaConfig based approach as it gives more flexibility.<\/p>\n<\/blockquote>\nA web application using Spring MVC and JPA(Hibernate)<\/h2>\n
<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" \r\n xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 \r\n http:\/\/maven.apache.org\/maven-v4_0_0.xsd\">\r\n <modelVersion>4.0.0<\/modelVersion>\r\n <groupId>com.sivalabs<\/groupId>\r\n <artifactId>springmvc-jpa-demo<\/artifactId>\r\n <packaging>war<\/packaging>\r\n <version>1.0-SNAPSHOT<\/version>\r\n <name>springmvc-jpa-demo<\/name>\r\n\r\n <properties>\r\n <project.build.sourceEncoding>UTF-8<\/project.build.sourceEncoding>\r\n <maven.compiler.source>1.8<\/maven.compiler.source>\r\n <maven.compiler.target>1.8<\/maven.compiler.target> \r\n <failOnMissingWebXml>false<\/failOnMissingWebXml>\r\n <\/properties>\r\n\r\n <dependencies>\r\n <dependency>\r\n <groupId>org.springframework<\/groupId>\r\n <artifactId>spring-webmvc<\/artifactId>\r\n <version>4.2.4.RELEASE<\/version>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>org.springframework.data<\/groupId>\r\n <artifactId>spring-data-jpa<\/artifactId>\r\n <version>1.9.2.RELEASE<\/version>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>org.slf4j<\/groupId>\r\n <artifactId>jcl-over-slf4j<\/artifactId>\r\n <version>1.7.13<\/version>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>org.slf4j<\/groupId>\r\n <artifactId>slf4j-api<\/artifactId>\r\n <version>1.7.13<\/version>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>org.slf4j<\/groupId>\r\n <artifactId>slf4j-log4j12<\/artifactId>\r\n <version>1.7.13<\/version>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>log4j<\/groupId>\r\n <artifactId>log4j<\/artifactId>\r\n <version>1.2.17<\/version>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>com.h2database<\/groupId>\r\n <artifactId>h2<\/artifactId>\r\n <version>1.4.190<\/version>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>commons-dbcp<\/groupId>\r\n <artifactId>commons-dbcp<\/artifactId>\r\n <version>1.4<\/version>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>mysql<\/groupId>\r\n <artifactId>mysql-connector-java<\/artifactId>\r\n <version>5.1.38<\/version>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>org.hibernate<\/groupId>\r\n <artifactId>hibernate-entitymanager<\/artifactId>\r\n <version>4.3.11.Final<\/version>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>javax.servlet<\/groupId>\r\n <artifactId>javax.servlet-api<\/artifactId>\r\n <version>3.1.0<\/version>\r\n <scope>provided<\/scope>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>org.thymeleaf<\/groupId>\r\n <artifactId>thymeleaf-spring4<\/artifactId>\r\n <version>2.1.4.RELEASE<\/version>\r\n <\/dependency>\r\n <\/dependencies>\r\n<\/project><\/pre>\n
@Configuration\r\n@EnableTransactionManagement\r\n@EnableJpaRepositories(basePackages=\"com.sivalabs.demo\")\r\n@PropertySource(value = { \"classpath:application.properties\" })\r\npublic class AppConfig \r\n{\r\n @Autowired\r\n private Environment env;\r\n\r\n @Bean\r\n public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer()\r\n {\r\n return new PropertySourcesPlaceholderConfigurer();\r\n }\r\n \r\n @Value(\"${init-db:false}\")\r\n private String initDatabase;\r\n \r\n @Bean\r\n public PlatformTransactionManager transactionManager()\r\n {\r\n EntityManagerFactory factory = entityManagerFactory().getObject();\r\n return new JpaTransactionManager(factory);\r\n }\r\n\r\n @Bean\r\n public LocalContainerEntityManagerFactoryBean entityManagerFactory()\r\n {\r\n LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();\r\n\r\n HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();\r\n vendorAdapter.setGenerateDdl(Boolean.TRUE);\r\n vendorAdapter.setShowSql(Boolean.TRUE);\r\n\r\n factory.setDataSource(dataSource());\r\n factory.setJpaVendorAdapter(vendorAdapter);\r\n factory.setPackagesToScan(\"com.sivalabs.demo\");\r\n\r\n Properties jpaProperties = new Properties();\r\n jpaProperties.put(\"hibernate.hbm2ddl.auto\", env.getProperty(\"hibernate.hbm2ddl.auto\"));\r\n factory.setJpaProperties(jpaProperties);\r\n\r\n factory.afterPropertiesSet();\r\n factory.setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());\r\n return factory;\r\n }\r\n\r\n @Bean\r\n public HibernateExceptionTranslator hibernateExceptionTranslator()\r\n {\r\n return new HibernateExceptionTranslator();\r\n }\r\n \r\n @Bean\r\n public DataSource dataSource()\r\n {\r\n BasicDataSource dataSource = new BasicDataSource();\r\n dataSource.setDriverClassName(env.getProperty(\"jdbc.driverClassName\"));\r\n dataSource.setUrl(env.getProperty(\"jdbc.url\"));\r\n dataSource.setUsername(env.getProperty(\"jdbc.username\"));\r\n dataSource.setPassword(env.getProperty(\"jdbc.password\"));\r\n return dataSource;\r\n }\r\n \r\n @Bean\r\n public DataSourceInitializer dataSourceInitializer(DataSource dataSource) \r\n {\r\n DataSourceInitializer dataSourceInitializer = new DataSourceInitializer();\r\n dataSourceInitializer.setDataSource(dataSource);\r\n ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator();\r\n databasePopulator.addScript(new ClassPathResource(\"data.sql\"));\r\n dataSourceInitializer.setDatabasePopulator(databasePopulator);\r\n dataSourceInitializer.setEnabled(Boolean.parseBoolean(initDatabase));\r\n return dataSourceInitializer;\r\n } \r\n}<\/pre>\n\n
jdbc.driverClassName=com.mysql.jdbc.Driver\r\njdbc.url=jdbc:mysql:\/\/localhost:3306\/test\r\njdbc.username=root\r\njdbc.password=admin\r\ninit-db=true\r\nhibernate.dialect=org.hibernate.dialect.MySQLDialect\r\nhibernate.show_sql=true\r\nhibernate.hbm2ddl.auto=update<\/pre>\n
delete from user;\r\ninsert into user(id, name) values(1,'Siva');\r\ninsert into user(id, name) values(2,'Prasad');\r\ninsert into user(id, name) values(3,'Reddy');<\/pre>\n
log4j.rootCategory=INFO, stdout\r\nlog4j.appender.stdout=org.apache.log4j.ConsoleAppender\r\nlog4j.appender.stdout.layout=org.apache.log4j.PatternLayout\r\nlog4j.appender.stdout.layout.ConversionPattern=%5p %t %c{2}:%L - %m%n\r\n\r\nlog4j.category.org.springframework=INFO\r\nlog4j.category.com.sivalabs=DEBUG<\/pre>\n@Configuration\r\n@ComponentScan(basePackages = { \"com.sivalabs.demo\"}) \r\n@EnableWebMvc\r\npublic class WebMvcConfig extends WebMvcConfigurerAdapter\r\n{\r\n @Bean\r\n public TemplateResolver templateResolver() {\r\n TemplateResolver templateResolver = new ServletContextTemplateResolver();\r\n templateResolver.setPrefix(\"\/WEB-INF\/views\/\");\r\n templateResolver.setSuffix(\".html\");\r\n templateResolver.setTemplateMode(\"HTML5\");\r\n templateResolver.setCacheable(false);\r\n return templateResolver;\r\n }\r\n\r\n @Bean\r\n public SpringTemplateEngine templateEngine() {\r\n SpringTemplateEngine templateEngine = new SpringTemplateEngine();\r\n templateEngine.setTemplateResolver(templateResolver());\r\n return templateEngine;\r\n }\r\n\r\n @Bean\r\n public ThymeleafViewResolver viewResolver() {\r\n ThymeleafViewResolver thymeleafViewResolver = new ThymeleafViewResolver();\r\n thymeleafViewResolver.setTemplateEngine(templateEngine());\r\n thymeleafViewResolver.setCharacterEncoding(\"UTF-8\");\r\n return thymeleafViewResolver;\r\n }\r\n\r\n @Override\r\n public void addResourceHandlers(ResourceHandlerRegistry registry)\r\n {\r\n registry.addResourceHandler(\"\/resources\/**\").addResourceLocations(\"\/resources\/\");\r\n }\r\n\r\n @Override\r\n public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer)\r\n {\r\n configurer.enable();\r\n }\r\n\r\n @Bean(name = \"messageSource\")\r\n public MessageSource configureMessageSource()\r\n {\r\n ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();\r\n messageSource.setBasename(\"classpath:messages\");\r\n messageSource.setCacheSeconds(5);\r\n messageSource.setDefaultEncoding(\"UTF-8\");\r\n return messageSource;\r\n }\r\n}<\/pre>\n\n
public class SpringWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer\r\n{\r\n\r\n @Override\r\n protected Class<?>[] getRootConfigClasses()\r\n {\r\n return new Class<?>[] { AppConfig.class};\r\n }\r\n\r\n @Override\r\n protected Class<?>[] getServletConfigClasses()\r\n {\r\n return new Class<?>[] { WebMvcConfig.class };\r\n }\r\n\r\n @Override\r\n protected String[] getServletMappings()\r\n {\r\n return new String[] { \"\/\" };\r\n }\r\n\r\n @Override\r\n protected Filter[] getServletFilters() {\r\n return new Filter[]{ new OpenEntityManagerInViewFilter() };\r\n }\r\n}<\/pre>\n\n
@Entity\r\npublic class User\r\n{\r\n @Id @GeneratedValue(strategy=GenerationType.AUTO)\r\n private Integer id;\r\n private String name;\r\n\r\n \/\/setters and getters\r\n}<\/pre>\npublic interface UserRepository extends JpaRepository<User, Integer>\r\n{\r\n}<\/pre>\n@Controller\r\npublic class HomeController\r\n{\r\n @Autowired UserRepository userRepo;\r\n\r\n @RequestMapping(\"\/\")\r\n public String home(Model model)\r\n {\r\n model.addAttribute(\"users\", userRepo.findAll());\r\n return \"index\";\r\n }\r\n}<\/pre>\n<!DOCTYPE html>\r\n<html xmlns=\"http:\/\/www.w3.org\/1999\/xhtml\" \r\n xmlns:th=\"http:\/\/www.thymeleaf.org\">\r\n<head>\r\n<meta charset=\"utf-8\"\/>\r\n<title>Home<\/title>\r\n<\/head>\r\n<body>\r\n <table>\r\n <thead>\r\n <tr>\r\n <th>Id<\/th>\r\n <th>Name<\/th>\r\n <\/tr>\r\n <\/thead>\r\n <tbody>\r\n <tr th:each=\"user : ${users}\">\r\n <td th:text=\"${user.id}\">Id<\/td>\r\n <td th:text=\"${user.name}\">Name<\/td>\r\n <\/tr>\r\n <\/tbody>\r\n <\/table>\r\n<\/body>\r\n<\/html><\/pre>\n
\n<\/b>
\nBut again, this is too much of work to do if you want to quickly get up and running. Another problem with it is, assume you want to develop another SpringMVC application with similar technical stack?
\n<\/b>
\nWell, you copy-paste the configuration and tweak it. Right? But remember one thing: if you have to do the same thing again and again, you should find an automated way to do it.<\/b><\/p>\n\n
\n
A quick taste of SpringBoot<\/h2>\n
<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" \r\n xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 \r\n http:\/\/maven.apache.org\/maven-v4_0_0.xsd\">\r\n <modelVersion>4.0.0<\/modelVersion>\r\n <groupId>com.sivalabs<\/groupId>\r\n <artifactId>hello-springboot<\/artifactId>\r\n <packaging>jar<\/packaging>\r\n <version>1.0-SNAPSHOT<\/version>\r\n <name>hello-springboot<\/name>\r\n\r\n <parent>\r\n <groupId>org.springframework.boot<\/groupId>\r\n <artifactId>spring-boot-starter-parent<\/artifactId>\r\n <version>1.3.2.RELEASE<\/version>\r\n <\/parent>\r\n\r\n <properties>\r\n <project.build.sourceEncoding>UTF-8<\/project.build.sourceEncoding>\r\n <java.version>1.8<\/java.version>\r\n <\/properties>\r\n\r\n \r\n <dependencies>\r\n <dependency>\r\n <groupId>org.springframework.boot<\/groupId>\r\n <artifactId>spring-boot-starter-test<\/artifactId>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>org.springframework.boot<\/groupId>\r\n <artifactId>spring-boot-starter-data-jpa<\/artifactId>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>org.springframework.boot<\/groupId>\r\n <artifactId>spring-boot-starter-web<\/artifactId>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>org.springframework.boot<\/groupId>\r\n <artifactId>spring-boot-starter-thymeleaf<\/artifactId>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>org.springframework.boot<\/groupId>\r\n <artifactId>spring-boot-devtools<\/artifactId>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>mysql<\/groupId>\r\n <artifactId>mysql-connector-java<\/artifactId>\r\n <\/dependency>\r\n <\/dependencies>\r\n<\/project><\/pre>\n
spring.datasource.driver-class-name=com.mysql.jdbc.Driver\r\nspring.datasource.url=jdbc:mysql:\/\/localhost:3306\/test\r\nspring.datasource.username=root\r\nspring.datasource.password=admin\r\nspring.datasource.initialize=true\r\nspring.jpa.hibernate.ddl-auto=update\r\nspring.jpa.show-sql=true<\/pre>\n
@SpringBootApplication\r\npublic class Application\r\n{\r\n public static void main(String[] args)\r\n {\r\n SpringApplication.run(Application.class, args);\r\n }\r\n}<\/pre>\n\n
\nRemember I said \u201c95% of the times I use same configuration\u201d. So when you add springboot-starter-web <\/b>dependency by default it will pull all the commonly used libraries while developing Spring MVC applications such as spring-webmvc, jackson-json, validation-api <\/b>and tomcat<\/b>.<\/li>\n\n
\n@SpringApplication <\/b>having a main method and by running that main we are able to run the application and access it at
\nhttp:\/\/localhost:8080\/<\/b>.<\/p>\nSummary<\/h2>\n