一、开发基础

• 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