个人中心
gpt4 book ai didi

JavaWeb Spring依赖注入深入学习

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 28 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章JavaWeb Spring依赖注入深入学习由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、依赖注入(DI) 。

依赖注入听起来很高深的样子，其实白话就是：给属性赋值。一共有两种方法，第一是以构造器参数的形式，另外一种就是以setting方法的形式.

1 构造器注入 。

1 使用构造器注入 。

使用xml的注入方式 。

A. 通过参数的顺序 。

<constructor-arg index="0"><value>张三</value></constructor-arg> <constructor-arg index="1"><value>56</value></constructor-arg> 。

 B. 通过参数的类型 。

<constructor-arg type="java.lang.Integer"><value>56</value></constructor-arg> <constructor-arg type="java.lang.String"><value>张三</value></constructor-arg> 。

具体实例 。

假如现在要对一个Person类注入参数，Student是一个另外一个类.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Person {
  private String pid;
  private String name;
  private Student student;
 
 
  public Person(String pid, Student student){
   this .pid= pid;
   this .student = student;
  }
 
  public Person(String pid, String name){
   this .pid = pid;
   this .name = name;
  }
}

配置applicationContext.xml,假如不进行参数配置，则报错，找不到相应的构造器。配置了相应的参数，则应在类中声明相应的构造函数.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<? xml version = "1.0" encoding = "UTF-8" ?>
< beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  < bean id = "person" class = "com.itheima10.spring.di.xml.constructor.Person" >
   <!--
    不配参数，将会采取默认的构造器
    constructor-arg person类中某一个构造器的某一个参数
     index 为参数的角标
     type 参数的类型
     value 如果为基础属性，则用这个赋值
     ref 引用类型赋值
    -->
   < constructor-arg index = "0" type = "java.lang.String" value = "aaa" ></ constructor-arg >
   < constructor-arg index = "1" ref = "student" ></ constructor-arg >
  </ bean >
  < bean id = "person1" class = "com.itheima10.spring.di.xml.constructor.Person" >
   < property name = "pid" value = "1" ></ property >
  </ bean >
  < bean id = "student" class = "com.itheima10.spring.di.xml.constructor.Student" ></ bean >
</ beans >

编写测试类DIXMLConstructorTest ，进行断点调试，将会发现根据配置的参数，进入的构造函数是Person(String pid, Student student) 。

?
1
2
3
4
5
6
7
8
public class DIXMLConstructorTest {
 
  @Test
  public void test1(){
   ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml" );
   Person person = (Person) context.getBean( "person" );
  }
}

2 使用属性setter方法进行注入 。

使用xml的注入方式:

A. 简单Bean的注入 简单Bean包括两种类型：包装类型和String 。

?
1
2
3
4
5
< bean id = "personService" class = "com.itcast.bean.impl.PersonServiceImpl" >
<!-- 基本类型,string类型 -->
< property name = "age" value = "20" ></ property >
< property name = "name" value = "张无忌" ></ property >
</ bean >

B. 引用其他Bean 。

?
1
2
3
4
< bean id = "person" class = "com.itcast.bean.Person" />
  < bean id = "personService" class = "com.itcast.bean.impl.PersonServiceImpl" >
  < property name = "person" ref = "person" />
</ bean >

1.1 装配list集合 。

?
1
2
3
4
5
6
7
< property name = "lists" >
  < list >
   < value >list1</ value >
   < value >list2</ value >
   < ref bean = "person" />
  </ list >
</ property >

1.2 装配set集合 。

?
1
2
3
4
5
6
7
< property name = "sets" >
  < set >
   < value >list1</ value >
   < value >list2</ value >
   < ref bean = "person" />
  </ set >
</ property >

1.3 装配map 。

?
1
2
3
4
5
6
7
8
9
10
< property name = "maps" >
     < map >
      < entry key = "01" >
        < value >map01</ value >
      </ entry >
      < entry key = "02" >
        < value >map02</ value >
      </ entry >
     </ map >
</ property >

map中的<entry>的数值和<list>以及<set>的一样，可以使任何有效的属性元素，需要注意的是key值必须是String的.

1.4 装配Properties 。

?
1
2
3
4
5
6
< property name = "props" >
  < props >
   < prop key = "01" >prop1</ prop >
   < prop key = "02" >prop2</ prop >
  </ props >
</ property >

 具体实例 。

1.创建两个对象Person和Student 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package xgp.spring.demo;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
 
public class Person {
  private String pid;
  private String name;
  private Student student;
  private List lists;
  private Set sets;
  private Map map;
  private Properties properties;
  private Object[] objects;
 
  public Person(){
   System.out.println( "new person" );
  }
  //省略getter和setter方法
}
?
1
2
3
4
5
6
7
8
9
10
11
package xgp.spring.demo;
 
