spring笔记

day1
什么是Spring？
    开源、轻量级

Spring 特征：
    1.B/S 和 C/S，使用资源小
    2.对象间的关系松，高内聚，低耦合
      IOC --- Inverse of control
         使得业务组件都处在框架的管理之下
         框架可以管理组件的创建和依赖关系
         框架可以提供可以配置的服务
    3.通过AOP技术将业务与非业务分离
      AOP --- Aspect Oreinted Programming
      在不修改组件的前提下，为组件提供扩展的服务
    4.Spring容器管理整个JavaBean生命周期
      简化对j2ee技术的使用
    5.与Hibernate、Struts一样是个框架
      (类集合) (框架提供)
    6.Spring是一个全方位的框架
      SpringMVC 类似 Struts

Spring框架在多层开发中位于那一层？或哪几层？
    框架简化开发过程，提供公共服务和便利的工具
    1.业务逻辑层 (Ioc *AoP) 最擅长的一层
    2.表现层    (SpringMVC Web B/S都有)
    3.数据持久层 (SpringDAO ORM)

什么是IoC：
    1.IOC --- Inverse of control (控制反转)
       A主动创建B的实例：正向控制
      过去：拉模型
           组件决定自己依赖的对象的创建
           接口没有在松散耦合中起到太大作用
      IOC：推模型，也叫做依赖注入
           采用工厂模式管理应用组件的创建，管理组件的依赖关系
           用接口表达组件间的依赖
      依赖注入的方式
        1)构造方法注入
        2)set 方法注入
    2.Spring IoC 容器先创建B的实例，再把B的实例注入A中
    3.执行过程：
      1)执行 BeanFactory 或 ApplicationContext 时，解析 xml 文件
      2)通过反射，执行 JavaBean 的空参构造方法，创建实例
      3)调用 JavaBean 的 set方法，将xml的信息注入到这 JavaBean 实例
        或者执行满参构造方法创建实例，同时注入 xml 的信息

spring 框架的7个组成部分
    1.BeanFactory -- (低级容器，接口)使用工厂模式实例化组件，装配组件
       XmlBeanFactory(实现类)
    2.ApplicationContext (高级容器，接口)--- bean factory 增加事件发布，增加了国际化，资

源访问等的支持
       ClassPathXmlApplicationContext(实现类)
    3.aop --  提供一种基于声明方式的AOP
    4.dao 支持--简化jdbc，声明的事务
    5.orm 支持-- 简化使用 Hibernate ,toplink 等持久化框架，方便的事务管理
    6.web 支持-- 在 web 应用中使用 spring 框架的相关支持，协调表现层和业务层的关系
    7.web mvc--- 独立的 web mvc 框架

    spring 是全方位的框架
    spring 的组成部分相对独立，可选择的使用

作业：
    用户注册页面
    要求： Servlet + Spring + JDBC + MySQL
         1.判断用户名是否已注册(保证用户名唯一性)
         2.采用B/S架构，使用IoC功能，完成JavaBean的注入。
           在JavaBean不要使用 new 方式创建对象。
         3.连接数据库时的 driver ，配置在 xml 文件中。


day2
二、控制反转(inverse of control IOC )
    2、Bean 工厂(BeanFactory)的功能和配置
        ClassPathResource
            在类路径下查找资源
            另有 FileSystemResource
        XmlBeanFactory
            读取 xml 文件中的配置信息
            生产bean
            解决bean 依赖
   
    * Bean 的创建
        spring 可调用bean的构造方法，或通过工厂方法生产 bean 对象

    1.利用 bean 的构造方法创建bean
        无参的构造方法
            <bean id="refName" class="foopak.FooClass">
               <property name="username" value="root"/>
               <property name="password" value="123"/>
            </bean>
        有参的构造方法，需指明构造方法的参数列表，通过：
            <bean id="refName" class="foopak.FooClass">
                <construct-arg><value>arg0</value></construct-arg>
                <construct-arg><value>arg1</value></construct-arg>
            </bean>
            表明调用了两个参数的构造方法

    2.通过工厂方法获得 bean 对象
        bean 没有公共的构造方法，需通过工厂类或工厂实例来创建
        分为静态工厂和实例工厂方法两种情况
        静态工厂方法:
            class 指明工厂类，factory-method 指明工厂方法
            如： Connection con=DriverManager.getConnection(url,user,pwd);
            对应的配置：
                <bean id="con" class="java.sql.DriverManager" factory-

