El patrón que estoy tratando de implementar en mi proyecto es el de Modelo-Vista-Controlador.
A modo de ejemplo tomaré la función abrir. A continuación se puede apreciar como es que divide el código para manejar el patrón MVC.
/** Clase que maneja la vista del editor
*
*
*
*
* */
import java.awt.event.*;
import javax.swing.*;
import java.awt.*;
import javax.swing.text.*;
public class Interfaz extends JFrame{
JMenuBar barraMenu;
JMenu archivo;
JMenuItem abrirFichero;
JMenuItem guardarFichero;
JMenuItem salir;
JMenu edicion;
JMenuItem cortar;
JMenuItem copiar;
JMenuItem pegar;
JTextArea areaDeTexto;
JScrollPane desplazamiento;
// Constructor de la clase Interfaz.
public Interfaz(){
super("Editor ++");
this.setSize(400,400);
this.definir_componentes();
this.agregar_componentes();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
/** Se definen los componentes de la ventana, así como también
* algunas de sus características
*
*
* */
public void definir_componentes(){
// Área de Texto
areaDeTexto = new JTextArea();
areaDeTexto.setLineWrap(true);
areaDeTexto.setWrapStyleWord(true);
desplazamiento = new JScrollPane(areaDeTexto);
// Barra de menú y menús
barraMenu = new JMenuBar();
archivo = new JMenu("Archivo");
archivo.setMnemonic(KeyEvent.VK_A);
edicion = new JMenu("Edición");
edicion.setMnemonic(KeyEvent.VK_E);
// MenuItems
abrirFichero = new JMenuItem(new ModeloAbrir(areaDeTexto));
guardarFichero = new JMenuItem(new ModeloGuardar(areaDeTexto));
salir = new JMenuItem("Salir");
Action accionCopiar = areaDeTexto.getActionMap().get(DefaultEditorKit.copyAction);
accionCopiar.putValue(Action.NAME,"Copiar ");
accionCopiar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('C',Event.CTRL_MASK));
copiar = new JMenuItem(accionCopiar);
Action accionPegar = areaDeTexto.getActionMap().get(DefaultEditorKit.pasteAction);
accionPegar.putValue(Action.NAME,"Pegar ");
accionPegar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('P',Event.CTRL_MASK));
pegar = new JMenuItem(accionPegar);
Action accionCortar = areaDeTexto.getActionMap().get(DefaultEditorKit.cutAction);
accionCortar.putValue(Action.NAME,"Cortar ");
accionCortar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('O',Event.CTRL_MASK));
cortar = new JMenuItem(accionCortar);
}
/** Agrega los componentes definidos por
* la función definir_componentes()
*
* */
public void agregar_componentes(){
barraMenu.add(archivo);
barraMenu.add(edicion);
archivo.add(abrirFichero);
archivo.add(guardarFichero);
archivo.add(salir);
edicion.add(copiar);
edicion.add(pegar);
edicion.add(cortar);
this.add(barraMenu, BorderLayout.NORTH);
this.add(desplazamiento, BorderLayout.CENTER);
}
}Clase ModeloAbrir
/** Clase en la que se maneja la mayor parte de la lógica de la
* acción abrir del menú Archivo
*
*
* */
import java.awt.Event;
import java.io.*;
import javax.swing.*;
import javax.swing.text.*;
// Clase ModeloAbrir que hereda de la clase abstracta ControladorAbrir
public class ModeloAbrir extends ControladorAbrir {
/** Constructor de la clase ModeloAbrir
*
*
* @param areaDeTrabajo Componente en el que se pretende mostrar el
* contenido del archivo leído.
*/
public ModeloAbrir(JTextComponent areaDeTrabajo)
{
// Se le pasa al constructor de la superclase el JTextComponent
super(areaDeTrabajo);
// Etiqueta y tecla aceleradora
this.putValue(Action.NAME, "Abrir ...");
this.putValue(Action.ACCELERATOR_KEY,
KeyStroke.getAWTKeyStroke('A', Event.CTRL_MASK));
}
/**
* Lee el archivo y coloca su contenido en el área de texto
*
* @param archivo Archivo a leer
*
* @throws FileNotFoundException Error al leer el archivo
*/
@Override
protected void logicaAbrir(File archivo)
throws FileNotFoundException
{
// Se crea el objeto archivoEntrada para leer el archivo.
// bufferLinea irá modificando su longitud al ir leyendo las lineas del
// archivo. Al final todos esos caracteres se colocarán en el area de Texto
BufferedReader archivoEntrada = new BufferedReader(new FileReader(archivo));
StringBuffer bufferLinea = new StringBuffer();
try
{
String linea = archivoEntrada.readLine();
while (linea != null)
{
// Se va añadiendo las líneas que se leen a la variable bufferLinea
// modificando cada vez la longitud de caracteres de esta variable.
// Además se agrega un salto de línea con la instrucción
// System.getProperty("line.separator") la cual da mayor portabilidad
bufferLinea.append(linea);
bufferLinea.append(System.getProperty("line.separator"));
// Siguiente linea.
linea = archivoEntrada.readLine();
}
}
catch (IOException e)
{
JOptionPane.showMessageDialog(
areaDeTrabajo, e, "Error al leer el archivo",
JOptionPane.ERROR_MESSAGE);
}
// Se pone el texto leido en el JTextArea.
areaDeTrabajo.setText(bufferLinea.toString());
}
}
Clase ControladorAbrir
/** Clase que maneja el controlador de la acción abrir del menú
* Archivo
*
*
* */
import java.awt.event.ActionEvent;
import java.io.*;
import javax.swing.*;
import javax.swing.text.JTextComponent;
public abstract class ControladorAbrir extends AbstractAction{
protected JTextComponent areaDeTrabajo;
private JFileChooser fc;
/** Constructor de la clase ControladorAbrir.
*
*
* @param areaDeTrabajo Componente de texto en el cual se mostrará
* el contenido del archivo
*
*/
public ControladorAbrir(JTextComponent areaDeTrabajo)
{
this.areaDeTrabajo = areaDeTrabajo;
}
/** Método que se dispara cuando se da clic en la opción Abrir
*
* @param event
*/
public void actionPerformed(ActionEvent event)
{
// Se crea el FileChooser.
fc = new JFileChooser();
int respuesta;
respuesta = fc.showOpenDialog(areaDeTrabajo);
// Confirma que se haya presionado el botón Abrir y así poder aplicar
// la lógica de la opción Abrir
if (JFileChooser.APPROVE_OPTION == respuesta)
{
// Se obtiene el fichero
File archivo = fc.getSelectedFile();
try
{
// Se abre el archivo. Este método tiene que ser definido por las
// clases hijas
logicaAbrir(archivo);
}
catch (Exception e)
{
// Mensaje de error si se produce.
JOptionPane.showMessageDialog(
areaDeTrabajo, e, "Error en el archivo " + archivo,
JOptionPane.ERROR_MESSAGE);
}
}
}
/** Las clases hijas deben redefinir este método abstracto para leer el contenido
* del archivo
*
* @param archivo Archivo del cual se va a leer
*
* @throws FileNotFoundException Excepción si el archivo no existe.
*/
protected abstract void logicaAbrir(File archivo)
throws FileNotFoundException;
}
Enseguida también pongo el código como separé la funcionalidad "Guardar como...".
La parte de Interfaz es la misma que la mostrada en el ejemplo anterior.
Clase ModeloGuardar
/** Clase en la que se maneja la mayor parte de la lógica de la
* acción guardar del menú Archivo
*
*
*
*
* */
import java.awt.Event;
import java.io.*;
import javax.swing.*;
import javax.swing.text.*;
//Clase ModeloGuardar que hereda de la clase abstracta ControladorGuardar
public class ModeloGuardar extends ControladorGuardar
{
/** Constructor de la clase ModeloGuardar
*
*
* @param areaDeTrabajo Componente en el que se pretende tomar el contenido
* para guardarlo en alguna ruta en específico
*/
public ModeloGuardar(JTextComponent areaDeTrabajo)
{
// Se le pasa al constructor de la superclase el JTextComponent
super(areaDeTrabajo);
// Etiqueta y tecla aceleradora
this.putValue(Action.NAME, "Guardar como... ");
this.putValue( Action.ACCELERATOR_KEY,
KeyStroke.getAWTKeyStroke('G', Event.CTRL_MASK));
}
/** Toma el archivo creado de la ruta específicada en el selector de archivos
* y escribe sobre él el contenido del areaDeTrabajo (área de Texto) para
* guardarlo en dicho archivo
*
* @param archivo Archivo a escribir
*
* @throws FileNotFoundException Error al leer el archivo
*/
protected void logicaGuardar(File archivo) throws FileNotFoundException
{
PrintWriter archivoSalida = new PrintWriter(archivo);
archivoSalida.print(areaDeTrabajo.getText());
archivoSalida.close();
}
}
Clase ControladorGuardar
/** Clase que maneja el controlador de la acción guardar del menú
* Archivo
*
*
* */
import java.awt.event.ActionEvent;
import java.io.*;
import javax.swing.*;
import javax.swing.text.JTextComponent;
public abstract class ControladorGuardar extends AbstractAction
{
protected JTextComponent areaDeTrabajo;
private JFileChooser selectorArchivos;
/** Constructor de la clase ControladorGuardar
*
*
* @param componenteTexto Componente de texto del cual se dispondrá de
* su contenido para guardarlo
*
*/
public ControladorGuardar( JTextComponent areaDeTrabajo)
{
this.areaDeTrabajo = areaDeTrabajo;
}
/** Método que se dispara cuando se da clic en la opción Guardar
*
* @param event
*/
public void actionPerformed(ActionEvent event)
{
selectorArchivos = new JFileChooser();
int respuesta;
respuesta = selectorArchivos.showSaveDialog(areaDeTrabajo);
// Confirma que se haya presionado el botón Guardar y así poder aplicar
// la lógica de la opción Guardar
if (JFileChooser.APPROVE_OPTION == respuesta)
{
// Se obtiene el fichero
File archivo = selectorArchivos.getSelectedFile();
try
{
// Se guarda. Las clases hijas deben redefinir este método.
logicaGuardar(archivo);
}
catch (Exception e)
{
// Mensaje de error si se produce.
JOptionPane.showMessageDialog(null,"Error de archivo"+e.toString());
}
}
}
/** Las clases hijas deben redefinir este método abstracto para guardar el contenido
*
*
* @param archivo Archivo en el cual se va a guardar
*
* @throws FileNotFoundException Excepción si el archivo no existe.
*/
protected abstract void logicaGuardar(File archivo)throws FileNotFoundException;
}Fuentes
Chuidiang
