https://mp.weixin.qq.com/s/SHKqf7y8pmM7lHlFRU4vqQ

原文:https://dzone.com/articles/why-springboot 作者:Siva Prasad Reddy Katamreddy 译者:Oopsguy

本文介绍将各种Spring的配置方式,帮助您了解配置Spring应用的复杂性。

Spring是一个非常受欢迎的Java框架,它用于构建web和企业应用。不像许多其他框架只关注一个领域,Spring框架提供了各种功能,通过项目组合来满足当代业务需求。

Spring框架提供了多种灵活的方式配置Bean。例如XML、注解和Java配置。随着功能数量的增加,复杂性也随之增加,配置Spring应用将变得乏味而且容易出错。 Spring团队创建了Spring Boot以解决配置复杂的问题。

但在开始Spring Boot之前,我们将快速浏览一下Spring框架,看看Spring Boot正在决解什么样的问题。

在本文中,我们将介绍:

  • Spring框架概述
  • 一个使用了Spring MVC和JPA(Hibernate)的web应用
  • 快速尝试Spring Boot

Spring框架概述

如果您是一名Java开发人员,那么您很可能听说过Spring框架,甚至可能已经在您的项目中使用了它。Spring框架主要是作为依赖注入容器,但它不仅仅是这样。

Spring很受欢迎的原因有几点:

  • Spring的依赖注入方式鼓励编写可测试代码。
  • 具备简单但功能强大的数据库事务管理功能
  • Spring简化了与其他Java框架的集成工作,比如JPA/Hibernate ORM和Struts/JSF等web框架。
  • 构建web应用最先进的Web MVC框架。

连同Spring一起的,还有许多其他的Spring姊妹项目,可以帮助构建满足当代业务需求的应用:

  • Spring Data:简化了关系数据库和NoSQL数据存储的数据访问。
  • Spring Batch:提供强大的批处理框架。
  • Spring Security:用于保护应用的强大的安全框架。
  • Spring Social:支持与Facebook、Twitter、Linkedin、Github等社交网站集成。 Spring Integration:实现了企业集成模式,以便于使用轻量级消息和声明式适配器与其他企业应用集成。 还有许多其他有趣的项目涉及各种其他当代应用开发需求。有关更多信息,请查看http://spring.io/projects。

刚开始,Spring框架只提供了基于XML的方方式来配置bean。后来,Spring引入了基于XML的DSL、注解和基于Java配置的方式来配置bean。

让我们快速了解一下这些配置风格的大概样子。

基于XML的配置

<bean
 
id
=
"userService"
 
class
=
"com.sivalabs.myapp.service.UserService"
>
    
<property
 
name
=
"userDao"
 
ref
=
"userDao"
/>
</bean>
<bean
 
id
=
"userDao"
 
class
=
"com.sivalabs.myapp.dao.JdbcUserDao"
>
    
<property
 
name
=
"dataSource"
 
ref
=
"dataSource"
/>
</bean>
<bean
 
id
=
"dataSource"
 
class
=
"org.apache.commons.dbcp.BasicDataSource"
 
destroy-method
=
"close"
>
    
<property
 
name
=
"driverClassName"
 
value
=
"com.mysql.jdbc.Driver"
/>
    
<property
 
name
=
"url"
 
value
=
"jdbc:mysql://localhost:3306/test"
/>
    
<property
 
name
=
"username"
 
value
=
"root"
/>
    
<property
 
name
=
"password"
 
value
=
"secret"
/>
</bean>

基于注解的配置

@Service
public
 
class
 
UserService
{
    
private
 
UserDao
 userDao
;
    
@Autowired
    
public
 
UserService
(
UserDao
 dao
){
        
this
.
userDao 
=
 dao
;
    
}
    
...
    
...
}
@Repository
public
 
class
 
JdbcUserDao
{
    
private
 
DataSource
 dataSource
;
    
@Autowired
    
public
 
JdbcUserDao
(
DataSource
 dataSource
){
        
this
.
dataSource 
=
 dataSource
;
    
}
    
...
    
...
}

基于Java配置


@Configuration
public
 
class
 
