乐优商城项目---day01-SpringBoot

 

1.1.什么是SpringBoot

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

1.2.SpringBoot的特点

Spring Boot 主要特征是：

• 创建独立的spring应用程序

• 直接内嵌tomcat、jetty和undertow（不需要打包成war包部署）

• 提供了固定化的“starter”配置，以简化构建配置

• 尽可能的自动配置spring和第三方库

• 提供产品级的功能，如：安全指标、运行状况监测和外部化配置等

• 绝对不会生成代码，并且不需要XML配置

总之，Spring Boot为所有 Spring 的开发者提供一个开箱即用的、非常快速的、广泛接受的入门体验

更多细节，大家可以到官网查看。

下面是记录SpringBoot的程序的Demo案例，方便记录

1. 新建SpringBoot的Maven工程之后，直接有建新建模块比较简单，在引入POM坐标

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

2.Pom坐标引入后，要新建SpringBoot的启动类，和SSM项目相比，SpringBoot项目不用配置Web.xml,不用配置applicationApplication.xml,bean.xml,springmvc.xml，也不用配置，可以是是非常的灵活和方便，一切的工作都交给注解来完成，这个是SpringBoot项目的初始例子很简单

@RestController
@EnableAutoConfiguration        //自动加载配置文件
public class HelloWorld {
    @GetMapping(value = "/show")
    public String show(){
        return "Hello World Spring Boot";
    }

    public static void main(String[] args) {
        SpringApplication.run(HelloWorld.class,args);

    }
}

请求地址：http:localhost:8080/show，因为内置Tomcat,所以也不用配置Tomcat的配置文件，可以说是大大节省了做文件的工作

下面是对SpringBoot项目的一个优化，因为之前写注解，没有他怎么了解过源码，现在在深入的回顾一下，先来说一下注解@ComponmentScan，这个相当于SpringMVC.XML的配置文件用来扫描

Controller这个包下面的控制器，所以正常的SpringBoot的启动器，都放在最外层已经是Service,Controller,Dao的上级目录，以便能扫描到所有的配置文件，@RestController就更简单了也是相当于SPringMVC.xml的控制器里面的一个标签，也是简化开发.

@ComponentScan

spring框架除了提供配置方式的注解扫描<context:component-scan />，还提供了注解方式的注解扫描@ComponentScan。

在HelloWorkdApplication.class中，使用@ComponentScan注解：

@EnableAutoConfiguration

开启spring应用程序的自动配置，SpringBoot基于你所添加的依赖和你自己定义的bean，试图去猜测并配置你想要的配置。比如我们引入了spring-boot-starter-web，而这个启动器中帮我们添加了tomcat、SpringMVC的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！

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

所以，我们使用SpringBoot构建一个项目，只需要引入所需依赖，配置就可以交给SpringBoot处理了。在测试的时候，这个@RestController这个注解不能掉，虽然在之前的SSM项目种也要写@Controller这个注解，但是到SpringBoot这个项目种，这个注解还是要写的

发起请求：

我们现在的引导类中使用了@EnableAutoConfiguration和@ComponentScan注解，有点麻烦。springboot提供了一种简便的玩法：@SpringBootApplication注解

使用@SpringBootApplication改造Application：之前对@SpringBootApplication这个注解了解的一直不是很多，现在才知道他是两个注解二为一的注解方式

@SpringBootApplication    //包含了@EnableAutoConfiguration和@ComponentScan注解
public class HelloWorldApplication {
    public static void main(String[] args) {
        SpringApplication.run(HelloWorldApplication.class,args);
    }
}

发现@SpringBootApplication其实是一个组合注解，这里重点的注解有3个：

• @SpringBootConfiguration

• @EnableAutoConfiguration：开启自动配置

• @ComponentScan：开启注解扫描

3.默认配置原理

springboot的默认配置方式和我们之前玩的配置方式不太一样，没有任何的xml。那么如果自己要新增配置该怎么办？比如我们要配置一个数据库连接池，以前会这么玩：

<!-- 配置连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      init-method="init" destroy-method="close">
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

3.1.回顾历史

事实上，在Spring3.0开始，Spring官方就已经开始推荐使用java配置来代替传统的xml配置了，我们不妨来回顾一下Spring的历史：