method="getConnection">
                    <construct-arg><value>jdbc:mysql://localhost/test</value></construct

-arg>
                    <construct-arg><value>zhangsan</value></construct-arg>
                    <construct-arg><value>pwd</value></construct-arg>
                </bean>
                工厂方法参数和构造方法参数设置的形式相同
           
             实例工厂方法：   
                要先创建工厂实例，然后再由工厂实例创建产品
                如： Statement stmt = con.createStatement();
                        con 对象是工厂
                        stmt 对象是产品
                配置为：
                 <bean id="con" class="java.sql.DriverManager" factory-

method="getConnection">
                       ……
                 </bean>
                 <bean id="stmt" factory-bean="con" factory-method="createStatement"/>
   
    单例 bean
        bean 工厂生产bean 缺省都是单例的
        scope 属性
            scope="singleton|prototype|request|session"
        后两者用于web应用中   
        

    通过注入解决bean的依赖

        1 依赖注入的两种方式
            1) set 注入
                <property name="xxxYy">
                    ……
                </property>
               相当于 setXxxYy(val);
            2) 构造方法注入
                <construtor-arg>……</construtor-arg>
          spring 直接利用了 bean 的 set 或 构造方法
          避免了使用接口注入的侵入性
         
        2 依赖的目标类型分成三种形式：
            1) 基本类型+String 
                <value>data</value>
               类型自动转化
            2) 对其他bean 的引用 
                <ref bean="target"/>
            3) 集合类型
                list
                props
                set
                map
       
        3 让spring 自动装配bean，解决依赖
            autowire 属性指明自动装配的依据：
                    byName--- id=property
                    byType--- 属性的类型=当前工厂中bean的类型       
                    constructor--构造方法参数的类型=当前工厂中bean的类型
                    autodetect-- constructor ---> byType
            autowire-candidate 属性
                指明是否作为 autowire 的候选对象
                解决多个候选对象的冲突
                    true ---
                    false ---
        4 让容器检测 bean 所有的依赖是否都已经满足
            某个 bean 需要设置好所有属性
            防止遗漏装配，在运行后出现莫名奇妙的情况
            dependency-check 属性指明应检查的目标类型
                simple -- 基本类型+字符串+集合
                objects --- 对其他bean的依赖
                all
                none -- 默认值

    管理 Bean 生命周期
        生命周期
            构造
            set
            回调初始化方法
            getBean 返回
        回调方法：
            两个属性指明
                init-method
                destroy-method
            或实现两个接口：
                InitiallizingBean
                DisposableBean
           
    重用 bean 定义
        parent -- 继承 bean 定义
                    bean 之间不一定有继承关系
        abstract --- 只作为模板，不可以被实例化
   
    补充：
        name
            id=""
            name="/myBean"
            name="a b c"
           
        延迟加载bean
            bean 的加载时机
                预先加载
                    构造 bean 工厂时实例化所有bean
                延迟加载
                    getBean 时构造
                    先构造依赖的bean

                BeanFactory 总是延迟加载的
                ApplicationContext
                    BeanFactory 的扩展
                    预先加载 单例 bean
                    lazy-init (true|false)

    3、ApplicationContext
     BeanFactory 的扩展，为应用提供国际化和事件框架的支持

    1)I18N(国际化)
    ApplicationContext 可以读取国际化的消息文件
        getMessage();
   
    实施：
        1)注册消息源
        <bean id="messageSource"
            class="ResourceBundelMessageSource">
            <property name="basename">
                <value>MessageResource</value>
            </property>
        </bean>   
        bean 的id 必须是"messageSource"
        2)读取消息
        ApplicationContext 的方法：
            getMessage(String key,String[] args,Locale l);
                key - 消息的key
                args- 插入到消息中的参数
                l - 区域
                    Locale 语言和区域代码的封装对象
                        locale=new Local("zh","CN");
                            local=Locale.getDefault();
    思考：工厂管理的组件怎样使用获得国际化消息
   
    注意：因为AppicationContext包含了BeanFactory所有的功能，所以优先选择

