基于SpringBoot实现SSM框架整合

前言

之前学习了Spring框架的JDBC、MVC，SpringBoot也是Spring框架下面的一个子项目，是Spring生态的一部分；

为什么我们要使用Spring的Boot子项目呢？

如果单独使用Spring或者SpringMVC作为Web开发框架，需要通过大量的配置类/配置文件把JDBC、Druid、Redis等Web开发依赖包放到Spring容器中；

Spring推出了1个快速开发工具包（SpringBoot），可以让程序员更加方便、快速启动Spring容器并自动整合各种Web开发依赖；

SpringBoot的核心功能=Tomcat+Spring+SpringMVC的功能；

Maven和SpringBoot的联系？

maven是实现SpringBoot的基础，SpringBoot项目本身就是Maven项目。
在maven项目中使用springboot的多个starter加几个约定，就能成为SpringBoot项目了。
Spring Boot工程本质上就是一个Maven工程。

SpringBoot有以下特点：

1.独立运行

Spring Boot 而且内嵌了各种 servlet 容器，Tomcat、Jetty 等，现在不再需要打成 war 包部署到容器中，Spring Boot 只要打成一个可执行的 jar 包就能独立运行，所有的依赖包都在一个 jar 包内。

2.简化配置

spring-boot-starter-web 启动器自动依赖其他组件，简少了 maven 的配置。

3.自动配置

Spring Boot 能根据当前类路径下的类、jar 包来自动配置 bean，如添加一个 spring-boot-starter-web 启动器就能拥有 web 的功能，无需其他配置。

4.无代码生成和 XML 配置

Spring Boot 配置过程中无代码生成，也无需 XML 配置文件就能完成所有配置工作，这一切都是借助于条件注解完成的，这也是 Spring4.x 的核心功能之一

5.避免大量的 Maven 导入和各种版本冲突

6.应用监控

Spring Boot 提供一系列端点可以监控服务及应用，做健康检测。

一、SpringBoot概述

通过Spring的缺点，看到SpringBoot的优势；

1.Spring优缺点

1.1.优点

Spring是一个轻量级的Java开源框架，通过IOC和AOP技术实现高内聚、低耦合的Web应用开发；

1.2.缺点

当添加1个框架或技术时，就需要添加相应的maven依赖；
当添加1个框架或技术时，引入的依赖可能会出现依赖冲突；
当添加1个框架或技术时，需要添加大量的配置信息；

2.SpringBoot概述

SpringBoot是对Spring的缺点进行大大改善和优化，SpringBoot基于约定大于配置的思想，提供了大量默认配置和实现；

使用SpringBoot之后，程序员只需要按照SpringBoot规定的方式去进行程序代码的开发即可，无需再去编写一堆复杂的配置；

3.SpringBoot主要功能

版本锁定：SpringBoot在父工程中进行了大量常见依赖的版本锁定

起步依赖：SpringBoot按功能应用场景将需要的依赖进行组合，允许程序员以starter的方式在maven中进行引入一组依赖；

自动配置：在导入starter之后SpringBoot主要帮我们完成了2件事，相关组件的自动导入（按条件装配)，相关组件的自动装配；

内置Tomcat：SpringBoot内置了一个tomcat，使用它开发的程序无需再进行tomcat部署，可直接运行；

总之：SpringBoot最主要作用就是帮我们快速的构建庞大的Spring项目，并且尽可能的减少配置，让程序员去关注业务而非配置。

二、SpringBoot入门案例

搭建一个SpingBoot项目，实现访问浏览器地址localhost:8080/index ，返回hello, springboot!

1.创建工程

1个SpringBoot工程要求必须去继承1个springboot提供的父工程（org.springframework.boot)，父工程中引入了大量的依赖，并对大量的依赖版本进行了锁定；

当前SpringBoot工程继承了这个父工程之后，我们就无需再在当前项目中添加依赖；

<?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.0</modelVersion>

    <groupId>com.zhanggen</groupId>
    <artifactId>springboot-quickstart</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--1. 继承父工程: 父工程里面进行版本的锁定-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
    </parent>

    <!--2.引入依赖启动器: 里面是一堆需要的依赖的集合-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

pom.xml

如果需要编译成jar包,pom.xml添加如下内容

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

2.编写Controller

package com.zhanggen.web.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

//这个文件和SpringMVC的Controller是一样的
@RestController
public class IndexController {
    @RequestMapping("/index")
    public String index() {
        return "hello springBoot!";
    }
}

IndexController.java

