一、开发基础

• Java基础（两到三小时过一遍）
• Java开发环境配置（必须使用JDK1.8）
• IDE安装（优先使用IntelliJ IDEA）

二、名词解释

• Spring：JAVA开发应用框架
• Spring Boot：用来简化Spring应用的初始搭建以及开发过程的配置框架
• Maven：Java项目构建工具，成熟的项目
• Gradle：更简洁的Java项目构建工具，吸收了旧构建工具的优点。
• JPA：是Sun官方提出的Java持久化规范，即数据库操作规范。
• Hibernate：Hibernate是一个ORM框架，是JPA的默认实现方式，一般说JPA都是指Hibernate。
• Mybatis：Mybatis是一个轻便的ORM框架。
• Spring data jpa：是Spring基于ORM框架、JPA规范的基础上封装的一套JPA应用框架

三、新项目流程

1. 新建gradle项目
   • File->new->Prroject->Spring Initializr

   • 填写Group、Artifact选择Gradle Project项目生成

   • 可以直接在生成项目的时候选择对应需要安装的插件，如：web、jpa、mybatis等，也可以在项目初始化完成之后在build.gradle中添加/配置

2. 配置build.gradle（位于根目录）

   plugins {
       id 'org.springframework.boot' version '2.1.3.RELEASE'
       id 'java'
   }
   
   apply plugin: 'io.spring.dependency-management'
   
   group = 'com.duomai'
   version = '0.0.1-SNAPSHOT'
   sourceCompatibility = '1.8' // JDK最大兼容版本
   
   repositories {
       mavenCentral()
   }
   
   dependencies {
       // Spring Boot JPA 组件
       implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
       // Spring Boot Web组件
       implementation 'org.springframework.boot:spring-boot-starter-web'
       // Mybatis插件，注意暂时使用**1.1.1**版本，高版本的运行好像有问题
       implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:1.1.1'
       // Mybatis分页插件
       implementation group: 'com.github.pagehelper', name: 'pagehelper-spring-boot-starter', version: '1.2.10'
       runtimeOnly 'org.springframework.boot:spring-boot-devtools'
       runtimeOnly 'mysql:mysql-connector-java'
       testImplementation 'org.springframework.boot:spring-boot-starter-test'
   }
   
   

   修改了build.gradle后，idea会自动安装/更新依赖包。
   参考：gradle官网、Spring Boot Web服务搭建、Spring Boot Mysql使用、Spring Boot JPA使用

3. 项目基础配置（位于src/resources/application.properties）

   #运行配置
   server.port=9000
   #数据格式配置
   spring.jackson.time-zone=GMT+8 // 设置接口返回时区为东八区
   spring.jackson.date-format=yyyy-MM-dd HH:mm:ss // 自动将接口返回中的日期格式转换为标准格式
   #数据库连接配置
   spring.datasource.url=jdbc:mysql://192.168.0.235:3355/shop_balances?serverTimezone=Asia/Shanghai&tinyInt1isBit=false // serverTimezone选择Mysql东八区，tinyInt1isBit禁止Mysql自动将tinyint(1)类型数据映射为boolean类型
   spring.datasource.username=cishop
   spring.datasource.password=fuyuan1906
   #log配置
   logging.path=E:/java/demo/balance_card/log
   logging.level.com.favorites=DEBUG
   #logging.level.org.springframework.web=INFO
   logging.level.org.hibernate=ERROR
   #mybatis设置
   mybatis.type-aliases-package=com.duomai.balance_card.Model.Mapper
   mybatis.configuration.map-underscore-to-camel-case=true
   logging.level.com.duomai.balance_card.Model.Mapper=DEBUG
   #pagehelper插件设置
   pagehelper.helperDialect=mysql
   pagehelper.reasonable=false
   pagehelper.supportMethodsArguments=true
   pagehelper.params=pageNum=page;pageSize=limit
   #jpa 设置
   spring.jpa.properties.hibernate.hbm2ddl.auto=update
   spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
   spring.jpa.show-sql= true
   

4. 项目启动
   • IDEA启动，运行[Prefix]Application.java文件即可

   • 命令行启动

     • Maven项目
       在springboot的应用的根目录下运行 mvn spring-boot:run

     • Grdale项目
       在springboot的应用的根目录下运行 gradle bootRun 或 gradlew bootRun
       （前者是使用本地的gradle版本运行，后者是使用代码仓库中的gradle运行）

   • 打包构建可执行文件运行

5. 开发环境热更新设置
   热更新不是很好用，有一定的延迟时间

四、项目文件分层解析

