devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

异步编程实战之r2dbc

作者：我家小花儿 | 2024-03-07 01:30:14

赞

踩

异步编程实战之r2dbc

 一, 添加依赖

  1. <dependency>
  2.   <groupId>com.baomidou</groupId>
  3.   <artifactId>mybatis-plus-generator</artifactId>
  4.   <version>3.5.2</version>
  5. </dependency>
  6. <dependency>
  7.   <groupId>com.baomidou</groupId>
  8.   <artifactId>mybatis-plus</artifactId>
  9.   <version>3.5.1</version>
  10. </dependency>
  11. <dependency>
  12.   <groupId>org.freemarker</groupId>
  13.   <artifactId>freemarker</artifactId>
  14.   <version>2.3.31</version>
  15. </dependency>

二, 数据库连接配置

  1. spring.r2dbc.username=root
  2. spring.r2dbc.password=cl8q!a#jrkYgMBHu
  3. spring.r2dbc.url=r2dbcs:mysql://172.16.1.187:2883/ob_test?userSSL=false&useUnicode=true&characterEncoding=UTF-8&sslMode=DISABLED&serverTimeZone=GMT%2B8

三, 编写模版文件

controller模板

  1. package ${package.Controller};
  2.  
  3. import io.swagger.annotations.ApiResponse;
  4. import com.shuinfo.ods_poc.vo.${entity}.${entity}SaveReq;
  5. import org.springframework.web.bind.annotation.RequestBody;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.RestController;
  8. <#if superControllerClassPackage??>
  9. import ${superControllerClassPackage};
  10. </#if>
  11. import lombok.extern.slf4j.Slf4j;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.web.bind.annotation.PutMapping;
  14. import io.swagger.v3.oas.annotations.Operation;
  15. import com.fasterxml.jackson.annotation.JsonView;
  16. import com.shuinfo.ods_poc.view.TestView;
  17. import com.shuinfo.ods_poc.vo.R;
  18. import ${package.Service}.${table.serviceName};
  19. import com.shuinfo.ods_poc.vo.${entity}.${entity}SaveResp;
  20. import reactor.core.publisher.Mono;
  21. import org.springframework.web.bind.annotation.*;
  22.  
  23. /**
  24.  * <p>
  25.  * ${table.comment!} 前端控制器
  26.  * @author ${author}
  27.  * @since ${date}
  28.  */
  29. @RestController
  30. @RequestMapping("<#if package.ModuleName?? && package.ModuleName != "">/${package.ModuleName}</#if>/<#if controllerMappingHyphenStyle>${controllerMappingHyphen}<#else>${table.entityPath}</#if>")
  31. @Slf4j
  32. public class ${table.controllerName} {
  33.   @Autowired
  34.   private ${table.serviceName} ${table.serviceName?uncap_first};
  35.  
  36.   @PutMapping("/save")
  37.   @Operation(summary = "保存数据")
  38.   @JsonView(value = TestView.class)
  39.   @ApiResponse(code = 200, message = "返回数据", response = R.class)
  40.   public Mono<R<${entity}SaveResp>> save(@RequestBody ${entity}SaveReq req){
  41.     return ${table.serviceName?uncap_first}.save(req).map(R::successRespons);
  42.   }
  43.  
  44.   @GetMapping("/delete")
  45.   @Operation(summary = "根据单号删除数据")
  46.   @JsonView(value = TestView.class)
  47.   @ApiResponse(code = 200, message = "返回数据", response = R.class)
  48.   public Mono<String> delete(@RequestParam("orderNo") String orderNo){
  49.     return ${table.serviceName?uncap_first}.delete(orderNo);
  50.   }
  51.  
  52. }

dao模版:

  1. package ${package.Mapper};
  2.  
  3. import org.springframework.data.r2dbc.repository.R2dbcRepository;
  4. import ${package.Entity}.${entity};
  5.  
  6. public interface ${table.mapperName} extends R2dbcRepository<${entity}, Long> {
  7.  
  8. }

