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 实例时,传统的方法是由调用者创建被调用者的 ...

随机推荐

附加题找bug
private: void ReSize(int sz) { ) { return; } if(maxSize != sz) { T *arr = new T[sz]; if(arr == NULL) ...
RabbitMQ入门_13_消息持久化
参考资料:https://www.rabbitmq.com/tutorials/tutorial-two-java.html 默认情况下,队列中的消息是不持久化的.如果 RabbitMQ 崩溃,队列中 ...
hihoCoder 1513 小Hi的烦恼
hihoCoder 1513 小Hi的烦恼思路: 用bitset判断交集个数代码: #include<bits/stdc++.h> using namespace std; #defi ...
python - 面向对象编程(初级篇)
写了这么多python 代码,也常用的类和对象,这里准备系统的对python的面向对象编程做以下介绍. 面向对象编程(Object Oriented Programming,OOP,面向对象程序设计) ...
Lua面向对象 --- 继承
工程结构: BasePlayer.lua: BasePlayer = {} BasePlayer.root = "BasePlayer" function BasePlayer:S ...
ssh 登陆进去后， .bashrc 也没有被执行
查了一下,ssh login 之后, 会执行 .bash_profile 于是新建一个.bash_profile , 内容如下 if [ -f ~/.bashrc ]; then . ~/.bashr ...
Python递归遍历《指定目录》下的所有《文件》
https://www.cnblogs.com/dreamer-fish/p/3820625.html
linux下修改mysql登录密码
一.修改mysql密码 1.停止服务 /etc/init.d/mysqld stop 2.以不检查权限的方式启动 /etc/init.d/mysqld --skip-grant- ...
20170814xlVBA PowerPoint分类插图加说明
Public Sub AddPictures() Dim ppApp As PowerPoint.Application Set ppApp = New PowerPoint.Application ...
看起来很懵的java内存加载面试题
源代码如下,求结果 public class MemoryAnalyse { public static int k = 0; public static MemoryAnalyse t1 = new ...

Spring DI

Spring DI的更多相关文章

随机推荐

热门专题