Java实现Qt的SIGNAL-SLOT机制

SIGNAL-SLOT是Qt的一大特色，使用起来十分方便。在传统的AWT和Swing编程中，我们都是为要在

监听的对象上添加Listener监听器。被监听对象中保存有Listener的列表，当相关事件发生时，被监听
对象会通知所有Listener。而在Qt中，我们只需通过connect方法连接两个对象上的方法就可以了，非常
方便、优雅地实现了传统的观察者Observer模式。

Qt是如何办到的呢？对于发出SIGNAL的对象，我们需要在其头文件定义中声明Q_Object宏，之后Qt的
预处理器MOC会为我们自动添加上相应的代码来实现SIGNAL-SLOT机制。这与AspectJ自定义了Javac
编译器很类似，都是通过增强编译器来自动添加相应的代码。

增强编译或增加预处理太复杂，怎样能够简单的实现这种机制呢？首先我们实现一个类似的QObject类，
需要发射SIGNAL的类都要继承它。在QObject类中，我们自动为其子类提供监听器列表，查找SLOT方法，
信号发射等功能。

QObject.java

1.在连接方法中，我们将信号和新建的ReceiverSlot类保存到Map中，从而将它们关联起来。

public static void connect(QObject sender, String signal, Object receiver, String slot) {
if (sender.signalSlotMap == null)
sender.signalSlotMap = new HashMap<String, List<ReceiverSlot>>();

List<ReceiverSlot> slotList = sender.signalSlotMap.get(signal);
if (slotList == null) {
slotList = new LinkedList<ReceiverSlot>();
sender.signalSlotMap.put(signal, slotList);
}
slotList.add(createReceiverSlot(receiver, slot));
}

static class ReceiverSlot {
Object receiver;
Method slot;
Object[] args;
}

2.在创建ReceiverSlot时，我们解析SLOT方法名，如将slot(String,String)解析为方法slot，参数两个String。
如果解析失败我们就认为该SLOT仍是一个信号，也就是SIGNAL-SIGNAL的连接。这种情况下，我们需要
传递调用的不是receiver的SLOT方法，而是emit方法继续发射信号。

private static ReceiverSlot createReceiverSlot(Object receiver, String slot) {
ReceiverSlot receiverSlot = new ReceiverSlot();
receiverSlot.receiver = receiver;

Pattern pattern = Pattern.compile("(\\w+)\\(([\\w+,]*)\\)");
Matcher matcher = pattern.matcher(slot);
if (matcher.matches() && matcher.groupCount() == 2) {
// 1.Connect SIGNAL to SLOT
try {
String methodName = matcher.group(1);
String argStr = matcher.group(2);
ArrayList<String> argList = new ArrayList<String>();

pattern = Pattern.compile("\\w+");
matcher = pattern.matcher(argStr);
while (matcher.find())
argList.add(matcher.group());
String[] arguments = argList.toArray(new String[0]);

receiverSlot.slot = findMethod(receiver, methodName, arguments);
receiverSlot.args = new Object[0];
}
catch (Exception e) {
e.printStackTrace();
}
}
else {
// 2.Connect SIGNAL to SIGNAL
if (receiver instanceof QObject) {
receiverSlot.slot = emitMethod;
receiverSlot.args = new Object[] { slot };
}
}

return receiverSlot;
}

private static Method emitMethod;

protected Map<String, List<ReceiverSlot>> signalSlotMap;

static {
try {
emitMethod = QObject.class.getDeclaredMethod("emit", String.class, Object[].class);
} catch (Exception e) {
e.printStackTrace();
}
}

3.解析后，如果是SIGNAL-SLOT的连接，那我我们根据方法名和参数找到该方法，准备反射调用。

private static Method findMethod(Object receiver, String methodName, String[] arguments)
throws NoSuchMethodException {

Method slotMethod = null;

if (arguments.length == 0)
slotMethod = receiver.getClass().getMethod(methodName, new Class[0]);
else {
for (Method method : receiver.getClass().getMethods()) {

// 1.Check method name
if (!method.getName().equals(methodName))
continue;

// 2.Check parameter number
Class<?>[] paramTypes = method.getParameterTypes();
if (paramTypes.length != arguments.length)
continue;

// 3.Check parameter type
boolean isMatch = true;
for (int i = 0; i < paramTypes.length; i++) {
if (!paramTypes[i].getSimpleName().equals(arguments[i])) {
isMatch = false;
break;
}
}
if (isMatch) {
slotMethod = method;
break;
}
}

if (slotMethod == null)
throw new NoSuchMethodException("Cannot find method[" + methodName +
"] with parameters: " + Arrays.toString(arguments));
}

return slotMethod;
}

4.发射信号时，我们取到所有与该SIGNAL关联的ReceiverSlot类，逐个发射信号。

protected void emit(String signal, Object... args) {
System.out.println(getClass().getSimpleName() + " emit signal " + signal);

if (signalSlotMap == null)
return;

List<ReceiverSlot> slotList = signalSlotMap.get(signal);
if (slotList == null || slotList.isEmpty())
return;

for (ReceiverSlot objSlot : slotList) {
try {
if (objSlot.slot == emitMethod)
objSlot.slot.invoke(objSlot.receiver, objSlot.args[0], args);
else
objSlot.slot.invoke(objSlot.receiver, args);
}
catch (Exception e) {
e.printStackTrace();
}
}
}

