Spring DI

一. Spring DI 依赖注入

利用spring IOC实例化了对象，而DI将实例化的对象注入到需要对象的地方，完成初始化任务。

对象由spring创建，之后再由spring给属性赋值

spring提供两种方式设置属性值：

① setter方法注入

②构造方法注入

二. set方法注入

2.1单值注入

Cat有type和age属性，采用单值注入的方式，进行初始化。

 package com.hdu.setter;

 import java.io.Serializable;

 public class Cat implements Serializable{

     private static final long serialVersionUID = 1L;

     private String type;

     private int age;

     public String getType() {

         return type;

     }

     public void setType(String type) {

         this.type = type;

     }

     public int getAge() {

         return age;

     }

     public void setAge(int age) {

         this.age = age;

     }

 }

Class Cat

<!-- 实例化Cat对象

     <bean>节点是用来告知spring实例化对象

     <property>节点,是用来告知spring对象有注入

     name="type" type->Type->setType

     把名字的第一个字母大写，前面用字符串连接一个set,构建出一个新字符串,

     拿着个字符串去class属性所对应的类中寻找是否有此方法签名的方法.

     如果有就反射调用此setter方法.setter方法的参数是value="smallCat"

-->

<bean id="cat" class="com.hdu.setter.Cat">

    <!-- 单值注入 -->

    <property name="type" value="smallCat"></property>

    <property name="age" value="3"></property>

</bean>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.setter.Cat;

 public class TestIOCDI {

     @Test

     public void testMethod() {

         ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_object.xml");

         Cat cat = context.getBean("cat",Cat.class);

         System.out.println(cat.getType()+" "+cat.getAge());

     }

 }

2.2对象注入

人人有猫。将Cat对象注入到Person对象中。

 package com.hdu.setter;

 public class Person {

     private String name;

     private int age;

     private Cat cat;

     public String getName() {

         return name;

     }

     public void setName(String name) {

         this.name = name;

     }

     public int getAge() {

         return age;

     }

     public void setAge(int age) {

         this.age = age;

     }

     public Cat getCat() {

         return cat;

     }

     public void setCat(Cat cat) {

         this.cat = cat;

     }

 }

Class Person

<!-- 实例化Cat对象 -->

<bean id="cat" class="com.hdu.setter.Cat">

    <!-- 单值注入 -->

    <property name="type" value="smallCat"></property>

    <property name="age" value="3"></property>

</bean>

<!-- name="cat" cat->Cat->setCat

     ref="cat" 引用对象,cat是spring容器中的唯一id,指上面已经实例化的cat对象

-->

<bean id="person" class="com.hdu.setter.Person">

<!-- 单值注入 -->

<property name="name" value="kuotian"></property>

<property name="age" value="23"></property>

<!-- 对象注入 -->

<property name="cat" ref="cat"></property>

</bean>

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.setter.Person;

 public class TestIOCDI {

     @Test

     public void testMethod() {

         ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_object.xml");

         //对象都是由spring创建和管理,对象的关系也要由spring来维护

         Person person = context.getBean("person",Person.class);

         System.out.println("Person:name="+person.getName());

         System.out.println("Person:age="+person.getAge());

         System.out.println("Person:Cat:type="+person.getCat().getType());

         System.out.println("Person:Cat:age="+person.getCat().getAge());

     }

 }

2.3集合注入

toString是为了便于测试。

 package com.hdu.setter;

 import java.util.List;

 import java.util.Map;

 import java.util.Properties;

 import java.util.Set;

 public class Message {

     private List list;

     private Set set;

     private Map map;

     private Properties pros;

     public void setList(List list) {

         this.list = list;

     }

     public void setSet(Set set) {

         this.set = set;

     }

     public void setMap(Map map) {

         this.map = map;

     }

     public void setPros(Properties pros) {

         this.pros = pros;

     }

     @Override

     public String toString() {

         return "Message [list=" + list + ", set=" + set + ", map=" + map + ", pros=" + pros + "]";

     }

 }

2.3.1直接注入

<!-- 实例化Cat对象 -->

<bean id="cat" class="com.hdu.setter.Cat">

    <!-- 单值注入 -->

    <property name="type" value="smallCat"></property>

    <property name="age" value="3"></property>

</bean>

<!-- 直接集合注入 -->

