Java StdCouchDbInstance类代码示例

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);
}