Spring note

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企业级开发(图灵出版社)