Spring简单介绍——以及IOC容器和Bean配置

最新推荐文章于 2024-09-29 20:00:00 发布
最新推荐文章于 2024-09-29 20:00:00 发布
阅读量158 收藏
点赞数
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45394128/article/details/100142229
版权

Spring简单介绍

——以及IOC容器和Bean的配置

Spring简介

Spring是一个开源的框架，也是一个IOC和AOP容器框架。

Sprin特点

①非侵入式：基于Spring开发的应用中的对象可以不依赖与Spring的API。

②依赖注入：DI—Dependency Injection,反转控制（IOC）最经典的实现。

③面向切面编程：Aspect Oriented Programming——AOP。

④容器：Spring是一个容器，因为它包含并且管理应用对象的声明周期。

⑤组件化：Spring实现了使用简单组件配置组合成一个复杂的应用，在Spring中可以使用XML和Java注解组合这些对象。

⑥一站式：在IOC和AOP的基础上可以整合各种企业应用开源框架和优秀的第三方类库。

Spring模块

在这里插入图片描述

搭建Spring运行时环境

  1. 加入JAR包（五个jar必须先导入）

① Spring自身JAR包：spring-framework-4.0.0.RELEASE\libs目录下

  • spring-beans-4.0.0.RELEASE.jar
  • spring-context-4.0.0.RELE2ASE.jar
  • spring-core-4.0.0.RELEASE.jar
  • spring-expression-4.0.0.RELEASE.jar

② commons-logging-1.1.1.jar

  1. 在Spring Tool Suite工具中通过如下步骤创建Spring的配置文件

​ ① File->New->Spring Bean Configuration File

​ ② 为文件取名字 例如：applicationContext.xml

IOC容器

IOC(Inversion of Control)：反转控制，IOC容器在最底层实质上就是一个对象工厂。

反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源的方式即可，极大的降低了学习成本，提高了开发的效率。这种行为也称为查找的被动形式。

DI(Dependency Injection)：依赖注入

IOC 就是一种反转控制的思想， 而DI是对IOC的一种具体实现。

IOC容器在Spring中的实现

1）在通过IOC容器读取Bean的’实例之前，需要先将IOC容器本身实例化。

2）Spring提供了IOC容器的两种实现方式

① BeanFactory：IOC容器的基本实现，是Spring内部的基础设施，是面向Spring本身的，不是提供给开发人员使用的。

② ApplicationContext：BeanFactory的子接口，提供了更多高级特性。面向Spring的使用者，几乎所有场合都使用ApplicationContext而不是底层的BeanFactory。

ApplicationContext的主要实现类

  1. ClassPathXmlApplicationContext：对应类路径下的XML格式的配置文件

  2. FileSystemXmlApplicationContext：对应文件系统中的XML格式的配置文件

  3. 在初始化时就创建单例的bean，也可以通过配置的方式指定创建的Bean是多实例的。

bean的属性赋值

（1）依赖注入的方式

A.通过bean的setXxx()方法赋值（最常用）

创建一个Employee类

package bean;

public class Employee {
	private Integer id;
	private String name;
	private String desc;
	public Employee(Integer id, String name, String desc) {
		super();
		this.id = id;
		this.name = name;
		this.desc = desc;
	}
	public Employee() {
		super();
		System.out.println("无参构造器被调用了");
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		System.out.println("setId");
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		System.out.println("setName");
		this.name = name;
	}
	public String getDesc() {
		return desc;
	}
	public void setDesc(String desc) {
		System.out.println("setDesc");
		this.desc = desc;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", desc=" + desc + "]";
	}
	
}

创建配置文件XML

<bean id="employee01" class="bean.Employee">
    <!--name="xxx"中的xxx不是随便设置的，就是将bean.Employee中setXxx()方法名都变为小写，比如xxx，value的值是自己设置的，类似于构造器初始化设置的值。-->
		<property name="id" value="1001" ></property> 
		<property name="name" value="张三" ></property>
		<property name="desc" value="好人1" ></property>
</bean>

创建测试类

package test;

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

import bean.Employee;

