J'ai essayé de lier JavaFX et Spring Framework.

Je voulais une fonction de conteneur DI pour une application binaire (´ ・ ω ・ ｀)

Eh bien, ce que je voulais faire. @Autowired. Si vous l'utilisez, vous n'avez pas besoin d'en utiliser de nouveau et le design est rafraîchissant.

Il n'y a rien de tel que FXML et le contrôleur connecté comme les autres. Je l'ai fait simplement en déplaçant le conteneur DI ~

C'est pourquoi il est mis en œuvre

S'il s'agit d'une application GUI, il est nécessaire de charger explicitement la définition de Bean et d'exécuter Spring. Puis injectez le bean dans le programme Java en cours d'exécution.

1. Exécutez Spring
2. Injectez le grain.

Injectons des beans dans un programme JavaFX comme celui-ci.

Créez une classe qui s'injecte dans l'instance.

Tout d'abord, résumons les fonctions de fonctionnement de l'injection. C'est celui sur le net.

SpringInjector.java

@Scope(BeanDefinition.SCOPE_SINGLETON)
@Component
public class SpringInjector {
    
    @Autowired
    private AutowiredAnnotationBeanPostProcessor autowiredProcessor;
    
    @Resource
    private CommonAnnotationBeanPostProcessor commonProcessor;
    
    public void inject(final Object unmanagedBean) {
        
        // javax.*Injection d'annotations associées(@Resoure)
        commonProcessor.postProcessPropertyValues(null, null, unmanagedBean, unmanagedBean.getClass().getSimpleName());
        
        // @Autowire、@Injection d'annotation de valeur
        autowiredProcessor.processInjection(unmanagedBean);
    }
}

Le ** AnnotationBeanPostProcessor ** qui apparaît ici est Cela semble être une fonction qui injecte des beans dans une certaine classe. Wagwanny

Enregistrez cette classe en tant que bean!

application-config.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
    
    
    <!-- Uncomment and add your base-package here:-->

    <context:annotation-config />
     <context:component-scan base-package="com.TsugaruInfo.*"></context:component-scan>
    
    <!--Enregistrement Spring Injector-->
    <bean id="springInjector" class="com.Tsugaruweb.springUtils.SpringInjector"/>
</beans>

Enregistrez l'annotation de package en tant que composant. Enregistrez le springInjector en tant que bean.

Activer Spring sur la classe de scène parent

Appelez ApplicationContext au printemps dans la classe parent. (On a l'impression que vous pouvez l'appeler depuis la console de la même manière)

Réalisez la gestion des haricots ici new ClassPathXmlApplicationContext("spring/application-config.xml"); Injecter l'injecteur à ressort du conteneur DI, Exécute la fonction d'injection Bean de SprinInjector.

AbstractWebAquaStage.java

public class AbstractWebAquaStage extends Stage {

    //Contexte de l'application Spring(static)
    public static ApplicationContext applicationContext;

	/**
	 *Activer le contexte d'application Spring et@Injecter automatiquement
	 */
	public void init() {
		applicationContext = new ClassPathXmlApplicationContext("spring/application-config.xml");
		SpringInjector si = applicationContext.getBean(SpringInjector.class);
		si.inject(this);
	}
	
	 public AbstractWebAquaStage() {
		this.init();
	    //Sortie vers la console pour vérification de fonctionnement
	    System.out.println("Une instance a été créée comme étape parente.");
	  }
}

Maintenant que nous l'avons configuré, déplaçons-le.

J'ai pu le mettre en place avec un bon feeling. C'est cool (comité pour appeler le programme cool) Héritons de cette classe parente Créons une scène avec une fonction d'injection d'annotations

TopStage.java

public class TopStage extends AbstractWebAquaStage {
	@Autowired
	ResourceLoader resource;
/**
 *Top stage
 */
	public TopStage(){
		
		//Volet racine
		Pane MainPane = null;
		try {
			MainPane = (Pane)FXMLLoader.load(resource.getResource("classpath:fxml/Tekito.fxml").getURL());
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		
		Scene x_scene;
		x_scene = new Scene(MainPane);
		this.setScene(x_scene);

	}
}

Vous devriez déplacer cette étape pour la voir

AppMain.java

public class AppMain extends Application {

    //Contexte de l'application Spring(static)
    public static ApplicationContext applicationContext;
	@Override
	public void start(Stage stage) {
		stage = new TopStage();
		stage.show();
		
	}
	
	public static void main(String args[]) {
		launch();
	}
}

Courir

Voyons si ça marche

J'ai pu confirmer que cela fonctionnait correctement ヾ (.> ﹏ <.) ﾉ cool!

référence Ajouter Star pour l'injection Spring Bean dans le contrôleur JavaFX