Spring经典总结<1>

1.Spring作用和优点

    a.Spring框架是解决方案级的框架或者说整合框架，是各种组件、技术

     的使用平台,可以在这个平台上使用Struts,Hibernate,JDBC技术并且可

     以可以实现各种开发技术的组合。Spring提供了IoC和AOP机制的实

     现，可以改善程序结构，提高系统的灵活性，便于维护和扩展。

 Spring主要作用：让组件之间实现低耦合（方便解耦），让程序结构更  

                  加灵活，方便日后的维护和扩展 

                 低耦合：组件与组件之间的关联度较低

Spring相当于主机中的主板，而struts、Hibernate、jsp相当于主板上

的cpu、内存、显卡之类的组件（主板特点：可插拔 ） 

       b.在SSH使用中，Spring提供了一个容器，该容器具有IOC和AOP机

         制，利用这个容器IOC机制管理程序中的DAO,Service等组件，采用

         AOP机制实现事务，异常日志记录等共通处理。

2.Spring容器简介

   1)Spring容器是Spring框架的基础和核心。该容器具有以下功能：

    a.可以创建和初始化一个Bean组件对象

      在spring里，任何java对象和java组件都被当成bean处理。

    b.可以管理Bean对象的生命期

    c.可以利用IoC机制建立Bean对象之间的关系

    d.可以利用扩展的AOP机制将共通组件和某一批目标组件对象建立关联。

      （需要引入AOP扩展jar包）

 

    2)Spring容器类型可以使用BeanFactory或者ApplicationContext.

     --Spring容器实例化

      ApplicationContext ac =new ClasspathXmlApplicationContext(xml配置);

     --从Spring容器获取Bean对象

      接口类型 变量 =  (接口类型)ac.getBean("id属性");

     --销毁Spring容器

       使用AbstractApplicationContext类型的close();

       一般情况下，销毁容器对象由Spring管理完成，无需手动销毁。如果要

       手动销毁需要使用AbstractApplicationContext容器，调用

       AbstractApplicationContext容器的close()方法。

   3)Spring容器的使用方法

      --引入spring核心包

     --在src下添加spring配置文件

     --在spring配置文件定义Bean组件

    <bean id="标识符" class="包名.实现类名">

    </bean>

eg:

applicationContext.xml:

 <!-- 定义Bean组件 -->

<bean id="costDao" class="com.tarena.dao.JdbcCostDAO"></bean>

     --实例化spring容器，通过容器的getBean("标识符")方法获取

 

       eg:

public static void main(String[] args) {

// CostDAO costDao = new JdbcCostDAO();

// costDao.save();

// costDao.update();

// 获取Spring容器中的CostDAO

// 第一步实例化Spring容器

String conf = "applicationContext.xml";

// 用于加载src下的xml配置文件

AbstractApplicationContext ac = new 

          ClassPathXmlApplicationContext(conf);

// AbstractApplicationContext ac = new 

         FileSystemXmlApplicationContext 用于加载磁盘路径的xml配置

// 获取容器中的DAO

CostDAO costDao = (CostDAO) ac.getBean("costDao");

costDao.save();

costDao.update();

// ac.close();//销毁Spring容器

}

3.Spring容器对Bean组件的管理

 *1)创建Bean对象的方式

     Spring可以采用单例模式和非单例模式创建Bean对象。

     默认情况下，采用单例模式创建Bean对象。

     在<bean scope="">中利用scope属性控制创建模式。

     scope="singleton"采用单例模式，

     scope="prototype"采用原型(非单例)模式

     (在JavaWeb环境中，scope属性值还可以指定request,session等范围)

 如果scope="singleton"，Spring容器实例化时，会自动创建Bean组件

     对象。

     如果scope="prototype"，Spring容器会在调用getBean方法时创建Bean

     对象。

scope属性的取值介绍：

在web（仅限于web项目）环境中，还可以设置所创建的bean对象的生命周期和request、session。

a.request 表示bean对象生命周期和request生命周期相同

b.session 表示bean对象生命周期和session生命周期相同

c.global session 相当于application

d.singleton 单例模式

