Druid数据源配置多个数据库

言简意赅

pom.xml文件引入jar包

 <!--jdbc连接数据库-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

application.properties

#
#
#
#配置多个数据库:用户信息存储数据库:xcn_admin_database
xcn_admin_database.druid.url=jdbc:mysql://数据库ip地址/xcn_admin_data?characterEncoding=utf8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
xcn_admin_database.druid.username=root
xcn_admin_database.druid.password=
xcn_admin_database.druid.driver-class-name=com.mysql.cj.jdbc.Driver
#
#
#
#配置多个数据库:商品信息数据库xcn_public_database
xcn_commodity_database.druid.url=jdbc:mysql://数据库ip地址/xcn_commodity_data?characterEncoding=utf8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
xcn_commodity_database.druid.username=root
xcn_commodity_database.druid.password=
xcn_commodity_database.druid.driver-class-name=com.mysql.cj.jdbc.Driver
#
#
#
#配置多个数据库:订单数据库xcn_public_database
xcn_order_database.druid.url=jdbc:mysql://数据库ip地址/xcn_order_data?characterEncoding=utf8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
xcn_order_database.druid.username=root
xcn_order_database.druid.password=
xcn_order_database.druid.driver-class-name=com.mysql.cj.jdbc.Driver
#
#
#
#配置多个数据库:公共信息查询数据库xcn_public_database
xcn_public_database.druid.url=jdbc:mysql://数据库ip地址/xcn_public_data?characterEncoding=utf8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
xcn_public_database.druid.username=root
xcn_public_database.druid.password=
xcn_public_database.druid.driver-class-name=com.mysql.cj.jdbc.Driver
#
#
#
#配置多个数据库:公共信息查询数据库xcn_public_database
xcn_shoppingcart_database.druid.url=jdbc:mysql://数据库ip地址/xcn_shoppingcart_data?characterEncoding=utf8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
xcn_shoppingcart_database.druid.username=root
xcn_shoppingcart_database.druid.password=
xcn_shoppingcart_database.druid.driver-class-name=com.mysql.cj.jdbc.Driver
#
#
#

#配置druid（使用 druid连接池）
#
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
#初始化连接池个数
spring.datasource.druid.initialSize=5
#最小连接池个数
spring.datasource.druid.minIdle:5
#最大连接池个数
spring.datasource.druid.maxActive=20
# 配置获取连接等待超时的时间，单位毫秒，缺省启用公平锁，并发效率会有所下降
spring.datasource.druid.maxWait:60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.druid.timeBetweenEvictionRunsMillis:60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.druid.minEvictableIdleTimeMillis=300000
# 用来检测连接是否有效的sql，要求是一个查询语句。
# 如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用
spring.datasource.druid.validationQuery=SELECT 1 FROM DUAL
# 建议配置为true，不影响性能，并且保证安全性。
# 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
spring.datasource.druid.testWhileIdle=true
# 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
spring.datasource.druid.testOnBorrow=false
# 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
spring.datasource.druid.testOnReturn=false
# 打开PSCache，并且指定每个连接上PSCache的大小
spring.datasource.druid.poolPreparedStatements=true
spring.datasource.druid.maxPoolPreparedStatementPerConnectionSize=20
# 通过别名的方式配置扩展插件，多个英文逗号分隔，常用的插件有：
# 监控统计用的filter:stat
# 日志用的filter:log4j
# 防御sql注入的filter:wall
spring.datasource.druid.filters:stat,wall,log4j
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
spring.datasource.druid.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 合并多个DruidDataSource的监控数据
spring.datasource.druid.useGlobalDataSourceStat=true

配置项java.class

配置文件说明
config：配置文件
dao：公共操作数据库接口（在每一个子类中调用 service中的接口即可，非常滴方便，下面贴代码）

package com.xcn.dsxm.main_public.database.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.github.pagehelper.PageHelper;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.Properties;

import static com.xcn.dsxm.main_public.database.config.DBConfig_xcn_admin.MYBATIS_BASEPACKAGE;

/**
 * 在SpringBoot中集成MyBatis，可以在mapper接口上添加@Mapper注解，将mapper注入到Spring,但是如果每一给mapper都添加@mapper注解会很麻烦，
 * 这时可以使用@MapperScan注解来扫描包。
 * 经测试发现，@MapperScan注解只会扫描包中的接口，不会扫描类，所以可以在包中写Provider类。
 * @MapperScan("com.demo.mapper")：扫描指定包中的接口
 * @MapperScan("com.demo.*.mapper")：一个*代表任意字符串，但只代表一级包,比如可以扫到com.demo.aaa.mapper,不能扫到com.demo.aaa.bbb.mapper
 * @MapperScan("com.demo.**.mapper")：两个*代表任意个包,比如可以扫到com.demo.aaa.mapper,也可以扫到com.demo.aaa.bbb.mapper
 */
