Spring学习第一天(控制反转(IOC)与依赖注入(DI))

Spring第一天学习总结

1、spring中的IOC到底可以解决什么样的问题

降低了程序的耦合，减少了类与类之间的依赖。

2. 如何搭建出来spring中基于xml的IOC的开发环境

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
	
		<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl(全限定类名)"></bean>
	</beans>	

3、如何使用spring的注入来实现类之间的依赖关系的维护

依赖注入： 最常用的方法是4和5，其余方法用的不多
1.使用默认构造函数：
XML代码

	<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

2.使用某个类中的方法创建对象，并存入spring的容器。
Java代码

	public class InstanceFactory {
	    public IAccountService getAccountService(){
	        return new AccountServiceImpl();
	    }
	}

XML代码

	<bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean>
	<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>

3.使用某个类中的静态方法创建对象，并存入spring的容器。
Java代码

	public class StaticFactory {
	    public static IAccountService getAccountService(){
	        return new AccountServiceImpl();
	    }
	}

XML代码

	<bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>

4、使用有参数的构造函数注入

	使用的标签：constructor-arg
	标签出现的位置：bean标签的内部
	标签中的属性：
		type: 用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型。
		index: 用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
		name: 用于指定给构造函数中指定名称的参数赋值(最常用的，以上两个不常用)
		---------以上三个用于指定给构造函数中哪儿个参数赋值----------
		value: 用于提供基本类型和String类型的数据
		ref: 用于指定其他bean类型数据(指的就是在spring的IOC核心容器中出现过的bean对象)
		
	优势：
		在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
	弊端：
		改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

Java代码

		// 如果是经常变化的数据,并不适用于注入的方式
	    private String name;
	    private Integer age;
	    private Date birthday;
	
	    public AccountServiceImpl(String name,Integer age,Date birthday){
	        this.name = name;
	        this.age = age;
	        this.birthday = birthday;
	    }
	
	    public void saveAccount() {
	        System.out.println("service中的saveAccount方法执行了！" + name +"\t"+age+"\t"+birthday);
	    }

XML代码

		<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
			<constructor-arg name="name" value="太僧特"></constructor-arg>
			<constructor-arg name="age" value="18"></constructor-arg>
			<constructor-arg name="birthday" ref="now"></constructor-arg>
		</bean>
		<!-- 配置一个日期对象 -->
		<bean id="now" class="java.util.Date"></bean>

5、set方法注入(更常用的方法！)

		涉及的标签：property
		出现的位置：bean标签的内部
		标签的属性
			name: 用于指定注入时所调用的set方法名称
			value: 用于提供基本类型和String类型的数据
			ref: 用于指定其他bean类型数据(指的就是在spring的IOC核心容器中出现过的bean对象)
		优势：
			创建对象时，没有明确限制，可以直接使用默认构造函数
		弊端：
			如果有某个成员必须有值，则获取对象时有可能set方法没有执行。

XML代码

		<bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2">
			<property name="name" value="TEST"></property>
			<property name="age"  value="21"></property>
			<property name="birthday" ref="now"></property>
		</bean>

6、复杂类型的注入和集合类型的注入

		用于给List结构集合注入的标签：
			list array set
		用于给Map结构集合注入的标签：
			map props
		结构相同，标签可以互换

Java代码

		private String[] myStrs;
	    private List<String> myList;
	    private Set<String> mySet;
	    private Map<String,String> myMap;
	    private Properties myProps;
	
	    public String[] getMyStrs() {
	        return myStrs;
	    }
	
	    public void setMyStrs(String[] myStrs) {
	        this.myStrs = myStrs;
	    }
	
	    public List<String> getMyList() {
	        return myList;
	    }
	
	    public void setMyList(List<String> myList) {
	        this.myList = myList;
	    }
	
	    public Set<String> getMySet() {
	        return mySet;
	    }
	
	    public void setMySet(Set<String> mySet) {
	        this.mySet = mySet;
	    }
	
	    public Map<String, String> getMyMap() {
	        return myMap;
	    }
	
	    public void setMyMap(Map<String, String> myMap) {
	        this.myMap = myMap;
	    }
	
	    public Properties getMyProps() {
	        return myProps;
	    }
	
	    public void setMyProps(Properties myProps) {
	        this.myProps = myProps;
	    }
	
	    public void saveAccount() {
	        System.out.println(Arrays.toString(myStrs));
	        System.out.println(myList);
	        System.out.println(mySet);
	        System.out.println(myMap);
	        System.out.println(myProps);
	    }

XML代码

		<bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl2">
			<property name="myStrs">
				<set>
					<value>AAA</value>
					<value>BBB</value>
					<value>CCC</value>
				</set>
			</property>

			<property name="myList">
				<array>
					<value>AAA</value>
					<value>BBB</value>
					<value>CCC</value>
				</array>
			</property>
			
			<property name="myMap">
				<props>
					<prop key="testC">CCC</prop>
					<prop key="testD">DDD</prop>
				</props>
			</property>

			<property name="myProps">
				<map>
					<entry key="testA" value="AAA"></entry>
					<entry key="testB">
						<value>BBB</value>
					</entry>
				</map>
			</property>
		</bean>

复习：与注解相关的知识。

预习：学习注解IOC到底干了什么事？

自我思考:

1. 什么是依赖注入(DI)？

   把有依赖关系的类放入容器中，解析出这些类的实例，就叫依赖注入。
   
   实例：
   	Class A中用到了Class B的对象b，一般情况下，需要在A的代码中显式的new一个B的对象。采用依赖注入技术之后，A的代码只需要定义一个私有的B对象，
   	不需要直接new来获得这个对象，而是通过相关的容器控制程序来将B对象在外部new出来并注入到A类里的引用中。
   
   这样做的好处：假如现在有N多个类，需要用到Class B,那就需要在类里面实例化N多次，这样对于后期的维护和管理都是不方便的，如果后期需求发生改变，那更改量有大很多。
   

2. IOC与依赖注入的关系，控制反转(IOC)到底是什么？

   控制反转(IOC)包含了依赖注入(DI),控制反转是面向对象编程中的一种设计原则,可以用来降低计算机代码之间的耦合。