<bean id="message" class="com.hdu.setter.Message">

    <property name="list">

        <list>

            <!-- value引用的是单值 ref引用的事对象 -->

            <value>杭州</value>

            <value>17</value>

            <ref bean="cat" />

        </list>

    </property>

    <property name="set">

        <set>

            <value>杭州</value>

            <value>17</value>

            <ref bean="cat" />

        </set>

    </property>

    <property name="map">

        <map>

            <entry key="bj" value="北京"></entry>

            <entry key="hz" value="杭州"></entry>

            <entry key="cc" value-ref="cat"></entry>

        </map>

    </property>

    <property name="pros">

        <props>

            <prop key="bj">北京</prop>

            <prop key="hz">杭州</prop>

            <prop key="sh">上海</prop>

        </props>

    </property>

</bean>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.setter.Message;

 public class TestIOCDI {

     @Test

     public void testMethod() {

         ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_collection.xml");

         //直接注入

         Message msg = context.getBean("message",Message.class);

         System.out.println(msg);

     }

 }

2.3.2间接注入

　　间接注入，集合可复用多次。

　　beans需要引入util命名空间。

<?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:aop="http://www.springframework.org/schema/aop"

    xmlns:tx="http://www.springframework.org/schema/tx"

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

    xmlns:util="http://www.springframework.org/schema/util"

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:mvc="http://www.springframework.org/schema/mvc"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx.xsd

        http://www.springframework.org/schema/util

        http://www.springframework.org/schema/util/spring-util.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/mvc

        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 实例化Cat对象 -->

    <bean id="cat" class="com.hdu.setter.Cat">

        <!-- 单值注入 -->

        <property name="type" value="smallCat"></property>

        <property name="age" value="3"></property>

    </bean>

    <!-- 间接集合注入 -->

    <util:list id="list">

        <value>杭州</value>

        <value>17</value>

        <ref bean="cat" />

    </util:list>

    <util:set id="set">

        <value>杭州</value>

        <value>17</value>

        <ref bean="cat" />

    </util:set>

    <util:map id="map">

        <entry key="bj" value="北京"></entry>

        <entry key="hz" value="杭州"></entry>

        <entry key="cc" value-ref="cat"></entry>

    </util:map>

    <util:properties id="props">

        <prop key="bj">北京</prop>

        <prop key="hz">杭州</prop>

        <prop key="sh">上海</prop>

    </util:properties>

    <bean id="message1" class="com.hdu.setter.Message">

        <property name="list" ref="list"></property>

        <property name="set" ref="set"></property>

        <property name="map" ref="map"></property>

        <property name="pros" ref="props"></property>

    </bean>

</beans>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.setter.Message;

 public class TestIOCDI {

     @Test

     public void testMethod() {

         ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_collection.xml");

         //直接注入

         Message msg = context.getBean("message",Message.class);

         System.out.println("直接注入:"+msg);

         //间接注入

         Message msg1 = context.getBean("message1",Message.class);

         System.out.println("间接注入:"+msg1);

     }

 }

从结果看出两种注入方式的效果是一样的。

2.4表达式注入

2.4.1 ${}表达式

参考手册中的事例。

①准备一个properties文件。

jdbc_driverClass=com.mysql.jdbc.Driver

jdbc_url=jdbc:mysql://localhost:3306/tmpdb

jdbc_userName=root

jdbc_userPassword=root

mysql.properties

②存放数据相关类

 package com.hdu.util;

 public class JDBCUtil {

     private String driverClass;

     private String url;

     private String userName;

     private String password;

     public String getDriverClass() {

         return driverClass;

     }

     public void setDriverClass(String driverClass) {

         this.driverClass = driverClass;

     }

     public String getUrl() {

         return url;

     }

     public void setUrl(String url) {

         this.url = url;

     }

     public String getUserName() {

         return userName;

     }

     public void setUserName(String userName) {

         this.userName = userName;

     }

     public String getPassword() {

         return password;

     }

     public void setPassword(String password) {

         this.password = password;

     }

     @Override

     public String toString() {

         return "JDBCUtil [driverClass=" + driverClass + ", url=" + url + ", userName=" + userName + ", password="

                 + password + "]";

     }

 }

Class JDBCUtil

③xml中beans需要引入context命名空间。

<?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:aop="http://www.springframework.org/schema/aop"

    xmlns:tx="http://www.springframework.org/schema/tx"

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

    xmlns:util="http://www.springframework.org/schema/util"

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:mvc="http://www.springframework.org/schema/mvc"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx.xsd

        http://www.springframework.org/schema/util

        http://www.springframework.org/schema/util/spring-util.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/mvc

        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 优先加载 先把属性文件加载到spring容器中 多个文件用逗号间隔 -->

    <context:property-placeholder location="classpath:resources/mysql.properties,resources/page.properties"/>

    <!-- 表达式注入 ${} -->

    <bean id="jdbcUtil" class="com.hdu.util.JDBCUtil">

        <property name="driverClass" value="${jdbc_driverClass}"></property>

        <property name="url" value="${jdbc_url}"></property>

        <property name="userName" value="${jdbc_userName}"></property>

        <property name="password" value="${jdbc_userPassword}"></property>

    </bean>

