import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
private void addFeatureIdExample(SimpleFeatureCollection collection ) throws Exception {
    // addFeatureIdExample start
    Transaction transaction = new DefaultTransaction("Add Example");
    SimpleFeatureStore store = (SimpleFeatureStore) dataStore.getFeatureSource(typeName);
    store.setTransaction(transaction);
    try {
        List<FeatureId> added = store.addFeatures( collection );
        System.out.println( added ); // prints out the temporary feature ids
        
        transaction.commit();
        System.out.println( added ); // prints out the final feature ids
        
        Set<FeatureId> selection = new HashSet<FeatureId>( added );
        FilterFactory ff = CommonFactoryFinder.getFilterFactory();
        Filter selected = ff.id( selection ); // filter selecting all the features just added
    }
    catch( Exception problem){
        transaction.rollback();
        throw problem;
    }
    // addFeatureIdExample end
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
private void removeExample2() throws Exception {
    // removeExample2 start
    Transaction transaction = new DefaultTransaction("removeExample");
    SimpleFeatureStore store = (SimpleFeatureStore) dataStore.getFeatureSource(typeName);
    store.setTransaction(transaction);
    
    FilterFactory ff = CommonFactoryFinder.getFilterFactory(GeoTools.getDefaultHints());
    Filter filter = ff.id(Collections.singleton(ff.featureId("fred")));
    try {
        final Set<FeatureId> removed = new HashSet<FeatureId>();
        SimpleFeatureCollection collection = store.getFeatures( new Query( typeName, filter, Query.NO_NAMES ));
        collection.accepts( new FeatureVisitor(){
            public void visit(Feature feature) {
                removed.add( feature.getIdentifier() );
            }
        }, null );
        store.removeFeatures(filter);
        transaction.commit();
    } catch (Exception eek) {
        transaction.rollback();
    }
    // removeExample2 end
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
/**
 * Create a Style where features with given IDs are painted
 * yellow, while others are painted with the default colors.
 */
private Style createSelectedStyle(Set<FeatureId> IDs) {
    Rule selectedRule = createRule(SELECTED_COLOUR, SELECTED_COLOUR);
    selectedRule.setFilter(ff.id(IDs));

    Rule otherRule = createRule(LINE_COLOUR, FILL_COLOUR);
    otherRule.setElseFilter(true);

    FeatureTypeStyle fts = sf.createFeatureTypeStyle();
    fts.rules().add(selectedRule);
    fts.rules().add(otherRule);

    Style style = sf.createStyle();
    style.featureTypeStyles().add(fts);
    return style;
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
/**
 * Delete all the features we have with this prefix
 * This prefix is empty on the server.
 *
 * @param position
 */
private void deleteInPosition(Sha1SyncPositionHash position) {
    Sha1Value prefix = new Sha1Value(position.position());
    HashAndFeatureValue find = new HashAndFeatureValue(prefix, null, null);
    // TODO, hmm, better search?
    int i = Collections.binarySearch(m_featureSha1s, find, new IdAndValueSha1Comparator(versionFeatures));
    if (i < 0) {
        i = -i - 1;
    }
    for ( ; i < m_featureSha1s.size(); i++) {
        HashAndFeatureValue value = m_featureSha1s.get(i);
        if (!versionFeatures.getBucketPrefixSha1(value).isPrefixMatch(prefix.get())) {
            break;
        }
        FeatureId fid = value.getFeature().getIdentifier();
        m_potentialDeletes.add(fid);
    }

}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
/**
 * see interface for details.
 * @param fc
 *
 * @throws IOException
 */
public List<FeatureId> addFeatures(FeatureCollection<SimpleFeatureType, SimpleFeature> fc) throws IOException {
    FeatureStore<SimpleFeatureType, SimpleFeature> store = store();

    //check if the feature collection needs to be retyped
    if (!store.getSchema().equals(fc.getSchema())) {
        fc = new RetypingFeatureCollection(DataUtilities.simple(fc), store.getSchema());
    }

    return store().addFeatures(fc);
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
private Style createSelectedStyle(FeatureId ids) {
    Rule selectedRule = createRule(SELECTED_COLOUR, SELECTED_COLOUR);
    selectedRule.setFilter(ff.id(ids));

    Rule otherRule = createRule(OUTLINE_COLOR, FILL_COLOR);
    otherRule.setElseFilter(true);

    FeatureTypeStyle fts = sf.createFeatureTypeStyle();
    fts.rules().add(selectedRule);
    fts.rules().add(otherRule);

    Style style = sf.createStyle();
    style.featureTypeStyles().add(fts);
    return style;
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
@Test
public void testGetFeaturesWithIdFilter() throws Exception {
    init();
    FilterFactory ff = dataStore.getFilterFactory();
    Id id = ff.id(new HashSet<FeatureId>(Arrays.asList(ff.featureId("01"),
            ff.featureId("07"))));
    SimpleFeatureCollection features = featureSource.getFeatures(id);
    assertEquals(2, features.size());
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
public void idSet(){
    // idSet start
    FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    Filter filter;
    
    Set<FeatureId> selected = new HashSet<FeatureId>();
    selected.add(ff.featureId("CITY.98734597823459687235"));
    selected.add(ff.featureId("CITY.98734592345235823474"));
    
    filter = ff.id(selected);
    // idSet end
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
/**
 * How to find Features using IDs?
 * 
 * Each Feature has a FeatureID; you can use these FeatureIDs to request the feature again later.
 * 
 * If you have a Set<String> of feature IDs, which you would like to query from a shapefile:
 * 
 * @param selection
 *            Set of FeatureIDs identifying requested content
 * @return Selected Features
 * @throws IOException
 */
// grabSelectedIds start
SimpleFeatureCollection grabSelectedIds(Set<String> selection) throws IOException {
    FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    
    Set<FeatureId> fids = new HashSet<FeatureId>();
    for (String id : selection) {
        FeatureId fid = ff.featureId(id);
        fids.add(fid);
    }
    Filter filter = ff.id(fids);
    return featureSource.getFeatures(filter);
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
private void addFeaturesEvents(SimpleFeatureCollection collection ) throws Exception {
    // addEvents start
    Transaction transaction = new DefaultTransaction("Add Example");
    SimpleFeatureStore store = (SimpleFeatureStore) dataStore.getFeatureSource(typeName);
    store.setTransaction(transaction);

    class CommitListener implements FeatureListener {
        public void changed(FeatureEvent featureEvent) {
            if (featureEvent instanceof BatchFeatureEvent ){
                BatchFeatureEvent batchEvent = (BatchFeatureEvent) featureEvent;
                
                System.out.println( "area changed:" + batchEvent.getBounds() );
                System.out.println( "created fids:" + batchEvent.fids );
            }
            else {
                System.out.println( "bounds:" + featureEvent.getBounds() );
                System.out.println( "change:" + featureEvent.filter );
            }
        }
    }
    CommitListener listener = new CommitListener();
    store.addFeatureListener( listener );
    try {
        List<FeatureId> added = store.addFeatures( collection );
        transaction.commit();
    }
    catch( Exception problem){
        transaction.rollback();
        throw problem;
    }
    // addEvents end
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
private static void example4() throws IOException {
    System.out.println("example4 start\n");
    // example4 start
    Map<String, Serializable> params = new HashMap<String, Serializable>();
    params.put("directory", directory);
    DataStore store = DataStoreFinder.getDataStore(params);

    FilterFactory ff = CommonFactoryFinder.getFilterFactory();

    Set<FeatureId> selection = new HashSet<FeatureId>();
    selection.add(ff.featureId("fid1"));

    Filter filter = ff.id(selection);
    Query query = new Query("example", filter);

    FeatureReader<SimpleFeatureType, SimpleFeature> reader = store
            .getFeatureReader(query, Transaction.AUTO_COMMIT);

    try {
        while (reader.hasNext()) {
            SimpleFeature feature = reader.next();
            System.out.println("feature " + feature.getID());

            for (Property property : feature.getProperties()) {
                System.out.print("\t");
                System.out.print(property.getName());
                System.out.print(" = ");
                System.out.println(property.getValue());
            }
        }
    } finally {
        reader.close();
    }
    // example4 end
    System.out.println("\nexample4 end\n");
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
/**
 * Sets the display to paint selected features yellow and
 * unselected features in the default style.
 *
 * @param IDs identifiers of currently selected features
 */
public void displaySelectedFeatures(Set<FeatureId> IDs) {
    Style style;

    if (IDs.isEmpty()) {
        style = createDefaultStyle();

    } else {
        style = createSelectedStyle(IDs);
    }

    Layer layer = mapFrame.getMapContent().layers().get(0);
    ((FeatureLayer) layer).setStyle(style);
    mapFrame.getMapPane().repaint();
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
void processGmlResponse(Response response) throws IOException, SAXException, ParserConfigurationException {
    FeatureCollection<?, ?> features;
    if (response instanceof ResponseFeatureCollection) {
        ResponseFeatureCollection responseFeatures = (ResponseFeatureCollection) response;
        features = responseFeatures.getFeatureCollection();
    } else {
        CountingInputStream counter = new CountingInputStream(response.getResultStream());
        long s = System.currentTimeMillis();
        features = (FeatureCollection<?, ?>) parseWfs(counter);
        long e = System.currentTimeMillis();
        m_parseMillis = e - s;
        m_rxGml += counter.getByteCount();
    }

    FeatureIterator<?> it = features.features();
    try {
        while (it.hasNext()) {
            Feature feature = it.next();
            FeatureId fid = feature.getIdentifier();
            m_potentialDeletes.remove(fid);
            if (!m_features.containsKey(fid)) {
                m_listener.featureCreate(fid, feature);
                m_numCreates++;
            } else {
                m_listener.featureUpdate(fid, feature);
                m_numUpdates++;
            }
        }
    } finally {
        it.close();
    }
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
private Feature byFid(Map<Identifier, FeatureAccessor> clientMap, FeatureId fid) {
	FeatureAccessor featureAccessor = clientMap.get(fid);
	if (featureAccessor == null) {
		return null;
	}
	return featureAccessor.getFeature();
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
@Override
public SimpleFeature getRetypedSimpleFeature(
		SimpleFeatureBuilder builder,
		SimpleFeature original ) {

	final SimpleFeatureType target = builder.getFeatureType();
	for (int i = 0; i < target.getAttributeCount(); i++) {
		final AttributeDescriptor attributeType = target.getDescriptor(i);
		Object value = null;

		if (original.getFeatureType().getDescriptor(
				attributeType.getName()) != null) {
			final Name name = attributeType.getName();
			value = retypeAttributeValue(
					original.getAttribute(name),
					name);
		}

		builder.add(value);
	}
	String featureId = getFeatureId(original);
	if (featureId == null) {
		// a null ID will default to use the original
		final FeatureId id = RetypingFeatureCollection.reTypeId(
				original.getIdentifier(),
				original.getFeatureType(),
				target);
		featureId = id.getID();
	}
	final SimpleFeature retyped = builder.buildFeature(featureId);
	retyped.getUserData().putAll(
			original.getUserData());
	return retyped;
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
@Override
@Transactional(rollbackFor = { Throwable.class })
public Object create(Object feature) throws LayerException {
	SimpleFeatureSource source = getFeatureSource();
	if (source instanceof SimpleFeatureStore) {
		SimpleFeatureStore store = (SimpleFeatureStore) source;
		DefaultFeatureCollection collection = new DefaultFeatureCollection();
		collection.add((SimpleFeature) feature);
		transactionSynchronization.synchTransaction(store);
		try {
			List<FeatureId> ids = store.addFeatures(collection);
			// fetch it again to get the generated values !!!
			if (ids.size() == 1) {
				return read(ids.get(0).getID());
			}
		} catch (IOException ioe) {
			featureModelUsable = false;
			throw new LayerException(ioe, ExceptionCode.LAYER_MODEL_IO_EXCEPTION);
		}
		return feature;
	} else {
		log.error("Don't know how to create or update " + getFeatureSourceName() + ", class "
				+ source.getClass().getName() + " does not implement SimpleFeatureStore");
		throw new LayerException(ExceptionCode.CREATE_OR_UPDATE_NOT_IMPLEMENTED, getFeatureSourceName(), source
				.getClass().getName());
	}
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
/**
 * This method is called by our feature selection tool when
 * the user has clicked on the map.
 *
 * @param pos map (world) coordinates of the mouse cursor
 */
void selectFeatures(MapMouseEvent ev) {

    System.out.println("Mouse click at: " + ev.getMapPosition());

    /*
     * Construct a 5x5 pixel rectangle centred on the mouse click position
     */
    Point screenPos = ev.getPoint();
    Rectangle screenRect = new Rectangle(screenPos.x-2, screenPos.y-2, 5, 5);
    
    /*
     * Transform the screen rectangle into bounding box in the coordinate
     * reference system of our map context. Note: we are using a naive method
     * here but GeoTools also offers other, more accurate methods.
     */
    AffineTransform screenToWorld = mapFrame.getMapPane().getScreenToWorldTransform();
    Rectangle2D worldRect = screenToWorld.createTransformedShape(screenRect).getBounds2D();
    ReferencedEnvelope bbox = new ReferencedEnvelope(
            worldRect,
            mapFrame.getMapContent().getCoordinateReferenceSystem());

    /*
     * Create a Filter to select features that intersect with
     * the bounding box
     */
    Filter filter = ff.intersects(ff.property(geometryAttributeName), ff.literal(bbox));

    /*
     * Use the filter to identify the selected features
     */
    try {
        SimpleFeatureCollection selectedFeatures =
                featureSource.getFeatures(filter);

        SimpleFeatureIterator iter = selectedFeatures.features();
        Set<FeatureId> IDs = new HashSet<FeatureId>();
        try {
            while (iter.hasNext()) {
                SimpleFeature feature = iter.next();
                IDs.add(feature.getIdentifier());

                System.out.println("   " + feature.getIdentifier());
            }

        } finally {
            iter.close();
        }

        if (IDs.isEmpty()) {
            System.out.println("   no feature selected");
        }

        displaySelectedFeatures(IDs);

    } catch (Exception ex) {
        ex.printStackTrace();
        return;
    }
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
public FeatureId getIdentifier() {
	return simpleFeature.getIdentifier();
}
 

import org.opengis.filter.identity.FeatureId; //导入依赖的package包/类
/** Not Implemented Use getID() */
public FeatureId getIdentifier() {return null;}