import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
@BeforeClass
public static void beforeClass() throws MalformedURLException {
    HttpClient httpClient = new StdHttpClient.Builder()
            .url("http://192.168.99.100:5984/")
            .username("mapUser")
            .password("myCouchDBSecret")
            .build();

    dbi = new StdCouchDbInstance(httpClient);
    CouchDbConnector dbc = dbi.createConnector(CouchInjector.DB_NAME, false);

    repo = new MapRepository();
    repo.db = dbc;
    repo.postConstruct();
    debugWriter = repo.sites.mapper.writerWithDefaultPrettyPrinter();
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
private CouchDbConnector initConnection(String dbName, String userName, String password, String host, int port, boolean enableSSL, int timeout)
  {
Builder builder = new StdHttpClient.Builder()
.host(host)
.port(port)
.connectionTimeout(timeout)
.socketTimeout(timeout)
.enableSSL(enableSSL); 

      
      if(userName != null && !userName.isEmpty() && password != null && !password.isEmpty())
          builder.username(userName).password(password);
      
      dbInstance = new StdCouchDbInstance(builder.build());
      if (!dbInstance.checkIfDbExists(dbName))
      	dbInstance.createDatabase(dbName);
      CouchDbConnector couchDB = dbInstance.createConnector(dbName, true);   
      return couchDB;


  }
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
@Override
public void connect() throws IOException
{
  StdHttpClient.Builder builder = new StdHttpClient.Builder();
  if (dbUrl != null) {
    try {
      builder.url(dbUrl);
    } catch (MalformedURLException e) {
      throw new IllegalArgumentException(e.getMessage());
    }
  }
  if (userName != null) {
    builder.username(userName);
  }
  if (password != null) {
    builder.password(password);
  }

  HttpClient httpClient = builder.build();
  couchInstance = new StdCouchDbInstance(httpClient);
  dbConnector = couchInstance.createConnector(dbName, false);
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
@Bean
public StdCouchDbConnector connector() throws Exception {

    String url = "http://localhost:5984/";
    String databaseName = "ektorp-integration-tests";

    Properties properties = new Properties();
    properties.setProperty("autoUpdateViewOnChange", "true");

    HttpClientFactoryBean factory = new HttpClientFactoryBean();
    factory.setUrl(url);
    factory.setProperties(properties);
    factory.afterPropertiesSet();
    HttpClient client = factory.getObject();

    CouchDbInstance dbInstance = new StdCouchDbInstance(client);
    return new StdCouchDbConnector(databaseName, dbInstance);
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
public CouchDbLiteStoreAdapter(Context context) {
	if (couchDbServer == null) {
		String filesDir = context.getFilesDir().getAbsolutePath();
		try {
			couchDbServer = new CBLServer(filesDir);
			couchDbClient = new CBLiteHttpClient(couchDbServer);
			couchDb = new StdCouchDbInstance(couchDbClient);
			db = couchDbServer.getDatabaseNamed(TOUCH_DB_NAME, true);
			
			allReports = new AllReportsByTimestampDesc(db, DESIGN_DOC_NAME);
			pendingSyncReports = new PendingSyncReports(db, DESIGN_DOC_NAME);
			uploadedReports = new UploadedReports(db, DESIGN_DOC_NAME);
		} catch (IOException e) {
			Log.e("UnicefGisStore", "Error starting TDServer", e);
		}
	}
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
public void testAttachments() throws IOException {

        HttpClient httpClient = new CBLiteHttpClient(manager);
        CouchDbInstance dbInstance = new StdCouchDbInstance(httpClient);

        CouchDbConnector dbConnector = dbInstance.createConnector(DEFAULT_TEST_DB, true);

        TestObject test = new TestObject(1, false, "ektorp");

        //create a document
        dbConnector.create(test);

        //attach file to it
        byte[] attach1 = "This is the body of attach1".getBytes();
        ByteArrayInputStream b = new ByteArrayInputStream(attach1);
        AttachmentInputStream a = new AttachmentInputStream("attach", b, "text/plain");
        dbConnector.createAttachment(test.getId(), test.getRevision(), a);

        AttachmentInputStream readAttachment = dbConnector.getAttachment(test.getId(), "attach");
        Assert.assertEquals("text/plain", readAttachment.getContentType());
        Assert.assertEquals("attach", readAttachment.getId());

        BufferedReader br = new BufferedReader(new InputStreamReader(readAttachment));
        Assert.assertEquals("This is the body of attach1", br.readLine());
    }
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
@Before
public void before() throws Exception {
    loadConfiguration();

    if (isConfigured()) {
        final int timeout = 8 * 1000; // 8 seconds should be more than
                                      // enough
        httpClient = new StdHttpClient.Builder().socketTimeout(timeout).host(getHostname()).build();

        // set up a simple database
        couchDbInstance = new StdCouchDbInstance(httpClient);

        final String databaseName = getDatabaseName();
        if (couchDbInstance.getAllDatabases().contains(databaseName)) {
            throw new IllegalStateException("Couch DB instance already has a database called " + databaseName);
        }
        connector = couchDbInstance.createConnector(databaseName, true);

        final String[] columnNames = new String[] { "name", "gender", "age" };
        final ColumnType[] columnTypes = new ColumnType[] { ColumnType.STRING, ColumnType.CHAR,
                ColumnType.INTEGER };
        predefinedTableDef = new SimpleTableDef(databaseName, columnNames, columnTypes);
    }

}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
@BeforeClass
public static void beforeClass() throws MalformedURLException {
    roomOwner = "testOwner";
    HttpClient httpClient = new StdHttpClient.Builder()
            .url("http://127.0.0.1:5984/")
            .build();
    dbi = new StdCouchDbInstance(httpClient);
    CouchDbConnector dbc = dbi.createConnector(CouchInjector.DB_NAME, false);

    repo = new MapRepository();
    repo.db = dbc;
    repo.postConstruct();
    debugWriter = repo.sites.mapper.writerWithDefaultPrettyPrinter();
    swapRoomsAccessPolicy = new AccessCertainResourcesPolicy(Collections.singleton(SiteSwapPermission.class));
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
private CouchDbConnector initConnection() throws MalformedURLException, ProxyInitilizedFailedException {
	
   	String username = ConfigManager.get("couchdbUsername");
   	String password = ConfigManager.get("couchdbPassword");
   	String host = ConfigManager.get("couchdbHost");
   	int port = ConfigManager.getInt("couchdbPort");
   	int timeout = ConfigManager.getInt("couchdbTimeout");
   	boolean enableSSL =  ConfigManager.getBoolean("couchdbEnableSSL", false);
   	String dbName = ConfigManager.get("couchdbDBName");
   
	Builder builder = new StdHttpClient.Builder();
	builder = builder
			.host(host)
			.port(port)
			.connectionTimeout(timeout)
			.enableSSL(enableSSL);

	if (username != null && !username.isEmpty() && password != null && !password.isEmpty() ) {
    	builder = builder.username(username).password(password);
	}
	
	CouchDbInstance dbInstance = new StdCouchDbInstance(builder.build());

       if (!dbInstance.checkIfDbExists(dbName))
       	dbInstance.createDatabase(dbName);
       CouchDbConnector couchDB = dbInstance.createConnector(dbName, true);  
	
	return couchDB;
	
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
static void setup()
{
  StdHttpClient.Builder builder = new StdHttpClient.Builder();
  HttpClient httpClient = builder.build();
  StdCouchDbInstance instance = new StdCouchDbInstance(httpClient);
  DbPath dbPath = new DbPath(TEST_DB);
  if (instance.checkIfDbExists((dbPath))) {
    instance.deleteDatabase(dbPath.getPath());
  }
  connector = instance.createConnector(TEST_DB, true);
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
static void teardown()
{
  StdHttpClient.Builder builder = new StdHttpClient.Builder();
  HttpClient httpClient = builder.build();
  StdCouchDbInstance instance = new StdCouchDbInstance(httpClient);
  DbPath dbPath = new DbPath(TEST_DB);
  if (instance.checkIfDbExists((dbPath))) {
    instance.deleteDatabase(dbPath.getPath());
  }
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
/**
 * Inits the.
 */

@PostConstruct
public void init() {

  LOGGER.trace("Initializing version: " + WifKeys.WIF_KEY_VERSION);
  // TODO do it more elegant,enable the rewriting of reviews, only for
  // development
  System.setProperty("org.ektorp.support.AutoUpdateViewOnChange", "true");
  repoURL = couchDBConfig.getRepoURL();
  wifDB = couchDBConfig.getWifDB();
  loginRequired = couchDBConfig.isLoginRequired();
  LOGGER.info("Using CouchDB URL {}, with What If database: {} ", repoURL,
      wifDB);
  try {
    if (loginRequired) {

      LOGGER.info("using the login name {} ", couchDBConfig.getLogin());
      httpClient = new StdHttpClient.Builder().url(repoURL)
          .username(couchDBConfig.getLogin())
          .password(couchDBConfig.getPassword()).build();
    } else {
      LOGGER.info("authentication not required, not using credentials");
      httpClient = new StdHttpClient.Builder().url(repoURL).build();
    }
  } catch (MalformedURLException e) {
    LOGGER.error(
        "MalformedURLException: Using CouchDB URL {} , with What If database: {} "
            + repoURL, wifDB);
  }

  CouchDbInstance dbInstance = new StdCouchDbInstance(httpClient);
  // TODO There should be one for each repository
  db = new StdCouchDbConnector(wifDB, dbInstance);

}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
public UpdateableDataContext getDB(String user, String password) throws Exception {
	HttpClient httpClient = new StdHttpClient.Builder().host(getHostname()).password(password).username(user).maxConnections(4).build();
	StdCouchDbInstance couchDbInstance = new StdCouchDbInstance(httpClient);
	
	UpdateableDataContext dataContext = new CouchDbDataContext(couchDbInstance);
	return dataContext;
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
@Override
public CouchDbInstance create(CloudantServiceInfo serviceInfo,
        ServiceConnectorConfig serviceConnectorConfig) {
    HttpClient httpClient;
    try {
        httpClient = new StdHttpClient.Builder()
                .url(serviceInfo.getUrl())
                .build();
        return new StdCouchDbInstance(httpClient);
    } catch (MalformedURLException e) {
        LOG.logp(Level.WARNING, CloudantInstanceCreator.class.getName(), "create", "Error parsing URL", e);
        return null;
    }
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
@PostConstruct
private void init() {
    HttpClient httpClient;
    httpClient = new StdHttpClient.Builder()
            .host("127.0.0.1")
            .port(5984)
            .username("admin")
            .password("password")
            .build();
    CouchDbInstance dbInstance = new StdCouchDbInstance(httpClient);
    couchDBConnector = dbInstance.createConnector("relax-dms", false);

    restTemplate = new RestTemplate(httpClient);
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
@Override
protected void configure() {
	try {
		CouchDbInstance couchDbInstance = new StdCouchDbInstance(new StdHttpClient.Builder()
				.url(couchDbConfig.getUrl())
				.username(couchDbConfig.getAdmin().getUsername())
				.password(couchDbConfig.getAdmin().getPassword())
				.maxConnections(couchDbConfig.getMaxConnections())
				.build());
		DbConnectorFactory connectorFactory = new DbConnectorFactory(couchDbInstance, couchDbConfig.getDbPrefix());

		CouchDbConnector dataSourceConnector = connectorFactory.createConnector(OdsRegistrationRepository.DATABASE_NAME, true);
		bind(CouchDbConnector.class).annotatedWith(Names.named(OdsRegistrationRepository.DATABASE_NAME)).toInstance(dataSourceConnector);

		CouchDbConnector clientConnector = connectorFactory.createConnector(ClientRepository.DATABASE_NAME, true);
		bind(CouchDbConnector.class).annotatedWith(Names.named(ClientRepository.DATABASE_NAME)).toInstance(clientConnector);

		CouchDbConnector eplAdapterConnector = connectorFactory.createConnector(EplAdapterRepository.DATABASE_NAME, true);
		bind(CouchDbConnector.class).annotatedWith(Names.named(EplAdapterRepository.DATABASE_NAME)).toInstance(eplAdapterConnector);
		
		CouchDbConnector userConnector = connectorFactory.createConnector(UserRepository.DATABASE_NAME, true);
		bind(CouchDbConnector.class).annotatedWith(Names.named(UserRepository.DATABASE_NAME)).toInstance(userConnector);

	} catch (MalformedURLException mue) {
		throw new RuntimeException(mue);
	}
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
public CouchDbConnector createConnector(String couchUrl, String dbName,
		int maxConnections, String username, String password) {
	HttpClient httpClient;

	try {
		StdHttpClient.Builder builder = new StdHttpClient.Builder().url(
				couchUrl).maxConnections(maxConnections);
		if (username != null) {
			builder.username(username);
		}
		if (password != null) {
			builder.password(password);
		}
		httpClient = builder.build();
	} catch (MalformedURLException e) {
		throw new IllegalStateException(e);
	}

	CouchDbInstance dbInstance = new StdCouchDbInstance(httpClient);
	StdCouchDbConnector connector = new StdCouchDbConnector(dbName,
			dbInstance) {
		final StreamingJsonSerializer customSerializer = new StreamingJsonSerializer(
				mapper);

		@Override
		protected String serializeToJson(Object o) {
			return customSerializer.toJson(o);
		}
	};

	return connector;
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
@Test
public void doTest() {
	Item item = new Item();
	item.setItemField("test" + System.currentTimeMillis());

	CouchDbInstance dbInstance = new StdCouchDbInstance(httpClient);
	db = new StdCouchDbConnector("mydatabase", dbInstance);
	db.createDatabaseIfNotExists();
	db.create(item);
	Assert.assertEquals(item.getItemField(), db.get(Item.class, item.getId()).getItemField());
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
/**
 * Initialize the data store by reading the credentials, setting the client's properties up and
 * reading the mapping file. Initialize is called when then the call to
 * {@link org.apache.gora.store.DataStoreFactory#createDataStore} is made.
 *
 * @param keyClass
 * @param persistentClass
 * @param properties
 */
@Override
public void initialize(Class<K> keyClass, Class<T> persistentClass, Properties properties) {
  LOG.debug("Initializing CouchDB store");
  super.initialize(keyClass, persistentClass, properties);

  final CouchDBParameters params = CouchDBParameters.load(properties);

  try {
    final String mappingFile = DataStoreFactory.getMappingFile(properties, this, DEFAULT_MAPPING_FILE);
    final HttpClient httpClient = new StdHttpClient.Builder()
        .url("http://" + params.getServer() + ":" + params.getPort())
        .build();

    dbInstance = new StdCouchDbInstance(httpClient);

    final CouchDBMappingBuilder<K, T> builder = new CouchDBMappingBuilder<>(this);
    LOG.debug("Initializing CouchDB store with mapping {}.", new Object[] { mappingFile });
    builder.readMapping(mappingFile);
    mapping = builder.build();

    final ObjectMapperFactory myObjectMapperFactory = new CouchDBObjectMapperFactory();
    myObjectMapperFactory.createObjectMapper().addMixInAnnotations(persistentClass, CouchDbDocument.class);

    db = new StdCouchDbConnector(mapping.getDatabaseName(), dbInstance, myObjectMapperFactory);
    db.createDatabaseIfNotExists();

  } catch (IOException e) {
    LOG.error("Error while initializing CouchDB store: {}", new Object[] { e.getMessage() });
    throw new RuntimeException(e);
  }
}
 

import org.ektorp.impl.StdCouchDbInstance; //导入依赖的package包/类
public void setProperties(String propertiesFile) throws IOException, CouchDbJobStoreException {
    Properties properties = new Properties();
    properties.load(ClassLoader.class.getResourceAsStream(propertiesFile));

    HttpClientFactoryBean httpClientFactoryBean = new HttpClientFactoryBean();
    httpClientFactoryBean.setProperties(extractHttpClientProperties(properties));
    httpClientFactoryBean.setCaching(false);
    try {
        httpClientFactoryBean.afterPropertiesSet();

        String dbNameGeneratorClass = properties.getProperty("db.nameGenerator");
        String dbName = properties.getProperty("db.name");

        DatabaseNameProvider dbNameGenerator;
        if (dbNameGeneratorClass == null || dbNameGeneratorClass.equals("")) {
            dbNameGenerator = new DefaultDatabaseNameProvider(dbName);
        } else {
            Class<?> aClass = Class.forName(dbNameGeneratorClass);
            dbNameGenerator = (DatabaseNameProvider) aClass.newInstance();
        }

        String databaseName = dbNameGenerator.getDatabaseName();
        if (databaseName == null || databaseName.equals("")) {
            databaseName = "scheduler";
        }
        CouchDbConnector connector = new StdCouchDbConnector(databaseName, new StdCouchDbInstance(httpClientFactoryBean.getObject()));
        this.jobStore = new CouchDbJobStore(connector);
        this.triggerStore = new CouchDbTriggerStore(connector);
        this.calendarStore = new CouchDbCalendarStore(connector);
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
        throw new CouchDbJobStoreException(e);
    }
}