投稿
  1. 极客之音首页
  2. 后端漫谈

Spring之初识IOC基础配置（一）

飞熊 • • 后端漫谈 • 阅读 203

生活中，最使人疲惫的往往不是道路的遥远，而是心中的郁闷;最使人痛苦的往往不是生活的不幸，而是希望的破灭;最使人颓废的往往不是前途的坎坷，而是自信的丧失;最使人绝望的往往不是挫折的打击，而是心灵的死亡。所以我们要有自己的梦想，让梦想的星光指引着我们走出落漠，走出惆怅，带着我们走进自己的理想。

导读：本篇文章讲解 Spring之初识IOC基础配置（一），希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

Spring之初识IOC基础配置（一）

一、Spring概述

1.什么是Spring?

Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。

Spring是一个分层的 Java SE/EE应用 full-stack (一站式)轻量级开源框架。

一站式框架是指 Spring 有 JavaEE 开发的每一层解决方案:

	WEB层：SpringMVC
	Service层：Spring的Bean管理，声明式事务
	DAO层：Spring的JDBC模板，ORM模板

2.Spring的优点

1.方便解耦，简化开发
通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2.AOP编程的支持
通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

3.声明式事务的支持
在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

4.方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对
Junit4支持，可以通过注解方便的测试Spring程序。

5.方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。

6.降低Java EE API的使用难度
Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

7.Java 源码是经典学习范例
Spring的源码设计精妙、结构清晰、匠心独运，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

3.Spring的体系结构

在这里插入图片描述

二、什么是ICO？

IOC : Inverse of Control（控制反转），它是一种设计思想，是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。
正控：使用某个对象，需要自己负责对象的创建
反控：使用某个对象，只需要从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架控。
简单的说，IOC控制反转，就是将对象的创建权反转给了Spring。

三、基于XML配置ICO

1.添加依赖

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

spring-context相关依赖示意图

在这里插入图片描述
在这里插入图片描述

2.根路径下创建非中文任意名称的 xml 文件

创建bean.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">

</beans>

3.bean.xml中配置对象，交由让spring管理

bean.xml中配置service与dao对象

	<!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中
        id 属性：对象的唯一标识。
        class 属性：指定要创建对象的全限定类名-->
        
    <!-- 配置 service -->
    <bean id="userService" class="cn.ybzy.service.impl.UserServiceImpl"></bean>
   
    <!-- 配置 dao -->
    <bean id="userDao" class="cn.ybzy.dao.impl.UserDaoImpl"></bean>

4.执行测试验证

/**
 * 获取spring的Ioc核心容器，并根据id获取对象
 */
public static void main(String[] args) {
	//使用 ApplicationContext 接口，获取 spring 容器
	ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
	//根据 bean 的 id 获取对象
	UserService userService = (UserService) ac.getBean("userService");
	System.out.println(userService);
	UserDao userDao= (UserDao) ac.getBean("userDao");
	System.out.println(userDao);
	}
}

5.ApplicationContext接口介绍

1.ApplicationContext的继承关系

在这里插入图片描述
2.ApplicationContext接口的实现

在这里插入图片描述
ApplicationContext接口有以下3个常用实现：

ClassPathXmlApplicationContext：加载类路径下的配置文件。(常用方式)

