程序解耦

什么是程序耦合

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关
系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。
在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。
例子：业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。

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

如果此时没有持久层实现类，编译将不能通过。这种编译期依赖关系，应该在我们开发中杜绝。我们需要优化代码解决。

解耦的思路

工厂模式解耦
- 在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂。
- 工厂模式简单解释：
  - 一般我们程序需要利用资源，都是new一个对象出来。
  - 但是工厂模式不是，当我们需要获取对象时，同时跟工厂要，由工厂为我们查找或者创建对象。（这种被动接收的方式获取对象的思想就是控制反转）
控制反转
- 把创建对象的权力交给框架，是框架的重要特征。
- 包括依赖注入和依赖查找
- 它的作用主要是消减程序的耦合（解除代码中的依赖）

bean.properties

accountService=com.lwb.service.impl.AccountServiceImpl
accountDao=com.lwb.dao.impl.AccountDaoImpl

BeanFactory.java

/**
 * 一个创建Bean对象的工厂
 *
 * Bean：在计算机英语中，有可重用组件的含义。
 * JavaBean：用java语言编写的可重用组件。
 *      javabean >  实体类
 *
 *   它就是创建我们的service和dao对象的。
 *
 *   第一个：需要一个配置文件来配置我们的service和dao
 *           配置的内容：唯一标识=全限定类名（key=value)
 *   第二个：通过读取配置文件中配置的内容，反射创建对象
 *
 *   我的配置文件可以是xml也可以是properties
 */
public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;

    //定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    private static Map<String,Object> beans;

    //使用静态代码块为Properties对象赋值
    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

    /**
     * 根据bean的名称获取对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }

    /**
     * 根据Bean的名称获取bean对象
     * @param beanName
     * @return

    public static Object getBean(String beanName){
        Object bean = null;
        try {
            String beanPath = props.getProperty(beanName);
//            System.out.println(beanPath);
            bean = Class.forName(beanPath).newInstance();//每次都会调用默认构造函数创建对象
        }catch (Exception e){
            e.printStackTrace();
        }
        return bean;
    }*/
}

控制反转IOC

前期准备环境搭建

准备 spring 的开发包
- 官网：http://spring.io/
- 下载地址：
  - http://repo.springsource.org/libs-release-local/org/springframework/spring
- 解压:(Spring 目录结构:)
  - docs :API 和开发规范.
  - libs :jar 包和源码.
  - schema :约束.
创建业务层接口和实现类
创建持久层接口和实现类

基于 XML 的配置

在类的根路径下创建的一个任意名称的 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>

让 spring 管理资源，在配置文件中配置 service 和dao，

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

测试配置

//1.使用 ApplicationContext 接口，就是在获取 spring 容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.根据 bean 的 id 获取对象
IAccountService aService = (IAccountService) ac.getBean("accountService");
System.out.println(aService);
IAccountDao aDao = (IAccountDao) ac.getBean("accountDao");
System.out.println(aDao);

Spring基于XML的IOC的细节

工厂类的结构图
- BeanFactory和ApplicationContext 的区别
  - BeanFactory 才是 Spring 容器中的顶层接口。
  - ApplicationContext 是它的子接口
  - 最大的区别是创建时间的结点不同
    - ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
    - BeanFactory：什么使用什么时候创建对象。
- ApplicationContext 接口的实现类
  - ClassPathXmlApplicationContext ：它是从类的根路径下加载配置文件( 推荐使用)
  - FileSystemXmlApplicationContext ：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
  - AnnotationConfigApplicationContext：当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
bean标签详解
- 作用：
  - 用于配置对象让 spring 来创建的。
  - 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
- 属性：
  - id：给对象在容器中提供一个唯一标识。用于获取对象。
  - class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
  - scope：指定对象的作用范围。
    - singleton :默认值，单例的.
      - 一个应用只有一个对象的实例。它的作用范围就是整个引用。
      - 生命周期：
        
        对象出生：当应用加载，创建容器时，对象就被创建了。
        
        对象活着：只要容器在，对象一直活着。
        
        对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
    - prototype :多例的.
      - 每次访问对象时，都会重新创建对象实例。
      - 生命周期：
        
        对象出生：当使用对象时，创建新的对象实例。
        
        对象活着：只要对象在使用中，就一直活着。
        
        对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。
    - request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
    - session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
    - global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.
  - init-method：指定类中的初始化方法名称。
  - destroy-method：指定类中销毁方法名称。