AppConfig
{
    
@Bean
    
public
 
UserService
 userService
(
UserDao
 dao
){
        
return
 
new
 
UserService
(
dao
);
    
}
    
@Bean
    
public
 
UserDao
 userDao
(
DataSource
 dataSource
){
        
return
 
new
 
JdbcUserDao
(
dataSource
);
    
}
    
@Bean
    
public
 
DataSource
 dataSource
(){
        
BasicDataSource
 dataSource 
=
 
new
 
BasicDataSource
();
        dataSource
.
setDriverClassName
(
"com.mysql.jdbc.Driver"
);
        dataSource
.
setUrl
(
"jdbc:mysql://localhost:3306/test"
);
        dataSource
.
setUsername
(
"root"
);
        dataSource
.
setPassword
(
"secret"
);
        
return
 dataSource
;
    
}
}

哇!Spring提供给了许多方法来做同样的事,我们甚至可以混合使用,在同一个应用中使用基于Java配置和注解配置的方式。

这非常灵活,但它有好有坏。刚开始接触Spring的新人可能会困惑应该使用哪一种方式。到目前为止,Spring团队建议使用基于Java配置的方式,因为它具有更多的灵活性。

没有哪一种方案是万能,我们应该根据自己的需求来选择合适的方式。

很好,现在您已经了解了多种Spring Bean的配置方式的基本形式。

让我们快速地了解一下典型的Spring MVC+JPA/Hibernate web应用的配置。

一个使用了Spring MVC和JPA(Hibernate)的web应用

在了解Spring Boot是什么以及它提供了什么样的功能之前,我们先来看一下典型的Spring Web应用配置是怎样的,哪些是痛点,然后我们将讨论Spring Boot是如何解决这些问题的。

步骤1:配置Maven依赖

首先我们需要做的是配置pom.xml中所需的依赖。

<?
xml version
=
"1.0"
 encoding
=
"UTF-8"
?>
<project
 
xmlns
=
"http://maven.apache.org/POM/4.0.0"
    
xmlns:xsi
=
"http://www.w3.org/2001/XMLSchema-instance"
    
xsi:schemaLocation
=
"http://maven.apache.org/POM/4.0.0 
                        http://maven.apache.org/maven-v4_0_0.xsd"
>
    
<modelVersion>
4.0.0
</modelVersion>
    
<groupId>
com.sivalabs
</groupId>
    
<artifactId>
springmvc-jpa-demo
</artifactId>
    
<packaging>
war
</packaging>
    
<version>
1.0-SNAPSHOT
</version>
    
<name>
springmvc-jpa-demo
</name>
    
<properties>
        
<project.build.sourceEncoding>
UTF-8
</project.build.sourceEncoding>
        
<maven.compiler.source>
1.8
</maven.compiler.source>
        
<maven.compiler.target>
1.8
</maven.compiler.target>
      
        
<failOnMissingWebXml>
false
</failOnMissingWebXml>
    
</properties>
    
<dependencies>
        
<dependency>
            
<groupId>
org.springframework
</groupId>
            
<artifactId>
spring-webmvc
</artifactId>
            
<version>
4.2.4.RELEASE
</version>
        
</dependency>
        
<dependency>
            
<groupId>
org.springframework.data
</groupId>
            
<artifactId>
spring-data-jpa
</artifactId>
            
<version>
1.9.2.RELEASE
</version>
        
</dependency>
        
<dependency>
            
<groupId>
org.slf4j
</groupId>
            
<artifactId>
jcl-over-slf4j
</artifactId>
            
<version>
1.7.13
</version>
        
</dependency>
        
<dependency>
            
<groupId>
org.slf4j
</groupId>
            
<artifactId>
slf4j-api
</artifactId>
            
<version>
1.7.13
</version>
        
</dependency>
        
<dependency>
            
<groupId>
org.slf4j
</groupId>
            
<artifactId>
slf4j-log4j12
</artifactId>
            
<version>
1.7.13
</version>
        
</dependency>
        
<dependency>
            
<groupId>
log4j
</groupId>
            
<artifactId>
log4j
</artifactId>
            
