spring笔记

day1

什么是Spring？

开源、轻量级

Spring特征：

1.B/S和C/S，使用资源小

2.对象间的关系松，高内聚，低耦合

IOC---Inverseofcontrol

使得业务组件都处在框架的管理之下

框架可以管理组件的创建和依赖关系

框架可以提供可以配置的服务

3.通过AOP技术将业务与非业务分离

AOP---AspectOreintedProgramming

在不修改组件的前提下，为组件提供扩展的服务

4.Spring容器管理整个JavaBean生命周期

简化对j2ee技术的使用

5.与Hibernate、Struts一样是个框架

(类集合)(框架提供)

6.Spring是一个全方位的框架

SpringMVC类似Struts

Spring框架在多层开发中位于那一层？或哪几层？

框架简化开发过程，提供公共服务和便利的工具

1.业务逻辑层(Ioc*AoP)最擅长的一层

2.表现层(SpringMVCWebB/S都有)

3.数据持久层(SpringDAOORM)

什么是IoC：

1.IOC---Inverseofcontrol(控制反转)

A主动创建B的实例：正向控制

过去：拉模型

组件决定自己依赖的对象的创建

接口没有在松散耦合中起到太大作用

IOC：推模型，也叫做依赖注入

采用工厂模式管理应用组件的创建，管理组件的依赖关系

用接口表达组件间的依赖

依赖注入的方式

1)构造方法注入

2)set方法注入

2.SpringIoC容器先创建B的实例，再把B的实例注入A中

3.执行过程：

1)执行BeanFactory或ApplicationContext时，解析xml文件

2)通过反射，执行JavaBean的空参构造方法，创建实例

3)调用JavaBean的set方法，将xml的信息注入到这JavaBean实例

或者执行满参构造方法创建实例，同时注入xml的信息

spring框架的7个组成部分

1.BeanFactory--(低级容器，接口)使用工厂模式实例化组件，装配组件

XmlBeanFactory(实现类)

2.ApplicationContext(高级容器，接口)---beanfactory增加事件发布，增加了国际化，资

源访问等的支持

ClassPathXmlApplicationContext(实现类)

3.aop--提供一种基于声明方式的AOP

4.dao支持--简化jdbc，声明的事务

5.orm支持--简化使用Hibernate,toplink等持久化框架，方便的事务管理

6.web支持--在web应用中使用spring框架的相关支持，协调表现层和业务层的关系

7.webmvc---独立的webmvc框架

spring是全方位的框架

spring的组成部分相对独立，可选择的使用

作业：

用户注册页面

要求：Servlet+Spring+JDBC+MySQL

1.判断用户名是否已注册(保证用户名唯一性)

2.采用B/S架构，使用IoC功能，完成JavaBean的注入。

在JavaBean不要使用new方式创建对象。

3.连接数据库时的driver，配置在xml文件中。

day2

二、控制反转(inverseofcontrolIOC)

2、Bean工厂(BeanFactory)的功能和配置

ClassPathResource

在类路径下查找资源

另有FileSystemResource

XmlBeanFactory

读取xml文件中的配置信息

生产bean

解决bean依赖

*Bean的创建

spring可调用bean的构造方法，或通过工厂方法生产bean对象

1.利用bean的构造方法创建bean

无参的构造方法

<beanid="refName"class="foopak.FooClass">

<propertyname="username"value="root"/>

<propertyname="password"value="123"/>

</bean>

有参的构造方法，需指明构造方法的参数列表，通过：

<beanid="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指明工厂方法

如：Connectioncon=DriverManager.getConnection(url,user,pwd);

对应的配置：

<beanid="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>

工厂方法参数和构造方法参数设置的形式相同

实例工厂方法：

要先创建工厂实例，然后再由工厂实例创建产品

如：Statementstmt=con.createStatement();

con对象是工厂

stmt对象是产品

配置为：

<beanid="con"class="java.sql.DriverManager"factory-

method="getConnection">

……

</bean>

<beanid="stmt"factory-bean="con"factory-method="createStatement"/>