public class Test01 {
	public static void main(String[] args) {
    /*创建Spring容器对象,在创建容器对象的时候，会读取spring的配置文件，从配置文件中，可以知道, 当前容器管理了那些对象的创建，同时会将容器所管理的对象给创建出来。*/
		ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        // 从Spring容器对象中获取员工
		Employee employee = context.getBean("employee01", Employee.class);
		System.out.println(employee);
}

执行结果：

无参构造器被调用了
setId
setName
setDesc
Employee [id=1001, name=张三, desc=好人1]
B.通过bean的构造器赋值(了解)
1) 按照构造函数中的参数名字进行匹配

Employee类中其他都不变，有参构造变为如下：

public Employee(Integer id, String name, String desc) {
		super();
		System.out.println("有参构造被调用了");
		this.id = id;
		this.name = name;
		this.desc = desc;
	}

配置文件XML改为如下：

<bean id="employee02" class="bean.Employee">
		<constructor-arg name="id" value="1002"></constructor-arg>
		<constructor-arg name="name" value="李四"></constructor-arg>
		<constructor-arg name="desc" value="好人2"></constructor-arg>
</bean>

执行结果：

有参构造被调用了//此时不调用set()方法
Employee [id=1002, name=李四, desc=好人2]
2) 通过索引值指定参数位置

Employee类不变，只是改变一下配置文件：

<bean id="employee03" class="bean.Employee">
		<constructor-arg index="0" value="1003"></constructor-arg>
		<constructor-arg index="1" value="王五"></constructor-arg>
		<constructor-arg index="2" value="好人3"></constructor-arg>
</bean>

执行结果：

有参构造被调用了
Employee [id=1003, name=王五, desc=好人3]
3) Spring自动匹配合适的构造器

自动匹配合适的构造器，要求传递的参数类型必须和构造函数形参类型一致！

Employee类不变，只是改变一下配置文件：

<bean id="employee04" class="bean.Employee">
		<constructor-arg  value="1004"></constructor-arg>
		<constructor-arg  value="钱六"></constructor-arg>
		<constructor-arg  value="好人4"></constructor-arg>
</bean>

执行结果：

有参构造被调用了
Employee [id=1004, name=钱六, desc=好人4]
4) 通过类型区分重载的构造器

在Employee类中添加Double类型的salary属性,其他属性不改变，并提供get/set方法，和toString方法，提供新的构造函数，这个构造函数不需要desc。

package bean;

public class Employee {
	private Integer id;
	private String name;
	private String desc;
	private Double salary;
	
	public Employee(Integer id, String name, String desc) {
		super();
		this.id = id;
		this.name = name;
		this.desc = desc;
	}
	
	public Employee(Integer id, String name, Double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	
	public Employee() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getDesc() {
		return desc;
	}
	public void setDesc(String desc) {
		this.desc = desc;
	}
	public Double getSalary() {
		return salary;
	}
	public void setSalary(Double salary) {
		this.salary = salary;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", desc=" + desc + ", salary=" + salary + "]";
	}
}

改变一下配置文件：

<bean id="employee05" class="bean.Employee">
		<constructor-arg value="1005"></constructor-arg>
		<constructor-arg value="冯7"></constructor-arg>
		<constructor-arg value="10000"></constructor-arg>
</bean>

执行结果

Employee [id=1005, name=冯7, desc=10000, salary=null]//当有两个构造器时,前面应该调用接收String类型的构造函数，也调用接收Double类型参数的构造器，原因是反射底层在获取类中所有构造方法的时候，放到了一个数组中，如果数组中的第一个可以匹配，那么后面的就不在匹配了。

遍历构造器：

public static void main(String[] args){
	testConstructor();
}
public static void testConstructor() {
		Class cla = Employee.class;
		Constructor[] cons = cla.getDeclaredConstructors();
		for (Constructor constructor : cons) {
			System.out.println(constructor);
		}
}

结果如下：

public bean.Employee(java.lang.Integer,java.lang.String,java.lang.String)
public bean.Employee(java.lang.Integer,java.lang.String,java.lang.Double)
public bean.Employee()

问题的解决：在xml文件中设置type

<bean id="employee05" class="bean.Employee">
		<constructor-arg value="1005"></constructor-arg>
		<constructor-arg value="冯7"></constructor-arg>
		<constructor-arg value="10000" type="java.lang.Double"></constructor-arg>
</bean>

结果如下：

Employee [id=1006, name=冯七,salary=10000.0]

字面值