e.prototype 原型模式

   2)Bean对象的创建时机

     默认是随着容器创建，可以使用lazy-init=true设置(在调用getBean()创建)

     延迟创建

   3)Bean对象的初始化和销毁

     使用<bean init-method="" destroy-method="">

     可以指定Bean对象创建和销毁时触发的方法。

     destroy-method只适用于scope="singleton"模式.

    当调用applicationcontext.close()时,容器会自动销毁所有单例对象,此时会  

    触发指定destory-method方法。

     init-method指定的初始化方法可以在构造方法执行后自动执行。

 4.如何使用Spring容器的IoC机制

  Spring提供的IoC主要是用于建立两个对象（组件、Bean）之间的关系，

  好处是低耦合方式。Spring经典总结

   1）DI（依赖注入技术）

     Dependency Injection 称为依赖注入。意思是采用注入技术建立两个组件

     的依赖关系。

      Spring通过DI技术实现了IoC思想。DI技术可以分成以下几类：

      --setter方式注入（依靠属性的set方法注入）

<property....></property>对应的注入方式只能是setter注入

 applicationContext.xml配置：

<!-- 定义Bean组件 -->

<bean id="costDao" scope="singleton" init-method="myinit"

destroy-method="mydestroy" class="com.tarena.dao.JdbcCostDAO">

</bean>

<bean id="hibernateCostDao" 

     class="com.tarena.dao.HibernateCostDAO">

</bean>

<!-- setter方式注入示例 -->

<bean id="costAction" scope="prototype" 

      class="com.tarena.action.CostAction">

<!-- 将ref指定的id属性Bean对象给costDao属性注入 -->

<property name="costDao" ref="hibernateCostDao"></property>

</bean>

其中，name=”costDao”中的costDao为要注入的属性，即public void 

setCostDao ....方法中的setCostDao()方法名中的除”set”之后的部分

  /** setter方式注入示例*/

public class CostAction {

private CostDAO costDao1;

// spring自动调用该方法，注入一个CostDAO对象

public void setCostDao(CostDAO costDao) {

this.costDao1 = costDao;

}

public String add() {

System.out.println("执行资费添加操作");

costDao1.save();

return "success";

}

}

      --构造方式注入（依靠构造方法注入）

  applicationContext.xml配置：

<!-- 定义Bean组件 -->

<bean id="costDao" scope="singleton" init-method="myinit"

destroy-method="mydestroy" class="com.tarena.dao.JdbcCostDAO">

</bean>

   <bean id="hibernateCostDao" 

  class="com.tarena.dao.HibernateCostDAO">

</bean>

<!-- 构造方式注入示例 -->

<bean id="costAction1" scope="prototype" 

     class="com.tarena.action.CostAction1">

<!-- 构造方式注入 -->

<!-- “0”为构造参数索引：构造参数索引;"costDao"为要注入的Bean对象的id -->

<constructor-arg index="0" ref="costDao">

</constructor-arg>

   </bean>

其中，<constructor-arg index="构造参数索引"

            ref="要注入的Bean对象的id">

      </constructor-arg>

 Spring经典总结

/**构造方式注入示例*/

public class CostAction1 {

private CostDAO costDao1;

// spring自动调用该方法，注入一个CostDAO对象

public CostAction1(CostDAO costDao) {

this.costDao1 = costDao;

}

public String add() {

System.out.println("执行资费添加操作");

costDao1.save();

return "success";

}

         }

      --接口方式注入(了解名称,可以参考spring文档)

   2）IoC思想

      Inverse of Controller 称为反向控制或控制反转，确切讲被称为控制转移，

      意思就是转交控制权。

     所谓控制及控制权：指的是负责对象的创建、初始化以及销毁等工作。

     两个组件，当A调用B时，原有方式需要在A里面编写控制权逻辑代码，

     当需要替换B组件时，需要修改控制权逻辑，因此A和B组件的耦合度比

     较高。

     采用IoC思想后，就是将A中的控制权逻辑转移给第三方容器或框架，有

     第三方框架负责A,B对象的创建，释放，初始化和关系指定等工作。

 

    *3）Action--->DAO采用Spring的IoC方式

       --在Action中定义一个DAO接口类型的变量

       --在Action中定义一个setter方法，主要作用是接收spring注入进

         来DAO对象。

       --将Action和DAO都交给Spring容器，Action配置如下:

        <bean id="action标识符" class="action实现类">

            <!--setter方式注入配置-->

            <property name="属性名" 

               ref="dao定义时的Bean组件Id值">

            </property>

        </bean>

        参见上例“setter方式注入”

     4）采用构造方式注入重构3示例

          --定义带参数构造方法替代setter方法

          --定义Action的<bean>时，采用

        <constructor-arg>替代<property>配置

       <constructor-arg index="构造参数索引"

           ref="要注入的Bean对象的id">

       </constructor-arg>

参见上例“构造方式注入”

评论

1 楼 lijingshou 2013-11-25  

抄的也不注明一下出处,无语啊