关于springboot

Posted 2021-02-03 sky-raining

概念

Spring的优缺点

1. 优点(AOP和IOC简化开发)
 Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。
2. 缺点(配置繁琐和pom.xml的坐标引入麻烦)
 1. 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。
 2. 所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。
 3. 除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。
 

SpringBoot

1. springboot解决spring的缺点:
 SpringBoot基于**约定优于配置**的思想,不必在配置与逻辑业务之间进行思维的切换,从而大大提高了开发的效率.
2. SpringBoot的特点:
 1. 为基于Spring的开发提供更快的入门体验
 2. 开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求
 3. 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等
 4. SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式
3. 核心功能
 1. 起步依赖(start dependence)
 起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
 简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
 2. 自动配置(auto configuration)
 SpringBoot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。
 

开始代码

快速开始

1. 创建普通的maven项目,简单的javase就好
2. 编写pom.xml文件
 1. SpringBoot要求，项目要继承SpringBoot的起步依赖spring-boot-starter-parent
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.0.5.RELEASE</version>
 </parent>
 2. SpringBoot要集成SpringMVC进行Controller的开发，所以项目要导入web的启动依赖(以功能为单位的)
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 </dependencies>
3. 编写启动引导类(引导类放置的位置在创建项目时指定的groupid包下)
 package cn.wzlove;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 // 使用注解标注该类是SpringBoot的引导类
 @SpringBootApplication
 public class MySpringBootApplication {
 
 public static void main(String[] args) {
 // run方法表示运行SpringBoot的引导类,参数是SpringBoot引导类的字节码文件
 SpringApplication.run(MySpringBootApplication.class);
 }
 
 }
4. 编写Controller进行测试
 @Controller
 public class QuickController {
 
 @RequestMapping("quick")
 @ResponseBody
 public String quickStart(){
 return "quick start";
 }
 }
 ====================================
 或者使用RestController
 @RestController
 public class HelloController {
 
 @RequestMapping("hello")
 public String hello(){
 return "hello";
 }
 }
 

SpringBoot的热部署

1. 添加功能坐标:
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-devtools</artifactId>
 </dependency>
2. idea的配置
 file ---> setting,搜索compile,选中Compile,右侧会出现内容,这个时候选中Build project automatically.点击apply,点击ok
3. 快捷键ctrl+alt+shift+/,选中Registry,在aompiler.automake.allow.when.app.running后面打上对勾,之后关闭就好.
 

idea快速创建SpringBoot项目

1. file创建工程,这个时候不要选择maven,而是选择Spring Initializr,点击下一步,输入Group和Artifact,下一步,选择依赖,目前先选择Web下的Web,下一步,就可以一完成创建了.

SpringBoot的原理分析:

起步原理分析

1. SpringBoot继承的起步依赖spring-boot-starter-parent
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.0.6.RELEASE</version>
 </parent>
 查看源码可以看到默认加载resources下的以application开头的配置文件和各种插件,并且还继承了spring-boot-dependencies.
 
 继续查看spring-boot-dependencies的源码,主要看<properties></properties>之间的内容,也就是版本控制,里面包含了各种依赖包的版本号,继续看<dependencyManagement>里面的内容,版本统一管理器.
 
 这下就可以看出来继承的起步依赖主要是为了进行jar包的版本控制的.这样我们在pom文件中导入依赖就不需要指定版本了.
2. web工程的起步依赖所做的事
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 查看源码可以看到这个依赖内部引入了更多的依赖,比如过spring-web,spring-webmvc,json等等,传递依赖.
 

自动配置

