前言

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{ 
	//...
}

类对象配置总结:

  1. 创建一个config类,用@Configuration来注解
  2. 使用@ComponentScan(“包名”)来规定spring容器的扫描的包
  3. 使用@PropertySource("classpath: ")引入.properties配置文件(选用)
  4. 创建spring容器,以config.Class作为参数
  5. 用容器.getBean()获取bean类对象(提前用@bean或者三个创建对象的注解将对象放入IOC容器)
  6. 用@Value(“$()”)将.properties中的键值对成员变量进行注入