SpringBoot集成Maven的profile配置

- 日理万妓 2022-12-05 05:29 275阅读 0赞

## 一、上周知识点总结 ##

1.1 Linux

*  认识Linux
 *  虚拟机
    
     *  安装VMware--创建虚拟机--安装CentOS
 *  云主机
 *  远程工具
    
     *  xftp 文件管理
     *  xshell 远程终端
 *  Linux文件系统
    
     *  home root etc usr
 *  Linux常用指令
    
     *  文件管理
     *  用户权限
     *  系统操作
     *  软件管理指令
        
         *  wget
         *  rpm
         *  yum
 *  软件管理
    
     *  JDK
     *  Tomcat
     *  MySQL
     *  Nginx
 *  FTP文件上传（windows-(java)-Linux）
 *  项目打包部署

1.2 SpringBoot

*  了解SpringBoot
    
     *  习惯优于配置/约定大于配置
     *  自动配置（java配置方式）
 *  创建了第一个SpringBoot应用
    
     *  创建流程
     *  SpringBoot项目目录结构
     *  启动SpringBoot-
 *  自定义banner
 *  全局配置文件
    
     *  application.properties
     *  application.yml(yaml语言)
 *  java配置方式（复习）
 *  Starter POM (POM依赖导入starter--完成基本配置)
    
     *  一个starter对应着一个具体的开发场景(redis)
 *  SpringBoot是如何完成自动配置的？
 *  日志配置—（SpringBoot的日志框架）

1.3 本周知识点的预告

*  SpringBoot
 *  SpringBoot（thymeleaf、swagger、日志框架）
 *  SpringBoot整合tk.mapper(tk.mybatis)
 *  shiro
 *  shiro

## 二、今天计划 ##

*  SpringBoot 自动配置回顾
 *  基于SpringBoot的SSM开发
    
     *  整合数据库连接池
     *  整合MyBatis
     *  基于SpringBoot的单元测试
     *  全局异常捕获
     *  基于Maven的profile配置
 *  自定义starter实现（原理）

## 三、SpringBoot的自动配置（回顾） ##

*  SpringBoot内置了主流框架的配置（基于java配置方式），当在启动SpringBoot项目的时候，只要`满足特定的条件`,就会触发SpringBoot的自动配置
 *  SpringBoot项目启动的时候，就会通过一层一层的调用加载spring.factories文件，在spring.factories文件中包含了SpringBoot所支持的自定配置（各种AutoConfig类）；所有的自动配置类都会被扫描，但并不意味着所有的自动配置类都会被初始化，只有当满足某个自动配置类声明的条件时，此配置类才会被初始化。
 *  常见的自动配置加载条件
    
        @ConditionalOnClass
        @ConditionalOnBean
        @ConditionalOnProperty
        @EnableConfigurationProperties

## 四、基于SpringBoot的SSM开发 ##

4.1 Spring 支持

SpringBoot项目本身就是依赖于Spring的，所以当我们创建SpringBoot应用之后，Spring的支持就默认导入了。也就是说只要SpringBoot项目能够启动就默认支持Spring(IoC\\AOP)

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

4.2 SpringMVC支持

*  依赖spring-boot-starter-web

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

*  SpringMVC集成：
    
     *  在pom中添加spring-boot-starter-web依赖
     *  当SpringBoot应用中存在spring-boot-starter-web依赖就会触发WebMvcAutoConfiguration自动配置
     *  在WebMvcAutoConfiguration配置中又完成了例如DispatcherServletAutoConfiguration等SpringMVC所需的诸多配置

4.3 Druid支持

*  添加druid依赖 druid-spring-boot-starter
    
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
 *  添加mysql数据库驱动依赖
    
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
 *  在全局配置文件配置数据库连接池属性
    
        spring:
          datasource:
            druid:
              url: jdbc:mysql://47.96.11.185:3306/test
              # MySQL如果是8.x   com.mysql.cj.jdbc.Driver
              driver-class-name: com.mysql.jdbc.Driver
              username: root
              password: admin123
              initial-size: 1
              min-idle: 1
              max-active: 20