1. 从@SpringBootApplication开始研究,自动配置就是从这开始的.查看源码主要看:
 // SpringBootConfiguration其实就是@Configuration,指定配置文件的
 @SpringBootConfiguration
 // 自动配置
 @EnableAutoConfiguration
 // 根据约定大于配置,所以默认的扫描包是启动类下及其子包下的所有Bean
 @ComponentScan(excludeFilters = {
 @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
 @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
2. @EnableAutoConfiguration代表是否可以自动配置 ,查看源码主要看@Import(AutoConfigurationImportSelector.class),查看AutoConfigurationImportSelector类下的selectImports方法,看List<String> configurations = getCandidateConfigurations(annotationMetadata,attributes);其实应该就是全包名的集合,点进去看看,会让去查找META-INF/spring.factories下的这个文件,这个文件在当前类所在的包下,打开看看就是各种全类名.可以继续向下研究,查看各种AutoConfiguration类的源码

创建配置文件修改端口号和web应用的名称

resources下创建application.properties,内容为:
 # 设置启动端口号为8081
 server.port=8081
 # 当前web的应用名称
 server.servlet.context-path=/springboot
 

SpringBoot的配置文件:

配置文件类型和作用:

1. 覆盖默认配置: SpringBoot是基于约定的，所以很多配置都有默认值，但如果想替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。
2. 配置额外信息,比如数据源等等
3. 配置文件放在resources目录下.默认加载application.properties或application.yml（application.yaml）文件
4. application.properties文件是键值对类型的文件.yml文件类似于json.
 

yml文件

1. YML文件格式是YAML (YAML Aint Markup Language)编写的文件格式，YAML是一种直观的能够被电脑识别的的数据数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, php等。YML文件是以数据为核心的，比传统的xml方式更加简洁。
2. YML文件的扩展名可以使用.yml或者.yaml。(SpringBoot是有默认加载顺序的,源码可以看到,先加载yml的,后加载yaml的,最后加载properties,后面的会覆盖前面的).
3. 语法形式:
 1. 配置普通数据
 name: wangzhi =====> 冒号后面有空格
 2. 配置对象数据(person对象为例),两种,推荐第一种
 person:
 name: zhangsan
 age: 18
 addr: beijing
 =============================
 person: {name: zhangsan,age: 18,addr: beijing}
 3. 配置数组
 普通数组:
 city:
 - beijing
 - tianjin
 - chongqing
 - shanghai
 =============================
 city: [beijing,tianjin,chongqing,shanghai]
 对象集合:
 student:
 - name: tom
 age: 18
 addr: beijing
 - name: lucy
 age: 17
 addr: yuncheng
 ============================
 student: [{name: zhangsan,age: 18,addr: beijing},{name: tom,age: 18,addr: beijing}]
 4. map配置:
 map:
 key1: value1
 key2: value2
4. 测试注入:
 application.yml的内容为:
 name: wangzhi
 person:
 name: lucy
 age: 24
 addr: 运城
 代码内的注入(使用@Value注解):
 @Value("${name}")
 private String name;
 @Value("${person.addr}")
 private String addr;
 @Value("${person.age}")
 private int age;
 代码内的注入方式2:
 通过注解@ConfigurationProperties(prefix="配置文件中的key的前缀")可以将配置文件中的配置自动与实体进行映射,需要提供get和set方法
2. 执行器的配置(编写yml的文件的时候有代码提示,不配置也可以完成功能)
 <[email protected]的执行器的配置-->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-configuration-processor</artifactId>
 <optional>true</optional>
 </dependency>
 

SpringBoot与其他技术的整合

与Mybatis的整合

1. 添加Mybatis的起步依赖
 <!--mybatis起步依赖-->
 <dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter</artifactId>
 <version>1.3.2</version>
 </dependency>
2. 添加数据库驱动坐标
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 </dependency>
3. 添加数据库的连接信息(在resources下的application.properties添加内容):
 # 数据库的连接信息
 spring.datasource.driverClassName=com.mysql.jdbc.Driver
 spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8
 spring.datasource.username=root
 spring.datasource.password=nrblwbb7
4. 创建数据库和表结构:
 CREATE DATABASE test;
 USER test;
 DROP TABLE IF EXISTS `user`;
 CREATE TABLE `user` (
 `id` INT(11) NOT NULL AUTO_INCREMENT,
 `username` VARCHAR(50) DEFAULT NULL,
 `password` VARCHAR(50) DEFAULT NULL,
 `name` VARCHAR(50) DEFAULT NULL,
 PRIMARY KEY (`id`)
 ) ENGINE=INNODB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
 INSERT INTO `user` VALUES (‘1‘, ‘zhangsan‘, ‘123‘, ‘张三‘);
 INSERT INTO `user` VALUES (‘2‘, ‘lisi‘, ‘123‘, ‘李四‘);
 SELECT * FROM USER;
5. 创建实体类
 public class User {
 // 主键
 private Long id;
 // 用户名
 private String username;
 // 密码
 private String password;
 // 姓名
 private String name;
 
 //此处省略getter和setter方法 .. ..
 }
6. 创建mapper接口
 public interface UserMapper {
 List<User> queryUserList();
 }
7. 创建映射配置文件(在resources下新建mapper文件夹,在下面创建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="cn.wzlove.mapper.UserMapper">
 <select id="queryUserList" resultType="user">
 select * from user
 </select>
 </mapper>
8. 配置文件配置mybatis的信息:
 #spring集成Mybatis环境
 #pojo别名扫描包
 mybatis.type-aliases-package=cn.wzlove.domain
 #加载Mybatis映射文件
 mybatis.mapper-locations=classpath:mapper/*Mapper.xml
9. 写个Controller进行代码测试
 @RestController
 public class Controller {
 
 @Autowired
 private UserMapper userMapper;
 
 @RequestMapping("mybatis")
 public String testMyBatis(){
 List<User> users = userMapper.queryUserList();
 System.out.println(users);
 return "success";
 
 }
 }

与Junit的整合

1. 添加SpringBoot集成Junit测试的起步依赖(如果使用idea创建的话会直接引入,不需要重复导入)
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
2. 编写测试类:
 // SpringRunner继承自SpringJUnit4ClassRunner，使用哪一个Spring提供的测试测试引擎都可以
 @RunWith(SpringRunner.class)
 // classes后面的字节码是启动类的字节码
 @SpringBootTest(classes = SpringbootMybatisApplication.class)
 public class UserMapperTest {
 
 @Autowired
 private UserMapper userMapper;
 
 @Test
 public void testMyBatis(){
 List<User> users = userMapper.queryUserList();
 System.out.println(users);
 }
 }

与SpringDataJPA的整合

1. 添加Spring Data JPA的起步依赖
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
2. 添加mysql连接驱动依赖
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 </dependency>
3. 在application.properties中配置数据库和jpa的相关属性
 # 配置数据库的连接信息
 spring.datasource.driver-class-name=com.mysql.jdbc.Driver
 spring.datasource.url=jdbc:mysql:////127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8
 spring.datasource.username=root
 spring.datasource.password=nrblwbb7
 
 # 配置Spring Data JPA的相关信息
 spring.jpa.database=mysql
 spring.jpa.show-sql=true
 spring.jpa.generate-ddl=true
 spring.jpa.hibernate.ddl-auto=update
4. 创建实体并使用springdatajpa进行配置
 @Entity
 public class User {
 // 主键(mysql主键自增)
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;
 // 用户名
 private String username;
 // 密码
 private String password;
 // 姓名
 private String name;
 
 //此处省略setter和getter方法... ...
 }
5. 创建repository接口(也就是dao)
 /**
 * @ClassName UserRepository
 * @Author wz157
 * @Date 2018/10/19 23:18
 * @Description TODO
 * 两个泛型,第一个是实体,第二个是主键类型
 */
 public interface UserRepository extends JpaRepository<User,Long> {
 
 List<User> findAll();
 }
6. 创建测试类进行测试
 @RunWith(SpringRunner.class)
 @SpringBootTest(classes = SpringbootSpringdatajpaApplication.class)
 public class JpaTest {
 
 @Autowired
 private UserRepository userRepository;
 
 @Test
 public void testJps(){
 List<User> all = userRepository.findAll();
 System.out.println(all);
 }
 }
7. 如果是jdk9可能报错,需要额外引入依赖
 <dependency>
 <groupId>javax.xml.bind</groupId>
 <artifactId>jaxb-api</artifactId>
 <version>2.3.0</version>
 </dependency>
 

与Redis的整合

1. 配置redis的起步依赖:
 <!-- 配置使用redis启动器 -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>
2. 配置redis的连接信息(本地需要安装有Redis)
 #Redis
 spring.redis.host=127.0.0.1
 spring.redis.port=6379
3. 编写测试类:
 @RunWith(SpringRunner.class)
 @SpringBootTest(classes = SpringbootSpringdatajpaApplication.class)
 public class RedisTest {
 
 // 转化成json各执字符串
 @Autowired
 private RedisTemplate<String,String> redisTemplate;
 
 @Autowired
 private UserRepository userRepository;
 
 @Test
 public void testRedis() throws JsonProcessingException {
 // 1. 从redis中获取数据,习惯json字符串
 String userListJson = redisTemplate.boundValueOps("user.findAll").get();
 // 2. 判断redis是否存在数据
 if(null == userListJson){
 // 3. 如果不存在数据,从数据库查询
 List<User> all = userRepository.findAll();
 // 将查询出的数据存储到缓存中
 // 先将集合转换成json格式的字符串, 使用jackson进行转换
 ObjectMapper objectMapper = new ObjectMapper();
 userListJson = objectMapper.writeValueAsString(all);
 redisTemplate.boundValueOps("user.findAll").set(userListJson);
 System.out.println("=============从数据库中查询=============");
 } else{
 System.out.println("从缓存中查询");
 }
 // 4. 如果存在,将结果返回(测试直接打印就好)
 System.out.println(userListJson);
 } 
 }