Spring的入门学习day01:IOC(控制反转)与DI(依赖注入)

 

Spring的概述

spring 是什么?

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架,以 IoC(Inverse Of Control:控制反转)和 AOP(Aspect Oriented Programming:面向切面编程)为内核,提供了展现层 SpringMVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术,还能整合开源世界众多著名的第三方框架和类库,逐渐成为使用最多的Java EE 企业应用开源框架。

spring 的优势

方便解耦,简化开发
通过 Spring提供的 IoC容器,可以将对象间的依赖关系交由 Spring进行控制,避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。
AOP 编程的支持
通过 Spring的 AOP 功能,方便进行面向切面的编程,许多不容易用传统OOP 实现的功能可以通过 AOP 轻松应付。

声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来,通过声明式方式灵活的进行事务的管理,提高开发效率和质量。
方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作,测试不再是昂贵的操作,而是随手可做的事情。
方便集成各种优秀框架
Spring可以降低各种框架的使用难度,提供了对各种优秀框架(Struts、Hibernate、Hessian、Quartz等)的直接支持。
降低 JavaEE API 的使用难度
Spring对 JavaEE API(如 JDBC、JavaMail、远程调用等)进行了薄薄的封装层,使这些 API 的使用难度大为降低。

spring 的体系结构

IoC 的概念和作用

在了解IOC的概念和作用之前,首先要对程序的耦合与解耦有一个认识

什么是程序的耦合

耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系、数据传递关系。模块间联系越多,其耦合性越强,同时表明其独立性越差( 降低耦合性,可以提高其独立性)。
在软件工程中,耦合指的就是就是对象之间的依赖性。对象之间的耦合越高,维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。 划分模块的一个准则就是高内聚低耦合

解决耦合的思路

我们在使用对象的时候不是去new,而是通过IOC容器获取,对象与对象之间不再有直接联系,他们通过中间人IOC容器联系。

此处输入图片的描述

案例:JDBC的驱动注册

注册驱动时,我们为什么不使用 DriverManager 的 register 方法,而是采用 Class.forName 的方式?

原因是:我们的类依赖了数据库的具体驱动类(MySQL),如果这时候更换了数据库品牌(比如 Oracle),需要修改源码来重新数据库驱动。这显然不是我们想要的。

public class JdbcDemo1 {

    public static void main(String[] args) throws Exception {
        //1.注册驱动
        //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        Class.forName("com.mysql.jdbc.Driver");
        //2.获取连接
        //3.获取预处理 sql 语句对象
        //4.获取结果集
        //5.遍历结果集
    }
}

此时的好处是,我们的类中不再依赖具体的驱动类,此时就算删除 mysql 的驱动 jar 包,依然可以编译(运行就不要想了,没有驱动不可能运行成功的)。同时,也产生了一个新的问题,mysql 驱动的全限定类名字符串是在 java 类中写死的,一旦要改还是要修改源码。
解决这个问题也很简单,使用配置文件配置。

工厂模式解耦与IOC

在实际开发中我们可以把三层的对象都使用配置文件配置起来,当启动服务器应用加载的时候,让一个类中的方法通过读取配置文件,把这些对象创建出来 并存起来。在接下来的使用的时候,直接拿过来用就好了。那么,这个读取配置文件,创建和获取三层对象的类就是工厂。

使用spring的IOC解决程序耦合

案例:

 创建MAVEN项目,并准备三层接口类和实现类,创建maven项目,配置其pom.xml如下: 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>zyp_Spring</groupId>
    <artifactId>day01</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <!-- 引入-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>

</project>

项目结构如下:

创建持久层接口和实现类 

package com.zyp.dao;

public interface IAccountDao {
    void saveAccount();
}
package com.zyp.service.impl;
import com.zyp.dao.IAccountDao;
import com.zyp.dao.impl.AccountDaoImpl;
import com.zyp.service.IAccountService;

public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao = new AccountDaoImpl();
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

创建业务层接口和实现类

package com.zyp.service;

public interface IAccountService {
    /**
     * 模拟保存账户的方法
     */
    void saveAccount();
}
package com.zyp.dao.impl;

import com.zyp.dao.IAccountDao;

public class AccountDaoImpl implements IAccountDao {
    /**
     * 账户的持久层实现类
     * @author zyp
     */
    public void saveAccount() {
        System.out.println("账户信息已经保存");
    }
}

拷贝必备的jar包到项目中:

配置bean:

在类的根路径下的resource目录下创建bean.xml文件,把对象的创建交给spring来管理.每个<bean>标签对应一个类,其class属性为该类的全类名,id属性为该类的id,在spring配置中,通过id获取类的对象.

<?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 标签:用于配置让 spring 创建对象,并且存入 ioc 容器之中
        id 属性:对象的唯一标识。
        class 属性:指定要创建对象的全限定类名
-->
    <bean id="accountService" class="com.zyp.service.impl.AccountServiceImpl"></bean>
    <bean id="accountDao" class="com.zyp.dao.impl.AccountDaoImpl"></bean>
</beans>

