import org.geotools.feature.SchemaException; //导入依赖的package包/类
static SimpleFeatureType createSimpleFeatureType(String simpleFeatureTypeName)
        throws SchemaException {

    // list the attributes that constitute the feature type
    List<String> attributes = Lists.newArrayList(
            "Who:String:index=full",
            "What:java.lang.Long",     // some types require full qualification (see DataUtilities docs)
            "When:Date",               // a date-time field is optional, but can be indexed
            "*Where:Point:srid=4326",  // the "*" denotes the default geometry (used for indexing)
            "Why:String"               // you may have as many other attributes as you like...
    );

    // create the bare simple-feature type
    String simpleFeatureTypeSchema = Joiner.on(",").join(attributes);
    SimpleFeatureType simpleFeatureType =
            SimpleFeatureTypes.createType(simpleFeatureTypeName, simpleFeatureTypeSchema);

    return simpleFeatureType;
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
static SimpleFeatureType createSimpleFeatureType(String simpleFeatureTypeName)
        throws SchemaException {

    // list the attributes that constitute the feature type
    List<String> attributes = Lists.newArrayList(
            "Who:String:index=full",
            "What:java.lang.Long",     // some types require full qualification (see DataUtilities docs)
            "When:Date",               // a date-time field is optional, but can be indexed
            "*Where:Point:srid=4326",  // the "*" denotes the default geometry (used for indexing)
            "Why:String",              // you may have as many other attributes as you like...
            "Visibility:String"
    );

    // create the bare simple-feature type
    String simpleFeatureTypeSchema = Joiner.on(",").join(attributes);
    SimpleFeatureType simpleFeatureType =
            SimpleFeatureTypes.createType(simpleFeatureTypeName, simpleFeatureTypeSchema);

    // use the user-data (hints) to specify which date-time field is meant to be indexed;
    // if you skip this step, your data will still be stored, it simply won't be indexed
    simpleFeatureType.getUserData().put(SimpleFeatureTypes.DEFAULT_DATE_KEY, "When");

    return simpleFeatureType;
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
/**
 * Builds the feature type for the GDELT data set
 *
 * @param featureName
 * @return
 * @throws SchemaException
 */
public static SimpleFeatureType buildGdeltFeatureType(String featureName) throws SchemaException {

    List<String> attributes = new ArrayList<String>();
    for (Attributes attribute : Attributes.values()) {
        if (attribute == Attributes.geom) {
            // set geom to be the default geometry for geomesa by adding a *
            attributes.add("*geom:Point:srid=4326");
        } else {
            attributes.add(attribute.name() + ":" + attribute.getType());
        }
    }

    String spec = Joiner.on(",").join(attributes);

    SimpleFeatureType featureType = DataUtilities.createType(featureName, spec);
    //This tells GeoMesa to use this Attribute as the Start Time index
    featureType.getUserData().put(SimpleFeatureTypes.DEFAULT_DATE_KEY, Attributes.SQLDATE.name());
    return featureType;
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
static SimpleFeatureType createSimpleFeatureType(String simpleFeatureTypeName)
        throws SchemaException {

    // list the attributes that constitute the feature type
    List<String> attributes = Lists.newArrayList(
            "Who:String:index=full",
            "What:java.lang.Long",     // some types require full qualification (see DataUtilities docs)
            "When:Date",               // a date-time field is optional, but can be indexed
            "*Where:Point:srid=4326",  // the "*" denotes the default geometry (used for indexing)
            "Why:String"               // you may have as many other attributes as you like...
    );

    // create the bare simple-feature type
    String simpleFeatureTypeSchema = Joiner.on(",").join(attributes);
    SimpleFeatureType simpleFeatureType =
            SimpleFeatureTypes.createType(simpleFeatureTypeName, simpleFeatureTypeSchema);

    // use the user-data (hints) to specify which date-time field is meant to be indexed;
    // if you skip this step, your data will still be stored, it simply won't be indexed
    simpleFeatureType.getUserData().put(SimpleFeatureTypes.DEFAULT_DATE_KEY, "When");

    return simpleFeatureType;
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
static SimpleFeatureType createSimpleFeatureType(String simpleFeatureTypeName)
        throws SchemaException {

    // list the attributes that constitute the feature type
    List<String> attributes = Lists.newArrayList(
            "Who:String",
            "What:java.lang.Long",     // some types require full qualification (see DataUtilities docs)
            "When:Date",               // a date-time field is optional, but can be indexed
            "*Where:Point:srid=4326",  // the "*" denotes the default geometry (used for indexing)
            "Why:String"               // you may have as many other attributes as you like...
    );

    // create the bare simple-feature type
    String simpleFeatureTypeSchema = Joiner.on(",").join(attributes);
    SimpleFeatureType simpleFeatureType =
            DataUtilities.createType(simpleFeatureTypeName, simpleFeatureTypeSchema);

    return simpleFeatureType;
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
private static SimpleFeatureType getStatementFeatureType(final DataStore dataStore) throws IOException, SchemaException {
    SimpleFeatureType featureType;

    final String[] datastoreFeatures = dataStore.getTypeNames();
    if (Arrays.asList(datastoreFeatures).contains(FEATURE_NAME)) {
        featureType = dataStore.getSchema(FEATURE_NAME);
    } else {
        featureType = DataUtilities.createType(FEATURE_NAME,
            SUBJECT_ATTRIBUTE + ":String," +
            PREDICATE_ATTRIBUTE + ":String," +
            OBJECT_ATTRIBUTE + ":String," +
            CONTEXT_ATTRIBUTE + ":String," +
            GEOMETRY_ATTRIBUTE + ":Geometry:srid=4326," +
            GEO_ID_ATTRIBUTE + ":String");

        dataStore.createSchema(featureType);
    }
    return featureType;
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
private void initInternal() throws IOException {
    validPredicates = ConfigUtils.getGeoPredicates(conf);

    final DataStore dataStore = createDataStore(conf);

    try {
        featureType = getStatementFeatureType(dataStore);
    } catch (final IOException | SchemaException e) {
        throw new IOException(e);
    }

    featureSource = dataStore.getFeatureSource(featureType.getName());
    if (!(featureSource instanceof FeatureStore)) {
        throw new IllegalStateException("Could not retrieve feature store");
    }
    featureStore = (FeatureStore<SimpleFeatureType, SimpleFeature>) featureSource;
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
private static SimpleFeatureType getStatementFeatureType(final DataStore dataStore) throws IOException, SchemaException {
    SimpleFeatureType featureType;

    final String[] datastoreFeatures = dataStore.getTypeNames();
    if (Arrays.asList(datastoreFeatures).contains(FEATURE_NAME)) {
        featureType = dataStore.getSchema(FEATURE_NAME);
    } else {
        final String featureSchema = SUBJECT_ATTRIBUTE + ":String," //
                + PREDICATE_ATTRIBUTE + ":String," //
                + OBJECT_ATTRIBUTE + ":String," //
                + CONTEXT_ATTRIBUTE + ":String," //
                + GEOMETRY_ATTRIBUTE + ":Geometry:srid=4326;geomesa.mixed.geometries='true'";
        featureType = SimpleFeatureTypes.createType(FEATURE_NAME, featureSchema);
        dataStore.createSchema(featureType);
    }
    return featureType;
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
private synchronized void initType() {
	if (featureType == null
			|| !featureType.getName().getLocalPart()
					.equals(dataStoreTypeName)) {
		try {
			featureType = DataUtilities
					.createType(
							dataStoreTypeName,
							"envelope:com.vividsolutions.jts.geom.Polygon,id:java.lang.Long,queryString:String,path:String,startTime:Date,"
									+ "endTime:Date,totalTime:java.lang.Long,BodyAsString:String,BodyContentLength:java.lang.Long,"
									+ "Host:String,ErrorMessage:String,HttpMethod:String,HttpReferer:String,InternalHost:String,"
									+ "Operation:String,OwsVersion:String,QueryString:String,RemoteAddr:String,RemoteCity:String,"
									+ "RemoteCountry:String,RemoteHost:String,RemoteLat:double,"
									+ "RemoteLon:double,RemoteUser:String,RemoteUserAgent:String,Resources:String,"
									+ "ResponseContentType:String,ResponseLength:java.lang.Long,ResponseStatus:int,"
									+ "Service:String,SubOperation:String,Status:String,Category:String");
		} catch (SchemaException e) {
			LOGGER.log(Level.SEVERE, "Failed to initialized feature type",
					e);
		}
	}
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
/**
 * Create a SimpleFeatureCollection with a Geometry
 * 
 * @param all
 * @return
 * @throws SchemaException
 */
public static SimpleFeatureCollection createCollection(Geometry g) throws SchemaException {

  SimpleFeatureCollection collection = FeatureCollections.newCollection();
  SimpleFeatureType TYPE = DataUtilities.createType("MBB", "location:Polygon:srid=4326"); // 4326
                                                                                          // =
                                                                                          // srid
                                                                                          // of
                                                                                          // wgs84
  SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(TYPE);

  featureBuilder.add(g);
  SimpleFeature feature = featureBuilder.buildFeature(null);
  collection.add(feature);

  return collection;
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
static SimpleFeatureType createSimpleFeatureType(String simpleFeatureTypeName)
  throws SchemaException {

  // list the attributes that constitute the feature type
  List<String> attributes = Lists.newArrayList(
    "Who:String:index=full",
    "What:java.lang.Long",     // some types require full qualification (see DataUtilities docs)
    "When:Date",               // a date-time field is optional, but can be indexed
    "*Where:Point:srid=4326",  // the "*" denotes the default geometry (used for indexing)
    "Why:String"               // you may have as many other attributes as you like...
  );

  // create the bare simple-feature type
  String simpleFeatureTypeSchema = Joiner.on(",").join(attributes);
  SimpleFeatureType simpleFeatureType =
    SimpleFeatureTypes$.MODULE$.createType(simpleFeatureTypeName, simpleFeatureTypeSchema);

  // use the user-data (hints) to specify which date-time field is meant to be indexed;
  // if you skip this step, your data will still be stored, it simply won't be indexed
  simpleFeatureType.getUserData().put(Constants.SF_PROPERTY_START_TIME, "When");

  return simpleFeatureType;
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
public Abstract(final String typeName, final URI namespace,
		final Collection types, final Collection superTypes,
		final GeometryAttributeType defaultGeom) throws SchemaException {
	super(typeName, namespace, types, superTypes, defaultGeom);

	final Iterator st = superTypes.iterator();

	while (st.hasNext()) {
		final FeatureType ft = (FeatureType) st.next();

		if (!ft.isAbstract()) {
			throw new SchemaException(
					"Abstract type cannot descend from no abstract type : "
							+ ft);
		}
	}
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
private SimpleFeatureType createFeatureType(GeometryType geometryType) throws Exception {

		String schema = null;

		switch(geometryType) {
		case POINT:
			schema = "the_geom:Point:srid=4326," + dataSchema;
			break;
		case MULTIPOLYGON:
			schema = "the_geom:MultiPolygon:srid=4326," + dataSchema;
			break;
		}

		try {
			return DataUtilities.createType(geometryType.name().toLowerCase(), schema);
		} catch (SchemaException e) {
			throw new Exception("Failed to create feature types for shapefile export", e);
		}
	}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
@Before
public void setup()
		throws SchemaException,
		CQLException,
		IOException,
		GeoWavePluginException {
	dataStore = createDataStore();
	type = DataUtilities.createType(
			"geostuff",
			"geometry:Geometry:srid=4326,pop:java.lang.Long,pid:String,when:Date");

	type.getDescriptor(
			"when").getUserData().put(
			"time",
			false);
	dataStore.createSchema(type);

}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
@Before
public void setup()
		throws SchemaException,
		CQLException,
		IOException,
		GeoWavePluginException {
	dataStore = createDataStore();
	type = DataUtilities.createType(
			"geostuff",
			"geometry:Geometry:srid=4326,pop:java.lang.Long,when:Date,pid:String");

	dataStore.createSchema(type);
	query = new Query(
			"geostuff",
			CQL
					.toFilter("BBOX(geometry,27.20,41.30,27.30,41.20) and when during 2005-05-19T20:32:56Z/2005-05-19T21:32:56Z"),
			new String[] {
				"geometry",
				"pid"
			});
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
@Before
public void setup()
		throws SchemaException,
		CQLException,
		IOException,
		GeoWavePluginException {
	dataStore = createDataStore();
	type = DataUtilities.createType(
			"geostuff",
			"geometry:Geometry:srid=4326,pop:java.lang.Long,pid:String");

	dataStore.createSchema(type);
	query = new Query(
			"geostuff",
			CQL.toFilter("BBOX(geometry,27.30,41.20,27.20,41.30)"),
			new String[] {
				"geometry",
				"pid"
			});
}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
@Before
public void setup()
		throws SchemaException,
		CQLException,
		IOException,
		GeoWavePluginException {
	dataStore = createDataStore();
	((GeoWaveGTDataStore) dataStore).indexStore.addIndex(new SpatialDimensionalityTypeProvider()
			.createPrimaryIndex(new SpatialOptions()));
	type = DataUtilities.createType(
			"geostuff",
			"geometry:Geometry:srid=4326,pop:java.lang.Long,pid:String,start:Date,end:Date");

	dataStore.createSchema(type);

}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
@Before
public void setup()
		throws SchemaException,
		CQLException {
	type = DataUtilities.createType(
			"geostuff",
			"geom:Geometry:srid=4326,pop:java.lang.Long,pid:String");

	final List<AttributeDescriptor> descriptors = type.getAttributeDescriptors();
	defaults = new Object[descriptors.size()];
	int p = 0;
	for (final AttributeDescriptor descriptor : descriptors) {
		defaults[p++] = descriptor.getDefaultValue();
	}

}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
@Test
public void testOneTime()
		throws SchemaException {
	SimpleFeatureType schema = DataUtilities.createType(
			"sp.geostuff",
			"geometry:Geometry:srid=4326,pop:java.lang.Long,when:Date,whennot:Date,pid:String");

	final TimeDescriptorConfiguration timeConfig = new TimeDescriptorConfiguration();
	timeConfig.configureFromType(schema);

	TimeDescriptors td = new TimeDescriptors(
			schema,
			timeConfig);
	assertEquals(
			"when",
			td.getTime().getLocalName());
	assertNull(td.getStartRange());
	assertNull(td.getEndRange());
	assertTrue(td.hasTime());

}
 

import org.geotools.feature.SchemaException; //导入依赖的package包/类
@Test
public void testRangeTime()
		throws SchemaException {
	SimpleFeatureType schema = DataUtilities.createType(
			"sp.geostuff",
			"geometry:Geometry:srid=4326,pop:java.lang.Long,start:Date,end:Date,pid:String");
	final TimeDescriptorConfiguration timeConfig = new TimeDescriptorConfiguration();
	timeConfig.configureFromType(schema);

	TimeDescriptors td = new TimeDescriptors(
			schema,
			timeConfig);
	assertEquals(
			"start",
			td.getStartRange().getLocalName());
	assertEquals(
			"end",
			td.getEndRange().getLocalName());
	assertNull(td.getTime());
	assertTrue(td.hasTime());

}