Spring依赖注入(DI:配置文件+注解)

依赖注入

Spring依赖注入。。。。。。。。。。。。。。。。，两种方式我们可以达到把Spring容器创建的对象注入到我们需要用的位置。第一个式配置文件方式（配置文件中配置），另一种式注解的方式注入指定位置（简单，方便）。 

 1.配置文件注入

配置文件的注入方式也有setter注入，构造函数注入，p命名空间的注入，SpEl表达式注入，集合（List,Set,Map）Properties等的注入等注入方式。如下实现常用的几个注入方式：

方式一：Set注入

UserDao:

package com.spring.demo02;

public class UserDao {
    public void save() {
        System.out.println("持久层。。。");
    }
}

UserService:

package com.spring.demo02;

public class UserService {
    //配置文件注入：提供成员属性,设置set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    
    public void save() {
        System.out.println("业务层。。。");
        //调用
        userDao.save();
    }
}

配置文件设置依赖注入：

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">
       
       <!-- 演示的依赖注入 -->
       <bean id="userDao" class="com.spring.demo02.UserDao"/>
       
       <bean id="userService" class="com.spring.demo02.UserService">
           <property name="userDao" ref="userDao"/>
       </bean>
       
</beans>

测试依赖注入：

package com.spring.demo02;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDI {
    @Test
    public void run() {
        //创建容器对象，加载配置文件，创建userDao对象，userService也被创建
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取userService对象
        UserService userService = (UserService) context.getBean("userService");
        //调用save方法
        userService.save();
    }
}

运行结果：

方式二：构造函数注入

User：

package com.spring.demo03;

public class User {
    private String name;
    private Integer age;
    
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
    }
    
}

配置文件设置依赖注入：

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">
       
       <!-- 方式一：Set注入 -->
       <bean id="userDao" class="com.spring.demo02.UserDao"/>
       
       <bean id="userService" class="com.spring.demo02.UserService">
           <property name="userDao" ref="userDao"/>
       </bean>
       
       
       <!-- 方式二：构造方法的注入方式:name是属性名称，value是注入的值，如果要出入引用使用raf标签 -->
       <bean id="user" class="com.spring.demo03.User">
           <constructor-arg name="name" value="Tom"/>
           <constructor-arg name="age" value="18"/>
           
           <!-- 第二种方式  index写序号就行 -->
           <!-- <constructor-arg index="0" value="Tom"/>
           <constructor-arg name="1" value="18"/> -->
           
           
       </bean>

测试：

package com.spring.demo03;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDI {
    @Test
    public void run() {
        //创建容器对象，加载配置文件，创建User类的对象，并构造函数初始化
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取user对象
        User user = (User) context.getBean("user");
        System.out.println(user);
    }
}

运行结果：

方式三：p命名空间注入方式

User:

package com.spring.demo03;

public class User {
    private String name;
    private Integer age;
    
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }



    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
    }
    
}

配置文件设置依赖注入：

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- 方式三：p命名空间注入方式 -->
    <bean id="user" class="com.spring.demo03.User" p:name="Tom" p:age="18" />        
       
</beans>

 配置文件中需要设置命名空间p

测试:

package com.spring.demo03;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDI {
    @Test
    public void run() {
        //创建容器对象，加载配置文件，创建User类的对象，并构造函数初始化
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取user对象
        User user = (User) context.getBean("user");
        System.out.println(user);
    }
}

运行结果;

方式四：集合方式

 2.注解注入

Spring中提供一些作用在类上的注解，我们使用这些注解可以标志对应的类对象。还有通过一些属性的注解把容器创建的对象注入到指定位置，还有注入一些基本类型的值。还有一些作用范围的注解来控制对象的单例或者多例，生命周期等。

类上使用注解：

@Component　　　//每个层都可以，作用在类上
@Controller    //作用在web层
@Service       //作用在业务层
@Repository    //作用在持久层

这三个注解都放在每层的类上面，会创建对应的对象，Component可以每层类上但建议使用其他三个注解增强

属性注解：

@Value            //用于注入基本类型
@Autowired        //用于对象注入，默认按类型进行自动装配
@Qualifier        //用于对象注入，按名称注入
@Resource         //相当于@Autowired与Qualifier一起使用，JDK提供的注解，Spring支持

作用范围

@Scope(value="prototype")    //Bean的作用范围注解,作用在类上，singleton:单例（默认） prototype：多例
@PostConstruct               //相当于init-method
@PreDestroy                  //相当于destroy-method

  

实现注解方式

UserService:

package com.spring.demo04;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 组件注解，标记该类
 * 相当于：<bean id="userService" class="com.spring.demo04.UserService">
 */
@Component(value="userService")
public class UserService {
    //属性注解：基本数据类型
    @Value(value="业务层")
    private String name;
    
    //@Resource(name="userDao")    JDK提供的注解，spring支持
    //对象注解:按类型自动装配
    @Autowired
    @Qualifier(value="userDao")    //也可以不写，一旦写名称必须一致
    private UserDao userDao;
    
    
    public void save() {
        System.out.println(name+"启动。。。");
        userDao.save();
    }
}

UserDao:

package com.spring.demo04;
import org.springframework.stereotype.Repository;

/**
 * UserDao交给IOC容器
 * 相当于：<bean id="userDao" class="com.spring.demo04.UserDao">
 */
@Repository(value="userDao")
public class UserDao {
    
    public void save() {
        System.out.println("持久层启动。。。。");
    }
}

配置文件:

<?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"
    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">

    <!-- 开启注解的扫描:扫描该包下的所有类 -->
    <context:component-scan base-package="com.spring.demo04" />
    
</beans>

测试：

package com.spring.demo04;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDI {
    @Test
    public void run() {
        //创建容器对象，加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取userService对象
        UserService userService = (UserService) context.getBean("userService");
        //调用save方法
        userService.save();
    }
}

运行结果：