Spring

1 什么是spring ?
    Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架.
    spring的设计思想是，单例模式和工厂模式
2 spring的四大特点（优点）

    轻量级,低侵入的设计
    Spring的DI机制降低了业务对象替换的复杂性
    spring不依赖于web容器，独立于各种应用服务器， Write Once,Run Anywhere（一次编译到处运行）
    高度开放性：Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部，它的架构仍然是内在稳定的

3   spring的组成部分 七大模块

    Spring Core：Spring的基石，提供了Spring的最主要的核心机制：控制反转和依赖注入
    Spring Context：提供了Spring的上下文信息，如：国际化，验证等
   
    Spring Web支持：简化了处理多部分请求
    Spring MVC框架支持：一个全功能的构建 Web 应用程序的 MVC 实现，MVC 容纳了大量视图技术，其中包括 JSP、Velocity等。
   
    Spring Dao支持：Spring的Dao支持大大的简化了JDBC操作数据库所带来的繁琐
    Spring ORM支持 pring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、iBatis和TopLink。
                   所有这些都遵从Spring的通用事务和DAO异常层结构。

    Spring AOP：面向方面编程，提供了事务，日志，权限，安全等处理机制


具体解释
Spring 核心容器(Core):提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，它

是工厂模式的实现。BeanFactory使用控制反转(Ioc)模式将应用程序的配置和依赖性规范与实际的应

用代码程序分开。

Spring AOP:通过配置管理特性，Spring AOP模块直接面向方面的编程功能集成到了Spring框架中，所以可以很容易的使Spring框架管理的任何

对象支持 AOP。Spring AOP模块为基于Spring的应用程序

中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖于EJB组件，就可以将声明性事务管理

集成到应用程序中。

Spring ORM:Spring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、iBatis和TopLink。所有这些都遵从

Spring的通用事务和DAO异常层结构。

Spring DAO:JDBC DAO抽象层提供了有意义的异常层次的结构，可用该结构来管理异常处理和不同数据供应商抛出的异常错误信息。异常层次结

构简化了错误处理，并且大大的降低 了需要编写的异常代码数量(例如，打开和关系连接)。Spring DAO的面向JDBC的异常遵从通用的DAO异常

层结构。

Spring WEB:Web上下文模块建立在上下文模块（Context）的基础之上，为基于Web服务的应用

程序提供了上下文的服务。所以Spring框架支持 Jakarta Struts的集成。Web模块还简化了处理多部分请求

及将请求参数绑定到域对象的工作

Spring上下文(Context):Spring上下文是一个配置文件，向Spring框架提供上下文信息。

Spring上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化校验和调度功能。

Spring MVC:Spring的MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，

MVC框架变成为高度可配置的，MVC容纳的大量视图技术，包括JSP、Velocity、Tiles、iText和Pol


4 spring的核心机制

    1）.控制反转（IoC/Inverse Of Control）:调用者不再创建被调用者的实例，由spring框架实现（容器创建）所以称为控制反转。
    2）.依赖注入(DI/Dependence injection) :创建好实例后再注入调用者称为依赖注入。
   
    当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，
    在传统的程序设计过程中，通常由调用者来创建被调用者的实例, 但在Spring里，创建被调用者的工
    作不再由调用者来完成，因此称为控制反转; 创建被调用者 实例的工作通常由Spring容器来完成，
    然后注入调用者，因此也称为依赖注入


   什么是ioc容器

    bean工厂(BeanFactory) 和 应用上下文(Application Context)


在Spring中，BeanFactory是IoC容器的核心接口。 它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
                      BeanFactory
               |
               |
                  ApplicationContext(国际化)
               /              \
          /                \
FileSystemXmlApplicationContext     ClassPathXmlApplicationContext

 
 常用有三种方式可以得到BeanFactory ，从而bean实例，并进行调用

           //        InputStream is = new FileInputStream("beans.xml");