// 业务代码 src/main
java 
    com
        duomai
            balance_card
                [Prefix]Application.java // 项目启动文件，可以做一些全局设置，如时区设置、Mapper扫描等
                Config // 配置类，用于注册一些全局配置，如拦截器注册等
                Middleware // 中间件，实现AOP功能
                Controller // 控制器，主要做路由功能
                    xxxController.java
                    BaseErrorController.java // 路由匹配失败时使用的控制器
                Service // 业务代码
                Model // 目录主要用于实体与数据访问层
                    Entity // 数据表实体类
                    Repository // JPA数据仓库
                    Mapper // Mybatis映射文件
                    Provider // Mapper的Sql生成器
                Library // 库类，存放公共类文件/纯定义文件等
                    ApiReturnDefines.java // 接口返回定义
                    ExceptionErrprDefines.java // 异常监听层定义
                Helper // 辅助函数类文件
                OutPut // 接口输出层
                    ApiResult.java // 最终的接口输出格式
                    AiReturn.java // 快速生成ApiResult类，供外部调用
                Exception // 统一的异常处理
                    ControllerHandler // 路由层异常监听
                    SqlHandler // 数据库层异常监听
// 配置项
resources
    appliaction.properties // 项目配置文件

五、控制器中间件

1. 一般使用Spring过滤器或拦截器实现AOP切面编程

2. 过滤器和拦截器的对比

   • 作用域不同
     过滤器依赖于servlet容器，只能在 servlet容器，web环境下使用。
     拦截器依赖于spring容器，可以在spring容器中调用，不管此时Spring处于什么环境。
   • 细粒度的不同
     过滤器的控制比较粗，只能在请求进来时进行处理，对请求和响应进行包装。
     拦截器提供更精细的控制，可以分为controller对请求处理之前、渲染视图之后、请求处理之后三个切面。
   • 中断链执行的难易程度不同
     拦截器可以 preHandle方法内返回 false 进行中断。
     过滤器就比较复杂，需要处理请求和响应对象来引发中断，需要额外的动作，比如将用户重定向到错误页面。