</beans>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.util.JDBCUtil;

 public class TestIOCDI {

     @Test

     public void testMethod() {

         ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_expression1.xml");

         //从容器中取出对象

         JDBCUtil jdbcUtil = context.getBean("jdbcUtil", JDBCUtil.class);

         System.out.println(jdbcUtil);

     }

 }

结果：

2.4.1 #{}表达式

③xml中beans需要引入util命名空间。

<?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:aop="http://www.springframework.org/schema/aop"

    xmlns:tx="http://www.springframework.org/schema/tx"

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

    xmlns:util="http://www.springframework.org/schema/util"

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:mvc="http://www.springframework.org/schema/mvc"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx.xsd

        http://www.springframework.org/schema/util

        http://www.springframework.org/schema/util/spring-util.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/mvc

        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 优先加载 先把属性文件加载到spring容器中 多个文件用逗号间隔 -->

    <util:properties id="manyProperties" location="classpath:resources/mysql.properties,resources/page.properties"></util:properties>

    <!-- 表达式注入 #{} -->

    <bean id="jdbcUtil" class="com.hdu.util.JDBCUtil">

        <property name="driverClass" value="#{manyProperties.jdbc_driverClass}"></property>

        <property name="url" value="#{manyProperties.jdbc_url}"></property>

        <property name="userName" value="#{manyProperties.jdbc_userName}"></property>

        <property name="password" value="#{manyProperties.jdbc_userPassword}"></property>

    </bean>

</beans>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.util.JDBCUtil;

 public class TestIOCDI {

     @Test

     public void testMethod() {

         ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_expression2.xml");

         JDBCUtil jdbcUtil = context.getBean("jdbcUtil", JDBCUtil.class);

         System.out.println(jdbcUtil);

     }

 }

结果：

2.5空值注入

其中str2注入的是空值，而str1注入的只是空字符串。在测试方法中str1= str2=null的结果可以证明。

 package com.hdu.util;

 public class Kong {

     private String str1;

     private String str2;

     public String getStr1() {

         return str1;

     }

     public void setStr1(String str1) {

         this.str1 = str1;

     }

     public String getStr2() {

         return str2;

     }

     public void setStr2(String str2) {

         this.str2 = str2;

     }

     @Override

     public String toString() {

         return "Kong [str1=" + str1 + ", str2=" + str2 + "]";

     }

 }

str2才是注入空值。

<bean id="kong" class="com.hdu.util.Kong">

    <property name="str1" value=""></property>

    <property name="str2">

        <null></null>

    </property>

</bean>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.util.Kong;

 public class TestIOCDI {

     @Test

     public void testMethod() {

         ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_setter_kong.xml");

         Kong kong = context.getBean("kong", Kong.class);

         System.out.println(kong);

     }

 }

结果：

其中str2注入的是空值，而str1注入的只是空字符串。在测试方法中str1= str2=null的结果可以证明。

三.构造方法注入

 package com.hdu.constructor;

 import com.hdu.setter.Cat;

 public class ConstructorDI {

     private int age;

     private Cat cat;

     private String name;

     public ConstructorDI() {

     }

     public ConstructorDI(int age, Cat cat, String name) {

         super();

         this.age = age;

         this.cat = cat;

         this.name = name;

     }

     @Override

     public String toString() {

         return "ConstructorDI [age=" + age + ", cat=" + cat + ", name=" + name + "]";

     }

 }

<!-- 实例化Cat对象 -->

<bean id="cat" class="com.hdu.setter.Cat">

    <property name="type" value="smallCat"></property>

    <property name="age" value="3"></property>

</bean>

<!--

     index:从0开始,代表参数的位置

 -->

<bean id="constructor" class="com.hdu.constructor.ConstructorDI">

    <constructor-arg index="0" value="20"></constructor-arg>

    <constructor-arg index="1" ref="cat"></constructor-arg>

    <constructor-arg index="2" value="张三"></constructor-arg>

</bean>

测试

 package com.hdu.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.hdu.constructor.ConstructorDI;

 public class TestIOCDI {

     @Test

     public void testMethod() {

         ApplicationContext context = new ClassPathXmlApplicationContext("resources/spring_constructor.xml");

         ConstructorDI constructor = context.getBean("constructor", ConstructorDI.class);

         System.out.println(constructor);

     }

 }

