超详细的Spring Boot入门笔记

1. spring Boot 入门 
Spring Boot是Spring社区较新的一个项目。该项目的目的是帮助开发者更容易的创建基于Spring的应用程序和服务,让更多人的人更快的对Spring进行入门体验,让 Java开发也能够实现Ruby on Rails那样的生产效率。为Spring生态系统提供了一种固定的、约定优于配置风格的框架。 
Spring Boot具有如下特性:

  • 为基于Spring的开发提供更快的入门体验

  • 开箱即用,没有代码生成,也无需XML配置。同时也可以修改默认值来满足特定的需求。

  • 提供了一些大型项目中常见的非功能性特性,如嵌入式服务器、安全、指标,健康检测、外部配置等。

  • Spring Boot并不是对Spring功能上的增强,而是提供了一种快速使用Spring的方式。

  • 1.1 简单例子 
    首先创建一个一般的Maven项目,有一个pom.xml和基本的src/main/java结构。

  • 1.1.1 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/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0modelVersion>
    
       <groupId>com.bjhstgroupId>
       <artifactId>Springboot1artifactId>
       <version>0.0.1-SNAPSHOTversion>
       <packaging>jarpackaging>
    
       <name>Springboot1name>
       <description>Demo project for Spring Bootdescription>
       
       <parent>
          <groupId>org.springframework.bootgroupId>
          <artifactId>spring-boot-starter-parentartifactId>
          <version>1.5.10.RELEASEversion>
          <relativePath/> 
       parent>
    
       <properties>
          <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
          <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
          <java.version>1.8java.version>
       properties>
    
       <dependencies>
          
          
          
          <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-webartifactId>
          dependency>
    
          <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-testartifactId>
             <scope>testscope>
          dependency>
          
          <dependency>
             <groupId>org.mybatis.spring.bootgroupId>
             <artifactId>mybatis-spring-boot-starterartifactId>
             <version>1.1.1version>
          dependency>
          
          <dependency>
             <groupId>mysqlgroupId>
             <artifactId>mysql-connector-javaartifactId>
             <version>5.1.21version>
          dependency>
       dependencies>
    
    
       <build>
          <plugins>
             <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
             plugin>
          plugins>
       build>
    
    
    project>
    1.1.2 对pom的说明 
    首先是增加了,增加父pom比较简单,而且spring-boot-starter-parent包含了大量配置好的依赖管理,在自己项目添加这些依赖的时候不需要写版本号。 
    使用父pom虽然简单,但是有些情况我们已经有父pom,不能直接增加时,可以通过如下方式:
  • <dependencyManagement>
    <dependencies>
       <dependency>
          
          <groupId>org.springframework.bootgroupId>
          <artifactId>spring-boot-dependenciesartifactId>
          <version>1.2.3.RELEASEversion>
          <type>pomtype>
          <scope>importscope><!—这个地方-->
       dependency>
    dependencies>
    dependencyManagement>
    1.1.3 关于java.version属性 
    上面pom.xml虽然没有出现这个属性,这里要特别提醒。 
    Spring默认使用jdk1.6,如果你想使用jdk1.8,你需要在pom.xml的属性里面添加java.version,如下:
  • <properties>
    <java.version>1.8java.version>
    properties>
    1.1.4 添加spring-boot-starter-web依赖 
    Spring通过添加spring-boot-starter-*这样的依赖就能支持具体的某个功能。 
    我们这个示例最终是要实现web功能,所以添加的是这个依赖。 
    更完整的功能列表可以查看:Using-boot-starter-poms
  • 1.1.5 添加spring-boot-maven-plugin插件 
    该插件支持多种功能,常用的有两种,第一种是打包项目为可执行的jar包。 
    在项目根目录下执行mvn package将会生成一个可执行的jar包,jar包中包含了所有依赖的jar包,只需要这一个jar包就可以运行程序,使用起来很方便。该命令执行后还会保留一个XXX.jar.original的jar包,包含了项目中单独的部分。 
    生成这个可执行的jar包后,在命令行执行java -jar xxxx.jar即可启动项目。 
    另外一个命令就是mvnspring-boot:run,可以直接使用tomcat(默认)启动项目。 
    在我们开发过程中,我们需要经常修改,为了避免重复启动项目,我们可以启用热部署。

    1.1.6 spring-loaded热部署 
    Spring-Loaded项目提供了强大的热部署功能,添加/删除/修改方法/字段/接口/枚举等代码的时候都可以热部署,速度很快,很方便。 
    想在Spring Boot中使用该功能非常简单,就是在spring-boot-maven-plugin插件下面添加依赖:


  •        
    <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>springloadedartifactId>
    <version>1.2.5.RELEASEversion>
    dependency>
    添加以后,通过mvnspring-boot:run启动就支持热部署了。 注意:使用热部署的时候,需要IDE编译类后才能生效,你可以打开自动编译功能,这样在你保存修改的时候,类就自动重新加载了。
  • 1.2 创建一个应用类 
    我们创建一个Application类:

  • 超详细的Spring Boot入门笔记_第1张图片

  • 1.2.1 注意 
    Spring Boot建议将我们main方法所在的这个主要的配置类配置在根包名下。

  • 超详细的Spring Boot入门笔记_第2张图片

  • 超详细的Spring Boot入门笔记_第3张图片

  • 在Application.java中有main方法。 因为默认和包有关的注解,默认包名都是当前类所在的包,例如@ComponentScan, @EntityScan, @SpringBootApplication注解。(都是安当前Application.java所在包作为Scan扫描)

    1.2.2 @RestController 
    因为我们例子是写一个web应用,因此写的这个注解,这个注解相当于同时添加@Controller和@ResponseBody注解。

    1.2.3 @EnableAutoConfiguration 
    Spring Boot建议只有一个带有该注解的类。 
    @EnableAutoConfiguration作用:Spring Boot会自动根据你jar包的依赖来自动配置项目。 
    例如当你项目下面有HSQLDB的依赖时,Spring Boot会创建默认的内存数据库的数据源DataSource,如果你自己创建了DataSource,Spring Boot就不会创建默认的DataSource。

    如果你不想让Spring Boot自动创建,你可以配置注解的exclude属性,例如:

    @Configuration
    @EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
    publicclassMyConfiguration {
            }

    1.2.4 @SpringBootApplication 
    由于大量项目都会在主要的配置类上添加 
    @Configuration,@EnableAutoConfiguration,@ComponentScan三个注解。 
    因此Spring Boot提供了@SpringBootApplication注解,该注解可以替代上面三个注解(使用Spring注解继承实现)。

    1.2.5 启动项目SpringApplication.run 
    启动Spring Boot项目最简单的方法就是执行下面的方法: 
    SpringApplication.run(Application.class, args); 
    该方法返回一个ApplicationContext对象,使用注解的时候返回的具体类型是AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext,当支持web的时候是第二个。

    除了上面这种方法外,还可以用下面的方法:

       SpringApplication application = new SpringApplication(Application.class);
    application.run(args);

    SpringApplication包含了一些其他可以配置的方法,如果你想做一些配置,可以用这种方式。

    除了上面这种直接的方法外,还可以使用SpringApplicationBuilder:

        newSpringApplicationBuilder()
           .showBanner(false)
           .sources(Application.class)
           .run(args);

    当使用SpringMVC的时候由于需要使用子容器,就需要用到SpringApplicationBuilder,该类有一个child(xxx…)方法可以添加子容器。

    1.3 运行 
    在IDE中直接直接执行main方法,然后访问http://localhost:8080即可。 
    另外还可以用上面提到的mvn,可以打包为可执行jar包,然后执行java -jar xxx.jar。 
    或者执行mvnspring-boot:run运行项目。

    2. Spring Boot 属性配置和使用 
    Spring Boot 允许通过外部配置让你在不同的环境使用同一应用程序的代码,简单说就是可以通过配置文件来注入属性或者修改默认的配置。

    2.1 Spring Boot 支持多种外部配置方式 
    这些方式优先级如下:

    1. 命令行参数
    2. 来自java:comp/env的JNDI属性
    3. Java系统属性(System.getProperties())
    4. 操作系统环境变量
    5. RandomValuePropertySource配置的random.*属性值
    6. jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
    7. jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
    8. jar包外部的application.properties或application.yml(不带spring.profile)配置文件
    9. jar包内部的application.properties或application.yml(不带spring.profile)配置文件
    10. @Configuration注解类上的@PropertySource
    11. 通过SpringApplication.setDefaultProperties指定的默认属性

    2.1.1 命令行参数 
    通过java -jar app.jar –name=”Spring” –server.port=9090方式来传递参数。 
    参数用–xxx=xxx的形式传递。 
    可以使用的参数可以是我们自己定义的,也可以是Spring Boot中默认的参数。 
    很多人可能会关心如web端口如何配置这样的问题,这些都是Spring Boot中提供的参数,部分可用参数如下:

    # LOGGING
            logging.path=/var/logs
            logging.file=myapp.log
            logging.config= # location of config file (default classpath:logback.xml for logback)
            logging.level.*= # levels for loggers, e.g. "logging.level.org.springframework=DEBUG" (TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF)
    
            # EMBEDDED SERVER CONFIGURATION (ServerProperties)
            server.port=8080
            server.address= # bind to a specific NIC
            server.session-timeout= # session timeout in seconds
            server.context-parameters.*= # Servlet context init parameters, e.g. server.context-parameters.a=alpha
            server.context-path= # the context path, defaults to '/'
            server.servlet-path= # the servlet path, defaults to '/'

    更多常见的应用属性请浏览这里 
    注意:命令行参数在app.jar的后面! 
    可以通过SpringApplication.setAddCommandLineProperties(false)禁用命令行配置。

    2.1.2 Java系统属性 
    注意Java系统属性位置java -Dname=”isea533” -jar app.jar,可以配置的属性都是一样的,优先级不同。 
    例如java -Dname=”isea533” -jar app.jar –name=”Spring!”中name值为Spring!

    2.1.3 操作系统环境变量 
    配置过JAVA_HOME的应该都了解这一个。 
    这里需要注意的地方,有些OS可以不支持使用.这种名字,如server.port,这种情况可以使用SERVER_PORT来配置。

    2.1.4 RandomValuePropertySource 
    系统中用到随机数的地方,例如: 
    my.secret=r and om.value my .nu mbe r= {random.int} 
    my.bignumber=r and om. lon g my .nu mbe r.l ess .tha n.t en=  {random.int(10)} 
    my.number.in.range=${random.int[1024,65536]} 
    random.int*支持value参数和,max参数,当提供max参数的时候,value就是最小值。

    2.1.5 应用配置文件(.properties或.yml) 
    在配置文件中直接写:
  • name=Isea533
    server.port=8080
    .yml格式的配置文件如:
  • name: Isea533  
    
    server:  
      port: 8080

    当有前缀的情况下,使用.yml格式的配置文件更简单。关于.yml配置文件用法请看这里 注意:使用.yml时,属性名的值和冒号中间必须有空格,如name: Isea533正确,name:Isea533就是错的。

    2.1.5.1属性配置文件的位置 
    spring会从classpath下的/config目录或者classpath的根目录查找application.properties或application.yml。 
    /config优先于classpath根目录

    2.1.6 @PropertySource 
    这个注解可以指定具体的属性配置文件,优先级比较低。

    2.1.7 SpringApplication.setDefaultProperties 
    例如:

     SpringApplication application = new SpringApplication(Application.class);
        Map<String, Object>defaultMap = new HashMap<String, Object>();
    defaultMap.put("name", "Isea-Blog");
    //还可以是Properties对象
            application.setDefaultProperties(defaultMap);
            application.run(args);
            2.2 应用(使用)属性
            2.2.1 @Value(“${xxx})
    这种方式是最简单的,通过@Value注解可以将属性值注入进来。
            2.2.2 @ConfigurationProperties
    Spring Boot 可以方便的将属性注入到一个配置对象中。例如:
            my.name=Isea533
            my.port=8080
            my.servers[0]=dev.bar.com
            my.servers[1]=foo.bar.com
            对应对象:
    @ConfigurationProperties(prefix="my")
    publicclassConfig {
    private String name;
    private Integer port;
    private List<String> servers = newArrayList<String>();
    public String geName(){
            returnthis.name;
            }
    public Integer gePort(){
            returnthis.port;
            }
    public List<String>getServers() {
            returnthis.servers;
            }
            }
    Spring Boot 会自动将prefix=”my”前缀为my的属性注入进来。 
    Spring Boot 会自动转换类型,当使用List的时候需要注意在配置中对List进行初始化! 
    Spring Boot 还支持嵌套属性注入,例如:
  • name=isea533
    jdbc.username=root
    jdbc.password=root
            ...
    对应的配置类:
  • @ConfigurationProperties
    publicclassConfig {
    private String name;
            privateJdbcjdbc;
    class Jdbc {
        private String username;
        private String password;
    //getter...
    }
        public Integer gePort(){
            returnthis.port;
        }
        publicJdbcgetJdbc() {
            returnthis.jdbc;
        }
    }

    jdbc开头的属性都会注入到Jdbc对象中。

    2.2.3 在@Bean方法上使用@ConfigurationProperties 
    例如:

    @ConfigurationProperties(prefix = "foo")
    @Bean
    publicFooComponentfooComponent() {
        ...
    }

    Spring Boot 会将foo开头的属性按照名字匹配注入到FooComponent对象中。

    2.2.4 属性占位符 
    例如:

    app.name=MyApp
            app.description=${app.name} is a Spring Boot application
  • 可以在配置文件中引用前面配置过的属性(优先级前面配置过的这里都能用)。
    通过如${app.name:默认名称}方法还可以设置默认值,当找不到引用的属性时,会使用默认的属性。
    由于${}方式会被Maven处理。如果你pom继承的spring-boot-starter-parent,
    Spring Boot 已经将maven-resources-plugins默认的${}方式改为了@ @方式,例如@name@。
    如果你是引入的Spring Boot,你可以修改使用其他的分隔符

                2.2.5 通过属性占位符还能缩短命令参数 

                        例如修改web默认端口需要使用–server.port=9090方式,如果在配置中写上:

