java---Spring

 spring是什么?

struts 是 web 框架 (jsp/action/actionfrom)

hibernate 是 orm框架,处于持久层.

spring 是容器框架,用于配置bean,并维护bean之间关系的框架

 spring中有一个非常概念:bean (是java中的任何一种对象 javabean/service/action/数据源./dao, ioc(控制反转 inverseof control) di( dependency injection 依赖注入)

                            ioc或者说di,还可以达到解耦的目的

 

 

快速入门

开发一个spring项目.

 

1.       引入spring的开发包(最小配置spring.jar该包把常用的jar都包括, 还要写日志包 common-logging.jar

2.       创建spring的一个核心文件applicationContext.xml, [hibernate有核心 hibernate.cfg.xmlstruts核心文件 struts-config.xml], 该文件一般放在src目录下,该文件中引入 xsd文件：

可以从给出的案例中拷贝一份.

3.       配置bean

<!-- 在容器文件中配置bean(service/dao/domain/action/数据源) -->

<!-- bean元素的作用是，当我们的spring框架加载时候，spring就会自动的创建一个bea对象，并放入内存

UserServiceuserSerivce=new UserService();

userSerivce.setName("韩顺平");

-->

<bean id="userService"class="com.service.UserService">

<!-- 这里就体现出注入的概念.-->

<propertyname="name">

           <value>韩顺平</value>

</property>

</bean>

4.       在Test.java中，我们怎么使用

//我们现在使用spring来完成上面的任务

                   //1.得到spring 的applicationContext对象(容器对象)

                   ApplicationContextac=new ClassPathXmlApplicationContext("applicationContext.xml");

                   UserServiceus=(UserService) ac.getBean("userService");

                   us.sayHello();

5.       细节讨论?

传统的方法和使用spring的方法

5.1    使用spring ，没有new 对象,我们把创建对象的任务交给spring框架

8.2 spring的运行原理图:

 

 

//spring 实际上是一个容器框架，可以配置各种bean（action/service/domain/dao），并且可以维护bean与bean之间的关系，当我们需要使用某个bean的时候，我们可以使用getBean(id);

 

//ioc是什么？

答 ：ioc(inverse ofcontroll ) 控制反转: 所谓控制反转就是把创建对象(bean),和维护对象(bean)的关系的权利从程序中转移到spring的容器(applicationContext.xml),而程序本身不再维护.

 

//DI是什么？

答: di(dependencyinjection) 依赖注入: 实际上di和ioc是同一个概念，spring设计者认为di更准确表示spring核心技术

 

//学习框架,最主要的是学习各个配置

 

//spring 开发者提倡接口编程，配合di技术可以实现层与层的解耦

           创建一个接口 ChangeLetter

两个类实现接口

把对象配置到spring容器中

使用

//通过上面的案例，我们可以初步体会到di配合接口编程，的确可以减少层(web层) 和 业务层的耦合度

8.3 Bean

从ApplicationContext 应用上下文容器中获取bean和从bean工厂容器中获取bean

ApplicationCotext,spring更加高级的容器。功能

强大：

1.提供文本信息解析工具，包括对国际化支持。

2.提供载入文件资源的通用方法，如图片。

3.可以向注册为监听器的bean发送事件。

在很少的情况下，使用BeanFactory，如在移动设

备。

三种经常用到的实现：

1.ClassPathXmlApplicationContext:从类路径中加载。

2.FileSystemXmlApplicationContext:从文件系统加载。

3.XmlWebApplicationContext:从web系统中加载。

 

ApplicationContext context =   new FileSystemXmlApplicationContext(" c:\foo.xml");

ApplicationContext context =   new ClassPathXmlApplicationContext(" foo.xml");

 

具体案例:

//从ApplicationContext中取bean

ApplicationContextac=new ClassPathXmlApplicationContext("com/hsp/ioc/beans.xml");

//当我们去实例化beans.xml,该文件中配置的bean被实例(该bean scope是 singleton)从bean中取出student

                  

                  

                   //如果我们使用beanfactory去获取bean，当你只是实例化该容器， 那么

                   //容器的bean不被实例化,只有当你去使用getBean某个bean时，才会实时的创建.

                  

                   BeanFactoryfactory = new XmlBeanFactory( newClassPathResource("com/hsp/ioc/beans.xml"));

                   factory.getBean("student");

 

结论:

1.如果使用ApplicationContext，则配置的bean如果是 singlton不管你用不用，都被实例化.(好处就是可以预先加载,缺点就是耗内存)

2.如果是 BeanFactory ,则当你获取beanfacotry时候，配置的bean不会被马上实例化，当你使用的时候，才被实例(好处节约内存,缺点就是速度)

3.规定: 一般没有特殊要求，应当使用ApplicatioContext完成(90%)

u  bean 的  scope的细节

 

 

bean的生命周期

1.      实例化(当我们的程序加载beans.xml文件)，把我们的bean(前提是scope=singleton)实例化到内存

2.      调用set方法设置属性

3.      如果你实现了bean名字关注接口(BeanNameAware) 则，可以通过setBeanName获取id号

4.      如果你实现了 bean工厂关注接口，(BeanFactoryAware),则可以获取BeanFactory

5.      如果你实现了ApplicationContextAware接口，则调用方法

//该方法传递ApplicationContext

public voidsetApplicationContext(ApplicationContext arg0)

                    throwsBeansException {

           // TODOAuto-generated method stub

           System.out.println("setApplicationContext"+arg0);

          

}

6.      如果bean 和一个后置处理器关联,则会自动去调用Object postProcessBeforeInitialization方法

7.      如果你实现InitializingBean 接口，则会调用afterPropertiesSet

8.      如果自己在<bean init-method=”init” /> 则可以在bean定义自己的初始化方法.

9.      如果bean 和一个后置处理器关联,则会自动去调用Object postProcessAfterInitialization方法

10.  使用我们的bean

11.  . 容器关闭

12. 可以通过实现DisposableBean接口来调用方法 destory

13. 可以在<bean destory-method=”fun1”/> 调用定制的销毁方法

         小结: 我们实际开发中往往，没有用的这么的过程,常见的是:

1->2->6->10->9->11

 

问题:通过BeanFactory来获取bean对象，bean的生命周期是否和Applicationcontext 是一样吗?

不是一样的，bean是工厂中创建的生命周期会简单一些:

 

除了应用上下文提供的附加功能外，应用上下文

与bean工厂的另一个重要区别是关于单例bean

如何被加载。

bean工厂延迟加载所有bean，直到getBean()

方法被调用。

应用上下文会(applicationContext)在启动后预载入所有单例bean.这样可确保应用不需要等待他们被创建。

 *应用上下文容器，在启动后，只会预加载所有的单例bean ,如果bean 的scope=“prototype|request|session”,并不会预加载,而是交给程序去维护

配置bean的细节

Scope的说明

☞ 尽量使用 scope=”singleton”,不要使用prototype,因为这样对我们的性能影响较大.

<bean scope=“singleton|prototype|request|session” />

singleton: 单例 默认值

prototype: 原型 

request: 一次请求有效( javaweb开发中)

session: session级有效(java web开发中)

bean工厂介绍

工厂设计模式，创建分发各种bean。配置好它们之

间的写作关系，参与bean的生命周期。

BeanFactory factory = new XmlBeanFactory(

newClassPathResource("applicationContext.xml"));

bean工厂只把bean的定义信息载进来，用到的时候

才实例化。

factory.getBean("mybean");就可得到一个

bean。

bean工厂:最简单的容器，提供了基础的依赖

              注入支持。创建各种类型的Bean.

应用上下文(ApplicationContext):建立在bean工厂基础之上，提供系统架构服务。

1.4     装配bean

bean工厂：最简单的容器，提供了基础的依赖 注入支持。创建各种类型的Bean.

应用上下文(ApplicationContext)：建立在bean工厂基础之上，提供系统架构服务

 

 

1.4.1  beanFactory

<bean scope=“singleton|prototype|request|session” />

singleton: 单例默认值

prototype: 原型 

request: 一次请求有效( java web开发中)

session: session级有效(java web开发中)

 

1 bean工厂介绍

工厂设计模式，创建分发各种bean。配置好它们之间的写作关系，参与bean的生命周期。

BeanFactory factory = new XmlBeanFactory(newClassPathResource("applicationContext.xml"));

bean工厂只把bean的定义信息载进来，用到的时候才实例化。

factory.getBean("mybean");就可得到一个bean。

 

 

8.4.3 bean的生命周期 

bean被载入到容器中时，他的生命周期就开始了。：

1.容器寻找bean的定义信息并实例化。

2.使用依赖注入，spring按bean定义信息配置bean的所有属性。

3.若bean实现了BeanNameAware接口，工厂调用Bean的setBeanName

  （）方法传递bean的ID。

4.若bean实现了BeanFactoryAware接口，工厂调用setBeanFactory（）

   方法传入工厂自身。

5.若BeanPostProcessor(bean后置处理器)和bean关联，则它们的

  postProcessBeforeInitialization()方法被调用。 [过滤器举例理解]

6.若bean指定了ini-method方法、，它将被调用。

7.最后，若有BeanPostProcessor和bean关联，则它们的

  postProcessAfterInitialization()方法被调用、。

 

将bean从工厂中删掉有两种方法：

1.若bean实现了DisposableBean接口， distroy()方法被调用。

2.如果指定了定制的销毁方法，就调用这个方法

 

 

 

1.5     Bean基本装配

装配bean的时候，需要告诉容器哪些bean以及容器如何使用依赖注入将它们配合在一起。

 

      使用XML装配

几种spring容器都支持使用xml装配bean，包括：

   1.XmlBeanFactory:调用ClassPathResource载入上下文

      定义文件(比如applicationContext.xml)。

   2.ClassPathXmlApplicationContext:从类路径载<