一、Spring是什么?
在了解Spring之前,我们来了解在Java EE框架下企业级开发采用EJB框架的一些不足:
(1) EJB太笨重,而且Entity EJB不能脱离容器
(2) 企业级服务使用困难
(3) 开发的复杂度太高
(4) 侵入式方案,EJB要使用特定的接口
因此,Spring应运而生。
Spring是一个开源的用于简化采用Java语言开发企业级程序的一个分层的框架。
关于程序的分层结构:
1、Presentation layer(表示层)
(1) 表示逻辑(生成界面代码)
(2) 接收请求
(3) 处理业务层抛出的异常
(4) 负责规则验证(数据格式,数据非空等)
(5) 流程控制
2、Service layer(服务层/业务层)
(1) 封装业务逻辑处理,并且对外暴露接口
(2) 负责事务,安全等服务
3、Persistence layer(持久层)
(1) 封装数据访问的逻辑,暴露接口
(2) 提供方便的数据访问的方案(查询语言,API,映射机制等)
Domain layer(域层)
(1) 业务对象以及业务关系的表示
(2) 处理简单的业务逻辑
(3) 域层的对象可以穿越表示层,业务层,持久层
二、Spring的作用
为什么要使用Spring?
(1) 简化企业级开发
① 封装了大部分的企业级服务,提供了更好的访问这些服务的方式
② 提供了IOC,AOP功能的容器,方便编程
(2) 遵循Spring框架的应用程序,一定是设计良好的,针对接口编程,这样就简化了企业级程序的设计。
(3) Spring的组成
① Spring Core:核心容器,BeanFactory提供了组件生命周期的管理,组件的创建,装配,销毁等功能
SpringContext:ApplicationContext,扩展核心容器,提供事件处理、国际化等功能。它提供了一些企业级服务的功能,提供了JNDI,EJB,RMI的支持。
② Spring AOP:提供切面支持
③ Spring DAO:提供事务支持,JDBC,DAO支持
④ Spring ORM:对流行的O/R Mapping封装或支持
⑤ Spring Web:提供Web应用上下文,对Web开发提供功能上的支持,如请求,表单,异常等。
⑥ Spring Web MVC:全功能MVC框架,作用等同于Struts。
一、IoC的概念
IoC,Inversion of Control,控制反转。
对象的协作关系由对象自己负责。
依赖注入:对象的协作关系有容器来建立。
二、IoC的类型
(1) 基于特定接口(侵入式方案)
(2) 基于set方法
(3) 基于构造器
三、Spring容器
Spring容器负责生成、组装、销毁组件,并负责事件处理、国际化等功能。
(1) BeanFactory
① 核心容器,负责组件生成和装配
② 实现主要包括Xml BeanFactory
(2) ApplicationContext
(3) WebApplicationContext
(4) ……
四、IoC的使用
Resource:interface,用来包装资源
xmlBeanFactory:BeanFactory的一个实现,使用Resource对象来查找配置文件
BeanFactory.gerBean(“BeanId”):取得以参数命名,或者Id等于参数值的一个Bean实例。
BeanFactory(容器)在默认情况下,会采用单例方式返回对象。容器只到调用getBean方法时,才会实例化某个对象。
(1) Spring可以采用XML或者.properties文件作配置
(2) 配置文件(XML)
根元素
1、setter注入
(1) 注入简单属性(String和8中基本类型)
对于基本类型,Spring容器会自动作类型转换,以便赋值。
(2) 注入对象
A、让Spring容器在当前配置文件中找到相应的Bean,并调用set方法,注入该Bean。
B、将一个Bean的定义嵌套在另一个Bean中(可读性差),被嵌套的Bean不能采用getBean()返回
C、采用搜索多个配置文件来注入
(3) 注入集合类型
① Set
Set中存放字符串,对象,集合,不允许重复
② List
List中可以放入字符串,对象,List
③ Map
Map 有
④ Properties
Properties有
2、consctructor注入
如果Bean属性不多,并且属性值必须要注入才能使用,则应该采用constructor注入,其他情况就要set方法注入。
装配关系检查(Dependency checking)
simple:检查简单类型
ojects:检查对象类型
all:检查所有
自动装配(Autowring Properties)
装配方式:byName,byType,autodetect,constructor
autowire=“byName”:按照名称匹配
按照Bean的Id与属性的名称进行匹配
自动装配与手动装配可以结合使用,手动装配会覆盖自动装配。
autowire=“byType”:按照类型匹配
要注入的属性类型与配置文件中的Bean类型匹配的个数超过一个,会出错。
autowire=“antodetect”:
先按照construct,后按照byType。
autowire=“constructor”:
先去匹配构造器中参数类型,后与配置文件中的Bean类型匹配。
3、比较两种注入方式
关于自动匹配:
优点:快速开发
缺点:依赖关系不清楚,易出错,不易维护。
自动匹配的应用场合:
(1) 构建系统原型
(2) 与依赖关系检查(Dependency-check)结合使用
(3) 自动装配与手动装配结合
4、特殊的IoC
① 后处理Bean
接口:org.springframework.beans.factory.config.BeanPostProcessor
Spring已经实现该接口的BeanPostProcessor(不用再注册)
ApplicationContextAwareProcessor:
把应用上下文传递给所用实现了 ApplicationContextAware接口的Bean
ApplicationContextAware接口使用举例,可参照事件监听机制
DefaultAdvisorAutoProxyCreator自动对Bean应用切面
② Bean工厂后处理(只能在应用上下文中使用)
接口:org.springframework.beans.factory.config.BeanFactoryPostProcessor
Spring内部接口实现:
org.springframework.beans.factory.config.PropertyPlaceholderConfigurer
属性编辑
org.springframework.beans.factory.config.CustomEditorConfigurer
CustomerInfo("fname-lname-address")
实例工厂配置
代码:
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
静态工厂配置
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
5、事件处理
事件监听
1)自定义事件,通过继承org.springframework.context.ApplicationEvent
2)自定义监听器,实现 org.springframework.context.ApplicationListener,并注册
3)发布事件,为得到应用上下文,
必须实现org.springframework.context.ApplicationContextAware接口
一、AOP(Aspect-oriented programming,面向切面编程):
什么是AOP?
定义:将程序中的交叉业务逻辑提取出来,称之为切面。将这些切面动态织入到目标对象,然后生成一个代理对象的过程。
二、AOP核心概念
1、Aspect(切面)
切面,是对交叉业务逻辑的统称。
2、Joinpoint(连接点)
连接点,指切面可以织入到目标对象的位置(方法,属性等)。
3、Advice(通知)
通知,指切面的具体实现。
4、Pointcut(切入点)
切入点,指通知应用到哪些类的哪些方法或属性之上的规则。
5、Introduction(引入)
引入,指动态地给一个对象增加方法或属性的一种特殊的通知。
6、Weaving(织入)
织入,指将通知插入到目标对象。
7、Target(目标对象)
目标对象,指需要织入切面的对象。
8、Proxy(代理对象)
代理对象,指切面织入目标对象之后形成的对象。
三、Spring AOP原理
采用动态代理模式。
Spring AOP采用动态代理的过程:
(1) 将切面使用动态代理的方式动态织入到目标对象(被代理类),形成一个代理对象;
(2) 目标对象如果没有实现代理接口,那么Spring会采用CGLib来生成代理对象,该代理对象是目标对象的子类;
(3) 目标对象如果是final类,并且也没实现代理接口,就不能运用AOP。
四、Spring的通知
1、Spring的通知类型
(1) MethodBeforeAdvice
类全名:org.springframework.aop.MethodBeforeAdvice
在方法调用之前,做处理。
不能够改变返回值
不能够改变目标方法的流程,也不能中断流程的处理过程(除非抛出异常)
(2) AfterReturningAdvice
类全名:org.springframework.aop.AfterReturningAdvice
在方法调用之后,做处理。
不能够改变返回值
不能够改变目标方法的流程,也不能中断流程的处理过程(除非抛出异常)
(3) MethodInterceptor
类全名:org.aopalliance.intercept.MethodInterceptor
在方法调用之前以及之后,做处理。
可以改变返回值,也可以改变流程。
(4) ThrowsAdvice
类全名:org.springframework.aop.ThrowsAdvice
在方法抛出异常后,做处理。
当该通知处理完异常后,会简单地将异常再次抛出给目标调用方法。
2、配置过程:
(1)配置目标对象
(2)配置通知
(3)利用ProxyFactoryBean将通知织入到目标对象,形成一个动态代理对象
(4)客户端使用动态代理来访问目标对象的方法。
在默认情况下,通知会应用到所有的方法之上。
Pointcut:
根据方法和类决定在什么地方织入通知
Advisor:
将Pointcut与Advice结合到一起。
自定义切入点:
步骤:
1)实现org.springframework.aop.ClassFilter
2)实现org.springframework.aop.MethodMatcher
3)实现org.springframework.aop.Pointcut
4)实现org.springframework.aop.PointcutAdvisor
注意:
在此可定义
private Advice advice;
private Pointcut pointcut;
在配置文件中,将自定义的切入点与通知绑订到一起
5)利用ProxyFactoryBean将advisor织入到目标对象
ProxyFactoryBean的作用:
依照配置信息,将切面应用到目标对象,生成动态代理对象。
(1) Spring只支持方法连接点,不支持属性连接点。
(原因是Spring AOP采用的是动态代理模式,而动态代理本身就是在方法调用前加入代码。)
(2) Spring只在运行时,将切面织入到目标对象。
(有些AOP实现,可以在编译是织入切面到目标对象。)
Injecting Advice(con’t d)
(如果没有定义接口,则所有方法使用CGLib
五、切入点(Pointcut)
1、Pointcut
切入点是指通知/切面可以应用到哪些类,哪些方法之上。
Pointcut API
Pointcut:org.springframework.aop.Pointcut
对某些类某些方法应用切面。
Classfilter:org.springframework.aop.ClassFilter
用来过滤类(哪些类可以应用切面)
MethodMather:org.springframework.aop.MethodMatcher
用来过滤方法(类中哪些方法应用切面)
Advisor:org.springframework.aop.PointcutAdvisor
将Pointcut与Advice结合到一起
配置文件样例:
2、预定义切入点
① 静态切入点:
a、NameMatchMethodPointAdviosr
org.springframework.aop.support.NameMatchMethodPointcutAdvisor
根据方法名称的特点进行匹配
核心XML:mappedName→advice(ref)
配置文件样例:
class="org.springframework.aop.framework.ProxyFactoryBean">
b、RegexpMethodPointcutAdvisor
根据正则表达式匹配方法名
org.springframework.aop.support.RegexpMethodPointcutAdvisor
核心XML:pattern→advice(ref)
配置文件样例:
class="org.springframework.aop.framework.ProxyFactoryBean">
② 动态切入点:
org.springframework.aop.support.ControlFlowPointcut
③ 切入点的交叉与合并:
Pointcuts.union
配置文件样例:
④ Introduction
一种特殊类型的Advice,为类动态增加方法和属性。
编程步骤:
1)实现org.springframework.aop.IntroductionInterceptor或
继承org.springframework.aop.support.DelegatingIntroductionInterceptor
2)使用org.springframework.aop.support.DefaultIntroductionAdvisor
配置文件样例:
六、自动代理
Spring在生成代理对象的时候,默认情况下,会使用被代理对象的接口来生成代理对象。
如果被代理对象没有实现接口,此时,Spring会使用CGLIB生成代理对象,此时该代理对象是被代理对象的子类。
a、BeanNameAutoProxyCreator
org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator
根据类的名称来为符合相应名称的类生成相应代理对象。
beanNames(list),interceptorNames
配置文件样例:
b、DefaultAdvisorAutoProxyCreator
org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator
自动将Advisor与匹配的Bean进行绑定
只能与Advisor配合使用
配置文件样例:
Spring对持久层的支持:① JDBC,② O/R Mapping(Hibernate,TopLink等)
一、Spring对持久层支持采用的策略:
1、Spring对持久层“不发明重复的轮子”,即没有重新实现新的持久层方案,对现有持久层方案做封装,更利于使用。
2、采用DAO模式
3、提供了大量的模板类来简化编程(HibernateDaoSupport,JdbcTemplate等)
4、重新设计了一套完善的异常体系结构
① 类型丰富,细化异常类型
② 全都是运行时异常(RuntimeException)
二、Spring对JDBC的支持
1、配置数据源
方式一:采用Spring内置的数据源,Spring内置实现 DriverManagerDataSource
方式二:采用开源数据库产品如DBCP
DBCP提供的BasicDataSource
方式三: 直接使用容器提供的数据源(如Tomcat,Weblogic,Sun Application Server)
JNDI数据源:(mysql5,tomcat5.5)
step1:
在server.xml中:
type="javax.sql.DataSource" username="root" password="windows" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql://localhost:3306/tarena" maxActive="5" /> step2: 在context.xml中(conf\context.xml): step3: 在beans-config.xml: 2、配置JdbcTemplate模板类(封装了绝大多数数据库操作) 3、配置DAO 4、配置Service 编程步骤: step1: 配置数据源 step2: 配置JdbcTemplate class="org.springframework.jdbc.core.JdbcTemplate"> step3:配置DAO 注意: 查询时,使用RowMapper 三、Spring对Hibernate的支持 Step1: 配置数据源 Step2: 配置sessionfactory class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> org.hibernate.dialect.MySQLDialect Step3: 配置DAO 注意:以上配置是要求dao 继承HibernateDaoSupport 一、AOP事务的含义: 事务当作一个切面,动态地织入到目标对象,形成一个代理对象。 二、Spring的事务机制 Spring支持声明式事务。 Spring使用事务服务代理和事务管理器(如HibernateTransactionManager)来支持事务服务。 Spring对事务的边界多了一种嵌套事务(PROPAGATION_NESTED)。 PROPAGATION_NESTED: 如果客户端启动了事务T1,那么Bean启动一个嵌套在T1中的子事务T2; 如果客户端没有启动事务,那么Bean会启动一个新的事务,类似于REQUIRED_NEW 三、Spring中事务的使用 1、Spring中使用Hibernate事务 Step1:配置数据源 Step2:配置sessionfactory (同上) Step3:配置事务管理器 class="org.springframework.orm.hibernate3.HibernateTransactionManager"> Step4:创建事务服务代理 class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 事务属性描述格式: 传播行为,隔离级别,只读事务(read-only),回滚规则 在默认情况下,Spring的容器对于非受查异常(服务模块中抛出的非受查异常),会回滚事务。对于受查异常,会提交事务。 如果即使发生了某种受查异常,也要回滚事务,可以用 “- 异常类型“来声明。同样,对于非受查异常,如果不要求回滚事务,可以用"+异常类型"来声明。 如何简化事务配置? 使用继承(抽象的Service类)、自动代理。 四、Spring事务与EJB事务 1、EJB事务: EJB的CMT管理事务方式,只能设置事务边界(传播行为),对于隔离性是不能设置的,并且EJB不支持嵌套事务。 2、Spring事务: 对于Spring来说, Spring的声明式事务可以设置事务边界(传播行为),设置隔离级别,设置只读事务,回滚规则(+:对于任何异常都提交,-:对于任何异常都回滚) PS:Spring对嵌套事务的支持依赖与数据库底层对嵌套式事务的支持。 一、SSH: Struts(表示层)+Spring(业务层)+Hibernate(持久层) Struts: Struts是一个表示层框架,主要作用是界面展示,接收请求,分发请求。 在MVC框架中,Struts属于VC层次,负责界面表现,负责MVC关系的分发。(View:沿用JSP,HTTP,Form,Tag,Resourse ;Controller:ActionServlet,struts-config.xml,Action) Hibernate: Hibernate是一个持久层框架,它只负责与关系数据库的操作。 Spring: Spring是一个业务层框架,是一个整合的框架,能够很好地黏合表示层与持久层。 ① Web分层架构中业务层为什么都选择Spring? Service层需要处理业务逻辑和交叉业务逻辑,处理事务,日志,安全等,而这些与Spring的IoC,AOP等不谋而合。 ② Web分层架构中,对于各层技术的采用应该遵循一个怎样的标准? 1、选择发展成熟的技术: A、经过了项目实践证实可行性良好 B、文档完善 C、技术一直处于可持续发展更新 2、Web应用中对于技术的选择有赖于开发人员的技术掌握情况 二、Spring与Struts整合 前提: 必须在Web应用启动时,创建Spring的ApplicationContext实例 方式: 1、采用ContextLoaderListener来创建ApplicationContext: /WEB-INF/spring-config/applicationContext.xml org.springframework.web.context.ContextLoaderListener 2、采用ContextLoaderPlugIn来创建ApplicationContext 或者: 通过listener装载spring应用上下文 方式一:通过Spring的ActionSupport类 ActionSupport类: 知道ApplicationContext的获得方式。 步骤: 1、Action直接继承ActionSupport 2、使用ApplicationContext ctx = getWebApplicationContext();取得Spring上下文 3、取得相应Bean 注意:有可能需要替换commons-attributes-compiler.jar包。 优点: 简单 缺点: 耦合高 违反IOC 无法使用多方法的Action 方式二:通过Spring的DelegatingActionProxy类 步骤: 1、Action中,使用IOC获得服务 2、配置struts-config.xml 3、在Spring配置文件中 注意,要用bean name命名。 /somepath:Action的path 优点: 不使用Spring api编写 Action 利用了IOC装配。 可以利用容器的scope="prototype"来保证每一个请求有一个单独的Action来处理, 避免struts中Action的线程安全问题。 缺点: struts配置文件中,所有path都映射到同一个代理类 方式三:通过Spring的DelegatingRequestProcessor类 步骤: 1、Action中,使用IOC获得服务 2、配置struts-config.xml 3、在Spring配置文件中 小结: Spring与Struts整合方式只有两种: (1)由Spring容器来管理Action(方式二,方式三) (2)Action处于容器之外(方式一) 注意: 中文问题: 设置过滤器,设置页面编码,数据库编码 三、关于Spring与EJB 1、Spring与EJB3.0的对比 Spring与EJB3.0之间的关系是竞争关系。 ① Spring是一个开源的框架,而EJB3.0是一个标准(标准意味着将得到广泛的支持以及良好的兼容性),并且,采用EJB3.0,项目的后期维护得到了保证。 ② Spring是一个轻量级框架,EJB3.0是一个重量级框架(完整的容器,包含所有的服务)。 ③ Spring的IoC,AOP集成了大量的开源框架,可扩展性良好。EJB3.0的可扩展性则完全依赖于新的容器。 ④ Spring对事务支持不如EJB3.0成熟,Spring对集群的兼容也不够。 ⑤ Spring与EJB3.0都是一个企业级开发框架,都支持声明式事务。 2、Spring的优势与劣势 Spring的优势: ① 简化了企业级开发(对企业级服务进行了进一步的封装) ② 采用Spring框架的程序意味着良好的分层结构设计,并保证是面向接口编程的 ③ 用IoC,AOP容器,模块是可配置的,松耦合的,方便了后期维护 Spring的劣势: ① 配置复杂,不方便维护 ② 容器大量使用反射等机制装配对象,影响性能,对于高并发的大型应用无能为力。chapter05 Spring对事务的支持
chapter06 SSH整合