Admin: 1 версия

2010-06-01T06:50:39Z

1 версия

в 18:01, 31 мая 2010

2010-05-31T18:01:45Z

Новая страница

== Callback Pattern in Java ==



<source lang="java">
//[C] 2002 Sun Microsystems, Inc.---
import java.io.IOException;
public class RunCallbackPattern {
public static void main(String [] arguments){
System.out.println("Example for the Callback pattern");
System.out.println("This code will run two RMI objects to demonstrate");
System.out.println(" callback capability. One will be CallbackClientImpl,");
System.out.println(" which will request a project from the other remote");
System.out.println(" object, CallbackServerImpl.");
System.out.println("To demonstrate how the Callback pattern allows the");
System.out.println(" client to perform independent processing, the main");
System.out.println(" progam thread will go into a wait loop until the");
System.out.println(" server sends the object to its client.");
System.out.println();

System.out.println("Running the RMI compiler (rmic)");
System.out.println();
try{
Process p1 = Runtime.getRuntime().exec("rmic CallbackServerImpl");
Process p2 = Runtime.getRuntime().exec("rmic CallbackClientImpl");
p1.waitFor();
p2.waitFor();
}
catch (IOException exc){
System.err.println("Unable to run rmic utility. Exiting application.");
System.exit(1);
}
catch (InterruptedException exc){
System.err.println("Threading problems encountered while using the rmic utility.");
}

System.out.println("Starting the rmiregistry");
System.out.println();
Process rmiProcess = null;
try{
rmiProcess = Runtime.getRuntime().exec("rmiregistry");
Thread.sleep(15000);
}
catch (IOException exc){
System.err.println("Unable to start the rmiregistry. Exiting application.");
System.exit(1);
}
catch (InterruptedException exc){
System.err.println("Threading problems encountered when starting the rmiregistry.");
}

System.out.println("Creating the client and server objects");
System.out.println();
CallbackServerImpl callbackServer = new CallbackServerImpl();
CallbackClientImpl callbackClient = new CallbackClientImpl();

System.out.println("CallbackClientImpl requesting a project");
callbackClient.requestProject("New Java Project");

try{
while(!callbackClient.isProjectAvailable()){
System.out.println("Project not available yet; sleeping for 2 seconds");
Thread.sleep(2000);
}
}
catch (InterruptedException exc){}
System.out.println("Project retrieved: " + callbackClient.getProject());
}
}
import java.rmi.Naming;
import java.rmi.server.UnicastRemoteObject;
public class CallbackServerImpl implements CallbackServer{
private static final String CALLBACK_SERVER_SERVICE_NAME = "callbackServer";
public CallbackServerImpl(){
try {
UnicastRemoteObject.exportObject(this);
Naming.rebind(CALLBACK_SERVER_SERVICE_NAME, this);
}
catch (Exception exc){
System.err.println("Error using RMI to register the CallbackServerImpl " + exc);
}
}

public void getProject(String projectID, String callbackMachine,
String callbackObjectName){
new CallbackServerDelegate(projectID, callbackMachine, callbackObjectName);
}

}
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface CallbackServer extends Remote{
public void getProject(String projectID, String callbackMachine,
String callbackObjectName) throws RemoteException;
}

