装置配置

软件装置

下载地址：https://www.dameng.com/view_6…

本文以 x86 win64 DM8 为例

装置结束后关上 DM 数据库配置助手创立数据库，设置字符集 utf8，去除字符大小写敏感

创立表空间及用户，最好是一个库对应一个用户一个表空间，创立用户时须要指定对应表空间

须要对用户调配 DBA 操作权限

数据表迁徙

针对现有我的项目或框架库须要同步迁徙达到梦数据库，本文以 mysql5.7 为例，关上 DM 数据迁徙工具，留神放弃对象名大小写，抉择表时全副取出再全选，迁徙的表名和字段名就与原数据库保持一致

maven 援用

        <dependency>
            <groupId>com.dameng</groupId>
            <artifactId>DmJdbcDriver18</artifactId>
            <version>8.1.1.193</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.0</version>
        </dependency>        

数据库配置

应用 druid 治理连接池，去除 wall 的配置否则会报错

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
      driverClassName: dm.jdbc.driver.DmDriver
      url: jdbc:dm://localhost:5236/ROOT?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8
      username: ROOT
      password: abcd@1234
    filters: stat,slf4j

兼容代码

映射成 LinkHashMap

数据会在达梦的数据库驱动中强制大写，这对某些接口的数据返回给前端数据大小写呈现问题，影响范畴较大

JdbcTemplate 解决

咱们能够通过混合应用 jdbcTemplate 进行查问的通用操作，调用 query 办法，传入自定义的 ResultSetExtractor，失去 jdbc 原生的 ResultSet 对象，取出 ResultSetMetaData 转换成 DmdbResultSetMetaData，其中的 columns 对象为公有对象且无办法拜访，通过反射取出即可，通过 columns 获取到数据库理论的列名

    public List<LinkedHashMap<String, Object>> findListByParam(String sqlText, Map<String, Object> map) {List<LinkedHashMap<String, Object>> result = new ArrayList<>();
        List<Object> paramList = new ArrayList<>();
        // 解析 sqlText 中的占位符 #{xxxx}
        String regex = "\\#\\{(?<RegxName>[\\w.]*)\\}";
        String sqlTextCopy = sqlText;
        Pattern pattern = Pattern.compile(regex);

        Matcher matcher = pattern.matcher(sqlTextCopy);
        while (matcher.find()) {String paramNameSymbol = matcher.group(0);
            sqlText = sqlText.replace(paramNameSymbol, "?");
        }
        logger.debug("【sqlText】：" + sqlText);

        // 参数赋值
        matcher = pattern.matcher(sqlTextCopy);
        while (matcher.find()) {String paramNameSymbol = matcher.group(0);
            String paramName = paramNameSymbol.replace("#", "").replace("{","").replace("}", "");
            Object paramValue = map.get(paramName);
            logger.debug("【paramName】：" + paramName);
            logger.debug("【paramValue】：" + paramValue);
            paramList.add(paramValue);
        }

        jdbcTemplate.query(sqlText, paramList.toArray(), new ResultSetExtractor<Object>() {
            @Override
            public Object extractData(ResultSet rs) throws SQLException, DataAccessException {
                try {ResultSetMetaData rsMetaData = rs.getMetaData();
                    Column[] dm_columns = null;
                    if (dataBaseInfoUtil.getUsingDataBaseType() == GlobalEnum.DataBaseType.DM) {ResultSetMetaDataProxyImpl resultSetMetaDataProxy = (ResultSetMetaDataProxyImpl) rsMetaData;
                        DmdbResultSetMetaData dmdbResultSetMetaData = (DmdbResultSetMetaData) resultSetMetaDataProxy.getRawObject();
                        Class dataClass = DmdbResultSetMetaData.class;
                        Field field = dataClass.getDeclaredField("columns");
                        field.setAccessible(true);
                        dm_columns = (Column[]) field.get(dmdbResultSetMetaData);
                    }
                    while (rs.next()) {LinkedHashMap<String, Object> resultitem = new LinkedHashMap<>();
                        for (int i = 1; i <= rsMetaData.getColumnCount(); i++) {
                            String columnName = "";
                            if (dataBaseInfoUtil.getUsingDataBaseType() == GlobalEnum.DataBaseType.DM) {columnName = dm_columns[i - 1].name;
                            } else {columnName = rsMetaData.getColumnName(i);
                                ;
                            }
                            Object columnValue = rs.getObject(columnName);
                            resultitem.put(columnName, columnValue);
                        }
                        result.add(resultitem);
                    }

                } catch (Exception e) {e.printStackTrace();
                } finally {return null;}
            }
        });
        return result;
    }

与 mybaits 对立数据源

在应用事务时，因为查问操作通过 jdbcTemplate，更新操作通过 myabtis，在某些隔离级别下会查问不到未提交的数据，所以须要对立数据源都为 druid 治理的 datasource，这里的 dynamicDataSource 为我自定义的数据源解决对象，继承自 spring 的 AbstractRoutingDataSource，为了解决多数据源状况

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {//SpringBootExecutableJarVFS.addImplClass(SpringBootVFS.class);
        final PackagesSqlSessionFactoryBean sessionFactory = new PackagesSqlSessionFactoryBean();
        sessionFactory.setDataSource(dynamicDataSource());
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath*:mybatis/**/*Mapper.xml"));
        // 敞开驼峰转换，避免带下划线的字段无奈映射
        sessionFactory.getObject().getConfiguration().setMapUnderscoreToCamelCase(false);
        return sessionFactory.getObject();}

    @Bean
    public JdbcTemplate jdbcTemplate(){
        JdbcTemplate jdbcTemplate = null;
        try{jdbcTemplate = new JdbcTemplate(dynamicDataSource());
        }catch (Exception e){e.printStackTrace();
        }
        return jdbcTemplate;
    }

映射成实体类

对立将查问操作后果转换成 LinkHashMap 键值对，再通过 BeanMap 映射成对应的实体类

clob 长文本处理

                    Object value = map.get(resultkey);
                    if(value instanceof ClobProxyImpl){
                        try {value =  ((ClobProxyImpl) value).getSubString(1,(int)((ClobProxyImpl) value).length());
                        } catch (Exception e) {e.printStackTrace();
                        }
                    }

blob 二进制解决

                    Object value = map.get(resultkey);
                    if(value instanceof DmdbBlob){
                        try {DmdbBlob dmdbBlob = (DmdbBlob)value;
                            value = FileUtil.convertStreamToByte(dmdbBlob.getBinaryStream());
                        } catch (Exception e) {e.printStackTrace();
                        }
                    }