不良代码展示-高耦合度代码的例子

 原创文章，如有转载，请注明出处：http://blog.csdn.net/yihui823/article/details/6833131

 

前段时间，看到别人的一段代码，其实没什么逻辑，却做的丰富异常。

代码运行极其不稳定，却无从下手去改动。后来下定决心重写了。

昨晚有空，把原来不良代码抽取出来，供大家参考。

 

package testpj;

import java.util.Timer;
import java.util.TimerTask;

/**
* 高耦合的展示类
* @author yihui823
*/
public class CouplingTester {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {

Connect conn = new Connect();
Listener l = new Listener(conn);
conn.setListener(l);
l.onConnFailed("first connect");

//循环查看Connect的对象
while(true) {
System.out.println(l.getConnect().hashCode());
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
}
}
}

/**
* 模拟一个连接类
*/
private static class Connect extends Thread {

//监听器
private Listener listener;

/**
* 设置监听器
* @param listener 监听器
*/
public void setListener(Listener listener) {
this.listener = listener;
}

/**
* 线程方法，开始进行连接.
*/
public void run() {
//假设连接失败
try {
//保持连接
Thread.sleep(2000);
listener.onConnFailed("Connecting error!");
System.out.println("连接失败.");
} catch (InterruptedException ex) {
}

//假设连接成功
//            System.out.println("连接成功.");
//            while (true) {
//                try {
//                    //保持连接
//                    Thread.sleep(2000);
//                    System.out.println("保持连接.");
//                } catch (InterruptedException ex) {
//                }
//            }
}
}

/**
* 模拟监听器
*/
private static class Listener {

private Connect conn;
private Timer timer = null;

public Listener(Connect conn) {
this.conn = conn;
}

public Connect getConnect() {
return conn;
}

/**
* 连接失败时调用
* @param msg 失败消息
*/
public void onConnFailed(String msg) {

System.out.println("Connect failued : " + msg);
timer = new Timer();
ConnectTask ct = new ConnectTask(timer, conn);
timer.schedule(ct, 3000, 100);
}
}

/**
* 一个连接任务类
*/
public static class ConnectTask extends TimerTask {

private Connect conn;
private Timer timer = null;

public ConnectTask(Timer timer, Connect conn) {
this.timer = timer;
this.conn = conn;
}

public void run() {
if (conn.isAlive()) {
System.out.println(conn.hashCode() + " is still alive.");
if (timer != null) {
timer.cancel();
timer = null;
}
} else {
System.out.println(conn.hashCode() + " is not alive.");
conn = new Connect();
conn.setListener(new Listener(conn));
conn.start();
}
}
}
}

Connect类里的run方法，原来是做连接用的，这里用简单的代码去模拟了。

我们可以看到，这段代码的逻辑，其实是要做一个重连接。

也就是说，当连接断了之后，自动触发onConnFailed事件，然后再次去做连接。

在这个例子里面，Connect里面保存了Listener，而Listener里面又保存了Connect，

ConnectTask里面也保存了Connect。三个类紧紧的耦合在一起，

一个简单的逻辑有两个线程在运作。其结果，是一旦有一次失败了，

则会多一个Timer在后台持续运行，而这个Timer不会被标记停止。

 

这里主要的问题，就是三个类的高耦合。而良好的代码，是需要做到：高内聚，低耦合的。也就是说，类与类之间的关系，越松散越好，最好能相互独立。

 

解耦改动的方法：

1，Connect里面设置Listener。但是，Listener里面，不记录Connect实例。

2，在onConnFailed事件中，只是做启动连接的动作，不要启动线程。再次连接之前，暂停一段时间即可。

 

具体代码就不贴出来了。重点就是：不要高耦合。