serviceImpl模版:

  1. package ${package.Service};
  2. import lombok.extern.slf4j.Slf4j;
  3. import org.springframework.beans.BeanUtils;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  6. import ${package.Mapper}.${table.mapperName};
  7. import ${package.Entity}.${entity};
  8. import com.shuinfo.ods_poc.vo.${entity}.${entity}SaveReq;
  9. import com.shuinfo.ods_poc.vo.${entity}.${entity}SaveResp;
  10. import reactor.core.publisher.Mono;
  11. import org.apache.commons.lang3.StringUtils;
  12. import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
  13. /**
  14.  * <p>
  15.  * ${table.comment!} 服务实现类
  16.  * @author ${author}
  17.  * @since ${date}
  18.  */
  19. @Service
  20. @Slf4j
  21. public class ${table.serviceName}{
  22.     @Autowired
  23.     private ${table.mapperName} ${table.mapperName?uncap_first};
  24.     @Autowired
  25.     private R2dbcEntityTemplate r2dbcEntityTemplate;
  26.  
  27.     public Mono<${entity}SaveResp> save(${entity}SaveReq req) {
  28.         ${entity}SaveResp resp = new ${entity}SaveResp();
  29.         if(req == null || StringUtils.isEmpty(req.getOrderNo())){
  30.             return Mono.just(resp);
  31.         }
  32.         ${entity} ${entity?uncap_first} = new ${entity}();
  33.         BeanUtils.copyProperties(req,${entity?uncap_first});
  34.         return ${table.mapperName?uncap_first}.save(${entity?uncap_first}).log().map(entity -> {
  35.             resp.set${entity}(entity);
  36.             return resp;
  37.         });
  38.     }
  39.  
  40.     public Mono<String> delete(String orderNo) {
  41.         if(StringUtils.isEmpty(orderNo)){
  42.             return Mono.just("订单号不能为空！");
  43.         }
  44.         String sql = "delete from `${table.name}` where order_no = :orderNo";
  45.         return r2dbcEntityTemplate.getDatabaseClient().sql(sql).bind("orderNo",orderNo)
  46.                 .then().thenReturn("删除成功！");
  47.     }
  48. }