  1. 可以使用字符串表示的值，可以通过value属性或value子节点的方式指定。

  2. 基本数据类型及其封装类、String等类型都可以采取字面值注入的方式

  3. 若字面值中包含特殊字符，可以使用<![CDATA[]]>把字面值包裹起来

创建一个Book类

package bean;

public class Book {
	private String isbn;
	private String name;
	public String getIsbn() {
		return isbn;
	}
	public void setIsbn(String isbn) {
		this.isbn = isbn;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Book [isbn=" + isbn + ", name=" + name + "]";
	}
}

在spring_ioc.xml文件中进行配置

<bean id="book01" class="bean.Book">
    <!--通过value属性赋值-->
	<property name="isbn" value="j001"></property>
	<property name="name" value="活着"></property>
</bean>
-------------------------------------------------------------------------------------
<bean id="book02" class="bean.Book">
    <!--通过value标签赋值-->
	<property name="isbn">
		<value>j001</value>
	</property>
	<property name="name">
		<value>活着</value>
	</property>
</bean>
-------------------------------------------------------------
<bean id="book03" class="bean.Book">
    <!--通过value标签赋值，可以省略标签体，直接以“/”结束-->
	<property name="isbn" value="j001"/>
	<property name="name" value="活着"/>
</bean>

<!--如果有特殊的字符可以使用实体转义，也可以放在<![CDATA[]]中，<![CDATA[]]不能使用value属性，只能使用value标签-->
<property name="name">
	<value>
    	<![CDATA[!@#!编程思想]]>
    </value>
</property>

引用其他的bean

创建员工类Employee和部门类Department

package bean;

public class Employee {
	private Integer id;
	private String name;
	private String desc;
	private Double salary;
	private Department dept;
	
	
	public Employee(Integer id, String name, String desc, Double salary, Department dept) {
		super();
		this.id = id;
		this.name = name;
		this.desc = desc;
		this.salary = salary;
		this.dept = dept;
	}
	
	public Employee() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}



	public void setName(String name) {
		this.name = name;
	}

	public String getDesc() {
		return desc;
	}

	public void setDesc(String desc) {
		this.desc = desc;
	}

	public Double getSalary() {
		return salary;
	}
    
	public void setSalary(Double salary) {
		this.salary = salary;
	}

	public Department getDept() {
		return dept;
	}

	public void setDept(Department dept) {
		this.dept = dept;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", desc=" + desc + ", salary=" + salary + ", dept=" + dept
				+ "]";
	}

}

package bean;

public class Department {
	private Integer id;
	private String name;
	public Department() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Department(Integer id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Department [id=" + id + ", name=" + name + "]";
	}

}

在12.xml文件中配置部门属性

<bean id="employee01" class="bean.Employee">
 	<property name="id" value="1006"></property>
 	<property name="name" value="张三丰"></property>
 	<property name="desc" value="员工"></property>
 	<property name="salary" value="1500"></property>
 	<property name="dept" ref="dept"></property>
 </bean>
<bean id="dept" class="bean.Department">
	<property name="id" value="200"></property>
	<property name="name" value="武当山"></property>
	</bean>

</beans>

测试类

package test;

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

import bean.Employee;

public class Test03 {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("12.xml");
		Employee employee01 = context.getBean("employee01", Employee.class);
		System.out.println(employee01);
	}
}

结果：

Employee [id=1006, name=张三丰, desc=员工, salary=1500.0, dept=Department [id=200, name=武当山]]

给bean的级联属性赋值

<bean id="employee02" class="bean.Employee">
	<property name="id" value="1007"></property>
 	<property name="name" value="张丰"></property>
 	<property name="desc" value="员工02"></property>
 	<property name="salary" value="15002"></property>
 	<property name="dept" ref="dept"></property>
 	
