Java Transaction类代码示例

import org.geotools.data.Transaction; //导入依赖的package包/类
@Test
public void testFidFilterQuery() throws IllegalArgumentException, NoSuchElementException, IOException, CQLException {
    final String fidsString = fids.stream().collect(Collectors.joining("','", "'", "'"));
    final Filter filter = ECQL.toFilter("IN (" + fidsString + ")");
    final Query query = new Query(
            "GeoWaveFeatureReaderTest",
            filter,
            new String[] {
                "geometry",
                "pid"
            });
    final FeatureReader<SimpleFeatureType, SimpleFeature> reader =
        dataStore.getFeatureReader(query, Transaction.AUTO_COMMIT);
    int count = 0;
    while (reader.hasNext()) {
        final SimpleFeature feature = reader.next();
        assertTrue(fids.contains(feature.getID()));
        count++;
    }
    assertTrue(count == fids.size());
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
@Test
public void testPidFilterQuery() throws IllegalArgumentException, NoSuchElementException, IOException, CQLException {
    // Filter it so that it only queries for everything but the first pid.
    // There's only 2 pids total so it should just return the second one.
    final String pidsString = pids.subList(1, pids.size()).stream().collect(Collectors.joining("','", "'", "'"));
    final Filter filter = ECQL.toFilter("pid IN (" + pidsString + ")");
    final Query query = new Query(
            "GeoWaveFeatureReaderTest",
            filter,
            new String[] {
                "geometry",
                "pid"
            });
    final FeatureReader<SimpleFeatureType, SimpleFeature> reader =
        dataStore.getFeatureReader(query, Transaction.AUTO_COMMIT);
    int count = 0;
    while (reader.hasNext()) {
        final SimpleFeature feature = reader.next();
        assertTrue(fids.contains(feature.getID()));
        count++;
    }
    assertTrue(count == pids.size() - 1);
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
@Test
public void testLike() throws IllegalArgumentException, NoSuchElementException, IOException, CQLException {
    final Query query = new Query(
            "GeoWaveFeatureReaderTest",
            ECQL.toFilter("pid like '" + pids.get(
                    0).substring(
                    0,
                    1) + "%'"),
            new String[] {
                "geometry",
                "pid"
            });
    final FeatureReader<SimpleFeatureType, SimpleFeature> reader =
        dataStore.getFeatureReader(query, Transaction.AUTO_COMMIT);
    int count = 0;
    while (reader.hasNext()) {
        final SimpleFeature feature = reader.next();
        assertTrue(fids.contains(feature.getID()));
        count++;
    }
    assertEquals(1, count);
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
/**
 * Add a feature to the store.
 * 
 * @param feature the feature to add.
 */
default public void addFeature( SimpleFeature feature) {
    FeatureStoreInfo featureStoreInfo = getFeatureStoreInfo();
    SimpleFeatureStore featureStore = featureStoreInfo.getFeatureStore();
    if (featureStore != null) {
        Transaction transaction = new DefaultTransaction("add");
        featureStore.setTransaction(transaction);
        
        try {
            DefaultFeatureCollection fc = new DefaultFeatureCollection();
            fc.add(feature);
            featureStore.addFeatures(fc);
            transaction.commit();
        } catch (Exception eek) {
            try {
                transaction.rollback();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
private void makeLineLayer( IEpanetType[] types, File baseFolder, CoordinateReferenceSystem mapCrs )
        throws MalformedURLException, IOException {
    SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
    String shapefileName = types[0].getShapefileName();
    String typeName = types[0].getName();
    b.setName(typeName);
    b.setCRS(mapCrs);
    b.add("the_geom", LineString.class);
    for( IEpanetType type : types ) {
        b.add(type.getAttributeName(), type.getClazz());
    }
    SimpleFeatureType tanksType = b.buildFeatureType();
    ShapefileDataStoreFactory factory = new ShapefileDataStoreFactory();
    File file = new File(baseFolder, shapefileName);
    Map<String, Serializable> create = new HashMap<String, Serializable>();
    create.put("url", file.toURI().toURL());
    ShapefileDataStore newDataStore = (ShapefileDataStore) factory.createNewDataStore(create);
    newDataStore.createSchema(tanksType);
    Transaction transaction = new DefaultTransaction();
    SimpleFeatureStore featureStore = (SimpleFeatureStore) newDataStore.getFeatureSource();
    featureStore.setTransaction(transaction);
    try {
        featureStore.addFeatures(new DefaultFeatureCollection());
        transaction.commit();
    } catch (Exception problem) {
        problem.printStackTrace();
        transaction.rollback();
    } finally {
        transaction.close();
    }
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
private void writeShapefile(MemoryDataStore memoryDataStore, File outputFile) throws Exception {

		SimpleFeatureSource featureSource = memoryDataStore.getFeatureSource(memoryDataStore.getTypeNames()[0]);
		SimpleFeatureType featureType = featureSource.getSchema();

		Map<String, java.io.Serializable> creationParams = new HashMap<String, java.io.Serializable>();
		creationParams.put("url", DataUtilities.fileToURL(outputFile));

		ShapefileDataStoreFactory factory = (ShapefileDataStoreFactory) FileDataStoreFinder.getDataStoreFactory("shp");
		ShapefileDataStore dataStore = (ShapefileDataStore) factory.createNewDataStore(creationParams);
		dataStore.setCharset(Charset.forName("UTF-8"));
		dataStore.createSchema(featureType);

		SimpleFeatureStore featureStore = (SimpleFeatureStore) dataStore.getFeatureSource(dataStore.getTypeNames()[0]);

		Transaction transaction = new DefaultTransaction();
		try {
			SimpleFeatureCollection collection = featureSource.getFeatures();
			featureStore.addFeatures(collection);
			transaction.commit();
		} catch (IOException e) {
			try {
				transaction.rollback();
				throw new Exception("Failed to commit data to feature store", e);
			} catch (IOException e2 ) {
				logger.error("Failed to commit data to feature store", e);
				throw new Exception("Transaction rollback failed", e2);
			}
		} finally {
			transaction.close();
		}
	}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
private static void example3() throws IOException {
    System.out.println("example3 start\n");
    // example3 start
    Map<String, Serializable> params = new HashMap<String, Serializable>();
    params.put("directory", directory);
    DataStore datastore = DataStoreFinder.getDataStore(params);

    Query query = new Query("example");
    FeatureReader<SimpleFeatureType, SimpleFeature> reader = datastore
            .getFeatureReader(query, Transaction.AUTO_COMMIT);
    try {
        int count = 0;
        while (reader.hasNext()) {
            SimpleFeature feature = reader.next();
            System.out.println("feature " + count + ": " + feature.getID());
            count++;
        }
        System.out.println("read in " + count + " features");
    } finally {
        reader.close();
    }
    // example3 end
    System.out.println("\nexample3 end\n");
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
public static void main(String[] args) throws MalformedURLException,
		IOException, NoSuchAuthorityCodeException, FactoryException {
	if (args.length < 3) {
		System.err.println("Usage: ReprojectShapeFile in.shp out.shp epsg:code");
		System.exit(3);
	}
	File in = new File(args[0]);
	File out = new File(args[1]);
	CoordinateReferenceSystem crs = CRS.decode(args[2]);

	ShapefileDataStoreFactory fac = new ShapefileDataStoreFactory();
	FileDataStore inStore = fac.createDataStore(in.toURI().toURL());
	FileDataStore outStore = fac.createDataStore(out.toURI().toURL());

	SimpleFeatureCollection inFeatures = inStore.getFeatureSource()
			.getFeatures();

	ReprojectShapeFile reprojector = new ReprojectShapeFile();

	SimpleFeatureCollection outFeatures = reprojector
			.reproject(inFeatures, crs);
	outStore.createSchema(outFeatures.getSchema());
	Transaction transaction = new DefaultTransaction("create");
	String outName = outStore.getNames().get(0).getLocalPart();
	SimpleFeatureSource featureSource = outStore.getFeatureSource(outName);
	FeatureStore featureStore = (FeatureStore) featureSource;
	featureStore.setTransaction(transaction);
	featureStore.addFeatures(outFeatures);
	transaction.commit();
	outStore.dispose();
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
/**
 * Record a modification to the indicated fid
 * 
 * @param fid
 * @param original
 *            the original feature(prior state)
 * @param updated
 *            the update feature replacement feature; null to indicate
 *            remove
 */
public void modify(
		String fid,
		SimpleFeature original,
		SimpleFeature updated )
		throws IOException {
	// point move?
	if (!updated.getBounds().equals(
			original.getBounds())) {
		this.components.remove(
				original,
				this);
		this.components.writeCommit(
				updated,
				new GeoWaveEmptyTransaction(
						components));
	}
	else {
		this.components.writeCommit(
				updated,
				new GeoWaveEmptyTransaction(
						components));
	}

	ReferencedEnvelope bounds = new ReferencedEnvelope();
	bounds.include(updated.getBounds());
	bounds.include(original.getBounds());
	this.components.getGTstore().getListenerManager().fireFeaturesChanged(
			updated.getFeatureType().getTypeName(),
			Transaction.AUTO_COMMIT,
			bounds,
			true);

}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
@Override
public synchronized void setTransaction(
		final Transaction transaction ) {
	if (transaction != null) {
		// configure
		this.transaction = transaction;
	}
	else {
		this.transaction = null;

		if (typeNameDiff != null) {
			for (final Iterator<GeoWaveTransactionManagement> i = typeNameDiff.values().iterator(); i.hasNext();) {
				final GeoWaveTransactionManagement diff = i.next();
				diff.clear();
			}

			typeNameDiff.clear();
		}
	}
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
/**
 * Create an empty Diff
 * 
 * @throws IOException
 */
public GeoWaveTransactionManagement(
		final int maxAdditionBufferSize,
		final GeoWaveDataStoreComponents components,
		final String typeName,
		final Transaction transaction,
		final LockingManagement lockingManager,
		final String txID )
		throws IOException {
	super(
			components);
	this.maxAdditionBufferSize = maxAdditionBufferSize;
	mutex = this;
	this.typeName = typeName;
	this.transaction = transaction;
	this.lockingManager = lockingManager;
	this.txID = txID;
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
private void unlock(
		Transaction transaction,
		String featureID,
		Set<String> authorizations,
		long expiryInMinutes ) {
	AuthorizedLock lock = transaction == Transaction.AUTO_COMMIT ? null : (AuthorizedLock) transaction
			.getState(this);
	if (lock == null) {
		lock = new AuthorizedLock(
				this,
				authorizations,
				expiryInMinutes);
		if (transaction != Transaction.AUTO_COMMIT) transaction.putState(
				this,
				lock);
	}
	unlock(
			lock,
			featureID);
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
@Test
public void testFID()
		throws IllegalArgumentException,
		NoSuchElementException,
		IOException,
		CQLException {
	final FeatureReader<SimpleFeatureType, SimpleFeature> reader = dataStore.getFeatureReader(
			query,
			Transaction.AUTO_COMMIT);
	int count = 0;
	while (reader.hasNext()) {
		final SimpleFeature feature = reader.next();
		assertTrue(fids.contains(feature.getID()));
		count++;
	}
	assertTrue(count > 0);
}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
@Test
public void testRangeIndex()
		throws IllegalArgumentException,
		NoSuchElementException,
		IOException {
	final FeatureReader<SimpleFeatureType, SimpleFeature> reader = dataStore.getFeatureReader(
			query,
			Transaction.AUTO_COMMIT);
	int count = 0;
	while (reader.hasNext()) {
		final SimpleFeature feature = reader.next();
		assertTrue(fids.contains(feature.getID()));
		count++;
	}
	assertEquals(
			1,
			count);

}
 

import org.geotools.data.Transaction; //导入依赖的package包/类
@Test
public void testMax()
		throws IllegalArgumentException,
		NoSuchElementException,
		IOException {
	final FeatureReader<SimpleFeatureType, SimpleFeature> reader = dataStore.getFeatureReader(
			query,
			Transaction.AUTO_COMMIT);
	final MaxVisitor visitor = new MaxVisitor(
			"start",
			type);
	unwrapDelegatingFeatureReader(
			reader).getFeatureCollection().accepts(
			visitor,
			null);
	assertTrue(visitor.getMax().equals(
			etime));

}