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
1
2
　　　　(2) ApplicationContext

　　　　(3) WebApplicationContext

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 />
1
在切面组件中追加注解标记 
@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的同一个实例。

事物拦截器的实现原理。

spring中的事务管理是通过AOP代理来实现的，对被代理对象的每个方法进行拦截, 
在方法执行前启动事务,方法执行完后根据是否有异常和异常的种类进行提交或回滚。

来源：CSDN 
原文：https://blog.csdn.net/weixin_39671217/article/details/78007974