<version>
1.2.17
</version>
        
</dependency>
        
<dependency>
            
<groupId>
com.h2database
</groupId>
            
<artifactId>
h2
</artifactId>
            
<version>
1.4.190
</version>
        
</dependency>
        
<dependency>
            
<groupId>
commons-dbcp
</groupId>
            
<artifactId>
commons-dbcp
</artifactId>
            
<version>
1.4
</version>
        
</dependency>
        
<dependency>
            
<groupId>
mysql
</groupId>
            
<artifactId>
mysql-connector-java
</artifactId>
            
<version>
5.1.38
</version>
        
</dependency>
        
<dependency>
            
<groupId>
org.hibernate
</groupId>
            
<artifactId>
hibernate-entitymanager
</artifactId>
            
<version>
4.3.11.Final
</version>
        
</dependency>
        
<dependency>
            
<groupId>
javax.servlet
</groupId>
            
<artifactId>
javax.servlet-api
</artifactId>
            
<version>
3.1.0
</version>
            
<scope>
provided
</scope>
        
</dependency>
        
<dependency>
            
<groupId>
org.thymeleaf
</groupId>
            
<artifactId>
thymeleaf-spring4
</artifactId>
            
<version>
2.1.4.RELEASE
</version>
        
</dependency>
    
</dependencies>
</project>

我们配置了所有的Maven jar依赖,包括Spring MVC、Spring Data JPA、JPA/Hibernate、Thymeleaf和Log4j。

步骤2:使用Java配置配置Service/DAO层的Bean

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories
(
basePackages
=
"com.sivalabs.demo"
)
@PropertySource
(
value 
=
 
{
 
"classpath:application.properties"
 
})
public
 
class
 
AppConfig
 
{
    
@Autowired
    
private
 
Environment
 env
;
    
@Bean
    
public
 
static
 
PropertySourcesPlaceholderConfigurer
 placeHolderConfigurer
()
    
{
        
return
 
new
 
PropertySourcesPlaceholderConfigurer
();
    
}
    
@Value
(
"${init-db:false}"
)
    
private
 
String
 initDatabase
;
    
@Bean
    
public
 
PlatformTransactionManager
 transactionManager
()
    
{
        
EntityManagerFactory
 factory 
=
 entityManagerFactory
().
getObject
();
        
return
 
new
 
JpaTransactionManager
(
factory
);
    
}
    
@Bean
    
public
 
LocalContainerEntityManagerFactoryBean
 entityManagerFactory
()
    
{
        
LocalContainerEntityManagerFactoryBean
 factory 
=
 
new
 
LocalContainerEntityManagerFactoryBean
();
        
HibernateJpaVendorAdapter
 vendorAdapter 
=
 
new
 
HibernateJpaVendorAdapter
();
        vendorAdapter
.
setGenerateDdl
(
Boolean
.
TRUE
);
        vendorAdapter
.
setShowSql
(
Boolean
.
TRUE
);
        factory
.
setDataSource
(
dataSource
());
        factory
.
setJpaVendorAdapter
(
vendorAdapter
);
        factory
.
setPackagesToScan
(
"com.sivalabs.demo"
);
        
Properties
 jpaProperties 
=
 
new
 
Properties
();
        jpaProperties
.
put
(
"hibernate.hbm2ddl.auto"
,
 env
.
getProperty
(
"hibernate.hbm2ddl.auto"
));
        factory
.
setJpaProperties
(
jpaProperties
);
        factory
.
afterPropertiesSet
();
        factory
.
setLoadTimeWeaver
(
new
 
InstrumentationLoadTimeWeaver
());
        
return
 factory
;
    
}
    
@Bean
    
public
 
HibernateExceptionTranslator
 hibernateExceptionTranslator
()
    
{
        
return
 
new
 
HibernateExceptionTranslator
();
    
}
    
@Bean
    
public
 
DataSource
 dataSource
()
    
{
        
BasicDataSource
 dataSource 
=
 
new
 
BasicDataSource
();
        dataSource
.
setDriverClassName
(
env
.
getProperty
(
"jdbc.driverClassName"
));
        dataSource
.
setUrl
(
env
.
getProperty
(
"jdbc.url"
));
        dataSource
.
setUsername
(
env
.
getProperty
(
"jdbc.username"
));
        dataSource
.
setPassword
(
env
.
getProperty
(
"jdbc.password"
));
        
return
 dataSource
;
    
}
    
@Bean
    
public
 
DataSourceInitializer
 dataSourceInitializer
(
DataSource
 dataSource
)
 
    
{
        
DataSourceInitializer
 dataSourceInitializer 
=
 
new
 
DataSourceInitializer
();
        dataSourceInitializer
.
setDataSource
(
dataSource
);
        
ResourceDatabasePopulator
 databasePopulator 
=
 
new
 
ResourceDatabasePopulator
();
        databasePopulator
.
addScript
(
new
 
ClassPathResource
(
"data.sql"
));
        dataSourceInitializer
.
setDatabasePopulator
(
databasePopulator
);
        dataSourceInitializer
.
setEnabled
(
Boolean
.
parseBoolean
(
initDatabase
));
        
return
 dataSourceInitializer
;
    
}
   
}

