Spring boot小白自学之路 笔记

---

Spring Boot 自学之路

提示：以下是本篇文章正文内容，下面案例可供参考

简介

简化Spring应用开发的框架；
整个spring技术栈的一个大整合；
javaee开发的一站式解决方案

想用springboot快速搭建环境以及开发过程基本要求：
该框架使用了特定的方式来进行配置，

springboot 快速开发框架，微框架
springboot = spring（项目管理）+springmvc（控制器）

springboot的特点：
1.能够构建一个独立的spring应用
2.springboot开发的应用 内嵌tomcat容器，不需要部署war文件
3.简化maven配置 只需要导入一到两个依赖
4.自动配置spring应用和springmvc应用
5.没有xml文件，（关于spring的xml文件不需要！！！）

springboot 约定：
Application 是springboot应用的全局入口类，这个类只能出现一次，而且这个类要在所有子包之上！
springboot的配置文件：application.yml

配置springboot

1.引入依赖 pom.xml
   <!-- 引入springboot 的web支持 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- 继承springboot的父项目 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.7.RELEASE</version>
    </parent>

2.引入springboot配置文件
application.yml 必须在 src/main/resources根目录中
3.开发spring boot开发入口类

com.hbsi.Application
@SpringBootApplication //注解：代表这个类是一个springboot入口类 这个注解只能出现一次！
public class Application {

 public static void main(String[] args) {
        //启动spring boot应用
        SpringApplication.run(Application.class,args);
    }

4.开发控制器！！

@Controller
@RequestMapping("hello")
public class HelloController {
    @RequestMapping("hello")
    @ResponseBody
    public String hello(){
        System.out.println("hello嘿嘿");

        return "hello springboot";
    }
}

注意：springboot开发的项目 默认没有项目名
在application.yml中配置
http://localhost:8888/hello/hello
server.port:8888 修改服务器端口
server.context-path: /ems 把应用名改为/ems 访问时需要 http://localhost:8888/ems/hello/hello

Spring boot注解

1.@SpringBootApplication 用来标识这是一个spring boot入口类 只能出现一次
是一个派生注解也可以叫做组合注解
@SpringBootApplication=@SpringBootConfiguration +@EnableAutoConfiguration +@ComponentScan
@SpringBootConfiguration 标识这是一个spring boot入口类
@EnableAutoConfiguration 核心注解，自动配置spring以及项目中引入第三方技术的自动配置
@ComponentScan 组件扫描注解||注解扫描 会默认扫描入口类所在的包及其的子包 所以需要把入口类放到所有子包之上
2.main函数作用：
①通过main函数这种方式来启动内部内嵌tomcat服务器
②SpringApplication.run(Application.class,args);
参数1：入口类类对象 目的让@EnableAutoConfiguration自动配置spring时将@ComponentScan扫描注解创建对象一并放入工厂
参数2：main函数的参数，这个参数通过指定外部虚拟机参数形式覆盖应用内部默认参数
3.spring boot全新注解
@RestController == @Controller+@ResponseBody
范围：用在类上，用在所有控制器上
作用：将控制中所有方法返回值转化为json并响应到前端
如果将控制中所有方法返回值转化为json时再使用，如果还有方法要响应视图就只能用@Controller

Springboot配置文件拆分

spring.profiles.active：dev -->激活application-dev.yml配置

springboot工厂特性——创建对象

一次性创建多个组件对象包含复杂对象
@Configuration 配置注解 修饰范围：用在类上 作用：相当于曾经的spring.xml文件给一个类加上@Configuration 会把他的方法当作创建的bean对象 需要给方法前面加上@Bean注解 用来创建一个对象在工厂中一个实例

---

创建一个cofig包下面创建一个BeansConfig 类

//一次性再工厂中批量创建多个对象
@Configuration
public class BeansConfig {
//工厂中每一个方法代表一个对象的创建Calendar
    @Bean //修饰范围用在方法上 相当于spring.xml bean标签作用 用来创建一个对象在工厂中一个实例
    public Calendar getCalendar(){
        return Calendar.getInstance();
    }
    }

----------------------------------------------------------------------------------------------------------------------------
//mysql数据库配置
    @Bean
    @Scope("prototype")
    public Connection getconnection() throws ClassNotFoundException, SQLException {
        Class.forName("com.mysql.jdbc.Driver");
        Connection connection = DriverManager.getConnection("jdbc:mysql:///gjp","root","1234");
        return connection;  
        }

---

日后再springboot中 创建单个对象使用@Component 创建多个对象使用@Configuration
@Configuration和@Component功能一样 但语义不一样 @Configuration是在springboot中出现的全新的注解
@Scope(“prototype”) 表示每次获取都是一个崭新的对象
@Scope默认是单例模式，即scope=“singleton”。
另外scope还有prototype、request、session、global session作用域。
scope="prototype"多例

spring boot中注入语法

1.使用@Value注解进行属性注入