@Configuration
@MapperScan(basePackages = MYBATIS_BASEPACKAGE,sqlSessionFactoryRef = "sqlSessionFactory_xcn_admin")
public class DBConfig_xcn_admin {

    public static final String MYBATIS_BASEPACKAGE = "com.xcn.dsxm.main.database.dao";
    public static final String MAPPER_LOCATION = "classpath*:mybatis/*.xml";

    @Value("${xcn_admin_database.druid.url}")
    private String url;

    @Value("${xcn_admin_database.druid.username}")
    private String username;

    @Value("${xcn_admin_database.druid.password}")
    private String password;

    @Value("${xcn_admin_database.druid.driver-class-name}")
    private String driverClassName;

    @Value("${spring.datasource.druid.initialSize}")
    private int initialSize;

    @Value("${spring.datasource.druid.minIdle}")
    private int minIdle;

    @Value("${spring.datasource.druid.maxActive}")
    private int maxActive;

    @Value("${spring.datasource.druid.maxWait}")
    private int maxWait;

    @Value("${spring.datasource.druid.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.druid.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.validationQuery}")
    private String validationQuery;

    @Value("${spring.datasource.druid.testWhileIdle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.druid.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.druid.testOnReturn}")
    private boolean testOnReturn;

    @Value("${spring.datasource.druid.poolPreparedStatements}")
    private boolean poolPreparedStatements;

    @Value("${spring.datasource.druid.maxPoolPreparedStatementPerConnectionSize}")
    private int maxPoolPreparedStatementPerConnectionSize;

    @Value("${spring.datasource.druid.filters}")
    private String filters;

    @Value("{spring.datasource.druid.connectionProperties}")
    private String connectionProperties;

    /**
     * 关闭数据源，否则会造成
     * (*) property for user to setup
     */
    @Bean(destroyMethod = "close", initMethod = "init")
    public DataSource dbconfig_xcn_admin() {
        DruidDataSource datasource = new DruidDataSource();

        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);   //这里可以做加密处理
        datasource.setDriverClassName(driverClassName);

        //configuration
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        datasource.setConnectionProperties(connectionProperties);

        return datasource;
    }

    @Bean(name = "transactionManager_xcn_admin")
    public DataSourceTransactionManager transactionManager_xcn_admin() {
        return new DataSourceTransactionManager(dbconfig_xcn_admin());
    }

    @Bean(name = "sqlSessionFactory_xcn_admin")
    public SqlSessionFactory sqlSessionFactory_xcn_admin(@Qualifier("dbconfig_xcn_admin") DataSource masterDataSource) throws Exception {
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setCallSettersOnNulls(true);  //当数据库值为null时，也返回字段

        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(masterDataSource);
        sessionFactory.setConfiguration(configuration); //加载配置项
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(DBConfig_xcn_admin.MAPPER_LOCATION));
        return sessionFactory.getObject();
    }

    @Bean(name = "pageHelper_xcn_admin")
    public PageHelper pageHelper() {
        PageHelper pageHelper = new PageHelper();
        Properties p = new Properties();
        p.setProperty("offsetAsPageNum", "true");
        p.setProperty("rowBoundsWithCount", "true");
        pageHelper.setProperties(p);
        return pageHelper;
    }
}

dao层

package com.xcn.dsxm.main_public.database.dao;

import org.apache.ibatis.annotations.Mapper;

import java.util.HashMap;
import java.util.List;

@Mapper
public interface DbDao_xcn_commodity {

    /**
     * 1-插入数据
     */
    public int insert(String sql) throws Exception;

    public int insert(String mybatisId, HashMap<String, Object> params) throws Exception;


    /**
     * 2-删除数据
     */
    public int delete(String sql) throws Exception;

    public int delete(String mybatisId, HashMap<String, Object> params) throws Exception;


    /**
     * 3-更新数据
     */
    public int update(String sql) throws Exception;

    public int update(String mybatisId, HashMap<String, Object> params) throws Exception;


    /**
     * 4-查询多个结果
     */
    public List<HashMap<String, Object>> more(String sql) throws Exception;

    public List<HashMap<String, Object>> more(String mybatisId, HashMap<String, Object> params) throws Exception;


    /**
     * 5-执行事务
     */
    public int transaction(List<String> sqlArr) throws Exception;

    public int transactions(HashMap<String, Object>... sqlArr) throws Exception;

    public int transactions(List<HashMap<String, Object>> sqlArr) throws Exception;
}

daoImpl

package com.xcn.dsxm.main_public.database.dao.impl;

import com.xcn.dsxm.main_public.database.config.MyBatisMapper;
import com.xcn.dsxm.main_public.database.config.MyBatistType;
import com.xcn.dsxm.main_public.database.dao.DbDao_xcn_commodity;
import com.xcn.dsxm.main_public.database.dao.DbDao_xcn_public;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;

