异步编程实战之r2dbc

最新推荐文章于 2024-08-19 10:23:41 发布
最新推荐文章于 2024-08-19 10:23:41 发布
阅读量717 收藏 9
点赞数 8
分类专栏： 框架部分 Java 文章标签： mybatis java r2dbc 异步编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35255384/article/details/136426880
版权

 一, 添加依赖

<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-generator</artifactId>
  <version>3.5.2</version>
</dependency>
<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus</artifactId>
  <version>3.5.1</version>
</dependency>
<dependency>
  <groupId>org.freemarker</groupId>
  <artifactId>freemarker</artifactId>
  <version>2.3.31</version>
</dependency>

二, 数据库连接配置

spring.r2dbc.username=root
spring.r2dbc.password=cl8q!a#jrkYgMBHu
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模板

package ${package.Controller};

import io.swagger.annotations.ApiResponse;
import com.shuinfo.ods_poc.vo.${entity}.${entity}SaveReq;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
<#if superControllerClassPackage??>
import ${superControllerClassPackage};
</#if>
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PutMapping;
import io.swagger.v3.oas.annotations.Operation;
import com.fasterxml.jackson.annotation.JsonView;
import com.shuinfo.ods_poc.view.TestView;
import com.shuinfo.ods_poc.vo.R;
import ${package.Service}.${table.serviceName};
import com.shuinfo.ods_poc.vo.${entity}.${entity}SaveResp;
import reactor.core.publisher.Mono;
import org.springframework.web.bind.annotation.*;

/**
 * <p>
 * ${table.comment!} 前端控制器
 * @author ${author}
 * @since ${date}
 */
@RestController
@RequestMapping("<#if package.ModuleName?? && package.ModuleName != "">/${package.ModuleName}</#if>/<#if controllerMappingHyphenStyle>${controllerMappingHyphen}<#else>${table.entityPath}</#if>")
@Slf4j
public class ${table.controllerName} {
  @Autowired
  private ${table.serviceName} ${table.serviceName?uncap_first};

  @PutMapping("/save")
  @Operation(summary = "保存数据")
  @JsonView(value = TestView.class)
  @ApiResponse(code = 200, message = "返回数据", response = R.class)
  public Mono<R<${entity}SaveResp>> save(@RequestBody ${entity}SaveReq req){
    return ${table.serviceName?uncap_first}.save(req).map(R::successRespons);
  }

  @GetMapping("/delete")
  @Operation(summary = "根据单号删除数据")
  @JsonView(value = TestView.class)
  @ApiResponse(code = 200, message = "返回数据", response = R.class)
  public Mono<String> delete(@RequestParam("orderNo") String orderNo){
    return ${table.serviceName?uncap_first}.delete(orderNo);
  }

}

dao模版:

package ${package.Mapper};

import org.springframework.data.r2dbc.repository.R2dbcRepository;
import ${package.Entity}.${entity};

public interface ${table.mapperName} extends R2dbcRepository<${entity}, Long> {

}

serviceImpl模版:

package ${package.Service};
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ${package.Mapper}.${table.mapperName};
import ${package.Entity}.${entity};
import com.shuinfo.ods_poc.vo.${entity}.${entity}SaveReq;
import com.shuinfo.ods_poc.vo.${entity}.${entity}SaveResp;
import reactor.core.publisher.Mono;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
/**
 * <p>
 * ${table.comment!} 服务实现类
 * @author ${author}
 * @since ${date}
 */
@Service
@Slf4j
public class ${table.serviceName}{
    @Autowired
    private ${table.mapperName} ${table.mapperName?uncap_first};
    @Autowired
    private R2dbcEntityTemplate r2dbcEntityTemplate;

    public Mono<${entity}SaveResp> save(${entity}SaveReq req) {
        ${entity}SaveResp resp = new ${entity}SaveResp();
        if(req == null || StringUtils.isEmpty(req.getOrderNo())){
            return Mono.just(resp);
        }
        ${entity} ${entity?uncap_first} = new ${entity}();
        BeanUtils.copyProperties(req,${entity?uncap_first});
        return ${table.mapperName?uncap_first}.save(${entity?uncap_first}).log().map(entity -> {
            resp.set${entity}(entity);
            return resp;
        });
    }

