Add a side-effect to a Flux after each element is consumed?

This is a simplified example but it illustrates the point.

Let's say I have a method defined like this:

Flux<String> generateFlux() {
  return Flux.just("hello", "world"); // (S)
}

Is there a way to make S for example print something <i>after</i> an element has been consumed without the subscriber of the flux having to do or know anything about it?

For example, I'd to modify S so that this:

generateFlux().doOnNext(System.out::println).block()

actually prints out this to the console:

hello
consumed
world
consumed

Is this possible to do this using Reactor 3.3 and if so how?

Update

I guess my question was unclear so I'll add some more details. The gist of my question is that I want this to be unchanged:

generateFlux().doOnNext(System.out::println).block() // A

So I want to modify S, i.e. Flux.just("hello", "world") to accommodate what I'm asking, not A. I know you can add subscribe and doOnNext etc to A, but this is not what I'm asking. I'm asking if there's a way to modify S, so that without any changes made to A, this will be printed when the subscriber/consumer of A has processed all items:

hello
consumed
world
consumed

I.e. that S somehow receives a signal that the first element has been consumed ("hello"), and then it can perform a doOnNext (or whatever) and in this case print "consumer". When the second element has been consumed ("world") then it should print "consumed" again.

Is this possible?

A Flux is a publisher and the correct way to consume data from a flux is using subscribe.
So

 generateFlux.subscribe(word -> {
      System.out.println(word);
      System.out.println("consumed" + word);
});

using subscribe with passing just a Consumer as a parameter you will override what the subscriber will do on next.
Basically behind will be created a Subscriber with having those 2 prints as a behaviour.
How Flux works you need to understand this 2 interfaces

   public interface Publisher<T> {
       void subscribe(Subscriber<? super T> var1);
   }

   public interface Subscriber<T> {
       void onSubscribe(Subscription var1);
 
       void onNext(T var1);
 
       void onError(Throwable var1);

       void onComplete();
}

You can use doOnEach to add side effects to every element consumed in the given stream without modify the publisher (error and completion too).

  Flux.just("hello", "world")
                .doOnEach(item -> System.out.println(item))
                .blockLast();

doOnEach Documentation

Also there are lot of overloads for the different life cycles, like doOnError, doOnSuccess, doOnNext...

Documentation of Flux, you can find there all the operators and descriptions to those.

Update:

According to your update, you may think to the cross-cuting concern.
You can use Hooks to modify the reactive stream operators on assembling time.

Hooks Doc

You can use doOnNext callback to intercept the action of the publisher pushing the next element. but use subscribe instead of block

generateFlux()
.doOnNext(next => System.out.println("Next Element pushed by publisher" + next))
.subscribe();

You can use the subscribe signature that overrides all behaviour of onNext, onError & onCompleted. subscribe method is overloaded in Flux