メールサポート

   ...
   .transform(Mail.toStringTransformer())
   ...

   ...
   transform(Mail.toStringTransformer())
   ...

   ...
   transform(Mail.toStringTransformer())
   ...

<int-mail:mail-to-string-transformer ... >

@Bean
public JavaMailSender mailSender() {
    JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
    mailSender.setHost("somehost");
    mailSender.setUsername("someuser");
    mailSender.setPassword("somepassword");
    Properties javaMailProperties = new Properties();
    javaMailProperties.put("mail.smtp.starttls.enable", "true");
    mailSender.setJavaMailProperties(javaMailProperties);
    return mailSender;
}

@Bean
public IntegrationFlow mailOutboundFlow(MessageChannel outboundMail, JavaMailSender mailSender) {
    return IntegrationFlow.from(outboundMail)
            .handle(Mail.outboundAdapter(mailSender))
            .get();
}

@Bean
fun mailSender(): JavaMailSender =
    JavaMailSenderImpl().apply {
        host = "somehost"
        username = "someuser"
        password = "somepassword"
        javaMailProperties = Properties().apply {
            put("mail.smtp.starttls.enable", "true")
    }
}

@Bean
fun mailOutboundFlow(outboundMail: MessageChannel, mailSender: JavaMailSender) =
    integrationFlow(outboundMail) {
		handle(Mail.outboundAdapter(mailSender))
    }

@Bean
mailSender() {
    new JavaMailSenderImpl().with {
        host = "somehost"
        username = "someuser"
        password = "somepassword"
        javaMailProperties = ['mail.smtp.starttls.enable': 'true']
        it
    }
}

@Bean
mailOutboundFlow(MessageChannel outboundMail, JavaMailSender mailSender) {
    integrationFlow(outboundMail) {
        handle(Mail.outboundAdapter(mailSender))
    }
}

<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
        <property name="host" value="somehost"/>
        <property name="username" value="someuser"/>
        <property name="password" value="somepassword"/>
        <property name="javaMailProperties">
            <props>
                <prop key="mail.smtp.starttls.enable">true</prop>
            </props>
        </property>
    </bean>
<int-mail:outbound-channel-adapter channel="outboundMail"
    mail-sender="mailSender"/>

@Bean
public IntegrationFlow mailOutboundFlow(MessageChannel outboundMail) {
    return IntegrationFlow.from(outboundMail)
            .handle(Mail.outboundAdapter("somehost")
                    .credentials("someuser", "somepassword")
                    .javaMailProperties(p -> p.put("mail.smtp.starttls.enable", "true")))
            .get();
}

@Bean
fun mailOutboundFlow(outboundMail: MessageChannel) = integrationFlow(outboundMail) {
    handle(Mail.outboundAdapter("somehost")
        .credentials("someuser", "somepassword")
        .javaMailProperties { p -> p.put("mail.smtp.starttls.enable", "true") })
}

@Bean
mailOutboundFlow(MessageChannel outboundMail) {
    integrationFlow(outboundMail) {
        handle(Mail.outboundAdapter("somehost").with {
            credentials("someuser", "somepassword")
            javaMailProperties { p -> p.put('mail.smtp.starttls.enable', 'true') }
        })
    }
}

<int-mail:outbound-channel-adapter channel="outboundMail"
    host="somehost" username="someuser" password="somepassword"/>

@Bean
public IntegrationFlow mailOutboundFlow(MessageChannel outboundMail) {
    return IntegrationFlow.from(outboundMail)
            .enrichHeaders(h -> h.headerExpression(MailHeaders.TO, "payload.to")
                    .headerExpression(MailHeaders.CC, "payload.cc")
                    .headerExpression(MailHeaders.BCC, "payload.bcc")
                    .headerExpression(MailHeaders.REPLY_TO, "payload.replyTo")
                    .headerExpression(MailHeaders.FROM, "payload.from")
                    .headerExpression(MailHeaders.SUBJECT, "payload.subject"))
            .get();
}