• Spring1.0时代

  在此时因为jdk1.5刚刚出来，注解开发并未盛行，因此一切Spring配置都是xml格式，想象一下所有的bean都用xml配置，细思极恐啊，心疼那个时候的程序员2秒

• Spring2.0时代

  Spring引入了注解开发，但是因为并不完善，因此并未完全替代xml，此时的程序员往往是把xml与注解进行结合，貌似我们之前都是这种方式。

• Spring3.0及以后

  3.0以后Spring的注解已经非常完善了，因此Spring推荐大家使用完全的java配置来代替以前的xml，不过似乎在国内并未推广盛行。然后当SpringBoot来临，人们才慢慢认识到java配置的优雅。

有句古话说的好：拥抱变化，拥抱未来。所以我们也应该顺应时代潮流，做时尚的弄潮儿，一起来学习下java配置的玩法。

先在Pom坐标种引入Druid的连接池配置信息,在Resource目录中，新建一个JDBC.porperties的文件，里面加入着些内容

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/leyou
jdbc.username=root
jdbc.password=root

接下来就可以写配置数据源的信息，和之前的JDBC一样都用${}获取配置文件里面的变量的信息

@Configuration
@PropertySource("classpath:jdbc.properties")
public class jdbcConfig {

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

    @Bean
    public DataSource getConnection(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(this.driverClassName);
        druidDataSource.setUrl(this.url);
        druidDataSource.setUsername(this.username);
        druidDataSource.setPassword(this.password);
        System.out.println(druidDataSource);
        return druidDataSource;
    }
}

解读：

• @Configuration：声明JdbcConfiguration是一个配置类。

• @PropertySource：指定属性文件的路径是:classpath:jdbc.properties

• 通过@Value为属性注入值。

• 通过@Bean将 dataSource()方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值加入Spring容器中。相当于以前的bean标签

然后就可以在任意位置通过@Autowired注入DataSource了！

测试：

@SpringBootApplication
public class HelloWorldApplication {

    @Autowired
    private jdbcConfig jdbcConfig;

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

通过打断点调试可以发现，里面的URL信息已经全部读取到了，信息注入正常，

3.3.SpringBoot的属性注入

在上面的案例中，我们实验了java配置方式。不过属性注入使用的是@Value注解。这种方式虽然可行，但是不够强大，因为它只能注入基本类型值。

在SpringBoot中，提供了一种新的属性注入方式，支持各种java基本数据类型及复杂类型的注入。

1）新建JdbcProperties，用来进行属性注入：

@ConfigurationProperties(prefix = "jdbc")
public class jdbcConfgiure {
        String driverClassName;
        String url;
        String username;
        String password;
    //下面的都是Get和Set方法
}

• 在类上通过@ConfigurationProperties注解声明当前类为属性读取类

• prefix="jdbc"读取属性文件中，前缀为jdbc的值。

• 在类上定义各个属性，名称必须与属性文件中jdbc.后面部分一致，并且必须具有getter和setter方法

• 需要注意的是，这里我们并没有指定属性文件的地址，SpringBoot默认会读取文件名为application.properties的资源文件，所以我们把jdbc.properties名称改为application.properties

1.@Authorwired方式注入

2.构造函数注入

3.方法参数注入

下面是SpringBoot自动注入的四种方式的区别

大家会觉得这种方式似乎更麻烦了，事实上这种方式有更强大的功能，也是SpringBoot推荐的注入方式。两者对比关系：

3.4.更优雅的注入

事实上，如果一段属性只有一个Bean需要使用，我们无需将其注入到一个类（JdbcProperties）中。而是直接在需要的地方声明即可：

@Configuration
public class JdbcConfig {