server.port=${port:8080}

那么就可以使用更短的–port=9090,当不提供该参数的时候使用默认值8080。

2.2.6 属性名匹配规则 
例如有如下配置对象:

@Component
@ConfigurationProperties(prefix="person")
publicclassConnectionSettings {
private String firstName;
        }

firstName可以使用的属性名如下: 
person.firstName,标准的驼峰式命名 
person.first-name,虚线(-)分割方式,推荐在.properties和.yml配置文件中使用 
PERSON_FIRST_NAME,大写下划线形式,建议在系统环境变量中使用

2.2.7 属性验证 
可以使用JSR-303注解进行验证,例如:

@Component
@ConfigurationProperties(prefix="connection")
publicclassConnectionSettings {
@NotNull
privateInetAddressremoteAddress;
// ... getters and setters
        }

2.3 最后 
以上是Spring Boot 属性配置和使用的内容,有些不全面的地方或者读者有更多疑问,可以查看Spring Boot完整文档 或 Externalized Configuration。

3. Spring Boot 集成MyBatis

3.1. Spring Boot 集成druid 
druid有很多个配置选项,使用Spring Boot 的配置文件可以方便的配置druid。 
在application.yml配置文件中写上:

spring:
        datasource:
        name: test
        url: jdbc:mysql://192.168.16.137:3306/test
        username: root
        password:
        # 使用druid数据源
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.jdbc.Driver
        filters: stat
        maxActive: 20
        initialSize: 1
        maxWait: 60000
        minIdle: 1
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: select 'x'
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        maxOpenPreparedStatements: 20