模拟一个表现层,测试配置是否成功

package com.zyp.UI;

import com.zyp.dao.IAccountDao;
import com.zyp.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class client {
    public static void main(String[] args) {
        //1.使用 ApplicationContext 接口,就是在获取 spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据 bean 的 id 获取对象
        IAccountService accountService = (IAccountService) ac.getBean("accountService");
        System.out.println(accountService);
        accountService.saveAccount();

        IAccountDao accountDao = (IAccountDao) ac.getBean("accountDao");
        System.out.println(accountDao);
    }
}

结果如下:

注意事项及小结

BeanFactory 和 和 ApplicationContext 的区别

BeanFactory 才是 Spring 容器中的顶层接口。ApplicationContext 是它的子接口。
BeanFactory 和 ApplicationContext 的区别:创建对象的时间点不一样。
ApplicationContext:只要一读取配置文件,默认情况下就会创建对象。
BeanFactory:什么使用什么时候创建对象。

ApplicationContext 接口的实现类

ClassPathXmlApplicationContext :它是从类的根路径下加载配置文件 推荐使用这种
FileSystemXmlApplicationContext :它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext:当我们使用注解配置容器对象时,需要使用此类来创建 spring 容器。它用来读取注解。

IOC 中bean标签和管理对象细节

bean 标签

作用:
         用于配置对象让 spring 来创建的。
         默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性:
         id:给对象在容器中提供一个唯一标识。用于获取对象。
         class:指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
         scope:指定对象的作用范围。
                  * singleton :默认值,单例的.
                  * prototype :多例的.

                  * request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
                  * session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
                  * global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.
         init-method:指定类中的初始化方法名称。
         destroy-method:指定类中销毁方法名称。

bean 的作用范围和生命周期

单例对象:scope="singleton"
        一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期:
        对象出生:当应用加载,创建容器时,对象就被创建了。
        对象活着:只要容器在,对象一直活着。
        对象死亡:当应用卸载,销毁容器时,对象就被销毁了。
多例对象:scope="prototype"
        每次访问对象时,都会重新创建对象实例。
生命周期:
        对象出生:当使用对象时,创建新的对象实例。
        对象活着:只要对象在使用中,就一直活着。
        对象死亡:当对象长时间不用时,被 java 的垃圾回收器回收了。

实例化 Bean 的三种方式

第一种方式即使用默认无参构造函数:它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数,将会创建失败。

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

 第二种方式即spring 管理静态工厂:“”使用静态工厂的方法创建对象(使用某个类中的方法创建对象并且存入容器)

创建静态工厂如下:

package com.zyp.factory;

import com.zyp.service.IAccountService;
import com.zyp.service.impl.AccountServiceImpl;

/**
 * 模拟一个静态工厂,创建业务层实现类
 */
public class StaticFactory {
    public static IAccountService createAccountService(){
        return new AccountServiceImpl();
    }
}

使用StaticFactory类中的静态方法createAccountService创建对象,涉及到<bean>标签的属性:

id属性: 指定对象在容器中的标识,用于从容器中获取对象

class属性: 指定静态工厂的全类名

factory-method属性: 指定生产对象的静态方法

<bean id="accountService" class="com.zyp.factory.StaticFactory" factory-method="createAccountService"></bean>

第三种方式:spring 管理实例工厂- 使用实例工厂的方法创建对象

创建实例工厂如下:

package com.zyp.factory;

import com.zyp.service.IAccountService;
import com.zyp.service.impl.AccountServiceImpl;

/**
 * 模拟一个实例工厂,创建业务层实现类
 * 此工厂创建对象,必须现有工厂实例对象,再调用方法
 */
public class InstanceFactory {
    public IAccountService createAccountService(){
        return new AccountServiceImpl();
    }
}

先创建实例工厂对象instanceFactory,通过调用其createAccountService()方法创建对象,涉及到<bean>标签的属性:

其中:factory-bean属性: 指定实例工厂的id    factory-method属性: 指定实例工厂中生产对象的方法

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

其实第二种和第三种没什么区别,关键就是在于方法是不是静态的。

spring 的依赖注入

依赖注入的概念

依赖注入:Dependency Injection。它是 spring 框架核心 ioc 的具体实现。
我们的程序在编写时,通过控制反转,把对象的创建交给了 spring,但是代码中不可能出现没有依赖的情况。ioc 解耦只是降低他们的依赖关系,但不会消除。例如:我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系,在使用 spring 之后,就让 spring 来维护了。简单的说,就是坐等框架把持久层对象传入业务层,而不用我们自己去获取。

构造函数注入

顾名思义,就是使用类中的构造函数,给成员变量赋值。通过类默认的构造函数来给创建类的字段赋值,相当于调用类的构造方法。注意,赋值的操作不是我们自己做的,而是通过配置的方式,让 spring 框架来为我们注入

package com.zyp.service.impl;

import com.zyp.service.IAccountService;
import java.util.Date;

public class AccountServiceImpl implements IAccountService {

