深入学习SpringBoot微服务框架

SpringBoot微服务框架目录

• 一、 SpringBoot简介
• • • 1、什么是SpringBoot?
    • 2、作用
    • 3、本质
    • 4、SpringBoot的好处
    • 5、搭建环境
    • • （1）全局入口类
      • （2)SpringBoot的配置文件
• 二、第一个SpringBoot应用程序搭建
• • • 0、环境版本要求
    • 1、搭建开发环境（引入相关依赖）
    • 2、引入SpringBoot相关的配置文件
    • 3、引入全局入口类
    • 4、开发一个控制器（书写一个Controller)
    • 5、返回页面
• 三、SpringBootApplication注解解析
• 四、SpringBoot配置文件的拆分
• • • 1、为什么要拆分配置文件
    • 2、以生产中项目名称不一致为例:
    • • （1)Application.yml 主配置
      • （2）开发中小配置文件application-.yml
      • （3）测试中小配置文件application-xxx.yml
      • （4）上线中小配置文件application-xxx.yml
    • 4、作用
• 五、SpringBoot对象的创建方式
• • • 1、Spring创建对象？
    • • （1）简单对象和复杂对象区别
    • 2、SpringBoot如何创建对象？
    • • （1）简单对象
      • （2）管理多个对象
• 六、SpringBoot集成JSP页面展示
• • • 1、当前控制器中不能直接返回jsp逻辑名（页面的名字） 出现404
    • 2、集成jsp页面
    • • （1）引入jsp的集成jar包
      • （2）在应用中配置页面路径的前后缀
      • （3)访问页面路径正常 但是展示404
• 七、SpringBoot整合Mybatis
• • • 1、Spring+Mybatis整合思路
    • 2、SpringBoot整合Mybatis
    • • （1）引入依赖
      • （2）编程步骤
      • (3)数据源相关的配置
      • （3）告知mapper文件所在路径 别名
      • （4)告知Dao接口所在包
• 八、SpringBoot测试
• • • 1、引入相关依赖,内部包含原有的测试依赖
    • 2、测试类和方法书写 考虑：测试时要启动SpringBoot的应用
    • • (1)写一个父测试类，将SpringBoot中测试所需要的注解写在父测试类上
      • （2）不同实体类相关的测试就可以继承父测试类直接写测试了
• 九、SpringBoot中开启jsp的热部署
• • • 1、热部署
    • 2、在配置文件中进行配置就可以了
• 十、SpringBoot切面编程
• • • 1、切面编程Aop面向切面编程 切面=通知+切入点
    • 2、Spring怎么样完成AOP编程
    • • a、开发通知 额外通知
      • b、aop相关设置
    • 3、SpringBoot怎么完成Aop编程 核心：注解
    • • (1)引入相关依赖
      • （2）通知相关的注解：方法上
    • 4、SpringBoot中前置通知和后置通知
    • 5、SpringBoot中的环绕通知

一、 SpringBoot简介

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不 再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应 用开发领域(rapid application development)成为领导者。
约定大于配置。

springboot(微框架) = springmvc(控制器) + spring(项目管理)

1、什么是SpringBoot?

Spring是全新框架

2、作用

**简化Spring应用的初始化搭建 以及开发过程** 

简化初始搭建：通过特定的配置方式简化**替代** 这些配置`Spring.xml Springmvc.xml web.xml`（取消）

3、本质

SpringBoot本质就是基于Spring和SpringMVC的再封装

springboot(微框架) = springmvc(控制器框架) + spring(项目管理)

微框架（少量配置 简化开发）是微服务（SpringCloud）的所依赖的框架

4、SpringBoot的好处

1. 创建独立的Spring应用程序
   只有一个容器，不会出现像Spring和SpringMVC父子容器污染问题
   提供Springboot jpa(等价于Mybatis框架)
2. 应用中嵌入的Tomcat服务器，无需部署WAR文件，无需通过外部服务器部署
3. 简化Maven配置
   #初始化只需要两个依赖+Mybatis 只需要三个依赖就可以搭建SSM项目
4. 自动配置Spring，自动使用spring和springmvc所有机制和功能
5. 没有XML配置

5、搭建环境 （1）全局入口类

1、数量：一个SpringBoot应用中必须要存在一个入口类
2、名字：项目名+Application.javaxxx:项目名
3、位置：必须要在所有子包平级 com.tjcu.平级
4、**入口类中必须包含一个主函数 ** public static void main(String[] args){})

maven项目：

src/main/java
        cccom.tjcu.entity
                   .dao
                   .service
                   .......
                   XxxApplication.java

src/main/resources
         application.yml
src/test/java
src/test/resources

（2)SpringBoot的配置文件

1、位置：根下 maven项目 必须放在src/main/resources
2、名字：名字必须叫application.xxx
后缀：.yml |.yaml .properties
yml文件 简介 高效 语法要求严格
.properties key=value 会冗余，可读性强，映射关系明显

