Spring框架之容器(applicationContex.xml)

最新推荐文章于 2024-03-26 17:13:25 发布
最新推荐文章于 2024-03-26 17:13:25 发布
阅读量864 收藏 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灿
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring源码解析之默认配置文件名/WEB-INF/applicationContext.xml
挨踢俗人俗语记录
05-25 3367
众所周之，spring源码解析之默认配置文件名/WEB-INF/applicationContext.xml。但是这个是在spring源代码里记录的呢？ 今天就抱着试一试的态度去找到答案。 首先查看工程中的 web.xml,其中配置 spring的代码如下 contextConfigLocation /WEB-INF/applicationContext.x
SSM框架配置文件整理（一） applicationContext.xml
Zain_horse的博客
04-24 2415
1.applicationContext.xml配置文件在web项目中的作用： spring容器创建 数据注 连接数据库 …… 这些功能是完成SSM框架对web项目作用的基础
07 Spring事务
m0_51697147的博客
08-03 1045
事务：不可分割的原子操作，即一系列的操作要么同时成功，要么同时失败。 1.事务简介、2.事务管理方案、3.事务管理器、4.事务控制的API、5.事务的相关配置、6.事务的传播行为、7.事务的隔离级别、8.注解配置声明式事务......
【Spring】Spring框架中的一个核心接口ApplicationContext 简介，以及入口 Run() 的源码分析
最新发布
代码的魅力，根本走不出来
03-26 911
ApplicationContext 是Spring框架中的一个核心接口，它是Spring IoC容器的实现之一，用于管理和组织应用程序中的各种Bean，同时提供了一系列功能来支持依赖注入、AOP等特性。简单来说，ApplicationContext 是一个大型的、高级的Spring IoC容器，它扩展了BeanFactory接口，提供了更多的功能和特性，比如事件传播、国际化支持、资源加载、生命周期回调等。
ApplicationContext介绍
畅春园
01-15 1万+
ApplicationContext是Spring中的核心接口和容器，允许容器通过应用程序上下文环境创建、获取、管理bean。在构建容器的时候，创建对象采用的策略是立即加载的方式，即只要一读取完配置文件就立即创建配置文件中配置的对象。BeanFactory采用的是延迟加载的方式，什么时候根据id获取对象了，什么时候才真正地创建对象。 该接口具有三个常用的实现类： 1、ClassPathXmlApplicationContext：可以加载类路径下的配置文件，要求配置文件必须在类路径之下。 2、FileSyst
Spring 报错—“通配符的匹配很全面, 但无法找到元素 'aop:aspectj-autoproxy' 的声明”
qq_35556254的博客
06-10 1498
错误代码如下： 六月 10, 2019 8:54:20 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7c3...
SpringBoot之logback-spring.xml不生效的解决方法
08-28
主要介绍了SpringBoot之logback-spring.xml不生效的解决方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详解spring applicationContext.xml 配置文件
08-31
在Spring框架中，`applicationContext.xml`是核心的配置文件，它定义了应用上下文，即Spring容器，用来管理所有bean的创建、初始化、依赖注入以及生命周期。这个文件使用XML语法，遵循特定的命名空间和schema，以...
Spring 应用框架技术面试题.doc
05-25
Spring 应用框架技术面试题.doc Spring 应用框架技术面试题.doc Spring 应用框架技术面试题.doc Spring 应用框架技术面试题.doc Spring 应用框架技术面试题.doc Spring 应用框架技术面试题.doc Spring 应用框架技术...
Springboot 日志logback-spring.xml 配置文件
01-25
用于日志配置
Spring手动生成web.xml配置文件过程详解
08-18
主要介绍了Spring手动生成web.xml配置文件过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Propagation Propagation的七种事务属性 七种事务属性 NOT_SUPPORTED REQUIRED
qq_44043843的博客
10-09 6575
Propagation类的七种事务属性解释（REQUIRED，SUPPORTS，MANDATORY，REQUIRES_NEW，NOT_SUPPORTED，NESTED，NEVER） Spring中七种Propagation类的事务属性详解： REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 required SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。 supports MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。.
Spring初见杀——classNotFound异常
smithlaod的博客
03-19 1073
今天第一次使用Spring的aop切面编程的xml配置，出现了这样的异常： 三月 19, 2019 10:47:01 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh 信息: Refreshing org.springframework.context.support.Cla...
org.springframework.beans.factory.BeanDefinitionStoreException: Unexpected exception parsing XML doc
热门推荐
longtingjing的专栏
10-28 1万+
信息: Loading XML bean definitions from class path resource [beans-annotation.xml] Exception in thread "main" org.springframework.beans.factory.BeanDefinitionStoreException: Unexpected exception parsin
Spring中的ClassPathXMLApplicationContext类读取XML文件失败的情况
benimaur0的专栏
11-15 9240
最近在研究Java的Spring，跟着这个文章来对着一步一步的做： http://www.cnblogs.com/xing901022/p/4178963.html 然而即使是比葫芦画瓢，也不是一帆风顺。 期间遇到了这样一个问题： 在按照文章导入Spring3.0.5的jar包并且按照文章里提到的步骤来搭建环境的情况下，写好Person和Test类，创建好Bean.xml后，在ecli
搭建spring项目报错
yxz2017的博客
05-23 609
搭建Spring项目时报错：五月 23, 2018 10:29:47 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext...
加载Spring框架中会出现的问题（我所遇到的）
qq_41616629的博客
04-11 871
第一步下载spring.jar以及commons-logging，以及log4j（学习过程中并没有告诉我要加载这个！所以在第一个使用框架完成的程序                                                                             中就会遇到问题）网址我就不贴了，百度一下全都知道第二步我使用的是eclipse,所以要新建java项...
ApplicationContext介绍 ApplicationContext是什么？
Move on
03-08 1万+
如果说BeanFactory是Spring的心脏，那么ApplicationContext就是完整的身躯了。ApplicationContext由BeanFactory派生而来，提供了更多面向实际应用的功能。 ApplicationContext类体系结构 ApplicationContext的主要实现类是ClassPathXmlApplicationContext和FileSystemXmlApplicationContext，前者默认从类路径加载配置文件，后者默认从文件系统中装载配置文件
Spring框架：基于XML配置AOP
yorkmass
01-19 239
基于配置文件配置AOP 同理我们需要导入spring需要的jar包，这个步骤就不在重复了，和之前一样 我们新建一个包：com.yorkmass.spring.aop.xml，下面新建1个接口和4个类，在src目录新建配置文件命名为： applicationContext-xml.xml，打开勾选aop、beans命名空间 程序结构如下：  ArithmeticCalculator接口...
spring框架中bean.xml配置什么
05-20
在 Spring 框架中，bean.xml 配置文件主要用于声明和配置 Bean，以便在应用程序中使用。其中包括以下内容： 1. Bean 的定义：包括 Bean 的 ID、类名、作用域等信息。 2. Bean 的属性：设置 Bean 的属性，包括基本数据类型、引用类型、集合类型等。 3. Bean 的依赖：设置 Bean 之间的依赖关系，包括构造函数注入和属性注入。 4. Bean 的初始化和销毁方法：设置 Bean 的初始化和销毁方法，包括 InitializingBean 和 DisposableBean 接口的实现、@PostConstruct 和 @PreDestroy 注解等。 5. AOP 配置：配置切面、通知和切点等，实现面向切面编程。 6. 其他配置：包括 Spring 框架的各种配置，例如数据源配置、事务配置、缓存配置等。 总之，bean.xml 配置文件是 Spring 框架中非常重要的配置文件，通过它可以完成 Spring 的各种功能，实现对应用程序的控制反转和依赖注入。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值