@Bean
fun mailOutboundFlow(outboundMail: MessageChannel) = integrationFlow(outboundMail) {
    enrichHeaders {
        headerExpression(MailHeaders.TO, "payload.to")
        headerExpression(MailHeaders.CC, "payload.cc")
        headerExpression(MailHeaders.BCC, "payload.bcc")
        headerExpression(MailHeaders.REPLY_TO, "payload.replyTo")
        headerExpression(MailHeaders.FROM, "payload.from")
        headerExpression(MailHeaders.SUBJECT, "payload.subject")
    }
}

@Bean
mailOutboundFlow(MessageChannel outboundMail) {
    integrationFlow(outboundMail) {
        enrichHeaders {
            headerExpression(MailHeaders.TO, 'payload.to')
            headerExpression(MailHeaders.CC, 'payload.cc')
            headerExpression(MailHeaders.BCC, 'payload.bcc')
            headerExpression(MailHeaders.REPLY_TO, 'payload.replyTo')
            headerExpression(MailHeaders.FROM, 'payload.from')
            headerExpression(MailHeaders.SUBJECT, 'payload.subject')
        }
    }
}

<int-mail:header-enricher input-channel="expressionsInput" default-overwrite="false">
	<int-mail:to expression="payload.to"/>
	<int-mail:cc expression="payload.cc"/>
	<int-mail:bcc expression="payload.bcc"/>
	<int-mail:from expression="payload.from"/>
	<int-mail:reply-to expression="payload.replyTo"/>
	<int-mail:subject expression="payload.subject" overwrite="true"/>
</int-mail:header-enricher>

@Bean
public IntegrationFlow imapMailInboundFlow(Properties javaMailProperties, MessageChannel receiveChannel) {
    return IntegrationFlow
        .from(Mail.imapInboundAdapter("imaps://[username]:[password]@imap.gmail.com/INBOX")
                .shouldDeleteMessages(true)
                .shouldMarkMessagesAsRead(true)
                .javaMailProperties(javaMailProperties)
                .maxFetchSize(1),
            e -> e.poller(Pollers.fixedRate(5000)))
        .channel(receiveChannel)
        .get();
}

@Bean
fun imapMailInboundFlow(javaMailProperties: Properties, receiveChannel: MessageChannel) =
   integrationFlow(
        Mail.imapInboundAdapter("imaps://[username]:[password]@imap.gmail.com/INBOX")
            .shouldDeleteMessages(true)
            .shouldMarkMessagesAsRead(true)
            .javaMailProperties(javaMailProperties)
            .maxFetchSize(1),
        { poller { it.fixedRate(5000) } }
    ) {
        channel(receiveChannel)
    }

@Bean
imapMailInboundFlow(Properties javaMailProps, MessageChannel receiveChannel) {
    integrationFlow(
            Mail.imapInboundAdapter("imaps://[username]:[password]@imap.gmail.com/INBOX").with {
                shouldMarkMessagesAsRead true
                shouldDeleteMessages true
                id 'groovyImapIdleAdapter'
                javaMailProperties javaMailProps
                maxFetchSize 1
            }, { e -> e.poller(Pollers.fixedRate(5000)) }
    ) {
        channel receiveChannel
    }
}

<int-mail:inbound-channel-adapter id="imapAdapter"
      store-uri="imaps://[username]:[password]@imap.gmail.com/INBOX"
      java-mail-properties="javaMailProperties"
      channel="receiveChannel"
      should-delete-messages="true"
      should-mark-messages-as-read="true"
      auto-startup="true">
      <int:poller max-messages-per-poll="1" fixed-rate="5000"/>
</int-mail:inbound-channel-adapter>

@Bean
public IntegrationFlow imapIdleFlow(MessageChannel receiveChannel, MailMessageHandler mailMessageHandler,
    Properties javaMailProperties) {

	return IntegrationFlow
    .from(Mail.imapIdleAdapter("imaps://[username]:[password]@imap.gmail.com/INBOX")
            .shouldDeleteMessages(false)
            .shouldMarkMessagesAsRead(true)
            .javaMailProperties(javaMailProperties)
        .autoStartup(true)
        .id("imapIdleAdapter"))
    .channel(receiveChannel)
    .get();
}

