SpringBoot入门篇

SpringBoot入门篇
一什么是springboot

Spring官网：http://spring.io/projects

SpringBoot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品:

Springboot不是什么真正意义上的新框架，就像maven整合了所有的jar包，spring boot整合了所有常用的框架。如果说我们现在用ssm框架是组装一台台式机，

springboot就是直接给你一台品牌机。可以近似地理解为我们现在用的ssm框架去掉xml配置。搭建完springboot框架后，用法几乎和现在完全一样，springmvc的注解，spring的ioc等等。

总结：spring boot最主要作用就是帮我们快速的构建庞大的spring项目，并且尽可能的减少xml配置，做到迅速上手，让我们关注于业务而非配置。

二快速入门

1. 我们直接来建一个springboot项目。

2 添加依赖

2.1添加父工程

SpringBoot提供了一个名为spring-boot-starter-parent的工程，里面对各种常用依赖（并非全部）的版本进行了管理，我们的项目需要以这个项目为父工程，

这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标。
```
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
</parent>
```
2.2添加web启动器

为了让SpringBoot帮我们完成各种自动配置，我们必须引入SpringBoot提供的自动配置依赖，starter。因为我们是web项目，这里我们引入web启动器：
```
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
</dependencies>
```
我们不需要在这里指定版本信息。因为SpringBoot的父工程已经对版本进行了管理了。这个时候，我们会发现项目中多出了大量的依赖：

这些都是SpringBoot根据spring-boot-starter-web这个依赖自动引入的，而且所有的版本都已经管理好，不会出现冲突。

2.3管理jdk版本

默认情况下，maven工程的jdk版本是1.5，而我们开发使用的是1.8，因此这里我们需要修改jdk版本，添加以下属性：
```
<properties>
        <java.version>1.8</java.version>
</properties>
```
3 启动类

Springboot项目通过main函数启动：
```
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```
4 controller
```
@RestController
public class HelloController {
    @GetMapping("hello")
    public String hello(){
        return "hello sb";
    }

}
```
5 测试

Run application
- 1）监听的端口是8080
- 2）SpringMVC的映射路径是：/
- 3）/hello路径已经映射到了HelloController中的hello()方法
- 4）访问http://localhost:8080/hello
三配置

上面没有做任何配置，就实现了一个springmvc项目。但是如果要配置一个bean怎么办？

Ssm中配置配置连接池是这样：

1 尝试java配置

java配置主要靠java类和一些注解，比较常用的注解有：
- · @Configuration：声明一个类作为配置类，代替xml文件
- · @Bean：声明在方法上，将方法的返回值加入Bean容器，代替<bean>标签
- · @value：属性注入
- · @PropertySource：指定外部属性文件
首先引入连接池依赖：
```
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.6</version>
</dependency>
```
创建properties：
```
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/newapp
jdbc.username=root
jdbc.password=admin
```
配置类：
```
@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {

    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}
```
- @Configuration：声明JdbcConfig是一个配置类
- @PropertySource：指定属性文件的路径是:classpath:jdbc.properties
- 通过@Value为属性注入值
- 通过@Bean将 dataSource()方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值加入Spring容器中。
然后就可以在任意位置通过@Autowired注入DataSource。

测试：
```
@RestController
public class HelloController {

    @Autowired
    private DataSource dataSource;

    @GetMapping("hello")
    public String hello() {
        return "hello,sb" + dataSource;
    }
}
```
2 Springboot的属性注入

1)新建一个类用来属性注入
```
@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;
   
    // getters 和 setters
}
```
- 在类上通过@ConfigurationProperties注解声明当前类为属性读取类
- prefix="jdbc"读取属性文件中，前缀为jdbc的值。
- 在类上定义各个属性，名称必须与属性文件中jdbc.后面部分一致
- 这里并没有指定属性文件的地址，所以需要把jdbc.properties名称改为application.properties，这是SpringBoot默认读取的属性文件名：
- ConfigurationProperties需引入依赖:
- <dependency> <groupId> org.springframework.boot </groupId> <artifactId> spring-boot-configuration-processor </artifactId> <optional> true </optional> </dependency>
  2）在JdbcConfig中使用这个属性：