    @ConfigurationProperties(prefix = "jdbc")
    @Bean
    public DataSource getConnection(){
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
}

直接在Controller打断点就可以看见DataSource里面的属性的值

3.5.SpringBoot中的默认配置

通过刚才的学习，我们知道@EnableAutoConfiguration会开启SpringBoot的自动配置，并且根据你引入的依赖来生效对应的默认配置。那么问题来了：

• 这些默认配置是怎么配置的，在哪里配置的呢？

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

• 这些默认配置的属性来自哪里呢？

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

3.6.总结

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

• 你引入了相关依赖

• 你自己没有配置

1）启动器

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

因此，玩SpringBoot的第一件事情，就是找启动器，SpringBoot提供了大量的默认启动器，参考课前资料中提供的《SpringBoot启动器.txt》

2）全局配置

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

因此，玩SpringBoot的第二件事情，就是通过application.properties来覆盖默认属性值，形成自定义配置。我们需要知道SpringBoot的默认属性key，非常多，参考课前资料提供的：《SpringBoot全局属性.md》

4.SpringBoot实战

接下来，我们来看看如何用SpringBoot来玩转以前的SSM,我们沿用之前讲解SSM用到的数据库tb_user和实体类User

整合SpringMVC

4.3.1.修改端口

添加全局配置文件：application.properties

完成端口测试：

4.3.2.访问静态资源

现在，我们的项目是一个jar工程，那么就没有webapp，我们的静态资源该放哪里呢？

回顾我们上面看的源码，有一个叫做ResourceProperties的类，里面就定义了静态资源的默认查找路径：

@SpringBootApplication
@ConfigurationProperties(prefix = "spring.resource",ignoreInvalidFields = false)
public class UserApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserApplication.class,args);
    }
}

默认的静态资源路径为：

• classpath:/META-INF/resources/

• classpath:/resources/

• classpath:/static/

• classpath:/public/

只要静态资源放在这些目录中任何一个，SpringMVC都会帮我们处理。每次放入新的静态资源文件的时候项目都需要重新启动

我们习惯会把静态资源放在classpath:/static/目录下。我们创建目录，并且添加一些静态资源：

4.3.3.添加拦截器

拦截器也是我们经常需要使用的，在SpringBoot中该如何配置呢？

添加拦截器MyInteproces并继承HandelInteproces

@Component
public class MyInterproces implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("方法执行之前");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("方法执之后");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("方法全部执行完了！");
    }
}

然后定义配置类，注册拦截器：

@Configuration
public class MyConfig implements WebMvcConfigurer {

    @Autowired
    private MyInterproces myInterproces;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterproces).addPathPatterns("/**");
    }
}

发起请求进行测试：

http://localhost:8888/user

4.4.整合连接池

在pom.xml中引入jdbc的启动器：

   <!--jdbc的启动器，默认使用HikariCP连接池-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--不要忘记数据库驱动，因为springboot不知道我们使用的什么数据库，这里选择mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

指定连接池的参数

# 连接四大参数
spring.datasource.url=jdbc:mysql://localhost:3306/heima
spring.datasource.username=root
spring.datasource.password=root
# 可省略，SpringBoot自动推断
spring.datasource.driverClassName=com.mysql.jdbc.Driver

spring.datasource.hikari.idle-timeout=60000
spring.datasource.hikari.maximum-pool-size=30
spring.datasource.hikari.minimum-idle=10

整合MyBaits 

<!--mybatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
</dependency>

继承通用Mapper

   <!-- 通用mapper -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.2</version>
        </dependency>

这里面有个注意点这个URL后面必须加上字符编码的处理

全路径为不然会报编码异常的错误，下面就是比较经典的SSM三连发

spring.datasource.url=jdbc:mysql://localhost:3306/leyou?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC

Dao层

Serivce层

Controller层

完成运行结果显示：

SpringBoot实战总结：

开始引入Thymeleaf

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

接着就是经典的SSM操作查询全部，之后的Controller，给一个模型，把查处理的集合封装到模型里面，模型在传到页面

    @GetMapping("/all")
    public String findAll(ModelMap model){
       List<User> users=  userService.findAll();
        model.addAttribute("users",users);
        return "users";
    }

这个里面有个问题，如果你的Controller里面的注解是@RestController=@RestBody+@Controller ，所有 他就会只能给前台返回一个字符串“user”,这个时候必须要把@RestController这个注解改成@Controller这个注解，Thymeleaf就会去对应的目录下找那个对应的文件了，就可以达到方法的全部了，注意着两个注解的区别，控制器的请求方法没变，但是显示的结果完全不一样

@RestController显示

@Controller显示

以上就是关于SpringBoot的回顾