    public Mono<String> delete(String orderNo) {
        if(StringUtils.isEmpty(orderNo)){
            return Mono.just("订单号不能为空！");
        }
        String sql = "delete from `${table.name}` where order_no = :orderNo";
        return r2dbcEntityTemplate.getDatabaseClient().sql(sql).bind("orderNo",orderNo)
                .then().thenReturn("删除成功！");
    }
}

entity模版

package ${package.Entity};

import io.swagger.annotations.ApiModelProperty;
<#list table.importPackages as pkg>
import ${pkg};
</#list>
<#if swagger>
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
</#if>
<#if entityLombokModel>
import lombok.Getter;
import lombok.Setter;
    <#if chainModel>
import lombok.experimental.Accessors;
    </#if>
</#if>

/**
 * <p>
 * ${table.comment!}
 * </p>
 *
 * @author ${author}
 * @since ${date}
 */
<#if entityLombokModel>
@Getter
@Setter
    <#if chainModel>
@Accessors(chain = true)
    </#if>
</#if>
<#if table.convert>
@TableName("${schemaName}${table.name}")
</#if>
<#if swagger>
@ApiModel(value = "${entity}对象", description = "${table.comment!}")
</#if>
<#if superEntityClass??>
public class ${entity} extends ${superEntityClass}<#if activeRecord><${entity}></#if> {
<#elseif activeRecord>
public class ${entity} extends Model<${entity}> {
<#elseif entitySerialVersionUID>
public class ${entity} implements Serializable {
<#else>
public class ${entity} {
</#if>
<#if entitySerialVersionUID>

    private static final long serialVersionUID = 1L;
</#if>
<#-- ----------  BEGIN 字段循环遍历  ---------->
<#list table.fields as field>
    <#if field.keyFlag>
        <#assign keyPropertyName="${field.propertyName}"/>
    </#if>

    <#if field.comment!?length gt 0>
        <#if swagger>
    @ApiModelProperty("${field.comment}")
        <#else>
    /**
     * ${field.comment}
     */
        </#if>
    </#if>
    <#if field.keyFlag>
        <#-- 主键 -->
        <#if field.keyIdentityFlag>
    @TableId(value = "${field.annotationColumnName}", type = IdType.AUTO)
        <#elseif idType??>
    @TableId(value = "${field.annotationColumnName}", type = IdType.${idType})
        <#elseif field.convert>
    @TableId("${field.annotationColumnName}")
        </#if>
        <#-- 普通字段 -->
    <#elseif field.fill??>
    <#-- -----   存在字段填充设置   ----->
        <#if field.convert>
    @TableField(value = "${field.annotationColumnName}", fill = FieldFill.${field.fill})
        <#else>
    @TableField(fill = FieldFill.${field.fill})
        </#if>
    <#elseif field.convert>
    @TableField("${field.annotationColumnName}")
    </#if>
    <#-- 乐观锁注解 -->
    <#if field.versionField>
    @Version
    </#if>
    <#-- 逻辑删除注解 -->
    <#if field.logicDeleteField>
    @TableLogic
    </#if>

    @ApiModelProperty(value = "${field.comment}")
    private ${field.propertyType} ${field.propertyName};
</#list>


<#------------  END 字段循环遍历  ---------->

<#if !entityLombokModel>
    <#list table.fields as field>
        <#if field.propertyType == "boolean">
            <#assign getprefix="is"/>
        <#else>
            <#assign getprefix="get"/>
        </#if>
    public ${field.propertyType} ${getprefix}${field.capitalName}() {
        return ${field.propertyName};
    }

    <#if chainModel>
    public ${entity} set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
    <#else>
    public void set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
    </#if>
        this.${field.propertyName} = ${field.propertyName};
        <#if chainModel>
        return this;
        </#if>
    }
    </#list>
</#if>

<#if entityColumnConstant>
    <#list table.fields as field>
    public static final String ${field.name?upper_case} = "${field.name}";

