Spring框架课堂笔记(1)

最新推荐文章于 2022-03-13 10:41:59 发布

MrDAW

最新推荐文章于 2022-03-13 10:41:59 发布

阅读量122

点赞数

文章标签： java spring ioc

本文链接：https://blog.csdn.net/MrDAW/article/details/119428992

版权

学习打卡专栏收录该内容

24 篇文章 0 订阅

订阅专栏

Spring框架课堂笔记（1）

1、Spring核心之IoC控制反转

1.1 IoC的概念

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。

IoC 是指在程序开发中，实例的创建不再由调用者管理，而是由 Spring 容器创建。Spring 容器会负责控制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转移到了 Spring 容器中，控制权发生了反转，这就是 Spring 的 IoC 思想。

1.2 Spring入门案例

1.2.1 创建maven项目

创建完毕的目录结构

在这里插入图片描述

1.2.2 pom.xml文件添加依赖和插件

<dependencies>
		<!--单元测试-->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
		<!--spring依赖-->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.2.13.RELEASE</version>
		</dependency>
</dependencies>
<build>
	<plugins>
		<!--编译插件-->
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.8.0</version>
			<configuration>
				<source>1.8</source>
				<target>1.8</target>
			</configuration>
		</plugin>
	</plugins>
</build>

1.2.3 创建一个实体类

package com.kkb.pojo;
/**
* 实体类球队
*/
public class Team {
	private Integer id;
	private String name;
	private String location;
	public Team() {
		System.out.println("Team的默认构造方法被调用：id="+id+",name="+name+",
location="+location);
	}
}

1.2.4 创建Spring的配置文件application.xml

在这里插入图片描述

1.2.5 使用Spring容器创建对象

配置文件中创建对象

<?xml version="1.0" encoding="UTF-8"?>
<!--spring的配置文件
	1、beans: 根标签，spring中java的对象成为bean
	2、spring-beans.xsd 是约束文件（约束XML文件中能编写哪些标签）-->
<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,通知spring要创建哪个类的对象
		一个bean标签声明一个对象：
		id="自定义的对象名称" ,要求唯一
		class="类的完全限定名" 包名+类名，spring底层是反射机制创建对象，所以必须使用类
名
		相当于 Team team1=new Team();创建好的对象放入一个集合Map中
		例如：springMap.put("team1",new Team());
-->
<bean id="team1" class="com.daw.pojo.Team"></bean>
</beans>

1.2.6 获取Spring容器

Spring 提供了两种 IoC 容器，分别为 BeanFactory 和 ApplicationContext.

1.2.6.1 BeanFactory

BeanFactory 是基础类型的 IoC 容器,是一个管理 Bean 的工厂，它主要负责初始化各种 Bean，并调用它们的生命周期方法。

BeanFactory 接口有多个实现类，最常见的是

org.Springframework.beans.factory.xml.XmlBeanFactory，它是根据 XML 配置文件中的定义装配 Bean 的。

BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource(Spring配置文件
的名称));

1.2.6.2 ApplicationContext

ApplicationContext 是 BeanFactory 的子接口，也被称为应用上下文。它不仅提供了 BeanFactory 的所有功能，还添加了对 i18n（国际化）、资源访问、事件传播等方面的良好支持。

ApplicationContext 接口有两个常用的实现类:

1.2.6.2.1 ClassPathXmlApplicationContext——常用

该类从类路径 ClassPath 中寻找指定的 XML 配置文件，找到并装载完成 ApplicationContext 的实例化工作

ApplicationContext applicationContext=new ClassPathXmlApplicationContext(Spring配
置文件的名称);

1.2.6.2.2 FileSystemXmlApplicationContext

ApplicationContext applicationContext = new
FileSystemXmlApplicationContext(String configLocation);

它与 ClassPathXmlApplicationContext 的区别是：在读取 Spring 的配置文件时，FileSystemXmlApplicationContext 不再从类路径中读取配置文件，而是通过参数指定配置文件的位置，它可以获取类路径之外的资源，如“D:\application.xml”。

1.2.7 通过上下文对象获取容器中的对象