@Repository("dbDaoImpl_xcn_commodity")
public class DbDaoImpl_xcn_commodity extends SqlSessionDaoSupport implements DbDao_xcn_commodity {


    //Mybatis取消了自动注入SqlSessionFactory 和 SqlSessionTemplate 需要手动 set 一下
    @Resource
    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory_xcn_commodity) {
        super.setSqlSessionFactory(sqlSessionFactory_xcn_commodity );
    }

    @Override
    public int insert(String sql) {
        return this.getSqlSession().insert(MyBatisMapper.Default + "insertSql", sql);
    }

    @Override
    public int insert(String mybatisId, HashMap<String, Object> params) throws Exception {
        return this.getSqlSession().insert(mybatisId, params);
    }

    @Override
    public int delete(String sql) throws Exception {
        return this.getSqlSession().delete(MyBatisMapper.Default + "deleteSql", sql);
    }

    @Override
    public int delete(String mybatisId, HashMap<String, Object> params) throws Exception {
        return this.getSqlSession().delete(mybatisId, params);
    }

    @Override
    public int update(String sql) throws Exception {
        return this.getSqlSession().delete(MyBatisMapper.Default + "updateSql", sql);
    }

    @Override
    public int update(String mybatisId, HashMap<String, Object> params) throws Exception {
        return this.getSqlSession().delete(mybatisId, params);
    }

    @Override
    public List<HashMap<String, Object>> more(String sql) throws Exception {
        return this.getSqlSession().selectList(MyBatisMapper.Default + "selectSql", sql);
    }

    @Override
    public List<HashMap<String, Object>> more(String mybatisId, HashMap<String, Object> params) throws Exception {
        return this.getSqlSession().selectList(mybatisId, params);
    }

    /**
     * 事务 如果在方法内添加 try-catch 模块，则异常直接被模块捕获，不会激发SpringMvc的事务管理
     * 如果有结果返回值为 0 ，直接 throw 一个异常被 SpringMvc 捕获即可，SpringMvc 会自动执行事务回滚
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class, transactionManager = "transactionManager_bx_member")
    public int transaction(List<String> sqlArr) throws Exception {

        int result = 0;
        try {
            for (String sql : sqlArr) {
                String targetSql = sql.toLowerCase().trim();

                if (targetSql.startsWith("insert")) {
                    result += this.insert(targetSql);
                    continue;
                }

                if (targetSql.startsWith("delete")) {
                    result += this.delete(targetSql);
                    continue;
                }

                if (targetSql.startsWith("update")) {
                    result += this.update(targetSql);
                }
            }
        } catch (Exception e) {
            throw new RuntimeException("事务执行过程中出错 回滚 transaction");
        }

        return result;
    }

    /**
     * 事务 如果在方法内添加 try-catch 模块，则异常直接被模块捕获，不会激发SpringMvc的事务管理
     * 如果有结果返回值为 0 ，直接 throw 一个异常被 SpringMvc 捕获即可，SpringMvc 会自动执行事务回滚
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class, transactionManager = "transactionManager_bx_member")
    public int transactions(HashMap<String, Object>... sqlArr) throws Exception {
        int result = 0;

        for (HashMap<String, Object> item : sqlArr) {
            if (!item.containsKey(MyBatistType.mybatisId)) {
                return -1;
            }
            if (!item.containsKey(MyBatistType.mybatisType)) {
                return -1;
            }

            String mybatisId = (String) item.get(MyBatistType.mybatisId);
            String mybatisType = (String) item.get(MyBatistType.mybatisType);

            item.remove(MyBatistType.mybatisId);
            item.remove(MyBatistType.mybatisType);

            switch (mybatisType) {
                case MyBatistType.INSERT: {
                    result += this.insert(mybatisId, item);
                }
                break;
                case MyBatistType.DELETE: {
                    result += this.delete(mybatisId, item);
                }
                break;
                case MyBatistType.UPDATE: {
                    result += this.update(mybatisId, item);
                }
                break;
            }
        }

        return result;
    }

    /**
     * 事务 如果在方法内添加 try-catch 模块，则异常直接被模块捕获，不会激发SpringMvc的事务管理
     * 如果有结果返回值为 0 ，直接 throw 一个异常被 SpringMvc 捕获即可，SpringMvc 会自动执行事务回滚
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class, transactionManager = "transactionManager_bx_member")
    public int transactions(List<HashMap<String, Object>> sqlArr) throws Exception {
        int result = 0;

        for (HashMap<String, Object> item : sqlArr) {
            if (!item.containsKey(MyBatistType.mybatisId)) {
                return -1;
            }
            if (!item.containsKey(MyBatistType.mybatisType)) {
                return -1;
            }

            String mybatisId = (String) item.get(MyBatistType.mybatisId);
            String mybatisType = (String) item.get(MyBatistType.mybatisType);

            item.remove(MyBatistType.mybatisId);
            item.remove(MyBatistType.mybatisType);

            switch (mybatisType) {
                case MyBatistType.INSERT: {
                    result += this.insert(mybatisId, item);
                }
                break;
                case MyBatistType.DELETE: {
                    result += this.delete(mybatisId, item);
                }
                break;
                case MyBatistType.UPDATE: {
                    result += this.update(mybatisId, item);
                }
                break;
            }
        }

        return result;
    }

}

service层

package com.xcn.dsxm.main_public.database.service;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

import java.util.HashMap;
import java.util.List;

public interface DbService_xcn_commodity {


    /**
     * 1-插入数据
     */
    public int insert(String sql);

    public int insert(String mybatisId, HashMap<String, Object> params);


    /**
     * 2-删除数据
     */
    public int delete(String sql);

    public int delete(String mybatisId, HashMap<String, Object> params);


    /**
     * 3-更新数据
     */
    public int update(String sql);

    public int update(String mybatisId, HashMap<String, Object> params);


    /**
     * 4-查询多个结果
     */
    public JSONArray more(String sql);

    public JSONArray more(String mybatisId, HashMap<String, Object> params);


    /**
     * 4-查询一条结果
     */
    public JSONObject one(String sql);

    public JSONObject one(String mybatisId, HashMap<String, Object> params);

    /**
     * 6-执行事务
     */
    public int transaction(List<String> sqlArr);

    public int transactions(HashMap<String, Object>... sqlArr);

    public int transactions(List<HashMap<String, Object>> sqlArr);

}