public class Student {
 
  public Student(){
   System.out.println( "new student" );
  }
  public void say(){
   System.out.println( "student" );
  }
}

配置applicationContext.xml文件 。

?
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
<? xml version = "1.0" encoding = "UTF-8" ?>
< beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  <!--
   把person和student放入到spring容器中
   property 用来描述Person类的属性
   value 如果是一般属性，则用value赋值
   ref 如果该属性是引用类型，用ref赋值
   -->
  < bean id = "person" class = "com.itheima10.spring.di.xml.setter.Person"
    init-method = "init"
    lazy-init = "true" >
   < property name = "pid" value = "1" ></ property >
   < property name = "name" value = "王二麻子" ></ property >
   < property name = "student" ref = "student" ></ property >
   < property name = "lists" >
    < list >
     < value >list1</ value >
     < value >list2</ value >
     < ref bean = "student" />
    </ list >
   </ property >
   < property name = "sets" >
    < set >
     < value >set1</ value >
     < value >set2</ value >
     < ref bean = "student" />
    </ set >
   </ property >
   < property name = "map" >
    < map >
     < entry key = "entry1" >
      < value >map1</ value >
     </ entry >
     < entry key = "entry2" >
      < ref bean = "student" />
     </ entry >
    </ map >
   </ property >
   < property name = "properties" >
    < props >
     <!--
      不需要引用类型
      -->
     < prop key = "prop1" >prop1</ prop >
     < prop key = "prop2" >prop2</ prop >
    </ props >
   </ property >
   < property name = "objects" >
    < list >
     < value >aa</ value >
     < value >bb</ value >
    </ list >
   </ property >
  </ bean >
  < bean id = "student" class = "com.itheima10.spring.di.xml.setter.Student" ></ bean >
</ beans >

编写测试类DIXMLSetterTest 。

?
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
package xgp.spring.test;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import xgp.spring.demo.Person;
 
public class DIXMLSetterTest {
  /**
   * spring 容器做的事情：
   *  1、spring容器做了什么？（1）启动spring容器
   *       （2）为person和student两个bean创建对象
   *       （3）解析property的name属性，拼接setter方法，解析property的
   *        value或者ref属性，给setter方法传递参数，利用反射技术给对象赋值。
   *       （4）从spring容器中，把对象提取出来，对象调用方法。
   *  2、spring容器执行顺序是什么？
   */
  @Test
  public void test1(){
   ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml" );
   Person person = (Person) context.getBean( "person" );
   System.out.println(person.getPid());
   System.out.println(person.getName());
   System.out.println(person.getLists());
   System.out.println(person.getSets());
   System.out.println(person.getMap());
   System.out.println(person.getObjects().length);
  }
 
}
/*1
王五
[list1, list2, xgp.spring.demo.Student@76a9b9c]
[set1, set2, xgp.spring.demo.Student@76a9b9c]
{entry1=map1, entry2=map2}
2*/

spring容器的执行顺序 。

1.都是默认设置 。

JavaWeb Spring依赖注入深入学习

2.设置student(lazy-init=true) 。

JavaWeb Spring依赖注入深入学习

3.设置person(lazy-init=true) 。

JavaWeb Spring依赖注入深入学习

总结 可以采用两种方法注入参数，构造器要写对应的构造函数，setter要生成相应的setter方法，并编写默认的构造器.

2.5 IOC与DI的意义 。

学了这些，发现有什么意义?下面写个文档管理系统例子来说明，需求见下图 。

1.编写Document 接口 。

?
1
2
3
4
public interface Document {
  public void read();
  public void write();
}

2、编写实现类WordDocument ，ExcelDocument ，PDFDocument 。

?
1
2
3
4
5
6
7
8
9
public class WordDocument implements Document{
  public void read() {
   System.out.println( "word read" );
  }
 
  public void write() {
   System.out.println( "word write" );
  }
}

3、编写文档管理 系统 DocumentManager 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class DocumentManager {
  private Document document;
 
  public void setDocument(Document document) {
   this .document = document;
  }
  public DocumentManager(){
  }
  public DocumentManager(Document document) {
   super ();
   this .document = document;
  }
  public void read(){
   this .document.read();
  }
 
  public void write(){
   this .document.write();
  }
}

4、编写测试类DocumentTest 。

?
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
/**
  * 利用ioc和di能做到完全的面向接口编程
  *
  */
public class DocumentTest {
  /**
   * Document document = new WordDocument();
   * 这行代码是不完全的面向接口编程,因为等号的右边出现了具体的类
   */
  @Test
  public void testDocument_NOSPRING(){
   Document document = new WordDocument();
   DocumentManager documentManager = new DocumentManager(document);
   documentManager.read();
   documentManager.write();
  }
 