这里通过type: com.alibaba.druid.pool.DruidDataSource配置即可! 
3.2. Spring Boot 集成MyBatis 
Spring Boot 集成MyBatis有两种方式,一种简单的方式就是使用MyBatis官方提供的: 
mybatis-spring-boot-starter 
另外一种方式就是仍然用类似mybatis-spring的配置方式,这种方式需要自己写一些代码,但是可以很方便的控制MyBatis的各项配置。

3.2.1. mybatis-spring-boot-starter方式 
在pom.xml中添加依赖:


<dependency>
   <groupId>org.mybatis.spring.bootgroupId>
   <artifactId>mybatis-spring-boot-starterartifactId>
   <version>1.1.1version>
dependency>

mybatis-spring-boot-starter依赖树如下:

超详细的Spring Boot入门笔记_第4张图片

其中mybatis使用的3.3.0版本,可以通过:

mybatis:
mapperLocations: classpath:mapper/*.xml
typeAliasesPackage: tk.mapper.model
除了上面常见的两项配置,还有: 
mybatis.config:mybatis-config.xml配置文件的路径 
mybatis.typeHandlersPackage:扫描typeHandlers的包 
mybatis.checkConfigLocation:检查配置文件是否存在 

mybatis.executorType:设置执行模式(SIMPLE, REUSE, BATCH),默认为SIMPLE

明天持续,内容太多。。

你可能感兴趣的:(Springboot)