Spring DI的更多相关文章

4.spring di
spring di,即依赖注入,从应用的浅显意义来讲就是对属性赋值 1.用setter赋值,在spring的applicationContext.xml配置文件的bean下的property标签属性 ...
Spring DI使用详解
Spring DI使用详解一.介绍 DI的定义:依赖注入,为类里面的属性设值.例如,我们之前的setName方法就是在为name属性设值. IOC与DI的关系:IOC进行对象的创建,DI进行值的注入 ...
手写Spring DI依赖注入，嘿，你的益达！
目录提前实例化单例Bean DI分析 DI的实现构造参数依赖一:定义分析二:定义一个类BeanReference 三:BeanDefinition接口及其实现类四:DefaultBeanFa ...
Java Spring DI之旅
做过.NET的人很多都用过Microsoft Enterprise Library,里面有一个Dependency injection工具Unity,我们可以使用它来实现依赖注入:什么是依赖注入呢?我 ...
Spring DI模式小样例
今儿跟同事讨论起来spring早期的,通过大篇幅xml的配置演变到今天annotation的过程,然后随手写了个小样例,感觉还不错,贴到这里留个纪念. 样例就是用JAVA API的方式, ...
Spring DI - 依赖注入
1.IOC(DI) - 控制反转(依赖注入) 所谓的IOC称之为控制反转,简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理,从此在开发过程中不再需要关注对象的创建和生 ...
spring Di依赖注入
依赖注入有两种方式通过 get set 方法 Person.java package cn.itcast.spring.sh.di.set; import java.util.List; imp ...
Spring知识点总结(三)之Spring DI
1. IOC(DI) - 控制反转(依赖注入) 所谓的IOC称之为控制反转,简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理,从此在开发过程中不再需要关注对象的创建和 ...
吴裕雄--天生自然JAVA SPRING框架开发学习笔记：Spring DI（依赖注入）的实现方式属性注入和构造注入
依赖注入(Dependency Injection,DI)和控制反转含义相同,它们是从两个角度描述的同一个概念. 当某个 Java 实例需要另一个 Java 实例时,传统的方法是由调用者创建被调用者的 ...

随机推荐

HDU 4489 The King's Ups and Downs
HDU 4489 The King's Ups and Downs 思路: 状态:dp[i]表示i个数的方案数. 转移方程:dp[n]=∑dp[j-1]/2*dp[n-j]/2*C(n-1,j-1). ...
详解Mybatis通用Mapper介绍与使用
使用Mybatis的开发者,大多数都会遇到一个问题,就是要写大量的SQL在xml文件中,除了特殊的业务逻辑SQL之外,还有大量结构类似的增删改查SQL.而且,当数据库表结构改动时,对应的所有SQL以及 ...
Turbolinks
Turbolinks Turbolinks® makes navigating your web application faster. 功能: 自动优化导航. 无需server端配合.全HTML网页 ...
OAuth简介（包含简明使用教程）
SSO:用户一次登陆后在多个系统免登录. 博客gem 'doorkeeper' https://i.cnblogs.com/EditPosts.aspx?postid=9255973 OAuth:用 ...
大年三十。让字母在屏幕上奔跑：(sleep , system"clear")
system "clear",ruby清屏(osk系统上,window上用system "cls"). https://stackoverflow.com/qu ...
5.4 使用 Razor 表达式
以下内容主要展示 Razor 所支持的各种表达式,以及如何用它们来创建视图的内容. 在一个好的 MVC 框架应用程序中,动作方法与视图的作用是清晰.分离的.其规则很简单,如表所示: 组件要做的事不 ...
OAF点击事件对页面组件的Required属性不验证
在实际的需求中,OAF页面上很多字段设置了Required=YES,但是我们在点击某些按钮的时候,并不希望浏览器对其进行验证,可以通过设置 Disable Server Side Validation ...
微信小程序绑定数据（微信小程序交流群：604788754）
在小程序开发中,用js绑定数据时,明明没报错,但页面没有显示绑定的数据内容.这有可能是相对应的js绑定数据的一些变量名字的问题.遇到这种情况.可以从新建立一个新的demo页面.把问题页面相对应的js. ...
mysql添加伪劣及查看表信息
SELECT @rownum:=@rownum+1 AS rownum, table_name.* FROM (SELECT @rownum:=0) r, table_name select ...
js中的deom ready执行的问题
一开始我想到这,DOMContentLoaded,不兼容, <!DOCTYPE html> <html> <head> <meta charset=" ...

Spring DI

Spring DI的更多相关文章

随机推荐

热门专题