初始Spring 详解

缺乏、安全感 2022-12-02 04:16 71阅读 0赞

# 初始Spring `绿叶子` #

**Spring框架：** `轻量级框架, Java EE的春天,当前主流框架, Spring中：春天`

*  Spring框架 致力于JavaEE 应用的各种 解决方案, 而不是仅仅专注于某一层的方案, 可以说Spring 是`企业级应用开发`的 `"一站式"`
 *  （俗称一条龙服务）Spring针对不同的业务需求,都有不同的解决方案;
 *  Spring 贯穿：**表现层 业务层 持久层** 然而，并不是要取代这些已有的框架，而是以高度的开放性与它们无缝整合;  
    **企业级应用开发：**  
    **`企业级应用`**：指为 商业组织 大型企业而创建部署的; **解决方案/应用**  
    当前的企业级应用绝不可能是一个个 **独立系统** , 一般都会部署多个进行交互的应用; 同时这些应用又都可能会与, 其它企业相关应用 `连接`.  
    // 构成一个 **结构复杂** 跨越 Internet 的`分布式企业应用 集群；`  
    传统Java EE 解决企业级应用 使用 EJB：**重量级,架构系统** 而它：开发效率 , 开发难度 和 实际性能都令人失望. 所以后面出现了 **Spring**`“救世主”` 形式出现在了 Java程序员面前;  
    **EJB**
 *  EJB是的Enterprise Java Beans技术的简称, 又被称为`企业Java Beans`。基于分布式事务处理的企业级应用程序的组件
 *  但因为：**学习比较难，开发难度大，依赖应用服务器，运用大量的设计模式** 而被 淘汰;

**内容**：`IoC容器 , AOP实现 , 数据访问支持 , 简化 JDBC/ORM 框架 , 声明式事务 , Web集成...`  
**Spring 体系结构：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center]  
**Spring一共有十几个组件:**

*  Spring框架的核心组件只有三个：Core、Context和Beans。  
    他们构建起了整个Spring的骨骼架构，没有他们就不可能有AOP、Web等上层的特性功能。
 *  AOP包(主要提供面向切面编程的实现)
 *  Web(主要提供了Web应用开发的支持及针对Web应用的MVC思想实现)
 *  ORM（为我们之前学的Hibernate，以及以后会学到的Mybatis这类持久化框架提供支持）
 *  还有Spring MVC（这个是它自带的一个web视图层，可以替代到Sturts2，将来我们还会详细的学习这个SpringMVC框架）…等等

**Spring设计理念：**  
Spring三个核心组件（Core、Context、Beans）。如果再再他们三个中选一个核心来，那就非Beans莫属了。  
Spring是面向`Bean(Java类)`的编程:`（BOP，Bean Oriented Programming）`  
Bean在Spring 中作用就像Object`(对象)`对OOP`(面向对象)`的意义一样，没有对象的概念就没有面向对象编程，Spring中没有Bean也就没有Spring存在意义。`就像一次演出舞台都准备好了但是却没有演员一样。`  
Spring解决了一个非常关键的问题，他可以让你把对象之间的关系转而使用配置文件来管理，也就是他的依赖注入机制，而这个注入关系在一个叫`Ioc`的容器中管理。Spring正是通过把对象包装在Bean中从而达到对这些对象管理以及一系列额外操作的目的。  
**那它是怎么管理这些Bean的呢？**  
Spring把所有的Bean及它们之间的依赖关系以配置文件的方式组装起来，在一个叫IoC（Inversion of Control）的容器中进行管理，这也就是Spring的核心设计思想之一依赖注入机制，Spring的另一个核心设计思想叫做AOP ;

**优点**

*  低侵入式设计：非入侵式设计，基于Spring开发的应用一般不依赖于Spring的类
 *  Spring的依赖注入特性使Bean与Bean之间的依赖关系变的完全透明，可以统一管理和生成Bean，降低了耦合度：使用SpringIOC容器，将对象之间的依赖关系交给Spring，降低组件之间的耦合性，让我们更专注于应用逻辑
 *  它的面向切面编程`aop` 特性允许将一些通用任务如安全、事务、日志等进行集中式处理;
 *  独立于各种应用服务器，真正实现：一次编写，到处运行。
 *  并且它还提供了与第三方持久层框架的良好整合，并简化了底层数据库访问
 *  高度的开放性（可以和Struts2、Hibernate、MyBatis、CXF等很多主流第三方框架无缝整合）
 *  `总的来说，Spring确实是一个令每个开发人员都值得学习的开发工具。接下来，我们就一起在学习过程中体会他的魅力吧。`

# **Spring两大核心技术：** #

