SpringBoot2.0快速入门

朴灿烈づ我的快乐病毒、 2022-12-22 11:12 241阅读 0赞

# 学习目标 #

*  （1）spring boot核心
 *  （2）spring boot整合

# Spring Boot课程内容介绍 #

*  （1）Spring Boot简介
 *  （2）Spring Boot快速入门
 *  （3）Spring Boot原理分析
 *  （4）Spring Boot配置文件
 *  （5）Spring Boot与其他框架的整合

# Spring回顾 #

*  （1）Spring是什么？  
    Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的全栈，轻量级代替品
 *  （2）Spring核心是?  
    IOC，依赖注入 @Service@Repository,@Autowired  
    AOP，面向切面编程，事务，日志管理，权限
 *  （3）Spring特点是什么?  
    》Spring的组件代码是`轻量级的`，但它的配置却是`重量级的`  
    各种XML配置 application Context-dao.XML application Context-tx.XML springmvc.XML  
    》项目的依赖管理也是一件`耗时耗力`的事情，要十分注意版本兼容  
    pom.XML比较大

# Spring Boot介绍 #

*  （1）Spring Boot是什么?  
    Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程
 *  （2）Spring Boot的特点是什么?  
    》1 更快的入门体验  
    `开箱即用`  
    》2 也无需XML配置。同时也可以修改默认值  
    `基于约定优于配置的思想`  
    》3 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器等  
    》4 Spring Boot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式

# Spring Boot的核心功能概述 #

*  （1）起步依赖  
    起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
 *  （2）自动配置  
    Spring Boot的自动配置是一个运行时的过程  
    在应用程序启动时，自动加载默认配置，判断是否满足需求  
    如果满足，则不需要额度配置，否则加载额外配置

# Spring Boot快速入门-环境搭建 #

*  （1）创建Maven工程  
    该工程为普通的java工程即可
 *  （2）添加Spring Boot的起步依赖  
    》继承起步依赖spring-boot-starter-parent  
    》集成SpringMVC进行Controller的开发，要导入web的启动依赖
 *  （3）编写Spring Boot引导类
 *  （4）编写Controller
 *  （5）测试

## pom.xml ##

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

## Boot类 ##

@SpringBootApplication
    public class MySpringBootApplication { 
        public static void main(String[] args) { 
            //入口 初始化springboot
            SpringApplication.run(MySpringBootApplication.class);
        }
    }

## Controller ##

@Controller
    public class Demo01Controller { 
    
        @RequestMapping(path="/demo01",method = { RequestMethod.GET,RequestMethod.POST})
        public @ResponseBody
        String demo01(){ 
            return "HelloWorld!!!";
        }
    }

# Spring Boot快速入门-入门解析 #

*  （1）SpringBoot代码解析  
    `@SpringBootApplication`：标注SpringBoot的启动类，该注解具备多种功能（后面详细剖析）
 *  （2）`SpringApplication`.run(MySpringBootApplication.class) 代表运行SpringBoot的启动类，参数为SpringBoot启动类的字节码对象

# 快速创建springboot工程 #

*  （1）选择springboot初始化工具
 *  （2）设置包名，工程名
 *  （3）选择web依赖
 *  （4）复制controller(springboot将依赖，配置承包了，开发者只要写三层架构的代码)
 *  （5）启动  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 1]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 2]

# Spring Boot的原理分析-起步依赖-parent #

*  （1）分析spring-boot-starter-parent
 *  （2）分析spring-boot-starter-dependencies
 *  （3）一部分坐标的版本、依赖管理、插件管理已经定义好
 *  （4）SpringBoot工程继承spring-boot-starter-parent后已经具备版本锁定等配置  
    `起步依赖的作用就是进行依赖的传递`

# springboot打包插件 #

加上maven的打包插件，用于做微服务，分布式，内部包含了tomcat

## pom.xml ##

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

![在这里插入图片描述][20201113173827525.png_pic_center]

# Spring Boot的配置文件的类型和作用 #

*  （1）SpringBoot是基于约定的，所以很多配置都有默认值
 *  （2）为什么还要有配置文件？  
    想使用自己的配置替换`默认配置`
 *  （3）配置文件有两种  
    `application.properties`  
    `application.yml（application.yaml）`
 *  （4）SpringBoot默认会从Resources目录下加载application.properties或application.yml（application.yaml）文件

# Spring Boot的配置文件-yml文件的简介 #

*  （1）什么是yml?  
    YML文件格式是YAML (YAML Aint Markup Language)编写的文件格式
 *  （2）有什么特点?  
    》YAML是一种直观的能够被电脑识别的的数据数据序列化格式  
    》并且容易被人类阅读  
    》可以被支持YAML库的不同的编程语言程序导入  
    》YML文件是以数据为核心的，比传统的xml方式更加简洁  
    application.yml

server:
      port: 8091
      servlet:
        context-path: "/web01"

