Spring学习——依赖注入（DI）

字数统计: 1.5k字   |   阅读时长≈ 7分

依赖注入（DI）入门

  1. 创建 UserService，UserService 内部在调用 UserDao的save() 方法

    1
    2
    3
    4
    5
    6
    7
    8
    public class UserServiceImpl implements UserService {
    	    @Override
    	    public void save() {
    	           ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    	           UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    	            userDao.save();
    	    }
    }

  2. 将 UserServiceImpl 的创建权交给 Spring

    1
    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl"/>

  3. 从 Spring 容器中获得 UserService 进行操作

    1
    2
    3
    ApplicationContext applicationContext = new??ClassPathXmlApplicationContext("applicationContext.xml");
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    userDao.save();

    Bean的依赖注入

概念

  1. 依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。
  2. 在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。
  3. IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。
  4. 那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。
  5. 简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取 。

注入方式

  1. 构造注入
  2. 设值注入

构造注入

创建有参构造

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    public UserServiceImpl() {
    }

    public void save() {
        userDao.save();
    }
}

配置Spring容器用有参构造时进行注入

1
2
3
4
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg> 
</bean>

设值注入

注入数据的三种数据类型

  1. 普通数据类型
  2. 引用数据类型
  3. 集合数据类型（List、Map、Properties）

在UserServiceImpl中添加setUserDao方法

1
2
3
4
5
6
7
8
9
10
public class UserServiceImpl implements UserService {
        private UserDao userDao; 
        public void setUserDao(UserDao userDao) {
                  this.userDao = userDao;
         }  
        @Override 
        public void save() { 
                 userDao.save();
        }
 }

配置Spring容器调用set方法进行注入

1
2
3
4
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
               <property name="userDao" ref="userDao"/> 
</bean

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is

测试pojo类 :
Address.java

1
2
3
4
5
6
7
8
9
10
11
12
public class Address {

     private String address;

     public String getAddress() {
         return address;
    }

     public void setAddress(String address) {
         this.address = address;
    }
}

Student.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package com.asher.pojo;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Student {

     private String name;
     private Address address;
     private String[] books;
     private List<String> hobbys;
     private Map<String,String> card;
     private Set<String> games;
     private String wife;
     private Properties info;

     public void setName(String name) {
         this.name = name;
    }

     public void setAddress(Address address) {
         this.address = address;
    }

     public void setBooks(String[] books) {
         this.books = books;
    }

     public void setHobbys(List<String> hobbys) {
         this.hobbys = hobbys;
    }

     public void setCard(Map<String, String> card) {
         this.card = card;
    }

     public void setGames(Set<String> games) {
         this.games = games;
    }

     public void setWife(String wife) {
         this.wife = wife;
    }

     public void setInfo(Properties info) {
         this.info = info;
    }

     public void show(){
         System.out.println("name="+ name
                 + ",address="+ address.getAddress()
                 + ",books="
        );
         for (String book:books){
             System.out.print("<<"+book+">>\t");
        }
         System.out.println("\n爱好:"+hobbys);

         System.out.println("card:"+card);

         System.out.println("games:"+games);

         System.out.println("wife:"+wife);

         System.out.println("info:"+info);

    }
}

  1. 常量注入

    1
    2
    3
    <bean id="student" class="com.kuang.pojo.Student">
         <property name="name" value="小明"/>
    </bean>

    测试

    1
    2
    3
    4
    5
    6
    7
    8
    @Test
    public void test01(){
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

         Student student = (Student) context.getBean("student");

         System.out.println(student.getName());
    }

  2. Bean注入

    注意点：这里的值是一个引用，ref。

    1
    2
    3
    4
    5
    6
    7
    8
    <bean id="addr" class="com.kuang.pojo.Address">
         <property name="address" value="重庆"/>
    </bean>

    <bean id="student" class="com.kuang.pojo.Student">
         <property name="name" value="小明"/>
         <property name="address" ref="addr"/>
    </bean>

  3. 数组注入

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <bean id="student" class="com.kuang.pojo.Student">
         <property name="name" value="小明"/>
         <property name="address" ref="addr"/>
         <property name="books">
             <array>
                 <value>西游记</value>
                 <value>红楼梦</value>
                 <value>水浒传</value>
             </array>
         </property>
    </bean>

  4. List注入

    1
    2
    3
    4
    5
    6
    7
    <property name="hobbys">
         <list>
             <value>听歌</value>
             <value>看电影</value>
             <value>爬山</value>
         </list>
    </property>

  5. Map注入

    1
    2
    3
    4
    5
    6
    <property name="card">
         <map>
             <entry key="中国邮政" value="456456456465456"/>
             <entry key="建设" value="1456682255511"/>
         </map>
    </property>

  6. set注入

    1
    2
    3
    4
    5
    6
    7
    <property name="games">
         <set>
             <value>LOL</value>
             <value>BOB</value>
             <value>COC</value>
         </set>
    </property>

  7. Null注入

    1
    <property name="wife"><null/></property>

  8. Properties注入

    1
    2
    3
    4
    5
    6
    7
    <property name="info">
         <props>
             <prop key="学号">20190604</prop>
             <prop key="性别">男</prop>
             <prop key="姓名">小明</prop>
         </props>
    </property>

  9. 测试结果

    image-202102181531312612

p命名和c命名注入

image-20210218151820069

P命名空间注入

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，简化property name=”userDao”为p:userDao主要体现在配置文件中，如下：
首先，需要引入P命名空间

1
xmlns:p="http://www.springframework.org/schema/p"

其次，需要修改注入方式

1
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl" p:userDao ref="userDao"/>

C命名空间注入

本质是构造注入

首先，需要引入P命名空间

1
xmlns:p="http://www.springframework.org/schema/c"

其次，需要修改注入方式

1
<bean id="user" class="com.asher.pojo.User" c:name="Asher" c:age="18"/>

发现问题：爆红了，刚才我们没有写有参构造！

解决：把有参构造器加上，这里也能知道，c 就是所谓的构造器注入！
测试代码：

1
2
3
4
5
6
@Test
public void test02(){
     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
     User user = (User) context.getBean("user");
     System.out.println(user);
}

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

建立此博客主要用途：
分享知识、学习笔记、
技术探讨、好的文章收藏整理

在本博客中如果涉及到版权问题
请联系QQ:1583881877

如果对文章中有更好的看法，
请在留言区留下您宝贵的意见呦！！