spring的使用（1）：IOC和AOP

今天药忘吃喽~ 2022-05-27 01:26 221阅读 0赞

一、spring的简介

Spring它是一个一站式的分层轻量级框架。spring的有多个模块，其中模块划分：

![70][]

1）core container

Core 和 Beans 模块提供了 Spring 最基础的功能，提供 IoC 和依赖注入特性。这里的基础概念是 BeanFactory，它提供对 Factory 模式的经典实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。

Context 模块基于 Core 和 Beans 来构建，它提供了用一种框架风格的方式来访问对象，有些像 JNDI 注册表。 Context 封装包继承了 beans 包的功能，还增加了国际化（I18N） ,事件传播，资源装载，以及透明创建上下文，例如通过 servlet 容器，以及对大量 JavaEE 特性的支持，如 EJB、 JMX。核心接口是 ApplicationContext。

Expression Language，表达式语言模块，提供了在运行期间查询和操作对象图的强大能力。支持访问和修改属性值，方法调用，支持访问及修改数组、容器和索引器，命名变量，支持算数和逻辑运算，支持从 Spring 容器获取 Bean，它也支持列表投影、选择和一般的列表聚合等

2）AOP

AOP：提供了符合 AOP 联盟规范的面向方面的编程实现，让你可以定义如方法拦截器和切入点，从逻辑上讲，可以减弱代码的功能耦合，清晰的被分离开。而且，利用源码级的元数据功能，还可以将各种行为信息合并到你的代码中。

Aspects 模块：提供了对 AspectJ 的集成。

Instrumentation 模块：提供一些类级的工具支持和 ClassLoader 级的实现，可以在一些特定的应用服务器中使用。

3）Test：提供对使用 JUnit 和 TestNG 来测试 Spring 组件的支持，它提供一致的ApplicationContexts 并缓存这些上下文，它还能提供一些 mock 对象，使得你可以独立的测试代码

4）Data access/integration

JDBC 模块，提供对 JDBC 的抽象，它可消除冗长的 JDBC 编码和解析数据库厂商特有的错误代码。

ORM 模块，提供了常用的"对象/关系"映射 API 的集成层。 其中包括 JPA、 JDO、 Hibernate和 iBatis 。利用 ORM 封装包，可以混合使用所有 Spring 提供的特性进行"对象/关系"映射，如简单声明性 事务管理 。

OXM 模块，提供一个支持 Object 和 XML 进行映射的抽象层，其中包括 JAXB、 Castor、XMLBeans、 JiBX 和 XStream。

JMS 模块，提供一套"消息生产者、消费者"模板用于更加简单的使用 JMS， JMS 用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。

Transaction 模块，支持程序通过简单声明性 事务管理，只要是 Spring 管理对象都能得到Spring 管理事务的好处，即使是 POJO，也可以为他们提供事务

5）Web（Spring本身提供spring mvc）

Web-Socket 模块， WebSocket protocol 是 HTML5 一种新的协议。它实现了浏览器与服务器全双工通信， spring 支持 webSocket 通信。

Web 模块，提供了基础的 web 功能。例如多文件上传、集成 IoC 容器、远程过程访问、以及 Web Service 支持，并提供一个 RestTemplate 类来提供方便的 Restful services 访问

Web-Servlet 模块，提供了 Web 应用的 Model-View-Controller（MVC）实现。 Spring MVC框架提供了基于注解的请求资源注入、更简单的数据绑定、数据验证等及一套非常易用的JSP 标签，完全无缝与 Spring 其他技术协作。

Web-Portlet 模块，提供了在 Portlet 环境下的 MVC 实现

二、spirng的基础模块：控制反转IOC和依赖注入DI

1）说明：IOC（inversion of Controller） 控制反转，就是原来由我们自己实例化的对象交给spring容器来实始化。这时对象的实始化的权利就会反转。

DI（dependency injection） 依赖注入，在spring框架负责创建Bean对象时，动态将依赖对象注入到Bean组件中。