ServiceImpl

package com.xcn.dsxm.main_public.database.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.xcn.dsxm.main_public.database.dao.impl.DbDaoImpl_xcn_commodity;
import com.xcn.dsxm.main_public.database.service.DbService_xcn_commodity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;

@Service
public class DbServiceImpl_xcn_commodity implements DbService_xcn_commodity {

    @Autowired
    private DbDaoImpl_xcn_commodity dbDaoImplXcnCommodity;

    @Override
    public int insert(String sql) {
        try {
            return dbDaoImplXcnCommodity.insert(sql);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }

    @Override
    public int insert(String mybatisId, HashMap<String, Object> params) {
        try {
            return dbDaoImplXcnCommodity.insert(mybatisId, params);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }

    @Override
    public int delete(String sql) {
        try {
            return dbDaoImplXcnCommodity.delete(sql);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }

    @Override
    public int delete(String mybatisId, HashMap<String, Object> params) {
        try {
            return dbDaoImplXcnCommodity.delete(mybatisId, params);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }

    @Override
    public int update(String sql) {
        try {
            return dbDaoImplXcnCommodity.update(sql);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }

    @Override
    public int update(String mybatisId, HashMap<String, Object> params) {
        try {
            return dbDaoImplXcnCommodity.update(mybatisId, params);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }

    @Override
    public JSONArray more(String sql) {
        try {
            List<HashMap<String, Object>> mapResult = dbDaoImplXcnCommodity.more(sql);

            JSONArray jsonArray = JSONArray.parseArray(JSON.toJSONString(mapResult));
            return jsonArray;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public JSONArray more(String mybatisId, HashMap<String, Object> params) {
        try {
            List<HashMap<String, Object>> mapResult = dbDaoImplXcnCommodity.more(mybatisId, params);

            JSONArray jsonArray = JSONArray.parseArray(JSON.toJSONString(mapResult));
            return jsonArray;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public JSONObject one(String sql) {
        try {
            List<HashMap<String, Object>> mapResult = dbDaoImplXcnCommodity.more(sql);

            JSONArray jsonArray = JSONArray.parseArray(JSON.toJSONString(mapResult));
            if (jsonArray != null && jsonArray.size() > 0) {
                return jsonArray.getJSONObject(0);
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public JSONObject one(String mybatisId, HashMap<String, Object> params) {
        try {
            List<HashMap<String, Object>> mapResult = dbDaoImplXcnCommodity.more(mybatisId, params);

            JSONArray jsonArray = JSONArray.parseArray(JSON.toJSONString(mapResult));
            if (jsonArray != null && jsonArray.size() > 0) {
                return jsonArray.getJSONObject(0);
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public int transaction(List<String> sqlArr) {
        try {
            return dbDaoImplXcnCommodity.transaction(sqlArr);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }

    @Override
    public int transactions(HashMap<String, Object>... sqlArr) {
        try {
            return dbDaoImplXcnCommodity.transactions(sqlArr);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }

    @Override
    public int transactions(List<HashMap<String, Object>> sqlArr) {
        try {
            return dbDaoImplXcnCommodity.transactions(sqlArr);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }
}

有不懂得的留言私信我。