MongoDB数据迁移

本代码将mongodb存储的数据进行迁移到另一个mongodb；啰嗦内容见谅

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.bson.Document;

import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoIterable;

public class MongoDBHandler {
    static LinkedBlockingQueue<String> collectionQueue ;
    static MongoDatabase dataExport;
    static MongoDatabase dataImport;
    static Map<String,Integer> resourceMap;
    static Map<String,Integer> destinationMap;
    static Map<String,Integer> initDestinationMap;
    static{
        collectionQueue = new LinkedBlockingQueue<String>();
        resourceMap = new HashMap<String,Integer>();
        destinationMap = new HashMap<String,Integer>();
        initDestinationMap = new HashMap<String,Integer>();
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException{
        String addressSource = "*";
        int portSource = *;
        String userNameSource = "*";
        String pwdSource = "*";
        String dataNameSource = "*";

        String addressDestination ="*";
        int portDestination = *;
        String userNameDestination = "*";
        String pwdDestination = "*";
        String dataNameDestination = "*"; 
        int count = 0;

        dataExport = getConnection(addressSource,portSource,userNameSource,dataNameSource,pwdSource);
        dataImport = getConnection(addressDestination, portDestination, userNameDestination, dataNameDestination, pwdDestination);

        MongoIterable<String> mongoIteraExport = dataExport.listCollectionNames();
        MongoIterable<String> mongoIteraImport = dataImport.listCollectionNames(); 

        MongoCursor<String> mongoCursorExport = mongoIteraExport.iterator();
        MongoCursor<String> mongoCursorImport = mongoIteraImport.iterator();

        while(mongoCursorExport.hasNext()){
            String collectionName = mongoCursorExport.next();
            System.out.println("本源数据库集合"+(++count)+"名称："+collectionName);
            if(!collectionName.contains("system") && !collectionName.contains("dotacfm")){
                collectionQueue.offer(collectionName);
            }
        }
        System.out.println("集合进入队列完毕......本源数据库集合共有 "+count+"个！");
        count = 0;
        while(mongoCursorImport.hasNext()){
            System.out.println("目标数据库导入源数据之前集合"+(++count)+"名称："+mongoCursorImport.next());
        }
        System.out.println("目标数据库导入源数据之前集合共有 "+count+"个！");
        count = 0;
        System.out.println("进行数据复制迁移开始.......");
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        while(!collectionQueue.isEmpty()){
            Future<String> future = executorService.submit(new HandleService(collectionQueue.poll(), dataExport, dataImport));
            System.out.println("源集合: "+future.get()+" 数据复制迁移完毕！");
            count++;
        }
        System.out.println("进行数据复制迁移前台结束......."+"共计数据复制迁移集合有 "+count+" 个！");

        ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(1);
        QueryService queryService = new QueryService(dataImport);
        pool.scheduleAtFixedRate(queryService,5,10,TimeUnit.SECONDS);
    }
    /**
     * 查询目标数据库集合
     * @author waniz
     *
     */
    static class QueryService implements Runnable{
        MongoDatabase dataImport;
        public QueryService(MongoDatabase dataImport){
            this.dataImport = dataImport;
        }
        @Override
        public void run() {
            MongoIterable<String> colleactionNames = dataImport.listCollectionNames();
            MongoCursor<String> cursor = colleactionNames.iterator();
            AtomicInteger count = null;
            while(cursor.hasNext()){
                count = new AtomicInteger(0);
                String name = cursor.next();
                MongoCollection<Document> documents = dataImport.getCollection(name);
                int initCount = (int) documents.count();
                FindIterable<Document> docIterable = documents.find();
                MongoCursor<Document> docCursor = docIterable.iterator();
                while(docCursor.hasNext()){
                    count.addAndGet(1);
                    docCursor.next();
                }
                destinationMap.put(name, count.intValue());
                initDestinationMap.put(name, initCount);
                System.out.println("现目标数据库集合"+name+"文档数量为： "+count.intValue());
            }
            System.out.println("------源数据库文档详细："+resourceMap.toString());
            System.out.println("------目标数据库初始文档详细："+initDestinationMap.toString());
            System.out.println("------目标数据库文档详细："+destinationMap.toString());
        }
    }
    /**
     * 数据复制迁移操作类
     * @author waniz
     *
     */
    static class HandleService implements Callable<String>{
        String collection;
        MongoDatabase dataExport,dataImport;
        public HandleService(String collection,MongoDatabase dataExport,MongoDatabase dataImport){
            this.collection = collection;
            this.dataExport = dataExport;
            this.dataImport = dataImport;
        }
        @Override
        public String call() throws Exception {
            MongoCollection<Document> collectionExport = dataExport.getCollection(collection);
            MongoCollection<Document> collectionImport = dataImport.getCollection(collection);
            FindIterable<Document> documentIterableExport = collectionExport.find();
            double denominator = collectionExport.count();
            double count = 0;
            MongoCursor<Document> documentCursor = documentIterableExport.iterator();
            while(documentCursor.hasNext()){
                Document document = documentCursor.next();
                FindIterable<Document> documentIterableImport = collectionImport.find(document);
                Document d = documentIterableImport.first();
                if(d == null){
                    collectionImport.insertOne(document);
                }
                int percent = (int)(((++count)/denominator)*100);
                System.out.println("子操作已经完成："+percent+"%");
            }
            resourceMap.put(collection, (int) count);
            System.out.println("本次线程"+Thread.currentThread().getName()+"操作集合："+collection+"；共计："+count+" 条");
            return collection;
        }
    }

    /**
     * 数据操作类
     * @author waniz
     *
     */
    static class UpdateService implements Callable<String>{
        String collection;
        MongoDatabase dataImport;
        public UpdateService(String collection,MongoDatabase dataImport){
            this.collection = collection;
            this.dataImport = dataImport;
        }
        @Override
        public String call() throws Exception {
            double count = 0;
            MongoCollection<Document> collectionDoc = dataImport.getCollection(collection);
            FindIterable<Document> docItera = collectionDoc.find();
            MongoCursor<Document> docCur = docItera.iterator();
            while(docCur.hasNext()){
                Document doc = docCur.next();
                //doc.
            }
            System.out.println("本次线程"+Thread.currentThread().getName()+"操作集合："+collection+"；共计："+count+" 条");
            return collection;
        }
    }
    /**
     * 获取mongoDB数据库链接
     * @param address
     * @param port
     * @param userName
     * @param dataName
     * @param pwd
     * @return
     */
    private static MongoDatabase getConnection(String address,int port,String userName,String dataName,String pwd){
        //ServerAddress()两个参数分别为 服务器地址 和 端口  
        ServerAddress serverAddress = new ServerAddress(address,port);  
        List<ServerAddress> addrs = new ArrayList<ServerAddress>();  
        addrs.add(serverAddress);  
        //MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码  
        //此种链接方式会有验证问题
        // MongoCredential credential = MongoCredential.createScramSha1Credential(userName, dataName, pwd.toCharArray());  
        MongoCredential credential = MongoCredential.createCredential(userName, dataName, pwd.toCharArray());
        List<MongoCredential> credentials = new ArrayList<MongoCredential>();  
        credentials.add(credential);  
        //通过连接认证获取MongoDB连接  
        MongoClient mongoClient = new MongoClient(addrs,credentials);  
        //连接到数据库  
        MongoDatabase mongoDatabase = mongoClient.getDatabase(dataName);  
        System.out.println("Connect to database "+dataName+" successfully");  
        return mongoDatabase;
    }
}