SpringBoot约定大于配置

SpringBoot约定大于配置

 

Spring官方网站本身使用Spring框架开发，随着功能以及业务逻辑的日益复杂，应用伴随着大量的XML配置文件以及复杂的Bean依赖关系。随着Spring 3.0的发布，Spring IO团队逐渐开始摆脱XML配置文件，并且在开发过程中大量使用“约定优先配置”（convention over configuration）的思想来摆脱Spring框架中各类繁复纷杂的配置（即时是Java Config）。

Spring Boot正是在这样的一个背景下被抽象出来的开发框架，它本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于Spring框架的应用程序。也就是说，它并不是用来替代Spring的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具。同时它集成了大量常用的第三方库配置（例如Jackson, JDBC, Mongo, Redis, Mail等等），Spring Boot应用中这些第三方库几乎可以零配置的开箱即用（out-of-the-box），大部分的Spring Boot应用都只需要非常少量的配置代码，开发者能够更加专注于业务逻辑。

 

Spring boot和maven的约定大于配置体现在哪些方面

 

spring boot和maven的约定大于配置体现在哪些方面?

两者都遵从了约定大于配置的路线

 

约定优于配置体现点：

1.maven的目录文件结构

1）默认有resources文件夹,存放资源配置文件。src-main-resources,src-main-java

默认的编译生成的类都在targetwen

2）默认有target文件夹，将生成class文件盒编程生成的jar存放在target文件夹下

 

2.spring boot默认的配置文件必须是，也只能是application.命名的yml文件或者properties文件，且唯一

1）spring boot默认只会去src-main-resources文件夹下去找application配置文件

 

快速开始

传统基于Spring的Java Web应用，需要配置web.xml, applicationContext.xml，将应用打成war包放入应用服务器(Tomcat, Jetty等)中并运行。如果基于Spring Boot，这一切都将变得简单：

以Maven项目为例，首先引入Spring Boot的开发依赖：

 
 

   
   

    
    

   
   
   
   

    
    

     
     <parent>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     <groupId>org.springframework.boot
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     <artifactId>spring-boot-starter-parent
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     <version>1.4.1.RELEASE
     
     </version>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     </parent>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     <dependencies>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     <dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     <groupId>org.springframework.boot
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     <artifactId>spring-boot-starter-web
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     </dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     </dependencies>
    
    
   
   
 
 

编写一个类包含处理HTTP请求的方法以及一个main()函数：

 
 

   
   

    
    

   
   
   
   

    
    

     
     @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);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