FileSystemXmlApplicationContext：加载磁盘任意路径下的配置文件(必须有访问权限）
 
AnnotationConfigApplicationContext：使用注解配置容器对象时，用于读取注解创建容器。

3.ApplicationContext与BeanFactory的区别

BeanFactory 是 Spring 容器中的顶层接口。

ApplicationContext 是BeanFactory的子接口。

ApplicationContext:     
	适用于创建单例对象使用，它在构建核心容器时，创建对象采取的策略是立即加载的方式。
	也就是说，只要配置文件读取完马上就创建配置文件中配置的对象。
 
BeanFactory:           
   	 适用于创建多例对象使用，它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。
   	 也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。

四、Spring Bean的管理

1.Bean标签介绍

Bean标签的作用：
	用于配置对象让 spring 来创建的。
	
	默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

Bean标签的属性：
	id：给对象在容器中提供一个唯一标识。用于获取对象。
	
	class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
	
	scope：指定对象的作用范围。
	
	init-method：指定类中的初始化方法名称。
	
	destroy-method：指定类中销毁方法名称。

2. bean的作用范围

    bean标签的scope属性：用于指定bean的作用范围，常用的是单例的和多例。
    
     singleton：单例的（默认值）
     prototype：多例的
     request：作用于web应用的请求范围
     session：作用于web应用的会话范围
     global-session：作用于集群环境的会话范围，当不是集群环境时，它就是session
           
<bean id="userService" class="cn.ybzy.service.impl.UserServiceImpl" scope="prototype"></bean>

3. bean对象的生命周期

 单例对象：scope="singleton",单例对象的生命周期和容器相同
     出生：当容器创建时对象出生
     活着：只要容器还在，对象一直活着
     死亡：容器销毁，对象消亡      
     
  多例对象：scope="prototype",每次访问对象时，都会重新创建对象实例
      出生：当使用对象时，创建新的对象实例
      活着：对象只要是在使用过程中就一直活着。
      死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收       

<bean id="userService" class="cn.ybzy.service.impl.UserServiceImpl"
      scope="prototype" init-method="init" destroy-method="destroy"></bean>

public class UserServiceImpl implements UserService {

    public UserServiceImpl (){
        System.out.println("对象创建了。。。");
    }

    public void  init(){
        System.out.println("对象初始化了。。。");
    }
    
    public void  destroy(){
        System.out.println("对象销毁了。。。");
    }
}

4.实例化 Bean 的三种方式

1.使用默认无参构造函数

 <!--  在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
 采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。   -->

<bean id="userService" class="cn.ybzy.service.impl.UserServiceImpl"></bean>

2.使用实例工厂的方法创建对象

<!--  先把工厂的创建交给 spring 管理，然后在使用工厂的 bean 对象来调用里面的方法     -->
<!--  id 属性：指定 bean 的 id，用于从容器中获取
	  class 属性：指定静态工厂的全限定类名
	  factory-bean 属性：用于指定实例工厂 bean 的 id。
	  factory-method 属性：用于指定实例工厂中创建对象的方法。-->
	
<bean id="instanceFactory" class="cn.ybzy.factory.InstanceFactory"></bean>
<bean id="userService" factory-bean="instanceFactory" factory-method="getUserService"></bean>

//实例工厂	
public class InstanceFactory {
	public UserService getUserService(){
	return new UserServiceImpl();
	}
}

3.使用工厂中的静态方法创建对象

<!-- 	使用 StaticFactory 类中的静态方法 getUserService创建对象，并存入 spring 容器 -->
<!-- 	id 属性：指定 bean 的 id，用于从容器中获取
		class 属性：指定静态工厂的全限定类名
		factory-method 属性：指定生产对象的静态方法 	-->
		
<bean id="userService" class="cn.ybzy.factory.StaticFactory" factory-method="getUserService"></bean>


	//静态工厂
	public class StaticFactory {
		public static userService getUserService(){
		return new UserServiceImpl();
		}
	}

五、 Spring 的依赖注入

1.什么是依赖注入

依赖注入：Dependency Injection。降低程序间的耦合（依赖关系)

依赖关系的管理是由spring来维护，依赖关系的维护就称为依赖注入。

2.依赖注入的三种方式

1.构造函数注入

使用构造函数的方式，给 bean中的属性传值,类中需要提供一个对应参数列表的构造函数。

使用标签:constructor-arg
        标签中的属性
            type：指定参数在构造函数中的数据类型
            index：用指定参数在构造函数参数列表的索引位置。索引的位置是从0开始
            name：指定参数在构造函数中的名称                                         
            value：指定能赋的值是基本数据类型和 String 类型
            ref：指定能赋的值是其他 bean 类型。就是在spring的Ioc核心容器中出现过的bean对象

        优势：
            在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
        弊端：
            改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。


