JavaWeb Spring依赖注入深入学习

JavaWeb Spring依赖注入深入学习

一、依赖注入(DI)

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

1 构造器注入

1 使用构造器注入

使用xml的注入方式

A. 通过参数的顺序

张三

56

B. 通过参数的类型

56&lhttp://t;/value>

张三

具体实例

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

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,假如不进行参数配置，则报错，找不到相应的构造器。配置了相应的参数，则应在类中声明相应的构造函数。

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://springframework.org/schema/beans

http://springframework.org/schema/beans/spring-beans-2.5.xsd">

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://springframework.org/schema/beans

http://springframework.org/schema/beans/spring-beans-2.5.xsd">

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

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

B. 引用其他Bean

1.1 装配list集合

list1

list2

1.2 装配set集合

list1

list2

1.3 装配map

map01

map02

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

1.4 装配Properties

prop1

prop2

具体实例

1.创建两个对象Person和Student

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方法

}

package xgp.spring.demo;

public class Student {

public Student(){

System.out.println("new student");

}

public void say(){

System.out.println("student");

}

}

配置applicationContext.xml文件

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://springframework.org/schema/beans

http://springframework.org/schema/beans/spring-beans-2.5.xsd">

init-method="init"

lazy-init="true"&gthttp://;

list1

list2

set1

set2

map1

prop1

prop2

aa

bb

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://springframework.org/schema/beans

http://springframework.org/schema/beans/spring-beans-2.5.xsd">

init-method="init"

lazy-init="true"&gthttp://;

list1

list2

set1

set2

map1

prop1

prop2

aa

bb

init-method="init"

lazy-init="true"&gthttp://;

list1

list2

set1

set2

map1

prop1

prop2

aa

bb

编写测试类DIXMLSetterTest

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.都是默认设置

2.设置student(lazyhttp://-init=true)

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

总结

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

2.5 IOC与DI的意义

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

1.编写Document 接口

public interface Document {

public void read();

public void write();

}

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

public class WordDocument implements Document{

public void read() {

System.out.println("word read");

}

public void write() {

System.out.println("word write");

}

}

3、编写文档管理 系统 DocumentManager

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

/**

* 利用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的配置文件决定的

*

class="com.itheima10.spring.iocdi.document.DocumentManager">

class="com.itheima10.spring.iocdi.document.DocumentManager">

*/

@Test

public void testDocument_Spring(){

ApplicationContext context =

new ClassPathXmlApplicationContext("applicationContext.xml");

DocumentManager documentManager =(DocumentManager)context.getBean("documentManager");

documentManager.read();

documentManager.write();

}

}

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

class="com.itheima10.spring.iocdi.document.DocumentManager">

class="com.itheima10.spring.iocdi.document.DocumentManager">

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

2.6 mvc实例–模拟structs2

需求描述

建立工程目录

编码：

1、创建Dao层

建立PersonDao接口和实现类PersonDaoImpl

public interface PersonDao {

public void savePerson();

}

public class PersonDaoImpl implements PersonDao {

@Override

public void savePerson() {

System.out.println(" save person");

}

}

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

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类

public class PersonAction {

private PersonService personService;

public void setPersonService(PersonService personService) {

this.personService = personService;

}

public void savePerson(){

this.personService.savePerson();

}

}

4、配置applicationContext.xml

5、编写测试类testMVC

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的实现类。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。