@Bean
fun imapIdleFlow(receiveChannel: MessageChannel, javaMailProperties: Properties) =

    integrationFlow(
        Mail.imapIdleAdapter("imaps://[username]:[password]@imap.gmail.com/INBOX").apply {
            shouldDeleteMessages(false)
            shouldMarkMessagesAsRead(true)
            javaMailProperties(javaMailProperties)
            autoStartup(true)
            id("kotlinImapIdleAdapter")
        }
    ) {
        channel(receiveChannel)
    }

@Bean
imapIdleFlow(MessageChannel receiveChannel, Properties javaMailProps) {

    integrationFlow(
        Mail.imapIdleAdapter("imaps://[username]:[password]@imap.gmail.com/INBOX").with {
             shouldMarkMessagesAsRead false
             shouldDeleteMessages true
             javaMailProperties javaMailProps
             autoStartup true
             id 'groovyImapIdleAdapter'
        }
    ) {
        channel receiveChannel
    }
}

<int-mail:imap-idle-channel-adapter id="customAdapter"
      store-uri="imaps://[username]:[password]@imap.gmail.com/INBOX"
      channel="receiveChannel"
      auto-startup="true"
      should-delete-messages="false"
      should-mark-messages-as-read="true"
      java-mail-properties="javaMailProperties"/>

@Bean
fun javaMailProperties(): Properties = Properties().apply {
    this["mail.imaps.socketFactory.class"] = "javax.net.ssl.SSLSocketFactory"
    this["mail.imaps.socketFactory.fallback"] = "false"
    this["mail.store.protocol"] = "imaps"
}

@Bean
javaMailProperties() {
    new Properties([
            'mail.imaps.socketFactory.class'   : 'javax.net.ssl.SSLSocketFactory',
            'mail.imaps.socketFactory.fallback': 'false',
            'mail.store.protocol'              : 'imaps'
    ])
}

<util:properties id="javaMailProperties">
  <prop key="mail.imap.socketFactory.class">javax.net.ssl.SSLSocketFactory</prop>
  <prop key="mail.imap.socketFactory.fallback">false</prop>
  <prop key="mail.store.protocol">imaps</prop>
  <prop key="mail.debug">false</prop>
</util:properties>

@Bean
fun imapIdleFlow(searchTermStrategy: SearchTermStrategy) =
    integrationFlow(
        Mail.imapIdleAdapter("imap:something").apply {
            // ...
            searchTermStrategy(searchTermStrategy)
            // ...
        }
    )
// ...

@Bean fun searchTermStrategy(): SearchTermStrategy {
    return TestSearchTermStrategy()
}

@Bean
imapIdleFlow(SearchTermStrategy searchStrategy) {
    integrationFlow(
            Mail.imapIdleAdapter("imap:something").with {
                 // ...
                 searchTermStrategy searchStrategy
                 // ...
            }
    )
// ...
}

@Bean
SearchTermStrategy searchTermStrategy() {
    new TestSearchTermStrategy()
}

<mail:imap-idle-channel-adapter id="customAdapter"
			store-uri="imap:something"
			…
			search-term-strategy="searchTermStrategy"/>

<bean id="searchTermStrategy"
  class="o.s.i.mail.config.ImapIdleChannelAdapterParserTests.TestSearchTermStrategy"/>

@Bean
fun imapMailReceiver(javaMailProps: Properties) =
    ImapMailReceiver("imaps://[username]:[password]@imap.gmail.com/INBOX").apply {
        setShouldDeleteMessages(false)
        setShouldMarkMessagesAsRead(true)
        setJavaMailProperties(javaMailProps)
        setSelectorExpression(SpelExpressionParser().parseExpression("subject matches '(?i).*Spring Integration.*'"))
    }

@Bean
imapMailReceiver(Properties javaMailProps) {
     new ImapMailReceiver("imaps://[username]:[password]@imap.gmail.com/INBOX").with {
        shouldDeleteMessages = false
        shouldMarkMessagesAsRead = true
        javaMailProperties = javaMailProps
        selectorExpression = new SpelExpressionParser().parseExpression("subject matches '(?i).*Spring Integration.*'")
    }
}

