JavaDoc | : smirk : 该项目主要是通过 JavaDoc API 读取 class 中的信息 | REST library

It is NOT GUARANTEED that "the 1st, classA.doSomething() method will always finish and commit the transaction before the 2nd classB.complete() async call check the status of the same record".

Transactions are implemented as some kind of interceptors appropriate for the framework (this is true for CDI too). The method marked @Transactional is intercepted by the framework, so the transaction will not end before the closing } of the method. As a matter of fact, if the transaction was started by another method higher in the stack, it will end even later.

So, ClassB has plenty of time to run and see inconsistent state.

I would place the 1st part of doSomething in a separate REQUIRES_NEW transaction method (you may need to place it in a different class, depending on how you configured transaction interceptors; if you are using AOP, Spring may be able to intercept calls to methods of the same object, otherwise it relies on the injected proxy object to do the interception and calling a method through this will not activate the interceptor; again this is true for other frameworks as well, like CDI and EJB). The method doSomething calls the 1st part method, which finishes in a new transaction, then ClassB can continue asynchronously.

Now, in that case (as correctly pointed out in the comment), there is a chance that the 1st transaction succeeds and the 2nd fails. If this is the case, you will have to put logic in the system about how to compensate for this inconsistent state. Frameworks cannot deal with it because there is not one recipe, it is a per case "treatment". Some thoughts, in case they help: make sure that the state of the system after the 1st transaction clearly says that the second transaction should complete "shortly after". E.g. keep a "1st tx committed at" field; a scheduled task can check this timestamp and take action if it is too far in the past. JMS gives you all this - you get retries and a dead letter queue for the failed cases.

The AWS SDK for Java has two versions: V1 and V2. AmazonS3Client is the older V1 version while S3Client is the newer V2 version.

Amazon recommends using V2:

The AWS SDK for Java 2.x is a major rewrite of the version 1.x code base. It’s built on top of Java 8+ and adds several frequently requested features. These include support for non-blocking I/O and the ability to plug in a different HTTP implementation at run time.

You can find Amazon S3 V2 code examples in the Java Developer V2 DEV Guide here:

Developer guide - AWS SDK for Java 2.x

(At this point, the Amazon S3 Service guide does not have V2 examples in it.)

In addition, you can find all Amazon S3 V2 code examples in AWS Github here:

https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javav2/example_code/s3

If you are not familiar developing apps by using the AWS SDK for Java V2, it's recommended that you start here:

Get started with the AWS SDK for Java 2.x

(This getting started topic happens to use the Amazon S3 Java V2 API to help get you up and running with using the AWS SDK for Java V2)

Update:

You stated: However, setObjectTagging is supported in type AmazonS3 not but in type S3Client .

The way to tag an Object in an Amazon S3 bucket by using Java V2 API is to use this code:

After testing and looking through the Spring source code (for example the DefaultSingletonBeanRegistry mentioned by M. Deinum in a comment) I have found that two singleton beans where one is dependendent on the other will indeed be destroyed in the reverse order they are created in. When thinking about it I have a hard time seeing how it could work in another way. If the beans were not destroyed in the reverse order it would cause a lot of problems. For example, during the shutdown of an app a bean could try to use another bean that has already been destroyed. Unfortunately, I still haven't found any confirmation of the behavior in the documentation.

tokenUri represents the URI for the token endpoint. For example:

OK, so my initial solution for that is to use Stateful DoFn like this (I'm using Scio's Scala SDK as mentioned in the question):

Well after a long time of searching I found the answer: it was the update from AS 4.1.3 to 4.2.x with which Google decided to package Java11 instead of 8. Building and compiling was possible, but javadoc generation was broken for whatever reason.

I found the solution. In case of modules, javadoc requires a compiles module descriptor, so it is necessary to do mvn compile javadoc:javadoc instead of mvn javadoc:javadoc

Since consumer client id is not required and group id should only be used for offset management, I assume it means by topic name, when the consumer is subscribed to multiple topics. If you are only using one topic, then only partitions are numerically ordered

-fx-text-fill is a CSS property that is defined for controls with text properties (such as Labeled and its subclasses, and TextInputControl and its subclasses).

The property, as noted in the question, is listed in the JavaFX CSS Reference Guide.

-fx-text-inner-color is not a property, but a looked-up color (essentially a CSS color variable) that is defined in the default stylesheet modena.css. It is used as the value of the -fx-text-fill property for controls which have a background color set to -fx-control-inner-background, namely "text boxes, password boxes, lists, trees, and tables".

Changing -fx-text-inner-color at the root level will have the effect of changing the text color on all text boxes, password boxes, lists, trees, and tables.

Note that the default value of -fx-text-inner-color is set to a color ladder, which depends on the value of -fx-control-inner-background. Namely, when -fx-control-inner-background is dark (less than 45% intensity), it is set to -fx-light-text-color, when it is light (greater than 60% intensity, which it is by default), it is set to -fx-mid-text-color, and otherwise it is set to -fx-dark-text-color. The default values of these are white, #333, and black, respectively.

The effect of these default settings is to get a text fill which always contrasts with the background; so if you change the value of -fx-control-inner-background the text color will adjust automatically.

There are really two distinct approaches to defining a production-level style for an application:

• Define the styles for all the controls you use in the application. In this approach, you'll set the properties on each control (or at least, the properties which are different to the default). This is more work, but creates a "stand-alone" style which is more likely to be robust in the future if the user has a JavaFX implementation with a new default stylesheet.

• Tap into the default stylesheet modena.css and change the values of the looked-up colors on which everything is based. This is much easier. You can go a long way just by changing the value of -fx-base, from which most other looked-up colors are defined. Other key looked-up colors are

  • -fx-background, used for the background color of windows and panes
  • -fx-control-inner-background, used for the background color of text boxes, lists, tables, and trees
  • -fx-dark-text-color, -fx-mid-text-color, and -fx-light-text-color, used to define the color ladders for text drawn over -fx-background and -fx-control-inner-background
  • -fx-accent (selection), -fx-default-button, -fx-focus-color, and -fx-faint-focus-color

  Try creating an application and using