spring的原理。

其中简单的理解控制反转和依赖注入，就是spring是一个bean的容器，其中管理者bean的实例化的创建，并且依赖注入可以很好的在bean中注入参数，将对象注入到bean中。也就是**一个bean的容器，管理者很多bean**。

IOC是指对象实例化权利由spring容器来管理；DI在spring创建对象的过程中，对象所依赖的属性通过配置注入对象中。

2）spring容器如何将javabean加载到容器中

**无参数构造**：Bean类中必须提供无参数构造

<table> 
 <tbody> 
  <tr> 
   <td> <p style="margin-left:0cm;">1、在开发中可以使用id或name，id它遵守的xml规范，名称中不能包含特殊符号，name它是为了更好的扩展，在name中可以包含一些特殊符号，例如"/"；</p> <p style="margin-left:0cm;">2.class是指具体的bean的全限定名</p> <p style="margin-left:0cm;">3、在bean声明时它有一个scope属性，它是用于描述bean的作用域。</p> <p style="margin-left:0cm;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; singleton：单例，代表在spring ioc容器中只有一个Bean实例 (默认的scope)；</p> <p style="margin-left:0cm;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; prototype：多例，每一次从spring容器中获取时，都会返回一个新的实例；</p> <p style="margin-left:0cm;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; request：用在web开发中，将bean对象request.setAttribute()存储到request域中；</p> <p style="margin-left:0cm;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; session：用在web开发中，将bean对象session.setAttribute()存储到session域中。</p> <p style="margin-left:0cm;">&nbsp; &nbsp; &nbsp; 注意：常用的值是singleton与prototype</p> </td> 
  </tr> 
 </tbody> 
</table>

**静态工厂方法**：需要创建一个工厂类，在工厂类中提供一个static返回bean对象的方法就可以

public class Bean2Factory {
    	public static Bean2 createBean2() {
    		return new Bean2();
    	}
    }

**实例工厂方法**：需要创建一个工厂类，在工厂类中提供一个**非static**的创建bean对象的方法，在配置文件中需要将工厂配置，还需要配置bean

public class Bean3Factory {
    
    	public Bean3 createBean3() {
    		return new Bean3();
    	}
    }

3）bean在spring容器中的生命周期

4）spring容器如何将javabean初始化的时候加载属性（依赖注入）

说明：在spring中bean的属性注入有两种：**构造器注入**和**Setter方法注入**

**构造器注入**：其中构造注入必须要有对应的参数构造的构造方法

public Car(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }

使用c名称空间可以解决我们构造器注入时<constructor-arg>简化

<table> 
 <tbody> 
  <tr> 
   <td>Spring2.0以后提供了xml命名空间，首先它们不是真正的名称空间，是虚拟的。它是嵌入到spring内核中的。在使用的时候需要将依赖xml导入到spring配置文件的头中</td> 
  </tr> 
 </tbody> 
</table>

**Setter方法注入**：其中对应的参数要有对应的set方法

使用p名称空间可以解决我们setter注入时<property>简化

<table> 
 <tbody> 
  <tr> 
   <td>注意，在使用命名空间简化注入的时候要注意，如果c或p名称空间操作的属性后缀是”-ref”代表要引入另一个已经存在的bean。</td> 
  </tr> 
 </tbody> 
</table>

其中集合通过setter方法来进行注入的方法

<bean id="collectionDemo" class="cn.itheima.di.CollectionDemo">
        
        <property name="list">
            <list>
                <value>张三</value>
                <value>10</value>
                <ref bean="car"/>
            </list>
        </property>
    	
        
        <property name="set">
            <set>
                <value >10</value>
                <value>李四</value>
                <ref bean="person"/>
            </set>
        </property>
    	
        
        <property name="map">
            <map>
                <entry  key="username" value="李四"></entry>
                <entry key-ref="person" value-ref="car"></entry> 
            </map>
        </property>
    	
        
        <property name="props">
            <props>
                <prop key="company">ITCAST</prop>
                <prop key="price">10000</prop>
            </props>
        </property>
    </bean>

