import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private MimeType getMimeType(Set<MimeType> mimeTypes, String path) {
  try {
    mimeTypes.addAll(mimeUtil.getMimeTypes(path));
  } catch (MimeException e) {
    log.warn("Unable to determine MIME type from path", e);
  }

  if (isUnknownType(mimeTypes)) {
    return MimeUtil2.UNKNOWN_MIME_TYPE;
  }

  final List<MimeType> types = new ArrayList<>(mimeTypes);
  Collections.sort(
      types,
      new Comparator<MimeType>() {
        @Override
        public int compare(MimeType a, MimeType b) {
          return getCorrectedMimeSpecificity(b) - getCorrectedMimeSpecificity(a);
        }
      });
  return types.get(0);
}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
private ContentType getFileMimeType(File file){

        try {
            Collection<MimeType> types = MimeUtil.getMimeTypes(file);
            MimeType target = null;
            for (MimeType mimeType : types){
                if (mimeType.equals(MimeUtil2.UNKNOWN_MIME_TYPE)){
                    continue;
                }
                target = mimeType;
            }
            if (target != null){
                return ContentType.create(target.toString());
            }
            return null;
        } catch (MimeException e) {
            logger.error(e.getMessage(), e);
            return null;
        }
    }
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
/**
 * Defer this call to the InputStream method
 */
public Collection getMimeTypesURL(final URL url) throws UnsupportedOperationException {
	InputStream in = null;
	try {
		return getMimeTypesInputStream(in = new BufferedInputStream(MimeUtil.getInputStreamForURL(url)));
	}catch(Exception e) {
		throw new MimeException(e);
	}finally {
		closeStream(in);
	}
}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
/**
 * Defer this call to the InputStream method
 */
public Collection<MimeType> getMimeTypesURL(final URL url) throws UnsupportedOperationException {
	InputStream in = null;
	try {
		return getMimeTypesInputStream(in = new BufferedInputStream(MimeUtil.getInputStreamForURL(url)));
	}catch(Exception e) {
		throw new MimeException(e);
	}finally {
		closeStream(in);
	}
}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
private Collection lookupMimeTypesForMagicData(InputStream in) {

		int offset = 0;
		int len = getMaxExtents();
		byte[] data = new byte[len];
		// Mark the input stream
		in.mark(len);

		try {
			// Since an InputStream might return only some data (not all
			// requested), we have to read in a loop until
			// either EOF is reached or the desired number of bytes have been
			// read.
			int restBytesToRead = len;
			while (restBytesToRead > 0) {
				int bytesRead = in.read(data, offset, restBytesToRead);
				if (bytesRead < 0)
					break; // EOF

				offset += bytesRead;
				restBytesToRead -= bytesRead;
			}
		} catch (IOException ioe) {
			throw new MimeException(ioe);
		} finally {
			try {
				// Reset the input stream to where it was marked.
				in.reset();
			} catch (Exception e) {
				throw new MimeException(e);
			}
		}
		return lookupMagicData(data);
	}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
private InputStream getInputStream(URL url) {
	try {
		return MimeUtil.getInputStreamForURL(url);
	} catch (Exception e) {
		throw new MimeException("Error getting InputStream for URL ["
				+ url.getPath() + "]", e);
	}
}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
public Collection getMimeTypesFile(File file)
		throws UnsupportedOperationException {
	try {
		return getMimeTypesURL(file.toURI().toURL());
	}catch(Exception e) {
		throw new MimeException(e);
	}
}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
/**
 * Construct a mime type from a String such as <code>text/plain</code>.
 * It tries to ensure that the mime type pattern passed in is correctly
 * formatted.
 *
 * @param mimeType
 * @throws MimeException
 */
public MimeType(final String mimeType) throws MimeException {
	if(mimeType == null || mimeType.trim().length() == 0){
		throw new MimeException("Invalid MimeType [" + mimeType + "]");
	}
	String [] parts = mimeSplitter.split(mimeType.trim());
	
	if(parts.length > 0) {
		// Treat as the mediaType
		mediaType = getValidMediaType(parts[0]);
	} if(parts.length > 1) {
		subType = getValidSubType(parts[1]);
	}
}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
/**
 * Construct a mime type from a String such as <code>text/plain</code>.
 * It tries to ensure that the mime type pattern passed in is correctly
 * formatted.
 *
 * @param mimeType
 * @throws MimeException
 */
public MimeType(final String mimeType) throws MimeException {
	if(mimeType == null || mimeType.trim().length() == 0){
		throw new MimeException("Invalid MimeType [" + mimeType + "]");
	}
	String [] parts = mimeSplitter.split(mimeType.trim());

	if(parts.length > 0) {
		// Treat as the mediaType
		mediaType = getValidMediaType(parts[0]);
	} if(parts.length > 1) {
		subType = getValidSubType(parts[1]);
	}
}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
FileExtensionMimeType(String mimeType) throws MimeException {
  super(mimeType);
}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
private Collection _getMimeTypes(Collection mimeTypes, InputStream in) {

		try {
			if (mimeTypes.isEmpty() || mimeTypes.size() > 1) {
				Collection _mimeTypes = getMimeTypesInputStream(in = new BufferedInputStream(
						in));

				if (!_mimeTypes.isEmpty()) {
					if (!mimeTypes.isEmpty()) {
						// more than one glob matched

						// Check for same mime type
						for (Iterator it = mimeTypes.iterator(); it.hasNext();) {
							String mimeType = (String) it.next();
							if (_mimeTypes.contains(mimeType)) {
								// mimeTypes = new ArrayList();
								mimeTypes.add(mimeType);
								// return mimeTypes;
							}
							// Check for mime type subtype
							for (Iterator _it = _mimeTypes.iterator(); _it
									.hasNext();) {
								String _mimeType = (String) _it.next();
								if (isMimeTypeSubclass(mimeType, _mimeType)) {
									// mimeTypes = new ArrayList();
									mimeTypes.add(mimeType);
									// return mimeTypes;
								}
							}
						}
					} else {
						// No globs matched but we have magic matches
						return _mimeTypes;
					}
				}
			}
		} catch (Exception e) {
			throw new MimeException(e);
		} finally {
			closeStream(in);
		}
		return mimeTypes;

	}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
/**
 * Get the mime type of a file using extension mappings. The file path
 * can be a relative or absolute path or can refer to a completely non-existent file as
 * only the extension is important here.
 *
 * @param file points to a file or directory. May not actually exist
 * @return collection of the matched mime types.
 * @throws MimeException if errors occur.
 */
public Collection getMimeTypesFile(final File file) throws MimeException {
	return getMimeTypesFileName(file.getName());
}
 

import eu.medsea.mimeutil.MimeException; //导入依赖的package包/类
/**
 * Get the mime type of a URL using extension mappings. Only the extension is important here.
 *
 * @param url is a valid URL
 * @return collection of the matched mime types.
 * @throws MimeException if errors occur.
 */
public Collection getMimeTypesURL(final URL url) throws MimeException {
	return getMimeTypesFileName(url.getPath());
}