import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class MediatorClient extends JFrame implements ActionListener {
EntryField ef;
ListBox lb;
public MediatorClient() {
JPanel panel = new JPanel();
panel.setLayout(new BorderLayout());
panel.setPreferredSize(new Dimension(200, 100));
JTextField textField = new JTextField();
String[] data = {"one", "two", "three", "four"};
JList list = new JList(data);
list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
// Pattern 클래스 생성
ef = new EntryField(textField);
lb = new ListBox(list);
FontDialogDirector fdd = new FontDialogDirector(ef, lb);
ef.setDirector(fdd);
// JList 에 Listener 등록
textField.addActionListener(this);
panel.add(textField, BorderLayout.NORTH);
panel.add(list, BorderLayout.CENTER);
getContentPane().add(panel);
}
public void actionPerformed(ActionEvent e) {
ef.changed();
}
public static void main(String[] args) {
JFrame frame = new MediatorClient();
frame.pack();
frame.setVisible(true);
}
}
abstract class Widget {
private DialogDirector director;
public void setDirector(DialogDirector director) {
this.director = director;
}
public void changed() {
director.widgetChanged(this);
}
}
class ListBox extends Widget {
private JList list;
public ListBox(JList list) {
this.list = list;
}
public void setSelection(String str) {
list.setSelectedValue(str,true);
}
}
class EntryField extends Widget {
private JTextField textField;
public EntryField(JTextField textField) {
this.textField = textField;
}
public String getText() {
return textField.getText();
}
}
interface DialogDirector {
public void widgetChanged(Widget widget);
}
class FontDialogDirector implements DialogDirector {
EntryField ef;
ListBox lb;
public FontDialogDirector(EntryField ef, ListBox lb) {
this.ef = ef;
this.lb = lb;
}
public void widgetChanged(Widget widget) {
if (widget == ef) {
lb.setSelection(ef.getText());
}
}
}
|
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class TestServlet extends HttpServlet
{
private String error = "test/Error.jsp";
public void service(HttpServletRequest req, HttpServletResponse res)
throws ServletException
{
String path = "/test/";
String nextFile=null;
String comandString = req.getParameter("cmd");
try
{
Command cmd = CommandFactory.getCommand(comandString);
nextFile = cmd.execute(req);
}
catch (Exception e)
{
req.setAttribute("javax.servlet.jsp.jspException", e);
path = "/";
nextFile = error;
}
RequestDispatcher rd;
rd = getServletContext().getRequestDispatcher(path + nextFile);
try {
rd.forward(req, res);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
|
interface Command {
public void execute();
}
class Invoker {
public static void storeCommand(Command command) {
command.execute();
}
}
class ConcreteCommand implements Command {
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
this.receiver = receiver;
}
public void execute() {
receiver.action();
}
}
class Receiver {
public void action() {
System.out.println("Receiver called !!");
}
}
public class CommandClient {
public static void main(String args[]) {
Receiver receiver = new Receiver();
Command command = new ConcreteCommand(receiver);
Invoker.storeCommand(command);
}
}
|
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
public class ConcreteCommand implements Command
{
String jspPage;
public ConcreteCommand(String aJspPage)
{
this.jspPage = aJspPage;
}
public String execute(HttpServletRequest req) throws EPException
{
try
{
String name = req.getParameter("name");
EmpolyeeVO = new Employee().getEmployeeList(name);
req.setAttribute("employeeVO", EmpolyeeVO);
return this.jspPage;
}
catch (Exception e)
{
req.setAttribute("errorCode", " ERROR");
req.setAttribute("isPopup","Y");
req.setAttribute("isScript","Y");
throw e;
}
}
}
|
interface Product {
public void dispalyName();
}
class ConcreteProductA implements Product {
public void dispalyName() {
System.out.println("My Class name is ConcreteProductA !!");
}
}
class ConcreteProductB implements Product {
public void dispalyName() {
System.out.println("My Class name is ConcreteProductB !!");
}
}
abstract class Creator {
public abstract Product factoryMethod(String name);
public void anOperation(String name) {
Product p = factoryMethod(name);
p.dispalyName();
}
}
class ConcreteCreator extends Creator {
public Product factoryMethod(String name) {
Product p = null;
if (name.equals("A")) {
p = new ConcreteProductA();
} else if (name.equals("B")) {
p = new ConcreteProductB();
}
return p;
}
}
public class FactoryMethodClient {
public static void main(String[] args) {
Creator c = new ConcreteCreator();
c.anOperation("A");
}
}
|
…
Command cmd = null;
if (“add”.equals(commandString))
{
cmd = new AddCommand(“add.jsp”);
}
else if (“mod”.equals(commandString))
{
cmd = new ModCommand(“mod.jsp”);
}
…
|
…
Factory factory = new CommandFactory();
factory.operate(req, res, commandString);
…
|
public abstract class Factory
{
public abstract Command factoryMethod(String cmd);
public void operate(HttpServletRequest req, HttpServletResponse res,
String cmd)
{
Command = factoryMethod(cmd);
Command.execute(req, res);
}
}
|
public class CommandFactory implements Factory
{
public Command factoryMethod(String cmd)
{
if (“add”.equals(cmd))
{
return new AddCommand(“add.jsp”);
}
else if (“mod”.equals(cmd))
{
return new ModCommand(“mod.jsp”);
}
}
}
|
class Singleton {
private static Singleton instance = null;
private String say = "Hello World";
private Singleton() {}
public static Singleton instance() {
if (instance == null ) {
instance = new Singleton();
}
return instance;
}
public void setSay(String say) {
this.say = say;
}
public String getSay() {
return say;
}
}
public class SingletonClient {
public static void main(String args[]) {
Singleton first = Singleton.instance();
Singleton second = Singleton.instance();
System.out.println(first.getSay());
System.out.println(second.getSay());
first.setSay("Hello World again");
System.out.println(first.getSay());
System.out.println(second.getSay());
}
}
|
…
Factory factory = new CommandFactory();
factory.operate(req, res, commandString);
…
|
Factory factory = CommandFactory.getInstance();
factory.operate(req, res, commandString);
|
public class CommandFactory implements Factory
{
private static CommandFactory instance = null;
private CommandFactory() {}
public static CommandFactory getInstance()
{
if (instance == null ) {
instance = new CommandFactory();
}
return instance;
}
public Command factoryMethod(String cmd)
{
if (“add”.equals(cmd))
{
return new AddCommand(“add.jsp”);
}
else if (“mod”.equals(cmd))
{
return new ModCommand(“mod.jsp”);
}
}
}
|
interface AbstractProductA {
public void dispalyName();
}
class ConcreteProductA1 implements AbstractProductA {
public void dispalyName() {
System.out.println("My Class name is ConcreteProductA1 !!");
}
}
class ConcreteProductA2 implements AbstractProductA {
public void dispalyName() {
System.out.println("My Class name is ConcreteProductA2 !!");
}
}
interface AbstractProductB {
public void dispalyName();
}
class ConcreteProductB1 implements AbstractProductB {
public void dispalyName() {
System.out.println("My Class name is ConcreteProductB1 !!");
}
}
class ConcreteProductB2 implements AbstractProductB {
public void dispalyName() {
System.out.println("My Class name is ConcreteProductB2 !!");
}
}
abstract class AbstractFactory {
public abstract AbstractProductA createProductA();
public abstract AbstractProductB createProductB();
}
class ConcreteFactory1 extends AbstractFactory {
public AbstractProductA createProductA() {
AbstractProductA apa = null;
apa = new ConcreteProductA1();
return apa;
}
public AbstractProductB createProductB() {
AbstractProductB apb = null;
apb = new ConcreteProductB1();
return apb;
}
}
class ConcreteFactory2 extends AbstractFactory {
public AbstractProductA createProductA() {
AbstractProductA apa = null;
apa = new ConcreteProductA2();
return apa;
}
public AbstractProductB createProductB() {
AbstractProductB apb = null;
apb = new ConcreteProductB2();
return apb;
}
}
public class AbstractFactoryClient {
public static void main(String[] args) {
AbstractFactory af = new ConcreteFactory1();
AbstractProductA apa = af.createProductA();
apa.dispalyName();
}
}
|
…
String name = req.getParameter("name");
EmpolyeeVO = new Employee().getEmployeeList(name);
req.setAttribute("employeeVO", EmpolyeeVO);
…
|
public class Employee
{
public EmployeeVO getEmployeeList(String name)
{
MyConfigure configure = Configure.getInstance();
DAOFactory factory = DAOFactory.getDAOFactory("ORACLE");
EmployeeDAO dao = factory.getEmployeeDAO();
return dao.getEmployeeList (name);
}
}
|
public abstract class DAOFactory
{
public static DAOFactory getDAOFactory(String dataBase)
{
if ("ORACLE".equals(dataBase))
{
return OracleDAOFactory.getInstance();
}
return OracleDAOFactory.getInstance();
}
public abstract EmployeeDAO getEmployeeDAO();
}
|
public class OracleDAOFactory extends DAOFactory
{
private static OracleDAOFactory instance = null;
private OracleDAOFactory() {}
public static OracleDAOFactory getInstance()
{
if (instance == null)
{
instance = new OracleDAOFactory();
}
return instance;
}
public EmployeeDAO getEmployeeDAO()
{
return new EmployeeOracleDAO();
}
}
|
public interface EmployeeDAO
{
public EmployeeVO getEmployeeList(String name);
}
|
public class EmployeeOracleDAO implements EmployeeDAO
{
public EmployeeVO getEmployeeList(String name)
{
…
}
}
|
interface Strategy
{
public String algorithmInterface();
}
class ConcreteStrategyA implements Strategy
{
public String algorithmInterface()
{
return ("called Strategy A");
}
}
class ConcreteStrategyB implements Strategy
{
public String algorithmInterface()
{
return ("called Strategy B");
}
}
class Context
{
private Strategy strategy;
public Context()
{
strategy = new ConcreteStrategyA();
}
public void setStrategy(Strategy strategy)
{
this.strategy = strategy;
}
public String contextInterface()
{
return strategy.algorithmInterface();
}
}
public class StrategyClient
{
public static void main(String args[])
{
Context context = new Context();
System.out.println(context.contextInterface());
context.setStrategy(new ConcreteStrategyA());
System.out.println(context.contextInterface());
context.setStrategy(new ConcreteStrategyB());
System.out.println(context.contextInterface());
}
}
|
String queryScope = …. (input 변수)
String key = … (input 변수)
String sql = “ select * from EMP “
if (“NAME”.equlas(queryScope))
{
sql = sql + “ where name = ‘” + value + “’”;
}
else if (“ID”.equlas(queryScope))
{
sql = sql + “ where id = ‘” + value + “’”;
}
……
|
…
// SQL 문 쿼리를 직접 사용하던 것을 수정함
EmployeeOracleDAOListStrategy strategy =
StrategyFactory.getEmployeeOracleDAO(queryScope);
retuern Strategy.getEmpList(value);
// 기타 다른 메소드의 SQL 은 그대로 해당 클래스에서 처리됨
|
public interface EmployeeOracleDAOListStrategy
{
public EmployeeVO getEmpList(String value);
}
|
public class NameEmployeListStrategy implements EmployeListStrategy
{
public EmployeeVO getEmpList(String value)
{
// 성명으로 조회하는 SQL 문을 작성
}
}
|
public class IDEmployeListStrategy implements EmployeListStrategy
{
public EmployeeVO getEmpList(String value)
{
// ID로 조회하는 SQL 문을 작성
}
}
|
댓글
댓글 쓰기