spring
Spring 的创立者 Rod Johnson
1.什么是Spring Framework？
Spring Framework(简称Spring)是J2EE应用程序框架，不过，更严格地讲它是针对Bean的生命周期进行管理的
轻量级容器(Lightweight container)，可以单独利用Spring构筑应用程序，也可以和Struts，Webwork等
众多Web应用程序框架组合使用，并且可以与Swing等桌面应用程序API组合。所以Spring并不仅仅只能应用在J2EE中，
也可以应用在桌面应用及小应用程序中。针对Spring开发的组件不需要任何外部库。
2.使用Spring有什么好处？
(1)Spring能有效地组织你的中间层对象。
(2)Spring能消除在许多工程中常见的对Singleton的过多使用。
(3)Spring能消除各种各样自定义格式的属性文件的需要，使配置信息一元化。
(4)Spring能够帮助我们真正意义上实现针对接口编程。
(5)在Spring应用中的大多数业务对象没有依赖于Spring。
(6)使用Spring构建的应用程序易于单元测试。
(7)Spring支持JDBC和O/R Mapping产品(Hibernate)
(8)MVC Web框架，提供一种清晰，无侵略性的MVC实现方式。
(9)JNDI抽象层，便于改变实现细节，可以方便地在远程服务和本地服务间切换。
(10)简化访问数据库时的例外处理。
(11)Spring能使用AOP提供声明性事务管理。
(12)提供了JavaMail或其他邮件系统的支持。
3.什么是轻量(Lightweight)级容器？
Spring的开发者可以避免使用重量级容器开发EJB时的缺点：
(1)带有侵略性的API。(代码依赖于EJB)
(2)对容器的依赖。(代码不能在EJB容器之外工作)
(3)提供固定的一组机能，不具有配置能力。
(4)不同的产品，部署过程不同，不易通用。
(5)启动时间长。
----------------------------------------------------------
spring 7大组成模块：
1:spring core：提供了spring 的核心功能，BeanFactory是spring核心容器的主要组件，
它通过Ioc把程序的配置和依赖性与实际的代码分开，是整个spring的基础
2:spring context：通过配置文件向spring提供上下文信息，
它构建在BeanFactory之上，另外增加了国际化和资源访问等功能
3:spring dao：提供了一个简单有效的JDBC应用
4:spring aop：提供了面向方面编程的功能
5:spring orm：spring除了有自己的JDBC以外还提供了对其他ORM框架的支持，如Hibernate，都可以和spring进行良好的结合
6:spring web：提供了简化的处理多部分请求以及把请求参数绑定到域的任务。
7:spring MVC：提供了MVC2模式的实现，也可以和struts良好的集成在一起。
这七大模块可以单独使用，不需要其他模块的支持
--------------------------------------------------------
spring的特点：
1：设计良好的分层结构。
2：以IOC为核心，提倡面向接口编程。
3：良好的架构设计。
4：可以代替EJB
5：实现了MVC2
6：可以和其他框架良好的结合如：Hibernate ,struts等
Spring的核心思想是: IoC & AOP
IoC (Inversion of Control控制反转)
AOP (Aspect Oriented Programming面向方面编程)
Spring本身是一个轻量级容器，和EJB容器不同，Spring的组件就是普通的Java Bean
Spring负责管理所有的Java Bean组件，同样支持声明式的事务管理。
我们只需要编写好Java Bean组件，然后将它们"装配"起来就可以了，组件的初始化和管理均由Spring完成，
只需在配置文件中声明即可。这种方式最大的优点是各组件的耦合极为松散 。
**************************************************
什么是IoC? IoC英文为 Inversion of Control，即控制反转.
IoC模式(又称DI：Dependency Injection)
一种新的思维编程方式：Interface Driven Design 接口驱动，接口驱动有很多好处，可以提供不同灵活的子类实现，
增加代码稳定和健壮性等等，但是接口一定是需要实现的.
Dependency Injection模式是依赖注射的意思，
也就是将依赖先剥离，然后在适当时候再注射进入。
IoC容器的革命性优点
在Java基本教程中有一个定律告诉我们：所有的对象都必须创建；或者说：使用对象之前必须创建，
但是现在我们可以不必一定遵循这个定律了，我们可以从IoC容器中直接获得一个对象然后直接使用，无需事先创建它们。
这种变革，就如同我们无需考虑对象销毁一样；因为Java的垃圾回收机制帮助我们实现了对象销毁；
现在又无需考虑对象创建，对象的创建和销毁都无需考虑了，这给编程带来的影响是巨大的。
编写第一个HelloWorld程序：
1：interface
public interface IHelloWorld {
public void sayHello();
}
2:实现类：
public class HelloWorld implements IHelloWorld{
private String msg;
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public void sayHello(){
System.out.println(msg);
}
}
3：编写spring配置文件:applicationContext.xml
<beans>
<bean id="Hello" class="HelloWorld">
<property name="msg">
<value>Hello World!</value>
</property>
</bean>
</beans>
4:编写测试类：
public class TestHelloWorld {
public static void main(String[] args) {
ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml");
IHelloWorld hw= (IHelloWorld)ac.getBean("Hello");
hw.sayHello();
}
}
对于我们的实际开发有何帮助？
首先，我们的组件并不需要实现框架指定的接口，因此可以轻松的将组件从Spring中脱离，甚
至不需要任何修改（这在基于EJB2.x框架实现的应用中是难以想象的）。
其次，组件间的依赖关系减少，极大改善了代码的可重用性。
Spring的依赖注入机制，可以在运行期为组件配置所需资源，而无需在编写组件代码时就加以
指定，从而在相当程度上降低了组件之间的耦合。
---------------------------------------------------------------------
依赖注入的三种方式：
1：接口注入
2：set注入
3：构造注入
spring支持set注入和构造注入
把上面的HelloWorld改为构造注入：
1：实现类：
public class CHelloWorld implements IHelloWorld{
public String msg;
public CHelloWorld(String msg){
this.msg = msg;
}
public void sayHello(){
System.out.print(msg);
}
}
2：在spring配置文件:applicationContext.xml中：
<bean id="CHello" class="CHelloWorld">
<constructor-arg index="0">
<value>C Hello World!</value>
</constructor-arg>
</bean>
constructor-arg 用来表示用构造方式注入参数
index="0"表示是构造方法中的第一个参数
3:编写测试类：
public class TestHelloWorld {
public static void main(String[] args) {
ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml");
IHelloWorld hw= (IHelloWorld)ac.getBean("CHello");
hw.sayHello();
}
}
---------------------------------------------------------------------------
Spring的核心容器：
spring中两个最基本最重要的包：
org.springframework.context和org.springframework.beans为spring的IOC提供了基础
在这两个最重要的类是BeanFactory和ApplicationContext。BeanFactory来管理各种bean。ApplicationContext在BeanFactory之上
增加了其他功能如国际化，获取资源事件传递等。
1：bean的标志(id 和name)
每个bean都有一个id在管理bean的BeanFactory和ApplicationContext中必须是唯一标志。
id和name都可以用来指定id这两者中至少有一个。区别是id的命名必须符合xml id中和合法字符。name则没有限制，而且可以使用name指定多个id
2：bean的类
class属性路径要完整，包名.类名
3:singleton的使用
在spring 中bean可以定义为两种部署模式：singleton和non-singleton
singleton：只有一个共享的实例存在
non-singleton：每次请求都创建新的实例
4：bean的属性：
在定义bean的属性时除了直接指定bean的属性外还可以参考配置文件中定义的其他bean
1:
<bean id="DateHello" class="DateHelloWorld">
<property name="msg">
<value>Hello World!</value>
</property>
<property name="date">
<bean id="date" class="java.util.Date"/>
</property>
</bean>
2:
<bean id="DateHello" class="DateHelloWorld">
<property name="msg">
<value>Hello World!</value>
</property>
<property name="date">
<ref bean="date"/>
</property>
</bean>
<bean id="date" class="java.util.Date"/>
5:null值的处理
把属性设为null值有两种方法：
1：
<bean id="DateHello" class="DateHelloWorld">
<property name="msg">
<value>null</value>
</property>
</bean>
2:
<bean id="DateHello" class="DateHelloWorld">
<property name="msg">
<null/>
</property>
</bean>
6:使用depends-on
bean的depends-on可以用来在初始化这个bean前，强制执行一个或多个bean的初始化。
如：
<bean id="DateHello" class="DateHelloWorld" depends-on="date">
---------------------------------------------------------------------------------------
bean的生命周期：
1：bean的定义
//配置bean的开始，beans中包含一个或多个bean
<beans>
//定义一个bean id是唯一标志，class是bean的来源
<bean id="DateHello" class="DateHelloWorld">
//配置bean的开始
<property name="msg">
<null/>
</property>
//定义bean的结束
</bean>
//配置bean的结束
</beans>
2：bean的初始化
初始化有两种方式：
1在配置文件中指定init-method属性来完成
public class HelloWorld {
private String msg;
public void init(){
msg="Hello World";
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public void sayHello(){
System.out.println(msg);
}
}
applicationContext.xml文件中
<bean id="DateHello" class="HelloWorld" init-method="init">
2实现org.springframework.beans.factory.InitialingBean接口
实现其中的afterPropertiesSet()方法
public class HelloWorld implements InitializingBean{
private String msg;
public void afterPropertiesSet(){
msg="Hello World";
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public void sayHello(){
System.out.println(msg);
}
}
applicationContext.xml文件中
<bean id="DateHello" class="HelloWorld">
</bean>
3：bean的使用
有三种方式：
1：使用BeanWrapper
HelloWorld helloWorld = new HelloWorld ();
BeanWrapper bw = new BeanWrapperImpl(helloWorld);
bw.setPropertyValue("msg","HelloWorld");
System.out.println(bw.getPropertyValue("msg"));
2:使用BeanFactory
//InputStream is = new FileInputStream("applicationContext.xml");!!!!是错误的写法
ClassPathResource is = new ClassPathResource("applicationContext.xml");
XmlBeanFactory factory = new XmlBeanFactory (is);
HelloWorld helloWorld = (HelloWorld)factory.getBean ("HelloWorld");
helloWorld.sayHello();
3:使用ApplicationContext
ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml");
IHelloWorld hw= (IHelloWorld)ac.getBean("CHello");
hw.sayHello();
4：bean的销毁
销毁有两种方式：
1在配置文件中指定destory-method属性来完成
public class HelloWorld {
private String msg;
public void init(){
msg="Hello World";
}
public void cleanup(){
msg="";
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public void sayHello(){
System.out.println(msg);
}
}
applicationContext.xml文件中
<bean id="DateHello" class="HelloWorld" init-method="init" destory-method="cleanup">
2实现org.springframework.beans.factory.DisposeableBean接口
实现其中的destory()方法
public class HelloWorld implements InitializingBean,DisposeableBean{
private String msg;
public void afterPropertiesSet(){
msg="Hello World";
}
public void destory(){
msg="";
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public void sayHello(){
System.out.println(msg);
}
}
applicationContext.xml文件中
<bean id="DateHello" class="HelloWorld">
</bean>
----------------------------------------------------------
用ref属性指定依赖的方式
1：用local属性指定：local属性的值必须与被参考引用的bean的id一致，如果在同一个xml文件里没有匹配的元素，xml解析将产生一个错误
如：
<bean id="DateHello" class="DateHelloWorld">
<property name="msg">
<value>Hello World!</value>
</property>
<property name="date">
<ref local="date"/>
</property>
</bean>
<bean id="date" class="java.util.Date"/>
2:用bean属性指定
用ref元素中的bean属性指定被参考引用的bean是spring中最常见的形式
bean属性的值可以与被引用的bean的id相同也可以与name相同。
<bean id="DateHello" class="DateHelloWorld">
<property name="msg">
<value>Hello World!</value>
</property>
<property name="date">
<ref bean="date"/>
</property>
</bean>
<bean id="date" class="java.util.Date"/>
----------------------------------------------------------
bean自动装配的5种模式：
可以使用bean元素的autowire属性来指定bean的装配模式：
1：byName
2: byType
3:constructor
4:autodetect
5:no
显示的指定依赖如：property 和constructor-arg元素总会覆盖自动装配。对与大型应用不鼓励使用自动装配
--------------------------------------------------------------
bean 依赖检查的4种模式：
依赖检查能够分别对每个bean应用或取消应用，默认的是不检查依赖关系，
可以使用bean元素的dependency-check属性来指定bean的依赖检查，共有4种：
1：使用simple模式
是指对基本类型、字符串和集合进行依赖检查
如：
<bean id="DateHello" class="DateHelloWorld" autowire="autodetect" dependency-check="simple">
</bean>
<bean id="date" class="java.util.Date"/>
只会对msg进行检查
2：使用object模式
是指对对象进行依赖检查
如：
<bean id="DateHello" class="DateHelloWorld" autowire="autodetect" dependency-check="object">
</bean>
<bean id="date" class="java.util.Date"/>
只会对date进行检查
3：使用all模式
是指对所有属性进行依赖检查
如：
<bean id="DateHello" class="DateHelloWorld" autowire="autodetect" dependency-check="all">
</bean>
<bean id="date" class="java.util.Date"/>
会对msg进行检查和date进行检查
4：使用none模式
是指对所有属性不进行依赖检查
如：
<bean id="DateHello" class="DateHelloWorld" autowire="autodetect" dependency-check="none">
</bean>
<bean id="date" class="java.util.Date"/>
不会对msg进行检查和date进行检查
总结：一般情况下依赖检查和自动装配结合使用，当bean属性都有默认值或不需要对bean的属性是否被设置到bean上检查时，依赖检查的作用就不大了
-----------------------------------------------------------------------
集合的注入方式
对于集合List Set Map Props元素则有不同的配置方式
1：List
public class HelloWorld{
//定义一个List变量msg
List msg=null;
public void setMsg(List msg){
this.msg = msg;
}
}
xml文件：
<bean id="Hello" class="HelloWorld">
<property name="msg">
<list>
<value>Hello World!</value>
<value>Hello World2!</value>
</list>
</property>
</bean>
2:set
public class HelloWorld{
//定义一个Set变量msg
Set msg=null;
public void setMsg(Set msg){
this.msg = msg;
}
}
xml文件：
<bean id="Hello" class="HelloWorld">
<property name="msg">
<set>
<value>Hello World!</value>
<value>Hello World2!</value>
</set>
</property>
</bean>
3:map
public class HelloWorld{
//定义一个Map变量msg
Map msg=null;
public void setMsg(Map msg){
this.msg = msg;
}
}
xml文件：
<bean id="Hello" class="HelloWorld">
<property name="msg">
<map>
<entry key="h1">
<value>Hello World!</value>
</entry>
<entry key="h2">
<value>Hello World2!</value>
</entry>
</map>
</property>
</bean>
联系客服
