JavaWeb Spring依赖注入深入学习
2016-09-07 15:18
961 查看
一、依赖注入(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是一个另外一个类。
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,假如不进行参数配置，则报错，找不到相应的构造器。配置了相应的参数，则应在类中声明相应的构造函数。
<?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)
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
<bean id="personService" class="com.itcast.bean.impl.PersonServiceImpl"> <!-- 基本类型,string类型 --> <property name="age" value="20"></property> <property name="name" value="张无忌"></property> </bean>
B. 引用其他Bean
<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集合
<property name="lists"> <list> <value>list1</value> <value>list2</value> <ref bean="person" /> </list> </property>
1.2 装配set集合
<property name="sets"> <set> <value>list1</value> <value>list2</value> <ref bean="person" /> </set> </property>
1.3 装配map
<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
<property name="props"> <props> <prop key="01">prop1</prop> <prop key="02">prop2</prop> </props> </property>
具体实例
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文件
<?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
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(lazy-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的配置文件决定的
* <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的区别
<!-- 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
需求描述
建立工程目录
编码：
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
<!-- 把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
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的实现类。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。
您可能感兴趣的文章:
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 【JavaWeb-23】spring、IoC控制反转和DI依赖注入入门、基于XML的Bean装配、基于注解的Bean装配
- java学习笔记之Spring依赖注入和控制反转
- 如何用比较快速的方法掌握Spring的核心——依赖注入，Java web轻量级开发面试教程 读书笔记
- JavaWeb Spring开发入门深入学习
- 使用Spring.Net对Web页面进行依赖注入
- ITCAST视频-Spring学习笔记（编码剖析Spring依赖注入的原理）
- Spring 学习笔记之依赖注入
- java开源框架集成常见错误之spring2.5中没有org.springframework.web.struts.DelegatingActionProxy ，使得Action不能注入到spring中
- spring.net依赖注入到Web页面
- Spring学习（一）依赖注入
- Spring.net 学习笔记二 依赖注入
- JAVA框架当中Spring的依赖注入和控制反转
- spring学习笔记整理--05(编码剖析Spring依赖注入的原理)
- 学习spring依赖注入--备忘
- Spring 学习总结（一）依赖注入的理解
- Java 学习笔记09：Spring搭建MVC WEB项目
- 框架学习之Spring 第二节 采用Spring管理Bean和依赖注入
- 使用Spring.Net对Web页面进行依赖注入
- Spring学习（一）依赖注入
- spring2.5 基于注解依赖注入学习--01