/*
 * @(#)Logger 1.01 2005-4-9
 *
 * Copyright 2005 BeanSoft Studio. All rights reserved.
 * PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package studio.beansoft.util.logging;

import java.io.Serializable;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Logger, provides simple logging control function, only support log to console.
 * Because log4j is too big(larger than 300 KB) to use, so i decide not use it.
 * See static factory methods for details.
 * You might to change the log.properties file for log levels.
 * eg:
 * Logger.getLogger().debug("This is a debug");
 * studio.beansoft.util.logging.Logger.getLogger(this.getClass()).debug("something");
 * 
 * The log level is:
 * 
 * NONE>FATAL>ERROR>WARN>INFO>DEBUG>ALL
 * 
 * 
 * @version 1.01
 * @author BeanSoft
 */
public class Logger implements Serializable {
    /** The logger name. */
    private final String name;
    
    /**
     * Cached instances of allocated logger objects.
     */
    private static Map loggerInstances = new TreeMap();
    
 private static final int NONE = 7;
 
    private static final int ALL = 1;

    private static final int FATAL = 6;

    private static final int ERROR = 5;

    private static final int WARN = 4;

    private static final int INFO = 3;

    private static final int DEBUG = 2;

 

    private static int logLevel = NONE;

    // Load log level from log.properties
    static {
        Properties props = new Properties();
        try {
            props.load(Logger.class.getResourceAsStream("log.properties"));
            String levelStr = props.getProperty("loglevel");

            if ("ALL".equalsIgnoreCase(levelStr)) {
                logLevel = ALL;
            } else if ("ERROR".equalsIgnoreCase(levelStr)) {
                logLevel = ERROR;
            } else if ("WARN".equalsIgnoreCase(levelStr)) {
                logLevel = WARN;
            } else if ("INFO".equalsIgnoreCase(levelStr)) {
                logLevel = INFO;
            } else if ("DEBUG".equalsIgnoreCase(levelStr)) {
                logLevel = DEBUG;
            } else if ("NONE".equalsIgnoreCase(levelStr)) {
                logLevel = NONE;
            } else if ("FATAL".equalsIgnoreCase(levelStr)) {
                logLevel = FATAL;
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Creates new Logger the given logger name.
     * 
     * @param name
     *            the logger name.
     */
    protected Logger(final String name) {
        this.name = name;
        //this.loggerDelegate = getDelegatePlugin(name);
    }
    
    private String formatCurrentDate() {
        DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        return formatter.format(new Date());
    }

    /**
     * Added by BeanSoft.
     * 
     * @return the log level of this class
     */
    public int getLogLevel() {
        return logLevel;
    }

    /**
     * Return the name of this logger.
     * 
     * @return The name of this logger.
     */
    public String getName() {
        return name;
    }

    /**
     * Check to see if the DEBUG level is enabled for this logger.
     * 
     * @return true if a {@link #debug(Object)}method invocation would pass the
     *         msg to the configured appenders, false otherwise.
     */
    public boolean isDebugEnabled() {
        return getLogLevel() >= DEBUG;
    }

    /**
     * Issue a log msg with a level of DEBUG. Invokes log.log(Level.DEBUG,
     * message);
     */
    public void debug(Object message) {
        if (getLogLevel() <= DEBUG) {
            System.out.println(formatCurrentDate() + " " + getName() + ":debug:" + message);
        }
    }

    /**
     * Issue a log msg and throwable with a level of DEBUG. Invokes
     * log.log(Level.DEBUG, message, t);
     */
    public void debug(Object message, Throwable t) {
        if (getLogLevel() <= DEBUG) {
            System.out.println(formatCurrentDate() + " " + getName() + ":" + "debug:" + message);
            t.printStackTrace();
        }
    }

    /**
     * Check to see if the INFO level is enabled for this logger.
     * 
     * @return true if a {@link #info(Object)}method invocation would pass the
     *         msg to the configured appenders, false otherwise.
     */
    public boolean isInfoEnabled() {
        return getLogLevel() <= INFO;
    }

    /**
     * Issue a log msg with a level of INFO. Invokes log.log(Level.INFO,
     * message);
     */
    public void info(Object message) {
        if (getLogLevel() <= INFO) {
            System.out.println(formatCurrentDate() + " " + getName() + ":" + "info:" + message);
        }
    }

    /**
     * Issue a log msg and throwable with a level of INFO. Invokes
     * log.log(Level.INFO, message, t);
     */
    public void info(Object message, Throwable t) {
        if (getLogLevel() <= INFO) {
            System.out.println(formatCurrentDate() + " " + getName() + ":" + "info:" + message);
         t.printStackTrace();
        }
    }

    /**
     * Issue a log msg with a level of WARN. Invokes log.log(Level.WARN,
     * message);
     */
    public void warn(Object message) {
        if (getLogLevel() <= WARN) {
            System.out.println(formatCurrentDate() + " " + getName() + ":" + "warn:" + message);
        }
    }

    /**
     * Issue a log msg and throwable with a level of WARN. Invokes
     * log.log(Level.WARN, message, t);
     */
    public void warn(Object message, Throwable t) {
        if (getLogLevel() <= WARN) {
         System.out.println(formatCurrentDate() + " " + getName() + ":" + "warn:" + message);
         t.printStackTrace();
        }
    }

    /**
     * Issue a log msg with a level of ERROR. Invokes log.log(Level.ERROR,
     * message);
     */
    public void error(Object message) {
        if (getLogLevel() <= ERROR) {
            System.err.println(formatCurrentDate() + " " + getName() + ":" + "error:" + message);
        }
    }

    /**
     * Issue a log msg and throwable with a level of ERROR. Invokes
     * log.log(Level.ERROR, message, t);
     */
    public void error(Object message, Throwable t) {
        if (getLogLevel() <= ERROR) {
            System.err.println(formatCurrentDate() + " " + getName() + ":" + "error:" + message);
            t.printStackTrace(System.err);
        }
    }

    /**
     * Issue a log msg with a level of FATAL. Invokes log.log(Level.FATAL,
     * message);
     */
    public void fatal(Object message) {
        if (getLogLevel() <= FATAL) {
            System.err.println(formatCurrentDate() + " " + getName() + ":" + "fatal error:" + message);
        }        
    }

    /**
     * Issue a log msg and throwable with a level of FATAL. Invokes
     * log.log(Level.FATAL, message, t);
     */
    public void fatal(Object message, Throwable t) {
        if (getLogLevel() <= FATAL) {
            System.err.println(formatCurrentDate() + " " + getName() + ":" + "fatal error:" + message);
            t.printStackTrace(System.err);
        }
    }

    /////////////////////////////////////////////////////////////////////////
    //                            Factory Methods
    /////////////////////////////////////////////////////////////////////////
    
    /**
     * Create a anonymous Logger instance.
     * Date: 2005-04-09
     */
    public static Logger getAnonymousLogger() {
        return getLogger("");
    }
    
    /**
     * Create a Logger instance given the logger name from cached instances.
     * 
     * @param name
     *            the logger name
     */
    public static Logger getLogger(String name) {
        Logger instance = (Logger) loggerInstances.get(name);
        
        if(instance == null) {
            instance = new Logger(name);
//            System.out.println(formatCurrentDate() + " " + instance + " not found, so create it!");
            loggerInstances.put(name, instance);
        }
        return instance;
    }

    /**
     * Create a Logger instance given the logger name with the given suffix.
     * 
     * <p>
     * This will include a logger seperator between classname and suffix
     * 
     * @param name
     *            The logger name
     * @param suffix
     *            A suffix to append to the classname.
     */
    public static Logger getLogger(String name, String suffix) {
        return getLogger(name + "." + suffix);
    }

    /**
     * Create a Logger instance given the logger class. This simply calls
     * create(clazz.getName()).
     * 
     * @param clazz
     *            the Class whose name will be used as the logger name
     */
    public static Logger getLogger(Class clazz) {
        return getLogger(clazz.getName());
    }

    /**
     * Create a Logger instance given the logger class with the given suffix.
     * 
     * <p>
     * This will include a logger seperator between classname and suffix
     * 
     * @param clazz
     *            The Class whose name will be used as the logger name.
     * @param suffix
     *            A suffix to append to the classname.
     */
    public static Logger getLogger(Class clazz, String suffix) {
        return getLogger(clazz.getName() + "." + suffix);
    }
    
    public String toString() {
        return getClass().getName() + "[" + getName() + "]";        
    }
    
    
    public static void main(String[] args) {
        Logger.getLogger("test").fatal("fatal");
  Logger.getLogger("test").error("error");
  Logger.getLogger("test").debug("debug");
    }

}

import java.util.Vector;


/**
 * <meta name="usage" content="internal"/>
 * Pool of object of a given type to pick from to help memory usage
 */
public class ObjectPool implements java.io.Serializable
{

  /** Type of objects in this pool.
   *  @serial          */
  private final Class objectType;

  /** Vector of given objects this points to.
   *  @serial          */
  private final Vector freeStack;

  /**
   * Constructor ObjectPool
   *
   * @param type Type of objects for this pool
   */
  public ObjectPool(Class type)
  {
    objectType = type;
    freeStack = new Vector();
  }

  /**
   * Constructor ObjectPool
   *
   * @param className Fully qualified name of the type of objects for this pool.
   */
  public ObjectPool(String className)
  {
    try
    {
      objectType = Class.forName(className);
    }
    catch(ClassNotFoundException cnfe)
    {
      throw new RuntimeException(cnfe);
    }
    freeStack = new Vector();
  }


  /**
   * Constructor ObjectPool
   *
   *
   * @param type Type of objects for this pool
   * @param size Size of vector to allocate
   */
  public ObjectPool(Class type, int size)
  {
    objectType = type;
    freeStack = new Vector(size);
  }

  /**
   * Constructor ObjectPool
   *
   */
  public ObjectPool()
  {
    objectType = null;
    freeStack = new Vector();
  }

  /**
   * Get an instance of the given object in this pool if available
   *
   *
   * @return an instance of the given object if available or null
   */
  public synchronized Object getInstanceIfFree()
  {

    // Check if the pool is empty.
    if (!freeStack.isEmpty())
    {

      // Remove object from end of free pool.
      Object result = freeStack.lastElement();

      freeStack.setSize(freeStack.size() - 1);

      return result;
    }

    return null;
  }

  /**
   * Get an instance of the given object in this pool
   *
   *
   * @return An instance of the given object
   */
  public synchronized Object getInstance()
  {
 
    // Check if the pool is empty.
    if (freeStack.isEmpty())
    {

      // Create a new object if so.
      try
      {
        return objectType.newInstance();
      }
      catch (InstantiationException ex){}
      catch (IllegalAccessException ex){}

      // Throw unchecked exception for error in pool configuration.
      throw new RuntimeException("exception creating new instance for pool", null); //"exception creating new instance for pool");
    }
    else
    {

      // Remove object from end of free pool.
      Object result = freeStack.lastElement();

      freeStack.setSize(freeStack.size() - 1);

      return result;
    }
  }

  /**
   * Add an instance of the given object to the pool
   *
   *
   * @param obj Object to add.
   */
  public synchronized void freeInstance(Object obj)
  {

    // Make sure the object is of the correct type.
    // Remove safety.  -sb
    // if (objectType.isInstance(obj))
    // {
    freeStack.addElement(obj);
    // }
    // else
    // {
    //  throw new IllegalArgumentException("argument type invalid for pool");
    // }
  }
}

/*
 * @(#)ObjectPoolManager.java 1.00 2005-5-1
 *
 * Copyright 2005 BeanSoft Studio. All rights reserved.
 * PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
import java.util.HashMap;

import beanchat.entity.User;

import studio.beansoft.util.ObjectPool;
import studio.beansoft.util.logging.Logger;

/**
 * ObjectPoolManager, dynamic manage pooled objects' create and release.
 * 
 * @author BeanSoft
 * @version 1.00 2005-5-1
 */
public final class ObjectPoolManager {

 static Logger logger = studio.beansoft.util.logging.Logger.getLogger(ObjectPoolManager.class);
 /**
  * Holds instances of ObjectPool, the main key is the type of objects in this pool. 
  */
 private static HashMap objectPools = new HashMap();
 
 /**
  * This class is not instanceable.
  */
 private ObjectPoolManager() {
 }
 
 /**
  * Get a ObjectPool instance from the objectPools, if not found, then lazilly 
  * create a new one.
  * @param clazz the object type
  * @return the ObjectPool instance
  */
 private static ObjectPool getPool(Class clazz) {
     ObjectPool pool = (ObjectPool)objectPools.get(clazz);
     
     if(pool == null) {
         pool = new ObjectPool(clazz);
         objectPools.put(clazz, pool);
     }
     
     return pool;
 }
 
 /**
  * Get an instance of the given object in the corresponding object pool.
  * @param clazz the object type
  * @return the instance of the object type
  */
 public static Object getInstance(Class clazz) {
  logger.debug("getObject(" + clazz + ")");
  
  return getPool(clazz).getInstance();
 }
 
 /**
  * Free the instance to the corresponding object pool.
  * @param obj the object to be freeed
  */
 public static void freeInstance(Object obj) {
  logger.debug("Free object to pool" + obj);
  
  getPool(obj.getClass()).freeInstance(obj);
 }
 
 public static void main(String[] args) {
     User user = (User)(ObjectPoolManager.getInstance(User.class));
     user.setUserName("Hello");
     ObjectPoolManager.freeInstance(user);
     user = (User)(ObjectPoolManager.getInstance(User.class));
     
     System.out.println(user);
 }
}

import java.awt.*;
import java.io.*;
import java.net.*;
import java.awt.event.*;

/**
 * The multicast datagram socket class is useful for sending
 * and receiving IP multicast packets.  A MulticastSocket is
 * a (UDP) DatagramSocket, with additional capabilities for
 * joining "groups" of other multicast hosts on the internet.
 * <P>
 * A multicast group is specified by a class D IP address, those
 * in the range <CODE>224.0.0.1</CODE> to <CODE>239.255.255.255</CODE>,
 * inclusive, and by a standard UDP port number.  One would join a
 * multicast group by first creating a MulticastSocket with the desired
 * port, then invoking the <CODE>joinGroup(InetAddress groupAddr)</CODE>
 * method:
 * <PRE>
 * // join a Multicast group and send the group salutations
 * ...
 * byte[] msg = {'H', 'e', 'l', 'l', 'o'};
 * InetAddress group = InetAddress.getByName("228.5.6.7");
 * MulticastSocket s = new MulticastSocket(6789);
 * s.joinGroup(group);
 * DatagramPacket hi = new DatagramPacket(msg, msg.length,
 *                             group, 6789);
 * s.send(hi);
 * // get their responses!
 * byte[] buf = new byte[1000];
 * DatagramPacket recv = new DatagramPacket(buf, buf.length);
 * s.receive(recv);
 * ...
 * // OK, I'm done talking - leave the group...
 * s.leaveGroup(group);
 * </PRE>
 *
 * When one sends a message to a multicast group, <B>all</B> subscribing
 * recipients to that host and port receive the message (within the
 * time-to-live range of the packet, see below).  The socket needn't
 * be a member of the multicast group to send messages to it.
 * <P>
 * When a socket subscribes to a multicast group/port, it receives
 * datagrams sent by other hosts to the group/port, as do all other
 * members of the group and port.  A socket relinquishes membership
 * in a group by the leaveGroup(InetAddress addr) method.  <B>
 * Multiple MulticastSocket's</B> may subscribe to a multicast group
 * and port concurrently, and they will all receive group datagrams.
 * <P>
 * Currently applets are not allowed to use multicast sockets.
 */

public class UDPChat extends Frame {
  InetAddress group = null;
  MulticastSocket socket = null;
  String username;
  int port;

  TextArea textArea = new TextArea();
  Panel configPanel = new Panel();
  Label ipLabel = new Label();
  TextField ipField = new TextField(10);
  Label portLabel = new Label();
  TextField portField = new TextField(10);
  Label nameLabel = new Label();
  TextField nameField = new TextField(10);
  Panel messagePanel = new Panel();
  Button joinButton = new Button();
  Button leaveButton = new Button();
  TextField messageField = new TextField(80);
  Button sendButton = new Button();
  Button emptyButton = new Button();

  public UDPChat() {
    try  {
      jbInit();
      leaveButton.setEnabled(false);
      sendButton.setEnabled(false);
      textArea.setEditable(false);
      pack();
      show();
    }
    catch(Exception e) {
      e.printStackTrace();
    }
  }

  public static void main(String[] args) {
    UDPChat uDPChat = new UDPChat();
  }

  private void jbInit() throws Exception {
    this.setTitle("多点传送数据报聊天程序 - IP地址范围: 224.0.0.1 ~ 239.255.255.255");
    this.addWindowListener(new java.awt.event.WindowAdapter() {

      public void windowClosing(WindowEvent e) {
        this_windowClosing(e);
      }
    });
    ipLabel.setText("IP:");
    ipField.setText("225.0.0.1");
    portLabel.setText("端口:");
    portField.setText("4000");
    nameLabel.setText("用户名:");
    nameField.setText("匿名");
    joinButton.setForeground(Color.blue);
    joinButton.setLabel("进入");
    joinButton.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        join();
      }
    });
    leaveButton.setForeground(Color.red);
    leaveButton.setLabel("离开");
    leaveButton.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        leave();
      }
    });
    messageField.setText("这里输入要发送的文字");
    messageField.addActionListener(new java.awt.event.ActionListener() {
       public void actionPerformed(ActionEvent e) {
        send();
      }
    });
    sendButton.setLabel("    发送    ");
    sendButton.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        send();
      }
    });
    emptyButton.setLabel("清空记录");
    emptyButton.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(ActionEvent e) {
        emptyButton_actionPerformed(e);
      }
    });
    this.add(configPanel, BorderLayout.NORTH);
    configPanel.add(ipLabel);
    configPanel.add(ipField);
    configPanel.add(portLabel);
    configPanel.add(portField);
    configPanel.add(nameLabel);
    configPanel.add(nameField);
    this.add(messagePanel, BorderLayout.SOUTH);
    messagePanel.add(messageField);
    messagePanel.add(sendButton);

    this.add(textArea, BorderLayout.CENTER);
    Panel p = new Panel();
    p.setLayout(new GridBagLayout());
    GridBagConstraints c = new GridBagConstraints();
    c.weightx = c.weighty = 1;c.fill = GridBagConstraints.HORIZONTAL;
    c.gridx = 0; c.gridy = 0;
    p.add(joinButton, c);
    c.gridy ++;
    p.add(leaveButton, c);
    c.gridy ++;
    p.add(emptyButton, c);
    this.add(p, BorderLayout.WEST);
  }

  void join() {
    username = nameField.getText();
    if(username.equals("")) {
      textArea.append("请你务必首先输入一个名字.\n");
      return;
    }
    try {
      textArea.append("尝试进入聊天室...\n");
      group = InetAddress.getByName(ipField.getText());
      port = Integer.parseInt(portField.getText());
      socket = new MulticastSocket(port);
      socket.joinGroup(group);
      String message = username +  "[" + InetAddress.getLocalHost() + "] 进入聊天室 " + group + "! 端口号"
        + portField.getText() + ".\n";
      DatagramPacket hi = new DatagramPacket(message.getBytes(),
        message.getBytes().length, group, port);
      socket.send(hi);
      nameField.setEditable(false);
      joinButton.setEnabled(false);
      leaveButton.setEnabled(true);
      sendButton.setEnabled(true);
      new ReaderThread().start();
    }catch(Exception ex) {
      textArea.append("无法进入聊天室:" + ex + "\n");
      ex.printStackTrace();
    }
  }

  void send() {
    if(socket == null) return;
    try {
      String message = username + "[" + InetAddress.getLocalHost() + "] : " + messageField.getText() + "\n";
      DatagramPacket hi = new DatagramPacket(message.getBytes(),
        message.getBytes().length, group, port);
      socket.send(hi);
      messageField.requestFocus();
      messageField.selectAll();
    }catch(Exception ex) {
      textArea.append("无法发送消息:" + ex + "\n");
    }
  }

  void leave() {
    if(socket == null) return;
    try {
      textArea.append("尝试离开聊天室...");
      String message = username + " 已经离开了聊天室 " + group  + "!\n";
      DatagramPacket hi = new DatagramPacket(message.getBytes(),
        message.getBytes().length, group, port);
      socket.send(hi);
      socket.leaveGroup(group);
      socket.close();
      socket = null;
      nameField.setEditable(true);
      joinButton.setEnabled(true);
      leaveButton.setEnabled(false);
      sendButton.setEnabled(false);
      textArea.append("你已经离开了聊天室!\n");
    }catch(Exception ex) {
      textArea.append("无法离开聊天室:" + ex + "\n");
      ex.printStackTrace();
    }
  }

  void this_windowClosing(WindowEvent e) {
    leave();
    System.exit(0);
  }
  
  class ReaderThread extends Thread {

    public void run() {
      while(socket != null) {
        try {
          byte[] buf = new byte[1024];
          DatagramPacket recv = new DatagramPacket(buf, buf.length);
          socket.receive(recv);
          textArea.append(new String(recv.getData()));
        }catch(Exception ex) {
        }
      }
    }

  }

  void emptyButton_actionPerformed(ActionEvent e) {
    textArea.setText("");
  }

}