public class UserServiceImpl implements UserService {

    private String name;
    private Integer age;
    private Date birthday;

    public UserServiceImpl(String name,Integer age,Date birthday){
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }
}

	<bean id="userService " class="cn.ybzy.service.impl.UserServiceImpl">
	<constructor-arg name="name" value=" 大白"></constructor-arg>
	<constructor-arg name="age" value="22"></constructor-arg>
	<constructor-arg name="birthday" ref="now"></constructor-arg>
	</bean>
	
	<bean id="now" class="java.util.Date"></bean>

2.set 方法注入

注意: 需要在类中提供需要注入成员的 set 方法

通过配置文件给 bean 中的属性传值：使用 set 方法的方式

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

public class UserServiceImpl implements UserService{

    private String name;
    private Integer age;
    private Date birthday;
    private Car car;

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

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    
     public void setCar(Car car) {
        this.car = car;
    }
}

	<bean id="userService" class="cn.ybzy.service.impl.UserServiceImpl ">
		<property name="name" value="大白"></property>
		<property name="age" value="22"></property>
		<property name="birthday" ref="now"></property>
		<property name="car" ref="car"></property>
	</bean>
	
	<bean id="car" class="cn.ybzy.model.Car"></bean>
	<bean id="now" class="java.util.Date"></bean>

P名称空间的属性注入（Spring2.5以后）

	1.引入p名称空间
	
	2.写法
		普通属性	p:属性名=”值”  
		对象属性	p:属性名-ref=”值” 
		
	3.使用
	
<?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">
        <!--引入p名称空间-->
        xmlns:p="http://www.springframework.org/schema/p"

 <bean id="userService" class="cn.ybzy.service.impl.UserServiceImpl" p:name="大白" p:age="22" p:birthday-ref="now" p:car-ref="car"></bean>

	<bean id="car" class="cn.ybzy.model.Car"></bean>
	<bean id="now" class="java.util.Date"></bean>
 
</beans>

SpEL的属性注入（Spring3.0以后）

Spring 3.0 创建了一种新的方式用以配置对象的注入（set 注入或者构造参数注入），它便是 SpEL (Spring Expression Language)

语法：
	#{SpEL}

<bean id="car" class="cn.ybzy.model.Car"></bean>

 <bean id="userService" class="cn.ybzy.service.impl.UserServiceImpl">
		<property name="name" value="#{'大白'}"></property>
		<property name="age" value="#{22}"></property>
		<property name="birthday" ref="#{now}"></property>
		<property name="key" ref="#{car.key}"></property>
		<property name="driver" ref="#{car.getDriver()}"></property>
</bean>

3.注入集合属性

就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。
在注入集合数据时，只要结构相同，标签可以互换

注入集合数据:
	List 结构的：
		array,list,set
	Map 结构的
		map,entry,props,prop    

public class UserServiceImpl implements UserService {

    private String[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties props;
    
    public void setArray(String[] array) {
        this.array = array;
    }
    
    public void setList(List<String> list) {
        this.list = list;
    }
    
    public void setSet(Set<String> set) {
        this.set = set;
    }
    
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    
    public void setProps(Properties props) {
        this.props = props;
    }
}

    <bean id="userService" class="cn.ybzy.service.impl.UserServiceImpl ">
        <property name="array">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="list">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>

        <property name="set">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>

        <property name="map">
            <map>
                <prop key="AAA">aaa</prop>
                <prop key="BBB">bbb</prop>
            </map>
        </property>

        <property name="props">
            <props>
                <entry key="AAA" value="aaa"></entry>
                <entry key="BBB">
                    <value>bbb</value>
                </entry>
            </props>
        </property>
    </bean>

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/137140.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！