wcily123
其实挺聪明的,就是反映有点慢!
posts - 1,  comments - 0,  trackbacks - 0
 

 

day1
什么是Spring
   
开源、轻量级

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

    3ApplicationContext
     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
用户调用AmA又调用Bm
        
   
解决什么问题(什么时候考虑使用代理模式)
        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)
产生代理

    3Spring 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(安全)
比较JAASSpringSecurity
    JAAS              SpringSecurity
 
与具体的 web容器有关   与具体web容器无关(技术:IOC/AOP)


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

 

 

posted on 2009-06-01 21:35 wcily123 阅读(452) 评论(0)  编辑  收藏 所属分类: SSH--Spring

只有注册用户登录后才能发表评论。


网站导航:
 

<2024年11月>
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

常用链接

留言簿

随笔档案

文章分类

文章档案

搜索

  •  

最新评论