BlogJava-paulwong-随笔分类-SPRING INTERGRATION

SPRING INTEGRATION - 集群选主、分布式锁

paulwong — Thu, 20 Jan 2022 05:49:00 GMT

集群通常是有多个相同的实例，但对于定时任务场景，只希望有一个实例工作即可，如果这个实例挂了，其他实例可以顶替。

这个问题的方案则是集群选主，一个集群中，只有一个LEADER，由LEADER负责执行定时任务工作。当LEADER被取消时，会在剩下的实例中再选LEADER。

持有分布式锁的实例则是LEADER。

SPRING INTEGRATION JDBC 则已提供相关功能。

pom.xml

  <dependency>
           <groupId>org.springframework.integrationgroupId>
           <artifactId>spring-integration-jdbcartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
        dependency>

        <dependency>
           <groupId>org.flywaydbgroupId>
           <artifactId>flyway-coreartifactId>
        dependency>

        <dependency>
            <groupId>org.mariadb.jdbcgroupId>
            <artifactId>mariadb-java-clientartifactId>
        dependency>

LeaderElectionIntegrationConfig.java

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import javax.sql.DataSource;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.jdbc.lock.DefaultLockRepository;
import org.springframework.integration.jdbc.lock.JdbcLockRegistry;
import org.springframework.integration.jdbc.lock.LockRepository;
import org.springframework.integration.support.leader.LockRegistryLeaderInitiator;

import com.paul.integration.leader.ControlBusGateway;
import com.paul.integration.leader.MyCandidate;

@Configuration
public class LeaderElectionIntegrationConfig {

    @Bean
    public List needToStartupAdapterList(){
        return new CopyOnWriteArrayList<>();
    }

    @Bean
    public DefaultLockRepository defaultLockRepository(DataSource dataSource){
        DefaultLockRepository defaultLockRepository =
                new DefaultLockRepository(dataSource);
//        defaultLockRepository.setTimeToLive(60_000);
        return defaultLockRepository;
    }

    @Bean
    public JdbcLockRegistry jdbcLockRegistry(LockRepository lockRepository){
        return new JdbcLockRegistry(lockRepository);
    }

    @Bean
    public MyCandidate myCandidate(
        ControlBusGateway controlBusGateway,
        List needToStartupAdapterList
    ) {
        return new MyCandidate(controlBusGateway, needToStartupAdapterList);
    }

    @Bean
    public LockRegistryLeaderInitiator leaderInitiator() {
        return new LockRegistryLeaderInitiator(
                    jdbcLockRegistry(null), myCandidate(null, null)
               );
    }


}

MyCandidate.java

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.integration.leader.Context;
import org.springframework.integration.leader.DefaultCandidate;

import com.novacredit.mcra.mcracommon.integration.gateway.ControlBusGateway;

public class MyCandidate extends DefaultCandidate{

    private static final Logger LOG = LoggerFactory.getLogger(MyCandidate.class);

    private List needToStartupAdapterList;

    private ControlBusGateway controlBusGateway;

    public MyCandidate(
        ControlBusGateway controlBusGateway,
        List needToStartupAdapterList
    ) {
        this.controlBusGateway = controlBusGateway;
        this.needToStartupAdapterList = needToStartupAdapterList;
    }

    @Override
    public void onGranted(Context context) {
        super.onGranted(context);
        LOG.info("*** Leadership granted ***");
        LOG.info("STARTING MONGODB POLLER");
        needToStartupAdapterList
            .forEach(
                c -> {
//                    c = "@'testIntegrationFlow.org.springframework.integration.config."
//                            + "SourcePollingChannelAdapterFactoryBean#0'";
                    String command = c + ".start()";
                    LOG.info("-----{}", command);
                    controlBusGateway.sendCommand(command);
                }
             );
        LOG.info("STARTUP MESSAGE SENT");

    }

    @Override
    public void onRevoked(Context context) {
        super.onRevoked(context);
        LOG.info("*** Leadership revoked ***");
        LOG.info("STOPPING MONGODB POLLER");
        needToStartupAdapterList
            .forEach(
                c -> {
//                    c = "@'testIntegrationConfig.testIntegrationFlow."
//                            + "mongoMessageSource.inboundChannelAdapter'";
                    String command = c + ".stop()";
                    LOG.info("-----{}", command);
//                    controlBusGateway.sendCommand(command);
                }
             );
        LOG.info("SHUTDOWN MESSAGE SENT");
    }

}

ControlBusIntegrationConfig.java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.dsl.IntegrationFlow;
import org.springframework.integration.dsl.IntegrationFlows;
import org.springframework.integration.dsl.MessageChannels;
import org.springframework.integration.gateway.GatewayProxyFactoryBean;
import org.springframework.integration.handler.LoggingHandler;
import org.springframework.messaging.MessageChannel;

import com.paul.integration.gateway.ControlBusGateway;

@Configuration
public class ControlBusIntegrationConfig {

    @Bean
    public MessageChannel controlBusChannel() {
        return MessageChannels.direct().get();
    }

    @Bean
    public IntegrationFlow controlBusFlow() {
        return IntegrationFlows.from(controlBusChannel())
                    .log(LoggingHandler.Level.INFO, "controlBusChannel")
                    .controlBus()
                    .get();
    }

    @Bean
    public GatewayProxyFactoryBean controlBusGateway() {
        GatewayProxyFactoryBean gateway = new GatewayProxyFactoryBean(ControlBusGateway.class);
        gateway.setDefaultRequestChannel(controlBusChannel());
        gateway.setDefaultRequestTimeout(300l);
        gateway.setDefaultReplyTimeout(300l);
        return gateway;
    }

}

ControlBusGateway.java

public interface ControlBusGateway {

public void sendCommand(String command);

}

各个应用实例运行时，其中的LockRegistryLeaderInitiator会自动运行，抢夺LEADER数据，最终只有一个实例夺取。之后再执行MyCandidate中的代码。

paulwong 2022-01-20 13:49 发表评论

EVEN DRIVEN - SPRING CLOUD STREAM 3.x - Functional Programming Model