import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.UnknownHostException;
import java.rmi.Naming;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
public class CallbackClientImpl implements CallbackClient{
private static final String CALLBACK_CLIENT_SERVICE_NAME = "callbackClient";
private static final String CALLBACK_SERVER_SERVICE_NAME = "callbackServer";
private static final String CALLBACK_SERVER_MACHINE_NAME = "localhost";

private Project requestedProject;
private boolean projectAvailable;

public CallbackClientImpl(){
try {
UnicastRemoteObject.exportObject(this);
Naming.rebind(CALLBACK_CLIENT_SERVICE_NAME, this);
}
catch (Exception exc){
System.err.println("Error using RMI to register the CallbackClientImpl " + exc);
}
}

public void receiveProject(Project project){
requestedProject = project;
projectAvailable = true;
}

public void requestProject(String projectName){
try{
String url = "//" + CALLBACK_SERVER_MACHINE_NAME + "/" + CALLBACK_SERVER_SERVICE_NAME;
Object remoteServer = Naming.lookup(url);
if (remoteServer instanceof CallbackServer){
((CallbackServer)remoteServer).getProject(projectName,
InetAddress.getLocalHost().getHostName(),
CALLBACK_CLIENT_SERVICE_NAME);
}
projectAvailable = false;
}
catch (RemoteException exc){}
catch (NotBoundException exc){}
catch (MalformedURLException exc){}
catch (UnknownHostException exc){}
}

public Project getProject(){ return requestedProject; }
public boolean isProjectAvailable(){ return projectAvailable; }
}

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
public class CallbackServerDelegate implements Runnable{
private Thread processingThread;
private String projectID;
private String callbackMachine;
private String callbackObjectName;

public CallbackServerDelegate(String newProjectID, String newCallbackMachine,
String newCallbackObjectName){
projectID = newProjectID;
callbackMachine = newCallbackMachine;
callbackObjectName = newCallbackObjectName;
processingThread = new Thread(this);
processingThread.start();
}

public void run(){
Project result = getProject();
sendProjectToClient(result);
}

private Project getProject(){
return new Project(projectID, "Test project");
}

private void sendProjectToClient(Project project){
try{
String url = "//" + callbackMachine + "/" + callbackObjectName;
Object remoteClient = Naming.lookup(url);
if (remoteClient instanceof CallbackClient){
((CallbackClient)remoteClient).receiveProject(project);
}
}
catch (RemoteException exc){}
catch (NotBoundException exc){}
catch (MalformedURLException exc){}
}
}

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
public class CallbackServerWorkThread implements Runnable{
private Thread processingThread;
private String projectID;
private String callbackMachine;
private String callbackObjectName;

public CallbackServerWorkThread(String newProjectID, String newCallbackMachine,
String newCallbackObjectName){
projectID = newProjectID;
callbackMachine = newCallbackMachine;
callbackObjectName = newCallbackObjectName;
processingThread = new Thread(this);
processingThread.start();
}

public void run(){
Project result = getProject();
sendProjectToClient(result);
}

private Project getProject(){
return new Project(projectID, "Test project");
}

private void sendProjectToClient(Project project){
try{
String url = "//" + callbackMachine + "/" + callbackObjectName;
Object remoteClient = Naming.lookup(url);
if (remoteClient instanceof CallbackClient){
((CallbackClient)remoteClient).receiveProject(project);
}
}
catch (RemoteException exc){}
catch (NotBoundException exc){}
catch (MalformedURLException exc){}
}
}
public class Command implements java.io.Serializable{
public static final int GET_PROJECT = 1;
public static final int GET_TASK = 2;
public static final int CREATE_CONTACT = 4;
public static final int ADD_ADDRESS = 8;
public static final int REMOVE_ADDRESS = 16;
public static final int FINALIZE_CONTACT = 32;

private int command;
private Object [] arguments;

public int getCommand(){
return command;
}

public Object [] getArguments(){
return arguments;
}

public void setArguments(Object [] newArguments){
arguments = newArguments;
}

public void setCommand(int newCommand){
command = newCommand;
}

public Command(int name, Object [] argumentList){
command = name;
arguments = argumentList;
}
}
import java.util.ArrayList;
public class Project implements ProjectItem{
private String name;
private String description;
private ArrayList projectItems = new ArrayList();

public Project(){ }
public Project(String newName, String newDescription){
name = newName;
description = newDescription;
}

public String getName(){ return name; }
public String getDescription(){ return description; }
public ArrayList getProjectItems(){ return projectItems; }

public void setName(String newName){ name = newName; }
public void setDescription(String newDescription){ description = newDescription; }

public void addProjectItem(ProjectItem element){
if (!projectItems.contains(element)){
projectItems.add(element);
}
}

public void removeProjectItem(ProjectItem element){
projectItems.remove(element);
}

public String toString(){ return name + ", " + description; }
}
import java.net.Socket;
import java.util.Date;
import java.io.*;
public class ServerWorkThread implements Runnable{
private Thread processingThread;
private Socket requestSocket;
private Command command;

public ServerWorkThread(Socket clientRequestSocket){
requestSocket = clientRequestSocket;
processingThread = new Thread(this);
processingThread.start();
}

private void retrieveCommand(){
try{
ObjectInputStream in = new ObjectInputStream(requestSocket.getInputStream());
Object request = in.readObject();
requestSocket.close();
if (request instanceof Command){
command = (Command)request;
}
}
catch (ClassNotFoundException exc){
}
catch (IOException exc){
}
}

protected void processCommand(){
}

public void run(){
retrieveCommand();
processCommand();
}

public Command getCommand(){
return command;
}

protected Socket getRequestSocket(){
return requestSocket;
}
}