**控制反转** `(IoC：Inversion of Control ) /依赖注入(DI：Dependency Injection )`  
**面向切面编程** `(AOP：Aspect Oriented Programming)`

### **控制反转** ###

**概述：**

> 由传统的代码实例化操作, 转换为由 Spring容器来操作处理 Bean的实例化操作;  
> (依赖)控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。  
> 也称 **依赖注入 `Dl`** 是面向对象的一种设计理念，用来减低程序代码之间的 耦合度;

**什么是依赖：**

// 值代码中, 通过局部变量, 方法参数, 返回值等.. 建立于对其它对象的调用关系; 
    // 例如在：A类方法中 实例化 B类型的对象, 并调用其方法完成某种功能.. 就可以称为： `A类依赖于B类;
    // 几乎所有应用程序,都是由两个及以上的类,通过彼此合作实现完整的功能 . 类于类之间的依赖关系, 增加了程序开发的复杂程度; 我们在开发一个/修改类的时候，还需要考虑使用该类的类 的影响;
    is  是		子类继承父类 即 子类 is 父类;
    has 包含	A类依赖B类	即 A类 has B类;

--------------------

**实例demo**  
以汽车为例子：  
需要一个汽车类：`Cart.Java`

public class Cart { 
    	//这里车有两个属性：品牌 和 发动机; 因为车是依赖于发动机的所以 有一个发动机类型;
    	//这里发动机是个接口类型,以表示多种发动机可选性; 
    	public String brand;//品牌
    	public Fdj fdj;//发动机
    	//初始化
    	public void init(){ 
    		System.out.println("品牌："+this.brand);
    		//打印发动机;
    		fdj.show(); 
    	}
    	//get/set方法;
    	public String getBrand() { 
    		return brand;
    	}
    	public void setBrand(String brand) { 
    		this.brand = brand;
    	}
    	public Fdj getFdj() { 
    		return fdj;
    	}
    	public void setFdj(Fdj fdj) { 
    		this.fdj = fdj;
    	}
    }

发动机接口类：`Fdj.Java`

public interface Fdj { 
    	//打印当前发动机; 每一个继承发动机接口的 发动机子类都要实现改方法..
    	public void show();
    }

发动机接口实现类：  
`BenTianFdj.Java`本田发动机

public class BenTianFdj implements Fdj { 
    
    	@Override
    	public void show() { 
    		// TODO Auto-generated method stub
    		System.out.println("本田发动机");
    	}
    
    }

`SanLingFdj.Java` 三菱发动机

public class SanLingFdj implements Fdj { 
    	@Override
    	public void show() { 
    		System.out.println("三菱发动机");
    	}
    }

实现类：`Test.Java`

public class Test { 
    	public static void main(String[] args) { 
    		Cart c = new Cart();
    		//假设要 大众的品牌
    		c.setBrand("大众");  
    		//假设要 三菱发动机则;
    		c.setFdj(new SanLingFdj());
    		//最后结果;
    		c.init();
    	}
    }

// 还记的以前写 Servlet 和 JSP 时候吗？三层：数据层　业务逻辑层　展示层  
// 而有时候：实体类修改属性, 就要到数据层 —— 业务逻辑层 —— Service… 都要改;  
// 就像现在这样： Test是展示层 Cart是逻辑层…  
//发动机接口需要替换将导致 Cart —— Test发送改变; 而且现在 Test中还存在 new Cart…操作，导致程序的耦合…  
// 使程序, 程序不具备优良的\*\*可扩展性 , 可维护性 \*\* 甚至在开发中将会 , 难以测试;

**使用 `工厂模式`的方法解决此问题**  
// 加一个 工厂类：`CartFactory.Java` 专门用来制作Cart类 对象;

public class CartFactory { 
    	//制作汽车方法;
    	public Cart createCart(String brand, String fdj) { 
    		Cart cart = new Cart();
    		cart.setBrand(brand);
    		if (fdj.equals("本田")) { 
    			BenTianFdj ben = new BenTianFdj();
    			cart.setFdj(ben);
    		} else if (fdj.equals("三菱")) { 
    			SanLingFdj san = new SanLingFdj();
    			cart.setFdj(san);
    		}
    		return cart;
    	}
    }

// 修改`Test.Java`

public class Test { 
    	public static void main(String[] args) { 
    		//创建 汽车工厂;
    		CartFactory cartFactory = new CartFactory();
    		//生产汽车对象;
    		Cart c = cartFactory.createCart("大众","三菱");
    		//输出;
    		c.init(); 
    	}
    }

