精华内容
下载资源
问答
  • 依赖注入DI方式2.1 属性自动注入 - 不推荐代码准备阶段代码测试2.2 子节点构造器注入 - 不推荐2.3 子节点手动注入2.3.1 Property不是多值类2.3.1 是多值类 - Property需要子、孙节点 1. 属性设置 - XML配置文件、...

    1. 属性设置 - XML配置文件、以及与其等价的注解形式

    注意: - 所有Bean都懒加载,不过优先级比较低

    容器启动时
    属性
    lazy-init:true/false(default) - 懒加载
    scope
    singleton:单例
    prototype:每次获取都会被创建新对象
    request:每次请求都会被创建新对象
    session:不同session获取会被创建新对象
    init-method:创建对象时,被触发方法
    destroy-method:对象被回收时,被触发的方法
    Bean注解
    @PostConstructor:等价于init-method属性
    @PreDestory:等价于destory-method属性
    @Scope('singleton'):等价于scope属性
    @Compone:将Bean注册到Spring容器上

    2. 依赖注入DI的方式

    即类一旦被初始化、类内的某些属性通过Spring容器的XML文件一同自动的初始化

    2.1 属性自动注入 - 不推荐

    通过Spring自带的Junit测试工具进行测试DI注入

    autowire属性值
    default/no:不会自动注入
    byType:根据setxx方法的参数类型进行自动注入
    byName:根据setxx方法的方法名去掉set并且将首字母小写方法名 - 与一致
    constructor:根据构造器的参数类型进行注入
    代码准备阶段

    EmpService3 - 通过自动注入empDao3自动的会被初始化-无须手动new

    public class EmpService3 {
    	
    	EmpDao3 empDao3;
    	
    	EmpService3() {
    		System.out.println("EmpService3被实例化");
    	}
    	
    	EmpService3(EmpDao3 empDao) {
    		System.out.println("EmpService3被实例化");
    	}
    	
    	public void setEmpDao3(EmpDao3 empDao3) {
    		this.empDao3 = empDao3;
    	}
    	
    }
    


    EmpDao3

    public class EmpDao3 {
    	EmpDao3() {
    		System.out.println("EmpDao3被实例化");
    	}
    }
    

    Spring容器配置文件 - 注意共有6个类,只是上面两个的复制品,读者自行复制,改一下编号就可以

    <?xml version="1.0" encoding="UTF-8"?>
    <beans default-lazy-init="true" xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"> 
    		
    	<bean name="empDao" class="top.linruchang.dao.EmpDao"  ></bean>
    	<bean name="empService" class="top.linruchang.service.EmpService" autowire="constructor"></bean>
    	
    	<bean name="empDao2" class="top.linruchang.dao.EmpDao2"  ></bean>
    	<bean name="empService2" class="top.linruchang.service.EmpService2" autowire="byType"></bean>
    	
    	<bean name="empDao3" class="top.linruchang.dao.EmpDao3"  ></bean>
    	<bean name="empService3" class="top.linruchang.service.EmpService3" autowire="byName"></bean>
    	
    </beans>
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qlpEgpTO-1576777014901)(en-resource://database/13848:1)]
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BwhY7MBu-1576777014905)(en-resource://database/13850:1)]

    代码测试
    @RunWith(value=SpringJUnit4ClassRunner.class)
    @ContextConfiguration("applicationContext.xml")
    public class TestSpringContainer {
    	
         // 该注解的作用 - 自动初始化EmpService - 如果能自动注入,则对象实例化时,属性也会相应得到实例化(依赖注入)
    	@Autowired   
    	EmpService es;
    	
    	@Autowired
    	EmpService2 es2;
    	
    	@Autowired
    	EmpService3 es3;
    	
    	@Test
    	public void test1() {}
    	
    }
    


      运行结果
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1YNs2NNz-1576777014920)(en-resource://database/13852:1)]

    2.2 子节点构造器注入 - 不推荐

    的属性
    index:构造器参数的位置,从0开始
    name:构造器形参的变量名
    type:根据构造器的形参类型
    ref:被注入的bean的name属性名
    value:可直接写字面变量的值

      Spring容器的配置

    <?xml version="1.0" encoding="UTF-8"?>
    <beans default-lazy-init="true" xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"
    	> 
    			
    	<!-- 构造器参数类型 - type是被注入的Class全限定名 ref被注入的bean-name属性名   -->
    	<bean name="empDao" class="top.linruchang.dao.EmpDao" ></bean>
    	<bean name="empService" class="top.linruchang.service.EmpService">
    		<constructor-arg type="top.linruchang.dao.EmpDao" ref="empDao"></constructor-arg>
    	</bean>
    	
    	<!-- 构造器参数类型 - name构造器形参的变量名   ref被注入的bean-name属性名 -->
    	<bean name="empDao2" class="top.linruchang.dao.EmpDao2" ></bean>
    	<bean name="empService2" class="top.linruchang.service.EmpService2">
    		<constructor-arg name="empDao233" ref="empDao2"></constructor-arg>
    	</bean>  
    	
    	
    	<!-- 构造器参数类型 - index构造器第几个形参   ref被注入的bean-name属性名 -->
    	<bean name="empDao3" class="top.linruchang.dao.EmpDao3" ></bean>
    	<bean name="empService3" class="top.linruchang.service.EmpService3">
    		<constructor-arg index="0" ref="empDao3"></constructor-arg>
    	</bean>
    		
    </beans>
    


    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g0vFxPKp-1576777014924)(en-resource://database/13858:1)]


      测试代码:

    @RunWith(value=SpringJUnit4ClassRunner.class)
    @ContextConfiguration("applicationContext.xml")
    public class TestSpringContainer {
    	
    	@Autowired
    	EmpService es;
    	
    	@Autowired
    	EmpService2 es2;
    	
    	@Autowired
    	EmpService3 es3;
    	
    	@Test
    	public void test1() {
    		
    	}
    	
    }
    


      运行效果
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rxOR2Abj-1576777014929)(en-resource://database/13860:1)]

    2.3 子节点手动注入

    2.3.1 Property不是多值类
    属性
    name:调用setxxx() 去掉set并且将首字母小写
    ref:bean的name或者id名


      Spring容器配置文件

    	<bean name="empDao" class="top.linruchang.dao.EmpDao"></bean>	
    	<bean name="empService" class="top.linruchang.service.EmpService">
    		<property name="empDao1" ref="empDao"></property>	
    	</bean>
    	
    	<bean name="empDao2" class="top.linruchang.dao.EmpDao2"></bean>	
    	<bean name="empService2" class="top.linruchang.service.EmpService2">
    		<property name="empDao2" ref="empDao2"></property>
    	</bean>
    	
    	<bean name="empDao3" class="top.linruchang.dao.EmpDao3"></bean>	
    	<bean name="empService3" class="top.linruchang.service.EmpService3">
    		<property name="empDao3" ref="empDao3"></property>
    	</bean>
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cLQFWby6-1576777014932)(en-resource://database/13868:1)]


      由运行结果可知 - 运行成功

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-igHMt9Lo-1576777014934)(en-resource://database/13872:1)]

    2.3.1 是多值类 - Property需要子、孙节点

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E6b6FOKE-1576777014937)(en-resource://database/13874:1)]

      Emp代码

    public class Emp {
    	
    	List<String> hobbies1;
    	Set<String> hobbies2;
    	Map<Integer, String> hobbies3;
    	Properties hobbies4;
    	String[] hobbies5;
    	
    	public void setHobbies1(List<String> hobbies1) {
    		this.hobbies1 = hobbies1;
    		System.out.println("hobbies1" + hobbies1);
    		
    	}
    	
    	public void setHobbies2(Set<String> hobbies2) {
    		this.hobbies2 = hobbies2;
    		System.out.println("hobbies2" + hobbies2);
    	}
    	
    	public void setHobbies3(Map<Integer, String> hobbies3) {
    		this.hobbies3 = hobbies3;
    		System.out.println("hobbies3" + hobbies3);
    	}
    	
    	public void setHobbies4(Properties hobbies4) {
    		this.hobbies4 = hobbies4;
    		System.out.println("hobbies4" + hobbies4);
    	}
    	
    	public void setHobbies5(String[] hobbies5) {
    		this.hobbies5 = hobbies5;
    		System.out.println("hobbies5" + Arrays.toString(hobbies5));
    	}
    	
    }
    

      配置文件 - 注入的属性是List、Set、Map、数组、Properties( 其实也是Map )

    	 <bean name="emp" class="top.linruchang.domain.Emp">
    	 	<property name="hobbies1">
    	 		<list>
    	 			<value>篮球</value>
    	 			<value>足球</value>
    	 		</list>
    	 	</property>
    	 	
    	 	<property name="hobbies2">
    	 		<set>
    	 			<value>篮球</value>
    	 			<value>足球</value>
    	 		</set>
    	 	</property>
    	 	
    	 	<property name="hobbies3">
    	 		<map>
    	 			<entry key="1" value="篮球"></entry>
    	 			<entry key="2" value="足球"></entry>
    	 		</map>
    	 	</property>
    	 	
    	 	<property name="hobbies4">
    	 		<props>
    	 			<prop key="1">篮球</prop>
    	 			<prop key="2">足球</prop>
    	 		</props>
    	 	</property>
    	 	
    	 	<property name="hobbies5">
    	 		<array>
    	 			<value>篮球</value>
    	 			<value>足球</value>
    	 		</array>
    	 	</property>
    	 </bean>
    

      Spring单元测试代码

    @RunWith(value=SpringJUnit4ClassRunner.class)
    @ContextConfiguration("applicationContext.xml")
    public class DITest {
    	
    	@Autowired
    	Emp emp;
    		
    	@Test
    	public void test() {
    		System.out.println(emp);
    	}
    	
    }
    

      运行结果
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-urECQUSu-1576777014941)(en-resource://database/13876:1)]

    展开全文
  • DI:Dependency Injection(依赖注入) 从字面上分析: IoC:指将对象的创建权,反转给了Spring容器; DI :指Spring创建对象的过程中,将对象依赖属性(简单...依赖注入三种方式 1.setter注入,(属性注入) 使用se

    DI:Dependency Injection(依赖注入)

    从字面上分析:
    IoC:指将对象的创建权,反转给了Spring容器;
    DI :指Spring创建对象的过程中,将对象依赖属性(简单值,集合,对象)通过配置设值给该对象。
    IoC和DI其实是同一个概念的不同角度描述,DI相对IoC而言,明确描述了“被注入对象依赖IoC容器配置依赖对象”。

    所谓的依赖注入,就是属性不创建对象,通过配置文件的配置将Spring容器里面的对象注入给对应的属性

    依赖注入有三种方式

    1.setter注入,(属性注入)

    使用setter注入:
    1,使用bean元素的子元素设置;
    1,简单类型值,直接使用value赋值;
    2,引用类型,使用ref赋值;
    3,集合类型,直接使用对应的集合类型元素即可。
    2,spring通过属性的setter方法注入值;
    3,在配置文件中配置的值都是string,spring可以自动的完成类型的转换

    <?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.xsd">
    	
    	<!-- 员工 -->
    	<bean id="employee" class="cn.zj.spring.pojo.Employee" >
    		<!-- setter方法注入: 属性注入 
    			<property name="" value="">
    			name : 属性名称
    			value : 基本数据类型+String类型的值注入
    			ref : 引用类型(对象类型)的注入
    			value 和ref 只能二选一
    		-->
    		<property name="age" value="18"></property>
    		<property name="name" value="jinken"></property>
    		<property name="dept" ref="dept"></property>
    	</bean>
    	<!-- 部门 -->
    	<bean id="dept" class="cn.zj.spring.pojo.Department" ></bean>
    
    </beans>
    

    2.构造器注入

    <!-- 
    		1,默认情况下,constructor-arg的顺序就是构造器参数的顺序
    		2,3中调整构造器顺序:
    		   1.index:在构造器中的参数索引(从0开始)
    		   2.type:在构造器中的参数的类型
    		   3.name:在构造器中按照构造器的参数名字设置值 
    		   ====================
    		使用哪种注入方式比较好(setter?构造器?)?
    		1,如果一个类必须依赖另一个类才能正常运行,用构造器;
    		2,但是构造器的参数如果过多,构造器很难看;--测试参数不能少,否则报错20191221
    		3,更多的还是使用setter注入;
    		4,可以使用@Required标签来要求一个属性必须注入
    	 -->
    	
    	<!-- 员工 -->
    	<bean id="employee" class="cn.zj.spring.pojo.Employee" >
    		<!-- constructor注入 -->
    		<constructor-arg index="1"  value="乔峰"/>
    		<constructor-arg index="0" value="19"/>
    		<constructor-arg  ref="dept"/>
    	</bean>
    	<!-- 部门 -->
    	<bean id="dept" class="cn.zj.spring.pojo.Department" ></bean>
    

    3.P命名空间
    使用p命名空间注入先在约束上面引入 p标签(红色部分)

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:p="http://www.springframework.org/schema/p"
        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.xsd">
            
     	<!-- 配置部门 -->
     	<bean id="department" class="cn.zj.spring.pojo.Department" 
     	p:id="123"
     	p:name="销售部"/>
     	
     	<!-- 配置员工 -->
     	<bean id="emp" class="cn.zj.spring.pojo.Employee" 
     	p:id="111"
     	p:name="西门吹雪"
     	p:dept-ref="department"/>
    </beans>
    

    4.集合类型值注入

    在这里插入代码片
    
    
    public class CollectionBean {
    	private Set<String> set;
    	private List<String> list;
    	private String[] array;
    	private Map<String, String> map;
    	private Properties prop; //读取本地 xxx.properties文件(本质就是一个Map集合)
    }
    <bean id="collectionBean" class="cn.gzxst.spring.pojo.CollectionBean">
    		<!-- set集合注入  -->
    		<property name="set">
    			<set>
    				<value>set1</value>	
    				<value>set2</value>	
    				<value>set3</value>	
    			</set>
    		</property>
    		<!-- list集合注入  -->
    		<property name="list">
    			<list>
    				<value>list1</value>
    				<value>list2</value>
    				<value>list3</value>
    			</list>
    		</property>
    		<!-- 数组注入 -->
    		<property name="array">
    			<array>
    				<value>AA</value>
    				<value>BB</value>
    				<value>CC</value>
    			</array>
    		</property>
    		<!-- map集合注入 -->
    		<property name="map">
    			<map>
    				<entry key="key1" value="乔峰"/>
    				<entry key="key2" value="虚竹"/>
    				<entry key="key3" value="段誉"/>
    			</map>
    		</property>
    		<!-- Properties注入 -->
    		<property name="prop">
    			<props>
    				<prop key="pro1">proVlaue1</prop>
    				<prop key="pro2">proVlaue2</prop>
    				<prop key="pro3">proVlaue3</prop>
    			</props>
    		</property>
    	</bean>
    
    展开全文
  • Spring--IOC控制反转与DI依赖注入三种方式1. setter方法注入2.构造器注入3.接口注入 Spring的核心思想是IOC和AOP,IOC即控制反转,包括依赖注入和依赖查找,最主要使用的即依赖注入DI。通常情况下,我们创建对象时...

    Spring--IOC控制反转与DI依赖注入的三种方式


    Spring的核心思想是IOC和AOP,IOC即控制反转,包括依赖注入和依赖查找,最主要使用的即依赖注入DI。通常情况下,我们创建对象时,是通过new关键字主动进行的;而DI则是在创建对象时,只设置配置文件,由Spring统一创建对象并调用。这也就是控制反转的由来。

    接下来本文将重点介绍依赖注入的三种方式

    本文使用maven创建工程,pom.xml中依赖设置如下

     <dependencies>
                <!--spring-core:spring核心依赖包-->
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-core</artifactId>
                    <version>5.2.8.RELEASE</version>
                </dependency>
                <!--spring的IOC容器-->
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-beans</artifactId>
                    <version>5.2.8.RELEASE</version>
                </dependency>
                <!--bean的扩展-->
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                    <version>5.1.10.RELEASE</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context-support</artifactId>
                    <version>5.1.10.RELEASE</version>
                </dependency>
            </dependencies>
    

    1. setter方法注入

    假设我们要实现一个人吃水果的功能,人是一个对象,水果也是一个对象,人具有姓名等属性,水果也具有品种等属性。
    (1)我们在src/main/java/bean下创建水果类Fruit.java

    public class Fruit {
        private String name;
        private String color;
        private String taste;
    public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public String getColor() {
                return color;
            }
    
            public void setColor(String color) {
                this.color = color;
            }
    
            public String getTaste() {
                return taste;
            }
    
            public void setTaste(String taste) {
                this.taste = taste;
            }
             public void show(){
    
            System.out.println(name+"  "+color+"  "+taste);
    
        }
    }
    
    

    Fruit具有品种,颜色和口味三种属性,给予getter 和setter方法,并创建show()方法展示品种、颜色和口味。

    (2)在src/main/java/bean下创建人类Person.java

    public class Preson {
        private String name;
        private TestFruit fruit;
        public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public TestFruit getFruit() {
                return fruit;
            }
    
            public void setFruit(TestFruit fruit) {
                this.fruit = fruit;
            }
        public void eat(){
            System.out.println(name);
            fruit.show();
    
        }
    }
    

    人类具有姓名这个属性,给予getter和setter方法,在eat()函数中输出人的姓名和水果的信息。

    (3)在src/main/resources下创建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.xsd">
        <bean id="fruit" class="bean.Fruit">
                <property name="name" value="香蕉"></property>
                <property name="color" value="黄色"></property>
                <property name="taste" value=""></property>
        </bean>
        <bean id="person" class="bean.Preson">
           <property name="fruit" ref="fruit"></property>
            <property name="name" value="小明"></property>
        </bean>
    </beans>
    

    如果你要把一个引用传递给一个对象,那么你需要使用 标签的 ref 属性,而如果你要直接传递一个值,那么你应该使用 value 属性。

    (4)在src/main/java下创建Test测试类进行测试

    public class Test {
        public static void main(String[] args) {
            //读取配置文件
            ClassPathXmlApplicationContext  app=new ClassPathXmlApplicationContext("applicationContext.xml");
            Preson pr= (Preson) app.getBean("person");
            pr.eat();
        }
    }
    
    

    输出结果为

    小明
    香蕉 黄色 甜
    

    2.构造器注入

    假设我们同样要实现一个人吃水果的功能,人是一个对象,水果也是一个对象,人具有姓名等属性,水果也具有品种等属性。
    (1)我们在src/main/java/bean下创建水果类Fruit.java,此时不设置getter和setter方法,而是给予全参的构造函数

    public class TestFruit {
        private String name;
        private String color;
        private String taste;
    
        public TestFruit(String name, String color, String taste) {
            this.name = name;
            this.color = color;
            this.taste = taste;
        }
    
        public void show(){
    
            System.out.println(name+"  "+color+"  "+taste);
    
        }
    }
    
    

    给予全参的构造方法并创建show()方法展示品种、颜色和口味。

    (2)在src/main/java/bean下创建人类Person.java

    public class Preson {
        private String name;
        private TestFruit fruit;
        
        public Preson(String name, TestFruit fruit) {
            this.name = name;
            this.fruit = fruit;
        }
        
        public void eat(){
            System.out.println(name);
            fruit.show();
        }
    }
    

    给予人类全参的构造函数,在eat()函数中输出人的姓名和水果的信息。

    (3)在src/main/resources下创建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.xsd">
        <bean id="fruit" class="bean.fruit">
                <constructor-arg name="name" value="香蕉"></constructor-arg>
                <constructor-arg name="color" value="黄色"></constructor-arg>
                <constructor-arg name="taste" value=""></constructor-arg>
        </bean>
        <bean id="person" class="bean.Preson">
            <constructor-arg name="name" value="小明"></constructor-arg>
            <constructor-arg name="fruit" ref="fruit"></constructor-arg>
        </bean>
    </beans>
    

    如果你要把一个引用传递给一个对象,那么你需要使用 标签的 ref 属性,而如果你要直接传递一个值,那么你应该使用 value 属性。

    (4)在src/main/java下创建Test测试类进行测试

    public class Test {
        public static void main(String[] args) {
            //读取配置文件
            ClassPathXmlApplicationContext  app=new ClassPathXmlApplicationContext("applicationContext.xml");
            Preson pr= (Preson) app.getBean("person");
            pr.eat();
        }
    }
    
    

    输出结果同样为

    小明
    香蕉 黄色 甜
    

    3.接口注入

    接口注入模式因为具备侵入性,它要求组件必须与特定的接口相关联,因此并不被看好,实际使用有限,本文不做实例研究,仅了解即可

    展开全文
  • 依赖注入,简单的理解就是把组件所依赖的对象通过容器注入(赋值)到组件。 把StudentDao的实现类StudentDaoImp注入到StudentServiceImp 1.set方式 配置文件 当加载配置文件applicationContext.xml时,spring容器...

    依赖注入,简单的理解就是把组件所依赖的对象通过容器注入(赋值)到组件。

    把StudentDao的实现类StudentDaoImp注入到StudentServiceImp
    1.set方式
    在这里插入图片描述
    配置文件
    在这里插入图片描述
    当加载配置文件applicationContext.xml时,spring容器将StudentDao的实现类StudentDaoImp注入到StudentServiceImp实现类中。

    2.构造方法注入
    在这里插入图片描述
    注意:这里的构造方法没忘了添加

    配置文件
    在这里插入图片描述

    3.p命名空间注入
    在这里插入图片描述
    配置文件
    在这里插入图片描述
    p命名空间注入,实际还是通过set方法注入,只是写法不一样,写法没有子标签,使用的是标签属性。

    以上就是3种注入的方式的使用方法,有什么 不足的地方,欢迎各位大牛指出。

    展开全文
  • Spring依赖注入DI)的三种方式 Spring依赖注入DI)的三种方式,分别为: 1. 接口注入 2. Setter方法注入 3. 构造方法注入 下面介绍一下这三种依赖注入在Spring中是怎么样实现的。 首先我们需要以下几个...
  • 使用有参构造方式三种) 都需要使用标签 ​ 第一种:使用下标(index) ​ index=“0” 就是有参构造方法里面的第一个参数,以此类推 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns=...
  • 依赖注入DI DI依赖注入):就是 拿到的对象的属性,已经被注入好了相关的值,直接使用即可。 在Spring中,注入依赖对象可以采用手工装配或自动装配,在实际应用开发中建议使用手工装配,因为自动装配会产生许多...
  • 依赖注入(DI)的三种实现方式

    万次阅读 2017-09-21 10:28:24
    首先,依赖注入DI)的实现方式三种:设值注入、构造方法注入、接口注入,下面来看看这三种注入方式在Spring中的支持怎么样。 1、设值注入。  ①、新建一个项目  ②、新建一个User类,实现setter、getter方法 ...
  • Spring 依赖注入DI三种方式

    千次阅读 2019-05-09 12:03:46
    Spring通过依赖注入DI)实现控制反转(IOC)的通常有三种方式: 构造方法注入 setter注入(属性) 注解注入(接口) 构造方法注入 先简单了解一下测试项目的结构,用maven构建的,四个包: entity:存储实体...
  • Spring依赖注入DI)的三种方式,分别为: 1. 接口注入 2. Setter方法注入 3. 构造方法注入   下面介绍一下这三种依赖注入在Spring中是怎么样实现的。   首先我们需要以下几个类: 接口 Logic.java...
  • 总得来说,Spring中依赖注入有这么三种方式: ①通过set方式赋值 ②通过构造器赋值 ③通过p标签赋值 下面我们稍稍展开来谈: 1.通过set方式赋值 <bean id="teacher" class="org.szh.entity.Teacher" p:age=...
  • setter,构造,注解,三种依赖方式的总结 setter依赖注入总结: 先写个测试类 package Spring05; import org.junit.Before; import org.junit.Test; import org.springframework.context.ApplicationContext; import ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 639
精华内容 255
关键字:

di依赖注入三种方式