之后，我们实现一个它的子类QWidget，将常用的Swing控件都封装在QWidget的子类中，为这些控件提供
常见的预定义的SIGNAL，像Qt中的clicked和returnPressed。

QWidget.java

public class QWidget<T extends JComponent> extends QObject implements QSwing<T> {

protected T widget;

public QWidget(Class<T> clazz) {
try {
widget = clazz.newInstance();
}
catch (Exception e) {
e.printStackTrace();
}
}

@Override
public T getSwingWidget() {
return this.widget;
}

}

以下是封装了JButton和JTextField的QWidget子类。

QPushButton.java

public class QPushButton extends QWidget<JButton> {

public static final String CLICKED = "clicked";

public QPushButton(String text) {
super(JButton.class);

widget.setText(text);
widget.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
emit(CLICKED);
}
});
}

}

QLineEdit.java

public class QLineEdit extends QWidget<JTextField> {

public static final String RETURN_PRESSED = "returnPressed";

public QLineEdit() {
super(JTextField.class);

widget.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
emit(RETURN_PRESSED);
}
});
}

}

下面我们来写个测试类实验下Java版的SIGNAL-SLOT机制，依旧是之前的浏览器的例子。

AddressBar.java

public class AddressBar extends QWidget<JPanel> {

/**
* SIGNAL
*/
public static final String NEW_BUTTON_CLICKED = "newButtonClicked";
public static final String GO_TO_ADDRESS = "goToAddress(String,String)";

/**
* SLOT
*/
public static final String HANDLE_GO_TO_ADDRESS = "handleGoToAddress()";

private QPushButton newButton;
private QLineEdit addressEdit;
private QPushButton goButton;

public AddressBar() {
super(JPanel.class);

// 1.Create widget
newButton = new QPushButton("New");
addressEdit = new QLineEdit();
goButton = new QPushButton("Go");

// 2.Set property
addressEdit.getSwingWidget().setColumns(10);

// 3.Connect signal-slot
connect(newButton, QPushButton.CLICKED, this, NEW_BUTTON_CLICKED);
connect(addressEdit, QLineEdit.RETURN_PRESSED, this, HANDLE_GO_TO_ADDRESS);
connect(goButton, QPushButton.CLICKED, this, HANDLE_GO_TO_ADDRESS);

// 4.Add to layout
getSwingWidget().add(newButton.getSwingWidget());
getSwingWidget().add(addressEdit.getSwingWidget());
getSwingWidget().add(goButton.getSwingWidget());
}

public void handleGoToAddress() {
emit(GO_TO_ADDRESS, addressEdit.getSwingWidget().getText(), "test string");
}

}

TabBar.java

public class TabBar extends JTabbedPane {

/**
* SLOT
*/
public static final String HANDLE_NEW_TAB = "handleNewTab()";
public static final String HANDLE_GO_TO_SITE = "goToSite(String,String)";

public TabBar() {
handleNewTab();
}

public void handleNewTab() {
WebView tab = new WebView();
add("blank", tab);
}

public void goToSite(String url, String testStr) {
System.out.println("Receive url: " + url + ", " + testStr);

WebView tab = (WebView) getSelectedComponent();
tab.load(url);
}

}

MainWindow.java

public class MainWindow extends JFrame {

public static void main(String[] args) {
JFrame window = new MainWindow();
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
window.setSize(320, 340);
window.setVisible(true);
}

public MainWindow() {
// 1.Create widget
AddressBar addressBar = new AddressBar();
TabBar tabBar = new TabBar();

// 2.Set property

// 3.Connect signal-slot
QObject.connect(addressBar, AddressBar.NEW_BUTTON_CLICKED, tabBar, TabBar.HANDLE_NEW_TAB);
QObject.connect(addressBar, AddressBar.GO_TO_ADDRESS, tabBar, TabBar.HANDLE_GO_TO_SITE);

// 4.Add to layout
GridBagLayout layout = new GridBagLayout();
setLayout(layout);
GridBagConstraints grid = new GridBagConstraints();
grid.fill = GridBagConstraints.BOTH;
grid.gridx = grid.gridy = 0;
grid.weightx = 1.0;
grid.weighty = 0.1;
add(addressBar.getSwingWidget(), grid);
grid.fill = GridBagConstraints.BOTH;
grid.gridx = 0;
grid.gridy = 1;
grid.weightx = 1.0;
grid.weighty = 0.9;
add(tabBar, grid);
}

}

@SuppressWarnings("serial")
class WebView extends JEditorPane {

public WebView() {
setEditable(false);
}

public void load(final String url) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
try {
WebView.this.setPage(url);
} catch (IOException e) {
e.printStackTrace();
}
}
});
}

}

测试一下吧，运行起来的效果就是这样。



新建Tab页和前往该地址事件都可以成功地从AddressBar传递到TabBar。怎么样，这种Java版的
SIGNAL-SLOT是不是很方便。多开拓自己的视野，借鉴优秀的思想，我们才能做出更好的设计！
希望你喜欢本文。