3. 拦截器的使用
   • 编写自定义拦截器（Middleware/ControllerInterceptor.java）

   public class ControllerInterceptor implements HandlerInterceptor {
       private Logger logger = LoggerFactory.getLogger(ControllerInterceptor.class);
       @Override
       public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
           logger.info("preHandle....");
           // token校验等
           String token = request.getHeader("token");
           //     Common.sendJson(response, ApiReturn.fail(1001, "token验证失败"));
           //      return false;
           return true;
       }
   
       @Override
       public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
           logger.info("postHandle...");
       }
   
       @Override
       public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
           // 接口日志记录等
           logger.info("afterCompletion...");
       }
    ```
   
   **说明**：
   preHandle：对客户端发过来的请求进行前置处理，如果方法返回true,继续执行后续操作，如果返回false，执行中断请求处理，请求不会发送到Controller。可以在这里校验一些权限信息，如token等,校验失败直接以JSON格式返回请求。
   
   postHandler：在请求进行处理后执行，也就是在Controller方法调用之后处理，前提是preHandle方法返回true。具体来说，postHandler方法会在DispatcherServlet进行视图返回渲染前被调用。
   
   afterCompletion: 该方法在整个请求结束之后执行，前提依然是preHandle方法的返回值为true。
   

   • 注册拦截器（Config/InterceptorConfig.java）

   @Configuration
   public class InterceptorConfig implements WebMvcConfigurer {
       @Override
       // 核心方法
       public void addInterceptors(InterceptorRegistry registry) {
           registry.addInterceptor(ControllerInterceptor())
                   //配置拦截规则
                   .addPathPatterns("/**")
                   .order(1);
   
           // 多个拦截器按上述方法持续注册即可,同时也可以设置order值，从小到大执行。
       }
   
       @Bean
       public HandlerInterceptor ControllerInterceptor() {
           return new ControllerInterceptor();
       }
   }
   

六、Controller层

1. 定义控制器文件

   @RestController
   在类文件头部定义，标明为控制器文件，且输出格式为JSON
   

2. 路由和参数
   1. 定义路由名称，接收方法

      例：@RequestMapping(value = "/get", method = {RequestMethod.GET, RequestMethod.POST})
      
        可选参数：
      
        value：路由名称
      
        method：指定请求的method类型， GET、POST、PUT、DELETE、PATCH等,可多选
      
        consumes：指定处理请求的提交内容类型（Content-Type），例如application/json, text/html
      
        produces： 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回
      
        params： 指定request中必须包含某些参数值
      
        headers： 指定request中必须包含某些指定的header值
      

   2. 参数接收

      例：@RequestParam(value = "fields", required = false, defaultValue = "*") String fields
      
          value：参数名称
      
          defaultValue：默认值
      
          required：是否是必要参数
      

   3. 自定义错误路由
      1. 在Controller层中添加BaseErrorController.java文件，用于监听路由匹配失败的情况

         @Controller
         public class BaseErrorController implements ErrorController {
             @Override
             public String getErrorPath() {
                 System.out.print("错误页面");
                 return "error/error";
         }
         
             @RequestMapping(value = "/error")
             public void error() throws Exception {
                 throw new Exception("路由匹配失败");
             }
         }
         

      2. 在Exception文件夹中添加ControllerHandler.java，用于捕获路由报错并输出。

         @RestControllerAdvice
         public class ControllerHandler {
             // 缺少必选参数
             @ExceptionHandler({MissingServletRequestParameterException.class})
             @ResponseBody
             public ApiResult requestMissingServletRequest(MissingServletRequestParameterException e){
                 return ApiReturn.fail(ExceptionErrorDefines.RequestMissingServletRequest, e.getMessage());
             }
         }
         未解决：抛出异常后访问404页面运行环境会报错，但是页面正常  
         

         参考：https://www.jianshu.com/p/393f70b55b1b

3. Service层调用

   1. Service类成员注入
      • 使用@Autowired修饰符进行依赖注入

        @Autowired
        private final CardService cardService;
        

      • 用构造函数来做注入类成员（推荐使用）

        private StoreBalanceCardsRepository cardsRepository;
        public CardController(StoreBalanceCardsRepository cardsRepository) {
            this.cardsRepository = cardsRepository;
        }
        **注**：
        IntelliJ IDEA使用依赖注入会有IDE报错，但不影响实际编译运行，如需去除报错提示，需要在Dao层（Respository/Mapper）类开头添加注解 `@Repository`
        

   2. 调用

      cardService.get(id, fields);
      

七、Service层

1. 定义Service文件

   @Service
   在类文件头部定义，标明为Service文件
   

2. 注入Model层操作文件

   private final StoreBalanceCardsRepository storeBalanceCardsRepository;
   private final StoreBalanceCardsMapper storeBalanceCardsMapper;
   
       CardService(StoreBalanceCardsRepository storeBalanceCardsRepository, StoreBalanceCardsMapper storeBalanceCardsMapper) {
           this.storeBalanceCardsRepository = storeBalanceCardsRepository;
           this.storeBalanceCardsMapper = storeBalanceCardsMapper;
       }
   

3. 调用Model层文件

八、Model层

1. Repository

   • Spring中概念，概念类似于数据仓库，是Spring data jpa的实现。居于业务层和数据层之间，将两者隔离开来，在它的内部封装了数据查询和存储的逻辑。

   • Repository和传统意义上的DAO的区别：
     Repository蕴含着真正的OO概念，即一个数据仓库角色，负责所有对象的持久化管理。DAO则没有摆脱数据的影子，仍然停留在数据操作的层面上。Repository是相对对象而言，DAO则是相对数据库而言，虽然可能是同一个东西，但侧重点完全不同。

2. Mapper

   存放Mybatis数据库关系映射方法

3. Provider
   为Mapper层提供的SQL生成器，即将SQL的生成与映射解耦。

4. Entity

   • 根据表结构自动生成实体类

     **注意**：
     i、多次自动生成不会覆盖，如需更新需要把旧的实体类文件删除
     
     ii、有需要的话可以在实体类文件右击generate一键生成构造函数、set get方法、@Autowired等
     
     iii、自动生成的实体类中datetime类型的字段会被转为Java的timestamp类型数据，存储的时候也使用timestamp类型即可
     
     iv、生成出来的实体类catalog = "" 报错，是IDE的报错，不影响使用
     

     参考文档：https://blog.csdn.net/chenju05244554/article/details/1009142081

5. Hibernate 和 Mybatis 的对比

   • Hibernate优势：

     i、DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。
     
     ii、对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。
     
     iii、数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。
     
     iv、有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。
     

   • Mybatis优势：

     i、MyBatis可以进行更为细致的SQL优化，可以减少查询字段。
     
     ii、MyBatis容易掌握，而Hibernate门槛较高。
     

   • 选用Mybatis的原因

     i、Hibernate无法满足动态获取部分字段的需求，即使是使用Hibernate提供的原始SQL也无法实现
     
     ii、Hibernate的JPA查询只适用于一些简单的情况，如遇到复杂的SQL，Repository中的方法名会很长。这时候又将回到Hibernate的自定义SQL查询，即原生SQL。
     
     iii、Hibernate的维护成本比MyBatis高很多，MyBatis的SQL生成完全取决于开发者，所以SQL修改、维护、优化会比较便利。
     

九、MyBatis使用

1. 引入MyBatis以及pagehelper分页插件

   dependencies {
       implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:1.1.1'
       implementation group: 'com.github.pagehelper', name: 'pagehelper-spring-boot-starter', version: '1.2.10'
   }
   

2. application.properties 添加相关配置

   #mybatis设置
   mybatis.type-aliases-package=com.duomai.balance_card.Model.Mapper // 项目中Mapper存放的包
   mybatis.configuration.map-underscore-to-camel-case=true // 自动将sql字段下划线转为驼峰，可以保证取出的数据格式就是数据库中存储的格式
   logging.level.com.duomai.balance_card.Model.Mapper=DEBUG // 开启DEBUG模式，用于开发环境，记录执行的SQL。
   #pagehelper插件设置
   pagehelper.helperDialect=mysql // 指定分页插件使用哪种数据库
   pagehelper.reasonable=false // 分页合理化参数，默认值为false。当该参数设置为 true 时，pageNum<=0 时会查询第一页， pageNum>pages（超过总数时），会查询最后一页。默认false 时，直接根据参数进行查询。
   pagehelper.supportMethodsArguments=true // 支持通过 Mapper 接口参数来传递分页参数，默认值false，分页插件会从查询方法的参数值中，自动根据上面 params 配置的字段中取值，查找到合适的值时就会自动分页，设置后无需手动启用分页插件。
   pagehelper.params=pageNum=page;pageSize=limit //  自定义Mapper 接口参数来传递分页参数的参数名
   

3. 添加Mapper类扫描的两种方式
   • 在启动类中添加对mapper包扫描@MapperScan（推荐使用）

     @SpringBootApplication
     @MapperScan("com.duomai.balance_card.Model.Mapper")
     

   • 在具体的Mapper类上面添加注解 @Mapper

4. Mapper类SQL用例

   public interface StoreBalanceCardsMapper {
       // select用例
       @SelectProvider(type = StoreBalanceCardsSqlBuilder.class, method = "getById")
       List<Map> getById(@Param("id") int id, @Param("fields") String fields, @Param("page") int page, @Param("limit") int limit);
   
       // 列表
       @SelectProvider(type = StoreBalanceCardsSqlBuilder.class, method = "list")
       Page<Map> list(@Param("fields") String fields, @Param("page") int page, @Param("limit") int limit);
   
       // insert用例
       @InsertProvider(type = StoreBalanceCardsSqlBuilder.class, method = "add")
       @Options(useGeneratedKeys=true, keyProperty="storeBalanceCard.id", keyColumn="id")
       int add(@Param("storeBalanceCard") StoreBalanceCards storeBalanceCard);
   
       // update用例
       @UpdateProvider(type = StoreBalanceCardsSqlBuilder.class, method = "updateName")
       @Options(useGeneratedKeys=true, keyProperty="storeBalanceCard.id", keyColumn="id")
       int updateName(@Param("storeBalanceCard") StoreBalanceCards storeBalanceCard, @Param("limit") int limit);
   
       // delete用例
       @DeleteProvider(type = StoreBalanceCardsSqlBuilder.class, method = "deleteById")
       int delete(@Param("id") int id, @Param("limit") int limit);
   }
   

   • 通过Provider的方式动态获取SQL

   • 需要分页时在具体的方法后多加page、limit参数，自动实现分页

     // Service层调用
     List storeBalanceCard = storeBalanceCardsMapper.list(fields, page, limit);
     // Mapper层实现
     Page<Map> list(@Param("fields") String fields, @Param("page") int page, @Param("limit") int limit);
     

   • 分页组件仅可用于查询，不可用于更新/删除，更新/删除需要另外实现

5. Providerle类SQL用例

   public class StoreBalanceCardsSqlBuilder {
       private static final String STORE_BALANCE_CARDS = "store_balance_cards";
       public static String getById(int id, String fields) {
           return new SQL(){ { 
               SELECT(fields);
               FROM(STORE_BALANCE_CARDS);
               WHERE("store_balance_cards.id = #{id}");
           } }.toString();
       }
   
       public static String list(String fields) {
           return new SQL(){ {
               SELECT(fields);
               FROM(STORE_BALANCE_CARDS);
           } }.toString();
       }
   
       public static String add(@Param("storeBalanceCard") StoreBalanceCards storeBalanceCard) {
           return new SQL(){ {
               INSERT_INTO(STORE_BALANCE_CARDS);
               VALUES("sys_name", "#{storeBalanceCard.sysName}");
               VALUES("store_id", "#{storeBalanceCard.storeId}");
               VALUES("entity_store_id", "#{storeBalanceCard.entityStoreId}");
               VALUES("name", "#{storeBalanceCard.name}");
               VALUES("type", "#{storeBalanceCard.type}");
               VALUES("item_id", "#{storeBalanceCard.itemId}");
               VALUES("photo", "#{storeBalanceCard.photo}");
               VALUES("state", "#{storeBalanceCard.state}");
               VALUES("upgrade", "#{storeBalanceCard.upgrade}");
               VALUES("recharge_discount", "#{storeBalanceCard.rechargeDiscount}");
               VALUES("updated_at", "#{storeBalanceCard.updatedAt}");
               VALUES("created_at", "#{storeBalanceCard.createdAt}");
           } }.toString();
       }
   
       public static String updateName(@Param("storeBalanceCard") StoreBalanceCards storeBalanceCard, @Param("limit") int limit) {
           return new SQL(){ {
               UPDATE(STORE_BALANCE_CARDS);
               SET("name=#{storeBalanceCard.name}");
               if (storeBalanceCard.getUpdatedAt() != null) {
                   SET("updated_at=#{storeBalanceCard.updatedAt}");
               }
               WHERE("store_id = #{storeBalanceCard.storeId}");
           } }.toString() + " limit " + limit;
       }
   
       public static String deleteById(int id, int limit) {
           return new SQL(){ {
               DELETE_FROM(STORE_BALANCE_CARDS);
               WHERE("store_balance_cards.id = #{id}");
           } }.toString() + " limit " + limit;
       }
   }
   

6. 分页组件详解

十、接口输出

1. 接口统一输出格式

   state: // 状态位
   msg: // 接口输出提示信息
   data: { // 总的接口输出数据，可以为空
       data: // 接口数据
       other: // 其他返回数据，如total/page_total等
       ...:
   }
   

2. 正常接口输出/异常监听输出统一使用OutPut/ApiReturn方法

十一、异常处理

1. 项目运行异常统一监听
   现有：ControllrHandler 路由异常监听、SqlHandler 数据库操作异常监听
   需要持续添加
2. 统一使用接口输出类进行返回，杜绝直接返回报错信息。

十二、单元测试

1. 添加单元测试类

   src\test\java\com\duomai\balance_card\BalanceCardApplicationTests.java

2. demo

   @RunWith(SpringRunner.class)
   @SpringBootTest
   @AutoConfigureMockMvc
   public class BalanceCardApplicationTests {
   
       @Autowired
       private MockMvc mockMvc;
   
       @Test
       @SuppressWarnings("unchecked")
       public void getCard() throws Exception {
           String card_id = "1";
           String fields = "store_id,item_id,recharge_discount,photo,type,name";
           String res = this.mockMvc.perform(get("/card/get")
                   .param("id", card_id).param("fields", fields)
                   )
                   .andDo(print())
                   .andExpect(status().isOk())
                   .andReturn()
                   .getResponse()
                   .getContentAsString();
          // 接口返回不为空
          assertThat(res).isNotNull();
          // 校验接口返回格式是否完整
          Map<String, Object> api_res = Common.jsonToMap(res);
          assertThat(api_res).isNotNull();
          assertThat(api_res).hasSize(3);
          assertThat(api_res).containsKeys("state", "msg", "data");
          // 校验接口返回state是否正确
          int state = (int) api_res.get("state");
          Map<String, Object> api_data = (HashMap<String, Object>) api_res.get("data");
          assertThat(state).isEqualTo(ApiReturnDefines.SUCCESS);
          // 校验data数据是否正确
          assertThat(api_data).containsOnlyKeys("data");
          ArrayList<Map> data = (ArrayList) api_data.get("data");
          String[] fieldsAll = fields.split(",");
          assertThat(data).hasSize(1);
          assertThat(data.get(0)).containsKeys((Object[]) fieldsAll);
       }
   }
   

3. 详解
   • 使用 @RunWith(SpringRunner.class)、@SpringBootTest 定义测试类
   • 添加注解 @AutoConfigureMockMvc ，使用 Spring MockMvc 模拟Spring的HTTP请求并将其交给控制器，实际上并没有真正地启动服务器，仅仅是Mock，节省了启动服务器的开销。
   • 使用 AssertJ 库类来验证接口返回内容
     在demo中，使用断言验证了接口返回格式、state状态、data数据格式等基本内容。

   参考文档：https://spring.io/guides/gs/testing-web/

十三、项目打包

1. 不同的构建文件

• 普通 jar 包 : 会将源码编译后以工具包（即将class打成jar包）的形式对外提供，此时，你的 jar 包不一定要是可执行的，只要能通过编译，可以被别的项目以 import 的方式调用。
• 可执行 jar 包 : 能通过 java -jar 的命令运行。
• 普通 war 包 : war 是一个 web 模块，其中包括 WEB-INF，是可以直接运行的 WEB 模块。做好一个 web 应用后，打成包部署到容器中。
  • 可执行 war 包 : 普通 war 包 + 内嵌容器 。

1. 构建可执行 jar 包

   • IDE打包
     右侧Gradle -> Tasks -> build -> build
   • 命令行打包
     进入项目根目录，执行gradle build
2. 运行可执行 jar 包
   java -jar build/libs/balance_card-0.0.1.jar
   运行时可带参数，同application.properties中的参数名
   例:

   java -Djava.security.egd=file:/dev/./urandom -jar /opt/ci123/www/html/java/balance_card/build/libs/${jarName}.jar --server.port=80
   

十四、容器化部署

1. 创建docker镜像

• Dockfile 编写

  FROM java:8
MAINTAINER duomai
# 设置镜像源
COPY sources.list /etc/apt/sources.list
# 安装扩展
RUN apt-get update && apt-get install -y \
wget \
curl \
vim \
git \
less
# 配置系统时间
RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
&& echo 'Asia/Shanghai' > /etc/timezone
VOLUME /tmp
# 设置工作目录
ADD . /opt/ci123/www/html/java
WORKDIR /opt/ci123/www/html/java
# 指定输出端口
EXPOSE 80

  • 快速构建镜像

    sh docker/build.sh [version]

1. 环境变量配置

• 配置

  #数据库连接配置 application.properties
spring.datasource.url=jdbc:mysql://${APP_DB_HOST:192.168.0.235}:${APP_DB_PORT:3355}/${APP_DB_DATABASE:shop_balances}
spring.datasource.username=${APP_DB_USER:cishop}
spring.datasource.password=${APP_DB_PASSWORD:fuyuan1906}

  1. 启动容器( docker/run.sh )
• 启动参数

  -p // 宿主机运行端口
-d // 宿主机项目地址，缺省为执行run.sh的上一级目录
-n // 容器名称
-v // 镜像版本号
-j // jar包版本，缺省为1.0

• 环境变量

  # 运行配置
APP_SERVER_PORT // 容器运行jar包的端口
# 数据库配置
APP_DB_HOST
APP_DB_PORT
APP_DB_DATABASE
APP_DB_USER
APP_DB_PASSWORD
# 日志配置
APP_LOG_PATH // 日志输出地址
APP_LOG_SPRING_WEB_LEVEL // 对应logging.level.org.springframework.web，指org.springframework.web这个包下的日志输出等级，默认为ERROR，开发环境可配置为DEBUG
APP_LOG_MYBATIS_LEVEL // 对应logging.level.com.duomai.balance_card.Model.Mapper，指balance_card.Model.Mapper包下的日志输出等级，默认为ERROR，开发环境可配置为DEBUG，开启DEBUG之后可在日志中查看DB操作

• 启动容器

  docker run -d \
-e APP_SERVER_PORT=8080 \
-e APP_DB_HOST=192.168.0.235 \
-e APP_DB_PORT=3355 \
-e APP_DB_DATABASE=shop_balances \
-e APP_DB_USER=cishop \
-e APP_DB_PASSWORD=fuyuan1906 \
-e APP_LOG_PATH=/opt/ci123/www/html/java/balance_card/log \
-e APP_LOG_SPRING_WEB_LEVEL=DEBUG \
-e APP_LOG_MYBATIS_LEVEL=DEBUG \
-p $port:80 \
-v $dir:/opt/ci123/www/html/java/balance_card \
--restart=always \
--name $name \
harbor.oneitfarm.com/duomai/java-balance_card:$version \
sh /opt/ci123/www/html/java/balance_card/docker/start.sh -j $jarName

建议食用本文前请先阅读【RabbitMq 普通集群搭建】篇

一、镜像队列集群概念

​ 镜像队列是基于普通集群模式的扩展，普通集群模式下如果某一个节点宕机，该节点下的队列操作将完全失效。而在镜像队列模式下，队列的数据将被复制到所有节点（或者配置过的节点）中，从而保证了一个节点宕机，其余节点也可以正常消费此消息。但此模式下也必然会带来性能下降、内存/磁盘消耗增加、网络IO负担增加等问题，所以镜像队列适用于对高可用要求比较高的系统。

1. 每个镜像队列由一个主队列和一个或多个镜像组成。每个镜像队列都有自己的主节点，主队列存放于主节点上。对队列产生的操作将首先应用于队列的主节点，然后传播到镜像节点。包括发布队列、向消费者传递消息、跟踪来自消费者的确认等行为。
2. 发布到集群中的消息将被复制到所有的镜像队列中，消费者连接任意节点消费队列实际上都将被连接至主队列的节点上。如果主队列已经确认消费了消息，则其余镜像队列中的消息将被丢弃。
3. 如果主队列所在的节点发生异常，默认情况下最“老”的镜像队列将被选举为主队列，当然也可以制定不同的选举策略。

二、配置镜像队列

1. 将队列配置成镜像队列需要通过创建policy来实现。policy包含策略键ha-mode和其对应的键值ha-params(可选)组成。

• exactly模式
  • ha-params为count，表示队列的总数量。
  • count表示主队列+镜像队列的总数量，如果count为1，则表示只存在于主队列。如果 count为2则表示存在主队列和一个镜像队列，以此类推。如果count值大于集群中节点的总数则表示所有节点都将同步一份镜像队列。如果某个镜像队列的节点宕机，则会寻找一个剩余未同步的节点来同步镜像队列。
• all模式
  • 不需要ha-params。
  • 此模式下所有节点都将同步镜像队列，如果有新节点加入，则新节点也会进行同步。官方建议同步镜像队列的节点数为N/2 + 1,其中N表示节点总数。同步到所有节点会增加所有集群节点的负载，包括网络I/O、磁盘I/O和磁盘空间的使用等。
• nodes模式
  • ha-params为node names，节点的名称。
  • 此模式下将在指定的节点上同步镜像队列，如果声明队列时其余节点均不在新，则只会在声明连接的那个节点上创建队列。

1. 配置policy

• rabbitmqctl命令配置

  set_policy [-p vhost] [--priority priority] [--apply-to apply-to] name pattern definition

  • name：策略名称
  • pattern：策略匹配符，正则表达式。当与给定资源匹配时，将应用该策略。
  • definition：策略内容定义，JSON字符串。
  • priority：策略的优先级，整数。数字越大，优先级越高。默认值为0。
  • apply-to：策略应用的对象，支持queues,exchanges,all,默认值为all

    // exactly模式，匹配前缀为two的资源
    rabbitmqctl set_policy -p cluster ha-two ^two. '{"ha-mode":"exactly","ha-params":2,"ha-sync-mode":"automatic"}'
    
    // all模式，匹配所有前缀
    rabbitmqctl set_policy -p cluster ha-all ^ '{"ha-mode":"all"}'
    
    // nodes模式，匹配所有前缀
    rabbitmqctl set_policy -p cluster ha-nodes ^ '{"ha-mode":"nodes","ha-params":["rabbit@nodeA", "rabbit@nodeB"]}'
    

• management管理后台配置

  Admin -> Policies -> Add / update a policy

1. 新镜像队列同步设置

• ha-sync-mode:manual

  默认模式，新队列镜像将不同步现有消息，只接收新消息。当消费者消费完所有仅存在于主队列上的消息后，新的队列镜像将随着时间的推移成为和主节点队列相同的精确镜像队列。

• ha-sync-mode: automatic

  当新队列镜像加入时，队列将自动同步所有消息。

三、额外说明

1. 独占队列不会被复制为镜像队列。
2. 主节点队列失效后，其中一个镜像队列将被选举为主队列并带来如下影响：
   1. 与主机点连接的客户端将全部断开。
   2. 运行时间最长的镜像队列将被选举为主队列，如果镜像队列尚未开始同步，则队列上的消息将丢失。
   3. 新的主队列会认为之前所有的消费者的连接都已经断开，它将重新发送旧队列中没有收到ack的消息。这可能出现客户端已经发送过ack, 但是服务端在接收到之前就已宕机的情况，从而导致发送两遍相同的消息，因此所有未确认的消息都将使用redelivered标志重新发送。
   4. 如果消费者连着的是镜像队列节点，并且消费者在启动时设置了x-cancel-on-ha-failover参数，则消费者将收到一个服务端消费取消的通知，如果未设置此参数，则消费者将无法感知主节点已宕机。
   5. 如果使用自动ack机制则消息将丢失。
3. 如果停止了某个包含主节点队列的节点，则其他节点的镜像队列将被选举为主节点队列。在重新启动此节点后，该节点只会被当做是一个新加入集群的节点，不会重新成为主节点队列。
4. 在主节点队列宕机并且其他镜像队列尚未同步的极端情况下，rabbitMq集群将拒绝任何镜像队列选举为主队列，整个队将不可用且被关闭。如果在镜像队列尚未同步的情况下也需要将某个镜像队列选举为主队列，需要配置policy中ha-promote-on-shutdown为always（默认为when-synced），并且ha-promote-on-failure不可配置为hen-synced（默认值为always）。

四、集群测试

1. 启动节点、创建用户、vhost、exchange、queue，启动消费者。（快速启动，参考【RabbitMq 使用docker搭建集群】篇）

   1. 节点：
      1. 节点一：rabbit@clusterRabbit1
      2. 节点二：rabbit@clusterRabbit2
   2. 用户：api_management（administrator标签，开放虚拟主机cluster所有权限）

   3. 策略：

      rabbitmqctl set_policy -p cluster ha-all ^ '{"ha-mode":"all"}'
      

   4. vhost：cluster

   5. exchange：cluster（直连交换机）

   6. queue：

      1. 节点一 rabbit@clusterRabbit1：
         1. 队列一：
         • name：clusterRabbit1Queue1
         • routing_key：clusterRabbit1key
         1. 队列二：
         • name：clusterRabbit1Queue2
         • routing_key：clusterRabbitCommonKey
      2. 节点二 rabbit@clusterRabbit2：
         1. 队列三：
         • name：clusterRabbit2Queue1
         • routing_key：clusterRabbit2key
         1. 队列四：
         • name：clusterRabbit2Queue2
         • routing_key：clusterRabbitCommonKey（与队列二 相同）
   7. consumer：
      1. 消费者一：
      • 连接节点：节点一 rabbit@clusterRabbit1
      • 消费队列：队列一 clusterRabbit1Queue1
        1. 消费者二：
      • 连接节点：节点一 rabbit@clusterRabbit1
      • 消费队列：队列二 clusterRabbit1Queue2
        1. 消费者三：
      • 连接节点：节点二 rabbit@clusterRabbit2
      • 消费队列：队列三 clusterRabbit2Queue1
        1. 消费者四（非此节点的队列）：
      • 连接节点：节点一 rabbit@clusterRabbit1
      • 消费队列：队列三 clusterRabbit2Queue1
        1. 消费者五：
      • 连接节点：节点二 rabbit@clusterRabbit2
      • 消费队列：队列四 clusterRabbit2Queue2

2. 连接节点二 rabbit@clusterRabbit2,再次声明队列名和队列一同名的队列clusterRabbit1Queue1。【同名队列再次声明】

• 结果：声明不成功，节点二中没有生成新的clusterRabbit1Queue1队列，而节点一中clusterRabbit1Queue1队列多出了新绑定的routing_key:clusterRabbit2key,这意味着在同一集群中不同节点之间的队列名是唯一的,在一个节点中可以操作另一个节点的队列数据。

1. 生产者连接节点一 rabbit@clusterRabbit1，发布clusterRabbit1key消息。【发布此节点队列消息】

• 消费者一 成功接收到消息。

1. 生产者连接节点二 rabbit@clusterRabbi2，发布clusterRabbit1key消息。【发布非此节点队列消息】

• 消费者一 成功接收到消息。

1. 生产者连接节点一 rabbit@clusterRabbit1，发布clusterRabbitCommonKey消息。【多个节点队列绑定相同消息】

• 消费者二 成功接收到消息。
• 消费者五 成功接收到消息。

1. 生产者连接节点一 rabbit@clusterRabbit1，发布clusterRabbit2key消息。【消费非此节点队列消息】

• 消费三、四 轮询接收到消息。

1. 关闭节点二 rabbit@clusterRabbit2，连接节点一 rabbit@clusterRabbit1，发布clusterRabbit2key消息【投递消息给集群中意外退出的节点】

• 连接节点二 rabbit@clusterRabbit2的消费者全部断开，消费者四并未断开。
• 节点一rabbit@clusterRabbit1 晋升成为队列三、队列四的主节点。
• 消费者四 可以继续成功接收到消息。
• 再次启动节点二rabbit@clusterRabbit2，没有再次成为队列三、队列四的主节点，只是复制了队列三、队列四的镜像队列。

1. 修改消费者四，在ack之前sleep(20)，发布clusterRabbit2key消息，并立即关闭节点二 rabbit@clusterRabbit2

• 和上面一样，消费者四并未断开。
• 消费者收到两条相同的消息，说明节点二在收到 ack之前宕机后，此消息会被当做未消费的消息重新放入队列后消费。