启动main函数后，在控制台中可以发现启动了一个Tomcat容器，一个基于Spring MVC的应用也同时启动起来，这时访问[[http://localhost:8080](http://localhost:8080)]([http://localhost:8080](http://localhost:8080))就可以看到Hello World!出现在浏览器中了。

关于Spring MVC，请参考Spring MVC快速入门。

 

Spring Boot初探

在Maven依赖中引入了spring-boot-starter-web，它包含了Spring Boot预定义的一些Web开发的常用依赖:

• spring-web, spring-webmvc Spring WebMvc框架
• tomcat-embed-* 内嵌Tomcat容器
• jackson 处理json数据
• spring-* Spring框架
• spring-boot-autoconfigure Spring Boot提供的自动配置功能

Java代码中没有任何配置，和传统的Spring应用相比，多了两个我们不认识的符号：

• @EnableAutoConfiguration
• @SpringApplication

它们都是由Spring Boot框架提供。在SpringApplication.run()方法执行后，Spring Boot的autoconfigure发现这是一个Web应用（根据类路径上的依赖确定），于是在内嵌的Tomcat容器中启动了一个Spring的应用上下文，并且监听默认的tcp端口8080（默认约定）。同时在Spring Context中根据默认的约定配置了Spring WebMvc：

• Servlet容器默认的Context路径是/
• DispatherServlet匹配的路径(servlet-mapping中的url-patterns)是/*
• @ComponentScan路径被默认设置为SampleController的同名package，也就是该package下的所有@Controller，@Service, @Component, @Repository都会被实例化后并加入Spring Context中。

没有一行配置代码、也没有web.xml。基于Spring Boot的应用在大多数情况下都不需要我们去显式地声明各类配置，而是将最常用的默认配置作为约定，在不声明的情况下也能适应大多数的开发场景。

 

实例：数据库访问

除了最基本的Web框架，另一种非常普遍的开发场景是访问数据库。在传统的Spring应用中，访问数据库我们需要配置：

• 类路径上添加数据库访问驱动
• 实例化DataSource对象，指定数据库url, username, password等信息
• 注入JdbcTemplate对象，如果使用Hibernate，Mybatis等框架，还需要进一步配置框架信息

在Spring Boot中，上述过程会被简化。首先在Maven项目依赖中定义：

 
 

   
   

    
    

   
   
   
   

    
    

     
     <dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     <groupId>org.springframework.boot
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     <artifactId>spring-boot-starter-web-jdbc
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     </dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     <dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     <groupId>com.h2database
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     <artifactId>h2
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     </dependency>
    
    
   
   
 
 

spring-boot-starter-web-jdbc引入了spring-jdbc依赖，h2是一个内存关系型数据库。在引入了这些依赖并启动Spring Boot应用程序后，autoconfigure发现spring-jdbc位于类路径中，于是：

• 根据类路径上的JDBC驱动类型（这里是h2，预定义了derby, sqlite, mysql, oracle, sqlserver等等），创建一个DataSource连接池对象，本例中的h2是内存数据库，无需任何配置，如果是mysql, oracle等类型的数据库需要开发者配置相关信息。
• 在Spring Context中创建一个JdbcTemplate对象（使用DataSource初始化）

接下来开发者的工作就非常简单了，在业务逻辑中直接引入JdbcTemplate即可：

 
 

   
   

    
    

   
   
   
   

    
    

     
     @Service
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class MyService {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     @Autowired
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         JdbcTemplate jdbcTemplate;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

除了spring-jdbc，Spring Boot还能够支持JPA，以及各种NoSQL数据库——包括MongoDB，Redis，全文索引工具elasticsearch, solr等等。

 

配置

Spring Boot最大的特色是“约定优先配置”，大量的默认配置对开发者十分的友好。但是在实际的应用开发过程中，默认配置不可能满足所有场景，同时用户也需要配置一些必须的配置项——例如数据库连接信息。Spring Boot的配置系统能够让开发者快速的覆盖默认约定，同时支持Properties配置文件和YAML配置文件两种格式，默认情况下Spring Boot加载类路径上的application.properties或application.yml文件，例如：

 
 

   
   

    
    

   
   
   
   

    
    

     
     spring.datasource.url=jdbc:mysql:
     
     //localhost/test
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     spring.datasource.username=dbuser
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     spring.datasource.password=dbpass
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     spring.datasource.driver-
     
     class-name=com.mysql.jdbc.Driver
    
    
   
   
 
 

YAML格式更加简洁：

 
 

   
   

    
    

   
   
   
   

    
    

     
     spring:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
       datasource:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         url: jdbc:mysql:
     
     //localhost/test
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         username: dbuser
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         password: dbpass
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         driver-
     
     class: com.mysql.jdbc.Driver
    
    
   
   
 
 

一旦发现这些信息，Spring Boot就会根据它们创建DataSource对象。另一个常见的配置场景是Web应用服务器：

 
 

   
   

    
    

   
   
   
   

    
    

     
     # Server settings (ServerProperties)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     server:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
       port: 
     
     8080
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
       address: 
     
     127.0
     
     .0
     
     .1
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
       sessionTimeout: 
     
     30
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
       contextPath: /
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
  
     
     # Tomcat specifics
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
       tomcat:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         accessLogEnabled: 
     
     false
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         protocolHeader: x-forwarded-proto
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         remoteIpHeader: x-forwarded-
     
     for
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         basedir:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         backgroundProcessorDelay: 
     
     30 
     
     # secs
    
    
   
   
 
 

通过port和address可以修改服务器监听的地址和端口，sessionTimeout配置session过期时间（再也不用修改web.xml了，因为它根本不存在）。同时如果在生产环境中使用内嵌Tomcat，当然希望能够配置它的日志、线程池等信息，这些现在都可以通过Spring Boot的属性文件配置，而不再需要再对生产环境中的Tomcat实例进行单独的配置管理了。

 

@EnableAutoCongiguration

从Spring 3.0开始，为了替代繁琐的XML配置，引入了@Enable...注解对@Configuration类进行修饰以达到和XML配置相同的效果。想必不少开发者已经使用过类似注解：

• @EnableTransactionManagement开启Spring事务管理，相当于XMl中的<tx:*>
• @EnableWebMvc使用Spring MVC框架的一些默认配置
• @EnableScheduling会初始化一个Scheduler用于执行定时任务和异步任务

Spring Boot提供的@EnableAutoCongiguration似乎功能更加强大，一旦加上，上述所有的配置似乎都被包含进来而无需开发者显式声明。它究竟是如何做到的呢，先看看它的定义：

 
 

   
   

    
    

   
   
   
   

    
    

     
     @
     
     Target(
     
     ElementType.
     
     TYPE)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @Retention(RetentionPolicy.RUNTIME)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @Documented
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @Import({ 
     
     EnableAutoConfigurationImportSelector
     
     .class,
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     AutoConfigurationPackages
     
     .Registrar
     
     .class })
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public @
     
     interface EnableAutoConfiguration {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     /**
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
          * Exclude specific auto-configuration classes such that they will never be applied.
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
          */
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     Class<?>
     
     [] 
     
     exclude() 
     
     default {};
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

EnableAutoConfigurationImportSelector使用的是spring-core模块中的SpringFactoriesLoader#loadFactoryNames()方法，它的作用是在类路径上扫描META-INF/spring.factories文件中定义的类：

 
 

   
   

    
    

   
   
   
   

    
    

     
     # Initializers
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.context.ApplicationContextInitializer=\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # Auto Configure
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.MessageSourceAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.data.JpaRepositoriesAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.data.MongoRepositoriesAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.redis.RedisAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.jms.JmsTemplateAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.mongo.MongoTemplateAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration
    
    
   
   
 
 

实际上这就是Spring Boot会自动配置的一些对象，例如前面提到的Web框架由EmbeddedServletContainerAutoConfiguration, DispatcherServletAutoConfiguration, ServerPropertiesAutoConfiguration等配置完成，而DataSource的自动配置则是由DataSourceAutoConfiguration完成。现在我们以Mongo的配置MongoAutoConfiguration为例，来探索Spring Boot是如何完成这些配置的：

 
 

   
   

    
    

   
   
   
   

    
    

     
     @Configuration
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @ConditionalOnClass(Mongo.class)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     @EnableConfigurationProperties(MongoProperties.class)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class MongoAutoConfiguration {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     @Autowired
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private MongoProperties properties;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private Mongo mongo;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     @PreDestroy
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void close() throws UnknownHostException {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     if (
     
     this.mongo != 
     
     null) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     this.mongo.close();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     @Bean
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     @ConditionalOnMissingBean
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public Mongo mongo() throws UnknownHostException {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     this.mongo = 
     
     this.properties.createMongoClient();
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     return 
     
     this.mongo;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

首先这是一个Spring的配置@Configuration，它定义了我们访问Mongo需要的@Bean，如果这个@Configuration被Spring Context扫描到，那么Context中自然也就有两个一个Mongo对象能够直接为开发者所用。

但是注意到其它几个Spring注解：

• @ConditionOnClass表明该@Configuration仅仅在一定条件下才会被加载，这里的条件是Mongo.class位于类路径上
• @EnableConfigurationProperties将Spring Boot的配置文件（application.properties）中的spring.data.mongodb.*属性映射为MongoProperties并注入到MongoAutoConfiguration中。
• @ConditionalOnMissingBean说明Spring Boot仅仅在当前上下文中不存在Mongo对象时，才会实例化一个Bean。这个逻辑也体现了Spring Boot的另外一个特性——自定义的Bean优先于框架的默认配置，我们如果显式的在业务代码中定义了一个Mongo对象，那么Spring Boot就不再创建。

接下来看一看MongoProperties：

 
 

   
   

    
    

   
   
   
   

    
    

     
     @ConfigurationProperties(prefix = 
     
     "spring.data.mongodb")
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class MongoProperties {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private String host;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private 
     
     int port = DBPort.PORT;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private String uri = 
     
     "mongodb://localhost/test";
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private String database;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     // ... getters/ setters omitted
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

显然，它就是以spring.data.mongodb作为前缀的属性，然后通过名字直接映射为对象的属性，同时还包含了一些默认值。如果不配置，那么mongo.uri就是mongodb://localhost/test。

 

Production特性

从前面的例子可以看出，Spring Boot能够非常快速的做出一些原型应用，但是它同样可以被用于生产环境。为了添加生产环境特性支持，需要在Maven依赖中引入：

 
 

   
   

    
    

   
   
   
   

    
    

     
     <dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     <groupId>org.springframework.boot
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     <artifactId>spring-boot-starter-actuator
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     </dependency>
    
    
   
   
 
 

加入actuator依赖后，应用启动后会创建一些基于Web的Endpoint：

• /autoconfig，用来查看Spring Boot的框架自动配置信息，哪些被自动配置，哪些没有，原因是什么。
• /beans，显示应用上下文的Bean列表
• /dump，显示线程dump信息
• /health，应用健康状况检查
• /metrics
• /shutdown, 默认没有打开
• /trace

 

SpringBoot与SpringMVC的区别

Spring 框架就像一个家族，有众多衍生产品例如 boot、security、jpa等等。但他们的基础都是Spring 的 ioc和 aop ioc 提供了依赖注入的容器 aop ，解决了面向横切面的编程，然后在此两者的基础上实现了其他延伸产品的高级功能。Spring MVC是基于 Servlet 的一个 MVC 框架 主要解决 WEB 开发的问题，因为 Spring 的配置非常复杂，各种XML、 JavaConfig、hin处理起来比较繁琐。于是为了简化开发者的使用，从而创造性地推出了Spring boot，约定优于配置，简化了spring的配置流程。

说得更简便一些：Spring 最初利用“工厂模式”（DI）和“代理模式”（AOP）解耦应用组件。大家觉得挺好用，于是按照这种模式搞了一个 MVC框架（一些用Spring 解耦的组件），用开发 web 应用（ SpringMVC ）。然后有发现每次开发都写很多样板代码，为了简化工作流程，于是开发出了一些“懒人整合包”（starter），这套就是 Spring Boot。

 

Spring MVC的功能

Spring MVC提供了一种轻度耦合的方式来开发web应用。

Spring MVC是Spring的一个模块，式一个web框架。通过Dispatcher Servlet, ModelAndView 和 View Resolver，开发web应用变得很容易。解决的问题领域是网站应用程序或者服务开发——URL路由、Session、模板引擎、静态Web资源等等。

 

Spring Boot的功能

Spring Boot实现了自动配置，降低了项目搭建的复杂度。

众所周知Spring框架需要进行大量的配置，Spring Boot引入自动配置的概念，让项目设置变得很容易。Spring Boot本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于Spring框架的应用程序。也就是说，它并不是用来替代Spring的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具。同时它集成了大量常用的第三方库配置(例如Jackson, JDBC, Mongo, Redis, Mail等等)，Spring Boot应用中这些第三方库几乎可以零配置的开箱即用(out-of-the-box)，大部分的Spring Boot应用都只需要非常少量的配置代码，开发者能够更加专注于业务逻辑。

Spring Boot只是承载者，辅助你简化项目搭建过程的。如果承载的是WEB项目，使用Spring MVC作为MVC框架，那么工作流程和你上面描述的是完全一样的，因为这部分工作是Spring MVC做的而不是Spring Boot。

对使用者来说，换用Spring Boot以后，项目初始化方法变了，配置文件变了，另外就是不需要单独安装Tomcat这类容器服务器了，maven打出jar包直接跑起来就是个网站，但你最核心的业务逻辑实现与业务流程实现没有任何变化。

所以，用最简练的语言概括就是：

Spring 是一个“引擎”；

Spring MVC 是基于Spring的一个 MVC 框架 ；

Spring Boot 是基于Spring4+的条件注册的一套快速开发整合包。

 

Spring-boot-starter常用依赖模块

SpringBoot的2大优点：

1.基于Spring框架的“约定优先于配置（COC）”理念以及最佳实践之路。
2.针对日常企业应用研发各种场景的Spring-boot-starter自动配置依赖模块，且“开箱即用”（约定spring-boot-starter- 作为命名前缀，都位于org.springframenwork.boot包或者命名空间下）。

应用日志和spring-boot-starter-logging

常见的日志系统大致有：java.util默认提供的日志支持，log4j,log4j2,commons logging,下面的spring-boot-starter-logging也是其中的一种。

maven依赖：

 
 

   
   

    
    

   
   
   
   

    
    
        
     
     <dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <groupId>org.springframework.boot
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <artifactId>spring-boot-starter-logging
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     </dependency>
    
    
   
   
 
 

springBoot将使用logback作为应用日志的框架，程序启动时，由org.springframework.boot.logging-Logging-Application-Lisetener根据情况初始化并使用。
如果要想改变springBoot提供的应用日志设定，可以通过以下原则：

• 遵循logback的约定，在classpath中使用自己定制的logback.xml配置文件。
• 在文件系统的任意一个位置提供自己的logback.xml配置文件，然后通过logging.config配置项指向这个配置文件然后引用它，例如在application.properties中指定如下的配置：

logging.config=/{some.path.you.defined}/any-logfile-name-I-like.log}

 
 

快速web应用开发与spring-boot-starter-web

maven依赖：

 
 

   
   

    
    

   
   
   
   

    
    
       
     
     <dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <groupId>org.springframework.boot
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <artifactId>spring-boot-starter-web
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     </dependency>
    
    
   
   
 
 

在当下项目运行mvn spring-boot:run就可以直接启用一个嵌套了tomcat的web应用。
如果没有提供任何服务的Cotroller,访问任何路径都会返回一个springBoot默认的错误页面（Whitelabel error page）。

嵌入式Web容器层面的约定和定制

spring-boot-starter-web默认使用嵌套式的Tomcat作为Web容器对外提供HTTP服务，默认端口8080对外监听和提供服务。
我们同样可以使用spring-boot-starter-jetty或者spring-boot-starter-undertow作为Web容器。
想改变默认的配置端口，可以在application.properties中指定：

server.port = 9000(the port number you want)

 
 

类似的配置还有：

 
 

   
   

    
    

   
   
   
   

    
    

     
     server
     
     .address
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     server
     
     .ssl.*
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     server
     
     .tomcat.*
    
    
   
   
 
 

如果上诉仍然没有办法满足要求，springBoot支持对嵌入式的Web容器实例进行定制，可以通过向IoC容器中注册一个EmbeddedServletContainerCustomizer类型的组件来对嵌入式的Web容器进行定制

 
 

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class UnveilSpringEmbeddedTomcatCustomizer implements EmbeddedServletContainer{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     public void customize(ConfigurableEmbeddedServletContainer container){
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 container.setPort(
     
     9999);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 container.setContextPath(
     
     "C\\hello");
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                                ...
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   
 
 

数据访问与spring-boot-starter-jdbc

maven依赖：

 
 

   
   

    
    

   
   
   
   

    
    
    
     
     <dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     <groupId>org.springframework.boot
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     <artifactId>spring-boot-starter-jdbc
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     </dependency>
    
    
   
   
 
 

默认情况下，当我们没有配置任何DataSource,SpringBoot会为我们自动配置一个DataSource，这种自动配置的方式一般适用于测试，开发还是自己配置一个DataSource的实例比较好。
如果我们的工程只依赖一个数据库，那么，使用DataSource自动配置模块提供的参数是最方便的：

 
 

   
   

    
    

   
   
   
   

    
    

     
     spring.datasource.url=jdbc:mysql:
     
     //{datasource host}:3306/{databaseName}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     spring.datasource.username={database username}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     spring.datasource.passwd={database passwd}
    
    
   
   
 
 

还会自动配置的有：JdbcTemplate DateSourceTransactionManager等，我们只要在使用的时候注入（@Autowired）就好了
此外，SpringBoot还支持的数据库有spring-boot-data-jpa spring-boot-data-mongodb

spring-boot-starter-aop应用及其使用场景

AOP:Aspect Oriented Programming,面向切面编程

maven依赖：

 
 

   
   

    
    

   
   
   
   

    
    
    
     
     <dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     <groupId>org.springframework.boot
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     <artifactId>spring-boot-starter-aop
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     </dependency>
    
    
   
   
 
 

spring-boot-starter-aop主要由2部分组成：
1.位于spring-boot-autoconfigure的org.sringframework.boot.autoconfigure.aop.AopAutoConfiguration提供的@Configuration配置类和相应的配置项，即下面的2个配置项：

 
 

   
   

    
    

   
   
   
   

    
    

     
     spring.aop.auto=
     
     true
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     spring.aop.proxy-target-
     
     class=
     
     false
    
    
   
   
 
 

2.spring-boot-starter-aop模块提供了针对spring-aop aspectjrt 和aspectjweaver的依赖

应用安全与spring-boot-starter-security

spring-boot-starter-security 主要面向的是Web应用开发，配合spring-boot-starter-web,所以，对应的maven依赖如下：

 
 

   
   

    
    

   
   
   
   

    
    
       
     
     <dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <groupId>org.springframework.boot
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <artifactId>spring-boot-starter-web
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     </dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     <dependency>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <groupId>org.springframework.boot
     
     </groupId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     <artifactId>spring-boot-starter-security
     
     </artifactId>
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     </dependency>
    
    
   
   
 
 

spring-boot-starter-security 默认会提供一个基于HTTP Basic认证的安全防护策略，默认用户为user,访问密码则在当前web应用启动的时候，打印到控制台，要想定制，则在配置文件如下进行配置：

 
 

   
   

    
    

   
   
   
   

    
    

     
     security.user.
     
     name=
     
     {username}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     security.user.password=
     
     {passwd}
    
    
   
   
 
 

除此之外，spring-boot-starter-security还会默认启动一些必要的Web安全防护，比如针对XSS CSRF等场针对Web应用的攻击，同时，也会将一些常见的静态资源路径排除在安全防护之外。

AuthenticationManager AccessDecisionManager AbstractSecurityInterceptor被称为Spring Security的基础铁三角，前2者负责制定规则， AbstractSecurityInterceptor负责执行。我们常见的Filter类就可以定制和扩展SpringSecurity的防护机制。

进一步定制spring-boot-starter-security

上诉使用SecurityProperties暴露的配置项，即以security.*对spring-boot-starter-security进行简单的配置，还可以通过给出一个继承了WebSecurityConfigurerAdapter的JavaConfig配置类对spring-boot-starter-security的行为进行更深级别的定制，例如：

• 使用其他的AuthenticationManager实例
• 对默认的HttpSecurity定义的资源访问的规则重新定义
• 对默认提供的WebSecurity行为进行调整
  一般配合@Order（SecurityProperties.ACCESS_OVERRIDE_ORDER）进行标注。

 

总结

Spring Boot是新一代Spring应用的开发框架，它能够快速的进行应用开发，让人忘记传统的繁琐配置，更加专注于业务逻辑。现在Spring官方文档中所有的Guide中的例子都是使用Spring Boot进行构建，这也是一个学习Spring, Spring Boot非常好的地方。如果想进一步深度学习Spring Boot，可以参考：

• Spring Boot Reference
• spring.io网站源码

 

参考来源：http://www.cnblogs.com/panxuejun/p/6710888.html  感谢原作者的文章贡献，如有侵权，请及时联系，以便删除

参考来源：​ https://www.jianshu.com/p/2093dd0168b9 ​ 感谢原作者的文章贡献，如有侵权，请及时联系，以便删除

参考来源：https://www.cnblogs.com/ThinkVenus/p/8026633.html 感谢原作者的文章贡献，如有侵权，请及时联系，以便删除

参考来源：https://www.tianmaying.com/tutorial/spring-boot-overview 感谢原作者的文章贡献，如有侵权，请及时联系，以便删除