paulwong — Wed, 10 Nov 2021 07:10:00 GMT

SPRING CLOUD STREAM 3.x 版本时，之前的一些编程模式，如@Enablebindding，@StreamListenner等注释被废弃了，这是由于一些框架的代码必需由用户编写，如配置框架用的Input MessageChannel，Output MessageChannel，连接MessageHandler与MessageChannel等，被视为不必要的动作。为了简化用户代码，于是推出Functional Programming Model。

引入了新名词：Supplier、Function与Consumer。实际上这几个类可视为Adapter，如果之前已经有存在的Service类，且方法名为各种各样，可以重新包装成Supplier、Function与Consumer，并在固定的方法名：apply/get/accept中调用Service的方法。

Supplier

当在配置文件中注入此类型的Bean，并在spring.cloud.stream.function.definition加入此Bean的名称，SPRING CLOUD STREAM就会帮你生成一个Output MessageChannel，并连接上此Bean，后续只需要在BINDDING中加入对应的Destination Name，即可向BROKER发消息了。

Consumer

当在配置文件中注入此类型的Bean，并在spring.cloud.stream.function.definition加入此Bean的名称，SPRING CLOUD STREAM就会帮你生成一个Input MessageChannel，并连接上此Bean，后续只需要在BINDDING中加入对应的Destination Name，即可收到BROKER推送关于此Destination的消息了。

Function

当在配置文件中注入此类型的Bean，并在spring.cloud.stream.function.definition加入此Bean的名称，SPRING CLOUD STREAM就会帮你生成一个Input和Output MessageChannel，并连接上此Bean，后续只需要在BINDDING中分别对Input和Output MessageChannel加入对应的Destination Name1/Name2，即可收到BROKER推送关于此Destination的消息，也可以向BROKER发消息了。

与SPRING INTEGRATION的整合

如果要对消息进行复杂处理，如拆分消息、聚合消息、IF ELSE消息等，就要借助SPRING INTEGRATION了。

@Bean
    public IntegrationFlow upperCaseFlow(LoanService loanService) {
        return IntegrationFlows
                    //turn this IntegrationFlow as a gateway, here is a Function interface
                    //with loadCheckerFunction as bean name
                    .from(LoadCheckerFunction.class, gateway -> gateway.beanName("loadCheckerFunction"))
                    .handle(loanService, "check")
                    .logAndReply(LoggingHandler.Level.WARN);
    }

    public interface LoadCheckerFunction extends Function{

    }

IntegrationFlows.from(Class serviceInterface)是可以将本IntegrationFlow包装成serviceInterface的实现类，如果调用此接口，最终会返回IntegrationFlow最后一个步骤的实体，如果这个serviceInterface是Function的话，刚好和SPRING CLOUD STREAM对接上。

后续在spring.cloud.stream.function.definition加入此Bean的名称loadCheckerFunction，SPRING CLOUD STREAM就会帮你生成一个Input和Output MessageChannel，并连接上此Bean，再在BINDDING中分别对Input和Output MessageChannel加入对应的Destination Name1/Name2，即可收到BROKER推送关于此Destination的消息，也可以向BROKER发消息。

application.yaml

# This setting can increase or decrease the rate of message production (1000 = 1s)
# spring.cloud.stream.poller.fixed-delay=1000

# This setting can control which function method in our code will be triggered if there are multiple
# spring.cloud.function.definition=supplyLoan

# Give the autogenerated binding a friendlier name
spring:
   application:
      name: loan-check-rabbit
   banner:
      location: classpath:/banner-rabbit.txt
   cloud:
      stream:
         function.definition: loadCheckerFunction
         #BindingProperties
         bindings:
            loadCheckerFunction-in-0:
               destination: queue.pretty.log.messages
               binder: local_rabbit
            loadCheckerFunction-out-0:
               destination: queue.pretty.approved.messages
               binder: local_rabbit
         #BinderProperties
         binders:
            local_rabbit:
               type: rabbit
               environment:
                  spring:
                     rabbitmq:
                        host: 10.80.27.69
                        port: 5672
                        username: guest
                        password: guest
                        virtual-host: my-virtual-host

Reference

https://spring.io/blog/2019/10/25/spring-cloud-stream-and-spring-integration

paulwong 2021-11-10 15:10 发表评论

SPRING INTEGRATION - ENRICH

paulwong — Tue, 21 Sep 2021 05:40:00 GMT

enrich时可以发起一个子流程，取得结果后再设置回当前的对象中。

package org.springframework.integration.stackoverflow.enricher;

import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpMethod;
import org.springframework.integration.dsl.IntegrationFlow;
import org.springframework.integration.dsl.IntegrationFlows;
import org.springframework.integration.dsl.Transformers;
import org.springframework.integration.http.dsl.Http;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class SpringIntegrationEnricherApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringIntegrationEnricherApplication.class, args);
    }

    @Bean
    public IntegrationFlow jsonEnricherFlow(RestTemplate restTemplate) {
        return IntegrationFlows.from(Function.class)
                .transform(Transformers.fromJson(Map.class))
                .enrich((enricher) -> enricher
                        .>requestPayload((message) ->
                                ((List) message.getPayload().get("attributeIds"))
                                        .stream()
                                        .map(Object::toString)
                                        .collect(Collectors.joining(",")))
                        .requestSubFlow((subFlow) ->
                                subFlow.handle(
                                        Http.outboundGateway("/attributes?id={ids}", restTemplate)
                                                .httpMethod(HttpMethod.GET)
                                                .expectedResponseType(Map.class)
                                                .uriVariable("ids", "payload")))
                        .propertyExpression("attributes", "payload.attributes"))
                ., Map>transform(
                        (payload) -> {
                            payload.remove("attributeIds");
                            return payload;
                        })
                .transform(Transformers.toJson())
                .get();
    }

}

https://stackoverflow.com/questions/58205432/spring-integration-enrich-transform-message-using-rest-call

https://www.tabnine.com/web/assistant/code/rs/5c781b6ae70f87000197ab9f#L312