3.编写启动类

package com.zhanggen;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

//这个类的位置;放到com.zhanggen包下面
@SpringBootApplication
public class QuickStartApplication {
    public static void main(String[] args) {
        //参数1:当前类字节码  参数2：args
        SpringApplication.run(QuickStartApplication.class, args);
    }
}

QuickStartApplication.java

4.案例解析

做完了入门案例，我们应该会有下面这样几个疑问：

我们的工程在引入`spring-boot-starter-web`依赖的时候，为什么没有指定版本？
spring-boot-starter-web是个啥，为什么引入了它之后，就不需要再引入我们原来做spring开发的那一堆包了？
我们的程序没有部署到tomcat，为什么就可以被访问？
为什么我们访问程序的时候要用8080端口，谁定义的？

4.1.版本锁定

我们的项目继承了spring-boot-starter-parent父工程，它内部已经锁定了一些常见依赖的版本号，故而在我们自己开发的工程中无需再指定依赖的版本。

4.2.起步依赖

SpringBoot根据场景将各种依赖组装成了一个个的集合（starter），我们根据当前SpringBoot的功能引入指定的starter即可。

4.3.内置Tomcat

SpringBoot在中引入一个内置的tomcat，故而我们无需再将程序部署到Tomcat中即可运行。

4.4.默认配置

SpringBoot的约定大于配置，即SpringBoot的大量配置都有默认值，如果我们不去写配置就使用默认的。

比如说：Tomcat默认端口 8080、redis 默认端口6379 、session 的过期默认时间为30m等等；

三、SpringBoot配置文件

SpringBoot是基于约定的，很多配置都有默认值；

但它也允许使用自己的配置替换默认配置，具体做法是在resources下创建文件：

1.自定义配置文件

我们可以在当前项目的resource目录下，创建以下3类文件，但配置文件的名称只能叫application；

application.yaml
application.yml
application.properties

SpringBoot启动时会依次加载：yaml、yml、properties文件，如果多个配置文件同时存在，后加载的会覆盖前面加载的内容。

2.yaml介绍

yaml和yml文件格式是一样的，是专门用来写配置文件的语言，非常简洁和强大。

2.1.语法

# 大小写敏感
# 使用缩进表示层级关系
# 缩进的空格数目不重要，但是相同层级的元素必须左侧对齐 
# 参数值和冒号之间必须有空格
server:
  port: 8082
  servlet:
    context-path: /itheima

2.2.数据格式

# 纯量：单个的、不可再分的值（包括字符串字符串、布尔值、数值、Null、时间类型）
username: 'jack'

# 对象：键值对的集合，又称为映射（mapping）/ 哈希（hashes） / 字典（dictionary）
user:
  username: '张三'
  password: '123'
  
# 数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）
addressList:
  - '北京'
  - '上海'
  - '广州'

3.SpringBoot读取配置文件的三种方式

在SpringBoot项目中有3种方式读取配置文件中的配置项目；

