解决关联表的查询以及批量导入数据至solr cloud

最新推荐文章于 2021-04-28 21:38:29 发布
最新推荐文章于 2021-04-28 21:38:29 发布
阅读量221 收藏
点赞数
文章标签： 大数据 java 数据库
原文链接：https://my.oschina.net/u/3121930/blog/803362
版权

 

 

    mapreduce适合的工作方式是一开始就准备好数据资源，由mapper一条一条的处理数据，再由reducer整合。所谓兵马未动粮草先行，数据资源准备充足，mapreduce才能顺利算出结果。然而目前面临的问题是一条数据在mapper处理的过程中，需要多次查询数据库，以及写入solr cloud中。如果还是逐条处理，那么一条数据的生产代价将会非常昂贵。一个解决思路是在mapper的过程中缓存数据，批量处理。

    话不多说，直接上代码

ServiceRecord类

public class ServiceRecord implements Writable, DBWritable {
    
    // 基础信息，从表xx_service查得
    int saleId;
    String g_sid;
    String title;
    String content;
    
    // 地域信息，从表xx_service_info查得
    String provinceName;
    String cityName;
    String townName;

    // 这里实现clone方法，因为mapper在逐条格式化数据时会回收ServiceRecord对象
    public ServiceRecord clone() {
        ServiceRecord serviceRecord = new ServiceRecord();
        serviceRecord.saleId = saleId;
        serviceRecord.g_sid = g_sid;
        serviceRecord.title = title;
        serviceRecord.content = content;
        serviceRecord.provinceName = provinceName;
        serviceRecord.cityName = cityName;
        serviceRecord.townName = townName;
        return serviceRecord;
    }
    
    public void readFields(DataInput dataInput) throws IOException {
    }

    public void write(DataOutput dataOutput) throws IOException {
    }

    public void write(PreparedStatement statement) throws SQLException {
    }

    public void readFields(ResultSet resultSet) throws SQLException {
        saleId = resultSet.getInt("saleId");
        title = resultSet.getString("title");
        content = resultSet.getString("content");
        g_sid = UUID.nameUUIDFromBytes((saleId + "").getBytes()).toString();
    }
     
    public void readPositionFields(ResultSet resultSet) throws SQLException {
        provinceName = resultSet.getString("provinceName");
        cityName = resultSet.getString("cityName");
        townName = resultSet.getString("townName");
    }
}

ServiceMapper类：