paulwong 2021-09-21 13:40 发表评论

SPRING INTEGRATION RETRY

paulwong — Mon, 23 Aug 2021 05:01:00 GMT

当使用httpOutBoundGateway时，有时会碰到网络抖动问题而出现连接异常，这时应该有个重试机制，如隔多少秒重试，重试多少次后放弃等。
默认是重试3次，每次重试间隔是20秒。

@SpringBootApplication
public class SpringIntegrationDslHttpRetryApplication {

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext =
                SpringApplication.run(SpringIntegrationDslHttpRetryApplication.class, args);
        Function function = applicationContext.getBean(Function.class);
        function.apply("foo");
    }

    @Bean
    public IntegrationFlow httpRetryFlow() {
        return IntegrationFlows.from(Function.class)
                .handle(Http.outboundGateway("http://localhost:11111")
                                .httpMethod(HttpMethod.GET)
                                .expectedResponseType(String.class),
                        e -> e.advice(retryAdvice()))
                .get();
    }

    @Bean
    public RequestHandlerRetryAdvice retryAdvice() {
        return new RequestHandlerRetryAdvice();
    }

}

#打印日志
logging.level.org.springframework.retry=debug

Reference:
https://docs.spring.io/spring-integration/reference/html/handler-advice.html#retry-advice
https://stackoverflow.com/questions/49784360/configure-error-handling-and-retry-for-http-outboundgateway-spring-dsl
https://stackoverflow.com/questions/50262862/requesthandlerretryadvice-with-httprequestexecutingmessagehandler-not-working
https://stackoverflow.com/questions/63689856/spring-integration-http-outbound-gateway-retry-based-on-reply-content
https://blog.csdn.net/cunfen8879/article/details/112552420

paulwong 2021-08-23 13:01 发表评论

JSR-303 Bean Validation

paulwong — Thu, 28 Jan 2021 02:35:00 GMT

接收数据的JAVA BEAN通常需要验证其中字段的正确性，如不准为空，符合EMAIL格式等。

JSR-303 Bean Validation则提供了这样的便捷。

只要在JAVA BEAN中需要验证的字段加@NotNull这种标签，然后在SERVISE中的输入参数中加@Valid标签，则就激活验证流程。
也可以编程的方式自己验证：

@MessageEndpoint
//@Validated
public class MqMessageCcdValidator {

    private static final Logger LOGGER = LoggerFactory.getLogger(MqMessageCcdValidator.class);

    @Autowired
    private Validator validator;

    @ServiceActivator
    public MqMessage validate(/* @Valid */ Message> requestMessage) {
        Set>> set = validator.validate(requestMessage.getPayload());
        if(CollectionUtils.isNotEmpty(set)) {
            CompositeException compositeException = new CompositeException();
            set.forEach(
                constraintViolation -> {
                                            LOGGER.info("{}", constraintViolation);
                                            ReqInfoValidationException exception =
                                                    new ReqInfoValidationException(constraintViolation.getMessage());
                                            compositeException.addException(exception);
                                       }
            );
            throw new MessageHandlingException(requestMessage, compositeException);
        }

        return requestMessage.getPayload();
    }

}

自定义验证规则
可用标签来做，以下为验证手机号的规则：

import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.ReportAsSingleViolation;
import javax.validation.constraints.Pattern;

@Retention(RUNTIME)
@Target(value = { ElementType.FIELD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE })
@Constraint(validatedBy = {})
@ReportAsSingleViolation
@Pattern(regexp = "^1[3-9]\\d{9}$")
public @interface ChinaPhone {
    String message() default "Invalid Chinese mobile No.";
    Class[] groups() default {};
    Classextends Payload>[] payload() default {};
}

如果比较复杂的验证规则，则参见：
https://reflectoring.io/bean-validation-with-spring-boot/#implementing-a-custom-validator

How to use Java Bean Validation in Spring Boot
https://nullbeans.com/how-to-use-java-bean-validation-in-spring-boot/

Complete Guide to Validation With Spring Boot
https://reflectoring.io/bean-validation-with-spring-boot/

Spring JMS Validate Messages using JSR-303 Bean Validation
https://memorynotfound.com/spring-jms-validate-messages-jsr-303-bean-validation/

Spring REST Validation Example
https://mkyong.com/spring-boot/spring-rest-validation-example/

Spring Boot 整合 Bean Validation 校验数据

https://blog.csdn.net/wangzhihao1994/article/details/108403732

paulwong 2021-01-28 10:35 发表评论

SPRING INTEGRATION SCATTERGATHER

paulwong — Thu, 28 Jan 2021 02:11:00 GMT

场景，餐厅：

食客下单，有饮品、食物、甜点
侍应接单，传送给厨房
厨房分三个子流程处理，即饮品、食物、甜点子流程
等待三个子流程处理完，合并成一份交付
如果厨房发现某食物欠缺，会通知侍应，展开错误处理，即通知食客更改食物，再交给厨房
侍应将交付品传送给食客

有一个主流程、三个子流程和一个聚合流程，聚合流程会聚合三个子流程的产物，通知主流程，再往下走。
并且主流程会感知子流程的错误，并会交给相应错误处理流程处理，且将结果再交给聚合流程。

对应SPRING INTEGRATION 的SCATTERGATHER模式：

@Bean
public IntegrationFlow scatterGatherAndExecutorChannelSubFlow(TaskExecutor taskExecutor) {
    return f -> f
            .scatterGather(
                    scatterer -> scatterer
                            .applySequence(true)
                            .recipientFlow(f1 -> f1.transform(p -> "Sub-flow#1"))
                            .recipientFlow(f2 -> f2
                                    .channel(c -> c.executor(taskExecutor))
                                    .transform(p -> {
                                        throw new RuntimeException("Sub-flow#2");
                                    })),
                    null,
                    s -> s.errorChannel("scatterGatherErrorChannel"));
}

@ServiceActivator(inputChannel = "scatterGatherErrorChannel")
public Message processAsyncScatterError(MessagingException payload) {
    return MessageBuilder.withPayload(payload.getCause().getCause())
            .copyHeaders(payload.getFailedMessage().getHeaders())
            .build();
}