    </#list>
</#if>
<#if activeRecord>
    @Override
    public Serializable pkVal() {
    <#if keyPropertyName??>
        return this.${keyPropertyName};
    <#else>
        return null;
    </#if>
    }

</#if>
<#if !entityLombokModel>
    @Override
    public String toString() {
        return "${entity}{" +
    <#list table.fields as field>
        <#if field_index==0>
            "${field.propertyName}=" + ${field.propertyName} +
        <#else>
            ", ${field.propertyName}=" + ${field.propertyName} +
        </#if>
    </#list>
        "}";
    }
</#if>
}

四, 编写入口生成主类

package org.flywaydb.core.internal.database.generate;

import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class R2dbcGenerate {

    /**
     * 数据源配置
     */
    private static final DataSourceConfig.Builder DATA_SOURCE_CONFIG = new DataSourceConfig
            .Builder("jdbc:mysql://172.16.1.187:2883/ob_test?userSSL=false&useUnicode=true" +
            "&characterEncoding=UTF-8&sslMode=DISABLED&serverTimeZone=GMT%2B8",
            "root", "cl8q!a#jrkYgMBHu");
    private static GlobalConfig.Builder builder;

    /**
     * 执行 run
     */
    public static void main(String[] args){
        FastAutoGenerator.create(DATA_SOURCE_CONFIG)
                // 全局配置
                .globalConfig(builder -> builder
                                .author("zhihao").dateType(DateType.TIME_PACK)
                                .commentDate("yyyy-MM-dd")
                                // 输出路径
                                .outputDir("/Users/lizhihao/shuxin/wlc/starbuck-ods-webflux-poc/src/main/java")
                        )
                // 包配置
                .packageConfig(builder -> builder.parent("com.shuinfo.ods_poc.test")
//                .packageConfig(builder -> builder.parent("com.shuinfo.ods_poc")
                        //自定义mapper名，同dao
                        .mapper("dao")
                        .other("vo")
//                        .pathInfo(Collections.singletonMap(OutputFile.other,
//                                "/Users/lizhihao/shuxin/wlc/starbuck-ods-webflux-poc/src/main/java/com/shuinfo/ods_poc/vo"))
                )
                // 策略配置 表名
                .strategyConfig(builder -> builder.addInclude("main_order,order_customer,order_line," +
                        "order_line_discount,order_payment,order_price,order_service_type_config"))
                /*
                    模板引擎配置，默认 Velocity 可选模板引擎 Beetl 或 Freemarker
                   .templateEngine(new BeetlTemplateEngine())
                 */
                .templateEngine(new FreemarkerTemplateEngine())
                .templateConfig(builder -> builder.disable(TemplateType.MAPPER)
                        .disable(TemplateType.SERVICEIMPL).disable(TemplateType.XML)
                                .disable(TemplateType.CONTROLLER)
                        .entity("/templates/entity")
                        .mapper("/templates/dao")
                        .service("/templates/serviceImpl")
                        .controller("/templates/controller")
                        )
                //设置自定义的模块类及模版文件
                .injectionConfig(builder ->
                        builder.beforeOutputFile((tableInfo, objectMap) -> {
                            //自定义入参对象
                            Map<String,String> map = new HashMap<>(10);
                            map.put(tableInfo.getEntityName()+"SaveReq.java", "/templates/req.ftl");
                            map.put(tableInfo.getEntityName()+"SaveResp.java", "/templates/resp.ftl");
                            builder.customFile(map);
                            System.out.println("tableInfo: " + tableInfo.getEntityName() + " objectMap: " + objectMap.size());
                        })
                )
                .execute();
    }


}

五, 编写DataSourceConfig

/*
 * Copyright (c) 2011-2021, baomidou (jobob@qq.com).
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * <p>
 * https://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package org.flywaydb.core.internal.database.generate;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.config.IConfigBuilder;
import com.baomidou.mybatisplus.generator.config.IDbQuery;
import com.baomidou.mybatisplus.generator.config.IKeyWordsHandler;
import com.baomidou.mybatisplus.generator.config.ITypeConvert;
import com.baomidou.mybatisplus.generator.config.converts.MySqlTypeConvert;
import com.baomidou.mybatisplus.generator.config.converts.TypeConverts;
import com.baomidou.mybatisplus.generator.config.querys.DbQueryDecorator;
import com.baomidou.mybatisplus.generator.config.querys.DbQueryRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Optional;

/**
 * 数据库配置
 *
 * @author YangHu, hcl, hubin
 * @since 2016/8/30
 */
public class DataSourceConfig {
    protected final Logger logger = LoggerFactory.getLogger(DataSourceConfig.class);

    private DataSourceConfig() {
    }

