Spring入门及Ioc简介

最新推荐文章于 2024-07-18 09:20:47 发布

Bruce_Up

最新推荐文章于 2024-07-18 09:20:47 发布

阅读量596

点赞数

分类专栏：后端框架 Spring 文章标签： Spring入门框架

本文链接：https://blog.csdn.net/Bruce_Up/article/details/82666359

版权

后端框架同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

Spring

3 篇文章 0 订阅

订阅专栏

相互学习，欢迎指正，共同进步。

一、Spring概念：

Spring 是一个轻量级的Java开源框架，是为了解决企业应用开发的复杂性而创建的。
Spring 是容器框架，创建bean（相当于一个对象），维护bean之间的关系。实现了程序的解耦合和面向切面(AOP)的容器框架
Spring也是一种集成性框架，可以和其他框架进行整合，从而实现多个框架的协同开发。常见的有(SSH、SSM)。

这里简单打个比方，介绍Spring框架的重要地位

struts2是web框架相对于销售经理，hibernate是orm框架相当于仓库经理，它们两个都是非常优秀的框架，但是相互之间谁都不服谁，而Spring就相当于CEO,可以很好的管理它们，这样好了大家都能一起愉快的协同合作了。

二、Spring的优点：

方便解耦，简化开发（高内聚低耦合）
Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理
spring工厂是用于生成bean
AOP编程的支持
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持
只需要通过配置就可以完成对事务的管理，而无需手动编程
方便程序的测试
Spring对Junit4支持，可以通过注解方便的测试Spring程序
方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
降低JavaEE API的使用难度
Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

三、Spring框架结构：

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式。

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

四、Spring核心思想IOC(控制反转)：

1）IOC思想：

IOC是控制反转的简称，目的是为了“解耦合”。核心思想是把对象的创建、赋值和对象间的依赖关系控制权都放在IOC容器中，并在Ioc容器中进行对象之间依赖关系的绑定，因此Spring中Ioc又可以具体称为“依赖注入（DI）”。

IOC控制反转是一种思想，DI是Spring实现IOC的一种实现技术

2）理解对象之间的依赖关系及Ioc思想：

控制反转IoC是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方

解释一：

我们以往会使用new来创建对象，并通过setter方法设置对象与对象之间的依赖关系，new object() 这样的语法来将对象创建出来，这个对象是由自己主动创建出来的，创建对象的主动权在自己手上，自己需要哪个对象，就主动去创建，创建对象的主动权和创建时机是由自己把控的，而这样就会使得对象间的耦合度高了，A对象需要使用对象B来共同完成一件事，A要使用B，那么A就对B产生了依赖，也就是A和B之间存在一种耦合关系，并且是紧密耦合在一起。

例如有一个学生对象student和一个老师对象teacher，可以通过student.setTeacher(teacher)绑定学生和老师之间的关系。但这样学生对象就会依赖于老师对象。

而使用了Spring之后就不一样了，创建对象B的工作是由Spring来做的，Spring创建好B对象，然后存储到一个容器里面，当A对象需要使用B对象时，Spring就从存放对象的那个容器里面取出A要使用的那个B对象，然后交给A对象使用，至于Spring是如何创建那个对象，以及什么时候创建好对象的，A对象不需要关心这些细节问题

没懂没关系继续看解释二！

解释二：

我们在开发的时候通常的方法调用流程为Servlet 调用 Service里的方法,Service方法调用DAO里的方法，这就要求我们必须要在Service里new一个DAO对象。

存在的问题：

（1）Service需要对DAO对象进行维护，负责这个DAO对象的整个生命周期

（2）层与层之间的依赖问题，也就是Service依赖于DAO，只有DAO开发完成才能进行Service的开发，一旦DAO里改变比如方法名改变，那么Service也必须修改。

（3）多个这样的情况存在，创建的对象到处分散，给后期维护造成很大困难。

Spring如何去除依赖：

在类里添加一个DAO接口的属性，提供getter setter 方法，这里体现了多态及表明了Spring是强制面向接口编程的。这样做Service就不用具体new一个DAO对象，不会依赖于具体的DAO实现类。然后接下来其他的一切都交给Spring吧！

