Java WriteConcern.ACKNOWLEDGED属性代码示例

/**
 * Prepares {@link WriteConcern} from given {@link WriteConcernEnum}
 *
 * @param writeConcernEnum  write concern provided in config.
 * @return  write concern for mongo client option.
 */
public static WriteConcern writeConcern(WriteConcernEnum writeConcernEnum) {
    switch (writeConcernEnum) {
        case MAJORITY:
            return WriteConcern.MAJORITY;

        case JOURNALED:
            return WriteConcern.JOURNALED;

        case ACKNOWLEDGED:
            return WriteConcern.ACKNOWLEDGED;

        case UNACKNOWLEDGED:
            return WriteConcern.UNACKNOWLEDGED;

        default:
            return null;
    }
}
 

private WriteConcern determineWriteConcern(String label) {
    switch (label.toLowerCase()) {
        case "acknowledged":
            return WriteConcern.ACKNOWLEDGED;
        case "unacknowledged":
            return WriteConcern.UNACKNOWLEDGED;
        case "journaled":
            return WriteConcern.JOURNALED;
        case "majority":
            return WriteConcern.MAJORITY;
        default:
            return WriteConcern.ACKNOWLEDGED;
    }
}
 

public WriteConcern toWriteConcern(Object obj, WriteConcern defaultValue) {
	if(obj instanceof WriteConcern) return (WriteConcern) obj;
	if(decision.isSimpleValue(obj)) {
		String str = caster.toString(obj,"");
		str=str.trim().toUpperCase();
		if("ACKNOWLEDGED".equals(str))
			return WriteConcern.ACKNOWLEDGED;
		else if("ACKNOWLEDGED".equals(str))
			return WriteConcern.FSYNC_SAFE;
		else if("FSYNC_SAFE".equals(str) || "FSYNCSAFE".equals(str))
			return WriteConcern.FSYNCED;
		else if("JOURNAL_SAFE".equals(str) || "JOURNALSAFE".equals(str))
			return WriteConcern.JOURNAL_SAFE;
		else if("JOURNALED".equals(str))
			return WriteConcern.JOURNALED;
		else if("MAJORITY".equals(str))
			return WriteConcern.MAJORITY;
		else if("NORMAL".equals(str))
			return WriteConcern.NORMAL;
		else if("REPLICA_ACKNOWLEDGED".equals(str) || "REPLICAACKNOWLEDGED".equals(str))
			return WriteConcern.REPLICA_ACKNOWLEDGED;
		else if("REPLICAS_SAFE".equals(str) || "REPLICASSAFE".equals(str))
			return WriteConcern.REPLICAS_SAFE;
		else if("SAFE".equals(str))
			return WriteConcern.SAFE;
		else if("UNACKNOWLEDGED".equals(str))
			return WriteConcern.UNACKNOWLEDGED;
	}
	return defaultValue;
}
 

@Bean
public WriteConcernResolver writeConcernResolver() {
   return action -> {
      log.info("Using Write Concern of Acknowledged");
      return WriteConcern.ACKNOWLEDGED;
   };
}
 

@Before
public void setup() throws Exception {

    super.setup();

    // Cleanup stuff
    db.getCollection(COLL_NAME).drop();
    db.createCollection(COLL_NAME, null);

    ctx = new CRUDOperationContext(CRUDOperation.UPDATE, "test", factory, Collections.emptyList(), null) {
        @Override
        public EntityMetadata getEntityMetadata(String entityName) {
            return md;
        }
    };

    Updater updater = Updater.getInstance(nodeFactory, md,
            UpdateExpression.fromJson(JsonUtils.json("{'$set': { 'field1': 'changed-by-iterate-and-update'}}".replaceAll("'", "\""))));

    iterateAndUpdate = new TestIterateAndUpdate(
            nodeFactory,
            mock(ConstraintValidator.class),
            new FieldAccessRoleEvaluator(md, Collections.emptySet()),
            new DocTranslator(ctx, nodeFactory),
            updater, null, Projector.getInstance(MongoCRUDController.ID_PROJECTION, md), WriteConcern.ACKNOWLEDGED, 3,
            new DefaultConcurrentModificationDetectionCfg());
}
 