https://github.com/adnanmamajiwala/spring-integration-sample/tree/master/dsl-scatter-gather/src/main/java/com/si/dsl/scattergather

https://docs.spring.io/spring-integration/docs/5.1.x/reference/html/#scatter-gather

paulwong 2021-01-28 10:11 发表评论

SPRING INTEGRATION HEADER问题

paulwong — Tue, 20 Oct 2020 06:56:00 GMT

当SPRING INTEGRATION的流程中从HTTP outboundGateway转成JmsGateway时，会报header的错误，这时就要把相关多余的header移除。

.headerFilter("Api-Key", "Content-Type", "X-Powered-By", "Content-Language", "Transfer-Encoding", "Cache-Control", "Keep-Alive", "Set-Cookie")

https://stackoverflow.com/questions/50608415/cwsia0112e-the-property-name-keep-alive-is-not-a-valid-java-identifier

paulwong 2020-10-20 14:56 发表评论

Error handling in spring integration - How to get all the errors thrown in multiple threads and send them to the error-channel

paulwong — Thu, 15 Oct 2020 11:21:00 GMT

在SPRING INTEGRATION中，如果exception发生在各种thread里时，如何将exception返回到指定的channel，之后再绕回到aggrator-channel中。

@Bean
public IntegrationFlow provisionUserFlow() {
return
    IntegrationFlows.from("input.channel")
    .publishSubscribeChannel(Executors.newCachedThreadPool(),
        s -> s.applySequence(true)
            .subscribe(f -> f.enrichHeaders(e -> e.header(MessageHeaders.ERROR_CHANNEL, "errorChannel", true))
                .handle(provisionerA, "provision")
                .channel("aggregatorChannel")
            )
            .subscribe(f -> f.enrichHeaders(e -> e.header(MessageHeaders.ERROR_CHANNEL, "errorChannel", true))
                .handle(provisionerB, "provision")
                .channel("aggregatorChannel"))
            )
        .get();
}

@Bean
public IntegrationFlow aggregateFlow() {
  return IntegrationFlows.from("aggregatorChannel")
                    .channel( aggregatorChannel)
                    .aggregate( a -> a.processor( collect, "aggregatingMethod"))
                    .get();
}

@Transformer( inputChannel = "errorChannel", outputChannel = "aggregatorChannel")
public Message errorChannelHandler(ErrorMessage errorMessage) throws RuntimeException {

    Message failedMessage =  ((MessagingException) errorMessage.getPayload()).getFailedMessage();

    Exception exception = (Exception) errorMessage.getPayload();

  return  MessageBuilder.withPayload( exception.getMessage())
                                       .copyHeadersIfAbsent( failedMessage.getHeaders() )
                                       .build();
}

https://stackoverflow.com/q/46495127/11790720

paulwong 2020-10-15 19:21 发表评论

SPRING INTEGRATION子FLOW

paulwong — Thu, 15 Oct 2020 03:29:00 GMT

split-route-aggregate flow
split之后，可以将message分给不同的子flow处理，配置如下：

@Bean
public IntegrationFlow parallelSplitRouteAggregateFlow() {
    return IntegrationFlows
            .from(Http.inboundGateway("/trigger"))
            .handle((p, h) -> Arrays.asList(1, 2, 3))
            .split()
            .channel(MessageChannels.executor(Executors.newCachedThreadPool()))
            .route(o -> o % 2 == 0, m -> m
                    .subFlowMapping(true, sf -> sf.gateway(oddFlow()))
                    .subFlowMapping(false, sf -> sf.gateway(evenFlow())))
            .aggregate()
            .get();
}

@Bean
public IntegrationFlow oddFlow() {
    return flow -> flow.handle((payload, headers) -> "odd");
}

@Bean
public IntegrationFlow evenFlow() {
    return flow -> flow.handle((payload, headers) -> "even");
}

https://stackoverflow.com/questions/50121384/spring-integration-parallel-split-route-aggregate-flow-fails-due-to-one-way-mess

paulwong 2020-10-15 11:29 发表评论

SPRING INTEGRATION ERROR HANDLING

paulwong — Fri, 10 Jan 2020 07:32:00 GMT

https://github.com/zakyalvan/spring-integration-java-dsl-learn

package com.jwebs.learn.errorhandling;

import java.util.Random;

import javax.jms.ConnectionFactory;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.integration.channel.PublishSubscribeChannel;
import org.springframework.integration.core.MessageSource;
import org.springframework.integration.dsl.IntegrationFlow;
import org.springframework.integration.dsl.IntegrationFlows;
import org.springframework.integration.dsl.core.Pollers;
import org.springframework.integration.dsl.jms.Jms;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.MessagingException;

/**
* Show how to handle error in spring integration flow.
* Please note, errorChannel in spring integration only applicable to
* error thrown in asynch component.
*
* @author zakyalvan
*/
@SpringBootApplication
@IntegrationComponentScan
public class ErrorHandlingApplication {
    public static void main(String[] args) throws Exception {
        ConfigurableApplicationContext applicationContext = new SpringApplicationBuilder(ErrorHandlingApplication.class)
                .web(false)
                .run(args);

        Runtime.getRuntime().addShutdownHook(new Thread(() -> applicationContext.close()));

        System.out.println("Pres enter key to exit");
        System.in.read();
        System.exit(0);
    }

    @Autowired
    private ConnectionFactory connectionFactory;

    @Bean
    public MessageSource randomIntegerMessageSource() {
        return () -> MessageBuilder.withPayload(new Random().nextInt()).build();
    }

    @Bean
    public IntegrationFlow withErrorFlow() {
        return IntegrationFlows.from(randomIntegerMessageSource(), spec -> spec.poller(Pollers.fixedDelay(1000)))
                    .handle(Jms.outboundGateway(connectionFactory)
                    .requestDestination("processor.input")
                    .replyContainer(spec -> spec.sessionTransacted(true)))
                    .get();
    }