4.4 MyBatis支持

*  添加MyBatis依赖mybatis-spring-boot-starter
    
        
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
 *  配置application
    
        mybatis:
          mapper-locations: classpath:mappers/*Mapper.xml
          type-aliases-package: com.qfedu.springbootssm.beans

4.5 使用案例（DAO实现）

> 图书信息管理

*  创建数据表
    
        mysql> create table tb_books(
            -> book_id int primary key auto_increment,
            -> book_name varchar(100) not null,
            -> book_author varchar(50) not null,
            -> book_price float not null,
            -> book_desc varchar(400)
            -> );
 *  创建实体类
    
        public class Book {
        
            private Integer bookId;
            private String bookName;
            private String bookAuthor;
            private double bookPrice;
            private String bookDesc;
        	//无参构造器
            //全参构造器
        	//getter  &  setter
        }
 *  创建DAO接口
    
        public interface BookDAO {
        
            void insertBook(Book book) throws  Exception;
        
            List<Book> listBooks() throws Exception;
        
            Book queryBookById(Integer bookId) throws Exception;
            
        }
 *  创建映射文件
    
        <?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.qfedu.springbootssm.dao.BookDAO">
        
            <insert id="insertBook" parameterType="Book" useGeneratedKeys="true" keyProperty="bookId">
                insert into tb_books(book_name,book_author,book_price,book_desc)
                values(#{bookName},#{bookAuthor},#{bookPrice},#{bookDesc})
            </insert>
        
            <resultMap id="bookMap" type="Book">
                <id column="book_id" property="bookId"></id>
                <result column="book_name" property="bookName"/>
                <result column="book_author" property="bookAuthor"/>
                <result column="book_price" property="bookPrice"/>
                <result column="book_desc" property="bookDesc"/>
            </resultMap>
        
            <select id="listBooks" resultMap="bookMap" resultSets="java.util.List" >
                select * from tb_books
            </select>
        
            <select id="queryBookById" resultMap="bookMap">
                select * from tb_books where book_id=#{bookId}
            </select>
        
        </mapper>
 *  Mapper注册
    
     *  方案1：在DAO接口添加 @Mapper注解
     *  方案2：在启动类添加@MapperScan(basePackages = "com.qfedu.springbootssm.dao")注解

4.6 基于SpringBoot单元测试

@RunWith(SpringRunner.class)
    @SpringBootTest(classes = SpringbootSsmApplication.class)
    public class BookDAOTest {
    
        @Resource
        private BookDAO bookDAO;
    
        @Test
        public void testInsertBook() throws Exception{
            Book book = new Book(0,"Java","马总",22.22,"马总新作");
            bookDAO.insertBook(book);
            System.out.println(book.getBookId());
            //断言: 返回值与期望值是否一直
            Assert.assertEquals(3,book.getBookId().intValue());
        }
        
    }

4.7 使用案例（service及controller实现）

*  service接口
    
        public interface BookService {
        
            public void insertBook(Book book) throws  Exception;
        
            public List<Book> listBooks() throws  Exception;
        
        }
 *  service实现类
    
        @Service
        public class BookServiceImpl implements BookService {
        
            @Resource
            private BookDAO bookDAO;
        
            @Override
            public void insertBook(Book book) throws Exception {
                bookDAO.insertBook(book);
            }
        
            @Override
            public List<Book> listBooks() throws Exception {
                return bookDAO.listBooks();
            }
        }
 *  controller
    
     *  vo的实现
    
        @Controller
        @RequestMapping("book")
        public class BookController {
        
            @Resource
            private BookService bookService;
        
            @ResponseBody
            @RequestMapping("add")
            public ResultVO insert(Book book) {
                ResultVO resultVO = null;
                try {
                    bookService.insertBook(book);
                    resultVO = ResultVO.getSuccessVO("添加成功!");
                } catch (Exception e) {
                    e.printStackTrace();
                    resultVO = ResultVO.getFailVO("添加失败！");
                }
                return resultVO;
            }
        
            @ResponseBody
            @RequestMapping("list")
            public ResultVO listBooks(){
                ResultVO resultVO = null;
                try {
                    List<Book> books = bookService.listBooks();
                    resultVO = ResultVO.getSuccessVO("查询成功",books);
                } catch (Exception e) {
                    e.printStackTrace();
                    resultVO = ResultVO.getFailVO("网络延迟，请刷新重拾！");
                }
                return resultVO;
            }
        
        }

4.8 全局异常处理

*  使用全局异常处理类统一处理异常
    
     *  1.创建全局异常处理类，添加@ControllerAdvice注解
     *  2.在异常处理类中提供异常处理方法
        
            @ControllerAdvice
            public class GlobalExceptionHandler {
            
                @ExceptionHandler
                @ResponseBody
                public String exceptionHandler(Exception e){
                    String message = e.getMessage();
                    System.out.println("----------------"+message);
                    //根据不同的异常类型进行不同的处理
                    return message;
                }
            
            }

4.9 SpringBoot集成Maven的profile配置

> 在实际开发中，开发环境、测试环境、生产环境很多的配置是不同的；我们需要针对不同的环境进行不同的配置，比如：
> 
>  *  日志配置
>     
>      *  开发环境-- d:/logs/dev
>  *  端口配置
>     
>      *  开发环境-- 8080
>      *  测试环境-- 8081
>      *  生产环境-- 8082

*  针对不同的环境创建不同的配置文件(application-\*\*\*.yml)
    
     *  开发环境 application-dev.yml
        
            logging:
              file:
                path: d:/logs/dev
            server:
              port: 8080
     *  测试环境 application-test.yml
        
            logging:
              file:
                path: d:/logs/test
            server:
              port: 8081
     *  生产环境 application-prod.yml
        
            logging:
              file:
                path: d:/logs/prod
            server:
              port: 8082
 *  在pom.xml中进行profile的配置
    
        <profiles>
            
            <profile>
                <id>dev</id>
                <activation>
                    <activeByDefault>true</activeByDefault>
                </activation>
                <properties>
                    <profileName>dev</profileName>
                </properties>
            </profile>
        
            
            <profile>
                <id>test</id>
                <activation>
                    <activeByDefault>false</activeByDefault>
                </activation>
                <properties>
                    <profileName>test</profileName>
                </properties>
            </profile>
            
            <profile>
                <id>prod</id>
                <activation>
                    <activeByDefault>false</activeByDefault>
                </activation>
                <properties>
                    <profileName>prod</profileName>
                </properties>
            </profile>
        
        </profiles>
 *  在application.yml中动态加载profile
    
        # 在application.yml中动态加载 三个不同环境的配置文件
        spring:
          profiles:
            active: @profileName@
 *  项目打包（jar）运行
    
     *  打包
    
    <table> 
     <thead> 
      <tr> 
       <th>&nbsp;</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td><img alt="" height="273" src="https://img-blog.csdnimg.cn/2020090915355774.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDg1MDQ=,size_16,color_FFFFFF,t_70" width="539"></td> 
      </tr> 
     </tbody> 
    </table>
    
     *  运行
    
    <table> 
     <thead> 
      <tr> 
       <th>java -jar springboot-profile-1.0.0-SNAPSHOT.jar --spring.profiles.active=prod</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td><img alt="" height="513" src="https://img-blog.csdnimg.cn/20200909153604588.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDg1MDQ=,size_16,color_FFFFFF,t_70" width="1200"></td> 
      </tr> 
     </tbody> 
    </table>