spring框架巨巨巨巨详细

Spring框架是一个轻量级的企业级应用框架 企业应用开发的"一站式"选择，贯穿于表现层、业务层、持久层

1.优点 ：

1.低侵入式设计 独立于各种应用服务器

2.依赖注入特性将组件关系透明化，降低耦合度 面向切面编程特性允许将通用任务进行集中式处理

3. 与第三方框架的良好整合

2.Spring框架的组成结构图如下所示:

3.Spring设计理念：是面向Bean的编程

4.Spring两大核心技术

1.控制反转(IoC：Inversion of Control)/依赖注入(DI：Dependency Injection)

2.面向切面编程(AOP：Aspect Oriented Programming)

 5.AOP

5.1 AOP原理：

1.将复杂的需求分解出不同方面，将不同对象、不同模块之间的共同业务集中解决

2.通过动态代理的方式，把抽离出来的共性代码"织入"到业务代码中，实现对原有代码的增强处理

5.2 AOP的步骤：

1.创建一个增强。并纳入spring的容器中。使一个普通类变成增强有很多种：

    【1】使用类似<aop:before>标签把普通类变成增强

    【2】实现BeforeAdvice接口也可以把普通类变成增强。

<bean id="loggerAdvice" class="com.advice.LoggerAdvice"></bean>

2.创建切入点。

<aop:pointcut expression="execution(public void print())" id="pointcut"/>

3.定义切面。包涵增强的方法和切入点。

<aop:aspect ref="loggerAdvice">

    <aop:before method="before" pointcut-ref="pointcut"/>

</aop:aspect>

5.2 AOP相关术语：

• Aspect（切面）
• Advice（增强处理）
• Pointcut（切入点）
• Join Point（连接点）
• Target Object（目标对象）
• AOP proxy（AOP 代理）
• Weaving（织入）

5.3 各种增强类型

增强类型	特点
Before	前置增强处理，在目标方法前织入增强处理
AfterReturning	后置增强处理，在目标方法正常执行（不出现异常）后织入增强处理
AfterThrowing	异常增强处理，在目标方法抛出异常后织入增强处理
After	最终增强处理，不论方法是否抛出异常，都会在目标方法最后织入增强处理
Around	环绕增强处理，在目标方法的前后都可以织入增强处理。可以控制目标方法是否执行

5.4 AOP实现注解

1.在spring配置文件中启用注解框架

<aop:aspectj-autoproxy/>

2.在增强的类名上定义切面：注意一定要把这个增强类注册到spring中

@Aspect

@Component

public class Zhang

3.在具体的增强方法上定义增强的类型和切入点规则   

@Before("execution(public void print())")

   public void Zhang(JoinPoint jp)

6.IOC 

spring中使用ioc的步骤：

1.创建类。

2.通过bean标签把bean放到spring中。

3.初始化spring配置文件拿到spring的上下文，通过spring的上下文获取对应的bean。

6.1 构造器注入。

    1.创建一个自定义的有参构造函数，务必自行添加无参的构造函数。

    2.constructor-arg代表构造函数的一个参数。

    3.参数的属性默认就是标签的先后顺序。可以通过index属性（从0开始）来指定顺序。

6.2 p命名空间注入。使用属性元素，而不使用子元素来进行注入。

    1.语法：p:属性名="属性值"  p:属性名-ref="bean的id"

    2.需要引入p命名空间。

​xmlns:p="http://www.springframework.org/schema/p";
​

6.3 各种不同类型的注入

    1.特殊字符：<![CDATA[   ]]> 

    2.set和list集合  

<property name="ss">

          <set>

              <value>等等</value>

              <value>想想</value>

          </set>

</property>

    3.map集合     

      <property name="ss">

          <map>

              <entry>

                 <key></key>

                 <value>想想</value>

              </entry>

          </map>

       </property>

    4.props属性文件     

      <property name="">

          <props>

              <prop key=""></prop>

          </props>

       </property>

6.4 IoC/DI是什么?

6.5 IoC:就是使用IoC/DI容器反过来控制应用程序所需要的外部资源，这样的一种程序开发思想。