3.1.Environment(了解）

此对象是Spring框架提供的，用来表示整个应用运行时的环境，可以读取配置文件中的属性值并逐个注入到Bean对象的对应属性中;

3.2.@Value注解 (了解)

此注解是Spring框架提供的，用来读取配置文件中的属性值并逐个注入到Bean对象的对应属性中;

3.3.@ConfigurationProperties注解

此注解是SpringBoot框架提供的，用来快速、方便地将配置文件中的自定义属性值批量注入到某个Bean对象的相应属性中;

3.4.配置文件信息

#自定义配置信息
server:
  port: 8002
  servlet:
    context-path: /zhanggen

#SpringBoot配置控制台输出彩色日志
spring:
  output:
    ansi:
      enabled: ALWAYS


#对象：键值对的集合
user:
  username: '张根'
  password: '123'

application.yaml

3.5.获取代码

package com.zhanggen.web.controller;

import com.zhanggen.config.UserConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

//这个文件和SpringMVC的Controller是一样的
@RestController
public class IndexController {
    //注意Environment位于org.springframework.core.env.Environment包
    @Autowired
    private Environment environment;

    @Value("${user.username}")
    private String username;

    @Value("${user.password}")
    private String password;

    @Autowired
    private UserConfig userConfig;

    @RequestMapping("/index")
    public String index() {
        //方式1：使用Environment对象，获取配置文件中的值
        System.out.println(environment.getProperty("user.username"));
        System.out.println(environment.getProperty("user.password"));
        //方式2：使用@Value，获取配置文件中的值
        System.out.println(this.username);
        System.out.println(this.password);
        //方式3：通过定义UserConfig对象获取配置文件中配置信息
        System.out.println(userConfig.getUsername());
        System.out.println(userConfig.getPassword());
        return "hello springBoot!";

    }
}

IndexController.java

4.SpringBoot多环境配置

使用springBoot的配置文件application.yaml配置3套环境，分别是测试、开发、生产环境；

4.1.配置文件

#自定义配置信息

#共有
user:
  username: '公共'
  password: '8899'



#集合哪一套环境
spring:
  profiles:
    active: test

--- #开发环境
spring:
  output:
    ansi:
      enabled: ALWAYS
  profiles: dev
server:
  port: 8001
  servlet:
    context-path: /dev
user:
  username: '开发'
  password: '121'


--- #测试环境
spring:
  output:
    ansi:
      enabled: ALWAYS
  profiles: test
server:
  port: 8002
  servlet:
    context-path: /test
user:
  username: '测试'
  password: '122'


--- #线上环境
spring:
  output:
    ansi:
      enabled: ALWAYS
  profiles: product
server:
  port: 8003
  servlet:
    context-path: /product
user:
  username: '线上'
  password: '123'

application.yaml

5.SpringBoot项目打包

使用spring-boot-maven-plugin插件可以把SpringBoot项目打包成1个可以独立运行起来的jar包；

在pom.xml的project节点中添加下面配置

<!--在pom.xml的project节点中添加下面配置,然后执行maven clean package-->
    <build>
        <finalName>springboot</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

pom.xml

执行maven clean package

1.命令格式传递参数

把SpringBoot打成jar包之后，就可以通过java -jar命名运行该jar包；

也可以在运行钱给指定SpringBoot配置文件中的配置值；

java –jar springboot.jar --spring.profiles.active=test     # 指定使用test环境 
java –jar springboot.jar --spring.profiles.active=test --server.port=9090  # 指定使用test环境,端口号为9090

四、SpringBoot整合SSM框架集

SpringBoot整合一些web开发过程中常用的框架；

1.日志输出设置

日志常用的级别有4个: debug info warn erro

1.1.修改springBoot配置文件

我们可以根据springBoot项目中的包，来控制包输出日志的级别；

#设置日志级别
logging:
  level:
    com.itheima: info

application.yaml

1.2.设置输出日志级别

Lombok提供的注解，此注解标注在类上之后，在类中就有1个log对象可以输出日志信息了

package com.zhanggen.web.controller;

import com.zhanggen.config.UserConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

//这个文件和SpringMVC的Controller是一样的
@RestController
@Slf4j //这是Lombok提供的注解，此注解标注在类上之后，在类中就有1个log对象可以输出日志信息了
public class IndexController {
    //注意Environment位于org.springframework.core.env.Environment包
    @Autowired
    private Environment environment;

    @Value("${user.username}")
    private String username;

    @Value("${user.password}")
    private String password;

    @Autowired
    private UserConfig userConfig;

    @RequestMapping("/index")
    public String index() {
        //方式1：使用Environment对象，获取配置文件中的值
        System.out.println(environment.getProperty("user.username"));
        System.out.println(environment.getProperty("user.password"));
        //方式2：使用@Value，获取配置文件中的值
        System.out.println(this.username);
        System.out.println(this.password);
        //方式3：通过定义UserConfig对象获取配置文件中配置信息
        System.out.println(userConfig.getUsername());
        System.out.println(userConfig.getPassword());
        log.debug("debug");
        log.info("info");
        log.error("error");

        return "hello springBoot!";

    }
}

IndexController.java

2.单元测试

使用springBoot框架之后如何进行单元测试

2.1.引入依赖

在pom.xml加入单元测试的starter

<!--引入junit依赖启动器-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>

2.2.编写测试类

在springBoot中测试类必须位于启动器类所在包之下；

由于SpringBoot的配置文件的名字是固定的，所以不需要@ContextConfiguration("classpath:applicationContext.xml")指定配置文件；

package com.zhanggen.test;

import com.zhanggen.config.UserConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

//在springBoot中测试类必须位于启动器类所在包之下
//SpringBoot的配置文件的名字是固定的
//所以不需要@ContextConfiguration("classpath:applicationContext.xml")
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class MyTest {
    @Autowired
    private UserConfig userConfig;

    @Test
    public void testConf() {
        System.out.println(userConfig.getPassword());
        System.out.println(userConfig.getUsername());
    }
}

3.释放静态资源

SpringBoot项目是一个普通java工程，不是web工程，没有webapp目录，那么静态资源应该放哪里呢？

在Springboot项目中，默认静态资源的存放目录为："classpath:/resources/", "classpath:/static/", "classpath:/public/"

如果我们想更换静态资源的默认存放路径，就需要设置静态资源映射。

3.1.classpath是什么？

当Java项目打包的时maven会把main包下的java/和resource/的包和配置文件合并打包到1个classes目录中，称为classpath；

3.2.SpringBoot静态资源存放路径（默认）

其实SpringBoot已经定义了4个位置用于存放静态资源；

classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/
classpath:/public/

3.3.自定义SpringBoot静态资源存放路径

我们可以在springBoot中更换静态文件默认存放路径；

但是自定义的路径也要在resources目录下，才能确保静态资源被打包带类路径中；

配置自定义静态资源路径的方法需要，额外定义1个配置类；

package com.itheima.reggie.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

//web相关配置
@Configuration
public class ReggieWebMvcConfig implements WebMvcConfigurer {
    //设置静态资源映射
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        //当访问请求是/backend/**时,去classpath:/backend/寻找对应资源
        registry.addResourceHandler("/backend/**").addResourceLocations("classpath:/backend/");
    }
}