    @Autowired
    @Qualifier("errorChannel")
    private PublishSubscribeChannel errorChannel;

    @Bean
    public IntegrationFlow errorHandlingFlow() {
        return IntegrationFlows.from(errorChannel)
                .handle(message -> System.out.println("@@@@@@@@@@@@@@@@@@@@@" + ((MessagingException) message.getPayload()).getFailedMessage().getPayload()))
                .get();
    }
}

paulwong 2020-01-10 15:32 发表评论

EIP in SPRING INTEGRATION

paulwong — Fri, 25 Oct 2019 03:03:00 GMT

idempotent receiver

幂等型，同一个MESSAGE，如MESSAGE ID都一样，在MESSAGING系统中不管运行多少次，结果都一样，为啥？因为重复的MESSAGE，都被忽略了。
方案：
消息被处理后，从消息中取出ID，放入META-DATA-STORE中，后续处理消息时，要从META-DATA-STORE中检查是否有值。

下面这个方案，ID的存储和判断是否重复消息都在一个INTERCEPTOR中搞定。
https://stackoverflow.com/questions/50401460/spring-integration-dsl-configure-idempotent-receiver-to-identify-duplicates
https://www.javacodegeeks.com/2015/09/monitoring-and-management.html

claim-check
将MESSAGE的PAYLOAD存在STORE中，返回一个ID，这个ID即claim-check，如果需要取MESSAGE的DETAIl时，可从STORE中取出MESSAGE。
https://github.com/spring-projects/spring-integration/blob/master/src/reference/asciidoc/claim-check.adoc

paulwong 2019-10-25 11:03 发表评论

SPRING INTEGRATION LESSONS

paulwong — Fri, 25 Oct 2019 01:45:00 GMT

Lessons

Introduction to Enterprise Application Integration

In our first lesson, you will get introduced to the concepts of Enterprise Application Integration. You will learn about the and Enterprise integration patterns that can be applied to simplify integration between different platforms and the Integration strategies that can be followed for this purpose. Finally, we will discuss how and why to implement a Message driven architecture and how to achieve both Synchronous and asynchronous communication among nodes.

Spring Integration Fundamentals

In this lesson, you will get to understand how Spring Integration works under the hood. The core concepts of Spring Integration messaging system (like message channels and endpoints) will be introduced. Additionally, the components that build the framework will be discussed, including the channel adapters, transformers, filters, routers etc. Finally, the two distinct methods of communication (synchronous and asynchronous) are explained and the lesson ends with a discussion on error handling.

Spring Integration and Web Services

In this lesson, we will focus on the integration with external web services. Spring Integration comes with the necessary functionality (adapters, channels etc.) to support web services out of the box. A full example is built from scratch in order to better understand the topic.

Enterprise Messaging

In this lesson, we will focus on integrating our application with JMS messaging. For this purpose, we will use Active MQ, which will be our broker. We will show examples of sending and receiving JMS messages by using the Spring Integration JMS channel adapters. Following these examples, we will see some ways of customizing these invocations by configuring message conversion and destination resolution.

Spring Integration Full Example

In this lesson, we will wrap everything up by providing a complete application that uses several of the components provided by Spring Integration in order to provide a service to its users. We will discuss the system architecture, the actual implementation and the relevant error handling.

Monitoring and Management

In this lesson, we will examine different mechanisms of monitoring or gathering more information about what is going on within the messaging system. Some of these mechanisms consist of managing or monitoring the application through MBeans, which are part of the JMX specification. Another mechanism discussed in this chapter is how we will implement the EIP idempotent receiver pattern using a metadata store. Finally, the last mechanism described is the control bus. This will let us send messages that will invoke operations on components in the application context.

paulwong 2019-10-25 09:45 发表评论

SPRING INTEGRATION DSL DEMO

paulwong — Wed, 23 Oct 2019 03:55:00 GMT

https://github.com/spring-projects/spring-integration/tree/master/src/reference/asciidoc

paulwong 2019-10-23 11:55 发表评论

Spring Integration 中文手册 - GOOD

paulwong — Fri, 11 Oct 2019 02:28:00 GMT

Spring Integration 中文手册 (1)

Spring Integration 中文手册 (2)

paulwong 2019-10-11 10:28 发表评论

在SPRING INTEGRATION中手动开始和停止JMS LISTENER

paulwong — Wed, 09 Oct 2019 09:16:00 GMT

如果要对JMS BROKER生产和消费MESSAGE，一种方式是用JmsTemplate发送和消费消息，另一种方式是SPRING INTEGRATION。

SPRING INTEGRATION是实现了EIP模式的一种框架，即使用CHANNEL和JMS-INBOUND-ADAPTER、JMS-OUTBOUND-ADAPTER，完全脱离了JmsTemplate的API。

如果需要实现这种场景：从BROKER取一条消息，处理消息，且处理途中不要再从BROKER再取消息，处理完后再取消息，再处理。

这样要求手动开始和停止JMS LISTENER，即手动开始和停止JMS-INBOUND-ADAPTER、JMS-OUTBOUND-ADAPTER。

@Bean
@InboundChannelAdapter(value = "loaderResponseChannel")
public MessageSource loaderResponseSource() throws Exception {
    return Jms
            .inboundAdapter(oracleConnectionFactory())
            .configureJmsTemplate(
                    t -> t.deliveryPersistent(true)
                            .jmsMessageConverter(jacksonJmsMessageConverter())
            ).destination(jmsInbound).get();
}

当使用@InboundChannelAdapter时，会自动注册一个SourcePollingChannelAdapter ，但这个名字比较长：configrationName.loaderResponseSource.inboundChannelAdapter。

呼叫这个实例的start()和stop()方法即可。

@Bean
public IntegrationFlow controlBusFlow() {
    return IntegrationFlows.from("controlBus")
              .controlBus()
              .get();
}

Message operation = MessageBuilder.withPayload("@configrationName.loaderResponseSource.inboundChannelAdapter.start()").build();
operationChannel.send(operation)

https://stackoverflow.com/questions/45632469/shutdown-spring-integration-with-jms-inboundadapter

