Java FtpStreamingMessageSource-失败时重试

我已经配置了spring与这个bean的集成：

private static final Pattern FILE_PATTERN = Pattern.compile("<pattern>");

@Bean
public SessionFactory<FTPFile> ftpSessionFactory(){
    DefaultFtpSessionFactory factory = new DefaultFtpSessionFactory();
    factory.setHost("localhost");
    factory.setPort(21);
    factory.setUsername("root");
    factory.setPassword("123456");
    factory.setClientMode(FTPClient.PASSIVE_LOCAL_DATA_CONNECTION_MODE);
    return new CachingSessionFactory<>(factory);
}

@Bean
public ConcurrentMetadataStore metadataStore(){
    PropertiesPersistingMetadataStore  store = new PropertiesPersistingMetadataStore();
    store.setFileName("ftpStore.properties");
    return store;
}

@Bean(destroyMethod = "close")
public DataSource selectDataSource(){
    HikariDataSource dataSource = new HikariDataSource();
    dataSource.setJdbcUrl("jdbc:mysql://10.10.10.10:33306/csv");
    dataSource.setUsername("root");
    dataSource.setPassword("123456");
    return dataSource;
}

@Bean
public PlatformTransactionManager transactionManager(){
    return new DataSourceTransactionManager(selectDataSource());
}

@Bean
public TransactionSynchronizationFactory synchronizationFactory(){
    return new DefaultTransactionSynchronizationFactory(new TransactionSynchronizationProcessor() {
        @Override
        public void processBeforeCommit(IntegrationResourceHolder integrationResourceHolder) {
            int x = 22; //???
        }

        @Override
        public void processAfterCommit(IntegrationResourceHolder integrationResourceHolder) {
            int x = 22; //???
        }

        @Override
        public void processAfterRollback(IntegrationResourceHolder integrationResourceHolder) {
            int x = 22; //???
        }
    });
}

@Bean
public PollerMetadata pollerMetadata(PlatformTransactionManager transactionManager){
    PeriodicTrigger trigger = new PeriodicTrigger(5000);
    trigger.setFixedRate(true);

    MatchAlwaysTransactionAttributeSource source = new MatchAlwaysTransactionAttributeSource();
    source.setTransactionAttribute(new DefaultTransactionAttribute());
    TransactionInterceptor interceptor = new TransactionInterceptor(transactionManager, source);

    PollerMetadata metadata = new PollerMetadata();
    metadata.setTrigger(trigger);
    metadata.setTransactionSynchronizationFactory(synchronizationFactory());
    metadata.setAdviceChain(Collections.singletonList(interceptor));
    return metadata;
}

@Bean
@InboundChannelAdapter(channel = "ftpChannel", poller = @Poller("pollerMetadata"))
public MessageSource<InputStream> ftpMessageSource(){
    FtpStreamingMessageSource source = new FtpStreamingMessageSource(new FtpRemoteFileTemplate(ftpSessionFactory()));
    source.setRemoteDirectory("ftp/folder");
    source.setFilter(new CompositeFileListFilter<>(Arrays.asList(
            new FtpRegexPatternFileListFilter(FILE_PATTERN),
            acceptOnceFileListFilter()
    )));
    return source;
}

@Bean
public FtpPersistentAcceptOnceFileListFilter acceptOnceFileListFilter(){
    FtpPersistentAcceptOnceFileListFilter filter = new FtpPersistentAcceptOnceFileListFilter(metadataStore(), "remote");
    filter.setFlushOnUpdate(true);
    return filter;
}

@Bean
@ServiceActivator(inputChannel = "newChannel")
public MessageHandler handler(){
    return new MessageHandler(){
        @Override
        public void handleMessage(Message<?> message) throws MessagingException {
            System.out.println(message.getPayload());
            throw new MessagingException("error");
        }
    };
}

@Bean
public MessageChannel ftpChannel(){
    return new DirectChannel();
}

@Bean
public MessageChannel newChannel(){
    return new DirectChannel();
}

@Bean
public MessageChannel strChannel(){
    return new DirectChannel();
}

@Bean
@Transformer(inputChannel = "ftpChannel", outputChannel = "strChannel")
public org.springframework.integration.transformer.Transformer transformer2(){
    return new StreamTransformer("UTF-8");
}

@Bean
@Transformer(inputChannel = "strChannel", outputChannel = "newChannel")
public UnmarshallingTransformer transformer(){
    UnmarshallingTransformer transformer = new UnmarshallingTransformer(unmarshaller());
    return transformer;
}

@Bean
public Jaxb2Marshaller unmarshaller(){
    Jaxb2Marshaller unmarshaller = new Jaxb2Marshaller();
    unmarshaller.setContextPath("com.generated.xsd");
    return unmarshaller;
}

