java配置类
java提供一种基于java代码的方式完全替代xml配置。
java中只有类,那我们把一个类映射成xml就可以了。这也符合面向对象的思想。
java配置可以和xml配置配合使用,也可以完全废弃xml。
// @Configuration告知spring,该类下将被定义一个或多个Bean。
@Configuration //@Component
public class SpringConfig {
public SpringConfig() {
System.out.println("spring config..");
}
//@Bean在spring上下文中注册了一个Bean,方法名为bean的id。
//因为spring默认单例模式,因此该方法一开始就会且只会被调用一次。
@Bean
public Person p(){
return new Person();
}
@Bean
public Dog dog(){
Dog dog = new Dog();
dog.setName("dog wangwang..");
return dog;
}
@Bean
// @Scope(value = "prototype")
public Animal animal(){
System.out.println("animal run..");
return new Animal("animal..");
}
}
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring.xml");
Person person = (Person)applicationContext.getBean("p");
System.out.println(person.getName());
输出:
spring config..
person run...
human
1.spring上下文加载xml配置。
2.扫描xml配置的package。
3.注册@Bean到上下文中。
看源码可知@Configuration是一个@Component。因此我们可以尝试配置用直接用@Conponent注解。
package org.springframework.context.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.stereotype.Component;
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
String value() default "";
}
//@Configuration告知spring,该类下将被定义一个或多个Bean。
//@Configuration
@Component
public class SpringConfig {
public SpringConfig() {
System.out.println("spring config..");
}
//@Bean在spring上下文中注册了一个Bean,方法名为bean的id。
//因为spring默认单例模式,因此该方法一开始就会且只会被调用一次。
//方法中所有的代码都是为了构建一个合法的Bean返回。因此依赖关系我们也必须在代码中手动构p建。
@Bean
public Person p(){
System.out.println("person run...");
return new Person();
}
@Bean
public Dog dog(){
// System.out.println("dog run..");
Dog dog = new Dog();
return dog;
}
@Bean
// @Scope(value = "prototype")
public Animal animal(){
// System.out.println("animal run..");
return new Animal("animal..");
}
}
正常输出:
spring config..
person run...
human
@Configuration和@Conponent的区别请参照。
http://blog.csdn.net/ttjxtjx/article/details/49866011
基于java配置的上下文
我们也可以完全基于java代码,只需要将原来的应用上下文由
ClassPathXmlApplicationContext
换为
AnnotationConfigApplicationContext
默认构造函数的值为需要扫描的package,就是
<context:component-scan base-package="demo.*"/>
中的demo.*。
或者直接将配置类作为参数,如下。如果是直接进行配置类注册的话,那么我们的配置类上面不需要任何的注解。反之如果是扫包的形式就需要注解。
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
Person p1 = (Person)context.getBean("p");
System.out.println(p1.getName());
System.out.println(p1.getPet().getName());
输出:
spring config..
animal run..
human
dog wangwang.
这里有的人会问为什么我在p方法中没有set相关的属性,而输出却是有值的呢?方法中我们只是new了,当时是肯定是没有值得,而spring获取到方法返回的对象后没有就此罢手,而是对这个bean作了一些手脚。根据我们的注解。
下面是Person类:
//@Component注解的bean被spring扫描到了之后自动纳入spring管理。
//@Component
public class Person {
//通过spring的@Value动态注入属性值
@Value("human")
String name;
// @Value("18")
int age = 18;
//自动注入,建立bean之间的依赖关系
@Autowired
Dog pet;
// public Person(Dog pet,String name, int age) {
// this.name = name;
// this.age = age;
// this.pet = pet;
// }
public Dog getPet() {
return pet;
}
public void setPet(Dog pet) {
this.pet = pet;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
配置类之间的依赖
这样看是消除了刺眼的尖括号,然而实际上,这个陪之类依旧定了上千个bean,乱糟糟一片。
我们自然的就像给这个方法归类,比如说,dao层的Bean都放到一起,service层的放到一起,entity放在一起分门归类,形成多个配置类。
然后在引用上下中注册多次配置类。比如下面这样。
//@Configuration告知spring,该类下将被定义一个或多个Bean。
public class SpringConfig {
public SpringConfig() {
System.out.println("spring config..");
}
//@Bean在spring上下文中注册了一个Bean,方法名为bean的id。
//因为spring默认单例模式,因此该方法一开始就会且只会被调用一次。
//方法中所有的代码都是为了构建一个合法的Bean返回。因此依赖关系我们也必须在代码中手动构建。
@Bean
public Person p(){
return new Person();
}
@Bean
public Dog dog(){
Dog dog = new Dog();
dog.setName("dog wangwang..");
return dog;
}
@Bean
// @Scope(value = "prototype")
public Animal animal(){
System.out.println("animal run..");
return new Animal("animal..");
}
}
public class Data {
@Value("root")
private String user;
@Value("123456")
private String pwd;
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
//@Configuration
public class OtherConfig {
@Bean
public Data data() {
return new Data();
}
}
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(SpringConfig.class);
context.register(OtherConfig.class);
context.refresh();
Person p1 = (Person)context.getBean("p");
System.out.println(p1.getName());
System.out.println(p1.getPet().getName());
Data data = (Data)context.getBean("data");
System.out.println(data.getUser());
输出
spring config..
animal run..
human
dog wangwang..
root
这里注意在应用上下文中注册配置类的时候要调用refresh()方法。
这样看起来确实清爽了很多,然而做一件事情就要做到最好。
spring3.0提供@Import注解可以让我们为配置文件之类建立一种依赖关系。
如下代码。
//@Configuration
@Import({SpringConfig.class,OtherConfig.class})
public class AppConfig {
}
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
Person p1 = (Person)context.getBean("p");
System.out.println(p1.getName());
System.out.println(p1.getPet().getName());
Data data = (Data)context.getBean("data");
System.out.println(data.getUser());
ok,应用上下文现在只需要注册AppConfig就可以了。