- 浏览: 1571331 次
- 来自: 上海
文章分类
- 全部博客 (374)
- Java (101)
- Struts (54)
- Oracle (30)
- JavaScript (16)
- Spring (27)
- Hibernate (16)
- MyEclipse (3)
- JSF (1)
- FreeMarker (2)
- SiteMesh (2)
- JfreeChart (2)
- Ibatis (2)
- JSP (12)
- MyBatis (4)
- SWFupload (1)
- EJB (4)
- Jboss (4)
- WebService (2)
- Linux (16)
- Android (2)
- XML (6)
- Java 网络编程 (13)
- AXIS2 (1)
- FTP (1)
- Jswing (1)
- Socket (3)
- 杂文选集 (6)
- solr (2)
- PS (1)
- Tomcat (7)
- JDBC (9)
- Highcharts (1)
- maven (1)
- Nodejs (0)
- navicat (2)
- Exception (5)
- eclipse (3)
- jQuery (1)
- springMVC (4)
- MySQL (11)
- SVN (1)
- Sql Server (1)
- zookeeper (1)
- JVM (1)
- Groovy (2)
- Git (1)
- Nginx (1)
- DynamicReport (1)
- IDEA (2)
- JasperReports (1)
- Postgresql (2)
- Mac (1)
- gradle (1)
- 数据结构算法 (1)
最新评论
-
hpu145:
引用引用
java 千分位的添加和去除 -
被遗忘的下路:
少了个junit-4.8.2的包
SSH2整合完整案例(四十三) -
白天看黑夜:
java过滤emoji字符处理,希望能帮到你http://ww ...
emoji 表情图片解决方法 -
caipeiming:
这个挺好JavaScript实现input输入框控件只允许输入 ...
js 控制文本框只能输入中文、英文、数字等 -
双子树:
东西太好啦受教啊
Struts2 JSP中将list,set ,Map传递到Action然后<s:iterator>遍历(三十五)
spring 第1天 IOC,DI,国际化,容器事件
- 博客分类:
- Spring
1.构造注入(就是使用 构造方法)
2,设值注入(就是使用setXX()方法)
Spring 容器:最基本的接口就是BeanFactory,BeanFactory负责配置,创建,管理Bean,它有一个子接口ApplicationContext,被称为"上下文",spring 还负责管理Bean和Bean之间的关系
Spring 的配置文件
applicatoinContext:一般不会使用 BeanFactory的实例,而是使用 ApplicationContext,因为 它包含了BeanFactory的所有功能功能,而且还提供了额外的功能:
ApplicationContext支持的国际化
ApplicationContext的事件机制 :采用的是观察者设计模式,通过ApplicationEvent和ApplicationListener,就可以对ApplicationContext的事件处理
让Bean获取spring容器:只需要实现 ApplicationContextAware 接口就可以获取spring容器了
2,设值注入(就是使用setXX()方法)
package cn.sh.springmvc.service.user; import cn.sh.springmvc.dao.UserDAO; public class UserService { private String name; private int age; private UserDAO userdao; public void info(){ System.out.println("名称为:"+name+"年龄:"+age); } //设值注入 public void setName(String name) { this.name = name; } public UserService() { System.out.println("调用servie:service初始化"); } //采用构造注入 public UserService(int age) { this.age = age; } public UserService(UserDAO userdao) { super(); this.userdao = userdao; } public UserDAO getUserdao() { return userdao; } public void setUserdao(UserDAO userdao) { this.userdao = userdao; } }
<bean id="userService" class="cn.sh.springmvc.service.user.UserService" > <!--构造注入--> <constructor-arg name="age" value="18" type="int"/> <!--设值注入--> <property name="name" value="wawa"/> </bean>
Spring 容器:最基本的接口就是BeanFactory,BeanFactory负责配置,创建,管理Bean,它有一个子接口ApplicationContext,被称为"上下文",spring 还负责管理Bean和Bean之间的关系
//BeanFactory接口包含如下几个基本方法 boolean containsBean(String name); //判断spring容器中是否保航id为name的bean实例 <T> T getBean(Class<T> requiredType);//获取Spring容器中属于requiredType类型的唯一实例. Object getBean(String name); //返回容器中ID为name的Bean实例 <T> T getBean(String name,Class requiredType) ;//返回容器中ID为name,并且类型为requiredType的Bean. Class<?> getType(String name);//返回容器中指定Bean的实例类型. //BeanFactory 有一个常用的实现类:XmlBeanFactory //BeanFactory 有一个子接口:ApplicationContext 该接口的实现类有: //1:FileSystemXmlApplicationContent //2:ClassPathXmlApplicationContext //3:XmlWebApplicationContext (web中常用) //4:AnnotaionConfigXmlApplicationContext (web中常用)
//一般的java应用程序 非web InputStreamResource isr=new FileSystemResource("applicationContext.xml"); XmlBeanFactory factory=new XmlBeanFactory(isr); //或者 ClassPathResource res=new ClassPathResource("appliactionContext.xml"); XmlBeanFactory factory=new XmlBeanFactory(res); //如果有多个配置文件采用BeanFactory的子接口 ApplicationContext act=new ClassPathXmlApplicationContext(new String[]{"bean.xml","bean1.xml"}); //或者 ApplicationContext act=new FileSystemApplicationContext(new String[]{"bean.xml","bean1.xml"});
Spring 的配置文件
<!--采用 XML Schema 来定义配置文件--> <?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:tx="http://www.springframework.org/schema/tx" 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-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd" default-autowire-candidates="*abc" default-lazy-init="true"> ...bean </beans> <!--采用DTD来定义配置文件 :--> <!--如果用DTD方式:配置文件中就不能使用spring2.X Spring3.0新增的配置标签 比如:2.x dependency-check 属性 3.0 JSP 标签, Hibernate标签, Tiles 2.2 标签 --> <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd"> <beans> ...bean </beans>
applicatoinContext:一般不会使用 BeanFactory的实例,而是使用 ApplicationContext,因为 它包含了BeanFactory的所有功能功能,而且还提供了额外的功能:
//1:ApplicatonContext 继承了MessageSource接口,因此提供了国际化支持 //2:提供了资源访问,比如URL和文件 //3:事件机制 //4:载入多个配置文件 //5:以声明的方式启动,并创建Spring容器 //当系统初始化ApplicaitonContext容器的时候,会初始化所有的singletion Bean.因此刚开始的时候可能需要消耗较大的系统开销.
ApplicationContext支持的国际化
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource"> <property name="basenames"> <list> <value>message</value> <!-- 多个开头的资源文件.... --> </list> </property> </bean> <!--message_en_US.properties--> hello=welcom,{0} now=now is:{0} <!--message_zh_CN.properties--> hello=欢迎你,{0} now=现在时间是:{0} <!--native2ascii message.properties message_zh_CN.properties-->
@Test public void test1() { ApplicationContext act=new ClassPathXmlApplicationContext("classpath*:applicationContent.xml"); String [] args={"读者"}; Object [] args1={new Date()}; String hello=act.getMessage("hello", args, Locale.getDefault()); String now=act.getMessage("now", args1, Locale.getDefault()); System.out.println(hello); System.out.println(now); } //syso: //欢迎你,读者 //现在时间是:14-8-4 下午10:14
ApplicationContext的事件机制 :采用的是观察者设计模式,通过ApplicationEvent和ApplicationListener,就可以对ApplicationContext的事件处理
//定义容器事件 package cn.sh.springmvc.applicationContext; import org.springframework.context.ApplicationEvent; /** * spring 的applicationEvent 事件机制 主要采用 观察者模式 * * 1、 ContextRefreshedEvent:ApplicationContext容器初始化或者刷新时触发该事件。 2、 ContextStartedEvent:当使用ConfigurableApplicationContext接口的start()方法启动ApplicationContext容器时触发该事件。 3、 ContextClosedEvent:当使用ConfigurableApplicationContext接口的close()方法关闭ApplicationContext容器时触发该事件。 4、 ContextStopedEvent: 当使用ConfigurableApplicationContext接口的stop()方法停止ApplicationContext容器时触发该事件。 5、 RequestHandledEvent:Web相关时间,只能应用与使用DispatcherServet 的Web应用, 在使用spring作为前端的MVC控制器是,当spring处理用户请求后,系统会自动触发 该事件 * */ public class EmailEvent extends ApplicationEvent { private String address; private String text; public EmailEvent(Object source) { super(source); } public EmailEvent(Object source, String address, String text) { super(source); this.address = address; this.text = text; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public String getText() { return text; } public void setText(String text) { this.text = text; } } //定义一个容器监听 package cn.sh.springmvc.applicationContext; import org.springframework.context.ApplicationEvent; import org.springframework.context.ApplicationListener; public class EmailNotifier implements ApplicationListener { @Override public void onApplicationEvent(ApplicationEvent evt) { if(evt instanceof EmailEvent){ EmailEvent emevt=(EmailEvent)evt; System.out.println("需要发送邮件的接收地址:"+emevt.getAddress()); System.out.println("需要发送邮件的邮件正文:"+emevt.getText()); }else { System.out.println("容器本身的事件:"+evt); } } }
//在applicationContext.xml中加入一个监听bean <bean class="cn.sh.springmvc.applicationContext.EmailNotifier"/>
//测试spring容器事件 @Test public void test2() { ApplicationContext act=new ClassPathXmlApplicationContext("classpath*:applicationContent.xml"); EmailEvent ele=new EmailEvent("hello","spring_test@163.com","this is a test"); act.publishEvent(ele);//主动触发容器事件 }
让Bean获取spring容器:只需要实现 ApplicationContextAware 接口就可以获取spring容器了
package cn.sh.springmvc.applicationContextAware; import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanNameAware; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; /** * 让Bean获取Spring容器 */ public class MyContent implements ApplicationContextAware,BeanNameAware,InitializingBean,DisposableBean{ private ApplicationContext act; private String beanName; @Override public void setApplicationContext(ApplicationContext act) throws BeansException { System.out.println("ApplicationContextAware 接口的 获取容器对象方法"); this.act=act; } public ApplicationContext getContext(){ return act; } @Override public void destroy() throws Exception { System.out.println("DisposableBean 接口的方法:即将被销毁"); } @Override public void afterPropertiesSet() throws Exception { System.out.println("InitializingBean 接口的方法:Bean所有属性初始化完成后,执行的一个初始化方法"); } @Override public void setBeanName(String name) { System.out.println("BeanNameAware接口,获取 Bean的name"); beanName=name; } public String getBeanName() { return beanName; } }
<!--定义一个能够获取spring容器的bean --> <bean id="myContent" name="CH,CN" class="cn.sh.springmvc.applicationContextAware.MyContent" lazy-init="true"> </bean> <alias name="CH" alias="ZG"/> <alias name="chinese" alias="ZH"/> <!-- 别名之间还可以传承 --> <alias name="ZH" alias="HH"/>
//使用bean 获取 spring容器 ,一般不建议这样使用,除非有特别必要 @Test public void test3() { ApplicationContext act=new ClassPathXmlApplicationContext("classpath*:applicationContent.xml"); MyContent p=act.getBean("chinese",MyContent.class); System.out.println(p.getContext()); System.out.println(act==p.getContext()); }
发表评论
-
spring-session 中的坑
2017-07-06 15:34 9938spring-session 配置 依赖 gradle ... -
Spring AspectJ Aop Annotation
2017-03-29 17:08 660import org.aspectj.lang.Proce ... -
spring 第13天 使用@scheduled注解执行定时任务
2015-01-06 23:11 54011我们使用spring的注解 @Scheduled 执行定时任务 ... -
Spring 第12天,事务传播属性和 隔离级别
2014-09-28 00:36 7691 事务的传播属性(Propagation) 1) REQ ... -
spring 第11天 quartz任务调度
2014-08-24 13:59 1096Quartz是一个强大的企业级任务调度框架,Spring中继承 ... -
spring 第10 天 AOP 面向切面
2014-08-21 00:08 1714AOP(Aspect Orient Programming ... -
spring 第9天 Resurce 资源访问
2014-08-17 22:20 1817Spring Resource接口 spring提供的Reso ... -
spring 第8天 Spring 注解
2014-08-17 15:33 1427spring注解 @Component:标注一个普通的sp ... -
spring 第7天 Bean,BeanFactory处理器,配置器
2014-08-16 21:46 1180spring 两种后处理器 第一种,Bean 后处理器 对容器 ... -
spring 第6天SpEL,P命名空间,Util Schema
2014-08-13 22:52 1258使用p名称空间配置属性 ... -
spring 第5天不同作用域的bean,注入Field,方法返回值
2014-08-11 22:31 2059协调作用域不同步的bean 问题是;当一个singleton的 ... -
spring 第4天bean继承,init,destory-method
2014-08-10 17:54 1594深入理解Spring容器中的b ... -
spring 第3天使用java类和XML配置bean
2014-08-09 16:51 1457下面采用java类来配置bean,前面都采用xml进行配置be ... -
spring 第2天,bean作用域,自动注入集合
2014-08-06 22:16 1879sping容器中的Bean <!---beans的全 ... -
SpringMVC 注解 和非注解
2014-01-26 10:29 17970首先看看非注解的项目结构 在web.xml文件 配置spr ... -
详解spring 每个jar的作用
2013-11-19 23:54 3865spring.jar 是包含有完整 ... -
Spring配置Hibernate事务
2013-11-10 13:45 1172为了保证数据的一致性,在编程的时候往往需要引入事务这个概念。事 ... -
Spring 中引用Properties文件
2013-08-29 14:39 10604其中部分配置信息(邮件发送相关): #邮件发送的相关配置 ... -
Spring IOC控制反转 依赖注入DI
2012-12-15 09:37 2289目录 1.使用IOC控制反转 中的DI依赖注入 手工注入 ... -
Spring IOC控制反转 依赖注入DI
2012-12-14 16:23 8目录 1.使用IOC控制反转 中的DI依赖注入 (两种配置方式 ...
相关推荐
IOC与DI的理解及使用 控制反转IOC(Inversion of Control)是一种设计思想,DI(依赖注入)是实现IOC的一种方法 。... 在Spring中实现控制反转的是IOC容器 ,其 实现方法是依赖注入 (Dependency Injection,DI)
依赖注入:Dependency Injection(DI)与控制反转(IoC),不同角度但是同一个概念。首先我们理解一点在传统方式中我们使用new的方式来创建一个对象,这会造成对象与被实例化的对象之间的耦合性增加以致不利于维护...
【第一章】 Spring概述 ——跟我学Spring3 【第二章】 IoC 之 2.1 IoC基础 ——跟我学Spring3 【第二章】 IoC 之 2.2 IoC 容器基本原理 ——跟我学Spring3 【第二章】 IoC 之 2.3 IoC的配置使用——跟我学Spring3 ...
(用户持久化类)重构第一步——面向接口编程 8 重构第二步——工厂(Factory)模式 9 重构第三步——工厂(Factory)模式的改进 10 重构第四步-IoC容器 11 控制反转(IoC)/依赖注入(DI) 11 什么是控制反转...
本资源是一篇关于学习和应用SSM框架(Spring、SpringMVC、MyBatis)的学习记录系列文章中的第六天内容,主题为初识Spring框架。 在这一部分中,你将了解到Spring框架的基本概念和使用方法,并通过实例探讨了Spring ...
(用户持久化类)重构第一步——面向接口编程 8 重构第二步——工厂(Factory)模式 9 重构第三步——工厂(Factory)模式的改进 10 重构第四步-IoC容器 11 控制反转(IoC)/依赖注入(DI) 11 什么是控制反转/依赖...
第一天内容:Spring框架简介(EJB、JMX、Spring核心功能、Spring模块详解、Spring重要概念(容器)、Spring容器初始化的整个流程、Spring后处理器),IOC详解,Spring环境搭建,Spring创建Bean的三种方式,scope属性...
具体描述 Spring: 轻量级:Spring 是非侵入性的 - ...一站式:在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 (实际上 Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC)
Spring系列第1篇:为何要学spring?Spring系列第2篇:控制反转(IoC)与依赖注入(DI)。Spring系列第3篇:Spring容器基本使用及原理。Spring系列第4篇:xml中bean定义详解(-)Spring系列第5篇:创建bean实例这些方式...
Spring 是一个轻量级的开源框架, 为简化企业级应用开发而生...一站式:在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 (Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC)
1. spring杂谈[原创] 1.1 Spring事务处理时自我调用的解决方案及一些实现方式的风险 ...1.32 Spring3 Web MVC下的数据类型转换(第一篇)——《跟我学Spring3 Web MVC》抢先看 1.33 Spring 注入集合类型
【第二章】 IoC 之 2.2 IoC 容器基本原理 ——跟我学【第二章】 IoC 之 2.3 IoC的配置使用——跟我学Spring3【第三章】 DI 之 3
1.3 【第二章】 IoC 之 2.2 IoC 容器基本原理 ——跟我学Spring3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 1.4 【第三章】 DI 之 3.1 DI的配置使用 ——跟我学spring3 . . . . . . . . . . ....
第一个 Hibernate 程式 SessionFactory 注入 HibernateTemplate Hibernate 编程交易管理 Hibernate 宣告式交易管理 <br> Web 层 Spring 提供了 MVC Web 框架,您可以善用 IoC 容器...
Spring即使一个AOP框架,也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring,只要用 JavaBean 属性和配置文件加入依赖性(协作对象)。然后可以很容易地在需要时替换具有类似接口的协作对象。} ...
第一章 J2EE快速入门 1.1 J2EE概述 1.1.1 J2EE的来源 1.1.2 J2EE整体框架 1.1.3 从J2EE到JavaEE 1.2 J2EE组件 1.2.1 客户端组件 1.2.2 Web组件 1.2.3 业务逻辑组件 1.3 J2EE容器 1.3.1 容器服务 1.3.2 容器类型 1.4 ...
第2章 IOC容器和Bean的配置2.1 IOC和DI2.1.1 IOC(Inversion of Control):反转控制在应用程序中的组件需要获取资源时,
第一章 J2EE快速入门 1.1 J2EE概述 1.1.1 J2EE的来源 1.1.2 J2EE整体框架 1.1.3 从J2EE到JavaEE 1.2 J2EE组件 1.2.1 客户端组件 1.2.2 Web组件 1.2.3 业务逻辑组件 1.3 J2EE容器 1.3.1 容器服务 1.3.2 容器类型 1.4 ...
而控制反转就是把传统程序中需要实现对象的创建、代码的依赖,反转给一个专门的"第三方"即容器来实现,即将创建和查找依赖对象的控制权交给容器,由容器将对象进行组合注入,实现对象与对象的松耦合,便于功能的复用...