`
feitianxm
  • 浏览: 15618 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
文章分类
社区版块
存档分类
最新评论

学习笔记—Spring

阅读更多
学习笔记—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企业级开发(图灵出版社)

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics