import org.apache.jena.atlas.web.ContentType; //导入依赖的package包/类
@Override
protected void executeAction(DeltaAction action) throws IOException {
    LOG.info("GET "+action.getURL());
    Id dsRef = Id.fromString(action.httpArgs.datasourceName);
    String filenameIRI = determineData(action, dsRef);
    ContentType ct = RDFLanguages.guessContentType(filenameIRI) ;
    String fn = IRILib.IRIToFilename(filenameIRI);
    Path path = Paths.get(fn);
    try ( InputStream in = Files.newInputStream(path) ) {
        action.response.setStatus(HttpSC.OK_200);
        action.response.setContentType(ct.getContentType());
        IOUtils.copy(in, action.response.getOutputStream());
    } catch (NoSuchFileException | FileNotFoundException ex) {
        throw new DeltaNotFoundException(action.getURL());
    }
}
 

import org.apache.jena.atlas.web.ContentType; //导入依赖的package包/类
@Override
protected void validate(HttpAction action) {
    String method = action.getRequest().getMethod();
    switch(method) {
        case HttpNames.METHOD_POST:
        case HttpNames.METHOD_PATCH:
            break;
        default:
            ServletOps.errorMethodNotAllowed(method+" : Patch must use POST or PATCH");
    }
    String ctStr = action.request.getContentType();
    // Must be UTF-8 or unset. But this is wrong so often,
    // it is less trouble to just force UTF-8.
    String charset = action.request.getCharacterEncoding();
    if ( charset != null && ! WebContent.charsetUTF8.equals(charset) )
        ServletOps.error(HttpSC.UNSUPPORTED_MEDIA_TYPE_415, "Charset must be omitted or UTF-8, not "+charset); 

    // If no header Content-type - assume patch-text.
    ContentType contentType = ( ctStr != null ) ? ContentType.create(ctStr) : ctPatchText;
    if ( ! ctPatchText.equals(contentType) && ! ctPatchBinary.equals(contentType) ) 
        ServletOps.error(HttpSC.UNSUPPORTED_MEDIA_TYPE_415, "Allowed Content-types are "+ctPatchText+" or "+ctPatchBinary+", not "+ctStr); 
    if ( ctPatchBinary.equals(contentType) )
        ServletOps.error(HttpSC.UNSUPPORTED_MEDIA_TYPE_415, contentTypePatchBinary+" not supported yet");
}
 

import org.apache.jena.atlas.web.ContentType; //导入依赖的package包/类
@Override
public TypedInputStream open(LookUpRequest request) {
    if (classLoader == null) {
        return null;
    }
    String resourceName = request.getFilenameOrURI();
    InputStream in = classLoader.getResourceAsStream(resourceName);
    if (in == null) {
        return null;
    }
    
    try {
        String ct = Files.probeContentType(Paths.get(new File(resourceName).getName()));
        return new TypedInputStream(in, ContentType.create(ct), resourceName);
    } catch (IOException ex) {
            log.trace("Error while trying to probe content type for " + resourceName + ": " + ex.getMessage());
        return new TypedInputStream(in, (String) null);
    } 
}
 

import org.apache.jena.atlas.web.ContentType; //导入依赖的package包/类
private static boolean isRDF(final MediaType requestContentType) {
    if (requestContentType == null) {
        return false;
    }

    final ContentType ctRequest = create(requestContentType.toString());

    // Text files and CSV files are not considered RDF to Fedora, though CSV is a valid
    // RDF type to Jena (although deprecated).
    if (matchContentType(ctRequest, ctTextPlain) || matchContentType(ctRequest, ctTextCSV)) {
        return false;
    }

    // SPARQL updates are done on containers.
    return isRdfContentType(requestContentType.toString()) || matchContentType(ctRequest, ctSPARQLUpdate);
}
 

import org.apache.jena.atlas.web.ContentType; //导入依赖的package包/类
public String probeContentType(Path path) throws IOException {
    if(path == null) {
        throw new IOException();
    }
    String fileName = path.getFileName().toString();
    if(fileName.endsWith(SPARQLGenerate.EXT)) {
        return SPARQLGenerate.MEDIA_TYPE;
    }
    ContentType ct = RDFLanguages.guessContentType(fileName);
    if(ct==null) {
        throw new IOException();
    }
    return ct.getContentType();
}
 

import org.apache.jena.atlas.web.ContentType; //导入依赖的package包/类
/**
 * Open anything that looks a bit like a file name
 */
@Override
public TypedInputStream open(LookUpRequest request) {
    String filenameIRI = request.getFilenameOrURI();
    String fn = toFileName(filenameIRI);
    if (fn == null) {
        log.debug("Cannot find a proper filename: " + filenameIRI);
        return null;
    }

    try {
        if (!exists$(fn)) {
            return null;
        }
    } catch (AccessControlException e) {
        log.debug("Security problem testing for file", e);
        return null;
    }

    try {
        InputStream in = IO.openFileEx(fn);
        try {
            String ct = Files.probeContentType(Paths.get(new File(filenameIRI).getName()));
            return new TypedInputStream(in, ContentType.create(ct), filenameIRI);
        } catch (Exception ex) {
            log.trace("Error while trying to probe content type for " + filenameIRI + ": " + ex.getMessage());
            return new TypedInputStream(in, (ContentType) null, filenameIRI);
        } 
    } catch (IOException ioEx) {
        // Includes FileNotFoundException
        // We already tested whether the file exists or not.
        log.debug("File unreadable (but exists): " + fn + " Exception: " + ioEx.getMessage());
        return null;
    }
}
 

import org.apache.jena.atlas.web.ContentType; //导入依赖的package包/类
static Module.Format fromMime(final String aMime) {
	final ContentType expectedCT = ContentType.create(aMime);
	for(final Module.Format format:values()) {
		final ContentType candidateCT=format.lang.getContentType();
		if(candidateCT.getType().equals(expectedCT.getType()) && candidateCT.getSubType().equals(expectedCT.getSubType())) {
			return format;
		}
	}
	return null;
}
 

import org.apache.jena.atlas.web.ContentType; //导入依赖的package包/类
public String mime() {
	final ContentType contentType = this.lang.getContentType();
	return contentType.getType()+"/"+contentType.getSubType();
}
 

import org.apache.jena.atlas.web.ContentType; //导入依赖的package包/类
@Override
public void read(InputStream in, String baseURI, ContentType ct, StreamRDF output, Context context) {
    Item item = SSE.parse(in) ;
    read(item, baseURI, ct, output, context) ;

}