@Override
@Before
public void setup() throws Exception {
    super.setup();

    db.getCollection(COLL_NAME).drop();
    db.createCollection(COLL_NAME, null);
    coll=db.getCollection(COLL_NAME);
    updater=new UpdateIfSameProtocol(coll,WriteConcern.ACKNOWLEDGED);
}
 

@SuppressWarnings("deprecation")
private WriteConcern getWriteConcern(String writeConcern) {
	if ("ACKNOWLEDGED".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.ACKNOWLEDGED;
	}
	if ("W1".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.W1;
	}
	if ("W2".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.W2;
	}
	if ("W3".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.W3;
	}
	if ("UNACKNOWLEDGED".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.UNACKNOWLEDGED;
	}
	if ("FSYNCED".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.FSYNCED;
	}
	if ("REPLICA_ACKNOWLEDGED".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.REPLICA_ACKNOWLEDGED;
	}
	if ("NORMAL".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.NORMAL;
	}
	if ("SAFE".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.SAFE;
	}
	if ("MAJORITY".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.MAJORITY;
	}
	if ("FSYNC_SAFE".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.FSYNC_SAFE;
	}
	if ("JOURNAL_SAFE".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.JOURNAL_SAFE;
	}
	if ("REPLICAS_SAFE".equalsIgnoreCase(writeConcern)) {
		return WriteConcern.REPLICAS_SAFE;
	}
	return WriteConcern.ACKNOWLEDGED;
}
 

private void loadConfiguration()
    throws UnknownHostException
{
    configuration.refresh();
    MongoDBEntityStoreConfiguration config = configuration.get();

    // Combine hostname, port and nodes configuration properties
    // If no configuration, use 127.0.0.1:27017
    serverAddresses = new ArrayList<>();
    int port = config.port().get() == null ? 27017 : config.port().get();
    List<String> nodes = config.nodes().get();
    if( nodes.isEmpty() )
    {
        String hostname = config.hostname().get() == null ? "127.0.0.1" : config.hostname().get();
        serverAddresses.add( new ServerAddress( hostname, port ) );
    }
    else
    {
        if( config.hostname().get() != null && !config.hostname().get().isEmpty() )
        {
            serverAddresses.add( new ServerAddress( config.hostname().get(), port ) );
        }
        serverAddresses.addAll( nodes.stream()
                                     .map( this::parseNode )
                                     .collect( toList() )
                              );
    }

    // If database name not configured, set it to polygene:entitystore
    databaseName = config.database().get();
    if( databaseName == null )
    {
        databaseName = DEFAULT_DATABASE_NAME;
    }

    // If collection name not configured, set it to polygene:entitystore:entities
    collectionName = config.collection().get();
    if( collectionName == null )
    {
        collectionName = DEFAULT_COLLECTION_NAME;
    }

    // If write concern not configured, set it to normal
    switch( config.writeConcern().get() )
    {
    case W1:
        writeConcern = WriteConcern.W1;
        break;
    case W2:
        writeConcern = WriteConcern.W2;
        break;
    case W3:
        writeConcern = WriteConcern.W3;
        break;
    case UNACKNOWLEDGED:
        writeConcern = WriteConcern.UNACKNOWLEDGED;
        break;
    case JOURNALED:
        writeConcern = WriteConcern.JOURNALED;
        break;
    case MAJORITY:
        writeConcern = WriteConcern.MAJORITY;
        break;
    case ACKNOWLEDGED:
    default:
        writeConcern = WriteConcern.ACKNOWLEDGED;
    }

    // Username and password are defaulted to empty strings
    username = config.username().get();
    password = config.password().get().toCharArray();
}