How do I determine if I need to annotate with @Bean

How do I determine in spring integration, that I need to annotate with @Bean?

For example lets look at a @Transformer annotation.

Consider the following code snippets:

1.

    @AllArgsConstructor
    @Getter
    @Setter
    @ToString
    private static class Person {
        private String firstName;
        private String lastName;
        private String phone;
    }

    @Override
    public void run(ApplicationArguments args) {
        firstChannel.send(MessageBuilder.withPayload(new Person("s", "f", null)).build());
    }

    // without bean
    @Transformer(inputChannel = FIRST_CHANNEL, outputChannel = SECOND_CHANNEL)
    public ContentEnricher contentEnricher() {
        ContentEnricher contentEnricher = new ContentEnricher();
        contentEnricher.setPropertyExpressions(ImmutableMap.of("phone", new ValueExpression("123")));
        return contentEnricher;
    }

    @ServiceActivator(inputChannel = SECOND_CHANNEL)
    private void fromSecondChannel(Message<?> message) {
        System.out.println(message.getPayload());
    }

and

2.

    // with bean
    @Bean
    @Transformer(inputChannel = FIRST_CHANNEL, outputChannel = SECOND_CHANNEL)
    public HeaderEnricher headerEnricher() {
        return new HeaderEnricher(ImmutableMap.of("key1", new StaticHeaderValueMessageProcessor<>("value1")));
    }

The output for the code snippet nr 2 without @Bean is :

GenericMessage [payload=org.springframework.integration.transformer.HeaderEnricher@15a3b42, headers={id=76d24f2c-8b64-a254-8733-8b5911871cce, timestamp=1590856526985}]

and with @Bean is :

GenericMessage [payload=DemoApplication11.Person(firstName=s, lastName=f, phone=null), headers={key1=value1, id=55e5b4b7-9a4b-8822-4398-b42755bc7697, timestamp=1590856617667}]

No @Bean means the transformer is called as a POJO method.

@Transformer(...)
public String transform(String in) {
    return in.toUpperCase();
}

If the transformer is actually an implementation of Transformer (such as the header enricher), you need @Bean.

The ContentEnricher is not a transformer, it is a MessageHandler, so it must be annotated with @ServiceActivator and @Bean.

See the documentation and here.

>Starting with version 4.0, you can configure messaging annotations on @Bean method definitions in @Configuration classes, to produce message endpoints based on the beans, not the methods. It is useful when @Bean definitions are “out-of-the-box” MessageHandler instances (AggregatingMessageHandler, DefaultMessageSplitter, and others), Transformer instances (JsonToObjectTransformer, ClaimCheckOutTransformer, and others), and MessageSource instances (FileReadingMessageSource, RedisStoreMessageSource, and others). The following example shows how to use messaging annotations with @Bean annotations ...

@Bean on a class means the Context Dependency Injection (CDI) container will automatically create an instance of that class and then use that instance to resolve @Autowired dependencies.

@Bean on a function means the Context Dependency Injection container will automatically call that function and use the object returned by that function to resolve @Autowired dependencies.

In most cases, Spring Boot will automatically create a default implementation of any configuration classes it needs, which will then be autowired anywhere it is needed. Defining your own @Bean function means you can pass a customized version of that class (either a subclass, or just an instance of the same class with some different parameters) into the Spring Boot framework.

I recommend you read up on what Context Dependency Injection means, and how Spring Boot actually implements it. There is no general answer to "when do i need @Bean" that doesn't require understanding CDI first.