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企业级开发(图灵出版社)
posted on 2009-06-01 21:35
wcily123 阅读(452)
评论(0) 编辑 收藏 所属分类:
SSH--Spring