https://docs.spring.io/spring-integration/docs/5.0.7.RELEASE/reference/html/system-management-chapter.html#control-bus

https://github.com/spring-projects/spring-integration-java-dsl/blob/master/src/test/java/org/springframework/integration/dsl/test/jms/JmsTests.java

https://stackoverflow.com/questions/50428552/how-to-stop-or-suspend-polling-after-batch-job-fail

paulwong 2019-10-09 17:16 发表评论

Enterprise Integration Patterns

paulwong — Thu, 18 Jul 2019 06:11:00 GMT

Why Enterprise Integration Patterns?

Enterprise integration is too complex to be solved with a simple 'cookbook' approach. Instead, patterns can provide guidance by documenting the kind of experience that usually lives only in architects' heads: they are accepted solutions to recurring problems within a given context. Patterns are abstract enough to apply to most integration technologies, but specific enough to provide hands-on guidance to designers and architects. Patterns also provide a vocabulary for developers to efficiently describe their solution.

Patterns are not 'invented'; they are harvested from repeated use in practice. If you have built integration solutions, it is likely that you have used some of these patterns, maybe in slight variations and maybe calling them by a different name. The purpose of this site is not to "invent" new approaches, but to present a coherent collection of relevant and proven patterns, which in total form an integration pattern language.

Despite the 700+ pages, our book covers only a fraction of patterns (and the problems to be solved) in the integration space. The current patterns focus on Messaging, which forms the basis of most other integration patterns. We have started to harvest more patterns but are realizing (once again) how much work documenting these patterns really is. So please stay tuned.

Messaging Patterns

We have documented 65 messaging patterns, organized as follows:

Correlation Identifier

Composed Msg. Processor

Message
Transformation

Event-driven Consumer

Point-to-Point Channel

Publish-Subscr. Channel

Datatype Channel

Invalid Message Channel

https://www.enterpriseintegrationpatterns.com/patterns/messaging/index.html

paulwong 2019-07-18 14:11 发表评论

SPRING BATCH & SPRING INTEGRATION TUTORIAL

paulwong — Thu, 18 Jul 2019 05:21:00 GMT

Spring JMS Integration Gateway Example 12 minute read

A detailed step-by-step tutorial on how to connect to a JMS broker using a Spring Integration Gateway and Spring Boot.

Spring JMS Artemis Example 6 minute read

A detailed step-by-step tutorial on how to connect to Apache ActiveMQ Artemis using Spring JMS and Spring Boot.

Spring JMS Topic Example 5 minute read

A detailed step-by-step tutorial on how to publish/subscribe to a JMS topic using Spring JMS and Spring Boot.

Spring JMS Integration Example12 minute read

A detailed step-by-step tutorial on how to connect to an ActiveMQ JMS broker using Spring Integration and Spring Boot.

Spring JMS Listener Example 7 minute read

A detailed step-by-step tutorial on how a Spring JMS listener works in combination with Spring Boot.

Spring JMS JmsTemplate Example 7 minute read

A detailed step-by-step tutorial on how to use JmsTemplate in combination with Spring JMS and Spring Boot.

Spring JMS Message Selector Example 5 minute read

A detailed step-by-step tutorial on how to implement a message selector using Spring JMS and Spring Boot.

Spring JMS Message Converter Example5 minute read

A detailed step-by-step tutorial on how to implement a message converter using Spring JMS and Spring Boot.

Spring Batch Admin Example 11 minute read

A detailed step-by-step tutorial on how to use a Spring Boot admin UI to manage Spring Batch jobs.

Spring Batch Tasklet Example 7 minute read

A detailed step-by-step tutorial on how to implement a Spring Batch Tasklet using Spring Boot.

Spring Batch Example 11 minute read

A detailed step-by-step tutorial on how to implement a Hello World Spring Batch job using Spring Boot.

paulwong 2019-07-18 13:21 发表评论

Spring Integration Java DSL

paulwong — Thu, 18 Jul 2019 05:16:00 GMT

This time I decided to play a little bit with Spring Integration Java DSL. Which has been merged directly into Spring Integration Core 5.0, which is smart and obvious move because:

Everyone starting the new Spring projects based on Java Config uses that
SI Java DSL enables you to use new powerfull Java 8 features like Lambdas
You can build your flow using the Builder pattern based on IntegrationFlowBuilder

Let's take a look on the samples howto use that based on ActiveMQ JMS.

https://bitbucket.org/tomask79/spring-integration-java-dsl/src/master/

paulwong 2019-07-18 13:16 发表评论

Message Processing With Spring Integration

paulwong — Wed, 05 Jun 2019 03:08:00 GMT

Full demo
https://dzone.com/articles/message-processing-spring

paulwong 2019-06-05 11:08 发表评论

Spring integration 基本概念

paulwong — Wed, 05 Jun 2019 02:36:00 GMT

1.spring integration 's architecture

主要提供两个功能：

在系统内提供实现轻量级、事件驱动交互行为的框架

在系统间提供一种基于适配器的平台，以支持灵活的系统间交互

2.spring integration对于企业集成模式的支持

2.1Message：一个信息的单元，通常有消息头（header）和消息内容（payload）组成

2.2Message channel：消息处理节点之间的连接，负责将Message从生产者传输到消费者。

根据消费者的多少，可分为point to point和publish-subscribe两种

根据消息传输方式的不同，分为同步和异步两种

2.3Message Endpoint：消息处理节点，消息从节点进入通道，也是从节点离开通道

几个常见的Message EndPoint：

CHANNEL ADAPTER，用于连接该适配器的特点是单向消息流的，要么是消息通过该适配器进入通道，要么是消息通过该适配器离开通道

MESSAGING GATEWAY，处理的消息流和Channel Adapter不同，不是单向的，即有进入该节点的消息，也会从该节点发出消息。

SERVICE ACTIVATOR，该节点调用服务来处理输入的消息，并将服务返回的数据发送到输出通道。在spring integration中，调用的方法被限定为本地方法调用。

ROUTER，路由器，将输入的消息路由到某个输出通道中

