下面列出了怎么用javax.xml.bind.SchemaOutputResolver的API类实例代码及写法，或者点击链接到github查看源代码。
public static void main(String[] args) throws Exception {
Path configFile = Paths.get("src/main/resources/org/citydb/config/schema/query.xsd");
System.out.print("Generting XML schema in " + configFile.toAbsolutePath() + "... ");
JAXBContext context = JAXBContext.newInstance(QueryWrapper.class);
context.generateSchema(new SchemaOutputResolver() {
@Override
public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException {
if (ConfigUtil.CITYDB_CONFIG_NAMESPACE_URI.equals(namespaceUri)) {
Files.createDirectories(configFile.getParent());
StreamResult res = new StreamResult();
res.setSystemId(configFile.toUri().toString());
return res;
} else
return null;
}
});
System.out.println("finished.");
}
@Override
public void generateSchema(Path outputPath)
{
try
{
JAXBContext jaxbContext = getJAXBContext();
SchemaOutputResolver sor = new SchemaOutputResolver()
{
@Override
public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException
{
StreamResult result = new StreamResult();
result.setSystemId(outputPath.toUri().toString());
return result;
}
};
jaxbContext.generateSchema(sor);
}
catch (JAXBException | IOException e)
{
throw new WindupException("Error generating Windup schema due to: " + e.getMessage(), e);
}
}
public static List<DOMResult> generateJaxbSchemas(
JAXBContext context, final Map<String, DOMResult> builtIns) throws IOException {
final List<DOMResult> results = new ArrayList<>();
context.generateSchema(new SchemaOutputResolver() {
@Override
public Result createOutput(String ns, String file) throws IOException {
DOMResult result = new DOMResult();
if (builtIns.containsKey(ns)) {
DOMResult dr = builtIns.get(ns);
result.setSystemId(dr.getSystemId());
results.add(dr);
return result;
}
result.setSystemId(file);
results.add(result);
return result;
}
});
return results;
}
@Bean
public XsdSchemaCollection schemaCollection() throws JAXBException, IOException {
JAXBContext context = JAXBContext.newInstance(CalculatorRequest.class, CalculatorResponse.class);
List<ByteArrayOutputStream> outs = new ArrayList<>();
context.generateSchema(new SchemaOutputResolver() {
@Override
public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
outs.add(out);
StreamResult result = new StreamResult(out);
result.setSystemId(suggestedFileName);
return result;
}
});
Resource[] resources = outs.stream().
map(ByteArrayOutputStream::toByteArray).
map(InMemoryResource::new).
collect(Collectors.toList()).
toArray(new Resource[]{});
return new CommonsXsdSchemaCollection(resources);
}
private String tryBuildSchemaFromJaxbAnnotatedClass() throws JAXBException, IOException {
final StringWriter stringWriter = new StringWriter();
JAXBContext.newInstance(clazz).generateSchema(new SchemaOutputResolver() {
@Override
public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException {
final StreamResult result = new StreamResult(stringWriter);
result.setSystemId("schema" + clazz.getSimpleName());
return result;
}
});
return stringWriter.toString();
}
private SchemaOutputResolver createSchemaOutputResolver(Config config, String xmlpath) {
File baseDir = new File(xmlpath, config.getBaseDir().getPath());
SchemaOutputResolverImpl outResolver = new SchemaOutputResolverImpl (baseDir);
for( Schema schema : (List<Schema>)config.getSchema() ) {
String namespace = schema.getNamespace();
File location = schema.getLocation();
outResolver.addSchemaInfo(namespace,location);
}
return outResolver;
}
private static String generateSchema( final Class<?> type ) throws JAXBException, IOException {
final StringWriter stringWriter = new StringWriter();
final JAXBContext jaxbContext =
JAXBContextFactory.createContext( new Class<?>[] { type }, Collections.emptyMap() );
jaxbContext.generateSchema( new SchemaOutputResolver() {
@Override
public final Result createOutput( final String namespaceURI, final String suggestedFileName )
throws IOException {
final StreamResult result = new StreamResult( stringWriter );
result.setSystemId( suggestedFileName );
return result;
}
} );
return stringWriter.toString();
}
public static void main(String[] args) throws Exception {
final File baseDir = new File("./data/static_data");
class MySchemaOutputResolver extends SchemaOutputResolver {
@Override
public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException {
return new StreamResult(new File(baseDir, "static_data1.xsd"));
}
}
JAXBContext context = JAXBContext.newInstance(StaticData.class);
context.generateSchema(new MySchemaOutputResolver());
}
private SchemaOutputResolver createSchemaOutputResolver(Config config, String xmlpath) {
File baseDir = new File(xmlpath, config.getBaseDir().getPath());
SchemaOutputResolverImpl outResolver = new SchemaOutputResolverImpl (baseDir);
for( Schema schema : (List<Schema>)config.getSchema() ) {
String namespace = schema.getNamespace();
File location = schema.getLocation();
outResolver.addSchemaInfo(namespace,location);
}
return outResolver;
}
private SchemaOutputResolver createSchemaOutputResolver(Config config, String xmlpath) {
File baseDir = new File(xmlpath, config.getBaseDir().getPath());
SchemaOutputResolverImpl outResolver = new SchemaOutputResolverImpl (baseDir);
for( Schema schema : (List<Schema>)config.getSchema() ) {
String namespace = schema.getNamespace();
File location = schema.getLocation();
outResolver.addSchemaInfo(namespace,location);
}
return outResolver;
}
private SchemaOutputResolver createSchemaOutputResolver(Config config, String xmlpath) {
File baseDir = new File(xmlpath, config.getBaseDir().getPath());
SchemaOutputResolverImpl outResolver = new SchemaOutputResolverImpl (baseDir);
for( Schema schema : (List<Schema>)config.getSchema() ) {
String namespace = schema.getNamespace();
File location = schema.getLocation();
outResolver.addSchemaInfo(namespace,location);
}
return outResolver;
}
private SchemaOutputResolver createSchemaOutputResolver(Config config, String xmlpath) {
File baseDir = new File(xmlpath, config.getBaseDir().getPath());
SchemaOutputResolverImpl outResolver = new SchemaOutputResolverImpl (baseDir);
for( Schema schema : (List<Schema>)config.getSchema() ) {
String namespace = schema.getNamespace();
File location = schema.getLocation();
outResolver.addSchemaInfo(namespace,location);
}
return outResolver;
}
private SchemaOutputResolver createSchemaOutputResolver(Config config, String xmlpath) {
File baseDir = new File(xmlpath, config.getBaseDir().getPath());
SchemaOutputResolverImpl outResolver = new SchemaOutputResolverImpl (baseDir);
for( Schema schema : (List<Schema>)config.getSchema() ) {
String namespace = schema.getNamespace();
File location = schema.getLocation();
outResolver.addSchemaInfo(namespace,location);
}
return outResolver;
}
private SchemaOutputResolver createSchemaOutputResolver(Config config, String xmlpath) {
File baseDir = new File(xmlpath, config.getBaseDir().getPath());
SchemaOutputResolverImpl outResolver = new SchemaOutputResolverImpl (baseDir);
for( Schema schema : (List<Schema>)config.getSchema() ) {
String namespace = schema.getNamespace();
File location = schema.getLocation();
outResolver.addSchemaInfo(namespace,location);
}
return outResolver;
}
public void testCreateSchema() throws Exception {
JAXBContext jctx = JAXBContext.newInstance(WorkflowDefinition.class);
final Map<String, StreamResult> schemas = new HashMap<String, StreamResult>();
jctx.generateSchema(new SchemaOutputResolver() {
@Override
public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException {
StreamResult sr = new StreamResult(new StringWriter());
sr.setSystemId(namespaceUri);
schemas.put(namespaceUri, sr);
return sr;
}
});
System.out.println(schemas.get(WorkflowProfileConsts.NS_WORKFLOW_V1).getWriter().toString());
}
@Test(expected = MarshalException.class)
public void generatesAndUsesSchema() throws JAXBException, IOException,
SAXException {
final JAXBContext context = JAXBContext.newInstance(A.class);
final DOMResult result = new DOMResult();
result.setSystemId("schema.xsd");
context.generateSchema(new SchemaOutputResolver() {
@Override
public Result createOutput(String namespaceUri,
String suggestedFileName) {
return result;
}
});
@SuppressWarnings("deprecation")
final SchemaFactory schemaFactory = SchemaFactory
.newInstance(WellKnownNamespace.XML_SCHEMA);
final Schema schema = schemaFactory.newSchema(new DOMSource(result
.getNode()));
final Marshaller marshaller = context.createMarshaller();
marshaller.setSchema(schema);
// Works
marshaller.marshal(new A("works"), System.out);
// Fails
marshaller.marshal(new A(null), System.out);
}
public static void main(String[] args) throws JAXBException, IOException {
JAXBContext jaxbContext = JAXBContext.newInstance(Presets.class);
SchemaOutputResolver sor = new SchemaOutputResolver() {
@Override
public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException {
File file = new File("src/jsettlers/mapcreator/presetloader/preset.xsd");
StreamResult result = new StreamResult(file);
result.setSystemId(file.toURI().toURL().toString());
return result;
}
};
jaxbContext.generateSchema(sor);
System.out.println("Finished!");
}
@Override
public void generateSchema(SchemaOutputResolver outputResolver)
throws IOException {
context.generateSchema(outputResolver);
}
/**
* Write out the schema documents.
*/
public void write(SchemaOutputResolver resolver, ErrorListener errorListener) throws IOException {
if(resolver==null)
throw new IllegalArgumentException();
if(logger.isLoggable(Level.FINE)) {
// debug logging to see what's going on.
logger.log(Level.FINE,"Writing XML Schema for "+toString(),new StackRecorder());
}
// make it fool-proof
resolver = new FoolProofResolver(resolver);
this.errorListener = errorListener;
Map<String, String> schemaLocations = types.getSchemaLocations();
Map<Namespace,Result> out = new HashMap<Namespace,Result>();
Map<Namespace,String> systemIds = new HashMap<Namespace,String>();
// we create a Namespace object for the XML Schema namespace
// as a side-effect, but we don't want to generate it.
namespaces.remove(WellKnownNamespace.XML_SCHEMA);
// first create the outputs for all so that we can resolve references among
// schema files when we write
for( Namespace n : namespaces.values() ) {
String schemaLocation = schemaLocations.get(n.uri);
if(schemaLocation!=null) {
systemIds.put(n,schemaLocation);
} else {
Result output = resolver.createOutput(n.uri,"schema"+(out.size()+1)+".xsd");
if(output!=null) { // null result means no schema for that namespace
out.put(n,output);
systemIds.put(n,output.getSystemId());
}
}
//Clear the namespace specific set with already written classes
n.resetWritten();
}
// then write'em all
for( Map.Entry<Namespace,Result> e : out.entrySet() ) {
Result result = e.getValue();
e.getKey().writeTo( result, systemIds );
if(result instanceof StreamResult) {
OutputStream outputStream = ((StreamResult)result).getOutputStream();
if(outputStream != null) {
outputStream.close(); // fix for bugid: 6291301
} else {
final Writer writer = ((StreamResult)result).getWriter();
if(writer != null) writer.close();
}
}
}
}
public FoolProofResolver(SchemaOutputResolver resolver) {
assert resolver!=null;
this.resolver = resolver;
}
public void generateSchema(SchemaOutputResolver outputResolver, ErrorListener errorListener) throws IOException {
getSchemaGenerator().write(outputResolver,errorListener);
}
@Override
public void generateSchema(SchemaOutputResolver outputResolver)
throws IOException {
context.generateSchema(outputResolver);
}
/**
* Write out the schema documents.
*/
public void write(SchemaOutputResolver resolver, ErrorListener errorListener) throws IOException {
if(resolver==null)
throw new IllegalArgumentException();
if(logger.isLoggable(Level.FINE)) {
// debug logging to see what's going on.
logger.log(Level.FINE,"Wrigin XML Schema for "+toString(),new StackRecorder());
}
// make it fool-proof
resolver = new FoolProofResolver(resolver);
this.errorListener = errorListener;
Map<String, String> schemaLocations = types.getSchemaLocations();
Map<Namespace,Result> out = new HashMap<Namespace,Result>();
Map<Namespace,String> systemIds = new HashMap<Namespace,String>();
// we create a Namespace object for the XML Schema namespace
// as a side-effect, but we don't want to generate it.
namespaces.remove(WellKnownNamespace.XML_SCHEMA);
// first create the outputs for all so that we can resolve references among
// schema files when we write
for( Namespace n : namespaces.values() ) {
String schemaLocation = schemaLocations.get(n.uri);
if(schemaLocation!=null) {
systemIds.put(n,schemaLocation);
} else {
Result output = resolver.createOutput(n.uri,"schema"+(out.size()+1)+".xsd");
if(output!=null) { // null result means no schema for that namespace
out.put(n,output);
systemIds.put(n,output.getSystemId());
}
}
}
// then write'em all
for( Map.Entry<Namespace,Result> e : out.entrySet() ) {
Result result = e.getValue();
e.getKey().writeTo( result, systemIds );
if(result instanceof StreamResult) {
OutputStream outputStream = ((StreamResult)result).getOutputStream();
if(outputStream != null) {
outputStream.close(); // fix for bugid: 6291301
} else {
final Writer writer = ((StreamResult)result).getWriter();
if(writer != null) writer.close();
}
}
}
}
public FoolProofResolver(SchemaOutputResolver resolver) {
assert resolver!=null;
this.resolver = resolver;
}
public void generateSchema(SchemaOutputResolver outputResolver, ErrorListener errorListener) throws IOException {
getSchemaGenerator().write(outputResolver,errorListener);
}
@Override
public void generateSchema(SchemaOutputResolver outputResolver)
throws IOException {
context.generateSchema(outputResolver);
}
/**
* Write out the schema documents.
*/
public void write(SchemaOutputResolver resolver, ErrorListener errorListener) throws IOException {
if(resolver==null)
throw new IllegalArgumentException();
if(logger.isLoggable(Level.FINE)) {
// debug logging to see what's going on.
logger.log(Level.FINE,"Writing XML Schema for "+toString(),new StackRecorder());
}
// make it fool-proof
resolver = new FoolProofResolver(resolver);
this.errorListener = errorListener;
Map<String, String> schemaLocations = types.getSchemaLocations();
Map<Namespace,Result> out = new HashMap<Namespace,Result>();
Map<Namespace,String> systemIds = new HashMap<Namespace,String>();
// we create a Namespace object for the XML Schema namespace
// as a side-effect, but we don't want to generate it.
namespaces.remove(WellKnownNamespace.XML_SCHEMA);
// first create the outputs for all so that we can resolve references among
// schema files when we write
for( Namespace n : namespaces.values() ) {
String schemaLocation = schemaLocations.get(n.uri);
if(schemaLocation!=null) {
systemIds.put(n,schemaLocation);
} else {
Result output = resolver.createOutput(n.uri,"schema"+(out.size()+1)+".xsd");
if(output!=null) { // null result means no schema for that namespace
out.put(n,output);
systemIds.put(n,output.getSystemId());
}
}
//Clear the namespace specific set with already written classes
n.resetWritten();
}
// then write'em all
for( Map.Entry<Namespace,Result> e : out.entrySet() ) {
Result result = e.getValue();
e.getKey().writeTo( result, systemIds );
if(result instanceof StreamResult) {
OutputStream outputStream = ((StreamResult)result).getOutputStream();
if(outputStream != null) {
outputStream.close(); // fix for bugid: 6291301
} else {
final Writer writer = ((StreamResult)result).getWriter();
if(writer != null) writer.close();
}
}
}
}
public FoolProofResolver(SchemaOutputResolver resolver) {
assert resolver!=null;
this.resolver = resolver;
}
/**
* This returns the SchemaOutputResolver to generate the schemas
*/
public SchemaOutputResolver getSchemaOutputResolver(){
return schemaOutputResolver;
}
public void generateSchema(SchemaOutputResolver outputResolver, ErrorListener errorListener) throws IOException {
getSchemaGenerator().write(outputResolver,errorListener);
}