    @Value("${qname}")
    private String qname;
qname需要在application.yml中设置	qname: 老哥
还可以注入已知的值
@Value("${server.port}")
private String port; 
    
-----------------------------------
用@Value注入集合时：
日期注入：
@Value("${dir}")
application.yml配置文件：
dir: 2020/10/04

-----------------------------------
List集合：
 @Value("#{'${qqs}'.split(',')}")
    private List<String> qq;
split(',')表示之间用 , 隔开
application.yml配置文件:
qqs: 安琪，安啦，安吧吧

------------------------------------
Map集合：
 @Value("#{${maps}}")
    private Map<String,String> maps;
application.yml配置文件：
maps: "{a: '小黑',b: '小白'}"

------------------------------------

---

2.直接注入对象中属性：前缀注入方式

@ConfigurationProperties(prefix = "user")
会去application.yml中找前缀为 user的属性
application.yml中：
user:
  id: 10
  namea: 哈巴
  
-------------------------------------------
@Component
@ConfigurationProperties(prefix = "user")
public class User {
    private String id;
    private String namea;
    
-------------------------------------------
------------------------------------------------------------------------------------------------------------------
 <!--自定义注入时候构建元数据-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

spring boot中集成jsp展示

1.引入依赖：

<!-- 配置内嵌tomcat解析jsp-->
    <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-jasper</artifactId>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

配置视图解析前缀和后缀：在application.yml中：
springmvc.view.prefix//前缀
springmvc.view.suffix//后缀

注意：经过上述配置已经将视图切换为jsp展示，但是在IDEA中无法直接访问 需要使用插件启动

---

在 <plugins下：

  <!-- 使用插件启动spring boot -->
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
//Maven->springbootday1 Macen Webapp-> Plugins->spring-boot->spring-boot.run
//通过插件启动就可以访问jsp

---

修改当前spring boot项目的运行目录
Application wordking directory：$MODUL{E}_{W}ORKIN{G}_{D}IR$

spring boot与mybatis整合

1.引入依赖
spring boot相关依赖

mybatis-spring boot-starter//整合spring boot
mysql druid lombook

pom中导入mybatis整合依赖

    <!-- 整合mybatis依赖 -->
    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>2.1.3</version>
    </dependency>

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.44</version>
    </dependency>