ApplicationContext

    2)事件框架
    提供了一个观察者模式的框架,快速实现组件间的事件通知
   
    实施：   
        1 所有想得到通知的对象都实现ApplicationListener
        2 事件源发出事件:applicationContext.publishEvent(event);
    自定义事件类
        什么时候需要？
            被观察者在需要传输数据给观察者时
        怎么做？
            自定义事件类 extends ApplicationEvent



day3
三、面向切面编程(Aspect oriented Programming)
    1、代理模式
    定义
        1 A , B 实现了相同的接口，接口要求方法 m
        2 用户调用A的m，A又调用B的m
        
    解决什么问题(什么时候考虑使用代理模式)
        1 扩展功能，而不修改现有的类
        2 职责具有清晰的划分
       
    怎么用   
        Actale--接口 方法 act
        Actor---实现
        Test --- 客户
        Broker--实现，Actor 的代理
   
    采用代理实现日志
        IFoo
            doA,doB,doC
        Foo
       
        Test -- Test
        FooLogProxy       
               
   
    注意思考：日志代理的弊端
        相同的代码散落在每一个方法中

   
    2、使用动态代理解决
        下面方法可以直接为接口 Foo 产生代理实例：
            Foo proxy = (Foo) Proxy.newProxyInstance(
                    Foo.class.getClassLoader(),
                    new Class[]
            { Foo.class },
            handler);
             对 proxy 调用接口定义的方法，都会被分发给:
                handler.invoke()
             handler 是实现InvocationHandler 接口的实例
             这样就把对多个方法的调用集中起来了
             handler.invoke()然后再分发请求到目标方法

         实施:
            1) 实现 InvocationHandler 接口
            2)产生代理

    3、Spring 的AOP 采用动态代理实现
    一些别扭的概念：
    切面：当前关注的一个代码的流程，其中可能调用了多个类的多个方法。
    连接点：一个代码流程中的某个步骤，也就是这个代码流程中对某个方法的调用。
    通知(Advice)：对于某个方法(连接点)，进行拦截的拦截规则。
    切入点：对于某个方法(连接点)，是否被拦截的判断(过滤)规则。
    目标对象：某个连接点所在的对象。
    AOP代理：目标对象的代理。

    代理的生成：ProxyFactoryBean(org.springframework.aop.framework.ProxyFactoryBean)
        工厂类，生产代理
        区别于 BeanFactory
    InvocationHandler 的行为 : Advice

    实施：
    1) 创建拦截器类，封装代理行为
        implements MethodInterceptor       
    2) 使用 ProxyFactoryBean 产生代理       
        属性：
            target 目标对象e
            proxyInterfaces 代理的接口
            interceptorNames 代理要干什么

    补充：Advice / Interceptor
        除了 MethodInterceptor,还有多种接口可供选择
        决定拦截方法的时机
            方法前拦截  MethodBeforeAdvice
            方法后拦截    AfterReturningAdvice               
            方法抛出异常后拦截 ThrowsAdvice               
            围绕方法拦截 MethodInterceptor
           
    MethodInterceptor 通用

    Pointcut
        切点，相当于过滤器，缩小拦截的方法的范围
       
   
    概要：
        缩小接口或类的范围
        缩小方法的范围

    实施
    1) implements Pointcut
        定制过滤规则
        ClassFilter
            站在接口或类的级别上缩小范围
        MethodMatcher
            站在方法的级别上所有范围
            isRuntime()
                return true ,意味着要对参数的值做判断，会调用有三个参数的matchs方法
    2) 把 pointcut 和 advice 组合成一个 advisor 对象
         advisor = pointcut + advice
         使用 DefaultPointcutAdvisor