ReggieWebMvcConfig.java

4.拦截器配置

在SpringBoot项目中的如果配置类实现了WebMvcConfigurer接口，就可以通过该配置类中的方法，实现SpringMVC的静态资源的释放、拦截器的配置等；

//SpringMvc(web层)相关配置
@Configuration
public class ReggieWebMvcConfig implements WebMvcConfigurer {
    //1.释放静态资源
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        //当访问请求是/backend/**时,去classpath:/backend/寻找对应资源
        registry.addResourceHandler("/backend/**").addResourceLocations("classpath:/backend/");
    }
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;
    //2.配置springBoot的拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //定义放行路径
        ArrayList<String> passUrlList = new ArrayList<>();
        passUrlList.add("/backend/**");//管理系统静态资源
        passUrlList.add("/error");//错误请求
        passUrlList.add("/employee/login");//管理系统登录请求
        passUrlList.add("/employee/logout");//管理系统退出请求
        registry.addInterceptor(loginCheckInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns(passUrlList);
    }
}

4.1.定义拦截器类

该拦截器用户检查当前用户是否登录？

package com.itheima.reggie.interceptor;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.itheima.reggie.common.ResultInfo;
import com.itheima.reggie.domain.Employee;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@Component//把拦截器对象放入spring的容器中，以供配置对象注入
public class LoginCheckInterceptor implements HandlerInterceptor {

    //在请求进入处理器之前进行拦截
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //检查用户的session中是否有当前信息信息，以验证当前用户是否登录？
        HttpSession session = request.getSession();
        Employee currentEmployee = (Employee) session.getAttribute("SESSION_EMPLOYEE");
        if (currentEmployee == null) {
            //返回错误信息
            ResultInfo resultInfo = ResultInfo.error("NOTLOGIN");//组装对象
            //ResultInfo对象转为json
            String jsonString = new ObjectMapper().writeValueAsString(resultInfo);
            response.getWriter().write(jsonString);
            return false;
        } else {
            return true;
        }
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

LoginCheckInterceptor.java

4.2.注册拦截器

在SpringBoot项目中的配置类中注册拦截器；

package com.itheima.reggie.config;

import com.itheima.reggie.interceptor.LoginCheckInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.ArrayList;

//SpringMvc(web层)相关配置
@Configuration
public class ReggieWebMvcConfig implements WebMvcConfigurer {
    //1.释放静态资源
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        //当访问请求是/backend/**时,去classpath:/backend/寻找对应资源
        registry.addResourceHandler("/backend/**").addResourceLocations("classpath:/backend/");
    }
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;
    //2.配置springBoot的拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //定义放行路径
        ArrayList<String> passUrlList = new ArrayList<>();
        passUrlList.add("/backend/**");//管理系统静态资源
        passUrlList.add("/error");//错误请求
        passUrlList.add("/employee/login");//管理系统登录请求
        passUrlList.add("/employee/logout");//管理系统退出请求
        registry.addInterceptor(loginCheckInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns(passUrlList);
    }
}

ReggieWebMvcConfig.java

5.整合Mybatis

SpringBoot整合Mybatis框架；

5.1.数据准备

