Spring核心概念

最新推荐文章于 2025-06-08 20:25:26 发布

C小陈童鞋

最新推荐文章于 2025-06-08 20:25:26 发布

阅读量1.4k

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/chenHaiJaheike/article/details/91358715

前言

Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring 框架来创建性能好、易于测试、可重用的代码。

Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson 编写的，并且于 2003 年 6 月首次在 Apache 2.0 许可下发布。

Spring 是轻量级的框架，其基础版本只有 2 MB 左右的大小。

学习框架我们必须多记，多背，多用。下一张学习高级的Ioc和AOP
下面我们学习一下Spring核心的概念：

初识Spring

Spring概述和用途：

学习一个框架，我们必然要先知道这个框架可以做什么。做过大型项目的朋友都知道，这些比较大的企业级应用结构复杂，涉及的资源众多，事务密集等等，传统Java EE解决企业级应用问题时的“重量级”架构体系，使它的开发效率、维护成本、应用性能等方面都令人失望。比如各个层级对象之间的耦合度总是达不到一个理想的状态，正是因为对象之间保持着一定程度的依赖，可能当我们需要对一个功能模块进行修改或者增加一个功能时，多个层级的代码都需要修改，甚至需要修改的代码贯穿整个架构层，这显然不是一个好的方案。Rod Johnson在2002年发表的一本书中，对Java EE技术日益臃肿、低效提出了质疑，也提出了Interface 21，这也是Spring框架的雏形。2003年2月Spring框架正式成为一个开源项目，发布于SourceForge中。

说了这么多，Spring框架到底可以帮助我们做哪些事呢？怎么说呢，它可以帮我们优化好多东西，它是一个全面的解决方案，不仅仅专注于某一层，而是贯穿表现层、业务层、持久层，可以说是“一站式”选择。作为轻量级的框架，它大大简化了Java企业级开发，提供了强大、稳定的功能。它也是一个三层架构，提供了一个集成框架，在Web层有Spring MVC，在业务层有Spring Core，在持久层有Spring ORM。Spring框架的核心就是IoC（控制反转）和AOP（面向切面编程）。

场景：

解耦，简化开发；
对程序进行监控，拦截等；
组合其他框架，百搭。

什么是Spring

Spring 是一个轻量级的 DI / IoC 和 AOP 容器的开源框架，来源于 Rod Johnson 在其著作《Expert one on one J2EE design and development》中阐述的部分理念和原型衍生而来。
Spring 提倡以“最少侵入”的方式来管理应用中的代码，这意味着我们可以随时用或不用 Spring

Spring IoC

1. IoC理解为控制反转

控制反转（Inversion of Control，IoC）也称为依赖注入（Dependency Injection，dl）是面向对象编程中的一种一种设计理念，用来程序代码之间的耦合度。

2. 什么是依赖

程序中，我们所说的依赖一般指通过局部变量、方法参数、返回值等建立的对于其他对象的调用关系。通俗的说，在A类中有一个方法，实例化了一个B类的对象，然后调用了B类对象的方法完成一个功能，那么我们就说A类依赖于B类。

面向对象的思想

根据面向对象的思想，我们考虑“什么事由谁去做”，所以几乎所有的应用都是依靠多个类之间的相互合作来实现一套完整的功能，但是类与类之间的依赖关系又增加了程序的复杂程度，我们对一个类进行修改时往往还要修改依赖于这个类的其他类。比如我们已经实现了一个功能，现在需要进行功能扩展，方法体需要多传入一个参数，那么我们要先修改这个底层方法，然后所有调用这个方法的层都需要修改，每次扩展起来都需要这样干一场，是很累的一件事。这就是为什么我们经常说“高复用，低耦合”。

3.Jar包

docs：该文件夹下存放Spring的相关文档，包括API参考文档，开发手册。
libs：该文件夹下存放Spring各个模块的jar文件，每个模块均提供三项内容，开发所需的jar文件，以-javadoc后缀表示的API和以 -sources 后缀表示的源文件。
schema：配置Spring的某些功能时需要用到的schema文件，对于已经集成了Spring的IDE环境如（Myeclipse，这些文件不需要专门导入）。

4. 经验

作为开源框架Spring提供了相关的源文件，在学习和研发的过程中，可以通过源文件，了解Spring的底层实现。这不仅有利于正确理解和运用Spring框架，也有利于开拓思路提升自身编程水平。

5. Spring的优点

低侵入式设计
独立于各种应用服务器
依赖注入特性将组件关系透明化，降低了耦合度
面向切面编程特性允许将通用任务进行集中式处理
与第三方框架的良好整合

6. 演示一个简单是示例

需求说明：

控制台输出
张嘎说：“三天不打小鬼子，手都痒痒！”
Rod说：“世界上有10种人，认识二进制的和不认识二进制的。
要求：说话人和说话内容都通过Spring实现依赖注入

（1）创建Greeting类

package com.bdqn.Servlet;