(org.springframework.aop.support.DefaultPointcutAdvisor) 构造 advisor 对象
    3) 然后把 advisor 添加到 interceptorNames 中


    使用 Spring 提供的Advisor实现
    1)NameMetchMethodPointcutAdvisor()
    1)RegexpMethodPointcutAdvisor()

    思考：使用 ProxyFactoryBean 创建代理的缺点？？
        1)每个target都要声明ProxyFactoryBean真麻烦!!!
        2)能不能以自动匹配的形式创建代理
        可以!!!使用自动代理创建器
   
    BeanNameAutoProxyCreator

(org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator)
        为指定的 bean 自动创建代理
        属性：
            beanNames
            interceptorNames
    DefaultAdvisorAutoProxyCreator

(org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator)
        根据 Advisor 创建代理


day4
四、使用AOP管理事务

    帐户管理
        Account
        IAccountDao
            long open(String name,double init);
            withdraw(long id,double amount);
            deposit(long id,double amount);
            List<Account> findByName(String name)       
        JdbcAccountDao
        applicationContex.xml
            提供数据源，注入给DAO

    实践经验：
        Dao 中定义的方法是持久化单元操作，
        一个事务可能有若干个单元操作构成，
        所以事务逻辑不应该出现在Dao中。
        通常事务逻辑应用在业务层(service层)

    采用 AOP 管理事务
        JdbcTransactionManager implements MethodInterceptor
       
        问题：
            1)事务管理器与Dao 都操作同一个连接对象
            2)同时，要保证在每个线程都操作不同的连接对象
        解决方法：采用ThreadLocal 管理连接对象

    创建模板类
        管理资源(连接对象)的获取释放
        执行SQL
        JDBCTemplate
            update(String sql,Object[] args);
            List<Map> query(String sql);   

    结论：事务管理棘手
         资源的管理棘手


五、对Jdbc的支持
    1.提供了JdbcTemplate 简化编程
    2.提供了声明的事务管理(与编程的事务管理)
        不再把事务逻辑硬编码在程序中，而是在配置文件中定义事务边界
    3.把所有checkedException ---> uncheckedException
        SQLException--->DataAccessException


    应用步骤：
        Account

        IAccountDao
            long open(String name,double amount);
            void deposit(long id,double amount);
            void withdraw(long id,double amount);
            List<Account> findByName(String name);

        JdbcAccountDao    extends JdbcDaoSupport
            继承了两个方法：
                setDataSource(DataSource ds)
                getJdbcTemplate()       

        Test

        applicationContext.xml
            datasource(org.springframework.jdbc.datasource.DriverManagerDataSource)
                driverClassName
                url
                username
                password
            dao
            transactionManager

(org.springframework.jdbc.datasource.DataSourceTransactionManager)
                dataSource
            transactionProxy

(org.springframework.transaction.interceptor.TransactionProxyFactoryBean)
                target
                transactionManager
                transactionAttributes

    事务的传播属性,七种                   
        调用者：调用当前方法的方法
        当前方法：声明事务属性的方法

    PROPAGATION_REQUIRED:如果存在一个事务，则支持当前事务。
                 如果没有事务则开启一个新的事务。

    PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。
                  如果没有事务，则非事务的执行。

    PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。
                   如果没有一个活动的事务，则抛出异常。

    PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。
                      如果一个事务已经存在，则将这个存在的事务挂起。

    PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。 

    PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常      

    PROPAGATION_NESTED: 如果一个活动的事务存在，则运行在一个嵌套的事务中.
                如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行
       
    JdbcTemplate                
        JdbcTemplate 的API
            更新
            查询

        如果使用Spring 提供的事务管理器 ， 你必须使用 Template       


六、Spring对 Hibernate 的支持
    1) HibernateTemplate
    2) 提供声明的事务管理
    3) LocalSessionFactoryBean

(org.springframework.orm.hibernate3.LocalSessionFactoryBean)
        dataSource