<int-mail:imap-idle-channel-adapter id="customAdapter"
	store-uri="imaps://some_google_address:${password}@imap.gmail.com/INBOX"
	channel="receiveChannel"
	should-mark-messages-as-read="true"
	java-mail-properties="javaMailProperties"
	mail-filter-expression="subject matches '(?i).*Spring Integration.*'"/>

@Bean
TransactionSynchronizationFactory transactionSynchronizationFactory() {
    SpelExpressionParser parser = new SpelExpressionParser();
    ExpressionEvaluatingTransactionSynchronizationProcessor expressionEvaluatingTransactionSynchronizationProcessor =
            new ExpressionEvaluatingTransactionSynchronizationProcessor();
    expressionEvaluatingTransactionSynchronizationProcessor.setAfterCommitExpression(parser.parseExpression("@syncProcessor.process(payload)"));
    return new DefaultTransactionSynchronizationFactory(expressionEvaluatingTransactionSynchronizationProcessor);
}

@Bean
public IntegrationFlow imapIdleFlow(ImapMailReceiver imapMailReceiver, MessageChannel receiveChannel,
    TransactionSynchronizationFactory transactionSynchronizationFactory) {
	return IntegrationFlow
        .from(Mail.imapIdleAdapter(imapMailReceiver)
            .shouldDeleteMessages(false)
            .autoStartup(true)
            .id("imapIdleAdapter")
                .transactionSynchronizationFactory(transactionSynchronizationFactory))
        .channel(receiveChannel)
        .get();
}

@Bean
public Mover syncProcessor() {
    return new Mover();
}

@Bean
fun transactionSynchronizationFactory() =
    DefaultTransactionSynchronizationFactory(ExpressionEvaluatingTransactionSynchronizationProcessor().apply {
        setAfterCommitExpression(SpelExpressionParser().parseExpression("@syncProcessor.process(payload)"))
    })

@Bean
fun imapIdleFlow(receiveChannel: MessageChannel, javaMailProperties: Properties,
    transactionSynchronizationFactory: TransactionSynchronizationFactory) =
    integrationFlow(
        Mail.imapIdleAdapter("imaps://[username]:[password]@imap.gmail.com/INBOX").apply {
            shouldDeleteMessages(false)
            javaMailProperties(javaMailProperties)
            autoStartup(true)
            id("kotlinImapIdleAdapter")
            transactionSynchronizationFactory(transactionSynchronizationFactory)
        }
    ) {
        channel(receiveChannel)
    }

@Bean
fun syncProcessor() =
     Mover()

@Bean
transactionSynchronizationFactory() {
    new DefaultTransactionSynchronizationFactory(
        new ExpressionEvaluatingTransactionSynchronizationProcessor().with {
            afterCommitExpression = new SpelExpressionParser().parseExpression("@syncProcessor.process(payload)")
            it
        }
    )
}

@Bean
imapIdleFlow(MessageChannel receiveChannel, TransactionSynchronizationFactory tranSyncFactory,
    Properties javaMailProps) {
    integrationFlow(
            Mail.imapIdleAdapter("imaps://[username]:[password]@imap.gmail.com/INBOX").with {
                 shouldDeleteMessages false
                 javaMailProperties javaMailProps
                 autoStartup true
                 id 'groovyImapIdleAdapter'
                 transactionSynchronizationFactory tranSyncFactory
            }
    ) {
        channel receiveChannel
    }
}

@Bean
syncProcessor() {
    Mover()
}

<int-mail:imap-idle-channel-adapter id="customAdapter"
    store-uri="imaps://something.com:[email protected] (英語)  /INBOX"
    channel="receiveChannel"
    auto-startup="true"
    should-delete-messages="false"
    java-mail-properties="javaMailProperties">
    <int:transactional synchronization-factory="syncFactory"/>
</int-mail:imap-idle-channel-adapter>

<int:transaction-synchronization-factory id="syncFactory">
    <int:after-commit expression="@syncProcessor.process(payload)"/>
</int:transaction-synchronization-factory>

<bean id="syncProcessor" class="thing1.thing2.Mover"/>