Ich habe versucht, JavaFX und Spring Framework zu verknüpfen.

Ich wollte eine DI-Container-Funktion für eine binäre Anwendung (´ ・ ω ・ ｀)

Nun, was ich tun wollte. @Autowired. Wenn Sie es verwenden, müssen Sie kein neues verwenden, und das Design wird aktualisiert.

Es gibt keine FXML und den Controller, die wie andere Personen verbunden sind. Ich habe es nur durch Bewegen des DI-Containers ~ gemacht

Deshalb wird es implementiert

Wenn es sich um eine GUI-Anwendung handelt, muss die Bean-Definition explizit geladen und Spring ausgeführt werden. Fügen Sie dann die Bean in das laufende Java-Programm ein.

1. Führen Sie Spring aus
2. Injizieren Sie die Bohne.

Lassen Sie uns Beans in ein JavaFX-Programm wie dieses einfügen.

Erstellen Sie eine Klasse, die in die Instanz eingefügt wird.

Lassen Sie uns zunächst die Funktionen für den Betrieb der Einspritzung zusammenfassen. Dies ist der im Netz.

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.*Einfügen verwandter Anmerkungen(@Resoure)
        commonProcessor.postProcessPropertyValues(null, null, unmanagedBean, unmanagedBean.getClass().getSimpleName());
        
        // @Autowire、@Wertanmerkungsinjektion
        autowiredProcessor.processInjection(unmanagedBean);
    }
}

Der hier angezeigte ** AnnotationBeanPostProcessor ** ist Es scheint eine Funktion zu sein, die Bohnen in eine bestimmte Klasse injiziert. Wagwanny

Registrieren Sie diese Klasse als Bohne!

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>
    
    <!--Registrierung des Federinjektors-->
    <bean id="springInjector" class="com.Tsugaruweb.springUtils.SpringInjector"/>
</beans>

Registrieren Sie die Paketanmerkung als Komponente. Registrieren Sie den springInjector als Bean.

Aktivieren Sie Spring in der übergeordneten Bühnenklasse

Rufen Sie ApplicationContext in Spring in der übergeordneten Klasse auf. (Es fühlt sich an, als könnten Sie es auf die gleiche Weise von der Konsole aus aufrufen.)

Verwirklichen Sie hier das Bohnenmanagement new ClassPathXmlApplicationContext("spring/application-config.xml"); Federinjektor aus DI-Behälter einspritzen, Führt die Bean-Injektionsfunktion von SprinInjector aus.

AbstractWebAquaStage.java

public class AbstractWebAquaStage extends Stage {

    //Frühlingsanwendung Kontext(static)
    public static ApplicationContext applicationContext;

	/**
	 *Aktivieren Sie den Spring-Anwendungskontext und@Autowired injizieren
	 */
	public void init() {
		applicationContext = new ClassPathXmlApplicationContext("spring/application-config.xml");
		SpringInjector si = applicationContext.getBean(SpringInjector.class);
		si.inject(this);
	}
	
	 public AbstractWebAquaStage() {
		this.init();
	    //Ausgabe an die Konsole zur Funktionsprüfung
	    System.out.println("Eine Instanz wurde als übergeordnete Stufe erstellt.");
	  }
}

Nachdem wir es eingerichtet haben, können wir es tatsächlich verschieben.

Ich konnte es mit einem guten Gefühl einrichten. Es ist cool (Komitee nennt das Programm cool) Lassen Sie uns diese übergeordnete Klasse erben Lassen Sie uns eine Stufe mit Anmerkungsinjektionsfunktion erstellen

TopStage.java

public class TopStage extends AbstractWebAquaStage {
	@Autowired
	ResourceLoader resource;
/**
 *Oberste Bühne
 */
	public TopStage(){
		
		//Wurzelfenster
		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);

	}
}

Sie sollten diese Stufe verschieben, um sie zu sehen

AppMain.java

public class AppMain extends Application {

    //Frühlingsanwendung Kontext(static)
    public static ApplicationContext applicationContext;
	@Override
	public void start(Stage stage) {
		stage = new TopStage();
		stage.show();
		
	}
	
	public static void main(String args[]) {
		launch();
	}
}

Lauf

Mal sehen, ob es funktioniert

Ich konnte bestätigen, dass es richtig funktioniert ヾ (.> ﹏ <.) ﾉ cool!

Referenz Stern für Spring Bean-Injektion in JavaFX Controller hinzufügen