 	<!--级联属性操作-->
	<property name="dept.name" value="峨眉派"></property>
 </bean>

	
<bean id="dept" class="bean.Department">
	<property name="id" value="200"></property>
	<property name="name" value="武当山"></property>
</bean>

结果：

Employee [id=1007, name=张丰, desc=员工02, salary=15002.0, dept=Department [id=200, name=峨眉派]]
duanqwei
关注
Spring——IOC操作Bean管理的两种方式
weixin_45480995的博客
07-03 665
IOC操作Bean管理的两种方式Bean管理操作有两种方式IOC操作Bean管理（基于xml方式、基于注解方式）
7.1JavaEE——Spring中的Bean的管理——Spring IoC容器
PAP
07-11 694
Spring提供了几个BeanFactory接口的实现类，其中最常用的是XmlBeanFactory，它可以读取XML文件并根据XML文件中的配置信息生成BeanFactory接口的实例，BeanFactory接口的实例用于管理Bean。ApplicationContext接口可以为单例的Bean实行预初始化，并根据元素执行setter方法，单例的Bean可以直接使用，提升了程序获取Bean实例的性能。BeanFactory接口实例的语法格式。根据实例的名字获取实例的别名数组。
spring-framework-中文文档一:IoC容器、介绍Spring IoC容器和bean
weixin_34217711的博客
04-03 119
5. IoC容器 5.1介绍Spring IoC容器和bean 5.2容器概述 本章介绍Spring Framework实现控制反转（IoC）[1]原理。IoC也被称为依赖注入（DI）。它是一个过程，对象通过构造函数参数，工厂方法的参数或在工厂方法构造或返回后在对象实...
Spring IoC容器和Bean简介
听海边涛声
02-24 193
Spring IoC容器和Bean简介
Spring官方文档 1.1 Spring IoC容器和Bean简介
weixin_43981133的博客
09-21 166
翻译自Spring官方文档: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans IoC容器 本章介绍Spring的控制反转（IOC）容器。 1.1。Spring IOC容器和Bean简介 本章介绍反转控制（IoC）原则的Spring框架实现。IoC也称为依赖注入（DI）。在此过程中，对象仅通过构造函数参数，工厂方法的参数或从工厂方法返回后在对象实例上设置的属性来定义其
Spring Bean管理--IOC容器简介
chuangxin的专栏
07-31 663
一、摘要 本文主要介绍Spring Bean管理部分的IOC容器：BeanFactory和ApplicationContext，以及Bean如何创建、销毁，如何通过InitializingBean或init、destroy方法进行生命周期管理等。 二、IOC容器 1、BeanFactory 2、ApplicationContext...
Spring IOC和Bean介绍
terry
11-14 122
Spring IoC容器和Bean简介 Spring IoC容器也称为依赖注入（DI）。在此过程中，对象仅通过构造函数参数，工厂方法的参数或在构造或从工厂方法返回后在对象实例上设置的属性来定义其依赖项（即，与它们一起使用的其他对象） 。然后，容器在创建bean时注入那些依赖项。此过程从根本上讲是通过使用类的直接构造或诸如服务定位器模式之类的控件来控制其依赖项的实例化或位置的bean本身的逆过程（因此称为Control的倒置）。 org.springframework.beans和org.springfram
JAVAWEB开发之Spring详解之——Spring的入门以及IOC容器装配Bean(xml和注解的方式)、Spring整合web开发、整合Junit4测试
04-22 2904
Spring框架学习路线 Spring的IOCSpring的AOP，AspectJSpring的事务管理，三大框架的整合 Spring框架概述 什么是Spring？  Spring是分层的JavaSE/EE full-stack(一站式)轻量级开源框架。 所谓分层： SUN提供的EE的三层结构：web层、业务层、数据访问层(也称持久层，集成层)。Struts2是we
Spring5框架——IOC操作Bean管理（FactoryBean）
qq_50233116的博客
11-03 436
bean的作用域、bean的生命周期、自动装配、外部属性文件、创建对象（基于注解方式）、注入属性（注解方式）、完全注解开发
Spring——IOC容器
ouyangkq666的博客
12-13 944
​目录 一、IOC底层原理 1、什么是IOC 2、IOC底层原理 3、画图讲解IOC底层原理 二、IOC接口 三、IOC操作Bean管理（概念） 四、IOC操作Bean管理（基于xml） 五、IOC操作Bean管理（xml注入其他类型属性） 六、IOC操作Bean管理（xml注入集合属性） 七、IOC操作Bean管理（FactoryBean） 八、IOC操作Bean管理（bean作用域） 九、IOC操作Bean管理（bean生命周期） 十、IOC操作Bean管理（xml自动装配） 十一、IOC操作Bean
Spring：IOC容器和Bean详解
qq_43745578的博客
09-28 1485
Spring：IOC容器和Bean详解
Spring核心技术（一）——IoC容器和Bean简介
weixin_30642561的博客
05-06 343
IoC容器和Bean简介 这章包括了Spring框架对于IoC规则的实现。Ioc也同DI(依赖注入)。而对象是通过构造函数，工厂方法，或者一些Set方法来定义对象之间的依赖的。容器在创建这些Bean对象的时候同时就会注入这些依赖。这个过程是根本上的反转了，不再由Bean本身来控制实例化和定位依赖，而是通过服务定位来控制这个过程，也是IoC（控制反转）的由来。 org.spr...
Spring之IOC、核心容器和Bean概念详解
u014678284的博客
03-17 4004
    这一周忙了很多与代码无关的事，感觉心态上还是有些急躁，周中挑几个晚上看了一些文章，上午起来总结了一下，下午开始写博客，因为没有时间撸代码，所以就打算先把看到的概念梳理梳理，磨刀不误砍柴工。    首先来看一看什么是IOC，他的全称是Inversion of Control，即控制反转，如果上网找绝大多数的概念是这样说的：Spring实现了把原始的通过代码操纵的组件和应用的调用权利交给了容器...
Spring中IOC容器概述与Bean的配置
u010512429的博客
05-23 1300
Spring中IOC容器概述与Bean的配置IOC容器概述IOC(Inversion of Control):其思想是反转资源获取的方向。传统的资源查找方式要求组件向容器发起请求查找资源。作为回应，容器适时地返回资源。Person p=new Person();而应用了IOC之后，则是容器主动地将资源推送给它所管理的组件，组件所要做的仅是选择一种合适的方式来接受资源。这种行为也被称为查找的被动形式...
介绍 Spring IoC 容器和 bean
邵小小的博客
07-01 5409
简介本章涵盖了 Spring Framework实现控制翻转 (IoC) 的原则。 IoC 有时也被称为依赖注入 (DI)。这是一个对象定义他们依赖的过程，其中对象之间的相关性，也就是说，它们一起工作，只能通过构造函数参数，参数工厂方法或设置在其构造后的对象实例或者是从一个工厂方法返回的对象实例的属性上。容器在创建的 bean 注入这些依赖。这个过程是根本的反转，因此称为控制反转（IoC），bean
Spring的使用
qq_38586166的博客
02-05 172
配置文件需要重新创建一个Source Folder文件夹conf，配置文件放在这里面 Spring和SpringMVC的配置文件需要创建Spring Bean Definition file MyBatis配置文件只需要创建XML File 1.Spring运行环境需要导入的jar包 spring-beans-4.0.0.RELEASE.jar spring-context-4.0.0.RELE2...
阿博图书馆管理：SpringBoot实战指南
2402_85761468的博客
09-27 698
MySQL数据库中数据的分表分库存储方式能够最大程度的避免数据同步代码的性能损耗，使得数据库的存取速度有了很大提升，而且同时保持了很大的灵活性。通过对系统功能模块分析可以得知，主要是对项目元素组合、分解和更换做出相应的单元，再通过系统模块来规划出一个原则，系统的设计首先是围绕用户需求进行开发设计的，主要是为了能够更好的管理信息和方便用户，其次就是围绕阿博图书馆管理系统进行设计，最终的设计必须要满足用户的需求，这样才能够实现系统的最大意义和价值，并且在设计的时候一定要避免代码相互重复的情况发生。
SpringBoot--为什么Controller是串行的？怎样才能并行？
最新发布
IT利刃出鞘的博客
09-29 461
本文介绍SpringBoot为什么Controller是串行的？在什么场景下才能并行执行？
Spring框架基础：IoC容器与Bean解析
本章深入介绍了Spring框架如何通过IoC容器和bean的概念，改善了传统编程模式的不足，提供了更高效、更灵活的组件管理方式，为Java开发带来显著的优势。学习和掌握这些基础知识，将有助于开发者更好地理解和运用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值