Newsgroup: it.comp.java
Titolo: [source] DemoPlugins (un esempio che mostra come implementare un meccanismo di estensione a plugin)

questo esempio mostra come implementare un meccanismo di estensione a plugin
//////////////////////////////////////////////////////////////////////////
./DemoPlugins.java
./Figura.java
./plugins/Poligono.java
./plugins/Esagono.java
./plugins/Pentagono.java
./plugins/...
java -classpath . DemoPlugins
/////////////////////////////////////////////////////////////////////////
**********************************
./DemoPlugins.java
**********************************
/*
 * DemoPlugins.java (version 1.1)
 *
 * Copyright (C) 2000 Andrea Medeghini
 * 
http://digilander.iol.it/schiele
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */
import java.net.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
public class DemoPlugins extends Frame implements WindowListener, ActionListener, FilenameFilter
{
	private FiguraMenuItem figura;
	private Disegno disegno;
	public DemoPlugins()
	{
		init();
	}
        	public static void main(String[] args)
        	{
		new DemoPlugins();
        	}
	private void init()
	{
                	try
		{
			System.out.println("DemoPlugins");
			File plugins = new File("plugins");
 
			URL[] urls = 
			{
				plugins.toURL()
			};
 
			Menu[] menu =
			{
				new Menu("figura")
			};
 
			MenuBar menubar = new MenuBar();
 
			menubar.setFont(new Font("Serif",Font.PLAIN,14));
 
			disegno = new Disegno();
 
			ClassLoader loader = new URLClassLoader(urls);
 
			String[] files = plugins.list(this);
 
			for (int k = 0; k < files.length; k++)
			{
	       	       	       	try
	       	       	       	{
					System.out.println("loading " + files[k]);
 
	Class c = loader.loadClass(files[k].substring(0,files[k].length() - 6));
 
					System.out.println("checking plugin...");
 
					Class[] i = c.getInterfaces();
 
					for (int j = 0; j < i.length; j++)
					{
						if (i[j].getName().compareTo("Figura") == 0)
						{
							Figura f = (Figura)c.newInstance();
 
	FiguraMenuItem m = new FiguraMenuItem(f.getName(),f);
 
							menu[0].add(m);
 
							m.addActionListener(this);
 
							System.out.println("plugin added");
						}
					}
				}
				catch (ClassNotFoundException e)
				{
					System.out.println(e);
				}
			}
 
			System.out.println("setting menu...");
 
if ((menu[0].getItemCount() > 0) && (figura = (FiguraMenuItem)menu[0].getItem(0)) != null)
	       	       	{
	       	       	       	disegno.setFigura(figura.getFigura(),Color.black);
	       	       	       	figura.setEnabled(false);
	       	       	}
			menubar.add(menu[0]);
 
			setMenuBar(menubar);
 
			add(disegno);
 
			pack();
 
			setFont(new Font("Serif",Font.PLAIN,14));
 
			setBackground(Color.white);
 
			setSize(getPreferredSize());
 
			setTitle("DemoPlugins");
 
			addWindowListener(this);
			System.out.println("all done.");	
			show();
		}
		catch (Exception e)
                	{
                        		System.out.println(e);
                        		System.exit(0);
                	}
	}
	public boolean accept(File dir,String name)
	{
	       	if (name.endsWith(".class")) 
		{
			return (true);
		}
	       	return (false);
	}
	public void windowClosing(WindowEvent e)
	{
		System.exit(0);
	}
	public void windowClosed(WindowEvent e)
	{
	}
	public void windowOpened(WindowEvent e)
	{
	}
	public void windowActivated(WindowEvent e)
	{
	}
	public void windowDeactivated(WindowEvent e)
	{
	}
	public void windowIconified(WindowEvent e)
	{
	}
	public void windowDeiconified(WindowEvent e)
	{
	}
	public void actionPerformed(ActionEvent e)
	{
	       	if (figura != null)
	       	{
			figura.setEnabled(true);
			figura = (FiguraMenuItem)e.getSource();
			figura.setEnabled(false);	        
 
			disegno.setFigura(figura.getFigura());
	       	}
	}
}
class FiguraMenuItem extends MenuItem
{
	private Figura figura;
	public FiguraMenuItem(String m,Figura f)
	{
	       	super(m);
	       	figura = f;
	}
	public void setFigura(Figura f)
	{
	       	figura = f;
	}
	public Figura getFigura()
	{
	       	return (figura);
	}
}
class Disegno extends Canvas
{
	private Figura figura;
	private Color color;
	public Disegno()
	{
	       	figura = null;
	       	color = Color.white;
	       	setSize(200,200);
	}
	public void setFigura(Figura f,Color c)
	{
	       	figura = f;
	       	color = c;
	       	repaint();
	}
	public void setFigura(Figura f)
	{
	       	figura = f;
	       	repaint();
	}
	public void setColor(Color c)
	{
	       	color = c;
	       	repaint();
	}
	public Figura getFigura()
	{
	       	return (figura);
	}
	public Color getColor()
	{
	       	return (color);
	}
	public void update(Graphics g)
	{
		paint(g);
	}
	public void paint(Graphics g)
	{
	       	int w = getSize().width;
	       	int h = getSize().height;
	       	if (figura != null) 
		{
			figura.disegna(g,color,w,h);
		}
	}
}
**********************************
./Figura.java
***********************************
/*
 * Figura.java (version 1.0)
 */