SPLITTER，将输入的消息拆分成子消息

AGGREGATOR，将输入的多个消息合并为一个消息

3.观看书中例子hello-world思考

测试gateway时，下面代码向通道names内放入消息world？

然后service-activator从names通道中获得消息world，调用方法sayHello返回值到给gateway？

解释：gateway有一个service－interface的属性，这个属性指向一个interface。当我们用一个接口声明一个gateway时，spring integration会自动帮我们生成该接口的代理类，这样当我们往gateway发送消息时，spring integration会通过代理类把消息转发到default－request－channel中去

作者：马国标
链接：https://www.jianshu.com/p/bf1643539f99
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

paulwong 2019-06-05 10:36 发表评论

如何在SPRING INTEGRATION中使用事务

paulwong — Tue, 04 Jun 2019 06:19:00 GMT

File Polling using the Spring Integration DSL

http://porterhead.blogspot.com/2016/07/file-polling-using-spring-integration.html

https://github.com/iainporter/spring-file-poller

Transaction Support in Spring Integration
https://www.baeldung.com/spring-integration-transaction

paulwong 2019-06-04 14:19 发表评论

用JAMES实现自己的邮件服务器

paulwong — Sun, 16 Dec 2012 05:14:00 GMT

应用服务器Apache企业应用XMLC
简介
James 是一个企业级的邮件服务器，它完全实现了smtp 和 pops 以及nntp 协议。同时，james服务器又是一个邮件应用程序平台。James的核心是Mailet API,而james 服务齐是一个mailet的容器。它可以让你非常容易的实现出很强大的邮件应用程序。James开源项目被广泛的应用于与邮件有关的项目中。你可以通过它来搭建自己的邮件服务器。我们可以利用Mailet API,编程接口来实现自己所需的业务。James集成了Avalon 应用程序框架以及Phoenix Avalon 框架容器。Phoenix为james 服务器提供了强大的支持。需要说明的是Avalon开源项目目前已经关闭。
快速上手
安装james
我这次使用的安装包是james 2.3.1。大家可以从这里下载到http://james.apache.org/download.cgi
现在让我们开始我们激动人心的james之旅。首先我们将james-binary-2.3.1.zip解压缩下载到你的安装目录。我们可以把这个过程理解为安装的过程。我在这里将它解压到c:\.并且把它改名为james.这样我们的james就安装好了。目录为C:\james。很简单吧！

准备知识－学习一些必要的知识
在我使用james的时候让我感觉首先理解james的应用程序结构是很重要的。否则你会在使用中感到很困惑。
它的应用程序结构是这样的：
James
|_ _apps
|_ _bin
|_ _conf
|_ _ext
|_ _lib
|_ _logs
|_ _tools
我们重点介绍一下两个文件夹bin 和 apps.
bin目录中的run.bat和run.sh是James的启动程序。只要记住这个重要文件就可以。
启动之后控制台显示如下：
Using PHOENIX_HOME: C:\james
Using PHOENIX_TMPDIR: C:\james\temp
Using JAVA_HOME: C:\j2sdk1.4.2_02
Phoenix 4.2
James Mail Server 2.3.1
Remote Manager Service started plain:4555
POP3 Service started plain:110
SMTP Service started plain:25
NNTP Service started plain:119
FetchMail Disabled
Apps 目录下有个james的子目录这个目录是它的核心。
james
|_ _SAR-INF
|_ _conf
|_ _logs
|_ _var
|_mail
|_address-error
|_error
|_indexes
|_outgoing
|_relay-denied
|_spam
|_spool
|_nntp
|_....
…
|_users
SAR-INF 下有一个config.xml是james中的核心配置文件。
Logs 包含了与james有关的Log。调试全靠它了。
Var 包含了一些文件夹通过它们的名字我们大概也能猜测出它们的用途。Mail主要用于存储邮件。nntp主要用于新闻服务器。Users用于存储所有邮件服务器的用户。也就是邮件地址前面的东东。如：pig@sina.com的pig就是所谓用用户。

创建用户：
我们在James上建若干用户，用来测试收发邮件。当然如果你不用james本身的用户也可以。James以telnet 的方式提供了接口用来添加用户。下面我来演示一下。
首先使用telnet来连接james的remote manager .
1.telnet localhost 4555 回车
2.然后输入管理员用户名和密码（user/pwd ： root/root 是默认设置这个可以在config.xml中修改）
JAMES Remote Administration Tool 2.3.1
Please enter your login and password
Login id:
root
Password:
root
Welcome root. HELP for a list of commands

3.添加用户
adduser kakaxi kakaxi
User kakaxi added

Adduser mingren mingren
User mingren added

4.查看添加情况
listusers
Existing accounts 2
user: mingren
user: kakaxi
得到上面的信息说明我们已经添加成功。

发送器
这个类主要用来测试我们的邮件服务器，可以不用将其打入包中。
java 代码

package com.paul.jamesstudy;

import java.util.Date;
import java.util.Properties;

import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

public class Mail {
    private String mailServer, From, To, mailSubject, MailContent;

    private String username, password;

    private Session mailSession;

    private Properties prop;

    private Message message;

    // Authenticator auth;//认证
    public Mail() {
        // 设置邮件相关
        username = "kakaxi";
        password = "kakaxi";
        mailServer = "localhost";
        From = "kakaxi@localhost";
        To = "mingren@localhost";
        mailSubject = "Hello Scientist";
        MailContent = "How are you today!";
    }
    public void send(){
        EmailAuthenticator mailauth =
new EmailAuthenticator(username, password);
        // 设置邮件服务器
        prop = System.getProperties();
        prop.put("mail.smtp.auth", "true");
        prop.put("mail.smtp.host", mailServer);
        // 产生新的Session服务
        mailSession = mailSession.getDefaultInstance(prop,
                (Authenticator) mailauth);
        message = new MimeMessage(mailSession);

        try {
        message.setFrom(new InternetAddress(From)); // 设置发件人
        message.setRecipient(Message.RecipientType.TO,
new InternetAddress(To));// 设置收件人
        message.setSubject(mailSubject);// 设置主题
        message.setContent(MailContent, "text/plain");// 设置内容
        message.setSentDate(new Date());// 设置日期
        Transport tran = mailSession.getTransport("smtp");
        tran.connect(mailServer, username, password);
        tran.send(message, message.getAllRecipients());
        tran.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Mail mail;
        mail = new Mail();
        System.out.println("sending");
        mail.send();
        System.out.println("finished!");
    }

}

class EmailAuthenticator extends Authenticator {
    private String m_username = null;

