spring
ApplicationContext Configuration
Sök…
Anmärkningar
Spring har gjort det så att konfigurera en ApplicationContext är extremt flexibel. Det finns många sätt att tillämpa varje typ av konfiguration, och de kan alla blandas och matchas ihop.
Java-konfiguration är en form av uttrycklig konfiguration. En @Configuration annoterad klass används för att specificera bönorna som kommer att vara en del av ApplicationContext , samt definiera och koppla beroenden för varje bönor.
Xml-konfiguration är en form för uttrycklig konfiguration. Ett specifikt xml-schema används för att definiera de bönor som kommer att ingå i ApplicationContext . Samma schema används för att definiera och leda beroenden för varje böna.
Autowiring är en form av automatisk konfiguration. Vissa anteckningar används i klassdefinitioner för att fastställa vilka bönor som kommer att vara en del av ApplicationContext , och andra kommentarer används för att leda beroenden hos dessa bönor.
Java-konfiguration
Java-konfiguration görs vanligtvis genom att tillämpa @Configuration kommentaren på en klass för att föreslå att en klass innehåller bönedefinitioner. @Bean specificeras genom att tillämpa @Bean anteckningen på en metod som returnerar ett objekt.
@Configuration // This annotation tells the ApplicationContext that this class
// contains bean definitions.
class AppConfig {
/**
* An Author created with the default constructor
* setting no properties
*/
@Bean // This annotation marks a method that defines a bean
Author author1() {
return new Author();
}
/**
* An Author created with the constructor that initializes the
* name fields
*/
@Bean
Author author2() {
return new Author("Steven", "King");
}
/**
* An Author created with the default constructor, but
* then uses the property setters to specify name fields
*/
@Bean
Author author3() {
Author author = new Author();
author.setFirstName("George");
author.setLastName("Martin");
return author;
}
/**
* A Book created referring to author2 (created above) via
* a constructor argument. The dependency is fulfilled by
* invoking the method as plain Java.
*/
@Bean
Book book1() {
return new Book(author2(), "It");
}
/**
* A Book created referring to author3 (created above) via
* a property setter. The dependency is fulfilled by
* invoking the method as plain Java.
*/
@Bean
Book book2() {
Book book = new Book();
book.setAuthor(author3());
book.setTitle("A Game of Thrones");
return book;
}
}
// The classes that are being initialized and wired above...
class Book { // assume package org.springframework.example
Author author;
String title;
Book() {} // default constructor
Book(Author author, String title) {
this.author = author;
this.title= title;
}
Author getAuthor() { return author; }
String getTitle() { return title; }
void setAuthor(Author author) {
this.author = author;
}
void setTitle(String title) {
this.title= title;
}
}
class Author { // assume package org.springframework.example
String firstName;
String lastName;
Author() {} // default constructor
Author(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
String getFirstName() { return firstName; }
String getLastName() { return lastName; }
void setFirstName(String firstName) {
this.firstName = firstName;
}
void setLastName(String lastName) {
this.lastName = lastName;
}
}
Xml-konfiguration
XML-konfiguration görs vanligtvis genom att definiera bönor i en XML-fil med Spring specifika beans schema. Under roten beans element skulle typiskt definition böna göras med hjälp av bean delelementet.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- An Author created with the default constructor
setting no properties -->
<bean id="author1" class="org.springframework.example.Author" />
<!-- An Author created with the constructor that initializes the
name fields -->
<bean id="author2" class="org.springframework.example.Author">
<constructor-arg index="0" value="Steven" />
<constructor-arg index="1" value="King" />
</bean>
<!-- An Author created with the default constructor, but
then uses the property setters to specify name fields -->
<bean id="author3" class="org.springframework.example.Author">
<property name="firstName" value="George" />
<property name="lastName" value="Martin" />
</bean>
<!-- A Book created referring to author2 (created above) via
a constructor argument -->
<bean id="book1" class="org.springframework.example.Book">
<constructor-arg index="0" ref="author2" />
<constructor-arg index="1" value="It" />
</bean>
<!-- A Book created referring to author3 (created above) via
a property setter -->
<bean id="book1" class="org.springframework.example.Book">
<property name="author" ref="author3" />
<property name="title" value="A Game of Thrones" />
</bean>
</beans>
// The classes that are being initialized and wired above...
class Book { // assume package org.springframework.example
Author author;
String title;
Book() {} // default constructor
Book(Author author, String title) {
this.author = author;
this.title= title;
}
Author getAuthor() { return author; }
String getTitle() { return title; }
void setAuthor(Author author) {
this.author = author;
}
void setTitle(String title) {
this.title= title;
}
}
class Author { // assume package org.springframework.example
String firstName;
String lastName;
Author() {} // default constructor
Author(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
String getFirstName() { return firstName; }
String getLastName() { return lastName; }
void setFirstName(String firstName) {
this.firstName = firstName;
}
void setLastName(String lastName) {
this.lastName = lastName;
}
}
Autowiring
Autowiring görs med hjälp av en sterotypanteckning för att specificera vilka klasser som ska vara bönor i ApplicationContext , och med hjälp av Autowired och Value kommentarerna för att ange bönberoende. Den unika delen av autowiring är att det inte finns någon extern ApplicationContext definition, eftersom allt görs inom klasserna som är själva bönorna.
@Component // The annotation that specifies to include this as a bean
// in the ApplicationContext
class Book {
@Autowired // The annotation that wires the below defined Author
// instance into this bean
Author author;
String title = "It";
Author getAuthor() { return author; }
String getTitle() { return title; }
}
@Component // The annotation that specifies to include
// this as a bean in the ApplicationContext
class Author {
String firstName = "Steven";
String lastName = "King";
String getFirstName() { return firstName; }
String getLastName() { return lastName; }
}
Starta om ApplicationContext
Java Config
Konfigurationsklassen behöver bara vara en klass som finns på klassens sökväg och synlig för din applikations huvudklass.
class MyApp {
public static void main(String[] args) throws Exception {
AnnotationConfigApplicationContext appContext =
new AnnotationConfigApplicationContext(MyConfig.class);
// ready to retrieve beans from appContext, such as myObject.
}
}
@Configuration
class MyConfig {
@Bean
MyObject myObject() {
// ...configure myObject...
}
// ...define more beans...
}
Xml Config
Konfigurationen xml-fil behöver endast finnas på klassens sökväg.
class MyApp {
public static void main(String[] args) throws Exception {
ClassPathXmlApplicationContext appContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
// ready to retrieve beans from appContext, such as myObject.
}
}
<?xml version="1.0" encoding="UTF-8"?>
<!-- applicationContext.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="myObject" class="com.example.MyObject">
<!-- ...configure myObject... -->
</bean>
<!-- ...define more beans... -->
</beans>
Autowiring
Autowiring behöver veta vilka baspaket som ska sökas efter kommenterade bönor ( @Component ). Detta anges via #scan(String...) .
class MyApp {
public static void main(String[] args) throws Exception {
AnnotationConfigApplicationContext appContext =
new AnnotationConfigApplicationContext();
appContext.scan("com.example");
appContext.refresh();
// ready to retrieve beans from appContext, such as myObject.
}
}
// assume this class is in the com.example package.
@Component
class MyObject {
// ...myObject definition...
}