//                InputStreamResource isr = new InputStreamResource(is);
//                BeanFactory beanFactory = new XmlBeanFactory(isr);
//               
//                Spring给出一些BeanFactory的实现类，其中最为常用的是XmlBeanFactory。
//                1、通过文件系统
//                Resource res = new FileSystemResource("src/beans.xml");
//                XmlBeanFactory beanFactory = new XmlBeanFactory(res);
//                2、通过类路径（class路径 ./表示上级目录） 
//                ClassPathResource res = new ClassPathResource("./beans.xml");
//                XmlBeanFactory beanFactory = new XmlBeanFactory(res);
//                3、通过ApplicationContext加载（ClassPathXmlApplicationContext或者FileSystemXmlApplicationContext）
//                ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
//                new String[] {"./beans.xml"});
//                BeanFactory beanFactory = (BeanFactory) appContext;
//               
//                ClassPathResource res = new ClassPathResource("./beans.xml");
//                XmlBeanFactory beanFactory = new XmlBeanFactory(res);


         或者 ApplicationContext ctx=new FileSystemXmlApplicationContext("src/bean.xml");
       
     ApplicationContext增加功能 1国际化2事件支持
     
      国际化测试
             (1)bean配置
         <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
                 <property name="basenames">
            <list>
                <value>message</value>
                <!-- 如果有多个资源文件，全部列在此处-->
            </list>
        </property>
          </bean>
     （2）
         ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
        String[] a = {"读者"};
        String hello = ctx.getMessage("hello",a,Locale.ENGLISH);//英文
        Object[] b = {new Date()};
        String now = ctx.getMessage("hello",b,Locale.getDefault());//默认
        System.out.println(hello);
        System.out.println(now);
      
        

5  简单测试BeanFactory

   <?xml version="1.0" encoding="gb2312"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<bean id="aaa" class="包名.类名"/>
</beans>

   测试  FileSystemXmlApplicationContext默认从项目目录寻找bean配置文件xml
 ApplicationContext ctx = new FileSystemXmlApplicationContext("src/bean.xml");
   Test t=(Test)ctx.getBean("aaa");
 System.out.println(t.getName());
 
  依赖注入的优点，代码将更加清晰，Spring管理bean的灵巧性, bean与bean之间的依赖关系放在配置文件里组织，
  不再担心对象之间的依赖关系之后，实现更高层次的松耦合将易如反掌
 
 
  依赖注入的方式 （为什么叫依赖注入 类的四种关系  ） 
    (1)set注入(2)构造注入(3)lookup方法注入


    setter注入实例
  <bean id="aaa" class="包名.类名">
        <property name="属性名">
            <ref local="另一个bean id"/>//local与bean的区别
        </property>
    </bean>

 
 //local与bean的区别  local：当前xml   bean：整个spring容器


  构造注入实例 提供构造方法（注入的实例参数）  要提供无参的构造方法
  <bean id="aaa" class="包名.类名">
        <constructor-arg><ref bean="steelAxe"/></constructor-arg>
    </bean>

  (3)lookup方法注入(依赖注入的bean每次都创建一个新实例)
    这种方法主要是用在Singleton的Object中使用非Singleton的Bean时，
    通过lookup-method的那个方法来取得非Singleton的Bean。一般用的不多，在用这种定义之前最佳想明白你的需求。
   
    1 Singleton的Object 中提供一个抽象方法，返回非Singleton的Bean，此时Singleton的类变成抽象类 如
      public abstract class Test//Singleton的Bean {
     TestBean tb;//非Singleton的Bean时
     
     public TestBean getTb() {
        return tb;
    }

    public void setTb(TestBean tb) {
        this.tb = tb;
    }

    public abstract TestBean  createXxx();
      }
    2  配置xml
         <bean id="testbean" class="com.TestBean"  singleton="false"/>//注意singleton="false"
        <bean id="test" class="com.Test">
         <property name="tb"> <ref local="testbean"/></property>//注意这个依然不能少
         <lookup-method name="createXxx" bean="testbean"/>
       </bean>
   3 测试
         Test t=(Test)ctx.getBean("test");
     System.out.println("不使用lookup-method注入");
     TestBean tb1=t.getTb();
     TestBean tb2=t.getTb();
     System.out.println(tb1==tb2);
     System.out.println("使用lookup-method注入");
     TestBean  tb3=t.createXxx();
     TestBean  tb4=t.createXxx();
     System.out.println(tb3==tb4);

     结果
         不使用lookup-method注入
        true
        使用lookup-method注入
        false



