前言
spring利用IOC（控制反转）机制，将创建对象的权利交给了spring框架，从而降低程序的耦合。spring有文件配置和注解两种策略来实现Bean对象的创建和注入，这两种方式可以相互代替，后面将对应记录两种方式的使用。
一、文件配置的方式
1.在根目录创建配置文件
命名为config.xml，配置spring必要内容：
<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"
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">
</beans>2.通过构造方法注入
通过调用bean所属类的带参构造器为bean的属性注入值。这也就意味着，如果需要使用构造器注入，就得为类提供包含参数的构造方法。
- id：注入的bean实例变量名
- class：指定全限定类名
- scope：指定作用范围，"prototype"多例，"singleton"单例（默认）
- name：指定构造函数参数名
- index：指定构造函数参数索引
- type：通过参数类型指定参数
- value：指定参数值（基本类型，String类型）
- ref：指定参数值（Bean类型，在配置文件中配置过的bean）
<!--
使用<constructor-arg>标签指定构造函数的参数以及设定的参数值
基本类型和String类型使用value赋值，引用Bean类型使用ref
同时，参数除了使用name，也可以使用index、type来指定
-->
<bean id="car" class="XMLBean.Car">
<constructor-arg name="price" value="10000"></constructor-arg>
<constructor-arg name="speed" value="80"></constructor-arg>
</bean>
<bean id="user" class="XMLBean.User">
<constructor-arg name="age" value="50"></constructor-arg>
<constructor-arg name="car" ref="car"></constructor-arg>
<constructor-arg name="name" value="周润发"></constructor-arg>
</bean>3.通过set方法注入
如果需要使用set注入，那么必须要为属性提供set方法，Spring容器就是通过调用bean的set方法为属性注入值的。而在xml文件中，使用set注入的方式就是通过property标签，如下所示：
<bean id="car" class="XMLBean.Car">
<property name="price" value="10000"></property>
<property name="speed" value="80"></property>
</bean>
<bean id="user" class="XMLBean.User">
<property name="age" value="50"></property>
<property name="car" ref="car"></property>
<property name="name" value="周润发"></property>
</bean>使用set注入一些复杂的数据类型/集合：
<!--注入集合数据/复杂数据类型：
用于List结构集合的标签：
List，set，array
用于Map结构集合的标签：
map,pro
结构相同，标签可以互换
-->
<bean id="accountDao3" class="AccountDaoImpl3">
<property name="strings">
<array>
<value>AAA</value>
<value>BBB</value>
</array>
</property>
<property name="myList">
<list>
<value>AAA</value>
<value>BBB</value>
</list>
</property>
<property name="myMap">
<map>
<entry key="AAA" value="aaa"></entry>
<entry key="BBB">
<value>bbb</value>
</entry>
</map>
</property>
<property name="myProperty">
<props>
<prop key="AAA">aaa</prop>
<prop key="BBB">bbb</prop>
</props>
</property>
</bean>3.使用静态工厂注入
静态工厂注入就是编写一个静态的工厂方法，这个工厂方法会返回我们需要的产品类，然后在配置文件中，指定使用这个工厂方法创建bean。首先需要一个静态工厂，如下所示：
public class StaticFactory {
//生产一个汽车类
public static Car getCar() {
return new Car(123, 54321);
}
}下面需要在xml中配置car这个bean，并指定它由工厂方法进行创建:
- id：指定产品bean的变量名
- class：指定工厂的全限定类名
- factory-method指定工厂类生产产品的方法
<bean id="mycar" class="XMLBean.StaticFactory" factory-method="getCar">
</bean>
<bean id="user" class="XMLBean.User">
<property name="age" value="50"></property>
<property name="car" ref="mycar"></property>
<property name="name" value="周润发"></property>
</bean>4.使用实例工厂注入
实例工厂与静态工厂类似，不同的是，静态工厂调用工厂方法不需要先创建工厂类的对象，因为静态方法可以直接通过类调用，所以在上面的配置文件中，并没有声明工厂类的bean。但是，实例工厂，需要有一个实例对象，才能调用它的工厂方法。先看看实例工厂的定义：
public class InstanceFactory {
/**
* 实例工厂方法，返回一个Car的实例对象
*/
public Car getCar() {
return new Car(100, 70000);
}
}首先将实例化工厂Bean注入IOC容器中，之后注入产品bean，并指明工厂类和生产方法：
<bean id="instanceFactory" class="XMLBean.InstanceFactory">
</bean> <!--将实例化工厂bean注入-->
<!--注入产品bean，并指明工厂bean和生产方法-->
<bean id="mycar" factory-bean="instanceFactory" factory-method="getCar">
</bean>
<bean id="user" class="XMLBean.User">
<property name="age" value="50"></property>
<property name="car" ref="mycar"></property>
<property name="name" value="周润发"></property>
</bean>测试实例
public class XmlBeanTest {
@Test
public void test1() {
ApplicationContext context =
new ClassPathXmlApplicationContext("config.xml");
// 获取user这个bean
User user = context.getBean("user",User.class);
// 输出产看结果
System.out.println(user);
}
}二、使用注解的方式
使用注解的好处：找到类就找到了bean注入的位置，不需要使用文件I/O，在大型系统中能够加快运行速度。
配置bean.xml文件：
<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"
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">
<!--可以隐式地自动向Spring容器注册4个BeanPostProcessor,
这样就可以使用@ Resource 、@ PostConstruct、@ PreDestroy、@PersistenceContext、
@Autowired、@Required等注解了实现自动注入-->
<context:annotation-config/>
<!--扫描的包的位置-->
<context:component-scan base-package="包名"></context:component-scan>
</beans>注解分为3类：
1.用于创建对象的注解
和xml配置中编写一个<bean>标签实现功能一样
@Component(value=)作用：将当前类对象存入spring容器中
属性：value:用于指定bean的id；不写时，默认为类名首字母小写@Controller：一般用于表现层@Service：一般用于业务层@Repository：一般用于持久层
以上三个注解的作用和属性与Component是一模一样的。spring提供了三层注解，使对象更佳清晰。
将User类注入IOC容器中：
@Component(value = "user") //将User类放入IOC容器中
public class User {
private String name;
private int age;
private Car car;
public User() {
}
public User(String name, int age, Car car) {
this.name = name;
this.age = age;
this.car = car;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", car=" + car +
'}';
}
}测试结果
可以看到@Component已经将User类注入，但是没有注入参数值。
public class AnnotationBeanTest {
@Test
public void test2() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
// 获取user这个bean
User user = context.getBean("user", User.class);
// 输出产看结果
System.out.println(user);
}
}
结果：
User{name='null', age=0, car=null}2.用于注入数据的注解
和xml配置中<bean>标签下写一个<property>作用一样
@Autowired
作用： 按照类型自动注入，只要有唯一一个bean对象类型和注入类型匹配，就可以注入成功。ps: 如果ico容器中没有任何bean对象的类型和要注入的变量类型匹配，则报错；如果有多个类型匹配时，会先匹配相同类型名称，再匹配id——@Repository(“id”)出现位置： 可以是变量上，也可以是方法上
细节： 在使用注释注入时，可以没有set方法
@Component("car") //放入spring容器中
public class Car {
// 只包含基本数据类型的属性
private int speed;
private double price;
public Car() {
}
public Car(int speed, double price) {
this.speed = speed;
this.price = price;
}
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"speed=" + speed +
", price=" + price +
'}';
}
}@Component(value = "user") //放入spring容器中
public class User {
private String name;
private int age;
@Autowired //根据类型，自动找到IOC中的Car类型Bean注入
private Car car;
public User() {
}
public User(String name, int age, Car car) {
this.name = name;
this.age = age;
this.car = car;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", car=" + car +
'}';
}
}测试：
可以发现car不在是null，而是已经有一个初始值。这说明@Autowired已经将IOC容器中的car注入给了私有变量car。
public class AnnotationBeanTest {
@Test
public void test2() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
// 获取user这个bean
User user = context.getBean("user", User.class);
// 输出产看结果
System.out.println(user);
}
}
结果：
User{name='null', age=0, car=Car{speed=0, price=0.0}}小结：
1.在成员变量上注入：
@Autowired //会找到spring容器中匹配的bean赋值给car
private Car car;2.在构造函数上注入：
@Autowired //有多个参数时，注解写参数前面
public User(@Value("李连杰") String name, @Value("56") int age, @Autowired Car car) {
//"李连杰"会注入给name
//"56"会注入给age
//查找合适bean注入给car
this.name = name;
this.age = age;
this.car = car;
}3.set注入：
@Autowired //调用set函数，将适当的bean注入给this.car
public void setCar(Car car) {
this.car = car;
}@Qualifier
作用： 在按照类型注入的基础上再按照名称注入。他在给类成员注入时不能单独使用，但是在给方法参数注入时可以。
@Autowired
@Qualifier("car")//给类成员变量注入时和@Autowired一起用
private Car car;属性： value，用于指定bean的id
@Resourse
作用：直接参照bean的id注入，可以独立使用
属性： name:用于指定bean的id
@Resource(name = "car")
private Car car;注：以上@Autowired、@Qualifier、@Resourse三个注入只能注入其他bean类型的数据，而基本类型和String类型无法使用这些注解，另外，集合类型的注入只能用过xml的方式来实现
@value
作用：用于注入基本类型和String类型的数据
属性：value:用于指定数据的值，可以使用spring中的spEL(spring的el表达式)
spEL的写法：$(表达式)
在User类中注入String和int类型的值：
//在成员变量中注入
@Value("成龙")
private String name;
@Value("60")
private int age;//set注入
@Value("成龙")
public void setName(String name) {
this.name = name;
}
@Value("60")
public void setAge(int age) {
this.age = age;
}3.用于改变作用范围
<bean>标签中适用scope属性实现功能一样@Scope作用：用于指定bean的范围
属性：value:常取值：singleton(单例，默认) 、prototype(多例)
4.和生命周期相关
@PreDestroy作用：用于指定销毁方法@PostConstruct作用：用于指定初始化方法
5.使用配置注解代替xml配置文件
@Configuration
作用：指定当前类是一个配置类
细节：当名为Configuration类作为AnnotationConfigApplicationContext()参数时可以不添加@Configuration，否则必须要添加。
@ComponentScan
作用：通过此注解指定spring创建容器时要扫描的包
属性：value:它和basePackages的作用是一样的
@bean
作用：把当前方法的返回值作为bean对象存入spring的ioc容器中
属性：用于指定bean的id,不写时默认值是当前方法的名称
细节：当用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象，查找的方式和@Autowired注解的作用是一样的
public class SpringConfiguration {
@Bean("car") //表示将函数返回的对象放入spring容器中
public Car createCar(@Value("66") int speed, @Value("88888")double price){ //通过注解注入参数
return new Car(speed,price);
}
@Bean("user")//表示将函数返回的对象放入spring容器中
public User createUser(@Value("陈浩南") String name,@Value("33") int age,@Qualifier(value = "car") Car car){
return new User(name,age,car);
}
}注：有了配置类，之前Car和User类前的@Component注解可以删除了。相当于已经通过配置类将响应的Bean放入了spring容器中。
测试
public class AnnotationBeanTest {
@Test
public void test2() {
ApplicationContext context =
new AnnotationConfigApplicationContext(SpringConfiguration.class);
// 获取user这个bean
User user = context.getBean("user", User.class);
// 输出产看结果
System.out.println(user);
}
}
结果：
User{name='陈浩南', age=33, car=Car{speed=66, price=88888.0}}@PropertySource
作用：用于指定properties文件的位置
属性：value：指定文件名的路径和名称；关键字：classpath表示在类路径下
//jdbc.properties文件：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/students
jdbc.username=root
jdbc.password=1234@ComponentScan("com")
@PropertySource("classpath:jdbcConfigeration.properties")
public class SpringConfiguration {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${user}")
private String uer;
@Value("${password}")
private String password;
@Bean //将一个DataSource对象放入ioc容器
public DataSource createDatasource(){
try{
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass(driver);
ds.setJdbcUrl(url);
ds.setUser(uer);
ds.setPassword(password);
System.out.println(driver+url+uer+password);
return ds;
}catch (Exception e){
throw new RuntimeException(e);
}
}
}@Import
作用：用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration 注解（不省略也可）。当使用@Import注解之后，有@Import注解的就是父配置类，而导入的是子配置类
属性：value[config.Class…] 用于指定配置类的字节码
@Configuration
@ComponentScan(basePackages = "com")
@Import({ JdbcConfig.class}) //导入子配置类
public class SpringConfiguration {
//...
}
@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig{
//...
}类对象配置总结：
- 创建一个config类，用@Configuration来注解
- 使用@ComponentScan(“包名”)来规定spring容器的扫描的包
- 使用@PropertySource("classpath: ")引入.properties配置文件（选用）
- 创建spring容器，以config.Class作为参数
- 用容器.getBean()获取bean类对象(提前用@bean或者三个创建对象的注解将对象放入IOC容器)
- 用@Value(“$()”)将.properties中的键值对成员变量进行注入
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