二、第一个SpringBoot应用程序搭建

0、环境版本要求

SpringBoot 2.2.5

Spring 5.x

Maven3.3以上（当前使用版本3.5.3）

JDK1.8+

Tomcat8.0+ 内置9.x的版本号

1、搭建开发环境（引入相关依赖）

基础2 parent web

    org.springframework.boot
    spring-boot-starter-parent
    2.2.5.RELEASE




    8
    8



    
    
        org.springframework.boot
        spring-boot-starter
    

2、引入SpringBoot相关的配置文件

名字：application.yml

位置：根下 src/main/resource下

3、引入全局入口类

位置：和所有子包平级

名字：xxxApplication.java|Application.java

内容：必须存在一个主函数

com.tjcu
     @SpringBootApplication
     public class Application{
        public static void main(String[] args){
             
        SpringApplication.run(Application.class,args);

        }
     }

@SpringBootApplication注解解析：表明当前项目启动SpringBoot配置，并标记SpringBoot的启动入口类。

• spring版本号：2.2.5

• 启动SpringBoot后

• SpringBoot项目访问界面

4、开发一个控制器（书写一个Controller)

@Controller
@RequestMapping("test")
public class TestController {
    
  
    @RequestMapping("test1")
      @ResponseBody//响应Json的形式
    public String test1(){
        System.out.println("--------springboot----------");
        //跳转 Springboot默认不支持jsp
        return  "first SpringBoot application";
    }
}

• 注意事项：

1、SpringBoot应用内嵌服务器默认端口8080

2、SpringBoot应用访问时默认没有项目名

3、http://localhost:8080/test/test1

4、修改默认端口号和项目名：Application.yml

server:    #端口号修改设置
  port: 8989
  servlet:
    context-path: /Springboot  #设置当前的应用名

5、返回页面

三、SpringBootApplication注解解析

@SpringBootApplication 复合注解，多个注解功能的集合

@Target({ElementType.TYPE})：``这个注解写在类上``
@Retention(RetentionPolicy.RUNTIME) ``会在运行时生效``
@documented ``会生成注释文档``
@Inherited ``注解可以被继承

重点注解：
1、@SpringBootConfiguration ：
作用：SpringBoot相关的配置 ，自动对Spring和SpringMVC进行初始化配置，
** 静态** （Spring.xml.Springmvc.xml）

2、@EnableAutoConfiguration：
作用：最重要的一个注解
(1)将Spring和Springmvc默认的初始化配置进行实例化，在程序中创建工厂
(2)会自动配置第三方技术（Mybatis）【没用的依赖不要添加，会自动配置】

3、@ComponentScan :完成注解扫描，默认扫描当前包及其子包所有包结构下的注解

//@SpringBootApplication //注解 标识SpringBoot入口
@SpringBootConfiguration //配置Spring+Springmvc的初始化配置
@EnableAutoConfiguration  //将配置Spring+Springmvc初始化配置实例化
@ComponentScan(value ="com.tjcu")//扫描当前包及其子包结构下的注解
public class Application {
    public static void main(String[] args) {
        
        SpringApplication.run(Application.class,args);

    }
}

四、SpringBoot配置文件的拆分 1、为什么要拆分配置文件

在实际开发过程中生产环境和测试环境有可能是不一样的，因此将生产中的配置和测试中的配置拆分开,是非常必要的，在springboot中也提供了配置文件拆分的方式

2、以生产中项目名称不一致为例: （1)Application.yml 主配置

#主配置文件:
      application.yml  #用来书写相同的的配置
        server:
          port: 8080 #生产和测试为同一个端口

（2）开发中小配置文件application-.yml

  #生产配置文件:
        application-pord.yml
          server:
            context-path: /whj

（3）测试中小配置文件application-xxx.yml

 #测试配置文件:
        application-dev.yml
          server:
            context-path: /springboot

（4）上线中小配置文件application-xxx.yml

 #上线配置文件:
        application-dev.yml
          server:
            context-path: /tjcu

3、开发后小配置文件后我们需要在主配置文件中进行引用当前所需要的小配置文件