public class Greeting {
	private String person="nobady";
	private String words="nothing";
	public String getPerson() {
		return person;
	}
	public void setPerson(String person) {
		this.person = person;
	}
	public String getWords() {
		return words;
	}
	public void setWords(String words) {
		this.words = words;
	}
	public Greeting(String person, String words) {
		super();
		this.person = person;
		this.words = words;
	}
	public Greeting() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public void sayGreeting(){
		System.out.println(this.person+"说“"+words+"”");
	}
}

（2）编写XML

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
 
	 <bean id="ZhangGa" class="com.bdqn.Servlet.Greeting">
	 	<property name="person">
	 		<value>张嘎</value>
	 	</property>
	 	<property name="words">
	 		<value>三天不打小鬼子，手都痒痒</value>
	 	</property>
	 </bean>
	 <bean id="rod" class="com.bdqn.Servlet.Greeting">
	 	<property name="person">
	 		<value>words</value>
	 	</property>
	 	<property name="words">
	 		<value>世界上有10种人，认识二进制和不认识二进制的人</value>
	 	</property>
	 </bean>

 </beans>

（3）编写测试类

package com.bdqn.Test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.bdqn.Print.Printer;
import com.bdqn.Servlet.Greeting;

public class SpringTest {

	@Test
	public void sTest(){
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		Greeting ZhangGa =(Greeting) context.getBean("ZhangGa");
		Greeting rod =(Greeting) context.getBean("rod");
		ZhangGa.sayGreeting();
		rod.sayGreeting();
	}
}

（4）展示效果
在这里插入图片描述

Spring AOP

简介：

如果说 IoC 是 Spring 的核心，那么面向切面编程就是 Spring 最为重要的功能之一了，在数据库事务中切面编程被广泛使用。

1.AOP理解为面向切面编程

面向切面编程（Aspect Oriented Programming，AOP）是软件编程思想发展到一定程度的产物，是对面向对象编程的有益补充。AOP一般适用于具有横切逻辑的场合，如事务管理、访问控制、性能监控等。

2. 什么是横切逻辑

在业务系统中，总有一些散落、渗透到系统各处且不得不处理的事情，这些穿插在既定业务中的操作就是所谓的“横切逻辑”，也称为切面。比如在一个系统中，多个业务方法中都存在相同的一部分内容：日志记录、异常处理、事务控制。这些都是保证程序健壮性的必要元素，但是重复性地编写这一段类似的代码，使得原本就比较复杂的业务体变得更加复杂，因为开发者还需要关注这些日志记录是否正常，事务是否正确控制，导致一个业务方法体内真正与业务有关的代码只有那么几行，而大量的篇幅却花在了这些事情上。针对这种情况，我们很容易想到把这些固定代码封装成一个方法体，但这样依然没有实现既定业务与横切逻辑的彻底解耦，因为在在业务代码中还是要调用这些方法，我们希望的是无须我们显式编写，在需要的时候，系统能够自动调用所需要的功能，这正是AOP要解决的问题。

3. 什么是面向切面编程

面向切面编程，简单地说就是在不改变源程序的基础上为代码段增加新的功能，对代码段进行增强处理

面向切面编程，它的编程思想来源于代理模式。什么是代理模式？代理模式就是为一个对象设置一个代理对象，在进行业务调用时调用代理对象，再由代理对象进行一些增强处理后调用真正的对象。当通过调用代理对象的代理方法时，就可以在调用原对象的方法之前或者之后进行一些额外的操作。比如，一个客户想实现一个功能，这个客户是找产品经理谈，而不是直接找程序员，产品经理就可以看作是程序员的代理对象，他根据客户的需求是否合理、工期是否可观等因素，决定是否接下这个任务并交付给程序员去实现。而在这个场景中，程序员只需要关心他所需要实现的功能，而不去直接跟客户打交道，使得自己有大量的精力运用在代码实现上。在这中设计模式下，如果我们需要在实现一个功能之前做一下判断处理，那么我们可以直接在业务层中创建一个新的业务控制类，将逻辑控制代码布置到业务控制类中，再根据环境进行判断是否调用原有业务功能即可，这样我们就可以不改变原有的代码，而是在新的代理对象上动手脚。

认识切面编程后，了解一下它的基本概念

切面（Aspect）：一个模块化的横切逻辑（也称横切关注点），可能会横切多个对象。
连接点（Join Point）：程序执行中的某个具体执行点。如上例中原对象（非代理对象）的方法。
增强处理（Advice）：切面在某个特定连接点上执行的代码逻辑。
切入点（Pointcut）：对连接点的特征进行描述，可使用正则表达式，类似于Servlet的url-pattern，用于匹配连接点（方法）。增强处理与一个切入点表达式相关联，并在与这个切入点匹配的某个连接点运行。
目标对象（Target object）：被一个或多个切面增强的对象。
AOP代理（Aop proxy）：由AOP所创建的对象，实现执行增强处理方法等功能。
织入（Weaving）：将增强处理连接到应用程序中的类型或对象上的过程，叫织入。
增强处理类型：在原对象的方法连接点之前插入的增强处理叫前置增强，在其之后的叫后置增强。此外还要环绕增强、异常抛出增强、最终增强等类型。

