Spring框架之容器(applicationContex.xml)

最新推荐文章于 2024-06-29 11:37:30 发布
最新推荐文章于 2024-06-29 11:37:30 发布
阅读量888 收藏 1
点赞数
分类专栏： 框架(SS2H MyBatis) Java从入门到高级编程 文章标签： spring 容器 applicationContex.xm BeanFactory
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuosixiaonengshou/article/details/53978570
版权

 

简单介绍

  1. Spring有两项技术：容器和AOP
  2. Spring现在已经从2.5到3.0，现在已经到了4.0版本，但是最好还是从2.5开始学起。
  3. 在Spring配置文件applicationContext.xml(当然名字是可以随意取的，但是还是要尽量遵守规范)
  4. 通过xml造出BeanFactory拿出bean
  5. 更多请见代码中有详细注解

 

简单初识Spring的容器技术

canSpring25Demo

 

Person.java

package cn.hncu.spring25;

public class Person {
	private String name;
	private Integer age;
	private Cat cat;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Cat getCat() {
		return cat;
	}
	public void setCat(Cat cat) {
		this.cat = cat;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", cat=" + cat + "]";
	}
	
}


 

Cat.java

package cn.hncu.spring25;

public class Cat {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Cat [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"
		xmlns:context="http://www.springframework.org/schema/context"
		xmlns:tx="http://www.springframework.org/schema/tx"
		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
	<!-- 默认是单例 -->
	<bean id="p1" class="cn.hncu.spring25.Person"></bean>
	<!-- 配置了scope="prototype"每次都是新new 一个对象，默认是 singleton-->
	<bean id="pp" class="cn.hncu.spring25.Person" scope="prototype"></bean>
	
	<bean id="p2" class="cn.hncu.spring25.Person">
		<property name="name" value="Jack"></property>
		<property name="age">
			<value>33</value>
		</property>
		<property name="cat" ref="cat"></property>
	</bean>
	<bean id="cat" class="cn.hncu.spring25.Cat" >
		<property name="name" value="Tom"></property>
	</bean>

</beans>


 

Demo.java

package cn.hncu.spring25;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class Demo {
	public static void main(String[] args) {
		Resource rs=new ClassPathResource("applicationContext.xml");
		BeanFactory factory=new XmlBeanFactory(rs);
		Person p1=(Person) factory.getBean("p1");//参数为xml配置bean的id
		Person p2=(Person) factory.getBean("p1");
		System.out.println(p1);
		System.out.println(p2);
		System.out.println(p1==p2);
		
		System.out.println("-------------------------------");
		
		Person p3=(Person) factory.getBean("pp");//参数为xml配置bean的id
		Person p4=(Person) factory.getBean("pp");
		System.out.println(p3);
		System.out.println(p4);
		System.out.println(p3==p4);
	}

}


结果图：

 

canSpring30Demo


Person.java

package cn.hncu.domain;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Person {
	private String name;
	private Integer age;
	private Cat cat;
	private List<String> list;
	private Map<String, Object> map;
	private Set<String> set;
	
	private Object[] obj;
	
	public Object[] getObj() {
		return obj;
	}
	public void setObj(Object[] obj) {
		this.obj = obj;
	}
	public Set<String> getSet() {
		return set;
	}
	public void setSet(Set<String> set) {
		this.set = set;
	}
	public Map<String, Object> getMap() {
		return map;
	}
	public void setMap(Map<String, Object> map) {
		this.map = map;
	}
	public List<String> getList() {
		return list;
	}
	public void setList(List<String> list) {
		this.list = list;
	}
	public Cat getCat() {
		return cat;
	}
	public void setCat(Cat cat) {
		this.cat = cat;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", cat=" + cat
				+ ", list=" + list + ", map=" + map + ", set=" + set + ", obj="
				+ Arrays.toString(obj) + "]";
	}
	
}


Cat.java

package cn.hncu.domain;

public class Cat {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	public void eatFish(){
		System.out.println("I like fish, it is delicious");
	}
	@Override
	public String toString() {
		return "Cat [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"
		xmlns:context="http://www.springframework.org/schema/context"
		xmlns:tx="http://www.springframework.org/schema/tx"
		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
	<bean  class="cn.hncu.domain.Person">
		<property name="name" value="Space"></property>
		<property name="age" value="20"></property>
		<property name="cat" ref="tigerCat"></property> 
		
		<property name="list">
			<list>
				<value>XXX</value>
				<value>YYY</value>
				<value>ZZZ</value>
			</list>
		</property>
		<property name="map">
			<map>
				<entry key="name" value="Hi"></entry>
				<entry key="age" value="15"></entry>
			</map>
		</property>
		<property name="set">
			<set>
				<value>111</value>
				<value>222</value>
				<value>333</value>
			</set>
		</property>
		<property name="obj">
			<array>
				<value>一个字符串</value>
				<ref bean="tigerCat"/>
				<bean class="cn.hncu.domain.Cat">
					<property name="name" value="Tom"></property>
				</bean>
				<list>
					<value>aaa</value>
					<value>111</value>
				</list>
			</array>
		</property>
	</bean>

	<!-- 外部导入xml中的bean -->
	<import resource="2.xml"/>
</beans>

 

2.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:context="http://www.springframework.org/schema/context"
		xmlns:tx="http://www.springframework.org/schema/tx"
		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
	<bean id="tigerCat" class="cn.hncu.domain.Cat">
		<property name="name" value="Tiger"></property>
	</bean>

</beans>


Demo.java

package cn.hncu.demo;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.hncu.domain.Person;

public class Demo {
	public static void main(String[] args) {
		//换种方式加载配置文件
		ApplicationContext ctx=new ClassPathXmlApplicationContext("cn/hncu/demo/applicationContext.xml");
		Person p=ctx.getBean(Person.class);
		p.getCat().eatFish();
		System.out.println(p);
	}
}


 

简单的学生登录：

 

StudDemo.java

package cn.hncu.stud;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.hncu.stud.action.LoginAction;

public class StudDemo {
	public static void main(String[] args) {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("cn/hncu/stud/stud.xml");
		LoginAction action=ctx.getBean(LoginAction.class);
		action.login();
	}
}


 

Stud.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:context="http://www.springframework.org/schema/context"
		xmlns:tx="http://www.springframework.org/schema/tx"
		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
	<bean  class="cn.hncu.stud.action.LoginAction">
		<property name="service" ref="service"></property>
	</bean>
	
	<bean id="service" class="cn.hncu.stud.service.IStudServiceImpl">
		<property name="orclDao" ref="orcl"></property>
	</bean>
	<!-- 如果想把改用jdbc方式访问，那么把该段的注释去掉 且 把上一段有关orcl的注入注释上
		<bean id="service" class="cn.hncu.stud.service.IStudServiceImpl">
			<property name="jdbcDao" ref="orcl"></property>
		</bean>
	 -->
	<bean id="jdbcDao" class="cn.hncu.stud.dao.IStudJdbcDao"></bean>
	<bean id="orclDao" class="cn.hncu.stud.dao.IStudOrclDao"></bean>
</beans>


LoginAction.java

package cn.hncu.stud.action;

import cn.hncu.stud.service.IStudService;

public class LoginAction {
	//依赖Spring注入service接口,可以不用再new 实现类，但是set和get方法必须要写
	private IStudService service=null;
	public void login(){
		service.login();
	}
	public IStudService getService() {
		return service;
	}
	public void setService(IStudService service) {
		this.service = service;
	}
	
}


IStudService.java

package cn.hncu.stud.service;

public interface IStudService {
	public void login();
}

 

IStudServiceImpl.java

package cn.hncu.stud.service;

import cn.hncu.stud.dao.IStudDAO;

public class IStudServiceImpl implements IStudService{
	//依赖Spring注入service接口,可以不用再new 实现类，但是set和get方法必须要写
	private IStudDAO dao=null;
	@Override
	public void login() {
		dao.login();
	}
	public IStudDAO getDao() {
		return dao;
	}
	public void setDao(IStudDAO dao) {
		this.dao = dao;
	}
	
}


 

IStudDAO.java

package cn.hncu.stud.dao;

public interface IStudDAO {
	public void login();
}


 

IStudJdbcDAO.java

package cn.hncu.stud.dao;

public class IStudJdbcDao implements IStudDAO{
	@Override
	public void login() {
		System.out.println("student  is   login  ----jdbc");
	}
}


 

IStudOrclDao.java

package cn.hncu.stud.dao;

public class IStudOrclDao implements IStudDAO{
	@Override
	public void login() {
		System.out.println("student  is   login  ----Orcl");
	}
}


 

有了Spring技术以后，实现service和dao的注入，就不再需要依赖实现类了(但要写接口的set和get方法)，而且通过xml就可以配置，代码不需要改变，符合开闭原则。

 

 

D灿
关注
专栏目录
开源框架面试之Spring面试题
用文字记录下每一个瞬间的感动和每一次思考的火花
10-04 9万+
文章目录1、什么是Spring框架？Spring框架有哪些主要模块？2、使用Spring框架能带来哪些好处？3、什么是控制反转（IOC）？什么是依赖注入？4. 请解释下Spring框架中的IOC？5、BeanFactory 和 Applicationcontext 有什么区别？6、Spring有几种配置方式？7、如何用基于XML配置的方式配置Spring？8、如何用基于Java配置的方式配置Spring？9、怎样用注解的方式配置Spring？10、请解释Spring Bean的生命周期？11、Spring
applicationContext.xml
09-01
Spring applicationContext.xml常见部分属性的使用备注
ApplicationContext.xml
03-05
博文链接：https://jacklang.iteye.com/blog/152841
Spring中的ApplicationContext
qq_43687990的博客
10-09 386
上图为ApplicationContext的子接口以及ApplicationContext的主要实现类 1.ApplicationContext的主要实现类： ——ClassPathXmlApplicationContext:从类路径下记载配置文件 ——FilesSystemXmlApplicationContext:从文件系统中加载配置文件 2.ConfigurableApplicationCo...
Spring ApplicationContext
盲目的拾荒者的博客
06-18 552
详细探索 Spring ApplicationContext接口Spring 框架的主要特性之一是 IoC（控制反转）容器。Spring IoC 容器负责管理应用程序的对象。它使用依赖注入来实现控制反转。接口*BeanFactory* 和*ApplicationContext* 代表 Spring IoC 容器。这里，BeanFactory是访问 Spring 容器的根接口。它提供了管理 bean 的基本功能。另一方面，ApplicationContext 是BeanFactory的子接口。因此，它提供了B
【Spring】Spring框架中的一个核心接口ApplicationContext 简介，以及入口 Run() 的源码分析
代码的魅力，根本走不出来
03-26 1565
ApplicationContext 是Spring框架中的一个核心接口，它是Spring IoC容器的实现之一，用于管理和组织应用程序中的各种Bean，同时提供了一系列功能来支持依赖注入、AOP等特性。简单来说，ApplicationContext 是一个大型的、高级的Spring IoC容器，它扩展了BeanFactory接口，提供了更多的功能和特性，比如事件传播、国际化支持、资源加载、生命周期回调等。
SSM框架配置文件整理（一） applicationContext.xml
Zain_horse的博客
04-24 2566
1.applicationContext.xml配置文件在web项目中的作用： spring容器创建 数据注 连接数据库 …… 这些功能是完成SSM框架对web项目作用的基础
Spring框架学习总结
thinkhi9999的博客
08-16 1211
Spring框架的优势是模块化的IoC设计模式，使得开发人员可以专心开发程序的模块化部分。它能够降低开发企业级应用的复杂性，使用Spring替代EJP发开企业级应用，而不用提心工作量太大，开发进度难以控制和复杂的测试过程等问题。Spring简化了企业级应用的开发，降低了开发成本并整合了各种流行框架，它以IoC和AOP(面向切面编程)两种先进的技术为基础，完美简化了企业级应用开发的复杂度。 Spring组成 ...
Spring框架中事件发布及其原理
Mr_YuanD的博客
01-31 1780
Spring框架中事件发布及其原理事件源发布事件定义事件源定义事件定义监听器测试springContextHolderApplicationContextAware接口ApplicationContext发布事件的原理AbstractApplicationContext事件广播earlyApplicationEventsApplicationEventMulticasterSimpleApplicationEventMulticaster总结附录 在业务系统中，当多个模块之间需要进行通信的时候，事件可以作
开源框架面试专题及答案.pdf
03-15
在IT行业的面试中，开源框架的掌握程度往往是衡量开发者能力的重要标准之一，特别是Spring框架。下面我们将深入探讨Spring框架中的几个关键概念，包括BeanFactory和ApplicationContext的区别、Spring Bean的生命周期...
容器使用及XML使用
09-23
经本人测试可执行，运行环境VC2005，主要包含容器使用例程及XML文档演示
配置applicationContext.xml文件
最新发布
技术研究中心
06-29 2068
是Spring应用程序的上下文配置文件，用于定义Spring容器中bean的创建、初始化、装配和管理。在这个文件中，我们可以配置各种bean及其依赖关系，甚至可以定义切面、事务管理、数据源等。每个bean元素都有一个唯一的id属性，用于标识bean实例，还有一个class属性，用于指定bean的实现类。是Spring应用程序的核心配置文件，负责管理和配置应用程序中的各种bean。在这个示例中，我们启用了注解驱动的事务管理，这样我们可以在代码中使用。的方法，Spring会自动调用这个方法，将。
ApplicationContext介绍
热门推荐
畅春园
01-15 1万+
ApplicationContext是Spring中的核心接口和容器，允许容器通过应用程序上下文环境创建、获取、管理bean。在构建容器的时候，创建对象采用的策略是立即加载的方式，即只要一读取完配置文件就立即创建配置文件中配置的对象。BeanFactory采用的是延迟加载的方式，什么时候根据id获取对象了，什么时候才真正地创建对象。 该接口具有三个常用的实现类： 1、ClassPathXmlApplicationContext：可以加载类路径下的配置文件，要求配置文件必须在类路径之下。 2、FileSyst
Propagation Propagation的七种事务属性 七种事务属性 NOT_SUPPORTED REQUIRED
qq_44043843的博客
10-09 6677
Propagation类的七种事务属性解释（REQUIRED，SUPPORTS，MANDATORY，REQUIRES_NEW，NOT_SUPPORTED，NESTED，NEVER） Spring中七种Propagation类的事务属性详解： REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 required SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。 supports MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。.
Spring框架学习：ApplicationContext.xml的配置和运用
qq_53641185的博客
08-08 2247
ApplicationContext.xml文件。如下是Test1的测试类。如下是Test2的测试类。
ApplicationContext介绍 ApplicationContext是什么？
Move on
03-08 1万+
如果说BeanFactory是Spring的心脏，那么ApplicationContext就是完整的身躯了。ApplicationContext由BeanFactory派生而来，提供了更多面向实际应用的功能。 ApplicationContext类体系结构 ApplicationContext的主要实现类是ClassPathXmlApplicationContext和FileSystemXmlApplicationContext，前者默认从类路径加载配置文件，后者默认从文件系统中装载配置文件
自己实现的一个XML对象容器
知识需要积累
06-11 182
IApplicationContent为容器，通过其中的方法可以添加配置文件，根据ID获得注入对象。注入对象xml规范见template.dtd。添加的配置文件交由IXMLParse负责解析。IXMLParse将文件解析的信息存放入配件IBean中，IBean中存放着关于对象类型，生产函数及其参数（不设定name属性或属性值为空时为构造函数），还有一些预定义的属性及值，参数和属性均支持引用注入的其...
The import org.springframework.context.support.ClassPathXmlApplicationContext cannot be resolved
johnhuster的专栏
07-27 9565
The import org.springframework.context.support.ClassPathXmlApplicationContext cannot be resolved [WARNING] 读取 spring-context-3.0.7.RELEASE.jar时出错; invalid LOC header (bad signature)导致
面试题：什么是ApplicationContext，它背后的原理和应用场景你清楚吗？
jakelihua
06-09 1190
当需要获取一个Bean时，ApplicationContext会检查是否已经存在该Bean实例，如果不存在，则创建新实例并返回该实例给调用方。总之，ApplicationContext是Spring框架非常重要的容器之一。它具有许多高级特性和功能，能够让我们更快地构建出高效、可扩展和易维护的应用程序，并且可以灵活地应对各种部署环境所需的配置信息。ApplicationContext是Spring框架中重要的容器之一，它是BeanFactory的超集，提供了更多的企业级特性和功能。
Spring SSH框架：详解applicationContext.xml头部配置
在SSH（Spring、Struts、Hibernate）框架中，`applicationContext.xml`是Spring的核心配置文件，它定义了整个应用的初始化、依赖注入和事务管理等关键组件。头部文件是配置文件的开头部分，它包含了XML文档的一些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值