应用的步骤(与JDBC有三点不同)   
   
    1)HibernateAccountDao extends HibernateDaoSupport
        setSessionFactory()
        getHibernateTemplate()
   
    2)事务管理器使用 HibernateTransactionManager

(org.springframework.orm.hibernate3.HibernateTransactionManager)

    3)使用 LocalSessionFactoryBean 获得SessionFactory


1.SpringDAO,SpringORM给持久层带来的好处：
  省去try catch代码，事务、异常自动处理
2.访问数据源的两种方法(b/s,c/s)：
  dataSource:
     JDBC Driver          JNDI
7.事务的五个属性：
  传播性、只读、



day5
Struts1.x流程：
B(浏览器)---->ActionServlet-->RequestProcessor-->Action-->JavaBean-->DB
        request                       ↓      <--       <--       <--
                                struts-config.xml  


七、在web 应用中使用Spring
    概述：
        Spring 提供监听器，在应用部署时构造ApplicationContext
        ApplicationContext 对象会被绑定在 servlet context 中
        Spring 提供了API获得servlet context 中的ApplicationContext       

   实施步骤：
    实现一个web应用，区分 mvc 。

    然后，使用spring 管理model ：
    1) 配置监听器加载上下文
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/applicationContext.xml</param-value>
        </context-param>
        <listener>
            <listener-class>
            org.springframework.web.context.ContextLoaderListener
            </listener-class>
        </listener>
    2) 在Servlet中获得上下文
        WebApplicationContext context=
            WebApplicationContextUtils
            .getWebApplicationContext(this.getServletContext());
   
-------------------------

八、对Struts 的支持
        辅助 Action 获得 model 对象
          两种选择：   
            Action 不受Spring 管理
                Spring为Action 获得 applicationContext 提供支持
            Action 受 Spring 管理，
                容器为Action注入依赖的 model 对象
                使用Spring 的RequestProcessor 或 Action 代理实现


    与Struts 集成的两种选择：
    1 spring 不管理Action
        那只需要关注 Action 怎样获得上下文,两种方式可选择
        1) 仍然通过 WebApplicationContextUtils 获得
            WebApplicationContextUtils.getWebApplicationContext(
                        this.getServlet().getServletContext());
        2)XxAction extends ActionSupport
                继承了一个方法 ：getWebApplicationContext           
            令外可选择 :
                DispatchActionSuport
                LookupDispatchActionSupport
                MappingDispatchActionSupport

       优点：结构清楚简单,容易理解

    2 让 Spring 管理 Action
        把 Action 做为 bean 配置
        这样就可以注入Action 依赖的 model 对象了

        实现机制，有两种：
            改变 RequestProcessor 创建 Action的行为
                改由上下文中获得 action
                原理：覆盖 processActionCreate
       
            所有请求都给一个特殊的Action，
                此 Action execute 方法由上下文中获得 action
                然后把处理行为委托给action
                    return action.execute()
                   
       
        Spring 给我们提供了这两种机制的实现
   
      实施：
        1) 把 Action 作为bean 配置,注入其依赖的model组件
            applicationContext.xml :
                <bean name="/actionpath" class="action class">
                    <property name="foo">
                        <ref bean="foo"/>
                    </property>
                </bean>
          struts-config.xml :
                <action name="/actionpath" type="action class"/>
                type 无效
                即，等价于：
                <action name="/actionpath" />   
        2) 选择 RequestProcessor 或者 Action ，
            使其委托请求给 spring 管理的bean

            A)使用DelegatingRequestProcessor
                <controller processorClass=
                "org.springframework.web.struts.DelegatingRequestProcessor"/>
            B)使用 Action 的代理 DelegatingActionProxy
                 <action path="/actionpath"
                    type="org.springframework.web.struts.DelegatingActionProxy"/>


Spring Security(安全)
比较JAAS与SpringSecurity
    JAAS              SpringSecurity
  与具体的 web容器有关   与具体web容器无关(技术：IOC/AOP)



推荐书籍(学完这课程之后再看)：
Spring2.x(2.0/2.5)实例指南
Spring2企业级开发(图灵出版社)