    <!-- lombook -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.8</version>
      <scope>provided</scope>
    </dependency>
    ```
------------------------------------------------------------------------------------------------------------------------

2配置数据源：
在application.yml文件中：
spring:
  mvc:
    view:
      prefix: / #配置前缀
      suffix: .jsp #配置后缀
      #配置
  datasource: #配置数据源
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/gjp
    username: root
    password: 1234

mybatis:
  mapper-locations: classpath:com/hbsi/mapper/*.xml #扫描mybatis配置文件
  type-aliases-package: com.hbsi.entity #别名 同样是类名或者类名首字母小写

---

3.入口类中加入DAO接口扫描注解
@SpringBootApplication
@MapperScan(“com.hbsi.dao”)
public class Application {
4.建表
5.实体类
6.Dao接口
7.mapper配置文件
8.Service接口
9.ServiceImpl @Service @Transaction（事务注解） 注入Dao对象

---

@Param是MyBatis所提供的(org.apache.ibatis.annotations.Param)，
作为Dao层的注解，作用是用于传递参数，从而可以与SQL中的的字段名相对应
//start 起始条数 //size每页显示记录数
ListfindByPage( @Param(“start”) Integer start, @Param(“size”)Integer size);

---

创建Service以及ServiceImpl
ServiceImpl中添加注解：
@Service表明是Service
@Transactional事务注解
//自动装配Userdao对象
@Autowired
private UserDao userDao;

---

为findAll方法添加事务
@Override
    @Transactional(propagation = Propagation.SUPPORTS)//@Transactional(propagation=Propagation.SUPPORTS)
    //如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.
    public List<User> findAll() {
        return userDao.findAll();
    }

---

编写mybatis框架的配置文件：UserDaoMapper.xml

---

编写控制层：

@Controller //表明控制器
@RequestMapping("user")
public class UserContller {
//自动装配Service对象
 @Autowired
    private UserService userService;
    

findall方法查询信息

@RequestMapping("findAll")
    public String  findAll(Model model){ //Model是一个接口 这里用来调用它的addAttribute方法
        List<User> users = userService.findAll();
        model.addAttribute("users",users);//向jsp传递数值 类似于request.setAttribute("users",users)效果一样。
        System.out.println(users);
        return "showAll";
    }
    

save添加信息

@RequestMapping("save")
    public String save(User user){
        userService.save(user);
        System.out.println(user);
        return "redirect:/user/findAll"; //重定向跳转到查询所有
    }
    

spring boot本地测试和jsp页面热部署

本地测试：
spring boot使用junit测试，必须引入相关依赖
1.pom中:

<!-- 引入test支持 -->
    <dependency>
       <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
	<scope>test</scope>
    </dependency>

2.在src/test/java中创建测试类：BasicTest

-----------------------------------------------------------------------
@RunWith(SpringJUnit4ClassRunner.class) //
//@RunWith(SpringRunner.class) SpringRunner继承了SpringJUnit4ClassRunner 
@SpringBootTest(classes = Application.class)//会自动去寻找Appendable入口类 然后启动Spring boot
public class BasicTest {

    @Autowired
    private UserService userService;

    @Test
    public void testFindall(){
        userService.findAll().forEach(user -> System.out.println(user));
    }
}

-----------------------------------------------------------------------
如果要对UserService进行测试 可以直接让UserService继承BasicTest 
这样就不用每次测试都写上注解了

---

UserServiceTest ：

public class UserServiceTest extends BasicTest {
    @Autowired
    private UserService userService;

    @Test
    public void testFindall(){
        userService.findAll().forEach(user -> System.out.println(user));
    }
}

BasicTest ：

@RunWith(SpringJUnit4ClassRunner.class)
//@RunWith(SpringRunner.class)   @RunWith 用于指定junit运行环境   SpringRunner继承了SpringJUnit4ClassRunner
@SpringBootTest(classes = Application.class)//会自动去寻找Appendable入口类 然后启动Spring boot
public class BasicTest {
}

JSP页面热部署

JSP页面部署（spring boot中默认是以生产格式部署的 只改一下就不能再修改了）
（就是修改之后必须要重启服务器才能生效）
热部署：
在服务器不关闭的情况下（在不需要重启动服务器的情况下） 将jsp页面修改立即生效过程
1.修改spring boot中jsp页面 开发模式部署
在application.yml中添加：
server.jsp-servlet.init-parameters: （MAP集合，空格、换行、Tab键）
devlopment:(空格)true #jsp开发模式部署 支持热部署

server:
  jsp-servlet:
    init-parameters: 
      devlopment: true #jsp开发模式部署 支持热部署-

spring boot集成logback日志展示

---------------1.logback 日志 log4j---------------
定义：Logback是由log4j创始人设计的又一个开源日志组件。 轻量级 易用
---------------2.日志展示---------------
ALL>DEBUG>INFO>WARN>ERROC>OFF
日志级别：级别越低输出日志信息越多

---------------3.项目中日志分类---------------
项目根日志（RootLogger）全局日志 一个项目只有一个根日志
项目中子日志（logger）：包级别的日志 一个项目中可以有n个子日志
log4j.rootLogger=ERROR,stdout//项目中的根日志 ERROR关闭日志 stdout->starnd out 在控制台指定位置输出 stdout是一个变量存储日志信息
-------------------------------log4j-------------------------

#项目中的根日志 ERROR关闭日志 stdout->starnd out 在控制台指定位置输出 stdout是一个变量存储日志信息
log4j.rootLogger=ERROR,stdout
#向控制台打印
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
#指定打印日志格式       
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%5p [t] - %m%n        

#子日志 监控dao包
log4.logger.com.hbsi.dao=DEBUG     

---

在UserServiceimpl中:

 private Logger logger = Logger.getLogger(UserServiceImpl.class);     
 public List<User> findAll() {
        logger.debug("debug");
        logger.info("info");
        logger.error("error");
        logger.warn("warn");
        return userDao.findAll();
log4j.properties中测试：
log4j.logger.com.hbsi.service=ERROR/INFO/DEBUG/WARN     

---------------4.springboot中默认集成就是logback日志---------------
springboot中日志默认级别为INFO
-------使用自定义配置文件的形式配置日志：【功能相对强大，可以覆盖系统默认的配置】-----
1）不需要再有额外的jar包
2）log back沿用了log4j中所有语法和规则
3）使用自定义的logback.xml覆盖默认日志 【不推荐】
在当前项目的resources中创建logback.xml 就可以覆盖默认日志

在springboot配置文件中配置日志 ：

在application.yml中：

logging:
  level:
    root: INFO #指定日志级别
    com.hbsi.dao: debug #监听指定包中日志
  #path:  ./log #指定路径 默认名字为spring.log日志
  file:  ./log/aa.log #指定路径和名字生成日志

spring boot全局热部署

1.热部署
定义：在不需要重启启动程序就可以将代码的修改立即生效这个过程教做热部署

2.spring boot 官方提供两种方式
1)spring boot-devtools 推荐
2)spring-loaded 有时候不会生效
3)jrebel Jvm占用内存少 修改之后会立即改变无需等待 但是价格昂贵

3.spring boot如何开启全局热部署
1）引入依赖

 <!--引入热部署依赖-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <optional>true</optional>
    </dependency>

---

2)开启idea自动编译功能
File-settings-bulid,Execu…-compiler-勾上Build project automatically
3)开启idea中的允许在程序运行的过程中允许交换类文件（类加载器）
ctrl+alt+shift+/ ——》选择1.Registry —>compiler.automake.allow.when.app.running
4)重新启动项目

spring boot面向切面编程

面向切面编程
AOP（Aspect Oriented Programming），要解决的问题是将横切关注点与业务逻辑分离

---

Spring 提出 AOP 面向切面编程
AOP：通过动态为项目中某些类在运行的过程中动态创建代理对象，
在代理对象中完成一些额外功能。
概念：
1）通知(Adivce)：除了目标方法以外的操作，被称为通知；日志通知、性能通知、事务通知等
2）切入点(pointcut)：用来告诉项目中那些类中那些方法执行过程中加入通知
3）切面(Aspect)：通知+切入点
Spring中AOP编程
1)开发通知 前置通知 后置通知 环绕通知 异常通知
2）配置通知并组装切面
1.spring boot面向切面编程：
1）引入依赖：

<!-- 引入springboot 的aop支持 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

2）面向切面编程的相关注解：
@Aspect 注解：修饰范围用在类上 作用：代表这个类是一个切面配置类 相当于 aop：config标签
@Order 注解：修饰范围可以用在方法上 也可以用在类上 作用：控制多个切面执行顺序 value属性：
int类型的值 数字越小优先执行
注意！：Order注解加在方法上 无效！

com.hbsi下创建一个aspects包，包下创建类：MyAspects

@Component
@Aspect
public class MyAscpects {

通知相关注解：
修饰范围：用在方法上 作用：代表这个方法是一个通知方法
value属性：用来书写当前通知对应切入点表达式
@Before和@After 获取运行时方法的相关信息 可以在自定义通知方法中加入JoinPoint参数
@Before 前置通知

    //前置通知
    @Before(value = "within(com.hbsi.service.*ServiceImpl)")
   //参数JoinPoint 获取当前执行方法对象 方法参数信息 以及 目标对象
    public void before174(JoinPoint joinPoint){
        System.out.println("进入前置通知");
        System.out.println("当前执行方法名："+joinPoint.getSignature().getName());
        System.out.println("当前执行方法参数："+joinPoint.getArgs()[0]); //方法参数是数组
        System.out.println("目标对象target："+joinPoint.getTarget());
    }

@After 后置通知

//后置通知
@After(value ="within(com.hbsi.service.*ServiceImpl)")
    public void after(JoinPoint joinPoint){
        System.out.println("进入后置通知");
        System.out.println("当前执行方法明："+joinPoint.getSignature().getName());
        System.out.println("当前执行方法参数："+joinPoint.getArgs()[0]); //方法参数是数组
        System.out.println("目标对象target："+joinPoint.getTarget());
    }

@Around 环绕通知
获取运行时方法的相关信息并且可以放行当前方法继续执行，
参数需要再环绕通知方法中声明：
ProceedingJoinPoint proceedingJoinPointjoinPoint

    //环绕通知，执行目标方法之前会进入环绕通知，环绕通知放行之后 才会执行目标方法，执行完成目标方法之后，在回到环绕通知。
    @Around("within(com.hbsi.service.*ServiceImpl)")
    public Object around(ProceedingJoinPoint proceedingJoinPointjoinPoint) throws Throwable {//放行目标后执行完成目标方法还会返回到环绕通知 因此需要参数
        System.out.println("进入环绕通知");
        System.out.println("当前执行方法明："+proceedingJoinPointjoinPoint.getSignature().getName());
        System.out.println("当前执行方法参数："+proceedingJoinPointjoinPoint.getArgs());//[0]); //方法参数是数组
        System.out.println("目标对象target："+proceedingJoinPointjoinPoint.getTarget());
        //放行目标方法执行 返回一个结果
       try {
           Object proceed = proceedingJoinPointjoinPoint.proceed();//放行，执行目标方法
           System.out.println("目标方法执行后");
           return proceed;
       }catch (Exception e){
           System.out.println("目标方法执行之后");
           return null;
       }

spring boot中多个切面执行顺序

后置通知与前置通知执行顺序相反 前置是入栈 后置是出栈
多个aop切面的执行同样是一个栈式结构 先进后出！

文件上传与下载：

文件上传：

----------------------------------------文件上传--------------------------------------------
1.文件上传：
定义：用户将本地计算机文件上传到当前请求应用的服务器的过程
2.springmvc文件上传：
a.准备文件上传页面 表单提交方式必须为 post enctype 必须为multipart/form-data
b.开发控制在控制器中使用 MultiparFile 形式进行接受用户上传文件
c.使用MultipatFile方式接收文件必须在配置文件中配置文件上传解析器，且id必须是multipartResolver
d.multipartResolver在处理文件上传时要求项目中必须引入commons-fileupload
-------------------spring boot文件上传-------------------
1.准备上传页面 提供from表单 提交post enctype multipart/form-data
2.开发控制器 使用MultipartFile形式接收 将接收文件放入执行目录中即可
控制层：

@Controller
@RequestMapping("file")
public class FileController {

    @RequestMapping("upload")
    public String upload(MultipartFile aaa, HttpServletRequest request) throws IOException {
        System.out.println("文件名："+aaa.getOriginalFilename());
        System.out.println("文件类型:"+aaa.getContentType());
        System.out.println("文件大小:"+aaa.getSize());

        //根据相对获取绝对路径
        String realpath = request.getSession().getServletContext().getRealPath("/files");
        //创建时间文件夹
        String format = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        File file = new File(realpath,format);
        if(!file.exists())file.mkdirs();
        //获取文件后缀
        String extensin = FilenameUtils.getExtension(aaa.getOriginalFilename());
        //根据文件后缀动态获取文件类型
        String mimmType = request.getSession().getServletContext().getMimeType("."+extensin);
        System.out.println(mimmType);

        String newFileNamePrefix = UUID.randomUUID().toString().replace("-"," ")+
                new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date());
        String newFileName = newFileNamePrefix+"."+extensin;
        //处理上传操作
       // aaa.transferTo(new File(realpath,aaa.getOriginalFilename()));
        aaa.transferTo(new File(file,newFileName));//上传文件放到时间文件夹里面
        return "redirect:/upload.jsp";
    }
}

注意：在spring boot中上传文件存在大小的限制（默认10MB）
------------------------yml文件中设置文件上传大小-----------------
spring.http.multipart.max-request-size: 20971520 #20MB 20480KB 控制请求可以上传文件大小 单位为字节也可以写KB MB 默认为10MB （控制前端上传文件大小）
spring.http.multipart.max-file-size: 4MB #用来控制实际文件上传大小限制 默认为1MB (这个是控制文件实际大小)

文件下载：

1.文件下载
将应用服务器中指定应用目录中文件下载到用户本地计算机过程 称之为文件下载
2.开发文件下载步骤
1）将应用中指定下载文件放入应用指定目录中
2）开发下载页面并在页面中提供可以下载文件链接
3）开发控制器处理下载相关操作，获取下载指定文件标识，处理下载操作
注意：在开发下载控制中响应的是一个文件流，不能存在页面跳转

控制层：

@RequestMapping("file")
public class FileController {
    @RequestMapping("down")
    public void download(String fileName, HttpServletRequest request, HttpServletResponse response) throws IOException {
    //根据相对路径获取绝对路径
        String realPath = request.getServletContext().getRealPath("/files/download");
        //获取文件名，根据文件名去指定的目录读取文件
        FileInputStream is = new FileInputStream(new File(realPath,fileName));
        //设置下载时响应头
        //response.setHeader("content-disposition","attachment;fileName="+ URLEncoder.encode(fileName,"UTF-8"));
         response.setHeader("content-disposition","inline;fileName="+ URLEncoder.encode(fileName,"UTF-8"));  //inline 为在线观看
        ServletOutputStream outputStream = response.getOutputStream();
        //流的复制
        IOUtils.copy(is,outputStream);
        IOUtils.closeQuietly(is);
        IOUtils.closeQuietly(outputStream);
    }

---

与mybatis整合配置文件----UserDaoMapper.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.hbsi.dao.UserDao"><!--在mybatis中，映射文件中的namespace是用于绑定Dao接口的，即面向接口编程。-->
    <!--插入数据-->
   <insert id="save" parameterType="user"><!-- parameterType 输入参数 参数为值的类型 -->
        insert into ssm values(#{id},#{name},#{age},#{bir});
    </insert>
        <!--查询 -->
    <select id="findAll"  resultType="User"> <!--resultType 返回值 参数为值的类型 -->
         select id,name,age,bir from ssm;
    </select>

</mapper>

pom配置文件

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/>  lookup parent from repository
    </parent>-->

    <groupId>com.hbsi</groupId>
    <artifactId>springbootdemo1</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springbootdemo1</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency> -->

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

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

</project>

Springboot 与MyBatis整合-----pom配置文件

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
  <!-- 继承springboot的夫项目 -->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.7.RELEASE</version>
  </parent>
  <dependencies>
    <!-- 引入springboot 的web支持 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 引入jsp支持 配置内嵌tomcat解析jsp -->
    <dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-jasper</artifactId>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!-- 整合mybatis依赖 -->
    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>2.1.3</version>
    </dependency>

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.44</version>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>org.junit.vintage</groupId>
          <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <!-- lombook -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.8</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>springbootday1</finalName>
    <plugins>
      <!--使用插件启动spring boot-->
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>