# yml文件的的普通属性和对象属性 #

*  （1）如何使用yml?  
    YML文件的扩展名可以使用.yml或者.yaml。
 *  （2）配置普通数据  
    key: value  
    name: jack  
    value之前有一个空格
 *  （3）配置对象数据  
     ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 3]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 4]

# yml文件的集合配置 #

*  （1） 配置Map数据 同 对象
 *  （2）配置数组（List、Set）数据  
    注意：value1与之间的 - 之间存在一个空格  
    ![在这里插入图片描述][20201114093830246.png_pic_center]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 5]

# SpringBoot配置信息的查询 #

*  （1） 官方文档查询  
    `https://docs.spring.io/spring-boot/docs/2.4.0/reference/htmlsingle/#common-application-properties`
 *  （2）IDEA自动提示

![img][]

# Spring Boot集成Junit5 #

## 创建 ##

使用springboot创建就完成集成

## 测试 ##

*  （1）在Spring Boot项目中使用Junit进行单元测试  
    PersonService的方法
 *  （2）添加Junit的起步依赖  
    以前使用junit4  
    现在，springboot 2.4 自动使用junit5
 *  （3）编写测试类  
    `@SpringBootTest`  
    public class TextXxx  
    在Spring Boot项目中如果编写测试类则必须要在类上面添加@SpringBootTest  
    2.4.0版本使用Junit5，`不需要加@Runwith`

## Demo02junitApplicationTests ##

@SpringBootTest
    class Demo02junitApplicationTests { 
    
        //查询所有的Person
        @Autowired
        private IPersonService service;
        @Test
        void contextLoads() { 
            service.savePerson();
        }
    
    }

## IPersonService ##

public interface IPersonService {
        void savePerson();
    }

## PersonServiceImpl ##

@Service
    public class PersonServiceImpl implements IPersonService {
        @Override
        public void savePerson() {
            System.out.println("savePerson");
        }
    }

# hikari数据库连接池 #

*  （1）Hikari 光
 *  （2）Hikari 是什么?  
    HikariCP是现在比较快，而且轻量的连接池
 *  （3）Hikari 有什么特点  
    》Hikari是一款非常强大，高效，并且号称“史上最快连接池”  
    》在springboot2.0之后，采用的默认数据库连接池就是Hikari。  
    不需要引入依赖，已经在SpringBoot中包含了。  
    GitHub地址：https://github.com/brettwooldridge/HikariCP

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 6]

# 手动使用hikari #

## pom.xml ##

<dependencies>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.39</version>
            </dependency>
            
            <dependency>
                <groupId>com.zaxxer</groupId>
                <artifactId>HikariCP</artifactId>
                <version>3.4.5</version>
            </dependency>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13.1</version>
                <scope>test</scope>
            </dependency>
        </dependencies>

## Test01 ##

public class TestHikari { 
        @Test
        public void test01() throws SQLException { 
            HikariConfig config = new HikariConfig();
            config.setJdbcUrl("jdbc:mysql://localhost:3306/test01");
            config.setUsername("root");
            config.setPassword("123456");
            HikariDataSource ds = new HikariDataSource(config);
            System.out.println(ds.getConnection());
    
        }
    
        @Test
        public void test02() throws SQLException { 
            //直接初始化HikariDataSource
            HikariDataSource hds = new HikariDataSource();
            hds.setJdbcUrl("jdbc:mysql://localhost:3306/test01");
            hds.setUsername("root");
            hds.setPassword("123456");
            System.out.println(hds.getConnection());
        }
    
    }

# Spring Boot整合-连接池 #

*  （1）数据库连接池hikari配置  
    只需要在application,`yml`配置文件中指定数据库相关参数

spring:
      datasource: # hikari
        driver-class-name: com.mysql.cj.jdbc.Driver # mysql 8
        username: root
        password: 123456
        url: jdbc:mysql://localhost:3306/springboot_test

*  （2）事务配置
    
    1.  添加事务相关的启动器依赖，mysql相关依赖；
    2.  编写业务类UserService使用事务注解@Transactional

# Spring Boot集成Mybatis #

*  （0）准备数据库创建user表

create database springboot_test;
    
    create table person(
    	id  int primary key auto_increment,
    	name varchar(20),
    	age int
    )

## domain中的person类 ##

package com.lbl.springboot_study.domain;
    
    import lombok.Data;
    
    import javax.persistence.Entity;
    import javax.persistence.Id;
    
    /** * Created by 李柏霖 * 2020/11/19 20:09 */
    
    @Data
    @Entity
    public class Person { 
        @Id
        private int id;
        private String name;
        private int age;
    }

*  （1） 添加启动器依赖；（自动添加 使用springboot init…勾选)
 *  （2）配置Mybatis：实体类别名包，日志，映射文件等；