实例化 Bean 的三种方式

第一种方式：使用默认无参构造函数
第二种方式：spring 管理静态工厂-使用静态工厂的方法创建对象

//模拟一个静态工厂，创建业务层实现类
public class StaticFactory {
	public static IAccountService createAccountService(){
		return new AccountServiceImpl();
	}
}
<!-- 此种方式是:
使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
id 属性：指定 bean 的 id，用于从容器中获取
class 属性：指定静态工厂的全限定类名
factory-method 属性：指定生产对象的静态方法
-->
<bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="createAccountService"></bean>

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

//模拟一个实例工厂，创建业务层实现类
//此工厂创建对象，必须现有工厂实例对象，再调用方法
public class InstanceFactory {
	public IAccountService createAccountService(){
		return new AccountServiceImpl();
	}
}
<!-- 此种方式是：
先把工厂的创建交给 spring 来管理。
然后在使用工厂的 bean 来调用里面的方法
factory-bean 属性：用于指定实例工厂 bean 的 id。
factory-method 属性：用于指定实例工厂中创建对象的方法。
-->
<bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instancFactory" factory-method="createAccountService"></bean>

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

构造函数注入：就是使用类中的构造函数，给成员变量赋值。

	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;
	}
	@Override
	public void saveAccount() {
		System.out.println(name+","+age+","+birthday);
	}
}
<!-- 使用构造函数的方式，给 service 中的属性传值
要求：
类中需要提供一个对应参数列表的构造函数。
涉及的标签：
constructor-arg
属性：
index:指定参数在构造函数参数列表的索引位置
type:指定参数在构造函数中的数据类型
name:指定参数在构造函数中的名称 用这个找给谁赋值
=======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
value:它能赋的值是基本数据类型和 String 类型
ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean
-->
<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>

set 方法注入：就是在类中提供需要注入成员的 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 中的属性传值：使用 set 方法的方式
涉及的标签：
property
属性：
name：找的是类中 set 方法后面的部分
ref：给属性赋值是其他 bean 类型的
value：给属性赋值是基本数据类型和 string 类型的
实际开发中，此种方式用的较多。
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<property name="name" value="test"></property>
<property name="age" value="21"></property>
<property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

注入集合属性：给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。

public class AccountServiceImpl implements IAccountService {
	private String[] myStrs;
	private List<String> myList;
	private Set<String> mySet;
	private Map<String,String> myMap;
	private Properties myProps;
	public void setMyStrs(String[] myStrs) {
	this.myStrs = myStrs;
	}
	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;
	}
}
<!-- 注入集合数据
List 结构的：
array,list,set
Map 结构的
map,entry,props,prop
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
	<!-- 在注入集合数据时，只要结构相同，标签可以互换 -->
	<!-- 给数组注入数据 -->
	<property name="myStrs">
		<set>
			<value>AAA</value>
			<value>BBB</value>
			<value>CCC</value>
		</set>
	</property>
	<!-- 注入 list 集合数据 -->
	<property name="myList">
		<array>
			<value>AAA</value>
			<value>BBB</value>
			<value>CCC</value>
		</array>
	</property>
	<!-- 注入 set 集合数据 -->
	<property name="mySet">
		<list>
			<value>AAA</value>
			<value>BBB</value>
			<value>CCC</value>
		</list>
	</property>
	<!-- 注入 Map 数据 -->
	<property name="myMap">
		<props>
			<prop key="testA">aaa</prop>
			<prop key="testB">bbb</prop>
		</props>
	</property>
	<!-- 注入 properties 数据 -->
	<property name="myProps">
		<map>
			<entry key="testA" value="aaa"></entry>
			<entry key="testB">
				<value>bbb</value>
			</entry>
		</map>
	</property>
</bean>

Spring学习笔记（八）程序解耦和IOC详解

目录

程序解耦

什么是程序耦合

解耦的思路

控制反转IOC

前期准备环境搭建

基于 XML 的配置

Spring基于XML的IOC的细节

猜你喜欢