在AppConfig.java配置类中,我们完成了以下操作:

  • 使用 @Configuration注解标记为一个Spring配置类。
  • 使用 @EnableTransactionManagement开启基于注解的事务管理。
  • 配置 @EnableJpaRepositories指定去哪查找Spring Data JPA资源库(repository)。
  • 使用 @PropertySource注解和 PropertySourcesPlaceholderConfigurer Bean定义配置PropertyPlaceHolder bean从 application.properties文件加载配置。
  • 为DataSource、JAP的EntityManagerFactory和JpaTransactionManager定义Bean。
  • 配置DataSourceInitializer Bean,在应用启动时,执行 data.sql脚本来初始化数据库。

我们需要在 application.properties中完善配置,如下所示:

jdbc
.
driverClassName
=
com
.
mysql
.
jdbc
.
Driver
jdbc
.
url
=
jdbc
:
mysql
:
//localhost:3306/test
jdbc
.
username
=
root
jdbc
.
password
=
admin
init
-
db
=
true
hibernate
.
dialect
=
org
.
hibernate
.
dialect
.
MySQLDialect
hibernate
.
show_sql
=
true
hibernate
.
hbm2ddl
.
auto
=
update

我们可以创建一个简单的SQL脚本 data.sql来将演示数据填充到USER表中:

delete
 
from
 user
;
insert 
into
 user
(
id
,
 name
)
 values
(
1
,
'Siva'
);
insert 
into
 user
(
id
,
 name
)
 values
(
2
,
'Prasad'
);
insert 
into
 user
(
id
,
 name
)
 values
(
3
,
'Reddy'
);

我们可以创建一个附带基本配置的 log4j.properties文件,如下所示:

log4j
.
rootCategory
=
INFO
,
 stdout
log4j
.
appender
.
stdout
=
org
.
apache
.
log4j
.
ConsoleAppender
log4j
.
appender
.
stdout
.
layout
=
org
.
apache
.
log4j
.
PatternLayout
log4j
.
appender
.
stdout
.
layout
.
ConversionPattern
=%
5p
 
%
t 
%
c
{
2
}:%
L 
-
 
%
m
%
n
log4j
.
category
.
org
.
springframework
=
INFO
log4j
.
category
.
com
.
sivalabs
=
DEBUG

步骤3:配置Spring MVC Web层的Bean

我们必须配置Thymleaf的ViewResolver、处理静态资源的ResourceHandler和处理i18n的MessageSource等。

@Configuration
@ComponentScan
(
basePackages 
=
 
{
 
"com.sivalabs.demo"
})
 
@EnableWebMvc
public
 
class
 
WebMvcConfig
 
extends
 
