Cho phép cài plugin trong java như thế nào?

public interface PluginFunction { // let the application pass in a parameter public void setParameter (int param); // retrieve a result from the plugin public int getResult(); // return the name of this plugin public String getPluginName(); // can be called to determine whether the plugin // aborted execution due to an error condition public boolean hasError(); }

import java.io.File; import java.util.*; public class PluginDemo { //parameter for plugins int count; // the directory where we keep the plugin classes String pluginsDir; // a list where we keep an initialized object of each plugin class List plugins; public static void main (String args[]) { PluginDemo demo = new PluginDemo(args); demo.getPlugins(); demo.runPlugins(); } PluginDemo (String args[]) { if (args.length > 0) count = Integer.parseInt(args[0]); else count = 1; if (args.length > 1) pluginsDir = args[0]; else pluginsDir = "plugins"; plugins = new ArrayList(); System.setSecurityManager(new PluginSecurityManager(pluginsDir)); } protected void getPlugins() { File dir = new File(System.getProperty("user.dir") + File.separator + pluginsDir); ClassLoader cl = new PluginClassLoader(dir); if (dir.exists() && dir.isDirectory()) { // we'll only load classes directly in this directory - // no subdirectories, and no classes in packages are recognized String[] files = dir.list(); for (int i=0; i<files.length; i++) { try { // only consider files ending in ".class" if (! files[i].endsWith(".class")) continue; Class c = cl.loadClass(files[i].substring(0, files[i].indexOf("."))); Class[] intf = c.getInterfaces(); for (int j=0; j<intf.length; j++) { if (intf[j].getName().equals("PluginFunction")) { // the following line assumes that PluginFunction has a no-argument constructor PluginFunction pf = (PluginFunction) c.newInstance(); plugins.add(pf); continue; } } } catch (Exception ex) { System.err.println("File " + files[i] + " does not contain a valid PluginFunction class."); } } } } protected void runPlugins() { Iterator iter = plugins.iterator(); while (iter.hasNext()) { PluginFunction pf = (PluginFunction) iter.next(); try { pf.setParameter(count); System.out.print(pf.getPluginName()); System.out.print(" ( "+count+" ) = "); if (pf.hasError()) { System.out.println("there was an error during plugin initialization"); continue; } int result = pf.getResult(); if (pf.hasError()) System.out.println("there was an error during plugin execution"); else System.out.println(result); count++; } catch (SecurityException secEx) { System.err.println("plugin '"+pf.getClass().getName()+"' tried to do something illegal"); } } } }

import java.io.File; /** * This is a fairly uptight security manager subclass. Classes loaded by * the PluginClassLoader are highly restricted in what they are allowed to do. * This is okay, because they're only supposed to calculate some values, * for which all necessary data is already available to them. * * A SecurityManager consists of various methods that the system calls to * check whether certain sensitive operations should be allowed. These * methods can throw a SecurityException to prevent the operation from * happening. With this SecurityManager, we want to prevent untrusted * code that was loaded by a class loader from performing those sensitive operations. * So we use inherited SecurityManager methods to check whether the call is being * made by an untrusted class. If it is, we throw an exception. * Otherwise, we simply return, allowing the operation to proceed normally. */ public class PluginSecurityManager extends SecurityManager { private String pluginDir = null; PluginSecurityManager (String dir) { pluginDir = dir; } /** * This is the basic method that tests whether there is a class loaded * by a ClassLoader anywhere on the stack. If so, it means that that * untrusted code is trying to perform some kind of sensitive operation. * We prevent it from performing that operation by throwing an exception. * trusted() is called by most of the check...() methods below. */ protected void trusted() { if (inClassLoader()) throw new SecurityException(); } /** * These are all the specific checks that a security manager can * perform. They all just call one of the methods above and throw a * SecurityException if the operation is not allowed. This * SecurityManager subclass is perhaps a little too restrictive. For * example, it doesn't allow loaded code to read *any* system properties, * even though some of them are quite harmless. */ public void checkCreateClassLoader() { trusted(); } public void checkAccess (Thread g) { trusted(); } public void checkAccess (ThreadGroup g) { trusted(); } public void checkExit (int status) { throw new SecurityException("Not allowed."); } public void checkExec (String cmd) { trusted(); } public void checkLink (String lib) { trusted(); } public void checkRead (java.io.FileDescriptor fd) { trusted(); } public void checkRead (String file) { // String path = new File(file).getParentFile().getAbsolutePath(); // if (! path.endsWith(pluginDir)) trusted(); } public void checkRead (String file, Object context) { trusted(); } public void checkWrite (java.io.FileDescriptor fd) { trusted(); } public void checkWrite (String file) { trusted(); } public void checkDelete (String file) { trusted(); } public void checkConnect (String host, int port) { trusted(); } public void checkConnect (String host,int port,Object context) {trusted();} public void checkListen (int port) { trusted(); } public void checkAccept (String host, int port) { trusted(); } public void checkMulticast (java.net.InetAddress maddr) { trusted(); } public void checkMulticast (java.net.InetAddress maddr, byte ttl) { trusted(); } public void checkPropertiesAccess() { trusted(); } public void checkPropertyAccess (String key) { // if (! key.equals("user.dir")) trusted(); } public void checkPrintJobAccess() { trusted(); } public void checkSystemClipboardAccess() { trusted(); } public void checkAwtEventQueueAccess() { trusted(); } public void checkSetFactory() { trusted(); } public void checkMemberAccess (Class clazz, int which) { trusted(); } public void checkSecurityAccess (String provider) { trusted(); } /** Loaded code can only load classes from java.* packages */ public void checkPackageAccess (String pkg) { if (inClassLoader() && !pkg.startsWith("java.") && !pkg.startsWith("javax.")) throw new SecurityException(); } /** Loaded code can't define classes in java.* or sun.* packages */ public void checkPackageDefinition (String pkg) { if (inClassLoader() && ((pkg.startsWith("java.") || pkg.startsWith("javax.") || pkg.startsWith("sun.")))) throw new SecurityException(); } /** * This is the one SecurityManager method that is different from the * others. It indicates whether a top-level window should display an * "untrusted" warning. The window is always allowed to be created, so * this method is not normally meant to throw an exception. It should * return true if the window does not need to display the warning, and * false if it does. In this example, however, our text-based Service * classes should never need to create windows, so we will actually * throw an exception to prevent any windows from being opened. **/ public boolean checkTopLevelWindow (Object window) { trusted(); return true; } }