package com.kkb.test;
import com.kkb.pojo.Team;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.FileSystemResource;
import java.util.Date;
public class Test1 {
	@Test
	public void test01(){
		//使用spring容器创建对象
		//1、指定spring配置文件的名称
		String springConfig="application.xml";
		//2、创建spring容器的对象：
		//方式1:不推荐，了解
		//BeanFactory beanFactory = new XmlBeanFactory(new
FileSystemResource("D:/workspaces/ideaProjects/MySpring/spring01/src/main/resour
ces/application.xml"));
		//beanFactory.getBean("team1");//根据ID从IOC容器获取对象
		//方式2：applicationContext--常用
		ApplicationContext applicationContext=new
ClassPathXmlApplicationContext(springConfig);//这里执行完毕容器中的对象都已经创建完成
		//方式3：applicationContext--了解
		//ApplicationContext applicationContext2 = new
FileSystemXmlApplicationContext("D:/workspaces/ideaProjects/MySpring/spring01/sr
c/main/resources/application.xml");
		//3、获取容器中的对象
		Team team1= (Team) applicationContext.getBean("team1");
		//4、容器其他api
		int beanDefinitionCount = applicationContext.getBeanDefinitionCount();
		System.out.println("spring容器中对象的个数："+beanDefinitionCount);
		String[] beanDefinitionNames =
applicationContext.getBeanDefinitionNames();
		System.out.println("spring容器中所有对象的名称：");
		for (String name : beanDefinitionNames) {
		System.out.println(name);
		}
	}
}

1.2.8 创建非自定义对象

pox.xml文件中补充
<!--创建非自定义的对象-->
	<bean id="date" class="java.util.Date"></bean>

//上面的测试方法中添加如下内容：
//5、获取日期对象
Date date1= (Date) applicationContext.getBean("date1");
System.out.println("日期："+date1);

1.2.9 bean标签的属性

在这里插入图片描述

示例演示：

Team实体类补充如下方法：

public void init(){
		System.out.println("Team ---- init()");
}
public void destroy(){
		System.out.println("Team ---- destroy()");
}

application.xml配置文件添加如下内容：

<!--
	bean标签的属性:
	id="自定义的对象名称" ,要求唯一
	name="bean对于的一个标识“，一般使用id居多
	class="类的完全限定名"
	scope="singleton/prototype" 单例/多例
		singleton：默认值，单例：在容器启动的时候就已经创建了对象，而且整个容器只有为一个
的一个对象
		prototype：多例，在使用对象的时候才创建对象，每次使用都创建新的对象
	lazy-init="true/false" 是否延迟创建对象，只针对单例有效
		true:不延迟创建对象，容器加载的时候立即创建
		false:默认加载，使用对象的时候才去创建对象
	init-method="创建对象之后执行的初始化方法"
	destroy-method="对象销毁方法，调用容器destroy方法的时候执行"
-->
	<bean id="team2" class="com.kkb.pojo.Team" scope="singleton" lazyinit="true" init-method="init" destroy-method="destroy"/>
	<bean id="team3" class="com.kkb.pojo.Team" scope="prototype" />

@Test
public void test02(){
	String springConfig="application.xml";
	ClassPathXmlApplicationContext applicationContext=new
ClassPathXmlApplicationContext(springConfig);
	Team team1 = (Team) applicationContext.getBean("team1");
	Team team11 = (Team) applicationContext.getBean("team1");
	System.out.println(team1);
	System.out.println(team11);
	Team team2 = (Team) applicationContext.getBean("team2");
	Team team22 = (Team) applicationContext.getBean("team2");
	System.out.println(team2);
	System.out.println(team22);
	applicationContext.close();//关闭容器
}

eam1);
System.out.println(team11);
Team team2 = (Team) applicationContext.getBean(“team2”);
Team team22 = (Team) applicationContext.getBean(“team2”);
System.out.println(team2);
System.out.println(team22);
applicationContext.close();//关闭容器
}

MrDAW

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring框架课堂笔记(1)

Spring框架课堂笔记（1）1、Spring核心之IoC控制反转1.1 IoC的概念Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。IoC 是指在程序开发中，实例的创建不再由调用者管理，而是由 Spring 容器创建。Spring 容器会负责控制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转移到了 Spring 容器中，控制权发生了反转，这就是 Spring 的 IoC 思想。1.2 Spring入门案例1.2.1 创建
复制链接

扫一扫