I'm willing to use Spring boot technology in my JavaFX application (to get the advantage of its dependency injection), but I'm wondering about the consequences on the memory, as you know any class with a "component" notation will be loaded to the MetaSpace (since it Spring boot will create a static object from it), so with tens of JavaFx view controllers loaded to the MetaSpace they will never get garbage collected from the launching of the application to the end, which is obviously a bad thing, is there any way to get around of this issue?
The Spring Boot autoconfiguration premium, measured this way, is about 1MB heap and 4MB non-heap.
Given above reasons, there is no way that Spring Boot can be used as a light weight platform for microservices. It is too heavy and two slow. And if you compare the codebase on both Spring Boot and Light Java, you can see Light Java code is small and easy to understand without any annotations.
Disadvantages of Spring BootLarge deployment files that result from unused dependencies. The long amount of time that it takes to replace legacy systems with Spring Boot applications. Its inability to build large, monolithic applications (although it works extremely well for developing microservices)
You write in comments:
JavaFX applications when the view controller doesn't get garbage collected means also the view objects will always stay there TableViews,ListViews,Panes ... which may take some important space
But I don’t think it needs to be that way.
The controller instance which references the Java nodes is just a Java object like any other and will be available for garbage collection when there are no more references to it in the JVM.
Let’s say you configure your JavaFX SpringBoot integration like this:
So you configure your controller factory to use Spring beans:
fxmlLoader.setControllerFactory(
springContext::getBean
);
Then your controllers are Spring beans whose scope you can control.
If you use prototype scope:
@Bean
@Scope("prototype")
public PersonController personControllerPrototype() {
return new PersonController();
}
Then the behavior is as specified in:
Spring does not manage the complete lifecycle of a prototype bean: the container instantiates, configures, and otherwise assembles a prototype object, and hands it to the client, with no further record of that prototype instance.
Typically you will create a controller and add a reference to the object tree that it instantiates into the scene graph. If you replace the tree in the scene graph when you navigate, and you don’t keep a reference to the controller anywhere, then the controller and any other associated nodes which have been removed from the scene graph can be garbage collected.
Or, if you wanted to just load the fxml once and keep the controller around forever you could use singleton scope to do that.
So basically, you can choose the scope and lifecycle of your controllers to be as best fits your application or the individual controllers that you are using.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With