    private String m_userpass = null;

    void setUsername(String username) {
        m_username = username;
    }

    void setUserpass(String userpass) {
        m_userpass = userpass;
    }

    public EmailAuthenticator(String username, String userpass) {
        super();
        setUsername(username);
        setUserpass(userpass);
    }

    public PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication(m_username, m_userpass);
    }
}

paulwong 2012-12-16 13:14 发表评论

SRING INTEGRATION + BATCH

paulwong — Sun, 21 Oct 2012 09:23:00 GMT

摘要: 场景：由SPRING INTEGRATION每10秒监控数据库中的POLL表，如果有符合条件的记录，则启动JDBC JOB，此JOB要做的也是和数据库交互的动作，如用JDBCITEMREADER读取数据库记录，用JDBCITEMWRITER写记录进数据库。 SPRING INTEGRATION与SPRING BATCH JOB交互的点是JOBPARAMETERS，即以KEY-V... 阅读全文

paulwong 2012-10-21 17:23 发表评论

spring integration同步数据库数据

paulwong — Wed, 17 Oct 2012 03:50:00 GMT

摘要: 需求为：当客户已有系统的数据被同步到我方数据库后，若再有新数据，只同步新数据到我方数据库。解决：因为客户的业务表是不能变动的，我方在客户数据库中新建一状态表，记录哪些数据被更新过。当客户业务表有新数据插入时，用触发器将新数据id插入到状态表。为方便实例：业务表pp，状态表status结构为：pp： Code highlighting produced by Actipro CodeHighli... 阅读全文

paulwong 2012-10-17 11:50 发表评论

SPRING INTEGRATION + SPRING BATCH

paulwong — Mon, 15 Oct 2012 16:11:00 GMT

摘要: SPRING INTEGRATION的强项是事件驱动，但捕获之后，要做的事是触发一个类的方法，对于要处理大数据量的文件，就没有办法了，如读取1w条记录，然后插入数据库。而这个正是SPRING BATCH的强项所在，因此有必要将此两个框架整合起来用。场景：盯着一个文件夹，如果一有文件，此文件可能非常大的，则启动一个BATCH JOB来处理。文件拉取器，监控文件夹一有新... 阅读全文

paulwong 2012-10-16 00:11 发表评论

SPRING INTERGRATION资源

paulwong — Mon, 11 Jun 2012 02:07:00 GMT

http://wangleifire.iteye.com/blog/351749

https://src.springframework.org/svn/spring-integration/trunk

paulwong 2012-06-11 10:07 发表评论

SPRING INTERGRATION

paulwong — Mon, 11 Jun 2012 02:04:00 GMT

将处理业务的流程拆分成一个一个链，前面处理完，再派给下一个，类似HTTP中的FILTER
不用安装服务器，内嵌在SPRING容器中，对外支持多种格式的数据，外部系统如要和SPRING INTERGRATION整合，不需要再进行开发
处理流程一般就是，ADAPTER去读取外部数据，转换后放到CHANNEL中，ENDPOINT处理CHANNEL中的数据，委派给下一个CHANNEL，下一个ENDPOINT处理，通过ADAPTER写到外部接口中。

ADAPTER
外部系统与CHANNEL之间的桥梁，获取外部数据将其放到CHANNEL去，有FTP，JMS，文件系统的
CHANNEL
里面放MESSAGE对象，MESSAGE里面可以放自定义对象，以提供消费者使用
ENDPOINT
CHANNEL的消费者，CHANNEL与ENDPOINT是一对一的关系，所以如果想在一个CHANNE下对应多个ENDPOINT，是做不到的，只能增加CHANNEL

Service Activators：从INPUT CHANNEL中取出一个对象作为参数，调用设置的POJO的方法，将结果放到OUTPUT CHANNEL中
Transformers：对CHANNEL中的对象进行类型转换
决定流向的ENDPOINT：Routers，SPLITER
例子

xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/integration"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:beans="http://www.springframework.org/schema/beans"
    xmlns:stream="http://www.springframework.org/schema/integration/stream"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/integration
            http://www.springframework.org/schema/integration/spring-integration.xsd
            http://www.springframework.org/schema/integration/stream
            http://www.springframework.org/schema/integration/stream/spring-integration-stream.xsd">

    <gateway id="cafe" service-interface="org.springframework.integration.samples.cafe.Cafe"/>

    <channel id="orders"/>

    <splitter input-channel="orders" expression="payload.items" output-channel="drinks"/>

    <channel id="drinks"/>

    <router input-channel="drinks"  expression="payload.iced ? 'coldDrinks' : 'hotDrinks'"/>

    <channel id="coldDrinks">
        <queue capacity="10"/>
    channel>
    <service-activator input-channel="coldDrinks" ref="barista" method="prepareColdDrink" output-channel="preparedDrinks"/>

    <channel id="hotDrinks">
        <queue capacity="10"/>
    channel>

    <service-activator input-channel="hotDrinks" ref="barista" method="prepareHotDrink" output-channel="preparedDrinks"/>

    <channel id="preparedDrinks"/>

    <aggregator input-channel="preparedDrinks"  method="prepareDelivery" output-channel="deliveries">
        <beans:bean class="org.springframework.integration.samples.cafe.xml.Waiter"/>
    aggregator>

    <stream:stdout-channel-adapter id="deliveries"/>

    <beans:bean id="barista" class="org.springframework.integration.samples.cafe.xml.Barista"/>

    <poller id="poller" default="true" fixed-delay="1000"/>

beans:beans>

paulwong 2012-06-11 10:04 发表评论