- @Configuration @EnableConfigurationProperties(JdbcProperties.class) public class JdbcConfig { @Bean public DataSource dataSource(JdbcProperties jdbc) { DruidDataSource dataSource = new DruidDataSource(); dataSource.setUrl(jdbc.getUrl()); dataSource.setDriverClassName(jdbc.getDriverClassName()); dataSource.setUsername(jdbc.getUsername()); dataSource.setPassword(jdbc.getPassword()); return dataSource; } }
总结：似乎更麻烦了，不过value只支持基本类型数据注入，而这种springboot推荐的方式，不严格要求属性文件中的属性名与成员变量名一致。支持驼峰，中划线，下划线等等转换，甚至支持对象引导。

比如：user.office.name：代表的是user对象中的office属性中的name属性，显然office也是对象。

3 更优雅的注入

如果一段属性，只有一个bean使用，不需要先注入到一个properties类中，可以直接在需要的地方声明：
```
@Configuration
public class JdbcConfig {
    
    @Bean
    // 声明要注入的属性前缀，SpringBoot会自动把相关属性通过set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}
```
直接把@ConfigurationProperties(prefix = "jdbc")声明在需要使用的@Bean的方法上，然后SpringBoot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。前提是：该类必须有对应属性的set方法。

4 自动配置的原理

我们看启动类：

4.1SpringBootApplication注解

查看源码又有三个注解：

4.1.1 SpringBootConfiguration

@Configuration标注当前类是配置类，并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到srping容器中，并且实例名就是方法名。

@SpringBootConfiguration继承自@Configuration，二者功能也类似，是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。所以一般我们无需自己添加。

4.1.2 @EnableAutoConfiguration

官网说明：The second class-level annotation is @EnableAutoConfiguration. This annotationtells Spring Boot to “guess” how you want to configure Spring, based on the jardependencies t

hat you have added. Since spring-boot-starter-web added Tomcatand Spring MVC, the auto-configuration assumes that you are developing a webapplication and sets up Spring accordingly.

翻译：@EnableAutoConfiguration的作用启动自动的配置。该标签告诉SpringBoot基于你所添加的依赖，去“猜测”你想要如何配置Spring。比如我们引入了spring-boot-starter-web，而这个启动器

中帮我们添加了tomcat、SpringMVC的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了。

总结，SpringBoot内部对大量的第三方库或Spring内部库进行了默认配置，这些配置是否生效，取决于我们是否引入了对应库所需的依赖，如果有那么默认配置就会生效。

所以，我们使用SpringBoot构建一个项目，只需要引入所需框架的依赖，配置就可以交给SpringBoot处理了。除非你不希望使用SpringBoot的默认配置，它也提供了自定义配置的入口。

4.1.3 @ConponentScan

@ComponentScan，扫描当前包及其子包下被@Component，@Controller，@Service，@Repository注解标记的类并纳入到spring容器中进行管理。是以前的<context:component-scan>（以前使用在xml中使用的标签，用来扫描包配置的平行支持）。

通过basePackageClasses和basePackages属性来扫描指定的包，如果没有属性值，将从声明这个注解的类所在的包开始，扫描包和子包。而@SpringBootApplication注解声明

的类就是main函数所在的启动类，因此扫描的包是该类所在包及其子包。因此，一般启动类会放在一个比较前的包目录中

4.2 默认配置的原理

4.2.1默认配置类

刚才说@EnableAutoConfiguration会开启SpringBoot的自动配置，并且根据你引入的依赖来生效对应的默认配置。那么问题是：

1）这些默认配置是在哪里定义的呢？