单例bean

bean工厂生产bean缺省都是单例的

scope属性

scope="singleton|prototype|request|session"

后两者用于web应用中

通过注入解决bean的依赖

1依赖注入的两种方式

1)set注入

<propertyname="xxxYy">

……

</property>

相当于setXxxYy(val);

2)构造方法注入

<construtor-arg>……</construtor-arg>

spring直接利用了bean的set或构造方法

避免了使用接口注入的侵入性

2依赖的目标类型分成三种形式：

1)基本类型+String

<value>data</value>

类型自动转化

2)对其他bean的引用

<refbean="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="abc"

延迟加载bean

bean的加载时机

预先加载

构造bean工厂时实例化所有bean

延迟加载

getBean时构造

先构造依赖的bean

BeanFactory总是延迟加载的

ApplicationContext

BeanFactory的扩展

预先加载单例bean

lazy-init(true|false)

3、ApplicationContext

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

1)I18N(国际化)

ApplicationContext可以读取国际化的消息文件

getMessage();

实施：

1)注册消息源

<beanid="messageSource"

class="ResourceBundelMessageSource">

<propertyname="basename">

<value>MessageResource</value>

</property>

</bean>

bean的id必须是"messageSource"

2)读取消息

ApplicationContext的方法：

getMessage(Stringkey,String[]args,Localel);

key-消息的key

args-插入到消息中的参数

l-区域

Locale语言和区域代码的封装对象

locale=newLocal("zh","CN");

local=Locale.getDefault();

思考：工厂管理的组件怎样使用获得国际化消息

注意：因为AppicationContext包含了BeanFactory所有的功能，所以优先选择

ApplicationContext

2)事件框架

提供了一个观察者模式的框架,快速实现组件间的事件通知

实施：

1所有想得到通知的对象都实现ApplicationListener

2事件源发出事件:applicationContext.publishEvent(event);

自定义事件类

什么时候需要？

被观察者在需要传输数据给观察者时

怎么做？

自定义事件类extendsApplicationEvent

day3

三、面向切面编程(AspectorientedProgramming)

1、代理模式

定义

1A,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产生代理实例：

Fooproxy=(Foo)Proxy.newProxyInstance(

Foo.class.getClassLoader(),

newClass[]

{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)创建拦截器类，封装代理行为

implementsMethodInterceptor

2)使用ProxyFactoryBean产生代理

属性：

target目标对象e

proxyInterfaces代理的接口

interceptorNames代理要干什么

补充：Advice/Interceptor

除了MethodInterceptor,还有多种接口可供选择

决定拦截方法的时机

方法前拦截MethodBeforeAdvice

方法后拦截AfterReturningAdvice

方法抛出异常后拦截ThrowsAdvice

围绕方法拦截MethodInterceptor

MethodInterceptor通用

Pointcut

切点，相当于过滤器，缩小拦截的方法的范围

概要：

缩小接口或类的范围

缩小方法的范围

实施

1)implementsPointcut

定制过滤规则

ClassFilter

站在接口或类的级别上缩小范围

MethodMatcher

站在方法的级别上所有范围

isRuntime()

returntrue,意味着要对参数的值做判断，会调用有三个参数的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

longopen(Stringname,doubleinit);

withdraw(longid,doubleamount);

deposit(longid,doubleamount);

List<Account>findByName(Stringname)

JdbcAccountDao

applicationContex.xml

提供数据源，注入给DAO

实践经验：

Dao中定义的方法是持久化单元操作，

一个事务可能有若干个单元操作构成，

所以事务逻辑不应该出现在Dao中。

通常事务逻辑应用在业务层(service层)

采用AOP管理事务

JdbcTransactionManagerimplementsMethodInterceptor

问题：

1)事务管理器与Dao都操作同一个连接对象

2)同时，要保证在每个线程都操作不同的连接对象

解决方法：采用ThreadLocal管理连接对象

创建模板类

管理资源(连接对象)的获取释放

执行SQL

JDBCTemplate