// 这里 `CartFactory` 工厂类就是 **“控制反转”** 的思想; Test类中不在出现 new Cart(); 的操作;  
// 而是交给了 **第三方** 工厂来完成此操作; 在如何获取 所依赖的 Cart 对象的方式上, `控制权` 发生了变化 `反转`  
// 从原来的直接 new Cart(); 到 CartFactory 工厂 .cartFactory(); 这就是 **控制反转** 降低了 耦合,但还是有 new Cart(); 操作并不是真正的解决 耦合;  
// 大量的`工厂` 引入开发过程中,会导致 工作量增加…  
// Spring 解决了这个问题, 提供了完整的 IOC 实现`控制反转` , 使开发可以专注于 业务类等操作;

### **使用Spring 修改：** ###

**配置Spring**

--------------------

**官网上下载:** 所需要的Spring资源，Spring Framework  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 1]  
`对于一些开发工具其实都已经集成了:开发环境(MyElicpse) ：`  
`在web项目上 ——右击项目——选择MyElicpse项——project facets [capabilities] 项—— 在选择：Install Spring Facet 一个小绿叶标志哦~选中即可！`

> 自动导入对应的 Jar 包  
> Src下产生对应的 applicationContext.xml ：(Spring 的配置文件，进行依赖注入DI)  
> 可以在Src 下专门建一个Source FoIderle文件 resources 名 资源目录; 所有的资源文件都可以放在这儿; Myelicpse 中就相当于就是在Src 下的一样, 不会有任何影响;

**需要Jar**  
`Spring运行依赖：`commons-logging-1.1.1.jar  
`为了方便观察,Bean实例化,采用 lo4j 输出查看`log4j-1.2.17.jar 需要对应的 log4j.properties