<table> 
 <tbody> 
  <tr> 
   <td> <p>1、集合的setter注入规则：都用对应的名称来进行包裹，list用list，set用set，map用map，properties用props</p> <p>2、ref来引入另一个bean对象，完成bean之间注入，注意这个bean一定要是容器中的bean</p> </td> 
  </tr> 
 </tbody> 
</table>

5）在spring加载bean的时候，加载属性的时候还可以用SpEl来进行加载属性，其中用这个表达是一定要用spring容器中已有的值或属性，或javabean对象来进行取值。

格式：\#\{表达式\}

6）注解开发实现IOC和DI

我们如何实现bean加载到spring的容器中呢，在本节的2）中上面都是通过配置<bean>来实现将一个一个的bean加载到spirng容器中的，但是这样太麻烦了，所以我们用注解的方式来进行加载bean到容器中。

首先要使用注解，必须要在spring的配置文件applicationContext.xml中进行配置如下

<context:annotation-config />
    
    <context:component-scan base-package="cn.itheima" />

<table> 
 <tbody> 
  <tr> 
   <td> <p style="margin-left:0cm;">1、我们在applicationContext.xml文件中使用了一个标签&lt;context:annotation-config /&gt;,它代表的是可以使用spring的注解，但是我们在类上添加的注解，spring不知道位置。</p> <p style="margin-left:0cm;">2、要解决这个问题，我们可以使用&lt;context:component-sacn base-package="包位置"&gt;，而且这个标签有上面标签的作用，所以可以省略上面的标签。</p> <p style="margin-left:0cm;">3、要扫描多个包文件的使用可以用半角逗号隔开</p> <p style="margin-left:0cm;">&lt;context:component-sacn base-package="com.weiwei.spring.controller,com.weiwei.spirng.service.impl"&gt;</p> </td> 
  </tr> 
 </tbody> 
</table>

注解的分类：

<table> 
 <tbody> 
  <tr> 
   <td style="width:131px;">类型</td> 
   <td style="width:151px;">注解</td> 
   <td style="width:567px;">说明</td> 
  </tr> 
  <tr> 
   <td colspan="1" style="width:131px;">加载bean注解</td> 
   <td style="width:151px;">@Controller</td> 
   <td style="width:567px;">用于表现层web</td> 
  </tr> 
  <tr> 
   <td style="width:151px;">@Service</td> 
   <td style="width:567px;">用于service层</td> 
  </tr> 
  <tr> 
   <td style="width:151px;">@Repository</td> 
   <td style="width:567px;">用于DAO层</td> 
  </tr> 
  <tr> 
   <td style="width:151px;">@Component</td> 
   <td style="width:567px;">bean不明确位置的时候使用</td> 
  </tr> 
  <tr> 
   <td colspan="1" style="width:131px;">容器中bean的生命</td> 
   <td style="width:151px;">@Scope</td> 
   <td style="width:567px;">它相当于xml配置中的scope="prototype"</td> 
  </tr> 
  <tr> 
   <td style="width:151px;">@PostConstruct</td> 
   <td style="width:567px;">它相当于xml配置中的init-method="myInit"</td> 
  </tr> 
  <tr> 
   <td style="width:151px;">@PreDestory</td> 
   <td style="width:567px;"> <p>它相当于xml配置中的destroy-method="myDestroy"</p> <p>注意：对于销毁的方法它只对bean的scope=singleton有效</p> </td> 
  </tr> 
  <tr> 
   <td colspan="1" style="width:131px;">容器bean的属性注入</td> 
   <td style="width:151px;">@Value</td> 
   <td style="width:567px;"> <p>用来注入一般属性值</p> <p>可以修饰属性，也可以修饰setter方法，如果写在属性上，就不需要提供setter方法</p> </td> 
  </tr> 
  <tr> 
   <td style="width:151px;"> <p>@Autowired</p> </td> 
   <td style="width:567px;"> <p>它默认是根据类型进行注入，</p> <p>可以修饰属性，也可以修饰setter方法，如果写在属性上，就不需要提供setter方法</p> </td> 
  </tr> 
  <tr> 
   <td style="width:151px;">@Qualifier</td> 
   <td style="width:567px;">@Qualifier和@Autowired一起使用，就可以根据名称来进行注入</td> 
  </tr> 
  <tr> 
   <td style="width:151px;">@Resource</td> 
   <td style="width:567px;">可以更具名称来进行注入</td> 
  </tr> 
 </tbody> 