注入其他属性例子
    <beans>

    <bean id="aaa" class="包名.类名"/>

    <bean id="bbb" class="lee.Chinese">
        <property name="schools">
            <list>
                <value>小学</value>
                <value>中学</value>
                <value>大学</value>
            </list>
        </property>


        <property name="score">
            <map>
                <entry key="数学">
                    <value>87</value>
                </entry>
                <entry key="英语">
                    <value>89</value>
                </entry>
                <entry key="语文">
                    <value>82</value>
                </entry>
            </map>
        </property>


        <property name="health">
            <props>
                <prop key="血压">正常</prop>
                <prop key="身高">175</prop>
            </props>
        </property>


        <property name="axes">
            <set>
                <value>xxx</value>
                <bean class="包名.类名"/>
                <ref local="另外一个bean id"/>
            </set>
        </property>

    </bean>

</beans>

上述中的health指的是Properties属性类
private Properties health = new Properties();



    




  测试 

   Spring的DI机制降低了业务对象替换的复杂性 
   面向接口编程的好处  灵活配置

6  spring  bean的实例 创建的几种方式
       （1）构造器   单例思想
       （2）静态工厂（静态方法创建）

         静态方法名(iint type)

       <bean id="xxx" class="包名.类名（工厂类)" factory-method="静态方法名">
        <constructor-arg value="1"></constructor-arg>
    </bean>


    创建同一接口下不同实例

     （3）工厂方法（非静态方法创建）
           <bean id="aaa" class="com.PersonFactory(工厂类)">
            <property name="type"><value>1</value></property>
           </bean>

       <bean id="xxx" factory-bean="工厂bean id" factory-method="非静态方法名">

7  自动装配

  

       有两个bean A与B
       B作为A的一个属性，当我们没有通过setter注入或者构造注入B实例时，我们可以在A bean中指定autowire属性，
       让它在spring容器个根据不同方式自动寻找b实例


    自动装配的优缺点：

    优点：自动装配能显著减少配置的数量，自动装配可以使配置与java代码同步更新

    缺点：Spring会尽量避免在装配不明确的时候进行猜测，容器中可能存在多个bean定义跟自动装配的

    setter方法和构造器参数类型匹配


    
    byName（用于set注入） 根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配。例如

，在bean定义中将autowire设置为by name，而该bean包含master属性（同时提供setMaster(..)方法），Spring就会查找名为master的bean定

义，并用它来装配给master属性。
 
    byType 如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配。如果存在多个该类型的bean，那么将会抛出异常，并

指出不能使用byType方式进行自动装配。若没有找到相匹配的bean，则什么事都不发生，属性也不会被设置。如果你不希望这样，那么可以通

过设置dependency-check="objects"让Spring抛出异常。
 
   constructor 与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛

出异常。
 
   autodetect 通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，

那么将使用byType方式。
 
 

   在用byType时候，如果没有匹配的bean 可测试dependency-check="objects"让Spring抛出异常


 8  spring框架中bean的生命周期?

  (1)  bean定义

    在配置文件里面用<bean></bean>来进行定义。

  (2)  bean初始化

    有两种方式初始化:  也可同时使用。参数指定的后执行

         A.在配置文件中通过指定init-method属性来完成

         B.实现org.springframwork.beans.factory.InitializingBean接口  实现afterPropertiesSet()方法

  (3)  bean调用

    有三种方式可以得到bean实例，并进行调用

  (4)  bean销毁

    销毁有两种方式。也可同时使用参数指定的销毁方法后运行

         A.使用配置文件指定的destroy-method属性

         B.实现org.springframwork.bean.factory.DisposableBean接口 实现destroy()方法
           
        可以通过调用ConfigurableListableBeanFactory里的destroySingletons销毁单例对象，测试destroy()方

           ConfigurableListableBeanFactory beanFactory =
            new XmlBeanFactory(new FileSystemResource("src/bean.xml"));
             beanFactory.destroySingletons();
                }
   
   9 spring 中bean的作用域（5种）:2.0以前只有单例和非单例   2。0以后有以下5种

    singleton

    在每个Spring IoC容器中一个bean定义对应一个对象实例。

    prototype

     一个bean定义对应多个对象实例。

    request

    在一次HTTP请求中，一个bean定义对应一个实例；即每次HTTP请求将会有各自的bean实例， 它们依

    据某个bean定义创建而成。该作用 域仅在基于web的Spring ApplicationContext情形下有效。

    session

    在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring

    ApplicationContext情形下有效。

    global session

    在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet

    context的时候有效。该作用域仅在基于 web的Spring ApplicationContext情形下有效。

