Spring框架总结

简介

创立于 2003年 ,
是为了解决企业级开发的复杂性的!
是一个分层的se/ee(javase和java ee)一站式轻量级开源框架

作用：

1.Spring是一个开元的轻量级的应用开发框架，其目的是用于简化企业级应用程序开发，减少侵入；
2.Spring的IOC和AOP应用，将组件的耦合度降至最低，即解耦，便于系统的维护和升级；
3.可以与第三方框架和技术整合应用，可以自由选择技术进行开发。

注解方式：

a)@Component        为通用注解
b)@Repository       为持久层组件注解
c)@Service          为业务层组件注解
d)@Controller       为控制层注解
e)@Scope            为Bean的作用域注解
f)@Autowired        为指定Bean之间依赖关系的注解
g)@Inject           为指定Bean之间依赖关系的注解
h)@Value            为注入Spring表达式值的注解
j)@ResponseBody             为Ajax返回类型的注解

工作流程

同步请求与响应处理（普通浏览器请求，整个页面刷新）

异步请求与响应处理（Ajax请求，页面局部刷新）

spring功能的作用

IOC ：控制反转（获取方式发生反转，由最初new方式创建，转为由框架创建、注入，这样可以降低对象之间的耦合度。）
AOP：面向切编程（是一种编程思想，将系统中非核心的业务提取出来，进行单独处理）
WebMVC ：MVC结构的实现、与其他 Web技术整合（m模型v视图c控制）
DAO：与 JDBC整合和事务管理 (整合JDBC提供了封装，简化了DAO组件的编写)
ORM ：与 ORM 框架整合

springMVC实现，主要实现组件如下

DispatcherServlet （控制器, 请求入口）
HandlerMapping （控制器, 请求派发）
Controller （控制器, 请求处理流程）
ModelAndView （模型, 封装处理结果和视图）
ViewResolver（视图, 视图显示处理器）

Spring的AOP和IOC在项目中都是为了解决系统代码耦合度过高的问题。使代码重用度高、易于维护。比如事务、日志和安全等。

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) 注入简单属性

  　　　　　　<beans><bean id=”BeanId” class=”classpath” autowire=” ” dependency-check=” ”><property name=”parameterName”><value>parameterValue</value></property></bean></beans>对于基本类型，Spring容器会自动作类型转换，以便赋值。

(2) 注入对象

　　　　
　　　　
　　　　
A、让Spring容器在当前配置文件中找到相应的Bean，并调用set方法，注入该Bean。

B、将一个Bean的定义嵌套在另一个Bean中（可读性差），被嵌套的Bean不能采用getBean（）返回
C、采用<ref bean=” ”>搜索多个配置文件来注入

(3) 注入集合类型

① Set
Set中存放字符串，对象，集合，不允许重复

② List
List中可以放入字符串，对象，List

③ Map
Map 有子元素来存取key，value，key只能为String

④ Properties
Properties有子元素

　spring的AOP　　　
　
　 AOP从运行的角度考虑程序的流程，提取业务处理过程的切面。

将程序中的交叉业务逻辑提取出来，称之为切面。将这些切面动态织入到目标对象，然后生成一个代理对象的过程。

Aspect Oriented Programming 面向方面编程(面向切面编程) 以切面为核心编程/找切面、追加共通逻辑/掌握应用

Object Oriented Programming 面向对象编程以对象为核心编程/类设计/设计原则或模式

AOP还是已OOP为基础，只不过是将共通逻辑单独封装成组件，然后通过配置将组件动态切入到原有组件方法中。
优点：可以在不修改原有组件功能代码情况下，扩充组件功能,对共通需求和传统业务需求进行解耦。

AOP使用

将程序中的交叉业务逻辑提取出来，称之为切面。将这些切面动态织入到目标对象，然后生成一个代理对象的过程。

1. 切面组件（加什么功能？）Aspect

在组件中寻找共通位置和时机，将追加功能切入到原有组件中。追加的功能组件一般被称为切面组件。

2. 切入点（给谁加？）Pointcut

切入点用于指定切入目标组件或方法。Spring提供了多种表达式

方法限定表达式

execution(修饰符？返回类型方法名(参数列表) 抛出异常？)

//所有以find开头的方法要被切入追加功能 execution(* find*(..))
//DeptService类中所有方法要切入追加功能 execution(*
cn.xdl.service.DeptService.*(..)) //cn.xdl.service包下所有类所有方法
execution(* cn.xdl.service..(..)) //cn.xdl.service包及子包下所有类所有方法
execution(* cn.xdl.service...(..))
类型限定表达式

within(类型)

//DeptService组件所有方法要被切入追加功能 within(cn.xdl.service.DeptService)
//cn.xdl.service包下所有类所有方法 within(cn.xdl.service.*)
//cn.xdl.service包及子包下所有类所有方法 within(cn.xdl.service..*)
Bean名称限定表达式