WebMvcConfigurerAdapter
{
    
@Bean
    
public
 
TemplateResolver
 templateResolver
()
 
{
        
TemplateResolver
 templateResolver 
=
 
new
 
ServletContextTemplateResolver
();
        templateResolver
.
setPrefix
(
"/WEB-INF/views/"
);
        templateResolver
.
setSuffix
(
".html"
);
        templateResolver
.
setTemplateMode
(
"HTML5"
);
        templateResolver
.
setCacheable
(
false
);
        
return
 templateResolver
;
    
}
    
@Bean
    
public
 
SpringTemplateEngine
 templateEngine
()
 
{
        
SpringTemplateEngine
 templateEngine 
=
 
new
 
SpringTemplateEngine
();
        templateEngine
.
setTemplateResolver
(
templateResolver
());
        
return
 templateEngine
;
    
}
    
@Bean
    
public
 
ThymeleafViewResolver
 viewResolver
()
 
{
        
ThymeleafViewResolver
 thymeleafViewResolver 
=
 
new
 
ThymeleafViewResolver
();
        thymeleafViewResolver
.
setTemplateEngine
(
templateEngine
());
        thymeleafViewResolver
.
setCharacterEncoding
(
"UTF-8"
);
        
return
 thymeleafViewResolver
;
    
}
    
@Override
    
public
 
void
 addResourceHandlers
(
ResourceHandlerRegistry
 registry
)
    
{
        registry
.
addResourceHandler
(
"/resources/**"
).
addResourceLocations
(
"/resources/"
);
    
}
    
@Override
    
public
 
void
 configureDefaultServletHandling
(
DefaultServletHandlerConfigurer
 configurer
)
    
{
        configurer
.
enable
();
    
}
    
@Bean
(
name 
=
 
"messageSource"
)
    
public
 
MessageSource
 configureMessageSource
()
    
{
        
ReloadableResourceBundleMessageSource
 messageSource 
=
 
new
 
ReloadableResourceBundleMessageSource
();
        messageSource
.
setBasename
(
"classpath:messages"
);
        messageSource
.
setCacheSeconds
(
5
);
        messageSource
.
setDefaultEncoding
(
"UTF-8"
);
        
return
 messageSource
;
    
}
}