10  spring在web环境中的配置（2种）

    1.在Web.xml中配置上下文载入器

    根据你的系统情况,你可以选择两种上下文载入器:ContextLoaderListener和ContextLoaderServlet.
    如果你的Web容器支持Servlet2.3标准或更高,你可以使用两者,否则只能使用后者.

    （1）ContextLoaderListener在Web.xml应该如下配置:
        <listener>
             <listener-class>
              org.springframework.web.context.ContextLoaderListener
             </listener-class>
        </listener>
    （2）ContextLoaderServlet在Web.xml应该如下配置:
        <servlet>
          <servlet-name>context</servlet-name>
          <servlet-class>
          org.springframework.web.context.ContextLoaderServlet
          </servlet-class>
          <load-on-startup>1</load-on-startup>
        </servlet>

    2.指定上下文载入器的配置文件
    不论你使用的那种上下文载入器,你都应该指明Spring配置文件的位置.如果没有指定,上下文载入器将把/web-

inf/applicationContext.xml当作Spring配置文件。
    要指定Spring配置文件的位置，你可以在Servlet上下文设置contextConfigLocation参数来为上下文载入器指定一个或多个Spring配

置文件
    （使用通配符或是用逗号隔开）。如下所示：
      <context-param>
        <param-name>
         contextConfigLocation
       </param-name>
       <param-value>
          /WEB-INF/bean.xml
       </param-value>
    </context-param>

    3.获得应用上下文
    接下来我们就可以获得ApplicationContext了，代码如下：
    WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);
    在一个自启动的Servlet中，我们可以这样获得它：
    public class InitialSystemServlet extends HttpServlet {
      public void init(ServletConfig config) throws ServletException {
        // 取得Spring的上下文
        WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(config.getServletContext());

      }



    
   
                               测试web应用环境相关的Bean作用域

       spring 2.5 dtd配置


           <?xml version="1.0" encoding="UTF-8" ?>
       <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

            <bean id="test" class="com.Test" >
            </bean>
          </beans>


    如果用户使用spring的webApplicationContext,则可以使用另外3种Bean的作用域:request,session和globalSession.不过
    在使用这些作用域之前,首先必须在web容器中进行一些额外的配置,在高版本的web容器中,则可以利用HTTP请求监听器进行配置:

    <listener>
    <listener-class>
    org.springframework.web.context.request.RequestContextListener
    </listener-class>
    </listener>
    细心的同学可能有一个疑问:在介绍webApplicationContext初始化时,我们已经通过ContextLoaderListener将web容器与
    spring容器整合,为什么这里又要引入一个额外的RequestContextListener以支持Bean的另外3个作用域呢?
    在整合spring容器时使用ContextLoaderListener,它实现了ServletContextListener监听器接口,ServletContextListener
    只负责监听web容器启动和关闭的事件.而RequestContextListener实现ServletRequestListener监听器接口,该监听器监听
    HTTP请求事件,web服务器接收的每一次请求都会通知该监听器.
    spring容器启动和关闭操作由web容器的启动和关闭事件触发,但如果spring容器中的Bean需要request,session,globalsession
    作用域的支持,spring容器本身就必须获得web容器的HTTP请求事件,以HTTP请求的事件"驱动"Bean作用域的控制逻辑.


11 spring 对dao的支持
    <1>dao模式优点
        减少开发代码量 提高工作效率
        降低系统资源消耗 提高系统性能
        业务逻辑层与持久层(数据层)的分离，使数据与操作更为清晰。
        数据访问独立到了一层，修改具体实现类，不影响系统的架构运行
     <2>DAO模式的四个组件
        DAO接口
        DAO接口实现类
        pojo值对象
        DAO实例的定位(工厂 或 spring注入)
   

    2. 核心类  JdbcTemplate（需要注入DataSource） 以及 JdbcDaoSupport类（简化注入，有一个字段dataSource）
       DataSource接口
    为了从数据库中取得数据，我们首先需要获取一个数据库连接。Spring通过DataSource对象来完成这个工作。
    DataSource是JDBC规范的一部分，它被视为一个通用的数据库连接工厂。通过使用DataSource，
    Container或Framework可以将连接池以及事务管理的细节从应用代码中分离出来。
    作为一个开发人员，在开发和测试产品的过程中，你可能需要知道连接数据库的细节。
    但在产品实施时，你不需要知道这些细节。通常数据库管理员会帮你设置好数据源。
    在使用Spring JDBC时，你既可以通过JNDI获得数据源，也可以自行配置数据源（使用Spring提供的DataSource实现类）。
    使用后者可以更方便的脱离Web容器来进行单元测试。 这里我们将使用DriverManagerDataSource
    ，不过DataSource有多种实现， 后面我们会讲到。使用DriverManagerDataSource和你以前获取一个JDBC连接 的做法没什么两样。
    你首先必须指定JDBC驱动程序的全限定名，这样DriverManager 才能加载JDBC驱动类，接着你必须提供一个url（因JDBC驱动而异，
    为了保证设置正确请参考相关JDBC驱动的文档）， 最后你必须提供一个用户连接数据库的用户名和密码。
    下面我们将通过一个例子来说明如何配置一个DriverManagerDataSource：
      
       编程方式获得dataSource

    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName("org.hsqldb.jdbcDriver");
    dataSource.setUrl("jdbc:hsqldb:hsql://localhost:");
    dataSource.setUsername("sa");
    dataSource.setPassword("");



    使用Spring的Dao支持来写Dao层，继承JdbcDaoSupport类，JdbcDaoSupport类中有一个字段dataSource
    也就是数据库连接，因此只需继承JdbcDaoSupport类，就隐式的获得了数据库连接，可以在bean.xml文件中
    注入connection（即：dataSource）
     <beans>
     <!-- spring 方式获得dataSource-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName">
            <value>com.mysql.jdbc.Driver</value>
        </property>
        <property name="url">
            <value>jdbc:mysql://localhost:3306/j2ee</value>
        </property>
        <property name="username">
            <value>root</value>
        </property>
        <property name="password">
            <value>123456</value>
        </property>
    </bean>

    <bean id="xxx" class="包名.类名(dao的实现类)">
        <property name="dataSource">
            <ref local="dataSource"/>
        </property>
    </bean>

     </beans>


    3.在这个Dao类中写一个内部类，使其实现：RowMapper接口，用来封装成具体的pojo对象，代码如下

     private class PersonRowMapper implements RowMapper
     {
        public Object mapRow(ResultSet resultSet, int rowNumber)
            throws SQLException {
            User user = new User();
            user.setId(resultSet.getLong("id"));
            user.setName(resultSet.getString("name"));
            user.setSex(resultSet.getString("sex"));
            user.setAge(resultSet.getInt("age"));
            user.setAddr(resultSet.getString("addr"));
            return user;
          }
     }


     4 通过JdbcTemplate类进行增删查询修改操作
         （1）增加 修改 删除示例
          public void createPerson(PersonBean p)
            {
        Object[] args = {p.getName() , new Integer(p.getAge()) };
        getJdbcTemplate().update("insert into person_test(p_name,p_age) values(?,?)", args );
            }
          （2）查询 返回单个object
            public PersonBean getPerson(int id)
            {
        Object[] args = {new Integer(id)};
        //PersonRowMapper是刚刚的内部类
        return (PersonBean)getJdbcTemplate().queryForObject("select p_name,p_age from person_test where p_id = ?",

args, new PersonRowMapper());
             }
       (3)返回list
          public List findPersonsByName(String name)
          {
            //PersonRowMapper是刚刚的内部类
        return getJdbcTemplate().query("select * from person_test where p_name like '%" + name +"%'" , new

PersonRowMapper());
          }


    5 spring 2.5以后提供了一个SimpleJdbcTemplate类来操作