import java.util.ArrayList;
public class Task implements ProjectItem{
private String name;
private ArrayList projectItems = new ArrayList();
private double timeRequired;

public Task(){ }
public Task(String newName, double newTimeRequired){
name = newName;
timeRequired = newTimeRequired;
}

public String getName(){ return name; }
public ArrayList getProjectItems(){ return projectItems; }
public double getTimeRequired(){ return timeRequired; }

public void setName(String newName){ name = newName; }
public void setTimeRequired(double newTimeRequired){ timeRequired = newTimeRequired; }

public void addProjectItem(ProjectItem element){
if (!projectItems.contains(element)){
projectItems.add(element);
}
}

public void removeProjectItem(ProjectItem element){
projectItems.remove(element);
}

}

import java.net.ServerSocket;
import java.net.Socket;
import java.io.IOException;
public class ThreadedServer{
private static final int DEFAULT_SERVER_PORT = 2001;

private boolean shutdown;
private int serverPort = DEFAULT_SERVER_PORT;

public void runServer(){
try{
ServerSocket mainServer = new ServerSocket(serverPort);
while (!shutdown){
Socket requestSocket = mainServer.accept();
new ServerWorkThread(requestSocket);
}
}
catch (IOException exc){
}
}

public int getServerPort(){
return serverPort;
}

public boolean isShutdown(){
return shutdown;
}

public void setShutdown(boolean isShutdown){
shutdown = isShutdown;
}

public void setServerPort(int newServerPort){
serverPort = newServerPort;
}
}

import java.rmi.Remote;
import java.rmi.RemoteException;
public interface CallbackClient extends Remote{
public void receiveProject(Project project) throws RemoteException;
}
import java.io.Serializable;
import java.util.ArrayList;
public interface ProjectItem extends Serializable{
public ArrayList getProjectItems();
}

</source>



== Chain Pattern ==



<source lang="java">
//[C] 2002 Sun Microsystems, Inc.---
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;