spring:
      datasource: # hikari
        driver-class-name: com.mysql.cj.jdbc.Driver # mysql 8
        username: root
        password: 123456
        url: jdbc:mysql://localhost:3306/springboot_test?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
    
    mybatis:
      type-aliases-package: com.lbl.springboot_study.domain #别名
      mapper-locations: classpath:com.wzx.demo04mybatis.dao/*.xml #xml文件
      #使用注解在启动类上面配置 @MapperScan("com.wzx.demo04mybatis.dao")//存放接口
      configuration:
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #mybatis日志

## Demo04mybatisApplication ##

@SpringBootApplication
    @MapperScan("com.wzx.demo04mybatis.dao")//存放接口
    	public class Demo04mybatisApplication { 
    		public static void main(String[] args) { 
    			SpringApplication.run(Demo04mybatisApplication.class, args);
    	}
    }

# Spring Boot集成Mybatis测试 #

*  （4）编写Mapper

public interface PersonDao { 
        //全查
        List<Person> findAllPersons();
    }

*  （5）配置Mapper映射文件

<?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.wzx.demo04mybatis.dao.PersonDao">
        <select id="findAllPersons" resultType="person">
            select * from person
        </select>
    </mapper>

*  （6）测试

@SpringBootTest
    class Demo04mybatisApplicationTests { 
    
        @Autowired
        PersonDao dao;//Alt+Enter修复 disabled inspection
        @Test
        void test01() { 
            System.out.println(dao.findAllPersons());
        }
    
    }

# Mysql驱动8的问题 #

java.sql.SQLException: The server time zone value

*  （1）com.mysql.cj.jdbc.Driver
 *  （2）jdbcURL  
    `jdbc:mysql://127.0.0.1:3306/test01?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8`

# Spring Boot集成Jpa #

*  （1）添加Spring Data JPA的起步依赖
 *  （2）添加数据库驱动依赖
 *  （3） 在application.properties中配置数据库和jpa的相关属性  
    `空格不能随便删除`

spring:
      datasource: # hikari
        driver-class-name: com.mysql.cj.jdbc.Driver # mysql 8
        username: root
        password: admin123
        url: jdbc:mysql://localhost:3306/springboot_study?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
    # 配置jpa PhysicalNamingStrategyStandardImpl小驼峰 xx_yy_xx
      jpa:
        show-sql: true
        hibernate:
          ddl-auto: update
          naming:
            physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
        database: mysql

# 测试 #

@SpringBootTest
    class Demo05jpa2ApplicationTests { 
    
        @Autowired
        UserDao userDao;
    
        @Test
        void test01() { 
            User user = new User();
            user.setGirlFriend("rose");
            user.setUsername("jack@xx.com");
            user.setName("jack");
            userDao.save(user);//--->orm -- >将对象值取出-->sql-->数据库
        }
    
    
    }

## User ##

@Entity //表示当前类，在数据库有表与它对应
    @Table(name = "tb_user2")
    public class User { 
        @Id //表示id
        @GeneratedValue(strategy = GenerationType.IDENTITY) //主键自增长
        private int id;
        private String username;
        private String password;
        private String girlFriend;
        private String name;

## UserDao ##

//继承通用的接口，即可完成增删改查
    public interface UserDao extends JpaRepository<User,Integer> { 
    }

# SpringBoot2.0 集成 redis #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 7]

# Spring Boot 集成Redis #

*  （1）添加redis的起步依赖
 *  （2） 配置redis的连接信息

## pom.xml ##

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

## yml ##

spring.redis.host=localhost
    spring.redis.port=6379

*  （3）注入RedisTemplate测试redis操作

@SpringBootTest
    class Demo06redisApplicationTests { 
    
        @Autowired
        RedisTemplate<String, String> rt;
    
        @Test
        void test01() { 
            //查找是否有缓存
            String json = rt.boundValueOps("cache1").get();
    
            //有就直接返回
            if (json != null) { 
                System.out.println("来自缓存:" + json);
            } else { 
                String json_ = "{name:jack,age:13}";
                //没有就先存，再返回
                rt.boundValueOps("cache1").set(json_);
                System.out.println("保存json " + json_);
            }
    
    
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/ddbfafc721264bdd996e305af21cf8a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/ebf142d15fec4594a68e784b1d4c1266.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/fa603781920145d7a0f2719abeca6d40.png
[20201113173827525.png_pic_center]: /images/20221120/42ee8b4c4e1c42209eb9a692eeab7479.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/37f7f61d4e1547b08e3afc7fe4b3440f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/fe601d4ea0c344cda0f7ffaf088d448e.png
[20201114093830246.png_pic_center]: /images/20221120/5bfcc027e01d4149ad0c6a436d02ddf8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/dec80cf780de4ac58f5fec0d05303093.png
[img]: /images/20221120/d084caffb6be4d8e9e76f98b02eb4e89.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/5d21bd9660f7418a8c1ec4eebe303a59.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM2MjEzOTg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/ca59b089aae847099b16484e9820162e.png