</table>

7）spring的容器的启动方式

说明：我们一直在谈论spring的容器如何将javabean加载到容器中，容器中的javabean如何进行参数的注入的，但是我们还没有谈论这个容器是怎么启动的，这个容器是在什么时候启动的。

容器启动的方式有两种：一种是代码实现的方式帮我们启动容器（测试时候用）；还有一种就是通过web来帮我们启动容器（推荐）

**代码启动的方式**（测试使用）

思路：其中就是用代码来进行启动的时候加载ApplicationContext，其中要导入spring的test模块

/**
    @RunWith:spring整合junit4
    @ContextConfiguration:指spring配置文件位置
    **/
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = "classpath:applicationContext.xml")
    public class AnnotationTest {
    
    	@Autowired
    	private IUserService userService;
    
    	// 测试@Component
    	@Test
    	public void test1() {
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		IUserService userService = (IUserService) context.getBean("userService");
    		userService.add();
    	}
    
    	@Test
    	public void test2() {
    		userService.add();
    	}
    }

**web启动方式**（推荐使用）

思路：在javaweb中其中web.xml中有三个重要的组件：listener、filter、servlet，其中执行的顺序是**context-param -> listener -> filter -> servlet，**所以在web工程启动的时候我们配置listener来进行加载spring容器。ContextLoaderListener它实现了ServletContextListener，在这个listener中，当服务器启动时，将ApplicationContext对象，其实是它的一个实现类WebApplicationContext,对象存入到了ServletContext中。

<context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

注意：其中context-param是全局的常量，其中用来指明spring的配置文件，其中如果不指定，其默认的路径为WEB-INF目录下查找applicationContext.xml，其中名称都不能改变，改变之后需要配置context-param来进行指定。

三、spirng的AOP模块

1）AOP的简介

AOP（Aspect Oriented Programming），意为[面向切面编程][Link 1]，通过[预编译][Link 2]方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是[OOP][]的延续，是软件开发中的一个热点，也是[Spring][]框架中的一个重要内容，是[函数式编程][Link 3]的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的[耦合度][Link 4]降低，提高程序的可重用性，同时提高了开发的效率。AOP是一个概念，并没有设定具体语言的实现，它能克服那些只有单继承特性语言的缺点，spring2.0之后整合AspectJ第三方AOP技术 。就是能够对类进行功能的加强，AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的[编译器][Link 5]用来生成遵守Java字节编码规范的Class文件。

<table> 
 <tbody> 
  <tr> 
   <td> <p style="margin-left:0cm;"><span style="color:#ff0000;">编程语言的发展：</span></p> <p style="margin-left:0cm;"><span style="color:#ff0000;">&nbsp; &nbsp; &nbsp; &nbsp;汇编语言（用助记忆的方式来替代一些机械语言，可以直接对底层进行操作）</span></p> <p style="margin-left:0cm;"><span style="color:#ff0000;">&nbsp; &nbsp; &nbsp; &nbsp;面型过程语言（</span><span style="color:#ff0000;">c</span><span style="color:#ff0000;">）</span></p> <p style="margin-left:0cm;"><span style="color:#ff0000;">&nbsp; &nbsp; &nbsp; &nbsp;函数式编程（）</span></p> <p style="margin-left:0cm;"><span style="color:#ff0000;">&nbsp; &nbsp; &nbsp; &nbsp;面型对象编程：基于原型的面向对象（javascript），基于类的面型对象（</span><span style="color:#ff0000;">c++,c#,java</span><span style="color:#ff0000;">等）</span></p> </td> 
  </tr> 
 </tbody> 