**Spring 的配置文件** `applicationContext.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" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
    	
    	
    		
    	
    	<bean id="BT" class="com.wsm.spring.BenTianFdj" ></bean> 
    	<bean id="SL" class="com.wsm.spring.SanLingFdj" ></bean> 
    	
    	<bean id="cart" class="com.wsm.spring.Cart" >
    		<property name="brand" value="大众" />	 
    		<property name="fdj" ref="BT" />  
    			
    	</bean>
    	
    	
    </beans>

`Test.Java`

package com.wsm.spring;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Test { 
    	public static void main(String[] args) { 
    		//通过 ClassPathXmlApplicationContext 实例化 Spring 上下文;
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		//通过 ApplicationContext 的getBean("Bean的Id"); 获取对应的Bean 的实例,返回Object类型;
    		Cart c = (Cart)context.getBean("cart"); //强转为 Cart类型对象;
    		//调用方法;
    		c.init();
    	}
    	/* * ApplicationContext 是一个接口,负责读取Spring 配置文件; * 管理对象加载,维护Bean对象与Bean对象之间的依赖关系; 负责Bean的生命周期; * ClassPathXmlApplicationContext 是 ApplicationContext 的实现类: * 从 classpath路径读取Spring配置文件; * */
    	 
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 2]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 3][]

### **面向切面编程** `(AOP：Aspect Oriented Programming)` ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 4]

> 上图：这个代码非常熟悉把，就是基本的业务实现的代码;  
> 日志——异常处理——事务控制 都是一个健壮的业务系统所必须的。  
> 为了保证系统健壮性可用，就要在众多业务方法中反复编写类似的代码; 使原本复杂的代码更加复杂;  
> 业务功能的开发者还要关注这些 “额外” 的代码是否处理正确, 遗漏的地方; 如果修改增加新的功能,也可能会导致 业务代码的修改;  
> 对这些, 零散的代码, 穿插在业务中的代码操作就是 `"横切逻辑"` 也称为 `切面`  
> 为了不受干涉的专注于 业务的代码，将这些代码 `抽离` 出来，放在专门的 方法/类中;  
> 便于管理 维护 ,但依然无法彻底的完成 业务 和 切面逻辑 的彻底`解耦` 业务的代码中还要保留调用的 方法();代码  
> **这正是 AOP 解决的问题：**  
> `面向切面编程,简单的说就是: 在不改变原来程序基础上为,代码增加新的功能,对代码进行增强处理.`  
> `设计思想来源于 ：代理模式(看样子后面得看看设计模式了)`  
> 原理：  
> 将复杂的需求分解出不同方面，将散布在系统中的公共功能集中解决  
> 采用代理机制组装起来运行，在不改变原程序的基础上对代码段进行增强处理，增加新的功能

**AOP基本概念**

*  切面（Aspect）
    
    > 切面可以理解为：切点和增强组成切面。它包括了横切逻辑的定义，也包括了连接点的定义。
 *  切入点（Pointcut）
    
    > 对连接点. 特征进行描述; 可以使用`正则表达式` 简单的说，就是连接点的查询条件
 *  连接点（Join Point）
    
    > 程序执行过程中某个具体执行的点 ( 就是核心要执行的方法; )
 *  增强处理（Advice）
    
    > 增强处理又分为： 前置增强，后置增强，环绕增强，异常抛出增强，最终增强等类型；  
    > 是织入到目标类连接点上的一段程序代码。  
    > 增强包含了用于添加到目标连接点上的一段执行逻辑，又包含了用于定位连接点的方位信息。
 *  AOP代理（AOP proxy）
    
    > AOP框架创建的对象。一个类被AOP织入增强之后，就产生了一个结果类，它是融合了原类和增强逻辑的代理类。(代理对象)
 *  目标对象（Target object）
    
    > 增强逻辑 织入的目标类；就是被增强的类的对象;
 *  织入（Weaving）
    
    > 将增强添加到目标类具体连接点上的过程。  
    > AOP有三种织入的方式：编译期织入、类装载期织入、动态代理织入（spring采用动态代理织入）  
    > Spring AOP就是负责实施切面的框架，它将切面所定义的横切逻辑织入到切面所指定的连接点中

**总结：**  
在AOP中切面就是与业务逻辑独立，但又垂直存在于业务逻辑的代码结构中的 **`通用功能组合`**  
切面与业务逻辑相交的点就是切点；  
连接点就是把业务逻辑 离散化后的关键节点；即 核心的业务逻辑代码块方法();  
连接点属于切点，是所有切入点的子集；  
增强（Advice）就是切面在切点上要执行的功能增加的具体操作；  
将增强添加到目标类具体连接点上的过程。这个就叫\`织入

//当然空讲理论当然不是关键, 奉上代码 **-"\_"-** ：  
// 在上述代码中扩展：  
**新增一个类：`Aop.Java`**  
可以理解为: **增强处理类**, 里面存储增强代码方法();

public class Aop { 
    	private Logger log = Logger.getLogger(Aop.class);
    	
    	//前置增强 //连接点对象
    	public void beforeee(JoinPoint joinPoint){ 
    		log.info("前置,调用" + joinPoint.getTarget() + "类,下的方法是"
    				+ joinPoint.getSignature().getName() + ",方法的参数是:"
    				+ Arrays.toString(joinPoint.getArgs()));
    	}
    	//后置增强 //连接点对象,返回值
    	public void afterReting(JoinPoint joinPoint,Object result){   
    		log.info("后置,调用" + joinPoint.getTarget() + "类,下的方法是"
    				+ joinPoint.getSignature().getName() + ",方法的参数是:"
    				+ Arrays.toString(joinPoint.getArgs()) + ",方法的返回值是：" + result);
    	}
    	/* JoinPoint 连接点对象; 为了能够在增强方法中获得当前连接点的信息，以便实施相关的判断和处理， 可以在增强方法中声明一个JoinPoint类型的参数。 Spring会自动注入实现该实例。 通过该实例的getTarget( ) 方法可以得到被代理的目标对象，!!! getSignature( )方法返回被代理的目标方法， getArgs( )方法返回传递给目标方法的参数数组。 对于实现后置增强的afterReturning( )方法，还可以定义一个参数用于接收目标方法的返回值。 */
    }

**Spring 的配置文件** `applicationContext.xml`  
将增强处理和切入点结合在一起，在切入点处插入增强处理，完成"织入"  
`另外在这之前还需要导入aop需要的命名空间`  
`Myelicpse可直接在文件格式下选中——Namespaces——打勾`![在这里插入图片描述][20200831230734497.png_pic_center]

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
    	
    	
    	
    	
    	<aop:config>
    		<aop:pointcut expression="execution (public String init())" id="mypoint"/>
    		
    		<aop:aspect ref="myLogAop">  
    			
    			<aop:before method="beforeee" pointcut-ref="mypoint"/>
    			 
    			 <aop:after-returning method="afterReting" pointcut-ref="mypoint" returning="result"/> 
    		</aop:aspect>
    	
    	</aop:config>
    	
    	
    	<bean id="myLogAop" class="com.wsm.aop.Aop"></bean> 
    
    </beans>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/ec7002c41fa04deb86b3d701d780a06c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/a3b79e9b4bc7431baf04c028d2d15e31.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200830114128224.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/ff3892d630644a33a170f0eeb5ece29b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/a1e8de3549e94a66b4997a3e982b7442.png
[20200831230734497.png_pic_center]: /images/20221123/621ceadb545243b79171de429bf19d38.png