update(Stringsql,Object[]args);

List<Map>query(Stringsql);

结论：事务管理棘手

资源的管理棘手

五、对Jdbc的支持

1.提供了JdbcTemplate简化编程

2.提供了声明的事务管理(与编程的事务管理)

不再把事务逻辑硬编码在程序中，而是在配置文件中定义事务边界

3.把所有checkedException--->uncheckedException

SQLException--->DataAccessException

应用步骤：

Account

IAccountDao

longopen(Stringname,doubleamount);

voiddeposit(longid,doubleamount);

voidwithdraw(longid,doubleamount);

List<Account>findByName(Stringname);

JdbcAccountDaoextendsJdbcDaoSupport

继承了两个方法：

setDataSource(DataSourceds)

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)HibernateAccountDaoextendsHibernateDaoSupport

setSessionFactory()

getHibernateTemplate()

2)事务管理器使用HibernateTransactionManager

(org.springframework.orm.hibernate3.HibernateTransactionManager)

3)使用LocalSessionFactoryBean获得SessionFactory

1.SpringDAO,SpringORM给持久层带来的好处：

省去trycatch代码，事务、异常自动处理

2.访问数据源的两种方法(b/s,c/s)：

dataSource:

JDBCDriverJNDI

7.事务的五个属性：

传播性、只读、

day5

Struts1.x流程：

B(浏览器)---->ActionServlet-->RequestProcessor-->Action-->JavaBean-->DB

request↓<--<--<--

struts-config.xml

七、在web应用中使用Spring

概述：

Spring提供监听器，在应用部署时构造ApplicationContext

ApplicationContext对象会被绑定在servletcontext中

Spring提供了API获得servletcontext中的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中获得上下文

WebApplicationContextcontext=

WebApplicationContextUtils

.getWebApplicationContext(this.getServletContext());

-------------------------

八、对Struts的支持

辅助Action获得model对象

两种选择：

Action不受Spring管理

Spring为Action获得applicationContext提供支持

Action受Spring管理，

容器为Action注入依赖的model对象

使用Spring的RequestProcessor或Action代理实现

与Struts集成的两种选择：

1spring不管理Action

那只需要关注Action怎样获得上下文,两种方式可选择

1)仍然通过WebApplicationContextUtils获得

WebApplicationContextUtils.getWebApplicationContext(

this.getServlet().getServletContext());

2)XxActionextendsActionSupport

继承了一个方法：getWebApplicationContext

令外可选择:

DispatchActionSuport

LookupDispatchActionSupport

MappingDispatchActionSupport

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

2让Spring管理Action

把Action做为bean配置

这样就可以注入Action依赖的model对象了

实现机制，有两种：

改变RequestProcessor创建Action的行为

改由上下文中获得action

原理：覆盖processActionCreate

所有请求都给一个特殊的Action，

此Actionexecute方法由上下文中获得action

然后把处理行为委托给action

returnaction.execute()

Spring给我们提供了这两种机制的实现

实施：

1)把Action作为bean配置,注入其依赖的model组件

applicationContext.xml:

<beanname="/actionpath"class="actionclass">

<propertyname="foo">

<refbean="foo"/>

</property>

</bean>

struts-config.xml:

<actionname="/actionpath"type="actionclass"/>

type无效

即，等价于：

<actionname="/actionpath"/>

2)选择RequestProcessor或者Action，

使其委托请求给spring管理的bean

A)使用DelegatingRequestProcessor

<controllerprocessorClass=

"org.springframework.web.struts.DelegatingRequestProcessor"/>

B)使用Action的代理DelegatingActionProxy

<actionpath="/actionpath"

type="org.springframework.web.struts.DelegatingActionProxy"/>

SpringSecurity(安全)

比较JAAS与SpringSecurity

JAASSpringSecurity

与具体的web容器有关与具体web容器无关(技术：IOC/AOP)

推荐书籍(学完这课程之后再看)：

Spring2.x(2.0/2.5)实例指南

Spring2企业级开发(图灵出版社)