</table>

2）AOP的应用场景

AOP是一种在原来本来执行的流程上，将其流程先隔断，执行我们插入的部分，之后在回到原来的流程上去的过程，所以AOP常用在日志记录，性能统计，安全控制，事务处理，[异常处理][Link 6]等等，将日志记录，性能统计，安全控制，事务处理，[异常处理][Link 6]等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

3）AOP常用的一些术语

**目标对象target**：指的是需要被增强的对象，由于spring aop是通过代理模式实现，从而这个对象永远是被代理对象。

**连接点(join point)**：所谓连接点是指那些被拦截到的点，在spring中这些点指的是方法，因为spring只支持方法类型的连接点

**切入点(pointcut)**：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、[正则表达式][Link 7]等方式集中起来，它定义了相应的 Advice 将要发生的地方。简单说切入点是指我们要对哪些连接点进行拦截的定义

**通知(advice)**：所谓通知是指拦截到连接点之后所要做的事情就是通知，通知分为**前置通知**，**后置通知**，**异常通知**，**最终通知**，**环绕通知**。Advice 定义了在 pointcut 里面定义的程序点具体要做的操作

**引介introduction**：引介是一种特殊的通知，在不修改类代码的前提下，introduction可以**在运行期为类动态地添加一些方法或属性**

**切面aspect**：是**切入点和通知**的结合

**织入weaving**：织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在**编译期**，**类装载期**，**运行期进行**。Spring采用动态织入，而aspectj采用静态织入

<table> 
 <tbody> 
  <tr> 
   <td> <p style="margin-left:0cm;">AOP分为<strong>静态AOP</strong>和<strong>动态AOP</strong></p> <p style="margin-left:0cm;">静态AOP：是指AspectJ实现的AOP，他是将切面代码直接编译到Java类文件中。</p> <p style="margin-left:0cm;">动态AOP：是指将切面代码进行动态织入实现的AOP。Spring的AOP为动态AOP，实现的技术为：&nbsp;JDK提供的动态代理术和CGLIB(动态字节码增强技术)&nbsp;</p> <p style="margin-left:0cm;">&nbsp; &nbsp; &nbsp; &nbsp;&nbsp;JDK动态代理：在运行 ，在JVM内部动态生成class字节码对象(Class对象)，<span style="color:#FF0000;">Jdk动态代理只针对于接口操作</span></p> </td> 
  </tr> 
 </tbody> 
</table>

**代理Proxy**：一个类被AOP织入增强后，就产生一个结果代理类

4）AOP的原理

5）AOP的实例

四、spring的总结

1）spring的重要思想就是三大块：test模块、IOC和DI模块、AOP模块，其中这个是三大基本模块，而其中web、dao等模块都是这些基础模块在不同的层上进行的应用。

在web上的应用，参看其中是如何用spring容器来管理spring mvc或struts2的重要类：

在dao层上的应用，也是通过spring容器来管理hibernate和mybatis的主要类：

在message的应用，

[70]: /images/20220527/1a95d9dc60be4246812b01b2eafd5377.png
[Link 1]: http://baike.baidu.com/view/1865230.htm
[Link 2]: http://baike.baidu.com/view/176610.htm
[OOP]: http://baike.baidu.com/view/63596.htm
[Spring]: http://baike.baidu.com/view/23023.htm
[Link 3]: http://baike.baidu.com/view/1711147.htm
[Link 4]: http://baike.baidu.com/view/1599212.htm
[Link 5]: http://baike.baidu.com/view/487018.htm
[Link 6]: http://baike.baidu.com/view/1072586.htm
[Link 7]: http://baike.baidu.com/view/94238.htm