import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class ServiceMapper extends Mapper<LongWritable, ServiceRecord, Text, IntWritable>{

    // 每缓存MAX_CAPACITY条数据后批量查询关联表，并且提交至solr
    private static final int MAX_CAPACITY = 100;
    
    // 总共提交至solr的数据量
    private int commitCount;
    // 缓存ServiceRecord
    private Map<Integer, ServiceRecord> serviceRecordMap;

    @Override
    protected void setup(Mapper<LongWritable, ServiceRecord, Text, IntWritable>.Context context)
            throws IOException, InterruptedException {
        super.setup(context);
        System.out.println("setup");
        
        commitCount = 0;
        serviceRecordMap = new HashMap<Integer, ServiceRecord>(MAX_CAPACITY);
        
        Configuration conf = context.getConfiguration();
        
        // init SQLUtil
        String sqlUrl = conf.get("mysql.url");
        String sqlUser = conf.get("mysql.user");
        String sqlPassword = conf.get("mysql.password");
        SQLUtil.instance().setDbUrl(sqlUrl);
        SQLUtil.instance().setDbUser(sqlUser);
        SQLUtil.instance().setDbPass(sqlPassword);
        SQLUtil.instance().init();
        
        // init SolrUtil
        String solrUrl = conf.get("solr.url");
        SolrUtil.instance().setUrl(solrUrl);
        SolrUtil.instance().init();
    }
    
    @Override
    protected void map(LongWritable key, ServiceRecord value,
            Mapper<LongWritable, ServiceRecord, Text, IntWritable>.Context context)
            throws IOException, InterruptedException {
        // 注意这里clone了value，因为value会被回收
        serviceRecordMap.put(value.saleId, value.clone());
        if (serviceRecordMap.size() >= MAX_CAPACITY) {
            // 批量处理缓存数据
            batchProcess();
        }
    }
    
    @Override
    protected void cleanup(Mapper<LongWritable, ServiceRecord, Text, IntWritable>.Context context)
            throws IOException, InterruptedException {
        // 处理剩余的缓存数据
        if (!serviceRecordMap.isEmpty()) {
            batchProcess();
        }
        // solr hard commit
        SolrUtil.instance().commit(false);
        super.cleanup(context);
    }
    
    private boolean batchProcess() {
        // 1. 查询关联表
        getPositionInfo();
        // 2. 更新至solr
        updateSolr();
        // 3. solr soft commit
        SolrUtil.instance().commit(true);
        // 4. increase commitCount
        commitCount += serviceRecordMap.size();
        // 5. 清除缓存数据
        serviceRecordMap.clear();
        System.out.println("commit: " + commitCount);
        return true;
    }
    
    private boolean getPositionInfo() {
        if (serviceRecordMap.isEmpty()) {
            return true;
        }
        // fetch connection
        Connection connection = SQLUtil.instance().getConnection();
        String sql = "SELECT service_id as saleId, province_name as provinceName, city_name as cityName, "
                + "town_name as townName from xx_service_info where service_id in ("
                + StringUtils.join(serviceRecordMap.keySet(), ',') + ");";
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            statement = connection.createStatement();
            statement.execute(sql);
            resultSet = statement.getResultSet();
            if (resultSet != null) {
                while (resultSet.next()) {
                    int saleID = resultSet.getInt("saleId");
                    ServiceRecord serviceRecord = serviceRecordMap.get(saleID);
                    if (serviceRecord != null) {
                        serviceRecord.readPositionFields(resultSet);
                    }
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
        } finally {
            SQLUtil.instance().releaseResourceNoThrow(resultSet, statement, connection);
        }
        return true;
    }
    
    private boolean updateSolr() {
        if (serviceRecordMap.isEmpty()) {
            return true;
        }
        List<ServiceRecord> serviceRecords = new ArrayList<ServiceRecord>(serviceRecordMap.values());
        return SolrUtil.instance().indexAsJson(serviceRecords);
    }

}

SQLUtil类：

import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Wrapper;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class SQLUtil {

    private static SQLUtil instance = null;

    // 连接池
    private DataSource dataSource = null;

    private String dbUrl = null;
    private String dbUser = null;
    private String dbPass = null;

    private SQLUtil() {
    }

    public static SQLUtil instance() {
        if (instance == null) {
            synchronized (SQLUtil.class) {
                if (instance == null) {
                    instance = new SQLUtil();
                }
            }
        }
        return instance;
    }

    public void init() {
        Objects.requireNonNull(dbUrl);
        Objects.requireNonNull(dbUser);
        Objects.requireNonNull(dbPass);
        create();
    }

    private void create() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setJdbcUrl(dbUrl);
        dataSource.setUser(dbUser);
        dataSource.setPassword(dbPass);
        try {
            dataSource.setDriverClass("com.mysql.jdbc.Driver");
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
        dataSource.setDataSourceName("SQLUtil");
        dataSource.setAutoCommitOnClose(false);
        dataSource.setPreferredTestQuery("select 1");
        dataSource.setMaxConnectionAge(3600);
        dataSource.setTestConnectionOnCheckout(true);
        dataSource.setIdleConnectionTestPeriod(300);
        dataSource.setDebugUnreturnedConnectionStackTraces(true);
        dataSource.setUnreturnedConnectionTimeout(120);

        this.dataSource = dataSource;
    }

    public Connection getConnection() {
        try {
            Connection connection = dataSource.getConnection();
            return connection;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    public void releaseResourceNoThrow(Wrapper... wrapperSet) {

        // 1. close ResultSet
        for (Wrapper wrapper : wrapperSet) {
            if (wrapper instanceof ResultSet) {
                try {
                    ((ResultSet) wrapper).close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

        // 2. close Statement or PreparedStatement
        for (Wrapper wrapper : wrapperSet) {
            if (wrapper instanceof PreparedStatement) {
                try {
                    ((PreparedStatement) wrapper).close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            } else if (wrapper instanceof Statement) {
                try {
                    ((Statement) wrapper).close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

        // 3. close Connection
        for (Wrapper wrapper : wrapperSet) {
            if (wrapper instanceof Connection) {
                try {
                    ((Connection) wrapper).close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void setDbUrl(String dbUrl) {
        this.dbUrl = dbUrl;
    }

    public void setDbUser(String dbUser) {
        this.dbUser = dbUser;
    }

    public void setDbPass(String dbPass) {
        this.dbPass = dbPass;
    }
}

SolrUtil类：

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class SolrUtil {
    private Gson gson = null;
    private List<NameValuePair> softCommitPairs = null;
    private List<NameValuePair> hardCommitPairs = null;
    
    private String url = null;
    
    private static SolrUtil instance = null;
    
    private SolrUtil() {
        gson = new GsonBuilder().create();
        
        NameValuePair softCommitPair = new BasicNameValuePair("softCommit", "true");
        softCommitPairs = new ArrayList<NameValuePair>();
        softCommitPairs.add(softCommitPair);
        
        NameValuePair hardCommitPair = new BasicNameValuePair("commit", "true");
        hardCommitPairs = new ArrayList<NameValuePair>();
        hardCommitPairs.add(hardCommitPair);
    }
    
    public static SolrUtil instance() {
        if (instance == null) {
            synchronized (SolrUtil.class) {
                if (instance == null) {
                    instance = new SolrUtil();
                }
            }
        }
        return instance;
    }
    
    public void init() {
        Objects.requireNonNull(url);
    }
    
    public boolean indexAsJson(ServiceRecord serviceRecord) {
        List<ServiceRecord> serviceRecords = new ArrayList<ServiceRecord>(1);
        serviceRecords.add(serviceRecord);
        return indexAsJson(serviceRecords);
    }
    
    public boolean indexAsJson(List<ServiceRecord> serviceRecords) {
        
        HttpClient httpclient = new DefaultHttpClient();
        try {
            HttpPost httppost = new HttpPost(url);
            InputStreamEntity reqEntity = new InputStreamEntity(
                    new ByteArrayInputStream(gson.toJson(serviceRecords).getBytes("UTF-8")), -1);
            reqEntity.setContentType("application/json");
            httppost.setEntity(reqEntity);
            HttpResponse response = httpclient.execute(httppost);
            if (response.getStatusLine().getStatusCode() != 200) {
                System.out.println(String.format("commit:%s with error:%s-%s",
                        httppost.getRequestLine(), 
                        response.getStatusLine().toString(), 
                        EntityUtils.toString(response.getEntity())));
                return false;
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // When HttpClient instance is no longer needed,
            // shut down the connection manager to ensure
            // immediate deallocation of all system resources
            httpclient.getConnectionManager().shutdown();
        }
        return true;
    }
    
    public boolean commit(boolean isSoftCommit) {
        HttpClient httpclient = new DefaultHttpClient();
        try {
            HttpPost httppost = new HttpPost(url);
            UrlEncodedFormEntity entity = null;
            if (isSoftCommit) {
                entity = new UrlEncodedFormEntity(softCommitPairs, HTTP.UTF_8);
            } else {
                entity = new UrlEncodedFormEntity(hardCommitPairs, HTTP.UTF_8);
            }
            httppost.setEntity(entity);
            HttpResponse response = httpclient.execute(httppost);
            if (response.getStatusLine().getStatusCode() != 200) {
                System.out.println(String.format("commit:%s with error:%s-%s",
                        httppost.getRequestLine(), 
                        response.getStatusLine().toString(), 
                        EntityUtils.toString(response.getEntity())));
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // When HttpClient instance is no longer needed,
            // shut down the connection manager to ensure
            // immediate deallocation of all system resources
            httpclient.getConnectionManager().shutdown();
        }
        return true;
    }
    
    public void setUrl(String url) {
        this.url = url;
    }
    
}

最后由IndexDriver创建job并提交job

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.lib.db.DBConfiguration;
import org.apache.hadoop.mapred.lib.db.DBInputFormat;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.MRJobConfig;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

public class IndexDriver {
    
    public static void main(String []args) throws Exception {
        String driverClass = "com.mysql.jdbc.Driver";
        String dbUrl = "jdbc:mysql://<ip>:<port>/<database>";
        String userName = "<user>";
        String password = "<password>";

        String solrUrl = "http://<ip>:<port>/solr/<collection>/update";
        
        long time_start, time_end;
        
        Configuration conf = new Configuration();
        conf.set("mysql.url", dbUrl);
        conf.set("mysql.user", userName);
        conf.set("mysql.password", password);
        conf.set("solr.url", solrUrl);
        // 单机执行时这个设置似乎没起作用，只创建了一个mapper实例
        conf.setInt(MRJobConfig.NUM_MAPS, 5);
        DBConfiguration.configureDB(conf, driverClass, dbUrl, userName, password);
        
        Job job = Job.getInstance(conf, IndexDriver.class.getName());
        job.setJarByClass(IndexDriver.class);
        DBInputFormat.setInput(job, ServiceRecord.class, "xx_service", null, null, "service_id as saleId", "subject as title", "cont as content");
        job.setOutputFormatClass(TextOutputFormat.class);
        FileOutputFormat.setOutputPath(job, new Path("/user/tanghuan/output"));
        job.setMapperClass(ServiceMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        
        time_start = System.currentTimeMillis();
        job.waitForCompletion(true);
        time_end = System.currentTimeMillis();
        System.out.println("finish job, take time: " + (time_end - time_start) + " ms");
        
    }

}

单机测试结果：commit: 572026. finish job, take time: 661384 ms

大约：865条/s

这里每条数据查mysql表两次，更新solr一次，solr每更新100条数据执行一次soft commit，在最后执行一次hard commit

总结

  1. ServiceRecord需要实现clone方法
  2. mapper并没有提供批量处理数据的接口，需要自己缓存数据再批量处理，且该方案得利于DBInputFormat查询数据库后以流的方式读取数据。

下一篇文章讲讲利用docker在单机上搭建虚拟的hadoop集群，再测试一下性能


 

转载于:https://my.oschina.net/u/3121930/blog/803362

choukun8124
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
solr运行配置与数据库数据导入到solr
12-14
建立结构为solr-tomcat/solr的两个文件夹（solr的HOME目录），如建在D盘根目录，d:/solr-tomcat/solr，solr-tomcat文件夹名字可任意命名，将apache-solr-3.6.0examplesolr下的所有文件及文件夹拷贝到这下面 ...
solr（九）：solrj操作solr cloud，实现数据单条以及批量从mysql导入数据
小蚯蚓的博客
05-01 1084
一、实现功能 使用solrj实现对solrcloud的增删改查，从而使整个项目可以实现在项目中应用。 二、环境 1.solr-4.10.3 2.zookeeper-3.4.6 3.apache-tomcat-8.5.12 4.jdk1.7 5.centos 6.4 三、具体代码 1.添加依赖 （1）solrj依赖 <!--solr--> <dependen...
SOLR对多个（关联）表创建索引
aaa1117a8w5s6d的专栏
02-19 3653
一、无关联多表创建索引 1.1数据库准备 　　首先在数据库创建一张表，本来有一个tuser表了，我又创建了一个role表，就两三个字段，没什么特殊的，然后在里面随便添加几条数据即可，看一下数据库： 1.2data-config.xml 　　数据库创建完成之后就是修改data-config.xml文件了，因为数据库跟solr之间的关联主要就是建立在这个文件上面的，所以接下来就
关于solr配置多表连接导入数据并实现
weixin_43147226的博客
03-19 398
1.先写好mysql语句先 此时是用的是内连接 代码如下 select u.id,u.username,s.real_name,c.college_name,d.apartment_name,dd.build,dd.number,dd.is_filled,ss.one,ss.two,ss.three,ss.four from uuser u join sstudent s on s.stu_id = u.id join college c on c.college_id = s.stu_college_i
solr 全量数据迁移
01-20
solr服务开启、停止、重启： cd到solr的bin目录 ./solr start | restart | stop -force ./solr start -p 9923 -force ./solr stop -p 9923 -force ...solr 全量数据迁移方法：(数据结构及数据全部迁移出来了
solr8使用solrJ查询数据使用记录
01-07
1.下载solr 下载地址 http://www.apache.org/dyn/closer.lua/lucene/solr/8.0.0 windows下载zip,linux下载tgz 下载完解压 2.solr启动&停止 solr-8.0.0\bin目录下执行cmd solr start 启动 solr stop -all 3.创建solr...
基于Solr的多表join查询加速方法
05-01
NULL 博文链接：https://mozhenghua.iteye.com/blog/2275318
solr导入数据必备jar包
08-23
包含 ： cloud-mysql-connector-java-5.1.7-bin.jar solr-dataimporthandler-6.0.1.jar solr-dataimporthandler-extras-6.0.1.jar
关于solr实现多表查询的方法
admintys的博客
10-29 4942
关于solr实现多表查询的方法 话不多说上代码. 注意点一:防止主键唯一性的冲突,我选择将主键注释掉(也可以使用uuid代替主键id) 注意点二:实现多表查询的关键是 copyField 将需要分词的关键字段copy.即可实现多表查询/ 下面为我的schema.xml 的配置文件. &lt;?xml version="1.0" ?&gt; &lt;fieldtype name="string...
solr mysql 多表_Solr数据库连接之多表关联
weixin_39631350的博客
01-19 185
Solr环境配置好后，有很多时候我们需要把数据库里的数据添加到索引里，这时就需要配置跟数据库的连接，下面我们看配置的步骤。1. 配置 solrconfig.xml (在slor 主目录 core conf下面 我的地址 ：D:\SolrHome\collection1\conf\solrconfig.xml )在根目录下加入如下配置，其中 data-config.xml 是我们要配置的数据库连接...
solr配置多表关联索引
tomcat_zhu的博客
01-16 1090
前言：多表关联索引不是多表索引，注意区分。多表索引正在研究，多表索引的条件限制就是主键的类型，如果是自增主键那么多表索引会出现后者覆盖前者的问题。如果是UUID等唯一的主键则可忽略此问题。 业务需求：将课程的相关信息添加索引到solr。 涉及到的数据表和课程先关信息： 1.课程基本信息表-课程基本信息； 2.课程章节表-课程一共的章节； 3.讲师表-课程的讲师信息； 4.课程价格表-课...
solr 7.2.1——导入表数据
那些年我们踩过的坑
03-20 2552
1.新建一个core，如果找不到配置文件就把configsets里的样例conf拷过去添加完成：2.编写数据表配置内容：此处可以配置获取数据条件增量更新条件&lt;?xml version="1.0" encoding="UTF-8" ?&gt; &lt;dataConfig&gt; &lt;dataSource type="JdbcDataSource" driver="com.mysq.
关于表关联数据几种展示方法
weixin_45951843的博客
09-17 1409
我们一般在数据库用主外建关联多张表，下面就是给大家演示当两张表关联的时候的几种展现方式： 查询到表关联数据大致可以分为两类 一、封装一个实体类 封装一个实体类就是把两张表的数据都封装到一个实体类里，然后在配置文件中用resultMap把两张表的数据封装起来，下面有两张表： 实体类： // 注意：使用mybatis时实体类id要和数据库字段名一致 @TableId("id") private Integer id; /** * 花种的id */ // @Tabl
Solr学习（八）多表导入
jiq•钦's technical Blog
05-03 4097
接着前面定时增量导入的介绍：http://blog.csdn.net/jiyiqinlovexx/article/details/24913853  这里介绍一下多表导入。 （一）
mysql根据关联字段，更新同步另一张表数据
xiaobozhang1993的博客
04-28 2033
业务场景 有两张表，体检表和档案表，体检表中有档案id，客户需要档案列表根据体检时间排序。因为目前只有一家机构使用，就有2w多条数据。所以放弃了关联查询，采用在档案表新加体检日期字段。 需要将现有体检表的体检日期，同步到档案表的体检日期字段。 解决方法 以学生和学生班级表为例，根据学生id更新班级学生的学习时间 CREATE TABLE `student` ( `id` int(11) NOT NULL, `name` varchar(255) DEFAULT NULL, `sex` ...
python增量导入oracle数据到solr
最新发布
04-05
下面是一个示例Python脚本，用于从Oracle数据库中查询并导入数据到Solr： ``` import cx_Oracle import pysolr # Oracle数据库连接配置 dsn_tns = cx_Oracle.makedsn('localhost', '1521', 'XE') conn = cx_Oracle...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值