程序的耦合和解耦
程序的耦合和解耦
耦合
指的是程序间的依赖关系，包括类之间的依赖和方法间的依赖
解耦
降低程序间的依赖关系，实际开发中应该做到编译器不依赖，运行时才依赖
解耦的思路
-
使用反射来创建对象，而避免使用new关键字
-
通过读取配置文件来获取要创建的对象的全限定类名
举例
下面请看一个简单的例子，模拟账号保存
该项目的文件结构如图
业务层的接口及其实现类：
package com.itheima.service;
/**
* @Author:Zzq
* @Description:账户的业务层的接口
* @Date:2020/6/13
* @Time:15:50
*/
public interface iAccountService {
/**
*@Author:Zzq
*@Description:模拟保存账户
*@Date:2020/6/13
*@Param: * @param null
*/
void saveAccount();
}
package com.itheima.service.impl;
import com.itheima.factory.BeanFactory;
import com.itheima.mapper.iAccountMapper;
import com.itheima.service.iAccountService;
/**
* @Author:Zzq
* @Description:账号的业务实现类
* @Date:2020/6/13
* @Time:15:53
*/
public class AccountServiceImpl implements iAccountService {
private iAccountMapper accountMapper = new AccountMapperImpl();
@Override
public void saveAccount() {
accountMapper.saveAccount();
}
}
持久层的接口及其实现类
package com.itheima.mapper;
/**
* @Author:Zzq
* @Description:账户的持久层接口
* @Date:2020/6/13
* @Time:16:08
*/
public interface iAccountMapper {
void saveAccount();
}
package com.itheima.mapper.impl;
import com.itheima.mapper.iAccountMapper;
/**
* @Author:Zzq
* @Description:账户的持久层实现类
* @Date:2020/6/13
* @Time:16:10
*/
public class AccountMapperImpl implements iAccountMapper {
public void saveAccount(){
System.out.println("保存了");
}
}
最后是main函数，也是其表现层
package com.itheima.ui;
import com.itheima.factory.BeanFactory;
import com.itheima.service.iAccountService;
/**
* @Author:Zzq
* @Description:模拟一个表现层，用于调用业务
* @Date:2020/6/13
* @Time:22:28
*/
public class Client {
public static void main(String[] args) {
AccountServiceImpl as = new AccountServiceImpl();
as.saveAccount();
}
}
从代码中可以看到，各个层次是相互依赖，层层套用，这样就称之为高耦合，各个代码块之间独立性较差，下面就按照解耦的思路来尽可能降低耦合，如下：
1.在项目文件中新建一个factory包，新建一个BeanFactory类来建立一个bean工厂来创建我们的service和mapper对象，并写好Bean.properties配置文件
package com.itheima.factory;
import java.io.InputStream;
import java.util.Properties;
/**
* @Author:Zzq
* @Description:是一个创建bean对象的工厂
*
* Bean：在计算机英语中，有可重用组件的含义。
* JavaBean：用Java编写的可重用组件。
* Java >> 实体类
* 它就是创建我们的service和mapper对象的。
* 1.需要一个配置文件来配置我们的service和mapper
* 配置的内容：唯一标识 = 全限定类名（key = value）
* 2.通过读取配置文件的配置内容，反射创建对象
*
* 配置文件可以是xml也可以是properties
* @Date:2020/6/13
* @Time:22:36
*/
public class BeanFactory {
//定义一个properties对象
private static Properties props;
//使用静态代码块为Properties对象赋值
static {
try {
//实例化对象
props = new Properties();
//获取properties文件的流对象
InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
props.load(in);
}catch (Exception e) {
throw new ExceptionInInitializerError("初始化properties失败");
}
}
/**
*@Author:Zzq
*@Description:根据bean的名称获取bean对象
*@Date:2020/6/13
*@Param: * @param null
*/
public static Object getBean(String beanName){
Object bean = null;
try {
String beanPath = props.getProperty(beanName);
bean = Class.forName(beanPath).newInstance();
}catch (Exception e){
e.printStackTrace();
}
return bean;
}
}
accountService = com.itheima.service.impl.AccountServiceImpl
accountMapper = com.itheima.mapper.impl.AccountMapperImpl
2.修改Client.java和AccountServiceImpl.java代码，使用反射来创建对象
package com.itheima.ui;
import com.itheima.factory.BeanFactory;
import com.itheima.service.iAccountService;
/**
* @Author:Zzq
* @Description:模拟一个表现层，用于调用业务
* @Date:2020/6/13
* @Time:22:28
*/
public class Client {
public static void main(String[] args) {
iAccountService as = (iAccountService) BeanFactory.getBean("accountService");
as.saveAccount();
}
}
package com.itheima.service.impl;
import com.itheima.factory.BeanFactory;
import com.itheima.mapper.iAccountMapper;
import com.itheima.service.iAccountService;
/**
* @Author:Zzq
* @Description:账号的业务实现类
* @Date:2020/6/13
* @Time:15:53
*/
public class AccountServiceImpl implements iAccountService {
private iAccountMapper accountMapper = (iAccountMapper) BeanFactory.getBean("accountMapper");
@Override
public void saveAccount() {
accountMapper.saveAccount();
}
}
以上就是解耦的过程，在使用了BeanFactory了之后，就算是删除掉了service或mapper文件，编译器也不会报错，有人看到这里肯定会说：啊，你这不是脱裤子放屁嘛，明明几个类就能解决的问题非要弄个工厂？其实是这个例子太高简单，还不足以看出低耦合的好处，在以后比较大型的开发中，如果有新的需求要加入，我们就可以只添加几个类就能完成，而不用重新考虑整个程序，避免牵一发而动全身。