私有静态最终模式文件\u Pattern=Pattern.compile（“”）；
@豆子
公共会话工厂ftpSessionFactory（）{
DefaultFtpSessionFactory=新的DefaultFtpSessionFactory（）；
setHost（“localhost”）；
工厂设置端口（21）；
factory.setUsername（“根”）；
出厂设置密码（“123456”）；
factory.setClientMode（FTPClient.PASSIVE\u LOCAL\u DATA\u CONNECTION\u MODE）；
返回新的CachingSessionFactory（工厂）；
}
@豆子
公共ConcurrentMetadataStore metadataStore（）{
PropertiesPersistingMetadataStore=新PropertiesPersistingMetadataStore（）；
store.setFileName（“ftpStore.properties”）；
退货店；
}
@Bean（destromethod=“close”）
公共数据源selectDataSource（）{
HikariDataSource dataSource=新的HikariDataSource（）；
setJdbcUrl（“jdbc:mysql://10.10.10.10:33306/csv");
dataSource.setUsername（“根”）；
dataSource.setPassword（“123456”）；
返回数据源；
}
@豆子
公共平台transactionManager transactionManager（）{
返回新的数据源TransactionManager（selectDataSource（））；
}
@豆子
公共事务同步工厂同步工厂（）{
返回新的DefaultTransactionSynchronizationFactory（新TransactionSynchronizationProcessor（））{
@凌驾
提交前的公共无效进程（IntegrationResourceHolder IntegrationResourceHolder）{
int x=22；/？？？
}
@凌驾
public void processAfterCommit（IntegrationResourceHolder IntegrationResourceHolder）{
int x=22；/？？？
}
@凌驾
回滚后的公共无效处理（IntegrationResourceHolder IntegrationResourceHolder）{
int x=22；/？？？
}
});
}
@豆子
公共PollerMetadata PollerMetadata（平台事务管理器事务管理器）{
PeriodicTrigger触发器=新PeriodicTrigger（5000）；
trigger.setFixedRate（true）；
MatchAlwaysTransactionAttributeSource=新的MatchAlwaysTransactionAttributeSource（）；
setTransactionaAttribute（新的DefaultTransactionaAttribute（））；
TransactionInterceptor拦截器=新的TransactionInterceptor（transactionManager，源）；
PollerMetadata=新的PollerMetadata（）；
setTrigger（trigger）；
setTransactionSynchronizationFactory（synchronizationFactory（））；
setAdviceChain（Collections.singletonList（拦截器））；
返回元数据；
}
@豆子
@InboundChannelAdapter（channel=“ftpcchannel”，poller=@poller（“pollerMetadata”））
public MessageSource ftpMessageSource（）{
FtpStreamingMessageSource=新的FtpStreamingMessageSource（新的FtpRemoteFileTemplate（ftpSessionFactory（））；
setRemoteDirectory（“ftp/文件夹”）；
source.setFilter（新的CompositeFileListFilter（Arrays.asList(
新的FTF文件列表过滤器（文件模式），
acceptOnceFileListFilter（）
)));
返回源；
}
@豆子
公共FTPPersistentAcceptonFileListFilter接受CefileListFilter（）{
FtpPersistentAcceptOnceFileListFilter=新的FtpPersistentAcceptOnceFileListFilter（metadataStore（），“remote”）；
filter.setFlushUpdate（true）；
回流过滤器；
}
@豆子
@ServiceActivator（inputChannel=“newChannel”）
public MessageHandler（）{
返回新的MessageHandler（）{
@凌驾
public void handleMessage（消息消息消息）引发MessaginException{
System.out.println（message.getPayload（））；
抛出新的MessaginException（“错误”）；
}
};
}
@豆子
公共消息频道ftpcchannel（）{
返回新的DirectChannel（）；
}
@豆子
public MessageChannel newChannel（）{
返回新的DirectChannel（）；
}
@豆子
公共消息频道strChannel（）{
返回新的DirectChannel（）；
}
@豆子
@变压器（inputChannel=“FTPCChannel”，outputChannel=“strChannel”）
public org.springframework.integration.transformer.transformer transformer2（）{
返回新的StreamTransformer（“UTF-8”）；
}
@豆子
@变压器（inputChannel=“strChannel”，outputChannel=“newChannel”）
公共解组变压器变压器（）{
解组变压器变压器=新的解组变压器（解组变压器（））；
回流变压器；
}
@豆子
公共Jaxb2Marshaller解组器（）{
Jaxb2Marshaller unmarshaller=新的Jaxb2Marshaller（）；
unmarshaller.setContextPath（“com.generated.xsd”）；
返回解组器；
}

---

我的问题是在

上抛出新的MessaginException（“错误”）

，所有ftp文件都保存到

ftpStore.properties

，下次重新加载时（例如，如果JVM失败），将不再处理此文件。如何确保事务已就绪（即如果没有异常文件保存到

ftpStore.properties

，否则不保存）？要从FTP服务器下载文件，是否需要遵循一些教程？

有一个

ResettableFileListFilter

抽象的问题需要处理

事实上，您的

ftppersistentAcceptonFileListFilter

就是这样一个：

如果在同步文件后，处理文件的下游流发生错误，则不会自动回滚筛选器，因此默认情况下不会重新处理失败的文件

如果希望在发生故障后重新处理此类文件，可以使用类似于以下的配置来帮助从筛选器中删除故障文件。这将适用于任何

ResettableFileListFilter

XML配置示例如下所示：

<int:transaction-synchronization-factory id="syncFactory">
    <int:after-rollback expression="@acceptOnceFilter.remove(payload)" />
</int:transaction-synchronization-factory>

因此，您需要分别使用适当的

DefaultTransactionSynchronizationFactory

和

ExpressionEvaluationTransactionSynchronizationProcessor

调整

synchronizationFactory

---

请参阅。

我只是想这样做，但似乎我需要Spel

processor.setAfterRollbackExpress中的FTPFile对象