2）为何依赖引入就会触发配置呢？

其实刚才的项目中，已经引入了一个依赖：spring-boot-autoconfigure，其中定义了大量自动配置类：

非常多，几乎涵盖了现在主流的开源框架，例如：
- redis
- jms
- amqp
- jdbc
- jackson
- mongodb
- jpa
- solr
- elasticsearch
我们来看一个熟悉的，例如SpringMVC，查看mvc 的自动配置类：

进入WebMvcAutoConfiguration：
- @Configuration：声明这个类是一个配置类
- @ConditionalOnWebApplication(type = Type.SERVLET)
　　　　ConditionalOn，就是在某个条件下，此处就是满足项目的类是是Type.SERVLET类型，也就是一个普通web工程

　　 @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })

　　这里的条件是OnClass，也就是满足以下类存在：Servlet、DispatcherServlet、WebMvcConfigurer，其中Servlet只要引入了tomcat依赖自然会有，后两个需要

　　引入SpringMVC才会有。这里就是判断你是否引入了相关依赖，引入依赖后该条件成立，当前类的配置才会生效。
- @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
　　这个条件与上面不同，OnMissingBean，是说环境中没有指定的Bean这个才生效。其实这就是自定义配置的入口，也就是说，如果我们自己配置了一个WebMVCConfigurationSupport的类，那么这个默认配置就会失效。

看一下类中定义的属性：

视图解析器：

处理器适配器：

4.2.2默认配置属性

默认配置的属性来自哪里：看这个静态内部类

这里通过@EnableAutoConfiguration注解引入了两个属性：WebMvcProperties和ResourceProperties。这也就是刚才说的SpringBoot的属性注入。

看看两个属性类：

WebMvcProperties里有内部资源视图解析器的prefix和suffix属性。

ResourceProperties中主要定义了静态资源（.js,.html,.css等)的路径。

如果我们要覆盖这些默认属性，只需要在application.properties中定义与其前缀prefix和字段名一致的属性即可。

5 总结

SpringBoot为我们提供了默认配置，而默认配置生效的条件一般有两个：

a 引入相关依赖

b 自己没有配置bean

1）启动器

我们如果不想配置，只需要引入依赖即可，而依赖版本我们也不用操心，只要引入了SpringBoot提供的stater（启动器），就会自动管理依赖及版本了。

2）全局配置

SpringBoot的默认配置，都会读取默认属性，而这些属性可以通过自定义application.properties文件来进行覆盖。这样虽然使用的还是默认配置，但是配置中的值改成了我们自定义的。

3）属性文件支持两种格式，application.properties和application.yml

推荐yml：
```
jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/xx
  username: root
  password: 123

server:
  port: 80
```
四 SpringBoot实践

现在我们用sb来实践ssm。

4.1 整合springmvc

默认配置已经可以使用springMvc，不过有时候需要自定义配置。

4.1.1 修改端口
```
server.port=80
```
4.1.2访问静态资源

项目是个jar项目，没有webapp，静态资源放哪儿？

在刚才ResourceProperties类中定义了默认静态资源默认查找路径：
- classpath:/META-INF/resources/
- classpath:/resources/
- classpath:/static/
- classpath:/public
我们习惯用第三种，尝试一下。

4.1.3添加拦截器

在SpringBoot官方文档中：

如果你想要保持Spring Boot 的一些默认MVC特征，同时又想自定义一些MVC配置（包括：拦截器，格式化器, 视图控制器、消息转换器等等），你应该让一个类实现WebMvcConfigurer，并且添加@Configuration注解，但是千万不要加@EnableWebMvc注解。如果你想要自定义HandlerMapping、HandlerAdapter、ExceptionResolver等组件，你可以创建一个WebMvcRegistrationsAdapter实例来提供以上组件。

如果你想要完全自定义SpringMVC，不保留SpringBoot提供的一切特征，你可以自己定义类并且添加@Configuration注解和@EnableWebMvc注解