entity模版

  1. package ${package.Entity};
  2.  
  3. import io.swagger.annotations.ApiModelProperty;
  4. <#list table.importPackages as pkg>
  5. import ${pkg};
  6. </#list>
  7. <#if swagger>
  8. import io.swagger.annotations.ApiModel;
  9. import io.swagger.annotations.ApiModelProperty;
  10. </#if>
  11. <#if entityLombokModel>
  12. import lombok.Getter;
  13. import lombok.Setter;
  14.     <#if chainModel>
  15. import lombok.experimental.Accessors;
  16.     </#if>
  17. </#if>
  18.  
  19. /**
  20.  * <p>
  21.  * ${table.comment!}
  22.  * </p>
  23.  *
  24.  * @author ${author}
  25.  * @since ${date}
  26.  */
  27. <#if entityLombokModel>
  28. @Getter
  29. @Setter
  30.     <#if chainModel>
  31. @Accessors(chain = true)
  32.     </#if>
  33. </#if>
  34. <#if table.convert>
  35. @TableName("${schemaName}${table.name}")
  36. </#if>
  37. <#if swagger>
  38. @ApiModel(value = "${entity}对象", description = "${table.comment!}")
  39. </#if>
  40. <#if superEntityClass??>
  41. public class ${entity} extends ${superEntityClass}<#if activeRecord><${entity}></#if> {
  42. <#elseif activeRecord>
  43. public class ${entity} extends Model<${entity}> {
  44. <#elseif entitySerialVersionUID>
  45. public class ${entity} implements Serializable {
  46. <#else>
  47. public class ${entity} {
  48. </#if>
  49. <#if entitySerialVersionUID>
  50.  
  51.     private static final long serialVersionUID = 1L;
  52. </#if>
  53. <#-- ----------  BEGIN 字段循环遍历  ---------->
  54. <#list table.fields as field>
  55.     <#if field.keyFlag>
  56.         <#assign keyPropertyName="${field.propertyName}"/>
  57.     </#if>
  58.  
  59.     <#if field.comment!?length gt 0>
  60.         <#if swagger>
  61.     @ApiModelProperty("${field.comment}")
  62.         <#else>
  63.     /**
  64.      * ${field.comment}
  65.      */
  66.         </#if>
  67.     </#if>
  68.     <#if field.keyFlag>
  69.         <#-- 主键 -->
  70.         <#if field.keyIdentityFlag>
  71.     @TableId(value = "${field.annotationColumnName}", type = IdType.AUTO)
  72.         <#elseif idType??>
  73.     @TableId(value = "${field.annotationColumnName}", type = IdType.${idType})
  74.         <#elseif field.convert>
  75.     @TableId("${field.annotationColumnName}")
  76.         </#if>
  77.         <#-- 普通字段 -->
  78.     <#elseif field.fill??>
  79.     <#-- -----   存在字段填充设置   ----->
  80.         <#if field.convert>
  81.     @TableField(value = "${field.annotationColumnName}", fill = FieldFill.${field.fill})
  82.         <#else>
  83.     @TableField(fill = FieldFill.${field.fill})
  84.         </#if>
  85.     <#elseif field.convert>
  86.     @TableField("${field.annotationColumnName}")
  87.     </#if>
  88.     <#-- 乐观锁注解 -->
  89.     <#if field.versionField>
  90.     @Version
  91.     </#if>
  92.     <#-- 逻辑删除注解 -->
  93.     <#if field.logicDeleteField>
  94.     @TableLogic
  95.     </#if>
  96.  
  97.     @ApiModelProperty(value = "${field.comment}")
  98.     private ${field.propertyType} ${field.propertyName};
  99. </#list>
  100.  
  101.  
  102. <#------------  END 字段循环遍历  ---------->
  103.  
  104. <#if !entityLombokModel>
  105.     <#list table.fields as field>
  106.         <#if field.propertyType == "boolean">
  107.             <#assign getprefix="is"/>
  108.         <#else>
  109.             <#assign getprefix="get"/>
  110.         </#if>
  111.     public ${field.propertyType} ${getprefix}${field.capitalName}() {
  112.         return ${field.propertyName};
  113.     }
  114.  
  115.     <#if chainModel>
  116.     public ${entity} set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
  117.     <#else>
  118.     public void set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
  119.     </#if>
  120.         this.${field.propertyName} = ${field.propertyName};
  121.         <#if chainModel>
  122.         return this;
  123.         </#if>
  124.     }
  125.     </#list>
  126. </#if>
  127.  
  128. <#if entityColumnConstant>
  129.     <#list table.fields as field>
  130.     public static final String ${field.name?upper_case} = "${field.name}";
  131.  
  132.     </#list>
  133. </#if>
  134. <#if activeRecord>
  135.     @Override
  136.     public Serializable pkVal() {
  137.     <#if keyPropertyName??>
  138.         return this.${keyPropertyName};
  139.     <#else>
  140.         return null;
  141.     </#if>
  142.     }
  143.  
  144. </#if>
  145. <#if !entityLombokModel>
  146.     @Override
  147.     public String toString() {
  148.         return "${entity}{" +
  149.     <#list table.fields as field>
  150.         <#if field_index==0>
  151.             "${field.propertyName}=" + ${field.propertyName} +
  152.         <#else>
  153.             ", ${field.propertyName}=" + ${field.propertyName} +
  154.         </#if>
  155.     </#list>
  156.         "}";
  157.     }
  158. </#if>
  159. }

四, 编写入口生成主类

  1. package org.flywaydb.core.internal.database.generate;
  2.  
  3. import com.baomidou.mybatisplus.generator.FastAutoGenerator;
  4. import com.baomidou.mybatisplus.generator.config.*;
  5. import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
  6. import com.baomidou.mybatisplus.generator.config.rules.DateType;
  7. import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
  8. import java.util.Collections;
  9. import java.util.HashMap;
  10. import java.util.Map;
  11.  
  12. public class R2dbcGenerate {
  13.  
  14.     /**
  15.      * 数据源配置
  16.      */
  17.     private static final DataSourceConfig.Builder DATA_SOURCE_CONFIG = new DataSourceConfig
  18.             .Builder("jdbc:mysql://172.16.1.187:2883/ob_test?userSSL=false&useUnicode=true" +
  19.             "&characterEncoding=UTF-8&sslMode=DISABLED&serverTimeZone=GMT%2B8",
  20.             "root", "cl8q!a#jrkYgMBHu");
  21.     private static GlobalConfig.Builder builder;
  22.  
  23.     /**
  24.      * 执行 run
  25.      */
  26.     public static void main(String[] args){
  27.         FastAutoGenerator.create(DATA_SOURCE_CONFIG)
  28.                 // 全局配置
  29.                 .globalConfig(builder -> builder
  30.                                 .author("zhihao").dateType(DateType.TIME_PACK)
  31.                                 .commentDate("yyyy-MM-dd")
  32.                                 // 输出路径
  33.                                 .outputDir("/Users/lizhihao/shuxin/wlc/starbuck-ods-webflux-poc/src/main/java")
  34.                         )
  35.                 // 包配置
  36.                 .packageConfig(builder -> builder.parent("com.shuinfo.ods_poc.test")
  37. //                .packageConfig(builder -> builder.parent("com.shuinfo.ods_poc")
  38.                         //自定义mapper名，同dao
  39.                         .mapper("dao")
  40.                         .other("vo")
  41. //                        .pathInfo(Collections.singletonMap(OutputFile.other,
  42. //                                "/Users/lizhihao/shuxin/wlc/starbuck-ods-webflux-poc/src/main/java/com/shuinfo/ods_poc/vo"))
  43.                 )
  44.                 // 策略配置 表名
  45.                 .strategyConfig(builder -> builder.addInclude("main_order,order_customer,order_line," +
  46.                         "order_line_discount,order_payment,order_price,order_service_type_config"))
  47.                 /*
  48.                     模板引擎配置，默认 Velocity 可选模板引擎 Beetl 或 Freemarker
  49.                    .templateEngine(new BeetlTemplateEngine())
  50.                  */
  51.                 .templateEngine(new FreemarkerTemplateEngine())
  52.                 .templateConfig(builder -> builder.disable(TemplateType.MAPPER)
  53.                         .disable(TemplateType.SERVICEIMPL).disable(TemplateType.XML)
  54.                                 .disable(TemplateType.CONTROLLER)
  55.                         .entity("/templates/entity")
  56.                         .mapper("/templates/dao")
  57.                         .service("/templates/serviceImpl")
  58.                         .controller("/templates/controller")
  59.                         )
  60.                 //设置自定义的模块类及模版文件
  61.                 .injectionConfig(builder ->
  62.                         builder.beforeOutputFile((tableInfo, objectMap) -> {
  63.                             //自定义入参对象
  64.                             Map<String,String> map = new HashMap<>(10);
  65.                             map.put(tableInfo.getEntityName()+"SaveReq.java", "/templates/req.ftl");
  66.                             map.put(tableInfo.getEntityName()+"SaveResp.java", "/templates/resp.ftl");
  67.                             builder.customFile(map);
  68.                             System.out.println("tableInfo: " + tableInfo.getEntityName() + " objectMap: " + objectMap.size());
  69.                         })
  70.                 )
  71.                 .execute();
  72.     }
  73.  
  74.  
  75. }

五, 编写DataSourceConfig

  1. /*
  2.  * Copyright (c) 2011-2021, baomidou (jobob@qq.com).
  3.  * <p>
  4.  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  5.  * use this file except in compliance with the License. You may obtain a copy of
  6.  * the License at
  7.  * <p>
  8.  * https://www.apache.org/licenses/LICENSE-2.0
  9.  * <p>
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12.  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13.  * License for the specific language governing permissions and limitations under
  14.  * the License.
  15.  */
  16. package org.flywaydb.core.internal.database.generate;
  17.  
  18. import com.baomidou.mybatisplus.annotation.DbType;
  19. import com.baomidou.mybatisplus.core.toolkit.StringUtils;
  20. import com.baomidou.mybatisplus.generator.config.IConfigBuilder;
  21. import com.baomidou.mybatisplus.generator.config.IDbQuery;
  22. import com.baomidou.mybatisplus.generator.config.IKeyWordsHandler;
  23. import com.baomidou.mybatisplus.generator.config.ITypeConvert;
  24. import com.baomidou.mybatisplus.generator.config.converts.MySqlTypeConvert;
  25. import com.baomidou.mybatisplus.generator.config.converts.TypeConverts;
  26. import com.baomidou.mybatisplus.generator.config.querys.DbQueryDecorator;
  27. import com.baomidou.mybatisplus.generator.config.querys.DbQueryRegistry;
  28. import org.slf4j.Logger;
  29. import org.slf4j.LoggerFactory;
  30. import javax.sql.DataSource;
  31. import java.sql.Connection;
  32. import java.sql.DriverManager;
  33. import java.sql.SQLException;
  34. import java.util.Optional;
  35.  
  36. /**
  37.  * 数据库配置
  38.  *
  39.  * @author YangHu, hcl, hubin
  40.  * @since 2016/8/30
  41.  */
  42. public class DataSourceConfig {
  43.     protected final Logger logger = LoggerFactory.getLogger(DataSourceConfig.class);
  44.  
  45.     private DataSourceConfig() {
  46.     }
  47.  
  48.     /**
  49.      * 数据库信息查询
  50.      */
  51.     private IDbQuery dbQuery;
  52.  
  53.     /**
  54.      * schemaName
  55.      */
  56.     private String schemaName;
  57.  
  58.     /**
  59.      * 类型转换
  60.      */
  61.     private ITypeConvert typeConvert;
  62.  
  63.     /**
  64.      * 关键字处理器
  65.      *
  66.      * @since 3.3.2
  67.      */
  68.     private IKeyWordsHandler keyWordsHandler;
  69.  
  70.     /**
  71.      * 驱动连接的URL
  72.      */
  73.     private String url;
  74.  
  75.     /**
  76.      * 数据库连接用户名
  77.      */
  78.     private String username;
  79.  
  80.     /**
  81.      * 数据库连接密码
  82.      */
  83.     private String password;
  84.  
  85.     /**
  86.      * 数据源实例
  87.      *
  88.      * @since 3.5.0
  89.      */
  90.     private DataSource dataSource;
  91.  
  92.     /**
  93.      * 数据库连接
  94.      *
  95.      * @since 3.5.0
  96.      */
  97.     private Connection connection;
  98.  
  99.     /**
  100.      * 获取数据库查询
  101.      */
  102.     public IDbQuery getDbQuery() {
  103.         if (null == dbQuery) {
  104.             DbType dbType = getDbType();
  105.             DbQueryRegistry dbQueryRegistry = new DbQueryRegistry();
  106.             // 默认 MYSQL
  107.             dbQuery = Optional.ofNullable(dbQueryRegistry.getDbQuery(dbType))
  108.                 .orElseGet(() -> dbQueryRegistry.getDbQuery(DbType.MYSQL));
  109.         }
  110.         return dbQuery;
  111.     }
  112.  
  113.     /**
  114.      * 判断数据库类型
  115.      *
  116.      * @return 类型枚举值
  117.      */
  118.     public DbType getDbType() {
  119.         return this.getDbType(this.url.toLowerCase());
  120.     }
  121.  
  122.     /**
  123.      * 判断数据库类型
  124.      *
  125.      * @param str url
  126.      * @return 类型枚举值，如果没找到，则返回 null
  127.      */
  128.     private DbType getDbType(String str) {
  129.         if (str.contains(":mysql:") || str.contains(":cobar:")) {
  130.             return DbType.MYSQL;
  131.         } else if (str.contains(":oracle:")) {
  132.             return DbType.ORACLE;
  133.         } else if (str.contains(":postgresql:")) {
  134.             return DbType.POSTGRE_SQL;
  135.         } else if (str.contains(":sqlserver:")) {
  136.             return DbType.SQL_SERVER;
  137.         } else if (str.contains(":db2:")) {
  138.             return DbType.DB2;
  139.         } else if (str.contains(":mariadb:")) {
  140.             return DbType.MARIADB;
  141.         } else if (str.contains(":sqlite:")) {
  142.             return DbType.SQLITE;
  143.         } else if (str.contains(":h2:")) {
  144.             return DbType.H2;
  145.         } else if (str.contains(":kingbase:") || str.contains(":kingbase8:")) {
  146.             return DbType.KINGBASE_ES;
  147.         } else if (str.contains(":dm:")) {
  148.             return DbType.DM;
  149.         } else if (str.contains(":zenith:")) {
  150.             return DbType.GAUSS;
  151.         } else if (str.contains(":oscar:")) {
  152.             return DbType.OSCAR;
  153.         } else if (str.contains(":firebird:")) {
  154.             return DbType.FIREBIRD;
  155.         } else if (str.contains(":xugu:")) {
  156.             return DbType.XU_GU;
  157.         } else if (str.contains(":clickhouse:")) {
  158.             return DbType.CLICK_HOUSE;
  159.         } else if (str.contains(":sybase:")) {
  160.             return DbType.SYBASE;
  161.         } else {
  162.             return DbType.OTHER;
  163.         }
  164.     }
  165.  
  166.     /**
  167.      * 获取数据库字段类型转换
  168.      */
  169.     public ITypeConvert getTypeConvert() {
  170.         if (null == typeConvert) {
  171.             DbType dbType = getDbType();
  172.             // 默认 MYSQL
  173.             typeConvert = TypeConverts.getTypeConvert(dbType);
  174.             if (null == typeConvert) {
  175.                 typeConvert = MySqlTypeConvert.INSTANCE;
  176.             }
  177.         }
  178.         return typeConvert;
  179.     }
  180.  
  181.     /**
  182.      * 创建数据库连接对象
  183.      * 这方法建议只调用一次，毕竟只是代码生成，用一个连接就行。
  184.      *
  185.      * @return Connection
  186.      * @see DbQueryDecorator#getConnection()
  187.      */
  188.     public Connection getConn() {
  189.         try {
  190.             if (connection != null && !connection.isClosed()) {
  191.                 return connection;
  192.             } else {
  193.                 synchronized (this) {
  194.                     if (dataSource != null) {
  195.                         connection = dataSource.getConnection();
  196.                     } else {
  197.                         this.connection = DriverManager.getConnection(url, username, password);
  198.                     }
  199.                 }
  200.             }
  201.             String schema = StringUtils.isNotBlank(schemaName) ? schemaName : getDefaultSchema();
  202.             if (StringUtils.isNotBlank(schema)) {
  203.                 schemaName = schema;
  204.                 try {
  205.                     connection.setSchema(schemaName);
  206.                 } catch (Throwable t) {
  207.                     logger.error("There may be exceptions in the driver and version of the database, " + t.getMessage());
  208.                 }
  209.             }
  210.         } catch (SQLException e) {
  211.             throw new RuntimeException(e);
  212.         }
  213.         return connection;
  214.     }
  215.  
  216.     /**
  217.      * 获取数据库默认schema
  218.      *
  219.      * @return 默认schema
  220.      * @since 3.5.0
  221.      */
  222.     protected String getDefaultSchema() {
  223.         DbType dbType = getDbType();
  224.         String schema = null;
  225.         if (DbType.POSTGRE_SQL == dbType) {
  226.             //pg 默认 schema=public
  227.             schema = "public";
  228.         } else if (DbType.KINGBASE_ES == dbType) {
  229.             //kingbase 默认 schema=PUBLIC
  230.             schema = "PUBLIC";
  231.         } else if (DbType.DB2 == dbType) {
  232.             //db2 默认 schema=current schema
  233.             schema = "current schema";
  234.         } else if (DbType.ORACLE == dbType) {
  235.             //oracle 默认 schema=username
  236.             schema = this.username.toUpperCase();
  237.         }
  238.         return schema;
  239.     }
  240.  
  241.     public String getSchemaName() {
  242.         return schemaName;
  243.     }
  244.  
  245.     public IKeyWordsHandler getKeyWordsHandler() {
  246.         return keyWordsHandler;
  247.     }
  248.  
  249.     public String getUrl() {
  250.         return url;
  251.     }
  252.  
  253.     public String getUsername() {
  254.         return username;
  255.     }
  256.  
  257.     public String getPassword() {
  258.         return password;
  259.     }
  260.  
  261.  
  262.     /**
  263.      * 数据库配置构建者
  264.      *
  265.      * @author nieqiurong 2020/10/10.
  266.      * @since 3.5.0
  267.      */
  268.     public static class Builder implements IConfigBuilder<DataSourceConfig> {
  269.  
  270.         private final DataSourceConfig dataSourceConfig;
  271.  
  272.         private Builder() {
  273.             this.dataSourceConfig = new DataSourceConfig();
  274.         }
  275.  
  276.         /**
  277.          * 构造初始化方法
  278.          *
  279.          * @param url      数据库连接地址
  280.          * @param username 数据库账号
  281.          * @param password 数据库密码
  282.          */
  283.         public Builder(String url, String username, String password) {
  284.             this();
  285.             if (StringUtils.isBlank(url)) {
  286.                 throw new RuntimeException("无法创建文件，请正确输入 url 配置信息！");
  287.             }
  288.             this.dataSourceConfig.url = url;
  289.             this.dataSourceConfig.username = username;
  290.             this.dataSourceConfig.password = password;
  291.         }
  292.  
  293.         /**
  294.          * 构造初始化方法
  295.          *
  296.          * @param dataSource 外部数据源实例
  297.          */
  298.         public Builder(DataSource dataSource) {
  299.             this();
  300.             this.dataSourceConfig.dataSource = dataSource;
  301.             try {
  302.                 Connection conn = dataSource.getConnection();
  303.                 this.dataSourceConfig.url = conn.getMetaData().getURL();
  304.                 this.dataSourceConfig.schemaName = conn.getSchema();
  305.                 this.dataSourceConfig.connection = conn;
  306.                 this.dataSourceConfig.username = conn.getMetaData().getUserName();
  307.             } catch (SQLException ex) {
  308.                 throw new RuntimeException("构建数据库配置对象失败!", ex);
  309.             }
  310.         }
  311.  
  312.         /**
  313.          * 设置数据库查询实现
  314.          *
  315.          * @param dbQuery 数据库查询实现
  316.          * @return this
  317.          */
  318.         public Builder dbQuery(IDbQuery dbQuery) {
  319.             this.dataSourceConfig.dbQuery = dbQuery;
  320.             return this;
  321.         }
  322.  
  323.         /**
  324.          * 设置数据库schema
  325.          *
  326.          * @param schemaName 数据库schema
  327.          * @return this
  328.          */
  329.         public Builder schema(String schemaName) {
  330.             this.dataSourceConfig.schemaName = schemaName;
  331.             return this;
  332.         }
  333.  
  334.         /**
  335.          * 设置类型转换器
  336.          *
  337.          * @param typeConvert 类型转换器
  338.          * @return this
  339.          */
  340.         public Builder typeConvert(ITypeConvert typeConvert) {
  341.             this.dataSourceConfig.typeConvert = typeConvert;
  342.             return this;
  343.         }
  344.  
  345.         /**
  346.          * 设置数据库关键字处理器
  347.          *
  348.          * @param keyWordsHandler 关键字处理器
  349.          * @return this
  350.          */
  351.         public Builder keyWordsHandler(IKeyWordsHandler keyWordsHandler) {
  352.             this.dataSourceConfig.keyWordsHandler = keyWordsHandler;
  353.             return this;
  354.         }
  355.  
  356.         /**
  357.          * 构建数据库配置
  358.          *
  359.          * @return 数据库配置
  360.          */
  361.         @Override
  362.         public DataSourceConfig build() {
  363.             return this.dataSourceConfig;
  364.         }
  365.     }
  366. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/202753
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号