import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
public class RunChainPattern {
public static void main(String [] arguments){
System.out.println("Example for the Chain of Responsibility pattern");
System.out.println();
System.out.println("This code uses chain of responsibility to obtain");
System.out.println(" the owner for a particular ProjectItem, and to");
System.out.println(" build up a list of project details. In each case,");
System.out.println(" a call to the appropriate getter method, getOwner");
System.out.println(" or getDetails, will pass the method call up the");
System.out.println(" project tree.");
System.out.println("For getOwner, the call will return the first non-null");
System.out.println(" owner field encountered. For getDetails, the method");
System.out.println(" will build a series of details, stopping when it");
System.out.println(" reaches a ProjectItem that is designated as a");
System.out.println(" primary task.");
System.out.println();

System.out.println("Deserializing a test Project for Visitor pattern");
System.out.println();
if (!(new File("data.ser").exists())){
DataCreator.serialize("data.ser");
}
Project project = (Project)(DataRetriever.deserializeData("data.ser"));

System.out.println("Retrieving Owner and details for each item in the Project");
System.out.println();
getItemInfo(project);
}

private static void getItemInfo(ProjectItem item){
System.out.println("ProjectItem: " + item);
System.out.println(" Owner: " + item.getOwner());
System.out.println(" Details: " + item.getDetails());
System.out.println();
if (item.getProjectItems() != null){
Iterator subElements = item.getProjectItems().iterator();
while (subElements.hasNext()){
getItemInfo((ProjectItem)subElements.next());
}
}
}
}
interface Contact extends Serializable{
public static final String SPACE = " ";
public String getFirstName();
public String getLastName();
public String getTitle();
public String getOrganization();

public void setFirstName(String newFirstName);
public void setLastName(String newLastName);
public void setTitle(String newTitle);
public void setOrganization(String newOrganization);
}
class ContactImpl implements Contact{
private String firstName;
private String lastName;
private String title;
private String organization;

public ContactImpl(){}
public ContactImpl(String newFirstName, String newLastName,
String newTitle, String newOrganization){
firstName = newFirstName;
lastName = newLastName;
title = newTitle;
organization = newOrganization;
}

public String getFirstName(){ return firstName; }
public String getLastName(){ return lastName; }
public String getTitle(){ return title; }
public String getOrganization(){ return organization; }

public void setFirstName(String newFirstName){ firstName = newFirstName; }
public void setLastName(String newLastName){ lastName = newLastName; }
public void setTitle(String newTitle){ title = newTitle; }
public void setOrganization(String newOrganization){ organization = newOrganization; }

public String toString(){
return firstName + SPACE + lastName;
}
}
class Task implements ProjectItem{
private String name;
private ArrayList projectItems = new ArrayList();
private Contact owner;
private String details;
private ProjectItem parent;
private boolean primaryTask;

public Task(ProjectItem newParent){
this(newParent, "", "", null, false);
}
public Task(ProjectItem newParent, String newName,
String newDetails, Contact newOwner, boolean newPrimaryTask){
parent = newParent;
name = newName;
owner = newOwner;
details = newDetails;
primaryTask = newPrimaryTask;
}

public Contact getOwner(){
if (owner == null){
return parent.getOwner();
}
else{
return owner;
}
}

public String getDetails(){
if (primaryTask){
return details;
}
else{
return parent.getDetails() + EOL_STRING + "\t" + details;
}
}

public String getName(){ return name; }
public ArrayList getProjectItems(){ return projectItems; }
public ProjectItem getParent(){ return parent; }
public boolean isPrimaryTask(){ return primaryTask; }

public void setName(String newName){ name = newName; }
public void setOwner(Contact newOwner){ owner = newOwner; }
public void setParent(ProjectItem newParent){ parent = newParent; }
public void setPrimaryTask(boolean newPrimaryTask){ primaryTask = newPrimaryTask; }
public void setDetails(String newDetails){ details = newDetails; }

public void addProjectItem(ProjectItem element){
if (!projectItems.contains(element)){
projectItems.add(element);
}
}

public void removeProjectItem(ProjectItem element){
projectItems.remove(element);
}

public String toString(){
return name;
}
}
class DataCreator{
private static final String DEFAULT_FILE = "data.ser";

public static void main(String [] args){
String fileName;
if (args.length == 1){
fileName = args[0];
}
else{
fileName = DEFAULT_FILE;
}
serialize(fileName);
}

public static void serialize(String fileName){
try{
serializeToFile(createData(), fileName);
}
catch (IOException exc){
exc.printStackTrace();
}
}

private static Serializable createData(){
Contact contact1 = new ContactImpl("Dennis", "Moore", "Managing Director", "Highway Man, LTD");
Contact contact2 = new ContactImpl("Joseph", "Mongolfier", "High Flyer", "Lighter than Air Productions");
Contact contact3 = new ContactImpl("Erik", "Njoll", "Nomad without Portfolio", "Nordic Trek, Inc.");
Contact contact4 = new ContactImpl("Lemming", "", "Principal Investigator", "BDA");

Project project = new Project("IslandParadise", "Acquire a personal island paradise", contact2);

Task task1 = new Task(project, "Fortune", "Acquire a small fortune", contact4, true);
Task task2 = new Task(project, "Isle", "Locate an island for sale", null, true);
Task task3 = new Task(project, "Name", "Decide on a name for the island", contact3, false);
project.addProjectItem(task1);
project.addProjectItem(task2);
project.addProjectItem(task3);

Task task4 = new Task(task1, "Fortune1", "Use psychic hotline to predict winning lottery numbers", null, false);
Task task5 = new Task(task1, "Fortune2", "Invest winnings to ensure 50% annual interest", contact1, true);
Task task6 = new Task(task2, "Isle1", "Research whether climate is better in the Atlantic or Pacific", contact1, true);
Task task7 = new Task(task2, "Isle2", "Locate an island for auction on EBay", null, false);
Task task8 = new Task(task2, "Isle2a", "Negotiate for sale of the island", null, false);
Task task9 = new Task(task3, "Name1", "Research every possible name in the world", null, true);
Task task10 = new Task(task3, "Name2", "Eliminate any choices that are not coffee-related", contact4, false);
task1.addProjectItem(task4);
task1.addProjectItem(task5);
task2.addProjectItem(task6);
task2.addProjectItem(task7);
task2.addProjectItem(task8);
task3.addProjectItem(task9);
task3.addProjectItem(task10);
return project;
}

private static void serializeToFile(Serializable content, String fileName) throws IOException{
ObjectOutputStream serOut = new ObjectOutputStream(new FileOutputStream(fileName));
serOut.writeObject(content);
serOut.close();
}
}
interface ProjectItem extends Serializable{
public static final String EOL_STRING = System.getProperty("line.separator");
public ProjectItem getParent();
public Contact getOwner();
public String getDetails();
public ArrayList getProjectItems();
}
class Project implements ProjectItem{
private String name;
private Contact owner;
private String details;
private ArrayList projectItems = new ArrayList();

public Project(){ }
public Project(String newName, String newDetails, Contact newOwner){
name = newName;
owner = newOwner;
details = newDetails;
}

public String getName(){ return name; }
public String getDetails(){ return details; }
public Contact getOwner(){ return owner; }
public ProjectItem getParent(){ return null; }
public ArrayList getProjectItems(){ return projectItems; }

public void setName(String newName){ name = newName; }
public void setOwner(Contact newOwner){ owner = newOwner; }
public void setDetails(String newDetails){ details = newDetails; }

public void addProjectItem(ProjectItem element){
if (!projectItems.contains(element)){
projectItems.add(element);
}
}

public void removeProjectItem(ProjectItem element){
projectItems.remove(element);
}

public String toString(){
return name;
}
}
class DataRetriever{
public static Object deserializeData(String fileName){
Object returnValue = null;
try{
File inputFile = new File(fileName);
if (inputFile.exists() && inputFile.isFile()){
ObjectInputStream readIn = new ObjectInputStream(new FileInputStream(fileName));
returnValue = readIn.readObject();
readIn.close();
}
else {
System.err.println("Unable to locate the file " + fileName);
}
}
catch (ClassNotFoundException exc){
exc.printStackTrace();

}
catch (IOException exc){
exc.printStackTrace();

}
return returnValue;
}
}

</source>

← Предыдущая	Версия 06:50, 1 июня 2010
(нет различий)

Java/Design Pattern/Call Back Pattern - История изменений

Admin: 1 версия

в 18:01, 31 мая 2010