Spring学习（二）— IoC学习以及基本环境搭建

最新推荐文章于 2022-03-16 21:27:31 发布

隔壁王同学m

最新推荐文章于 2022-03-16 21:27:31 发布

阅读量169

点赞数 2

分类专栏： spring 文章标签： spring

本文链接：https://blog.csdn.net/weixin_40093242/article/details/84719635

版权

spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、IoC( Inversion of Control )控制反转

IoC 是什么?

IoC 完成的事情原先由程序员主动通过 new 实例化对象事情,转交给 Spring 负责.
控制反转中控制指的是:控制类的对象.
控制反转中反转指的是转交给 Spring 负责.
IoC 最大的作用: 解耦.程序员不需要管理对象.解除了对象管理和程序员之间的耦合

二、环境搭建测试

导入基础jar包，四个核心包一个日志包(commons-logging)

2. 在 src 下新建 applicationContext.xml

Spring 容器 ApplicationContext,applicationContext.xml 配置的信息最终存储到了 AppliationContext 容器中
Spring 配置文件是基于 schema， schema 文件扩展名.xsd，每次引入一个 xsd 文件是一个 namespace(xmlns)。配置文件中只需要引入基本 schema。配置文件中通过<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">
   <!-- id 表示获取到对象标识    class 创建哪个类的对象  -->
    <bean id="peo" class="com.wzg.pojo.People"></bean>
</beans>

3.实体类People

package com.wzg.pojo;

public class People {
	private int id;
	private String name;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public People(int id, String name) {
		super();
		System.out.println("ִ执行含参构造函数");
		this.id = id;
		this.name = name;
	}
	public People() {
		super();
		System.out.println("ִ执行默认构造函数");
	}
	@Override
	public String toString() {
		return "People [id=" + id + ", name=" + name + "]";
	}
	
}

3.测试类

getBean(“<bean>标签 id 值”,返回值类型); 如果没有第二个参数，默认是 Object
getBeanDefinitionNames()，Spring 容器中目前所有管理的所有对象

package com.wzg.test;

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

import com.wzg.pojo.People;

public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		People people = ac.getBean("peo2", People.class);
		System.out.println(people);
		
		String[] names = ac.getBeanDefinitionNames();
		for(String n:names){
			System.out.println(n.toString());
		}
		
	}
}

三、Spring创建对象的三种方式

通过构造方法创建

1.1 无参构造创建:默认情况.

1.2 有参构造创建:需要明确配置。需要在类中提供有参构造方法。

在 applicationContext.xml 中设置调用哪个构造方法创建对象，如果设定的条件匹配多个构造方法执行最后的构造方法

index : 参数的索引,从 0 开始

name: 参数名

type:类型(区分开关键字和封装类 int 和 Integer)

<bean id="peo" class="com.wzg.pojo.People">
    <!-- ref 引用另一个 bean value 基本数据类型或String 等 -->
    <constructor-arg index="0" name="id" type="int"value="123"></constructor-arg>
    <constructor-arg index="1" name="name" type="java.lang.String" value=" 张三"></constructor-arg>
</bean>

2.实例工厂

工厂设计模式：帮助创建类对象.一个工厂可以生产多个对象.
实例工厂：需要先创建工厂,才能生产对象

//实例工厂
public class PeopleFactory {
    public People newInstance(){
        return new People(1,"测试");
    }
}

<!--  在 applicationContext.xml 中配置工厂对象和需要创建的对象  -->
<bean id="factory" class="com.wzg.pojo.PeopleFactory"></bean>
<bean id="peo1" factory-bean="factory" factory-method="newInstance"></bean>

3.静态工厂----不需要创建工厂，快速创建对象。

//编写一个静态工厂(在方法上添加 static)
public class PeopleFactory {
    public static People newInstance(){
        return new People(1,"测试");
    }
}

在 applicationContext.xml 中

<bean id="peo2" class="com.wzg.pojo.PeopleFactory" factory-method="newInstance"></bean>

四、给 Bean的属性赋值( 注入)

通过构造方法设置值
设置注入(通过 set 方法)

Bean类

package com.wzg.pojo;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class People {
	private int id;
	private String name;
	private Set<String> sets;
	private String [] strs;
	private List<String> list;
	private Map<String,String> map;
	public void setStrs(String[] strs) {
		this.strs = strs;
	}
	public String[] getStrs() {
		return strs;
	}
	public void setList(List<String> list) {
		this.list = list;
	}
	public List<String> getList() {
		return list;
	}
	public void setMap(Map<String, String> map) {
		this.map = map;
	}
	public Map<String, String> getMap() {
		return map;
	}
	public void setSets(Set<String> sets) {
		this.sets = sets;
	}
	public Set<String> getSets() {
		return sets;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public People(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public People() {
		super();
	}
	@Override
	public String toString() {
		return "People [id=" + id + ", name=" + name + ", sets=" + sets
				+ ", strs=" + Arrays.toString(strs) + ", list=" + list
				+ ", map=" + map + "]";
	}
}

如果属性是基本数据类型或 String 等简单类型，配置文件中为：（两种方法）

<bean id="peo" class="com.wzg.pojo.People">
    <property name="id" value="1"></property>
    <property name="name" value=" 张三 "></property>
</bean>

<bean id="peo" class="com.wzg.pojo.People">
    <property name="id">
        <value>1</value>
    </property>
    <property name="name">
        <value>张三</value>
    </property>
</bean>

其他类型： Set<?> List<?> 数组 map

<property name="sets">
    <set>
        <value>1</value>
        <value>2</value>
        <value>3</value>
        <value>4</value>
    </set>
</property>

<property name="list">
    <list>
        <value>1</value>
        <value>2</value>
        <value>3</value>
    </list>
</property>

<property name="strs" >
    <array>
        <value>1</value>
        <value>2</value>
        <value>3</value>
    </array>
</property>

<property name="map">
    <map>
        <entry key="a" value="b" ></entry>
        <entry key="c" value="d" ></entry>
    </map>
</property>

五、DI（依赖注入）

DI 和 IoC 是一样的。当一个类(A)中需要依赖另一个类()对象时，把 B 赋值给 A 的过程就叫做依赖注入。

新建一个bean类：

package com.wzg.pojo;

public class link {
	private int id;
	private String phone;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getPhone() {
		return phone;
	}
	public void setPhone(String phone) {
		this.phone = phone;
	}
	public link() {
		super();
	}
	@Override
	public String toString() {
		return "link [id=" + id + ", phone=" + phone + "]";
	}
}

配置文件

<bean id="peo" class="com.wzg.pojo.People">
    <property name="desk" ref="link"></property>
</bean>
<bean id="link" class="com.wzg.pojo.link">
    <property name="id" value="1"></property>
    <property name="phone" value="123456789"></property>
</bean>

隔壁王同学m

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring学习（二）— IoC学习以及基本环境搭建

一、IoC( Inversion of Control )控制反转IoC 是什么?IoC 完成的事情原先由程序员主动通过 new 实例化对象事情,转交给 Spring 负责. 控制反转中控制指的是:控制类的对象. 控制反转中反转指的是转交给 Spring 负责. IoC 最大的作用: 解耦.程序员不需要管理对象.解除了对象管理和程序员之间的耦合二、环境搭建测试导入基础ja...
复制链接

扫一扫