import java.awt.*;
public interface Figura
{
        	public String getName();
	public void disegna(Graphics g,Color c,int w,int h);
}
**********************************
./plugins/Poligono.java
***********************************
/*
 * Poligono.java (version 1.0)
 */
import java.awt.*;
public class Poligono
{
	private Poligono() {}
 
        	public static void disegna(Graphics g,Color c,int w,int h,int n)
        	{
		double a = (Math.PI + Math.PI) / (double)n;
		double[] x = new double[n];
		double[] y = new double[n];
		double xmax = 0;
		double ymax = 0;
		double xmin = 0;
		double ymin = 0;
		double mx = 0;
		double my = 0;
		double b = 0;
		x[0] = 0;
		y[0] = 0;
		for (int i = 1; i < n; i++) {
			x[i] = x[i - 1] + ((double)Math.cos(b));
			y[i] = y[i - 1] + ((double)Math.sin(b));
			xmax = (x[i] > xmax) ? x[i] : xmax;
			ymax = (y[i] > ymax) ? y[i] : ymax;
			xmin = (x[i] < xmin) ? x[i] : xmin;
			ymin = (y[i] < ymin) ? y[i] : ymin;
			mx += x[i];
			my += y[i];
			b += a;
		}	
		mx = mx / ((double)n);
		my = my / ((double)n);
	double sx = ((double)w) / (2.0d * ((xmax - mx) > (mx - xmin) ? (xmax - mx) : (mx - xmin)));
	double sy = ((double)h) / (2.0d * ((ymax - my) > (my - ymin) ? (ymax - my) : (my - ymin)));
		double s = (sx < sy) ? sx : sy;
		s = 0.8d * s;
		double ox = ((double)w) / 2.0d;
		double oy = ((double)h) / 2.0d;
		int[] px = new int[n];
		int[] py = new int[n];
		for (int i = 0; i < n; i++) {
			px[i] = (int)Math.round(ox + (x[i] - mx) * s);
			py[i] = (int)Math.round(oy - (y[i] - my) * s);
		}	
		Polygon p = new Polygon(px,py,n);
		g.clearRect(0,0,w,h);
		g.setColor(c);
		g.fillPolygon(p);
	}
}
**********************************
./plugins/Esagono.java
***********************************
/*
 * Esagono.java (version 1.0)
 */
import java.awt.*;
public class Esagono implements Figura
{
        	public String getName()
        	{
	       	return ("Esagono");
	}
	public void disegna(Graphics g,Color c,int w,int h)
        	{
	       	try
	       	{
	       	       	Poligono.disegna(g,c,w,h,6);
	       	}
	       	catch (Exception e)
	       	{
	       		System.out.println(e);
	       	}
	}
}
**********************************
./plugins/Pentagono.java
***********************************
/*
 * Pentagono.java (version 1.0)
 */
import java.awt.*;
public class Pentagono implements Figura
{
        	public String getName()
        	{
	       	return ("Pentagono");
	}
        	public void disegna(Graphics g,Color c,int w,int h)
        	{
	       	try
	       	{
	       	       	Poligono.disegna(g,c,w,h,5);
	       	}
	       	catch (Exception e)
	       	{
	       	       	System.out.println(e);
	       	}
	}
}
etc...
http://digilander.iol.it/schiele

questo esempio mostra come implementare un meccanismo di estensione a plugin
Grazie 1000 :P

questo esempio mostra come implementare un meccanismo di estensione a plugin
Ho un amico che dovrebbe fare qualcosa del genere in C++,
tu sai segnalarmi qualche Patterns sui Plug-Ins?
Mi sembrava di aver letto qualcosa ma non ricordo bene dove...
Grazie 1000 ;)

: 

Non se ti vien utile, ma in C/C++ (o in quel che vuoi, dato che si usa 
una feature di s/o :) il modo piu' semplice e' di creare una shared 
library (DLL in win32) che esporti una o piu' funzioni - l'interfaccia 
del plugin, e richiedere che sia in una certa posizione.
A runtime, e' possibile esaminare una dll, o un set di DLL, e verificare 
che l'intera interfaccia (o parte di essa) sia presente.
Sotto win32, COM serve (tra le altre cose) esattamente a questo,
astraendo dalla posizione e dai dettagli per recuperare le signature
dei metodi esportati dalla DLL, quindi e' probabilmente una buona
idea usarla.
-- 
God is Real, unless declared Integer.
ObjectZone - 
http://space.tin.it/computer/csadun



non saprei...
http://digilander.iol.it/schiele