profiles[ˈproʊfaɪlz：轮廓

server:    #端口号设置
  port: 8989
spring:
  profiles:
    active: test   #设置集合的小配置文件application-test.yml 设置当前的应用名

4、作用

避免反复修改配置 ，方便后期的维护

五、SpringBoot对象的创建方式 1、Spring创建对象？ （1）简单对象和复杂对象区别

• 简单对象：可以直接通过new关键字直接创建对象

• 复杂对象：不能直接new的对象，就是复制对象（抽象类，接口，Connection）

• 管理方式：FactoryBean 接口

class xxxFactoryBean implement FactoryBean{
   Connection.getObject();
   Class.forName("driver");
   return DriverManager.getConnecction("url","username","password")
}
Class getObjectType(){
return Connection.class;
}
boolen isSingleton(){
return false;
}

交给Spring管理

2、SpringBoot如何创建对象？

核心：使用注解

（1）简单对象

在springboot中可以管理自定义的简单组件对象的创建可以直接使用注解形式创建。

# 1.使用 @Repository [rɪˈpɑːzətɔːri]   @Service @Controller 以及@Component管理不同简单对象

• 比如要通过工厂创建自定义User对象:

//负责创建简单对象
@Component("User")

//Sscope负责单例：Singleton 多例:prototype
@Scope("prototype")
public class User {
    private Integer id;
    private String username;
    private String password;

• 通过工厂创建之后可以在使用处任意注入该对象

如:在控制器中使用自定义简单对象创建

@Controller
@Scope("prototype")
@RequestMapping("test")
public class TestController {
    
    @Autowired
    private User user;
    @Autowired
    private User user1;

    @RequestMapping("test1")
    
    @ResponseBody
    public String test1(){
        System.out.println("--------test1-------");
        System.out.println(user);
        System.out.println(user1);
        return "test1 method";
    }

会出现多例，创建了两个不同的对象

（2）管理多个对象

@Configuration+@Bean：既能管理简单对象也能管理负责对象

@Configuration:使用位置:类上 标识当前类是一个配置类

@Bean:添加在方法上，对当前获取的对象进行配置 等价于bean标签

简单对象管理：

@Configuration
public class ObjectConfig {
    
    @Bean("User")
    @Scope("prototype")
    public User getUser(){
    // 书写对象的创建过程
        return  new User();
    }
}

复杂对象管理：

六、SpringBoot集成JSP页面展示 1、当前控制器中不能直接返回jsp逻辑名（页面的名字） 出现404

SpringBoot框架默认集成Thymeleaf

2、集成jsp页面 （1）引入jsp的集成jar包

    jstl
    jstl
    1.2




  org.springframework.boot
  spring-boot-starter-tomcat



    org.apache.tomcat.embed
    tomcat-embed-jasper

（2）在应用中配置页面路径的前后缀

• 在application.properties

#配置jsp页面的前后缀
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

（3)访问页面路径正常 但是展示404

• 原因：IDEA和SpringBoot集成的工具问题

• 解决思路一：使用插件启动

        在项目中添加SpringBoot相关插件，引入jsp运行插件
  

  
  
      SpringBoot2
      
      
        
          org.springframework.boot
          spring-boot-maven-plugin
          
            -Dfile.encoding=UTF-8
          
        
      
  

通过插件启动SpringBoot项目

效果:

@Controller
@Scope("prototype")
@RequestMapping("test")
public class TestController {
    @RequestMapping("test2")
    public String test2(){
        System.out.println("---test2----");
        return  "index";
    }

• 解决思路二：在IDEA中配置工作资源的路径

选择Application:Edit Configurations

启动访问jsp页面

http://localhost:8989/test/test2

七、SpringBoot整合Mybatis 1、Spring+Mybatis整合思路

    > （1）引入依赖
    Spring myabtis mybatis-spring mysql druid
    （2）编程步骤
    1、建表
    3、Dao接口
    4、Mapper文件
    5、Service接口
    6、Service实现类 @Service+@Transactional+@Autowired(Dao)
    7、Spring.xml
    (1)开启注解扫描
    (2)引入小配置文件
    (3)创建数据源
    (4)创建SqlSessionFactory
    (5)创建Dao实现类对象 注入SqlSessionFactory Dao接口所在包
    (6)创建事务管理器
    (7)开启注解式事务驱动

2、SpringBoot整合Mybatis （1）引入依赖

    org.mybatis.spring.boot
    mybatis-spring-boot-starter
    2.1.2



    
      org.springframework.boot
      spring-boot-starter-web
    
    
    
    
      mysql
      mysql-connector-java
      8.0.16
    

  
    
      com.alibaba
      druid
      1.1.12
    

（2）编程步骤

1、建表
2、实体类
3、Dao接口
4、Mapper文件
5、Service接口
6、Service实现类@Service+@Transactional+@Autowired(Dao)
7、SpringBoot相关配置 application.properties
（1）创建数据源对象 DriverClassName url username password
（2）创建SqlSessionFactory不用写，但是要告知mapper文件所在路径 别名
（3）创建Dao不用写，但是要告知Dao接口所在包

(3)数据源相关的配置

#数据源相关配置 driverClassName url username password
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db1?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

（3）告知mapper文件所在路径 别名

#设置mybatis的mapper文件所在路径 别名
mybatis.mapper-locations=classpath:com/mapper/xxxMapper.xml
mybatis.type-aliases-package=com.tjcu.entity

（4)告知Dao接口所在包

不在配置文件进行配置，在入口类上完成包的扫描

在入口类添加注解@MapperScan("dao接口所在的包")

@SpringBootApplication
@MapperScan("com.tjcu.dao")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

八、SpringBoot测试 1、引入相关依赖,内部包含原有的测试依赖

    
      org.springframework.boot
      spring-boot-starter-test
    

2、测试类和方法书写 考虑：测试时要启动SpringBoot的应用 (1)写一个父测试类，将SpringBoot中测试所需要的注解写在父测试类上

@RunWith(SpringRunner.class)
//指定测试类启动时入口类的位置  //等价于指定工厂的位置
@SpringBootTest(classes = EmsApplication.class)
public class ParentTest {
}

（2）不同实体类相关的测试就可以继承父测试类直接写测试了

• Admin的测试类

public class AdminTest extends  ParentTest{
    @Autowired
    private AdminService adminService;

    @Test
    public void select(){
        Admin admin = new Admin();
        admin.setName("王恒杰");
        admin.setPassword("123456");
        Admin admin1 = adminService.login(admin);
        System.out.println(admin);
    }
}

• 可以再写一个emp测试类继承父测试类

public class EmpTest extends ParentTest {

}

• 好处：就是可以少写点代码

九、SpringBoot中开启jsp的热部署 1、热部署

在不启动应用的前提下，让jsp页面修改生效

2、在配置文件中进行配置就可以了

• application.proprestis版本

#开启jsp页面的热部署
server.servlet.jsp.init-parameters.development=true

• application.yml

 jsp-servlet:
    init-parameters:
      development: true  #开启jsp页面的调试模式

十、SpringBoot切面编程

springboot是对原有项目中spring框架和springmvc的进一步封装,因此在springboot中同样支持spring框架中AOP切面编程,不过在springboot中为了快速开发仅仅提供了注解方式的切面编程.

1、切面编程Aop面向切面编程 切面=通知+切入点 2、Spring怎么样完成AOP编程 a、开发通知 额外通知

前置通知 MethodBeforeAdvice

环绕通知 MethodInterceptor

后置通知 MethodRunterningAdvice

异常通知 ThrowsAdvice

1、写类 Implements通知接口

2、在Spring中进行配置

b、aop相关设置aop:config

1、配置切入点

2、组装切面

3、SpringBoot怎么完成Aop编程 核心：注解 (1)引入相关依赖

    org.springframework.boot
    spring-boot-starter-aop

（2）通知相关的注解：方法上

@Before 前置通知 方法参数joinPonit
@After 后置通知   方法参数 joinpoint
@Around 环绕通知

@Before(value="切入点表达式")
public void mytest1(){
System.out.println("xxxxxx");
}

切面相关注解：@Aspect 书写类上 标识当前类是一个切面配置类

4、SpringBoot中前置通知和后置通知

//创建对象
@Component
//标识当前类式切面配置类
@Aspect
public class AspectConfig{

    //前置通知   value属性 书写切入点表达式
    @Before("execution(* com.baizhi.service.*ServiceImpl.*(..))")
    public void myBefore(JoinPoint joinPoint) {
        System.out.println("-------------进入前置通知-----------");
        System.out.println("方法名：" + joinPoint.getSignature());
        System.out.println("参数：" + joinPoint.getArgs());
        System.out.println("目标对象：" + joinPoint.getTarget());
        System.out.println("-------------退出前置通知-----------");
    }

    //后置通知  value属性 书写切入点表达式
    @After("within(com.baizhi.service.*ServiceImpl)")
    public void myAfter(JoinPoint joinPoint) {
        System.out.println("-------------进入后置通知-----------");
        System.out.println("方法名：" + joinPoint.getSignature());
        System.out.println("参数：" + joinPoint.getArgs());
        System.out.println("目标对象：" + joinPoint.getTarget());
        System.out.println("-------------退出后置通知-----------");
    }

}

5、SpringBoot中的环绕通知

环绕通知

@Around

@Around("切入点表达式")
public void myAround(){
  //目标方法执行之前执行
  //调用目标方法 放行 让目标方法去执行
  //目标方法执行之后执行
}

//创建对象
@Component
//标识当前类式切面配置类
@Aspect
public class AspectConfig{
 @Around("execution(* com.baizhi.service.*ServiceImpl.*(..))")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("-------目标方法执行之前执行的内容------");
        //放行 执行目标方法
        Object proceed = proceedingJoinPoint.proceed();
        System.out.println("方法对象：" + proceedingJoinPoint.getSignature());
        System.out.println("参数：" + proceedingJoinPoint.getArgs());
        System.out.println("目标对象：" + proceedingJoinPoint.getTarget());
        System.out.println("-------目标方法执行之后执行的内容------");
        return proceed;
    }