也就是说：通过实现WebMvcConfigurer并添加@Configuration注解来实现自定义部分SpringMvc配置。

1）定义拦截器：
```
public class LoginInterceptor implements HandlerInterceptor {

    private Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        logger.debug("执行preHandle ");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        logger.debug("执行postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        logger.debug("执行afterCompletion ");
    }
}
```
2）定义配置类注册拦截器：
```
@Configuration
public class MvcConfig implements WebMvcConfigurer{
    /**
     * 通过@Bean注解，将我们定义的拦截器注册到Spring容器
     * @return
     */
    @Bean
    public LoginInterceptor loginInterceptor(){
        return new LoginInterceptor();
    }

    /**
     * 重写接口中的addInterceptors方法，添加自定义拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 通过registry来注册拦截器，通过addPathPatterns来添加拦截路径
        registry.addInterceptor(this.loginInterceptor()).addPathPatterns("/**");
    }
}
```
3）将日志级别从默认的info改为dubug：logging.level.com.wdit=debug

4.2整合jdbc和事务

添加jdbc启动器和数据库驱动：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
```
SpringBoot中通过注解来控制事务。就是在service方法中添加@Transacational
```
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id){
        return this.userMapper.selectByPrimaryKey(id);
    }

    @Transactional
    public void deleteById(Long id){
        this.userMapper.deleteByPrimaryKey(id);
    }
}
```
4.3整合连接池

添加启动器：
```

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.9</version>
</dependency>
```
配置属性：
```
#初始化连接数
spring.datasource.druid.initial-size=1
#最小空闲连接
spring.datasource.druid.min-idle=1
#最大活动连接
spring.datasource.druid.max-active=20
#获取连接时测试是否可用
spring.datasource.druid.test-on-borrow=true
#监控页面启动
spring.datasource.druid.stat-view-servlet.allow=true
```
4.4 整合mybatis

4.2.1mybatis

添加启动器：
```

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
</dependency>
```
配置属性：
```
# mybatis 别名扫描
mybatis.type-aliases-package=com.wdit.domain
# mapper.xml文件位置,如果没有映射文件，请注释掉
mybatis.mapper-locations=classpath:mappers/*.xml
```
这里没有配置mapper接口扫描包，因此需要给每一个Mapper接口添加@Mapper注解，才能被识别。
```
@Mapper
public interface UserMapper {
}
```
或者，我们也可以不加注解，而是在启动类上添加扫描包注解：
```
@SpringBootApplication
@MapperScan("com.wdit.demo.mapper")
public class Application {
    public static void main(String[] args) {
        // 启动代码
        SpringApplication.run(Application.class, args);
    }
}
```
4.2.2 通用mapper

添加启动器：
```

<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.0.2</version>
</dependency>
```
使用：
```
@Mapper
public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User>{
}
```
4.5 测试

数据库中新建表user，新建三个类：

domain
```
package com.wdit.domain;


public class User {
    private Long id;
    private String name;
    private String password;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}
```
mapper：
```
public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User>{
}
```
service：
```
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id){
        User user=new User();
        user.setId(id);
        return this.userMapper.selectOne(user);
    }

    @Transactional
    public void deleteById(Long id){
        this.userMapper.deleteByPrimaryKey(id);
    }
}
```
controller:
```
@RestController
public class HelloController {

    @Autowired
    private UserService userService;

    @GetMapping("/hello")
    public User hello() {
        User user = this.userService.queryById(8L);
        return user;
    }
}
```
相关阅读:
平衡数问题
 重复值判断练习题
 小范围排序
 堆排序
 基数排序
 计数排序
 希尔排序
 快速排序
 Effective C++笔记：实现
 Effective C++笔记：设计与声明
原文地址：https://www.cnblogs.com/hungryforknowedge/p/10157350.html

SpringBoot入门篇

5 总结