    /**
     * 数据库信息查询
     */
    private IDbQuery dbQuery;

    /**
     * schemaName
     */
    private String schemaName;

    /**
     * 类型转换
     */
    private ITypeConvert typeConvert;

    /**
     * 关键字处理器
     *
     * @since 3.3.2
     */
    private IKeyWordsHandler keyWordsHandler;

    /**
     * 驱动连接的URL
     */
    private String url;

    /**
     * 数据库连接用户名
     */
    private String username;

    /**
     * 数据库连接密码
     */
    private String password;

    /**
     * 数据源实例
     *
     * @since 3.5.0
     */
    private DataSource dataSource;

    /**
     * 数据库连接
     *
     * @since 3.5.0
     */
    private Connection connection;

    /**
     * 获取数据库查询
     */
    public IDbQuery getDbQuery() {
        if (null == dbQuery) {
            DbType dbType = getDbType();
            DbQueryRegistry dbQueryRegistry = new DbQueryRegistry();
            // 默认 MYSQL
            dbQuery = Optional.ofNullable(dbQueryRegistry.getDbQuery(dbType))
                .orElseGet(() -> dbQueryRegistry.getDbQuery(DbType.MYSQL));
        }
        return dbQuery;
    }

    /**
     * 判断数据库类型
     *
     * @return 类型枚举值
     */
    public DbType getDbType() {
        return this.getDbType(this.url.toLowerCase());
    }

    /**
     * 判断数据库类型
     *
     * @param str url
     * @return 类型枚举值，如果没找到，则返回 null
     */
    private DbType getDbType(String str) {
        if (str.contains(":mysql:") || str.contains(":cobar:")) {
            return DbType.MYSQL;
        } else if (str.contains(":oracle:")) {
            return DbType.ORACLE;
        } else if (str.contains(":postgresql:")) {
            return DbType.POSTGRE_SQL;
        } else if (str.contains(":sqlserver:")) {
            return DbType.SQL_SERVER;
        } else if (str.contains(":db2:")) {
            return DbType.DB2;
        } else if (str.contains(":mariadb:")) {
            return DbType.MARIADB;
        } else if (str.contains(":sqlite:")) {
            return DbType.SQLITE;
        } else if (str.contains(":h2:")) {
            return DbType.H2;
        } else if (str.contains(":kingbase:") || str.contains(":kingbase8:")) {
            return DbType.KINGBASE_ES;
        } else if (str.contains(":dm:")) {
            return DbType.DM;
        } else if (str.contains(":zenith:")) {
            return DbType.GAUSS;
        } else if (str.contains(":oscar:")) {
            return DbType.OSCAR;
        } else if (str.contains(":firebird:")) {
            return DbType.FIREBIRD;
        } else if (str.contains(":xugu:")) {
            return DbType.XU_GU;
        } else if (str.contains(":clickhouse:")) {
            return DbType.CLICK_HOUSE;
        } else if (str.contains(":sybase:")) {
            return DbType.SYBASE;
        } else {
            return DbType.OTHER;
        }
    }

    /**
     * 获取数据库字段类型转换
     */
    public ITypeConvert getTypeConvert() {
        if (null == typeConvert) {
            DbType dbType = getDbType();
            // 默认 MYSQL
            typeConvert = TypeConverts.getTypeConvert(dbType);
            if (null == typeConvert) {
                typeConvert = MySqlTypeConvert.INSTANCE;
            }
        }
        return typeConvert;
    }