bean(Spring容器中组件的id名)

//id=deptService组件的所有方法 bean(deptService) //id以Service结尾的组件的所有方法
bean(*Service)

AOP核心概念

1、Aspect（切面）—切面，是对交叉业务逻辑的统称。
2、Joinpoint（连接点）—连接点，指切面可以织入到目标对象的位置（方法，属性等）。
3、Advice（通知）—通知，指切面的具体实现。
4、Pointcut（切入点）—切入点，指通知应用到哪些类的哪些方法或属性之上的规则。
5、Introduction（引入）—引入，指动态地给一个对象增加方法或属性的一种特殊的通知。
6、Weaving（织入）—织入，指将通知插入到目标对象。
7、Target（目标对象）—目标对象，指需要织入切面的对象。
8、Proxy（代理对象）—代理对象，指切面织入目标对象之后形成的对象。

通知（什么时候加？）Advice

通知用于决定切面组件追加的时机，例如在原有组件方法前、方法后、抛出异常之后等。

try{
//追加逻辑–》前置通知
//原有组件的方法
//追加逻辑–》后置通知｝catch(){
//追加逻辑–》异常通知 }finally{
//追加逻辑–》最终通知
}
环绕通知：等价于前置+后置综合效果

AOP案例1

要求：在调用DeptDao每个方法之前，都要打印一个消息”进入DeptDao执行处理”

1. 分析

切面组件：LoggerBean方法，在方法中追加功能逻辑
通知：使用前置通知

切入点：DeptDao组件所有方法
within(cn.xdl.dao.JdbcDeptDao)

2. 编写切面组件

  public class LoggerBean {//前置通知方法            public void mybefore(){System.out.println("进入了DeptDao组件方法执行处理");           }       }

3. AOP XML 配置

AOP配置

<aop:aspectj-autoproxy />

在切面组件中追加注解标记
@Component//等价于定义 @Aspect//等价于定义 public class LoggerBean { //前置通知方法
@Before(“execution(* cn.xdl.dao.JdbcDeptDao.find*(..))”)//等价于
public void mybefore(){
System.out.println(“进入了DeptDao组件方法执行处理”);

}
}

AOP案例2

需求：为程序中处理组件追加性能监测日志，记录哪个方法执行了多长时间。

1. 分析

通知：采用环绕通知

切入点：程序中所有自定义组件 within(cn.xdl..*)

切面组件：计算出执行时间，记录到数据库或文件中

2. 编写切面组件

@Component
@Aspect
public class WatchBean {
@Around(“within(cn.xdl..*)”) public Object watch(ProceedingJoinPoint pjp) throws Throwable{
//加前置逻辑，在原有组件方法前调用
long begin = System.currentTimeMillis();
Object obj = pjp.proceed();//执行原有组件的方法
//加后置逻辑，在原有组件方法后调用
long end = System.currentTimeMillis();
long time = end-begin;//用时（毫秒）
//获取目标方法信息
String targetClass = pjp.getTarget().getClass().getName();//获取目标组件类型名
String methodName = pjp.getSignature().getName();//获取执行的目标方法名
System.out.println(targetClass+”类的”+methodName+”方法耗时”+time+”毫秒”);
return obj; }
}

3. AOP配置

追加@Component、@Aspect、@Around注解标记、@Aspect切面组件、@Around环绕

##AOP原理（动态代理技术）

当使用Spring AOP切入目标组件之后，从Spring容器再获取目标组件，容器返回的是一个动态生成的类型（代理类）对象，该代理类对象重写原有目标组件的方法，在重写方法中调用原有组件方法功能+切面组件的追加功能。
该技术被称为动态代理技术，Spring使用了下面两种：

目标组件有接口采用下面机制（JDK Proxy API）

创建一个新的组件，组件实现了原有接口，把所有方法完成

- 目标组件没有接口采用下面机制（CGLIB工具，推荐）
创建一个新的组件，组件继承了原有目标组件，把所有方法重写
- 可以在aop配置强制指定目标组件生成机制
<aop:aspectj-autoproxy proxy-target-class="true"/>

强制Spring容器采用CGLIB方式生成目标组件的子类，重写目标组件方法。

请求转发/请求重定向

请求转发
return “forward:xx.do”;
请求重定向
return “redirect:xx.jsp”;

Spring的Bean有以下五种作用域：

1.singleton:SpringIoc容器只会创建该Bean的唯一实例；
2.prototype:每次请求都创建一个实例；
3.request:每次HTTP请求都会产生一个新的bean。
4.session :每次会话创建一个实例；
5.global session :全局的HttpSession中,容器会返回该bean的同一个实例。

事物拦截器的实现原理。