在WebMvcConfig.java配置类中,我们完成了以下操作:

  • 使用 @Configuration注解标记为一个Spring配置类。
  • 使用 @EnableWebMvc注解启用基于注解的Spring MVC配置。
  • 通过注册TemplateResolver、SpringTemplateEngine和`hymeleafViewResolver Bean来配置Thymeleaf视图解析器。
  • 注册ResourceHandler Bean将以URI为 /resource/**的静态资源请求定位到 /resource/目录下。
  • 配置MessageSource bean从classpath下加载messages-{国家代码}.properties文件来加载i18n配置。

现在我们没有配置任何i18n内容,所以需要在 src/main/resources文件夹下创建一个空的 messages.properties文件。

步骤4:注册Spring MVC的前端控制器DispatcherServlet

在Servlet 3.x规范之前,我们必须在web.xml中注册Servlet/Filter。由于当前是Servlet 3.x规范,我们可以使用ServletContainerInitializer以编程的方式注册Servlet /Filter。

Spring MVC提供了一个惯例类AbstractAnnotationConfigDispatcherServletInitializer来注册DispatcherServlet。


public
 
class
 
SpringWebAppInitializer
 
extends
 
AbstractAnnotationConfigDispatcherServletInitializer
{
    
@Override
    
protected
 
Class
<?>[]
 getRootConfigClasses
()
    
{
        
return
 
new
 
Class
<?>[]
 
{
 
AppConfig
.
class
};
    
}
    
@Override
    
protected
 
Class
<?>[]
 getServletConfigClasses
()
    
{
        
return
 
new
 
Class
<?>[]
 
{
 
WebMvcConfig
.
class
 
};
    
}
    
@Override
    
protected
 
String
[]
 getServletMappings
()
    
{
        
return
 
new
 
String
[]
 
{
 
"/"
 
};
    
}
    
@Override
    
protected
 
Filter
[]
 getServletFilters
()
 
{
       
return
 
new
 
Filter
[]{
 
new
 
OpenEntityManagerInViewFilter
()
 
};
    
}
}

在SpringWebAppInitializer.java配置类中,我们完成了以下操作:

  • 我们将 AppConfig.class配置为RootConfigurationClass,它将成为包含了所有子上下文(DispatcherServlet)共享的Bean定义的父ApplicationContext。
  • 我们将 WebMvcConfig.class配置为ServletConfigClass,它是包含了WebMvc Bean定义的子ApplicationContext。
  • 我们将 /配置为ServletMapping,这意味所有的请求将由DispatcherServlet处理。
  • 我们将OpenEntityManagerInViewFilter注册为Servlet过滤器,以便我们在渲染视图时可以延迟加载JPA Entity的延迟集合。

步骤5:创建一个JPA实体和Spring Data JPA资源库

为User实体创建一个JPA实体User.java和一个Spring Data JPA资源库。

@Entity
public
 
class
 
User
{
    
@Id
 
@GeneratedValue
(
strategy
=
GenerationType
.
AUTO
)
    
private
 
Integer
 id
;
    
private
 
String
 name
;
    
//setters and getters
}
public
 
interface
 
UserRepository
 
extends
 
JpaRepository
<
User
,
 
Integer
>
{
}

步骤6:创建一个Spring MVC控制器

创建一个Spring MVC控制器来处理URL为 /,并渲染一个用户列表。

@Controller
public
 
class
 
HomeController
{
    
@Autowired
 
UserRepository
 userRepo
;
    
@RequestMapping
(
"/"
)
    
public
 
String
 home
(
Model
 model
)
    
{
        model
.
addAttribute
(
"users"
,
 userRepo
.
findAll
());
        
return
 
"index"
;
    
}
}

步骤7:创建一个Thymeleaf视图/WEB-INF/views/index.html来渲染用户列表

<!DOCTYPE html>
<html
 
xmlns
=
"http://www.w3.org/1999/xhtml"
      
xmlns:th
=
"http://www.thymeleaf.org"
>
<head>
<meta
 
charset
=
"utf-8"
/>
<title>
Home
</title>
</head>
<body>
    
<table>
        
<thead>
            
<tr>
                
<th>
Id
</th>
                
<th>
Name
</th>
            
</tr>
        
</thead>
        
<tbody>
            
<tr
 
th:each
=
"user : ${users}"
>
                
<td
 
th:text
=
"${user.id}"
>
Id
</td>
                
<td
 
th:text
=
"${user.name}"
>
Name
</td>
            
</tr>
        
</tbody>
    
</table>
</body>
</html>

我们都配置好了,可以运行应用了。但在此之前,我们需要在您的IDE中下载并配置像Tomcat、Jetty或者Wildfly等服务器。

您可以下载Tomcat 8并配置在您喜欢的IDE中,之后运行应用并将浏览器指向 http://localhost:8080/springmvc-jpa-demo。您应该看到一个以表格形式展示的用户详细信息列表。

Yay…( •̀ ω •́ )y,我们做到了。

但是等等,做了那么多的工作仅仅是为了从数据库中获取用户信息然后展示一个列表?

让我们诚实公平地来看待,所有的这些配置不仅仅是为了这次示例,这些配置也是其他应用的基础。

但我还是想说,如果您想早点起床跑步,这有太多的工作要做。

另一个问题是,假设您想要开发另一个Spring MVC应用,您会使用类似的技术栈?

好,您要做的就是复制粘贴配置并调整它。对么?但请记住一件事:如果您一次又一次地做同样的事情,您应该寻找一种自动化的方式来完成它。

除了一遍又一遍地编写相同的配置,您还能发现其他问题么?

这样吧,让我列出我从中发现的问题。

  • 您需要寻找特定版本的Spring以便完全兼容所有的库,并进行配置。
  • 我们花费了95%的时间以同样的方式配置DataSource、EntityManagerFactory和TransactionManager等bean。如果Spring能自动帮我们完成这些事,是不是非常棒?
  • 同样,我们大多时候以同样的方式配置Spring MVC的bean,比如ViewResolver、MessageResource等。

如果Spring可以自动帮我做这些事情,那真的非常棒!!!

想象一下,如果Spring能够自动配置bean呢?如果您可以使用简单的自定义配置来定义自动配置又将怎么样?

例如,您可以将DispatcherServlet的url-pattern映射到 /app/,而不是 /。您可以将Theymeleaf视图放在 /WEB-INF/template/文件夹下,而不是放在 /WEB-INF/views中。

所以基本上您希望Spring能自动执行这些操作,但是它有没有提供一个简单灵活的方式来覆盖掉默认配置呢?

很好,您即将进入Spring Boot的世界,您将梦想成真!

快速尝试Sprig Boot

欢迎来到Spring Boot世界!Spring Boot正是您一直在寻找的。它可以自动为您完成某些事情,但如果有必要,您可以覆盖掉默认配置。

与拿理论解释相比,我更喜欢通过案例来讲解。

步骤1:创建一个基于Maven的Spring Boot应用

创建一个Maven项目并配置如下依赖:

<?
xml version
=
"1.0"
 encoding
=
"UTF-8"
?>
<project
 
xmlns
=
"http://maven.apache.org/POM/4.0.0"
        
xmlns:xsi
=
"http://www.w3.org/2001/XMLSchema-instance"
        
xsi:schemaLocation
=
"http://maven.apache.org/POM/4.0.0 
                        http://maven.apache.org/maven-v4_0_0.xsd"
>
    
<modelVersion>
4.0.0
</modelVersion>
    
<groupId>
com.sivalabs
</groupId>
    
<artifactId>
hello-springboot
</artifactId>
    
<packaging>
jar
</packaging>
    
<version>
1.0-SNAPSHOT
</version>
    
<name>
hello-springboot
</name>
    
<parent>
        
<groupId>
org.springframework.boot
</groupId>
        
<artifactId>
spring-boot-starter-parent
</artifactId>
        
<version>
1.3.2.RELEASE
</version>
    
</parent>
    
<properties>
        
<project.build.sourceEncoding>
UTF-8
</project.build.sourceEncoding>
        
<java.version>
1.8
</java.version>
    
</properties>
    
<dependencies>
        
<dependency>
            
<groupId>
org.springframework.boot
</groupId>
            
<artifactId>
spring-boot-starter-test
</artifactId>
        
</dependency>
        
<dependency>
            
<groupId>
org.springframework.boot
</groupId>
            
<artifactId>
spring-boot-starter-data-jpa
</artifactId>
        
</dependency>
        
<dependency>
            
<groupId>
org.springframework.boot
</groupId>
            
<artifactId>
spring-boot-starter-web
</artifactId>
        
</dependency>
        
<dependency>
            
<groupId>
org.springframework.boot
</groupId>
            
<artifactId>
spring-boot-starter-thymeleaf
</artifactId>
        
</dependency>
        
<dependency>
            
<groupId>
org.springframework.boot
</groupId>
            
<artifactId>
spring-boot-devtools
</artifactId>
        
</dependency>
        
<dependency>
            
<groupId>
mysql
</groupId>
            
<artifactId>
mysql-connector-java
</artifactId>
        
</dependency>
    
</dependencies>
</project>

哇!我们的pom.xml文件一下子变小了许多!

步骤2:如下在application.properties中配置DataSoure/JPA


spring
.
datasource
.
driver
-
class
-
name
=
com
.
mysql
.
jdbc
.
Driver
spring
.
datasource
.
url
=
jdbc
:
mysql
:
//localhost:3306/test
spring
.
datasource
.
username
=
root
spring
.
datasource
.
password
=
admin
spring
.
datasource
.
initialize
=
true
spring
.
jpa
.
hibernate
.
ddl
-
auto
=
update
spring
.
jpa
.
show
-
sql
=
true

您可以将相同的data.sql文件拷贝到 src/main/resources文件加中。

步骤3:为实体创建一个JPA实体和Spring Data JPA资源库接口

与 springmvc-jpa-demo应用一样,创建User.java、UserRepository.java和HomeController.java。

步骤4:创建用于显示用户列表的Thymeleaf视图

从 springmvc-jpa-demo项目中复制之前创建的 /WEB-INF/views/index.html到 src/main/resources/template文件夹中。

步骤5:创建Spring Boot入口类

创建一个含有 main方法的Java类Application.java,如下所示:

@SpringBootApplication
public
 
class
 
Application
{
    
public
 
static
 
void
 main
(
String
[]
 args
)
    
{
        
SpringApplication
.
run
(
Application
.
class
,
 args
);
    
}
}

现在把 Application.java当作一个Java应用运行,并将您的浏览其指向 http://localhost:8080/。

您应该可以看到以表格的形式展示的用户列表,真的很酷!

很好,我听到您在喊:“到底发生了什么事???”。

让我解释刚刚所发生的事情。

  1. 简单的依赖管理
  • 首先要注意的是我们正在使用一些名为 spring-boot-start-*的依赖。记住我说过我花费95%的时间来配置同样的配置。当您在开发Spring MVC应用时添加了 spring-boot-start-web依赖,它已经包含了常用的一些库,比如spring-webmvc、jackson-json、validation-api和tomcat等。
  • 我们添加了 spring-boot-starter-data-jpa依赖。它包含了所有的 spring-data-jpa依赖,并且还添加了Hibernate库,因为很多应用使用Hibernate作为JPA的实现。
  1. 自动配置
  • spring-boot-starter-web不仅添加了这些库,还配置了经常被注册的bean,比如DispatcherServlet、ResourceHandler和MessageSource等bean,并且应用了合适的默认配置。
  • 我们还添加了 spring-boot-starter-Thymeleaf,它不仅添加了Thymeleaf的依赖,还自动配置了ThymeleafViewResolver bean。
  • 虽然我们没有定义任何DataSource、EntityManagerFactory和TransactionManager等bean,但它们可以被自动创建。怎么样?如果在classpath下没有任何内存数据库驱动,如H2或者HSQL,那么Spring Boot将自动创建一个内存数据库的DataSource,然后应用合理的默认配置自动注册EntityManagerFactory和TransactionManager等bean。但是我们正在使用MySQL,所以我们需要明确提供MySQL的连接信息。我们已经在 application.properties文件中配置了MySQL连接信息,Spring Boot将应用这些配置来创建DataSource。
  1. 支持嵌入式Servlet容器
  • 最重要且最让人惊讶的是,我们创建了一个简单的Java类,标记了一个神奇的注解 @SpringApplication,它有一个main方法。通过运行main方法,我们可以运行这个应用并通过 http://localhost:8080/来访问。

Servlet容器来自哪里?

我们添加了 spring-boot-starter-web,它会自动引入 spring-boot-starter-tomcat。当我们运行main()方法时,它将tomcat作为一个嵌入式容器启动,我们不需要部署我们的应用到外部安装好的tomcat上。

顺便说一句,您看到我们在pom.xml中配置的打包类型是jar而不是war,真有趣!

很好,但是如果我想使用jetty服务器而不是tomcat呢?很简单,只需要从 spring-boot-starter-web中排除掉 sprig-boot-starter-tomcat,并包含 spring-boot-starter-jetty依赖即可。

就是这样。

但是,这看起来真的很神奇!!!

我可以想象此时您在想什么。您正在感叹Spring Boot真的很酷,它为我自动完成了很多事情。但是,我还没了完全明白它幕后是怎样工作的,对不对?

我可以理解,观看魔术表演是非常有趣的,但软件开发则不一样,不用担心,未来我们将看到各种新奇的东西,并在以后的文章中详细地解释它们幕后的工作原理。很遗憾的是,我不能在这篇文章中把所有的东西都教给您。

总结

在本文中,我们快速介绍了各种Spring配置的样式,并了解了配置Spring应用的复杂型。此外,我们通过创建一个简单的web应用来快速了解Spring Boot。

推荐阅读

  • Spring框架中的设计模式(一)
  • Spring框架中的设计模式(二)
  • Spring框架中的设计模式(三)
  • Spring框架中的设计模式(四)
  • 程序员你为什么这么累?
  • 程序员你为什么这么累【续】:编码习惯之接口定义
  • 程序员你为什么这么累【续】:编码习惯之Controller规范
  • 程序员你为什么这么累【续】:编码习惯之日志建议 长按指纹 一键关注