    //如果是经常变化的数据,并不适用于注入的方式
    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(name+","+age+","+birthday);
    }
}

 涉及的标签: <constructor-arg>用来定义构造函数的参数,其属性可大致分为两类:

  1. 寻找要赋值给的字段
    1. index: 指定参数在构造函数参数列表的索引位置
    2. type: 指定参数在构造函数中的数据类型
    3. name: 指定参数在构造函数中的变量名,最常用的属性
  2. 指定赋给字段的值
    1. value: 给基本数据类型和String类型赋值
    2. ref: 给其它Bean类型的字段赋值,ref属性的值应为配置文件中配置的Beanid
<bean id="accountService" class="com.zyp.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="zyp"/>
        <constructor-arg name="age" value="100"/>
        <constructor-arg name="birthday" ref="now"/>
    </bean>
    <bean id="now" class="java.util.Date"></bean>

set 方法注入

顾名思义,就是在类中提供需要注入成员的 set 方法。具体代码如下:

package com.zyp.service.impl;

import com.zyp.service.IAccountService;
import java.util.Date;

public class AccountServiceImpl implements IAccountService {
    private String name;
    private Integer age;
    private Date birthday;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    @Override
    public void saveAccount() {
        System.out.println(name+","+age+","+birthday);
    }
}

涉及的标签: <property>,用来定义要调用set方法的成员. 其主要属性可大致分为两类:

  1. 指定要调用set方法赋值的成员字段
    1. name:要调用set方法赋值的成员字段
  2. 指定赋给字段的值
    1. value: 给基本数据类型和String类型赋值
    2. ref: 给其它Bean类型的字段赋值,ref属性的值应为配置文件中配置的Beanid
<bean id="accountService" class="com.zyp.service.impl.AccountServiceImpl">
        <property name="name" value="zyp"></property>
        <property name="age" value="21"></property>
        <property name="birthday" ref="now"></property>
    </bean>
    <!-- 使用Date类的无参构造函数创建Date对象 -->
    <bean id="now" class="java.util.Date" scope="prototype"></bean>

使用 p 名称空间注入数据(本质还是调用 set 方法)看看就好

此种方式是通过在 xml中导入 p名称空间,使用 p:propertyName 来注入数据,它的本质仍然是调用类中的set 方法实现注入功能,代码如下:

public class AccountServiceImpl implements IAccountService {
    private String name;
    private Integer age;
    private Date birthday;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    @Override
    public void saveAccount() {
        System.out.println(name+","+age+","+birthday);
    }
}
<bean id="accountService"
    class="com.itheima.service.impl.AccountServiceImpl4"
    p:name="test" p:age="21" p:birthday-ref="now"/>

注入集合属性

顾名思义,就是给类中的集合成员传值,它用的也是set方法注入的方式,只不过变量的数据类型都是集合。
我们这里介绍注入数组,List,Set,Map,Properties。具体代码如下:

package com.zyp.service.impl;

import com.zyp.service.IAccountService;
import java.util.*;

public class AccountServiceImpl01 implements IAccountService {
    // 设置集合字段
    private String[] myArray;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;

    // 生成集合字段的set方法
    public void setMyStrs(String[] myArray) {
        this.myArray = myArray;
    }
    public void setMyList(List<String> myList) {
        this.myList = myList;
    }
    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }
    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }
    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    @Override
    public void saveAccount() {
        System.out.println(Arrays.toString(myArray));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);
    }
}
  1. 只有键的结构:

    1. 数组字段: <array>标签表示集合,<value>标签表示集合内的成员.
    2. List字段: <list>标签表示集合,<value>标签表示集合内的成员.
    3. Set字段: <set>标签表示集合,<value>标签表示集合内的成员.

    其中<array>,<list>,<set>标签之间可以互相替换使用.

  2. 键值对的结构:

    1. Map字段: <map>标签表示集合,<entry>标签表示集合内的键值对,其key属性表示键,value属性表示值.
    2. Properties字段: <props>标签表示集合,<prop>标签表示键值对,其key属性表示键,标签内的内容表示值.

    其中<map>,<props>标签之间,<entry>,<prop>标签之间可以互相替换使用

    <bean id="accountService" class="com.zyp.service.impl.AccountServiceImpl01">
    	<property name="myStrs">
    		<array>
    			<value>value1</value>
    			<value>value2</value>
    			<value>value3</value>
    		</array>
    	</property>
    
    	<property name="myList">
    		<list>
    			<value>value1</value>
    			<value>value2</value>
    			<value>value3</value>
    		</list>
    	</property>
    
    	<property name="mySet">
    		<set>
    			<value>value1</value>
    			<value>value2</value>
    			<value>value3</value>
    		</set>
    	</property>
    
    	<property name="myMap">
    		<map>
    			<entry key="key1" value="value1"></entry>
    			<entry key="key2">
    				<value>value2</value>
    			</entry>
    			
    		</map>
    	</property>
    
    	<property name="myProps">
    		<props>
    			<prop key="key1">value1</prop>
    			<prop key="key2">value2</prop>
    		</props>
    	</property>
    </bean>
    

     

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值