4. 说明

切面可以理解为由增强处理和切入点组成，既包含了横切逻辑的定义，又包含了连接点的定义。面向切面编程主要关心两个问题，即在什么位置，执行什么功能。Spring AOP是负责实施切面的框架，即由Spring AOP完成织入工作。

5. 演示简单的增强处理，在执行某个方法前后做一个日志记录。

准备两个依赖包aopalliance-.jar和aspectjweaver-1.6.9.jar。（其实还需要一个spring-aop-5.0.8.RELEASE.jar，只不过这个jar包在上面下载的Spring包中有）

创建Servlet

package AOPTest;
 
public class Service {
    public int doing(){
        System.out.println("这是原对象的doing()方法");
        return 1;
    }
}

创建包含增强方法的Bean组件ServiceLogger

package AOPTest;
 
import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
 
import java.util.Arrays;
 
/**
 *  包含增强方法的JavaBean
 * */
public class ServiceLogger {
    private static final Logger log=Logger.getLogger(ServiceLogger.class);
 
    /**
     *  前置增强
     * */
    public void before(JoinPoint joinPoint){
        log.info("调用"+joinPoint.getTarget()+"的"+joinPoint.getSignature().getName()+"方法。方法入参是："+ Arrays.toString(joinPoint.getArgs()));
    }
 
    /**
     *  后置增强
     * */
    public void after(JoinPoint joinPoint,Object result){
        log.info("调用"+joinPoint.getTarget()+"的"+joinPoint.getSignature().getName()+"方法。方法返回值："+result);
    }
}

applicationContext配置文件中添加如下

<bean id="theLog" class="AOPTest.ServiceLogger"/>
    <bean id="service" class="AOPTest.Service"/>
    <aop:config>
        <aop:pointcut id="pointDemo" expression="execution(public int doing())"/>
        <aop:aspect ref="theLog">
            <aop:before method="before" pointcut-ref="pointDemo"/>
            <aop:after-returning method="after" pointcut-ref="pointDemo" returning="result"/>
        </aop:aspect>
    </aop:config>

测试类

package AOPTest;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 
 
public class ServiceTest {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        Service service=(Service) context.getBean("service");
        service.doing();
    }
}

我们没有在doing方法中调用ServiceLogger中的两个方法，也没有在测试类中调用，但是这两个方法却根据我们的要求分别在doing()方法的前后执行。这就是AOP，这就是增强处理，我们连显式地调用都不需要，系统会根据我们的要求在指定的地方（连接点）前或后执行相应的代码块。

上述代码中，在ServiceLogger类中的方法里，我们都传入了一个JoinPoint类型的参数，这是为了能够在增强方法中获取当前连接点的信息，比如方法名、目标对象名等，以便实施相关的判断和处理。这个参数Spring会自动为我们注入该实例，然后通过该实例的getTarget()方法可以得到被代理的目标对象，getSignature()方法返回被代理的目标方法，getArgs()方法返回传递给目标方法的参数数组。对于后置增强的方法体，还可以定义一个参数来接受目标方法所返回的值，进而做处理。

在上述的配置文件中，我们先引入包含增强方法的Bean组件，然后引入一个指向Service类的Bean，然后在<aop:config>元素中进行相关的配置。这些都是什么意思呢？我们首先使用<aop:pointcut>元素创建了一个切入点，此元素的expression属性中execution括号里的内容，即是一个表达式，是一个切入点指示符，可以配置需要增强处理的方法的特征，支持模糊匹配，主要有以下几种匹配方式：

1. public * methodName(Entity.User); 表示匹配任意返回值类型的

2. public void *(Entity.User); 表示匹配任意方法名

3. public void methodName(…); 表示匹配任意参数类型及个数的方法。

4. * com.service..(…); 表示匹配com.service包下所有类的所有方法。

5. * com.service….(…); 表示匹配com.service包及其子包下所有的类的所有方法。

新建了一个切入点之后，我们还要在切入点处插入增强处理，增强处理就会在切入点所匹配的方法（连接点）之前或之后执行，这个过程的专业叫法是“织入”。使用<aop:aspect>元素进行织入，此元素的ref属性引用包含增强方法的Bean，此处及为我们引入的ServiceLogger。然后在<aop:aspect>元素的子节点中插入两个元素，第一个是<aop:before>，见名知义这是前置增强标签，一般我们只写两个属性，method表示<aop:aspect>所引用的Bean中包含的方法，pointcut-ref表示此标签要关联的切入点。因为我们在后置增强方法中需要用到目标方法的返回值，所以对于后置增强我们使用<aop:after-returning>元素指定后置增强，与前置增强标签的用法一样，只不过我们需要多指定一个returning，值为result即可，注意"result"可不是一个字符串，它的真实值是目标方法的返回值。