Java中会议模式 : 会议模式 « 设计模式 « Java

En
Java
1. 图形用户界面
2. 三维图形动画
3. 高级图形
4. 蚂蚁编译
5. Apache类库
6. 统计图
7. 
8. 集合数据结构
9. 数据类型
10. 数据库JDBC
11. 设计模式
12. 开发相关类
13. EJB3
14. 电子邮件
15. 事件
16. 文件输入输出
17. 游戏
18. 泛型
19. GWT
20. Hibernate
21. 本地化
22. J2EE平台
23. 基于J2ME
24. JDK-6
25. JNDI的LDAP
26. JPA
27. JSP技术
28. JSTL
29. 语言基础知识
30. 网络协议
31. PDF格式RTF格式
32. 映射
33. 常规表达式
34. 脚本
35. 安全
36. Servlets
37. Spring
38. Swing组件
39. 图形用户界面
40. SWT-JFace-Eclipse
41. 线程
42. 应用程序
43. Velocity
44. Web服务SOA
45. 可扩展标记语言
Java 教程
Java » 设计模式 » 会议模式屏幕截图 
Java中会议模式

//[C] 2002 Sun Microsystems, Inc.---

import java.io.IOException;
import java.io.Serializable;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import java.util.HashMap;

public class RunSessionPattern {
  public static void main(String[] arguments) {
    System.out.println("Example for the Session pattern");
    System.out
        .println("This demonstration will show how a Session can be used");
    System.out
        .println(" to organize a series of actions between a client and");
    System.out.println(" server.");
    System.out
        .println("In this case, clients will use sessions to coordinate");
    System.out.println(" edits of Contact addresses.");
    System.out.println();

    System.out.println("Running the RMI compiler (rmic)");
    System.out.println();
    try {
      Process p1 = Runtime.getRuntime().exec("rmic SessionServerImpl");
      p1.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 SessionServer and two SessionClient objects");
    System.out.println();
    SessionServer serverObject = new SessionServerImpl();
    SessionClient clientOne = new SessionClient();
    SessionClient clientTwo = new SessionClient();

    System.out.println("Creating sample Contacts and Addresses");
    System.out.println();
    Contact firstContact = new ContactImpl("First""Contact""primo",
        "OOI"null);
    Contact secondContact = new ContactImpl("Second""Contact""secondo",
        "OOI"null);
    Address workAddress = new AddressImpl("Work address""5440 Division",
        "Fargo""ND""54321");
    Address homeAddress = new AddressImpl("Home address""40 Planar Way",
        "Paris""TX""84301");

    System.out
        .println("Adding a contact. Both clients will attempt to edit");
    System.out
        .println(" the same contact at first, which will result in a");
    System.out.println(" SessionException.");
    try {
      clientOne.addContact(firstContact);
      clientTwo.addContact(firstContact);
    catch (SessionException exc) {
      System.err.println("Exception encountered:");
      System.err.println(exc);
    }
    try {
      System.out
          .println("Adding a different contact to the second client");
      clientTwo.addContact(secondContact);
      System.out
          .println("Adding addresses to the first and second clients");
      clientTwo.addAddress(workAddress);
      clientOne.addAddress(homeAddress);
      clientTwo.addAddress(workAddress);
      clientTwo.addAddress(homeAddress);
      System.out.println("Removing address from a client");
      clientTwo.removeAddress(homeAddress);
      System.out.println("Finalizing the edits to the contacts");
      clientOne.commitChanges();
      clientTwo.commitChanges();
      System.out.println("Changes finalized");
      clientTwo.addContact(firstContact);
    catch (SessionException exc) {
      System.err.println("Exception encountered:");
      System.err.println(exc);
    }
    System.out.println("The following lines will show the state");
    System.out.println(" of the server-side delegate, which in this");
    System.out.println(" example represents a persistent data store.");
    System.out.println();
    System.out.println("Contact list:");
    System.out.println(SessionServerDelegate.getContacts());
    System.out.println("Address list:");
    System.out.println(SessionServerDelegate.getAddresses());
    System.out.println("Edit contacts:");
    System.out.println(SessionServerDelegate.getEditContacts());
  }
}

interface Address extends Serializable {
  public static final String EOL_STRING = System
      .getProperty("line.separator");

  public static final String SPACE = " ";

  public static final String COMMA = ",";

  public String getType();

  public String getDescription();

  public String getStreet();

  public String getCity();

  public String getState();

  public String getZipCode();

  public void setType(String newType);

  public void setDescription(String newDescription);

  public void setStreet(String newStreet);

  public void setCity(String newCity);

  public void setState(String newState);

  public void setZipCode(String newZip);
}

class AddressImpl implements Address {
  private String type;

  private String description;

  private String street;

  private String city;

  private String state;

  private String zipCode;

  public AddressImpl() {
  }

  public AddressImpl(String newDescription, String newStreet, String newCity,
      String newState, String newZipCode) {
    description = newDescription;
    street = newStreet;
    city = newCity;
    state = newState;
    zipCode = newZipCode;
  }

  public String getType() {
    return type;
  }

  public String getDescription() {
    return description;
  }

  public String getStreet() {
    return street;
  }

  public String getCity() {
    return city;
  }

  public String getState() {
    return state;
  }

  public String getZipCode() {
    return zipCode;
  }

  public void setType(String newType) {
    type = newType;
  }

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

  public void setStreet(String newStreet) {
    street = newStreet;
  }

  public void setCity(String newCity) {
    city = newCity;
  }

  public void setState(String newState) {
    state = newState;
  }

  public void setZipCode(String newZip) {
    zipCode = newZip;
  }

  public boolean equals(Object o) {
    if (!(instanceof AddressImpl)) {
      return false;
    else {
      AddressImpl address = (AddressImplo;
      if (street.equals(address.street&& city.equals(address.city)
          && state.equals(address.state)
          && zipCode.equals(address.zipCode)) {
        return true;
      }
      return false;
    }
  }

  public String toString() {
    return street + EOL_STRING + city + COMMA + SPACE + state + SPACE
        + zipCode + EOL_STRING;
  }
}

class SessionServerImpl implements SessionServer {
  private static final String SESSION_SERVER_SERVICE_NAME = "sessionServer";

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

  public long addContact(Contact contact, long sessionID)
      throws SessionException {
    return SessionServerDelegate.addContact(contact, sessionID);
  }

  public long addAddress(Address address, long sessionID)
      throws SessionException {
    return SessionServerDelegate.addAddress(address, sessionID);
  }

  public long removeAddress(Address address, long sessionID)
      throws SessionException {
    return SessionServerDelegate.removeAddress(address, sessionID);
  }

  public long finalizeContact(long sessionIDthrows SessionException {
    return SessionServerDelegate.finalizeContact(sessionID);
  }
}

interface SessionServer extends Remote {
  public long addContact(Contact contact, long sessionID)
      throws RemoteException, SessionException;

  public long addAddress(Address address, long sessionID)
      throws RemoteException, SessionException;

  public long removeAddress(Address address, long sessionID)
      throws RemoteException, SessionException;

  public long finalizeContact(long sessionIDthrows RemoteException,
      SessionException;
}

class SessionServerDelegate {
  private static final long NO_SESSION_ID = 0;

  private static long nextSessionID = 1;

  private static ArrayList contacts = new ArrayList();

  private static ArrayList addresses = new ArrayList();

  private static HashMap editContacts = new HashMap();

  public static long addContact(Contact contact, long sessionID)
      throws SessionException {
    if (sessionID <= NO_SESSION_ID) {
      sessionID = getSessionID();
    }
    if (contacts.indexOf(contact!= -1) {
      if (!editContacts.containsValue(contact)) {
        editContacts.put(new Long(sessionID), contact);
      else {
        throw new SessionException(
            "This contact is currently being edited by another user.",
            SessionException.CONTACT_BEING_EDITED);
      }
    else {
      contacts.add(contact);
      editContacts.put(new Long(sessionID), contact);
    }
    return sessionID;
  }

  public static long addAddress(Address address, long sessionID)
      throws SessionException {
    if (sessionID <= NO_SESSION_ID) {
      throw new SessionException(
          "A valid session ID is required to add an address",
          SessionException.SESSION_ID_REQUIRED);
    }
    Contact contact = (ContacteditContacts.get(new Long(sessionID));
    if (contact == null) {
      throw new SessionException(
          "You must select a contact before adding an address",
          SessionException.CONTACT_SELECT_REQUIRED);
    }
    if (addresses.indexOf(address== -1) {
      addresses.add(address);
    }
    contact.addAddress(address);
    return sessionID;
  }

  public static long removeAddress(Address address, long sessionID)
      throws SessionException {
    if (sessionID <= NO_SESSION_ID) {
      throw new SessionException(
          "A valid session ID is required to remove an address",
          SessionException.SESSION_ID_REQUIRED);
    }
    Contact contact = (ContacteditContacts.get(new Long(sessionID));
    if (contact == null) {
      throw new SessionException(
          "You must select a contact before removing an address",
          SessionException.CONTACT_SELECT_REQUIRED);
    }
    if (addresses.indexOf(address== -1) {
      throw new SessionException("There is no record of this address",
          SessionException.ADDRESS_DOES_NOT_EXIST);
    }
    contact.removeAddress(address);
    return sessionID;
  }

  public static long finalizeContact(long sessionIDthrows SessionException {
    if (sessionID <= NO_SESSION_ID) {
      throw new SessionException(
          "A valid session ID is required to finalize a contact",
          SessionException.SESSION_ID_REQUIRED);
    }
    Contact contact = (ContacteditContacts.get(new Long(sessionID));
    if (contact == null) {
      throw new SessionException(
          "You must select and edit a contact before committing changes",
          SessionException.CONTACT_SELECT_REQUIRED);
    }
    editContacts.remove(new Long(sessionID));
    return NO_SESSION_ID;
  }

  private static long getSessionID() {
    return nextSessionID++;
  }

  public static ArrayList getContacts() {
    return contacts;
  }

  public static ArrayList getAddresses() {
    return addresses;
  }

  public static ArrayList getEditContacts() {
    return new ArrayList(editContacts.values());
  }
}

interface Contact extends Serializable {
  public static final String SPACE = " ";

  public static final String EOL_STRING = System
      .getProperty("line.separator");

  public String getFirstName();

  public String getLastName();

  public String getTitle();

  public String getOrganization();

  public ArrayList getAddresses();

  public void setFirstName(String newFirstName);

  public void setLastName(String newLastName);

  public void setTitle(String newTitle);

  public void setOrganization(String newOrganization);

  public void addAddress(Address address);

  public void removeAddress(Address address);
}

class ContactImpl implements Contact {
  private String firstName;

  private String lastName;

  private String title;

  private String organization;

  private ArrayList addresses = new ArrayList();

  public ContactImpl() {
  }

  public ContactImpl(String newFirstName, String newLastName,
      String newTitle, String newOrganization, ArrayList newAddresses) {
    firstName = newFirstName;
    lastName = newLastName;
    title = newTitle;
    organization = newOrganization;
    if (newAddresses != null) {
      addresses = newAddresses;
    }
  }

  public String getFirstName() {
    return firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public String getTitle() {
    return title;
  }

  public String getOrganization() {
    return organization;
  }

  public ArrayList getAddresses() {
    return addresses;
  }

  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 void addAddress(Address address) {
    if (!addresses.contains(address)) {
      addresses.add(address);
    }
  }

  public void removeAddress(Address address) {
    addresses.remove(address);
  }

  public boolean equals(Object o) {
    if (!(instanceof ContactImpl)) {
      return false;
    else {
      ContactImpl contact = (ContactImplo;
      if (firstName.equals(contact.firstName)
          && lastName.equals(contact.lastName)
          && organization.equals(contact.organization)
          && title.equals(contact.title)) {
        return true;
      }
      return false;
    }
  }

  public String toString() {
    return firstName + SPACE + lastName + EOL_STRING + addresses;
  }
}

class SessionClient {
  private static final String SESSION_SERVER_SERVICE_NAME = "sessionServer";

  private static final String SESSION_SERVER_MACHINE_NAME = "localhost";

  private long sessionID;

  private SessionServer sessionServer;

  public SessionClient() {
    try {
      String url = "//" + SESSION_SERVER_MACHINE_NAME + "/"
          + SESSION_SERVER_SERVICE_NAME;
      sessionServer = (SessionServerNaming.lookup(url);
    catch (RemoteException exc) {
    catch (NotBoundException exc) {
    catch (MalformedURLException exc) {
    catch (ClassCastException exc) {
    }
  }

  public void addContact(Contact contactthrows SessionException {
    try {
      sessionID = sessionServer.addContact(contact, 0);
    catch (RemoteException exc) {
    }
  }

  public void addAddress(Address addressthrows SessionException {
    try {
      sessionServer.addAddress(address, sessionID);
    catch (RemoteException exc) {
    }
  }

  public void removeAddress(Address addressthrows SessionException {
    try {
      sessionServer.removeAddress(address, sessionID);
    catch (RemoteException exc) {
    }
  }

  public void commitChanges() throws SessionException {
    try {
      sessionID = sessionServer.finalizeContact(sessionID);
    catch (RemoteException exc) {
    }
  }
}

class SessionException extends Exception {
  public static final int CONTACT_BEING_EDITED = 1;

  public static final int SESSION_ID_REQUIRED = 2;

  public static final int CONTACT_SELECT_REQUIRED = 3;

  public static final int ADDRESS_DOES_NOT_EXIST = 4;

  private int errorCode;

  public SessionException(String cause, int newErrorCode) {
    super(cause);
    errorCode = newErrorCode;
  }

  public SessionException(String cause) {
    super(cause);
  }

  public int getErrorCode() {
    return errorCode;
  }
}


           
       
Related examples in the same category
www.java2java.com | Contact Us
Copyright 2010 - 2030 Java Source and Support. All rights reserved.
All other trademarks are property of their respective owners.