  /**
   * 在代码端不知道Document是由谁来实现的，这个是由spring的配置文件决定的
   * <bean id="documentManager"
    class="com.itheima10.spring.iocdi.document.DocumentManager">
    <!--
     document为一个接口
     -->
    <property name="document">
     <!--
      wordDocument是一个实现类，赋值给了document接口
      -->
     <ref bean="pdfDocument"/>
    </property>
   </bean>
   */
  @Test
  public void testDocument_Spring(){
   ApplicationContext context =
      new ClassPathXmlApplicationContext( "applicationContext.xml" );
   DocumentManager documentManager =(DocumentManager)context.getBean( "documentManager" );
   documentManager.read();
   documentManager.write();
  }
}

从上面可以看出不适用spring和适用spring的区别 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<!--
   documentManager,wordDocument,excelDocument,pdfDocument放入到spring容器中
   -->
  < bean id = "wordDocument" class = "com.itheima10.spring.iocdi.document.WordDocument" ></ bean >
  < bean id = "excelDocument" class = "com.itheima10.spring.iocdi.document.ExcelDocument" ></ bean >
  < bean id = "pdfDocument" class = "com.itheima10.spring.iocdi.document.PDFDocument" ></ bean >
 
  < bean id = "documentManager"
   class = "com.itheima10.spring.iocdi.document.DocumentManager" >
   <!--
    document为一个接口
    -->
   < property name = "document" >
    <!--
     wordDocument是一个实现类，赋值给了document接口
     -->
    < ref bean = "pdfDocument" />
   </ property >
  </ bean >

使用spring只需要在applicationContext中配置相应的<ref bean="">对象，而不需要关注具体的实现类，实现完全的面向接口编程，这也是为什么spring能够和这么多工具集成的原因.

2.6 mvc实例–模拟structs2 。

需求描述 。

JavaWeb Spring依赖注入深入学习

建立工程目录 。

JavaWeb Spring依赖注入深入学习

编码： 1、创建Dao层 建立PersonDao接口和实现类PersonDaoImpl 。

?
1
2
3
4
5
6
7
8
9
10
public interface PersonDao {
  public void savePerson();
}
 
public class PersonDaoImpl implements PersonDao {
  @Override
  public void savePerson() {
   System.out.println( " save person" );
  }
}

2、建立service层，PersonService接口与PersonServiceImpl实现类 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public interface PersonService {
  public void savePerson();
}
 
public class PersonServiceImpl implements PersonService{
  private PersonDao personDao;
 
  public void setPersonDao(PersonDao personDao) {
   this .personDao = personDao;
  }
  @Override
  public void savePerson() {
   this .personDao.savePerson();
 
  }
 
}

3、建立Action，PersonAction类 。

?
1
2
3
4
5
6
7
8
9
10
11
public class PersonAction {
  private PersonService personService;
 
  public void setPersonService(PersonService personService) {
   this .personService = personService;
  }
 
  public void savePerson(){
   this .personService.savePerson();
  }
}

4、配置applicationContext.xml 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!--
  把service,dao,action层的类放入到spring容器中
  -->
< bean id = "personDao" class = "xgp.spring.demo.PersonDaoImpl" ></ bean >
< bean id = "personService" class = "xgp.spring.demo.PersonServiceImpl" >
< property name = "personDao" >
  < ref bean = "personDao" />
</ property >
</ bean >
< bean id = "personAction" class = "xgp.spring.demo.PersonAction" >
< property name = "personService" >
  < ref bean = "personService" />
</ property >
</ bean >

5、编写测试类testMVC 。

?
1
2
3
4
5
6
7
8
9
public class MVCTest {
  @Test
  public void testMVC(){
   ApplicationContext context =
      new ClassPathXmlApplicationContext( "applicationContext.xml" );
   PersonAction personAction = (PersonAction)context.getBean( "personAction" );
   personAction.savePerson(); //save person
  }
}

上述实例很清楚的展现出了spring的面向接口编程，service层只需调用dao层的接口，而不需要关注于dao层的实现类，action也只需调用service的接口，而不需要关注service的实现类.

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：http://blog.csdn.net/i10630226/article/details/50507100 。

最后此篇关于JavaWeb Spring依赖注入深入学习的文章就讲到这里了,如果你想了解更多关于JavaWeb Spring依赖注入深入学习的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

28 4 0
文章推荐： struts中动态方法调用使用通配符
文章推荐： Laravel使用Caching缓存数据减轻数据库查询压力的方法
文章推荐： php图片添加文字水印实现代码
文章推荐： JavaWeb Spring开发入门深入学习
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com