我发现在“真正的Swing生活”中最难掌握的设计模式之一是MVC模式。我浏览了该站点上的很多文章，讨论了该模式，但是我仍然不了解如何在Java Swing应用程序中利用该模式。
假设我有一个JFrame，其中包含一个表，几个文本字段和一些按钮。我可能会使用TableModel将JTable与基础数据模型“桥接”。但是，负责清除字段，验证字段，锁定字段以及按钮操作的所有函数通常都直接在JFrame中。但是，这不是将模式的Controller和View混合了吗？
据我所知，当查看JTable（和模型）时，我设法“正确地”实现了MVC模式，但是当我整体查看整个JFrame时，事情就变得混乱了。
我真的很想听听其他人对此的看法。当需要使用MVC模式向用户显示表格，几个字段和一些按钮时，如何处理？
Answers:
我强烈推荐给MVC的书籍是Freeman和Freeman撰写的“ Head First Design Patterns”。他们对MVC有高度全面的解释。
简要总结
您就是用户-您与视图进行交互。视图是您进入模型的窗口。当您对视图执行某项操作（例如单击“播放”按钮）时，视图将告诉控制器您做了什么。处理该任务是控制器的工作。
控制器要求模型更改其状态。控制器执行您的动作并解释它们。如果单击按钮，控制器的工作就是弄清楚这意味着什么，以及如何基于该操作来操纵模型。
控制器也可能要求视图改变。当控制器从视图接收到一个动作时，它可能需要告诉视图作为结果进行更改。例如，控制器可以启用或禁用界面中的某些按钮或菜单项。
当状态改变时，模型会通知视图。当模型中的某些内容发生更改时，根据您执行的某些操作（例如单击按钮）或其他内部更改（例如播放列表中的下一首歌曲已开始），模型将通知视图其状态已更改。
视图向模型询问状态。该视图直接从模型获取其显示的状态。例如，当模型通知视图新歌曲已开始播放时，该视图向模型请求歌曲名称并显示它。由于控制器请求对视图进行某些更改，因此视图可能还会向模型询问状态。
来源（如果您想知道“奶油控制器”是什么，请考虑一个奥利奥饼干，其中控制器是奶油中心，视图是顶部饼干，模型是底部饼干。）
嗯，如果您有兴趣，可以从这里下载有关MVC模式的相当有趣的歌曲！
Swing编程可能会遇到的一个问题是将SwingWorker和EventDispatch线程与MVC模式合并。根据您的程序，您的视图或控制器可能必须扩展SwingWorker并覆盖doInBackground()放置资源密集型逻辑的方法。这可以很容易地与典型的MVC模式融合，这是Swing应用程序的典型特征。
编辑＃1：
此外，将MVC视为各种模式的组合很重要。例如，您的模型可以使用Observer模式实现（要求将View注册为模型的观察者），而控制器则可以使用Strategy模式。
编辑＃2：
另外，我想特别回答您的问题。您应该在视图中显示表格按钮等，这显然会实现一个ActionListener。在您的actionPerformed()方法中，您将检测到事件并将其发送到控制器中的相关方法（请记住，该视图包含对控制器的引用）。因此，当单击按钮时，视图将检测到事件，并将其发送到控制器的方法，控制器可能会直接要求视图禁用按钮或其他操作。接下来，控制器将与模型进行交互并修改模型（模型将主要具有getter和setter方法，以及一些其他方法来注册和通知观察者，依此类推）。修改模型后，它将立即调用已注册观察者的更新（在您的情况下，将是视图）。因此，视图现在将自行更新。
=D
我不认为视图是模型数据更改时会通知该视图的想法。我会将该功能委托给控制器。在这种情况下，如果更改应用程序逻辑，则无需干预视图的代码。该视图的任务仅适用于应用程序组件+布局，仅此而已。摇摆式布局已经是一项繁琐的任务，为什么要让它干扰应用程序逻辑呢？
我对MVC的想法（到目前为止，我正在与之合作）是：
风景 ：
就像我说的那样，创建视图已经很冗长，因此只需创建自己的实现即可：)
interface View{
JTextField getTxtFirstName();
JTextField getTxtLastName();
JTextField getTxtAddress();
}
出于可测试性目的，最好将这三个接口连接起来。我只提供了Model和Controller的实现。
该模型 ：
public class MyImplementationOfModel implements Model{
...
private SwingPropertyChangeSupport propChangeFirer;
private String address;
private String firstName;
private String lastName;
public MyImplementationOfModel() {
propChangeFirer = new SwingPropertyChangeSupport(this);
}
public void addListener(PropertyChangeListener prop) {
propChangeFirer.addPropertyChangeListener(prop);
}
public void setAddress(String address){
String oldVal = this.address;
this.address = address;
//after executing this, the controller will be notified that the new address has been set. Its then the controller's
//task to decide what to do when the address in the model has changed. Ideally, the controller will update the view about this
propChangeFirer.firePropertyChange("address", oldVal, address);
}
...
//some other setters for other properties & code for database interaction
...
}
控制器：
public class MyImplementationOfController implements PropertyChangeListener, Controller{
private View view;
private Model model;
public MyImplementationOfController(View view, Model model){
this.view = view;
this.model = model;
//register the controller as the listener of the model
this.model.addListener(this);
setUpViewEvents();
}
//code for setting the actions to be performed when the user interacts to the view.
private void setUpViewEvents(){
view.getBtnClear().setAction(new AbstractAction("Clear") {
@Override
public void actionPerformed(ActionEvent arg0) {
model.setFirstName("");
model.setLastName("");
model.setAddress("");
}
});
view.getBtnSave().setAction(new AbstractAction("Save") {
@Override
public void actionPerformed(ActionEvent arg0) {
...
//validate etc.
...
model.setFirstName(view.getTxtFName().getText());
model.setLastName(view.getTxtLName().getText());
model.setAddress(view.getTxtAddress().getText());
model.save();
}
});
}
public void propertyChange(PropertyChangeEvent evt){
String propName = evt.getPropertyName();
Object newVal = evt.getNewValue();
if("address".equalsIgnoreCase(propName)){
view.getTxtAddress().setText((String)newVal);
}
//else if property (name) that fired the change event is first name property
//else if property (name) that fired the change event is last name property
}
}
安装MVC的Main：
public class Main{
public static void main(String[] args){
View view = new YourImplementationOfView();
Model model = new MyImplementationOfModel();
...
//create jframe
//frame.add(view.getUI());
...
//make sure the view and model is fully initialized before letting the controller control them.
Controller controller = new MyImplementationOfController(view, model);
...
//frame.setVisible(true);
...
}
}
MVC模式是如何构造用户界面的模型。因此，它定义了3个元素：模型，视图，控制器：
例
当Button点击它调用ActionListener。该ActionListener只依赖于其他车型。它使用一些模型作为输入，使用其他模型作为结果或输出。就像方法参数和返回值一样。模型在更新时会通知ui。因此，控制器逻辑无需知道ui组件。模型对象不知道ui。通知是通过观察者模式完成的。因此，模型对象仅知道有人希望在模型更改时得到通知。
在Java swing中，有些组件也实现了模型和控制器。例如javax.swing.Action。它实现了ui模型（属性：启用，小图标，名称等），并且是一个控制器，因为它扩展了ActionListener。
甲详细说明，示例应用程序和源代码：https://www.link-intersystems.com/blog/2013/07/20/the-mvc-pattern-implemented-with-java-swing/。
少于240行的MVC基础知识：
public class Main {
public static void main(String[] args) {
JFrame mainFrame = new JFrame("MVC example");
mainFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
mainFrame.setSize(640, 300);
mainFrame.setLocationRelativeTo(null);
PersonService personService = new PersonServiceMock();
DefaultListModel searchResultListModel = new DefaultListModel();
DefaultListSelectionModel searchResultSelectionModel = new DefaultListSelectionModel();
searchResultSelectionModel
.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
Document searchInput = new PlainDocument();
PersonDetailsAction personDetailsAction = new PersonDetailsAction(
searchResultSelectionModel, searchResultListModel);
personDetailsAction.putValue(Action.NAME, "Person Details");
Action searchPersonAction = new SearchPersonAction(searchInput,
searchResultListModel, personService);
searchPersonAction.putValue(Action.NAME, "Search");
Container contentPane = mainFrame.getContentPane();
JPanel searchInputPanel = new JPanel();
searchInputPanel.setLayout(new BorderLayout());
JTextField searchField = new JTextField(searchInput, null, 0);
searchInputPanel.add(searchField, BorderLayout.CENTER);
searchField.addActionListener(searchPersonAction);
JButton searchButton = new JButton(searchPersonAction);
searchInputPanel.add(searchButton, BorderLayout.EAST);
JList searchResultList = new JList();
searchResultList.setModel(searchResultListModel);
searchResultList.setSelectionModel(searchResultSelectionModel);
JPanel searchResultPanel = new JPanel();
searchResultPanel.setLayout(new BorderLayout());
JScrollPane scrollableSearchResult = new JScrollPane(searchResultList);
searchResultPanel.add(scrollableSearchResult, BorderLayout.CENTER);
JPanel selectionOptionsPanel = new JPanel();
JButton showPersonDetailsButton = new JButton(personDetailsAction);
selectionOptionsPanel.add(showPersonDetailsButton);
contentPane.add(searchInputPanel, BorderLayout.NORTH);
contentPane.add(searchResultPanel, BorderLayout.CENTER);
contentPane.add(selectionOptionsPanel, BorderLayout.SOUTH);
mainFrame.setVisible(true);
}
}
class PersonDetailsAction extends AbstractAction {
private static final long serialVersionUID = -8816163868526676625L;
private ListSelectionModel personSelectionModel;
private DefaultListModel personListModel;
public PersonDetailsAction(ListSelectionModel personSelectionModel,
DefaultListModel personListModel) {
boolean unsupportedSelectionMode = personSelectionModel
.getSelectionMode() != ListSelectionModel.SINGLE_SELECTION;
if (unsupportedSelectionMode) {
throw new IllegalArgumentException(
"PersonDetailAction can only handle single list selections. "
+ "Please set the list selection mode to ListSelectionModel.SINGLE_SELECTION");
}
this.personSelectionModel = personSelectionModel;
this.personListModel = personListModel;
personSelectionModel
.addListSelectionListener(new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
ListSelectionModel listSelectionModel = (ListSelectionModel) e
.getSource();
updateEnablement(listSelectionModel);
}
});
updateEnablement(personSelectionModel);
}
public void actionPerformed(ActionEvent e) {
int selectionIndex = personSelectionModel.getMinSelectionIndex();
PersonElementModel personElementModel = (PersonElementModel) personListModel
.get(selectionIndex);
Person person = personElementModel.getPerson();
String personDetials = createPersonDetails(person);
JOptionPane.showMessageDialog(null, personDetials);
}
private String createPersonDetails(Person person) {
return person.getId() + ": " + person.getFirstName() + " "
+ person.getLastName();
}
private void updateEnablement(ListSelectionModel listSelectionModel) {
boolean emptySelection = listSelectionModel.isSelectionEmpty();
setEnabled(!emptySelection);
}
}
class SearchPersonAction extends AbstractAction {
private static final long serialVersionUID = 4083406832930707444L;
private Document searchInput;
private DefaultListModel searchResult;
private PersonService personService;
public SearchPersonAction(Document searchInput,
DefaultListModel searchResult, PersonService personService) {
this.searchInput = searchInput;
this.searchResult = searchResult;
this.personService = personService;
}
public void actionPerformed(ActionEvent e) {
String searchString = getSearchString();
List<Person> matchedPersons = personService.searchPersons(searchString);
searchResult.clear();
for (Person person : matchedPersons) {
Object elementModel = new PersonElementModel(person);
searchResult.addElement(elementModel);
}
}
private String getSearchString() {
try {
return searchInput.getText(0, searchInput.getLength());
} catch (BadLocationException e) {
return null;
}
}
}
class PersonElementModel {
private Person person;
public PersonElementModel(Person person) {
this.person = person;
}
public Person getPerson() {
return person;
}
@Override
public String toString() {
return person.getFirstName() + ", " + person.getLastName();
}
}
interface PersonService {
List<Person> searchPersons(String searchString);
}
class Person {
private int id;
private String firstName;
private String lastName;
public Person(int id, String firstName, String lastName) {
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
}
public int getId() {
return id;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
}
class PersonServiceMock implements PersonService {
private List<Person> personDB;
public PersonServiceMock() {
personDB = new ArrayList<Person>();
personDB.add(new Person(1, "Graham", "Parrish"));
personDB.add(new Person(2, "Daniel", "Hendrix"));
personDB.add(new Person(3, "Rachel", "Holman"));
personDB.add(new Person(4, "Sarah", "Todd"));
personDB.add(new Person(5, "Talon", "Wolf"));
personDB.add(new Person(6, "Josephine", "Dunn"));
personDB.add(new Person(7, "Benjamin", "Hebert"));
personDB.add(new Person(8, "Lacota", "Browning "));
personDB.add(new Person(9, "Sydney", "Ayers"));
personDB.add(new Person(10, "Dustin", "Stephens"));
personDB.add(new Person(11, "Cara", "Moss"));
personDB.add(new Person(12, "Teegan", "Dillard"));
personDB.add(new Person(13, "Dai", "Yates"));
personDB.add(new Person(14, "Nora", "Garza"));
}
public List<Person> searchPersons(String searchString) {
List<Person> matches = new ArrayList<Person>();
if (searchString == null) {
return matches;
}
for (Person person : personDB) {
if (person.getFirstName().contains(searchString)
|| person.getLastName().contains(searchString)) {
matches.add(person);
}
}
return matches;
}
}
Action因为Controller实际上我猜EventListener都是控制器
A controller encapsulates the application code that is executed in order to an user interaction。移动鼠标，单击组件，按下键等都是用户交互。为了清楚起见，我更新了答案。
您可以在单独的简单Java类中创建模型，并在另一个Java类中创建控制器。
然后，您可以在其之上具有Swing组件。JTable将是视图之一（表模型实际上将成为视图的一部分-它只会从“共享模型”转换为JTable）。
每当编辑表时，其表模型就会告诉“主控制器”进行更新。但是，控制器对表一无所知。因此，呼叫看起来应该更像：updateCustomer(customer, newValue)，而不是updateCustomer(row, column, newValue)。
为共享模型添加一个侦听器（观察者）接口。某些组件（例如您的表）可以直接实现它。另一个观察者可以是协调按钮可用性等的控制器。
这是做到这一点的一种方法，但是如果它对您的用例来说过大，您当然可以简化或扩展它。
您可以将控制器与模型合并，并具有相同的类过程更新并维护组件可用性。您甚至可以将“共享模型”设置为a TableModel（尽管如果不仅仅用于表，我建议至少提供一个不会泄漏表抽象的更友好的API）
在另一方面，你可以有更新的复杂接口（CustomerUpdateListener，OrderItemListener，OrderCancellationListener）和专用控制器（或中介）仅适用于不同的意见协调。
这取决于您的问题有多复杂。
为了进行适当的分离，您通常会有一个Frame类将委派给的控制器类。可以通过多种方法来建立类之间的关系-您可以实现一个控制器并将其与主视图类一起扩展，或者使用事件发生时Frame调用的独立控制器类。该视图通常将通过实现侦听器接口从控制器接收事件。
有时，MVC模式的一个或多个部分是微不足道的，或者如此“薄”，以至于增加了不必要的复杂性以将它们分开。如果您的控制器充满了一个线路调用，则将其放在单独的类中可能会最终混淆基本行为。例如，如果您要处理的所有事件都与TableModel有关，并且都是简单的添加和删除操作，则您可以选择在该模型中实现所有表操作功能（以及将其显示在模型中的回调JTable）。这不是真正的MVC，但是可以避免在不需要的地方增加复杂性。
无论您如何实现它，都请记住使用JavaDoc来记录您的类，方法和包，以便正确描述组件及其关系！
我发现了一些有关实现MVC模式的有趣文章，这些文章可能会解决您的问题。