什么？还没懂？？那就看解释三吧！！！！

解释三：

举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、电话号………，想办法认识她们，投其所好送其所要……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。

　　那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。

对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

3）DI(依赖注入)

　　IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。

比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。

那么DI是如何实现的呢？

Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

4）对象与类之间的耦合关系，经历了以下三种方式

通过new创建
通过工厂模式获取不同的实例工厂（需要自己写工厂，但是对象依旧依赖于工厂，并且中间又多了一道工序）
通过Ioc容器获取不同的实例对象（只需要自己配置）

五、Spring实现IOC简单例子：（打印机使用不同的墨水和纸张进行打印）

1）导入jar文件：（spring一般需要导入5个jar文件）

我这里用的maven项目，pom.xml里配置一个即可其他依赖的jar自动导入

 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.1.6.RELEASE</version>
    </dependency>

2）定义类和接口（Spring采用的是面向接口编程）

墨水接口：

package org.lanqiao.printer;

public interface Ink {
	public String getColor();//获取墨水的类型
}

纸张接口：

package org.lanqiao.printer;

public interface Paper {
	public String getSize();//获取纸张类型
}

黑白印实现类：

package org.lanqiao.printer;

public class BlackInk implements Ink{

	@Override
	public String getColor() {
		return "黑白";
	}

}

彩印实现类：

package org.lanqiao.printer;

public class ColorInk implements Ink{

	@Override
	public String getColor() {
		return "彩色";
	}

}

A4纸张实现类：

package org.lanqiao.printer;

public class A4Paper implements Paper{

	@Override
	public String getSize() {
		return "A4";
	}

}

B5纸张实现类：

package org.lanqiao.printer;

public class B5Paper implements Paper{

	@Override
	public String getSize() {
		return "B5";
	}

}

打印机类：（打印机依赖于纸张和墨水）

package org.lanqiao.printer;

public class Printer {

	private Paper paper;// 使用纸张
	private Ink ink;	//使用墨水


	public void print(String str) {
		System.out.println("打印机正在使用" + ink.getColor() + "墨盒，" + paper.getSize() + "纸打印。。。");
		System.out.println("------------------------------------------------");
		System.out.println(str);

	}

	public Paper getPaper() {
		return paper;
	}

	public void setPaper(Paper paper) {
		this.paper = paper;
	}

	public Ink getInk() {
		return ink;
	}

	public void setInk(Ink ink) {
		this.ink = ink;
	}

}

3）spring配置文件配置bean(一个bean相当于一个对象)

<?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.xsd">
	
	<bean id="a4" class="org.lanqiao.printer.A4Paper"/><!--A4Paper a4 = new A4Paper();//多态！！-->
	<bean id="b5" class="org.lanqiao.printer.B5Paper"/>
	<bean id="b" class="org.lanqiao.printer.BlackInk"/>
	<bean id="c" class="org.lanqiao.printer.ColorInk"/>
	<bean id="printer" class="org.lanqiao.printer.Printer" >
		<property name="ink" ref="b"/>
		<property name="paper" ref="a4"/>
	</bean>
	<bean id="printer1" class="org.lanqiao.printer.Printer" >
		<property name="ink" ref="c"/>
		<property name="paper" ref="b5"/>
	</bean>
</beans>

说明：

id : 唯一标识符，用来代表唯一的bean
class: 对象的类型（包名+类名）
property: 对象的一个属性
property 中的name：属性名
property 中的value ：用于给“简单属性”赋值
property 中的ref: 用于给复杂属性赋值（自定义类型的对象）

4）测试

package org.lanqiao.printer;


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

public class Person {
	public static void main(String[] args) {
		//创建Spring的Ioc容器对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//从Ioc容器获取Bean的实例(id为printer的Printer对象)
		Printer  p = context.getBean("printer",Printer.class);
		Printer  p1 = context.getBean("printer1",Printer.class);
		p.print("hello!!!");
		p1.print("Hello Again");
	}
}

打印结果：