    /**
     * 创建数据库连接对象
     * 这方法建议只调用一次，毕竟只是代码生成，用一个连接就行。
     *
     * @return Connection
     * @see DbQueryDecorator#getConnection()
     */
    public Connection getConn() {
        try {
            if (connection != null && !connection.isClosed()) {
                return connection;
            } else {
                synchronized (this) {
                    if (dataSource != null) {
                        connection = dataSource.getConnection();
                    } else {
                        this.connection = DriverManager.getConnection(url, username, password);
                    }
                }
            }
            String schema = StringUtils.isNotBlank(schemaName) ? schemaName : getDefaultSchema();
            if (StringUtils.isNotBlank(schema)) {
                schemaName = schema;
                try {
                    connection.setSchema(schemaName);
                } catch (Throwable t) {
                    logger.error("There may be exceptions in the driver and version of the database, " + t.getMessage());
                }
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
        return connection;
    }

    /**
     * 获取数据库默认schema
     *
     * @return 默认schema
     * @since 3.5.0
     */
    protected String getDefaultSchema() {
        DbType dbType = getDbType();
        String schema = null;
        if (DbType.POSTGRE_SQL == dbType) {
            //pg 默认 schema=public
            schema = "public";
        } else if (DbType.KINGBASE_ES == dbType) {
            //kingbase 默认 schema=PUBLIC
            schema = "PUBLIC";
        } else if (DbType.DB2 == dbType) {
            //db2 默认 schema=current schema
            schema = "current schema";
        } else if (DbType.ORACLE == dbType) {
            //oracle 默认 schema=username
            schema = this.username.toUpperCase();
        }
        return schema;
    }

    public String getSchemaName() {
        return schemaName;
    }

    public IKeyWordsHandler getKeyWordsHandler() {
        return keyWordsHandler;
    }

    public String getUrl() {
        return url;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }


    /**
     * 数据库配置构建者
     *
     * @author nieqiurong 2020/10/10.
     * @since 3.5.0
     */
    public static class Builder implements IConfigBuilder<DataSourceConfig> {

        private final DataSourceConfig dataSourceConfig;

        private Builder() {
            this.dataSourceConfig = new DataSourceConfig();
        }

        /**
         * 构造初始化方法
         *
         * @param url      数据库连接地址
         * @param username 数据库账号
         * @param password 数据库密码
         */
        public Builder(String url, String username, String password) {
            this();
            if (StringUtils.isBlank(url)) {
                throw new RuntimeException("无法创建文件，请正确输入 url 配置信息！");
            }
            this.dataSourceConfig.url = url;
            this.dataSourceConfig.username = username;
            this.dataSourceConfig.password = password;
        }

        /**
         * 构造初始化方法
         *
         * @param dataSource 外部数据源实例
         */
        public Builder(DataSource dataSource) {
            this();
            this.dataSourceConfig.dataSource = dataSource;
            try {
                Connection conn = dataSource.getConnection();
                this.dataSourceConfig.url = conn.getMetaData().getURL();
                this.dataSourceConfig.schemaName = conn.getSchema();
                this.dataSourceConfig.connection = conn;
                this.dataSourceConfig.username = conn.getMetaData().getUserName();
            } catch (SQLException ex) {
                throw new RuntimeException("构建数据库配置对象失败!", ex);
            }
        }

        /**
         * 设置数据库查询实现
         *
         * @param dbQuery 数据库查询实现
         * @return this
         */
        public Builder dbQuery(IDbQuery dbQuery) {
            this.dataSourceConfig.dbQuery = dbQuery;
            return this;
        }

        /**
         * 设置数据库schema
         *
         * @param schemaName 数据库schema
         * @return this
         */
        public Builder schema(String schemaName) {
            this.dataSourceConfig.schemaName = schemaName;
            return this;
        }

        /**
         * 设置类型转换器
         *
         * @param typeConvert 类型转换器
         * @return this
         */
        public Builder typeConvert(ITypeConvert typeConvert) {
            this.dataSourceConfig.typeConvert = typeConvert;
            return this;
        }

        /**
         * 设置数据库关键字处理器
         *
         * @param keyWordsHandler 关键字处理器
         * @return this
         */
        public Builder keyWordsHandler(IKeyWordsHandler keyWordsHandler) {
            this.dataSourceConfig.keyWordsHandler = keyWordsHandler;
            return this;
        }

        /**
         * 构建数据库配置
         *
         * @return 数据库配置
         */
        @Override
        public DataSourceConfig build() {
            return this.dataSourceConfig;
        }
    }
}

远方的、远方的、、、
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Boot 2.x实战90 - 响应式编程5 - Reactive 关系型数据库（R2DBC）
汪云飞记录本
07-07 1693
4. Reactive关系型数据库-R2DBC 与关系型数据库进行交互的JDBC不具备与数据库异步交互的能力，R2DBC（Reactive Relational Database Connectivity）将响应式编程API带给关系型SQL数据库。 Spring Data R2DBC为此提供支持，同样Spring Boot也提供了starter：spring-boot-starter-data-r2dbc和自动配置：spring-boot-actuator-autoconfigure-r2dbc。 在本书编
R2DBC，最新java下载教程
m0_64867003的博客
12-10 206
官方文档：https://docs.spring.io/spring-data/r2dbc/docs/1.1.0.RELEASE/reference/html/#r2dbc.datbaseclient.fluent-api 1.简介(摘自官网) R2DBC是 Reactive Relational Database Connectivity 的首字母缩写词。R2DBC 是一个 API 规范倡议，它声明了一个响应式 API，由驱动程序供应商实现以访问他们的关系数据库。 关于为什么创建 R2DBC.
spring webflux r2dbc使用mysql项目样例
shengzi101的专栏
05-28 863
响应式编程，一定要丢弃命令式编程的习惯，要进行思想转变，按照相应式、流的方式来思考实现步骤。并且，在响应式项目中，一定不要使用阻塞式方法，否则就失去了响应式编程的优点。
mybatis-r2dbc:MyBatis R2DBC适配器
04-24
MyBatis R2DBC Adapter 将MyBatis Reactive化，将底层的JDBC替换为R2DBC，从而实现全面异步化，提升数据库访问性能。 MyBatis R2DBC工作原理 对数据CRUD操作SqlSession接口进行Reactive化，对于R2DBC适配来说为ReactiveSqlSession Mapper接口Reactive化，将函数的类型从对象和List调整为Mono和Flux SQL的执行器调整为R2DBC的接口，这里我们不需要类似MyBatis的Executor机制，Reactive框架为R2DBC提供了执行调度功能 结果处理和映射： 支持，你也可以扩展R2DBCTypeHandler添加自定义类型。MyBatis R2DBC增加了JDBC Types的支持，主要是考虑兼容性。 如何使用? 和MyBatis的使用流程一样，如下： // construct
探索高效数据库访问：MyBatis R2DBC Adapter
gitblog_00018的博客
06-18 524
探索高效数据库访问：MyBatis R2DBC Adapter 项目地址:https://gitcode.com/linux-china/mybatis-r2dbc 在现代Web应用程序中，数据库性能往往成为瓶颈。为了突破这一点，开发者们不断寻求新的解决方案。MyBatis R2DBC Adapter 正是一个创新的开源项目，它将经典的MyBatis框架与先进的Reactive数据库访问技术R2D...
SpringOne大会上发布了一个实验性的反应式关系型数据库连接驱动R2DBC
cpongo011702
10-03 359
在SpringOne平台华盛顿大会上宣布的R2DBC是一个从头开始设计的实验性API，用于针对关系型数据库进行反应式编程。最终目标是试图影响ADBA规范。\u0026#xD;\u0026#xD;在活动中，Cloud Foundry Java Experience团队负责人Ben Hale表示，R2DBC的设计原则是基于以下四个原则：\u0026#xD;\u0026#xD;利用反应式流类型和模式；\...
R2DBC
zj18006的博客
07-23 1216
R2DBC整合mysql 前言: 目前关于响应式编程这块的教程的还不多，我也踩了很多雷，最终完成一个demo,在此分享出来。在操作之前需要WebFlux的前置知识。 分享一份WebFlux的博客：https://cloud.tencent.com/developer/article/1847825 官方文档：https://docs.spring.io/spring-data/r2dbc/docs/1.1.0.RELEASE/reference/html/#r2dbc.datbaseclient.flue
Spring Framework：使用R2DBC进行数据访问
听海边涛声
03-16 1151
Spring Framework：使用R2DBC进行数据访问
Spring Data R2DBC
BLOG域名:programb.blog.csdn.net
05-11 502
Overview Learn Samples Spring Data R2DBC, part of the larger Spring Data family, makes it easy to implement R2DBC based repositories. R2DBC stands for Reactive Relational Database Connectivity, an incubator to integrate relational databases using a reacti
R2DBC，手持4个大厂offer的我
m0_64867896的博客
12-22 329
R2DBC是 Reactive Relational Database Connectivity 的首字母缩写词。R2DBC 是一个 API 规范倡议，它声明了一个响应式 API，由驱动程序供应商实现以访问他们的关系数据库。 关于为什么创建 R2DBC 的部分答案是需要一个非阻塞应用程序堆栈来处理具有少量线程的并发并使用较少的硬件资源进行扩展。重用标准化的关系数据库访问 API（即 JDBC）无法满足这种需求，因为 JDBC 是一个完全阻塞的 API。尝试使用 a 来补偿阻塞行为ThreadPoo..
Spring Webflux 响应式编程 (二) - WebFlux编程实战
11-20
同时，WebFlux也支持反应式数据库如R2DBC，实现数据库操作的非阻塞。 4. 异常处理： 在WebFlux中，异常会被自动转换为HTTP错误响应。你可以通过全局异常处理器或在`Mono`和`Flux`链中添加错误处理来定制异常处理...
springboot-r2dbc-study:Spring启动R2dbc研究
04-10
R2dbc MySQL测试 服务器应用程序为R2dbc + MySQL测试提供简单的API 环境 开发环境：Mac，Java 11 终端命令的执行基于项目的根文件夹 数据库设置 必需：docker-compose可用环境 # Start Mysql instance $ docker-compose -f ./docker/mysql/docker-compose.yml up -d # Set DB Scheme $ ./mvnw -Dflyway.configFiles=src/main/resources/db/migration/flyway.conf flyway:migrate 运行Spring Boot $ ./mvnw spring-boot:run
Reactive Spring实战——响应式MySql交互
duan18888的博客
05-10 644
本文与大家探讨Spring中如何实现MySql响应式交互。 Spring Data R2DBC项目是Spring提供的数据库响应式编程框架。 R2DBC是Reactive Relational Database Connectivity的首字母缩写词。 R2DBC是一个API规范倡议，它声明了一个响应式API，由驱动程序供应商实现，并以响应式编程的方式访问他们的关系数据库。 实现数据库的响应式编程并不容易，传统的JDBC协议是一个完全阻塞的 API，所以响应式编程对JDBC协议可以说是一种“颠覆...
R2DBC-响应式数据库
bennettzhou404的博客
01-20 3556
r2dbcEntityTemplate:操作数据库的响应式客户端,提供crud Api数据类型映射关系,转换器。spring data 提供了基础的crud接口,不用写任何实现的情况下,可以直接具有crud功能。1.导入驱动:导入连接池(r2dbc-pool),导入驱动(r2dbc-mysql)3.多表查询复杂结果集合:DatabaseClient自定义sql,自定义结果封装。Converter:把数据库每一行row,转换成book。数据类型 int -> integer;
响应式编程——R2DBC
weixin_50458070的博客
01-24 460
Web、网络、IO（存储）、中间件（Redis、MySQL）
79、SpringBoot 整合 R2DBC --- R2DBC 就是 JDBC 的 反应式版本， R2DBC 是 JDBC 的升级版。
Java 领域技术分享
09-21 2947
SpringBoot 整合 R2DBC --- R2DBC 就是 JDBC 的 反应式版本， R2DBC 是 JDBC 的升级版。
R2DBC 揭秘（一）
龙哥盟
08-19 611
在这一章中，你已经了解了什么是反应式编程，它什么时候有用，以及它是如何工作的。您已经对声明式编程如何帮助异步数据流创建非阻塞、反应式解决方案有了较高的理解。在下一章中，我们将研究如何利用这些原则，通过使用反应式关系数据库连接(R2DBC)来促进与关系数据库的反应式交互。反应式编程已经成为应用开发的一个游戏变化，这一点也不奇怪。正如我在前一章所解释的，它对于创建非阻塞解决方案来帮助优化资源使用非常有用。但是为了让一个解决方案真正具有反应性，它必须无处不在，包括数据库交互。
MyBatis R2DBC 使用教程
最新发布
gitblog_00882的博客
08-19 403
MyBatis R2DBC 使用教程 mybatis-r2dbcMyBatis R2DBC Adapter项目地址:https://gitcode.com/gh_mirrors/my/mybatis-r2dbc 项目介绍 MyBatis R2DBC 是一个旨在将 MyBatis 与 R2DBC（Reactive Relational Database Connectivity）结合的项目。R2D...
R2DBC：响应式关系型数据库连接规范
R2DBC (Reactive Relational Database Connectivity) 是一个针对反应式编程设计的规范，它使得Java开发者能够在数据库访问层实现非阻塞的异步操作。这一特性对于构建高性能的应用至关重要，因为它避免了线程的等待和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

远方的、远方的、、、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值