`

Spring 简单案例(依赖注入)_02

阅读更多
      上一篇是注解注入一个bean,这篇就是XML配置注入一个bean

     废话不多说直接上代码,首先是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"
    xmlns:c="http://www.springframework.org/schema/c"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="classAId" class="com.expect.oa.entity.ClassA"></bean>

    <bean id="classBId" class="com.expect.oa.entity.ClassB">
        <!-- 这嘎达用的是构造函数注入,注入了一个对象,跟两个字符串 -->
    	<constructor-arg ref="classAId"></constructor-arg>
    	<constructor-arg name="string1" value="some string1"></constructor-arg>
    	<constructor-arg name="string2" value="some string2"></constructor-arg>
    </bean>
    
    <bean id="classCId" class="com.expect.oa.entity.ClassC">
        <!-- 这嘎达也是用的构造函数注入,注入了一个ArrayLisy<String> -->
    	<constructor-arg>
    		<list>
    			<value>Lin</value>
    			<value>Chirs</value>
    			<value>Biger</value>
    		</list>
    	</constructor-arg>
    </bean>
    
    <!-- 这嘎达是属性注入,注入一个对象 -->
    <bean id="classDId" class="com.expect.oa.entity.ClassD">
    	<property name="aEntity" ref="classAId"></property>
    </bean>
    
    <!-- 这嘎达是注解的配置文件 -->
    <bean id="SpringXMLconfig_other" class="com.expect.oa.config.SpringXMLconfig_other" />
    
</beans>

     上面的配置,是以XML为主,也可以注解的方式:
package com.expect.oa.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;

import com.expect.oa.entity.ClassE;
import com.expect.oa.entity.ClassF;

@Configuration
@Import(value={SpringXMLconfig.class})
@ImportResource(locations={"classpath:spring/ApplicationContext.xml"})
public class SpringXMLconfig_other {

	@Bean
	public ClassF getClassF(ClassE fEntity){
		return new ClassF(fEntity);
	}
	
}

     这是其中一个配置,包含在上面咯:
package com.expect.oa.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.expect.oa.entity.ClassE;

@Configuration
public class SpringXMLconfig {

	@Bean
	public ClassE  getClassE (){
		return new ClassE();
	}
	
}

     下面开始声明几个类:
package com.expect.oa.entity;

public class ClassA {

}

package com.expect.oa.entity;

public class ClassB {

	private ClassA aEntity;

	private String string1;
	
	private String string2;
	
	public ClassB(ClassA aEntity){
		this.aEntity = aEntity;
	}
	
	public ClassA getaEntity() {
		return aEntity;
	}

	public void setaEntity(ClassA aEntity) {
		this.aEntity = aEntity;
	}

	public String getString1() {
		return string1;
	}

	public void setString1(String string1) {
		this.string1 = string1;
	}

	public String getString2() {
		return string2;
	}

	public void setString2(String string2) {
		this.string2 = string2;
	}

	public ClassB(ClassA aEntity, String string1, String string2) {
		super();
		this.aEntity = aEntity;
		this.string1 = string1;
		this.string2 = string2;
	}

}

package com.expect.oa.entity;

import java.util.List;

public class ClassC {

	private List<String> names;

	public List<String> getNames() {
		return names;
	}

	public void setNames(List<String> names) {
		this.names = names;
	}

	public ClassC(List<String> names) {
		super();
		this.names = names;
	}
	
	
}

package com.expect.oa.entity;

public class ClassD {

	ClassA aEntity;

	public ClassA getaEntity() {
		return aEntity;
	}

	public void setaEntity(ClassA aEntity) {
		this.aEntity = aEntity;
	}

}

package com.expect.oa.entity;

public class ClassE {

}

package com.expect.oa.entity;

public class ClassF {

	private ClassE eEntity;

	public ClassF(ClassE eEntity){
		this.eEntity = eEntity;
	}

	public ClassE geteEntity() {
		return eEntity;
	}

	public void seteEntity(ClassE eEntity) {
		this.eEntity = eEntity;
	}
}

     准备工作完毕了,下面我们测试吧:
package com.expect.oa.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.expect.oa.entity.ClassB;
import com.expect.oa.entity.ClassC;
import com.expect.oa.entity.ClassD;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:spring/ApplicationContext.xml"})
public class TestXMLSpringDI {

	@Resource(name="classBId")
	ClassB bEntity;
	
	//通过构造函数构造了一个对象成员变量,跟两个字符串变量。
	
	@Test
	public void test() {
		System.out.println(bEntity.getString1());
		System.out.println(bEntity.getaEntity());
	}

	@Resource(name="classCId")
	ClassC cEntity;
	
	//构造一个list
	
	@Test
	public void testXmlDi (){
		for (int i = 0;i<3;i++){
			String name = cEntity.getNames().get(i);
			System.out.println(name);
		}
	}
	
	@Resource(name="classDId")
	ClassD dEntity;
	
	//属性注入对象
	
	@Test
	public void testXmlPropertyDi (){
		System.out.println(dEntity.getaEntity());
	}
}

     测试一XML配置为主的配置:
package com.expect.oa.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.expect.oa.entity.ClassD;
import com.expect.oa.entity.ClassF;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:spring/ApplicationContext.xml"})
public class TestSpringXMLConfig {

	//这里是通过注解配置的
	@Autowired
	ClassF fEntity;
	
	@Test
	public void test() {
		System.out.println(fEntity.geteEntity());
	}
	
	//属性注入对象,这里是通过XML配置的
	@Resource(name="classDId")
	ClassD dEntity;
	
	@Test
	public void testXmlPropertyDi (){
		System.out.println(dEntity.getaEntity());
	}
	
}

     测试以注解为主的配置:
package com.expect.oa.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.expect.oa.config.SpringXMLconfig_other;
import com.expect.oa.entity.ClassD;
import com.expect.oa.entity.ClassF;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringXMLconfig_other.class})
public class TestSpringConfig {
	//这里是通过注解配置的
	@Autowired
	ClassF fEntity;
	
	@Test
	public void test() {
		System.out.println(fEntity.geteEntity());
	}
	
	//属性注入对象,这里是通过XML配置的
	@Resource(name="classDId")
	ClassD dEntity;
	
	@Test
	public void testXmlPropertyDi (){
		System.out.println(dEntity.getaEntity());
	}

}
分享到:
评论

相关推荐

    spring依赖注入

    Spring依赖注入是Spring框架的核心特性之一,它使得对象之间的依赖关系得以解耦,增强了代码的可测试性和可维护性。依赖注入(Dependency Injection,简称DI)的理念是,一个对象不应该负责寻找并创建它所依赖的对象...

    Spring Ioc(依赖注入)入门例子--属性注入

    Spring的核心特性之一就是它的Inversion of Control(IoC,控制反转)容器,也被称为Dependency Injection(DI,依赖注入)。这个概念是Spring框架使应用程序组件之间解耦的关键。让我们深入探讨一下Spring的IoC和...

    Spring_01_入门篇_依赖注入(控制反转)_XML

    Spring框架的依赖注入特性极大地提高了代码的可测试性和可维护性。通过XML配置,我们可以清晰地看到对象间的依赖关系,方便管理和维护。对于初学者来说,理解并实践Spring的DI和IOC是深入学习Java企业级开发的关键...

    spring_day02_spring_

    1. day02_eesy_01anno_ioc:这部分可能涉及Spring的注解驱动的依赖注入(IoC)。注解如@Autowired、@Component、@Service、@Repository和@Controller等,使得代码更加简洁,同时避免XML配置。IoC(Inversion of ...

    Spring_2000_Spring_Hibernate_HibernateTemplate

    Spring的主要特性包括依赖注入(DI)、面向切面编程(AOP)、容器管理的bean以及对其他框架的集成,比如与Hibernate的整合。 **依赖注入(DI)** Spring的核心之一是依赖注入,它允许对象在运行时通过容器获得所需...

    spring_in_action_source.

    《Spring in Action》是一本非常经典的Spring框架实战书籍,它深入浅出地介绍了Spring的核心概念和技术,包括依赖注入、AOP(面向切面编程)、数据访问、Web开发等多个方面。这个压缩包文件“spring_in_action_...

    spring依赖注入基础知识.rar

    在提供的压缩包文件中,可能包含了一些关于Spring依赖注入的实践案例,如`spring_lab11_2`、`spring_lab11_3`和`spring_lab11`。这些实验可能涵盖了如何在Spring环境中配置bean、实现依赖注入,以及如何处理数据库...

    JavaEE spring 依赖注入DI入门案例

    JavaEE spring 依赖注入DI入门案例

    spring作业--转账案例.zip_protectionbkd_spring

    2. **依赖注入**:在转账案例中,Spring通过DI管理对象之间的依赖关系,使得代码更加灵活和可测试。开发者可以声明所依赖的组件,由Spring容器负责实例化、装配以及管理这些组件。 3. **Spring事务管理**:转账操作...

    Spring_2900_Registration_7

    首先,我们要明白Spring框架的核心理念是依赖注入(Dependency Injection,简称DI)。通过DI,Spring可以管理应用程序中的对象,使得代码更加松耦合,易于测试和维护。注册在Spring中通常涉及到服务的注册、bean的...

    spring+servlet 入门hello_world

    其核心特性包括依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP)。依赖注入允许开发者在运行时通过外部配置来管理对象的依赖关系,降低了代码的耦合度。面向切面编程则允许...

    Spring入门案例

    总的来说,"Spring入门案例"旨在帮助初学者理解Spring的基本原理和使用方式,包括但不限于Bean的定义与管理、依赖注入的实现、以及Spring如何简化企业级应用的开发。通过深入学习和实践这个案例,你将能够更好地掌握...

    spring课堂案例

    "spring课堂案例"这个主题深入探讨了Spring框架的核心特性之一——依赖注入(Dependency Injection,简称DI)。依赖注入是一种设计模式,它有助于提升软件的灵活性、可测试性和可维护性。 依赖注入的主要目的是降低...

    liyunqi-blog_javaweb_spring_dubbo_mybatis_

    在本项目中,Spring作为基础架构层,负责管理对象的生命周期、依赖注入、AOP(面向切面编程)以及Web MVC(模型-视图-控制器)等核心功能。 2. **Dubbo服务治理框架**:Dubbo是阿里巴巴开源的高性能RPC(远程过程...

    Spring_in_Action_4.pdf-第四版-英文原版

    这本书涵盖了从基础到高级的多个Spring核心概念和技术,包括依赖注入、AOP(面向切面编程)、数据访问、Web开发以及Spring Boot等。 1. **依赖注入(Dependency Injection, DI)**:Spring的核心特性之一,它通过容器...

    Spring 入门案例

    **Spring 框架概述** ...通过这个入门案例,你可以学习到如何创建Spring Bean、如何进行依赖注入、如何编写和运行单元测试,以及如何使用Spring MVC处理HTTP请求。这些基本技能是掌握Spring框架的关键。

    SPRING案例

    Spring框架是Java开发中不可或缺的一部分,它以其强大的依赖注入(DI)和面向切面编程(AOP)功能而闻名。本案例将深入探讨Spring的核心特性,包括AOP、IOC、静态代理、动态代理以及与其他技术如Hibernate和Struts的...

    《Java EE企业级应用开发教程Spring+Spring MVC+MyBatis》_源代码.zip

    2. **Chapter 03** - Spring框架:讲解Spring的核心特性,如依赖注入(DI)和面向切面编程(AOP)。通过示例展示如何配置Spring容器,以及如何使用Bean定义、自动装配和作用域。 3. **Chapter 05** - Spring MVC:...

    spring架构项目案例

    总结来说,"spring架构项目案例"是一个适合初学者的实践教程,涵盖了Spring 2.0的关键特性,包括依赖注入、AOP、Spring MVC、JDBC支持、事务管理和ORM集成。通过学习和实践这个项目,开发者可以掌握Spring的核心概念...

Global site tag (gtag.js) - Google Analytics