import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
public static String getAttachmentNameFromDispositionParameters(BodyDescriptor bd) {
    //Refer RFC : 2047 for mime word decoding
    //Refer RFC : 2183 for Content-Disposition Header Field
    String attachmentName = null;
    if (bd instanceof MaximalBodyDescriptor) {
        attachmentName = getDecodedWord(((MaximalBodyDescriptor) bd).getContentDispositionFilename());
        if (StringUtils.isEmpty(attachmentName)) {
            //Handling case where RFC 2183 is not properly implemented by tech.blueglacier.email creating client.
            attachmentName = getDecodedWord(((MaximalBodyDescriptor) bd).getContentDispositionParameters().get("name"));
        }
        //Added case for supporting RFC 2184 'Parameter Value Character Set and Language Information' 
        // this is currently not supported in mime4j (version 0.7.2)
        if (StringUtils.isEmpty(attachmentName)) {
            attachmentName = getDecodedDispositionFileName(bd);
        }
    }
    return attachmentName;
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
@Test
public void shouldSetSequenceWithEachNewPart() throws Exception{

    BodyDescriptor bodyMock = mock(BodyDescriptor.class);
    ByteArrayInputStream streamMock = new ByteArrayInputStream(new byte[] {});

    MessageContentExtractor extractor = new MessageContentExtractor();

    extractor.startHeader();
    extractor.body(bodyMock, streamMock);
    assertThat(getCurrentSequence(extractor)).containsExactly(1);

    extractor.startHeader();
    extractor.body(bodyMock, streamMock);
    assertThat(getCurrentSequence(extractor)).containsExactly(1, 2);

    extractor.startHeader();
    extractor.body(bodyMock, streamMock);
    assertThat(getCurrentSequence(extractor)).containsExactly(1, 2, 3);
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
@Override
public void body(BodyDescriptor bd, InputStream is) throws MimeException,
        IOException {
    String r = "";
    byte[] buffer = new byte[200];
    String s;
    int len;
    try {
        while ((len = is.read(buffer)) != -1) {
            if (len != 200) {
                byte buffer2[] = new byte[len];
                System.arraycopy(buffer, 0, buffer2, 0, len);
                s = new String(buffer2);
            } else {
                s = new String(buffer);
            }
            if (s != null)
                r += s;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    mailInfo.body = r;
    //System.out.println("body");
    //System.out.println(r);
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
@Override
public void startMultipart(BodyDescriptor bd) throws MimeException {
    Part part = (Part) stack.peek();

    String mimeType = bd.getMimeType();
    String boundary = bd.getBoundary();

    MimeMultipart multipart = new MimeMultipart(mimeType, boundary);
    part.setBody(multipart);

    stack.push(multipart);
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
@Override
public void startMultipart(BodyDescriptor bd) throws MimeException {
    expect(Part.class);

    Part e = (Part)stack.peek();
    String mimeType = bd.getMimeType();
    String boundary = bd.getBoundary();
    MimeMultipart multiPart = new MimeMultipart(mimeType, boundary);
    e.setBody(multiPart);
    stack.addFirst(multiPart);
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
public void fillEmailContents(BodyDescriptor bd, InputStream is){
	LOGGER.info("mime part received");
	if(addPlainTextEmailBody(bd,is)){}
	else if(addHTMLEmailBody(bd,is)){}
	else if(addCalendar(bd,is)){}
	else{
		addAttachments(bd,is);
	}
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
private boolean addCalendar(BodyDescriptor bd, InputStream is) {
	boolean isBodySet = false;
	BodyDescriptor calendarBodyDescriptor = bd;
	if(calendarBody == null){
		if(isCalendarBody(calendarBodyDescriptor)){
			calendarBody = new CalendarBody(bd,is);
			isBodySet = true;
			LOGGER.info("Email calendar body identified");
		}
	}
	
	return isBodySet;
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
private boolean addHTMLEmailBody(BodyDescriptor bd, InputStream is) {
	boolean isBodySet = false;
	BodyDescriptor emailHTMLBodyDescriptor = bd;
	if(htmlEmailBody == null){
		if(isHTMLBody(emailHTMLBodyDescriptor)){
			htmlEmailBody = new HtmlEmailBody(bd,is);
			isBodySet = true;
			LOGGER.info("Email html body identified");
		}
	}else{
		if(isHTMLBody(emailHTMLBodyDescriptor)){
			if(multipartStack.peek().getBodyDescriptor().getMimeType().equalsIgnoreCase("multipart/mixed")){
				InputStream mainInputStream;
				try {
					mainInputStream = concatInputStream(is, htmlEmailBody.getIs());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
				htmlEmailBody.setIs(mainInputStream);
			}else{
				addAttachments(new HtmlEmailBody(bd,is));
			}
			isBodySet = true;
		}
	}		
	return isBodySet;
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
private boolean addPlainTextEmailBody(BodyDescriptor bd, InputStream is) {
	boolean isBodySet = false;
	BodyDescriptor emailPlainBodyDescriptor = bd;
	if(plainTextEmailBody == null){
		if(isPlainTextBody(emailPlainBodyDescriptor)){
			plainTextEmailBody = new PlainTextEmailBody(bd,is);
			isBodySet = true;
			LOGGER.info("Email plain text body identified");
		}
	}else{
		if(isPlainTextBody(emailPlainBodyDescriptor)){
			if(multipartStack.peek().getBodyDescriptor().getMimeType().equalsIgnoreCase("multipart/mixed")){
				InputStream mainInputStream;
				try {
					mainInputStream = concatInputStream(is,plainTextEmailBody.getIs());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
				plainTextEmailBody.setIs(mainInputStream);
			}else{
				addAttachments(new PlainTextEmailBody(bd,is));
			}
			isBodySet = true;
		}
	}		
	return isBodySet;
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
@Override
public void body(BodyDescriptor bd, InputStream is) throws MimeException, IOException {
	// Gracefully switiching off the case of tech.blueglacier.email attached within an tech.blueglacier.email
	if(email.getMessageStack().peek().getEmailMessageTypeHierarchy() == EmailMessageTypeHierarchy.parent){
	email.fillEmailContents(bd, is);
}
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
private static String getDecodedDispositionFileName(BodyDescriptor bd){
	String attachmentName = null;
	try {
		attachmentName = ContentDispositionDecoder.decodeDispositionFileName(((MaximalBodyDescriptor)bd).getContentDispositionParameters());
	} catch (MimeException e) {
		throw new RuntimeException(e);
	}
	return attachmentName;
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
public static String getAttachmentNameFromContentTypeParmaeters(BodyDescriptor bd) {
	String attachmentName = null;
	if(bd instanceof MaximalBodyDescriptor){
		Map<String, String> contentTypeParameters = ((MaximalBodyDescriptor)bd).getContentTypeParameters();
		String nameKey = null;
		if(contentTypeParameters.containsKey(nameKey = "name") || contentTypeParameters.containsKey(nameKey = "NAME")
				|| contentTypeParameters.containsKey(nameKey = "Name")){
			attachmentName = contentTypeParameters.get(nameKey);
		}
		attachmentName = getDecodedWord(attachmentName);
	}
	return attachmentName;
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
public static String getAttachmentName(BodyDescriptor bd){		
	// Content tech.blueglacier.disposition 'filename' is more standard, so it's taken as default first
	String attachmentName = Common.getAttachmentNameFromDispositionParameters(bd);
	if(attachmentName == null || attachmentName.isEmpty()){			
		// Content type 'name' is other alternative so it's taken as alternative too
		attachmentName = Common.getAttachmentNameFromContentTypeParmaeters(bd);			
	}		
	return attachmentName;		
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
public void startMultipart(BodyDescriptor bd) {
    expect(Part.class);

    Part e = (Part)stack.peek();
    try {
        MimeMultipart multiPart = new MimeMultipart(e.getContentType());
        e.setBody(multiPart);
        stack.addFirst(multiPart);
    } catch (MessagingException me) {
        throw new Error(me);
    }
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
/**
 * @see org.apache.james.mime4j.parser.ContentHandler#startMultipart(org.apache.james.mime4j.stream.BodyDescriptor)
 */
public void startMultipart(final BodyDescriptor bd) throws MimeException {
    expect(Entity.class);

    final Entity e = (Entity) stack.peek();
    final String subType = bd.getSubType();
    final Multipart multiPart = new MultipartImpl(subType);
    e.setBody(multiPart);
    stack.push(multiPart);
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
public void startMultipart(BodyDescriptor bd) {
    expect(Part.class);
    Part e = (Part)stack.peek();
    try {
    	String contentType = e.getContentType();
    	if( contentType.contains( "multipart/signed" ) ) {
    		multipartSigned = true;
    	}
        MimeMultipart multiPart = new MimeMultipart(contentType);
        e.setBody(multiPart);
        stack.addFirst(multiPart);
    } catch (MessagingException me) {
        throw new Error(me);
    }
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
public void body(BodyDescriptor bd, InputStream is) throws IOException {
    sb.append("<body>\r\n");
    int b = 0;
    while ((b = is.read()) != -1) {
        sb.append(escape((char) b));
    }
    sb.append("</body>\r\n");
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
@Override
public void startMultipart(BodyDescriptor bd) throws MimeException {
    /* do nothing */
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
@Override
public void body(BodyDescriptor bd, InputStream is) throws MimeException, IOException {
    /* do nothing */
}
 

import org.apache.james.mime4j.stream.BodyDescriptor; //导入依赖的package包/类
public EmailAttachment(BodyDescriptor bd, InputStream is){
	super(bd, is);
}