程序间耦合
1 什么是程序的耦合
耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关数据传递关系。模块间联系越多,其耦合性越强,同时表明其独立性越差( 降低耦合性,可以提高其独立耦合性存在于各个领域,而非软件设计中独有的,但是我们只讨论软件工程中的耦合。
在软件工程中,耦合指的就是就是对象之间的依赖性。对象之间的耦合越高,维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。
它有如下分类:
(1)内容耦合。当一个模块直接修改或操作另一个模块的数据时,或一个模块不通过正常入口而转入另一个模块时,这样的耦合被称为内容耦合。内容耦合是最高程度的耦合,应该避免使用之。
(2)公共耦合。两个或两个以上的模块共同引用一个全局数据项,这种耦合被称为公共耦合。在具有大量公共耦合的结构中,确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
(3)外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构,而且不是通过参数表传递该全局变量的信息,则称之为外部耦合。
(4)控制耦合 。一个模块通过接口向另一个模块传递一个控制信号,接受信号的模块根据信号值而进行适当的动作,这种耦合被称为控制耦合。
(5)标记耦合 。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数,那么称模块 B 和 C 之间存在一个标记耦合。
(6)数据耦合。模块之间通过参数来传递数据,那么被称为数据耦合。数据耦合是最低的一种耦合形系统中一般都存在这种类型的耦合,因为为了完成一些有意义的功能,往往需要将某些模块的输出数据作为另一些模块的输入数据。
(7)非直接耦合 。两个模块之间没有直接关系,它们之间的联系完全是通过主模块的控制和调用来实。
总结:
耦合是影响软件复杂程度和设计质量的一个重要因素,在设计上我们应采用以下原则:如果模块间必须存在耦合,就尽量使用数据耦合,少用控制耦合,限制公共耦合的范围,尽量避免使用内容耦合。
内聚与耦合
内聚标志一个模块内各个元素彼此结合的紧密程度,它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系,一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量,耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合,高内聚。就是同一个模块内的各个元素之间要高度紧密,但是各个模块之间的相互依存度却要不那么紧密。
内聚和耦合是密切相关的,同其他模块存在高耦合的模块意味着低内聚,而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时,应力争做到高内聚,低耦合。
2 程序的耦合案例
首先创建数据库以及表结构的代码如下:
CREATE DATABASE spring; -- 创建spring数据库
use spring; -- 使用spring数据库
-- 创建account表
create table account(
id int primary key auto_increment,
name varchar(40),
money float
)character set utf8 collate utf8_general_ci;
-- 添加数据
insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);
-- 查询数据
SELECT * FROM account;
1.打开IDEA工具如图所示的界面,点击Create New Project。
2.选择Maven工程和JDK的版本,如图所示:并点击Next。
3.填写项目名称和保存的地址,点击Finish。如图所示:
4.导入相应的依赖jar包的代码如下:
<?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>com.txw</groupId>
<artifactId>spring_01jdbc</artifactId>
<version>1.0-SNAPSHOT</version>
<!--打包的方式-->
<packaging>jar</packaging>
<dependencies>
<!--导入MySQL的依赖坐标-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</version>
</dependency>
</project>
5.编写测试的代码如下:
package com.txw.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* 程序的耦合
* 耦合:程序间的依赖关系
* 包括:
* 类之间的依赖
* 方法间的依赖
* 解耦:
* 降低程序间的依赖关系
* 实际开发中:
* 应该做到:编译期不依赖,运行时才依赖。
* 解耦的思路:
* 第一步:使用反射来创建对象,而避免使用new关键字。
* 第二步:通过读取配置文件来获取要创建的对象全限定类名
*/
@SuppressWarnings("all") // 注解警告信息
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.获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/spring?useSSL=false","root","123456");
// 3.获取操作数据库的预处理对象
PreparedStatement pstm = conn.prepareStatement("select * from account");
// 4.执行SQL,得到结果集
ResultSet rs = pstm.executeQuery();
// 5.遍历结果集
while(rs.next()){
System.out.println(rs.getString("name"));
}
// 6.释放资源
rs.close();
pstm.close();
conn.close();
}
}
把mysql依赖jar包注释如图所示:
运行结果如图所示:说明编译的时候,就报错误!也是程序的耦合。
3 曾经代码中的问题分析
1.打开IDEA工具如图所示的界面,点击Create New Project。
2.选择Maven工程和JDK的版本,如图所示:并点击Next。
3.填写项目名称和保存的地址,点击Finish。如图所示:
4.导入相应的依赖jar包的代码如下:
<?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>com.txw</groupId>
<artifactId>spring_02factory</artifactId>
<version>1.0-SNAPSHOT</version>
<!--打包的方式-->
<packaging>jar</packaging>
</project>
5.编写账户业务层的接口的代码如下:
package com.txw.service;
/**
* 账户业务层的接口
*/
@SuppressWarnings("all") // 注解警告信息
public interface AccountService {
/**
* 模拟保存账户
*/
void saveAccount();
}
6.编写账户业务层的接口实现类的代码如下:
package com.txw.service.impl;
import com.txw.dao.AccountDao;
import com.txw.factory.BeanFactory;
import com.txw.service.AccountService;
/**
* 账户的业务层实现类
*/
@SuppressWarnings("all") // 注解警告信息
public class AccountServiceImpl implements AccountService {
private IAccountDao accountDao = new AccountDaoImpl();
public void saveAccount(){
accountDao.saveAccount();
}
}
7.编写账户的持久层接口的代码如下:
package com.txw.dao;
/**
* 账户的持久层接口
*/
@SuppressWarnings("all") // 注解警告信息
public interface AccountDao {
/**
* 模拟保存账户
*/
void saveAccount();
}
8.编写账户的持久层接口实现类的代码如下:
package com.txw.dao.impl;
import com.txw.dao.AccountDao;
/**
* 账户的持久层实现类
*/
@SuppressWarnings("all") // 注解警告信息
public class AccountDaoImpl implements AccountDao {
public void saveAccount(){
System.out.println("保存了账户");
}
}
9.编写测试的代码如下:
package com.txw.ui;
/**
* 模拟一个表现层,用于调用业务层
*/
public class Client {
public static void main(String[] args) {
AccountService as = new AccountServiceImpl();
as.saveAccount();
}
}
业务层调用持久层,并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类,编译将不能通过。这种编译期依赖关系,应该在我们开发中杜绝。我们需要优化代码解决。
4 编写工厂类和配置文件
1.编写一个创建Bean对象的工厂的代码如下:
package com.txw.factory;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
* 一个创建Bean对象的工厂
* Bean:在计算机英语中,有可重用组件的含义。
* JavaBean:用java语言编写的可重用组件。
* javabean > 实体类
* 它就是创建我们的service和dao对象的。
* 第一个:需要一个配置文件来配置我们的service和dao
* 配置的内容:唯一标识=全限定类名(key=value)
* 第二个:通过读取配置文件中配置的内容,反射创建对象
* 我的配置文件可以是xml也可以是properties
*/
@SuppressWarnings("all") // 注解警告信息
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;
}*/
}
2.在resources目录下创建bean.properties的代码如下:
accountService=com.txw.service.impl.AccountServiceImpl
accountDao=com.txw.dao.impl.AccountDaoImpl
3.修改账户的业务层实现类的代码如下:
package com.txw.service.impl;
import com.txw.dao.AccountDao;
import com.txw.factory.BeanFactory;
import com.txw.service.AccountService;
/**
* 账户的业务层实现类
*/
@SuppressWarnings("all") // 注解警告信息
public class AccountServiceImpl implements AccountService {
private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");
// private int i = 1;
public void saveAccount(){
int i = 1;
accountDao.saveAccount();
System.out.println(i);
i++;
}
}
4.编写测试代码如下:
package com.txw.ui;
import com.txw.factory.BeanFactory;
import com.txw.service.AccountService;
/**
* 模拟一个表现层,用于调用业务层
*/
public class Client {
public static void main(String[] args) {
for(int i=0;i<5;i++) {
AccountService as = (AccountService) BeanFactory.getBean("accountService");
System.out.println(as);
as.saveAccount();
}
}
}
运行结果如图所示:说明是单例的!
在实际开发中我们可以把三层的对象都使用配置文件配置起来,当启动服务器应用加载的时候,让一个类中的方法通过读取配置文件,把这些对象创建出来并存起来。在接下来的使用的时候,直接拿过来用就好了。
那么,这个读取配置文件,创建和获取三层对象的类就是工厂。