6.6 DI：就是应用程序依赖IoC/DI容器来注入所需要的外部资源，这样一种程序的开发思想。

　　1.能做什么?  松散耦合对象

　　2.怎么做? 使用Spring框架，里面有实现好了的IoC/DI容器

　　3.用在什么地方?  凡是程序里面需要使用外部资源的情况，都可以考虑使用IoC/DI容器

7.使用注解实现IOC和AOP

7.1 IoC注解实现：

1.在类上使用注解，实现组件的定义。被这些注解注释的类，在spring中就会有一个对象。

    @component：实现Bean组件的定义 。默认的id为 类名首字母小写<bean class="com.bean.User">

    @repository    ：用于标注DAO类

    @service    ：用于标注业务类

    @controller    ：用于标注控制器类

7.2 在属性上使用注解，实现属性的注入。

    1. 是默认按照类型进行注入，如果在spring中有多个相同的数据类型会报错。

@Autowired

 2.是默认按照属性的名称进行自动注入，也可以指定bean的id。

@Resource(name="zhiA4") 

 3.在spring的主配置文件中，指明要扫描的基本包（包涵子包）。

<context:component-scan base-package="com"/>

8.控制反转:

　　8.1 谁控制谁?  IoC/DI容器控制应用程序

　　8.2 控制什么? IoC/DI容器控制对象本身的创建、实例化; IoC/DI容器控制对象之间的依赖关系

　　8.3 为何叫反转(对应于正向)? 因为现在应用程序不能主动去获取外部资源了，而是被动等待IoC/DI容器给它注入它所需要的资源，所以称之为反转.

　　8.4哪些方面反转了?

                1.创建对象

                2.程序获取资源的方式反了

　　8.5为何需要反转?

                1.引入IoC/DI容器过后,体系更为松散，而且管理更有序;

                 2.类之间真正实现了松散耦合

9.依赖 

　　9.1 什么是依赖(按名称理解、按动词理解)? 依赖(按名称理解):依赖关系;  依赖(按动词理解):依赖的动作

　　9.2 谁依赖于谁?　 应用程序依赖于IoC/DI容器

　　9.3 为什么需要依赖? 因为发生了反转，应用程序依赖的资源都是IoC/DI容器里面

　　9.4 依赖什么东西? 应用程序依赖于IoC/DI容器,依赖IoC/DI容器为它注入所需要的资源。（比如：依赖关系）

10.注入:

　　10.1 谁注入于谁?  IoC/DI容器注入于应用程序

　　10.2 注入什么东西?  注入应用程序需要的外部资源，比如依赖关系

　　10.3 为何要注入?  因为程序要正常运行需要这些外部资源

11.依赖注入和控制反转是同一概念吗?

　　11.1 不是同一概念， 其实它们两个描述的是同一件事件，但是是从不同的角度来说:控制反转是从IoC/DI容器的角度；依赖注入是从应用程序的角度

　　11.2 控制反转的描述： IoC/DI容器反过来控制应用程序，控制应用程序锁所需要的外部资源（比如：外部资源）

　　11.3 依赖注入的描述： 应用程序依赖IoC/DI容器，依赖它注入所需要的外部资源。

12.参与者都有哪些?

IoC/DI容器、应用程序

13.什么是外部资源

　　对于一个类来讲，所谓的外部资源，就是指在自己类的内部不能得到或实现的东西，比如说:在类里面需要读取一个配置文件，那么这个配置文件就相当于这个类的外部资源。又比如：A类里面要调用B类，那么对于A类来讲B类就是外部资源。

14. IoC容器

　　14.1 简单的理解就是：实现IoC思想，并提供对象创建、对象装配以及对象生命周期管理的软件就是IoC容器。

　　14.2 对IoC的理解：

a. 应用程序无需主动new对象，而是描述对象应该如何被创建

b. 应用程序不需要主动装配对象之间的依赖关系,而是描述需要哪个服务，IoC容器会帮你装配，被动接受装配

c. 主动变被动，是一种让服务消费者不直接依赖于服务提供者的组件设计方式，是一种减少类与类之间依赖的设计原则