CREATE TABLE `tb_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `username` varchar(20) NOT NULL COMMENT '用户名',
  `password` varchar(20) NOT NULL COMMENT '密码',
  `nick_name` varchar(30) DEFAULT NULL COMMENT '姓名',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  `email` varchar(50) DEFAULT NULL COMMENT '邮箱',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;


insert  into `tb_user`(`id`,`username`,`password`,`nick_name`,`age`,`email`) values
                                                                                    (1,'张弢','123456','张大侠',18,'zhangtao1@wudangshan.cn'),
                                                                                    (2,'张启樵','123456','夺魄',20,'test2@wudangshan.cn'),
                                                                                    (3,'张君宝','123456','张公子',28,'test3@wudangshan.cn'),
                                                                                    (4,'易云','123456','武林盟主',21,'test4@wudangshan.cn'),
                                                                                    (5,'易继风','123456','名剑山庄.少庄主',24,'test5@wudangshan.cn');

tb_user.sql

5.2.添加依赖

  <!--调整mysql的版本-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!--加入mybatis的启动器,这是mybatis公司提供的-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>

pom.xml

5.3.创建实体类

package com.zhanggen.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import sun.rmi.runtime.Log;

@AllArgsConstructor
@NoArgsConstructor
@Data
public class User {
    private Long id;
    private String username;
    private String password;
    private String nickNage; //数据库字段为nick_name
    private Integer age;
    private String email;

}

User.java

5.4.创建UserMapper接口

创建dao层的接口，推荐使用类似于xxxMapper的名字

package com.zhanggen.mapper;

import com.zhanggen.domain.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface UserMapper {
    //查询所有
    // @Select("select * from tb_user")
    List<User> findAll();
}

UserMapper.interface

5.5.创建UserMapper映射文件

在resources下创建mappers目录，然后在此目录下创建UserMapper.xml文件；注意：这里用做到包的对应

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhanggen.mapper.UserMapper">
    <select id="findAll" resultType="com.zhanggen.domain.User">
        select * from tb_user
    </select>
</mapper>

UserMapper.xml

5.6.添加springBoot配置文件

在springBoot的配置文件中指定datasource，指定mapper映射文件

#激活哪1套环境
spring:
  profiles:
    active: test
  # 数据源配置（springboot内置连接池对象HiKariCP）
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.56.18:3306/dbForJava?characterEncoding=utf8
    username: zhanggen
    password: zhanggen
# mybatis简单配置
mybatis:
  mapper-locations: classpath:mappers/** # 指定mapper映射文件
  configuration:
    map-underscore-to-camel-case: true # 开启驼峰式映射

application.yaml

5.7.修改启动类(QuickStartApplication.java)

修改启动类（QuickStartApplication.java），在类中使用新增@MapperScan注解，指定mapper接口所在的包；

package com.zhanggen;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

//这个类的位置;放到com.zhanggen包下面
@SpringBootApplication
//扫描映射层的mapper包
@MapperScan("com.zhanggen.mapper")
public class QuickStartApplication {
    public static void main(String[] args) {
        //参数1:当前类字节码  参数2：args
        SpringApplication.run(QuickStartApplication.class, args);
    }
}

QuickStartApplication.java

5.8.测试

修改UserController代码为从数据库查询，然后重启程序进行测试。

package com.zhanggen.web.controller;

import com.zhanggen.config.UserConfig;
import com.zhanggen.domain.User;
import com.zhanggen.mapper.UserMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.Mapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

//这个文件和SpringMVC的Controller是一样的
@RestController
@Slf4j //这是Lombok提供的注解，此注解标注在类上之后，在类中就有1个log对象可以输出日志信息了
public class IndexController {
    //注意Environment位于org.springframework.core.env.Environment包
    @Autowired
    private Environment environment;

    @Value("${user.username}")
    private String username;

    @Value("${user.password}")
    private String password;

    @Autowired
    private UserConfig userConfig;


    @GetMapping("/index")
    public String index() {
        //方式1：使用Environment对象，获取配置文件中的值
        System.out.println(environment.getProperty("user.username"));
        System.out.println(environment.getProperty("user.password"));
        //方式2：使用@Value，获取配置文件中的值
        System.out.println(this.username);
        System.out.println(this.password);
        //方式3：通过定义UserConfig对象获取配置文件中配置信息
        System.out.println(userConfig.getUsername());
        System.out.println(userConfig.getPassword());

        log.debug("debug");
        log.info("info");
        log.error("error");
        return "hello springBoot!";

    }

    @Autowired
    private UserMapper userMapper;

    @GetMapping("/user")
    public List<User> findAll() {
        return userMapper.findAll();
    }
}

IndexController.java

6.SpringBoot获取Session对象

没有了HttpServletRequest实现类对象，我们可以从spring的容器中要session对象；

   @Autowired
    private HttpSession session;

五、SpringBoot整合SSM框架集(分模块开发)

基于SpringBoot分模块开发整合SSM框架

六、SpringBoot自动装配源码分析

SpringBoot项目中没有配置注解扫描，类中的注解是怎么被自动扫描到的？　 -------》@componentScan("启动类所在包的包名")

SpringBoot项目中没有配置DispatherServlet，为什么SpringMvc生效了? 　　-------》自动装配机制

1.SpringBoot自动装配机制

在SpringBoot项目的启动类上有1个复合注解叫做@SpringBootApplication；

@SpringBootApplication复合注解中包含1个@EnableAutoConfiguration（开启自动装配）的注解，作用是：

SpringBoot启动时找到ClassPath下当前项目引入的依赖jar包下/META-INF/spring.factories文件；
从spring.factories文件中1个名为org.springframework.boot.autoconfigure.EnableAutoConfiguration的键中找到所有自动装配类；
每一个自动装配类都有1个将当前装配类装配到springIOC容器的动作
执行该动作的代码把当前装配类装配到Spring容器中

这个过程就是自动装配；

2.SpringBoot按条件装配

并不是读取META-INF/spring.factories所有的Bean都会被初始化，而是通过判断每1个Starter的配置类中的@Condition是否满足加载满足条件，来加入Bean的；

- ConditionalOnClass：判断当前项目的classpath下是否存在指定类，若是则将当前的配置装载入spring容器。
- ConditionalOnProperty：判断配置文件中是否有对应属性和值才初始化Bean
- ConditionalOnMissingBean：判断如果IOC容器中没有对应Bean，才初始化Bean

SpringBoot支持条件装配，当前装配类装配到Spring容器之前，会检测当前装配类是否在当前项目的pom.xml依赖配置中？

满足条件时才可以被装配到Spring容器，称为按条件装配，并不是一次全部装配到Spring容器中；

3.@ConditionalOnProperty(name = "rule.transfor", havingValue = "rule")

在spring boot中有时候需要控制配置类是否生效,可以使用@ConditionalOnProperty注解来控制@Configuration是否生效。

七、SpringBoot的启动流程

参考

posted on 2022-05-26 08:59 Martin8866 阅读(3123) 评论(0) 编辑收藏举报

刷新页面返回顶部

基于SpringBoot实现SSM框架整合

前言

一、SpringBoot概述

1.Spring优缺点

1.1.优点

1.2.缺点

2.SpringBoot概述

3.SpringBoot主要功能

二、SpringBoot入门案例

1.创建工程

2.编写Controller

3.编写启动类

4.案例解析

4.1.版本锁定

4.2.起步依赖

4.3.内置Tomcat

4.4.默认配置

三、SpringBoot配置文件

1.自定义配置文件

2.yaml介绍

2.1.语法

2.2.数据格式

3.SpringBoot读取配置文件的三种方式

3.1.Environment(了解）

3.2.@Value注解 (了解)

3.3.@ConfigurationProperties注解

3.4.配置文件信息

3.5.获取代码

4.SpringBoot多环境配置

4.1.配置文件

5.SpringBoot项目打包

1.命令格式传递参数

四、SpringBoot整合SSM框架集

1.日志输出设置

1.1.修改springBoot配置文件

1.2.设置输出日志级别

2.单元测试

2.1.引入依赖

2.2.编写测试类

3.释放静态资源

3.1.classpath是什么？

3.2.SpringBoot静态资源存放路径（默认）

3.3.自定义SpringBoot静态资源存放路径

4.拦截器配置

4.1.定义拦截器类

4.2.注册拦截器

5.整合Mybatis

5.1.数据准备

5.2.添加依赖

5.3.创建实体类

5.4.创建UserMapper接口

5.5.创建UserMapper映射文件

5.6.添加springBoot配置文件

5.7.修改启动类(QuickStartApplication.java)

5.8.测试

6.SpringBoot获取Session对象

五、SpringBoot整合SSM框架集(分模块开发)

六、SpringBoot自动装配源码分析

1.SpringBoot自动装配机制

2.SpringBoot按条件装配

3.@ConditionalOnProperty(name = "rule.transfor", havingValue = "rule")

七、SpringBoot的启动流程

公告