Choix du framework de plugin Java

Question

Nous essayons de déterminer comment mettre en œuvre un plugin simple cadre pour un service que nous mettons en œuvre différents types de calculatrices pour être "branché".

Après la lecture d'un certain nombre de messages sur les plug-in Java, frameworks, il semble que les options les plus courantes sont:

• OSGI
• "Roulement de votre propre" plugin cadre
• Le plug-in Java, Framework (JPF)
• Le Java Plugin Simple Cadre (JSPF)

OSGI semble être plus que nous avons besoin.

"Le déploiement de votre propre" est ok, mais il serait agréable de les réutiliser d'une bibliothèque commune.

Nous en sommes à la JPF et JSPF. JPF ne semble pas être en développement actif plus.

JSPF semble très simple et vraiment tout ce dont nous avons besoin. Cependant, je n'ai pas beaucoup entendu parler. J'ai seulement vu un post sur StackOverflow à ce sujet. Personne d'autre ne avez aucune expérience avec JSPF? Ou tout autres commentaires sur ce choix de conception?

---

Mise à jour: Il n'y a pas nécessairement une réponse correcte à cette question.. mais nous allons y aller avec Pavol de l'idée que nous avons juste besoin d'un vraiment, vraiment de solution simple. Grâce EoH pour le guide de nice.

Answer 1

(Disclaimer: je suis l'auteur de JSPF, afin de mieux prendre mon commentaire avec un grain de sel ;-)

La principale raison que j'ai commencé avec le JSPF était parce que j'avais le même problème que vous avez maintenant: je cherchais une solution simple pour faire ma thèse-projet 1) extensible et 2) donner une plus ou moins claire de la structure de code.

La raison pour laquelle je n'ai pas décidé d'utiliser un cadre existant est parce que la plupart d'entre eux étaient si lourds pour commencer, que je me suis perdu dans la lecture de la documentation et était presque oublier ma tâche d'origine. Donc, selon votre déclaration

Nous essayons de déterminer comment mettre en œuvre un plugin simple cadre pour un service que nous de la mise en œuvre permet différents types de calculatrices pour être "branché".

Je pense que vous pourriez donner à JSPF un coup et de voir dans quelle mesure vous venez dans un délai d'une ou deux heures.

Toutefois, la décision finale dépend aussi un peu sur ce qu'est exactement que vous voulez atteindre, et les circonstances particulières.

J'ai entendu parler des résultats positifs à partir d'un certain nombre de personnes qui ont été l'utiliser pour structurer leurs projets ou de charger des plugins dans leurs projets. D'autre part, je connais également une personne dans notre département qui jeté de nouveau parce qu'il n'a pas l'impression que c'était en mélangeant bien avec son style de programmation.

Donc, pour répondre à votre question brièvement (et sûrement de façon biaisée), je voudrais utiliser

OSGi pour des projets et des équipes

• qui sont grandes et ont beaucoup de gens qui travaillent sur elle
• pour justifier la surcharge de la configuration de l'infrastructure
• dans le besoin de certains services spécifiques offerts

JPF pour des projets et des équipes

• de taille moyenne (?, honnêtement, je ne suis pas sûr au sujet du projet / taille de l'équipe, ils sont ciblage)
• qui sont dans le besoin de plus structurée des installations pour organiser leur code, comme les configurations XML, détaillé plugin de gestion du cycle de vie, extensible plugins ...

JSPF pour des projets et des équipes

• de petite taille, à la suite d'un agile paradigme
• qui a besoin de quelque chose qui fonctionne hors de la boîte, sans avoir besoin de configurations ou de configuration
• prêt à sacrifier un peu de fonctionnalités pour plus de simplicité

J'espère que vous trouverez le plugin cadre le plus approprié pour votre scénario. Et, peu importe ce que vous essayez, je serais heureux de connaître vos résultats.

Answer 2

Si vous prévoyez d'avoir un seul (ou peu), pas très complexe 'extension de points que peut-être bien définie de SPI et un morceau de configuration peut être suffisant. Pas besoin d'utiliser un plugin cadre.

Par morceau de configuration, je veux dire un mécanisme pour trouver vos plugins. Par exemple quelque chose comme META-INF/services/ ou tout simplement de votre liste de plugins dans un fichier de configuration.

Plus de détails (sur demande):

SPI = Interface du Fournisseur de Services, un "responsable de l'implémentation de côté l'équivalent d'une API". Pour en savoir plus, essayez de rechercher une différence entre l'API et le SPI. Cependant, dans ce contexte, il est juste un terme de fantaisie pour une interface à être mis en œuvre par vos plugins (c'est à dire définit votre contrat de plugins).

Un joli petit article "Création d'un Service Provider Interface" par Ethan Nicolas explique comment créer votre propre SPI de la même façon, comme c'est fait dans plusieurs partie de la Plate-forme Java lui-même.

META-INF/services/ peut être considéré comme un plus généralisé de l'approche pour la création de SPIs. Plus d'informations peuvent être trouvées dans la section correspondante de la JAR Fichier de Spécification.

Answer 3

Si vous avez besoin d’une solution très simple, essayez jin-plugin . C'est un framework de plugin minimaliste pour Java et PHP.

Answer 4

Salut tout le monde encore en regardant ce post...

J'ai une réponse, j'ai essayé, et une question de suivi pour vous. Je suis assez nouveau à Java, donc j'apprécierais toute aide.

Comme je suis encore en apprentissage, j'ai souvent envie de suivre le "rouler" paradigme. Après beaucoup de recherche autour, j'ai trouvé ça assez facile.

Ma petite application de l'analyse d'un dossier pour tous les fichiers jar et ressemble à chacun d'entre eux. Le fichier jar contient une ressource au plus haut niveau appelés "composants". C'est un fichier texte qui contient une ligne pour chaque nom de classe entièrement qualifié dans le fichier jar qui implémente mon interface de base appelé "Composant".

Puis mon chargeur de plugin fait ceci:

public class ComponentLoader {
    static class JarClassLoader extends URLClassLoader
    {
        public JarClassLoader(File jarFile) throws MalformedURLException {
            super ( new URL[] { jarFile.toURI().toURL() } );
        }

        static String nextComponentName(BufferedReader br) {
            try {
                String read = br.readLine();
                if (read != null && read.length() != 0) {
                    return read;
                }
                else {
                    return null;
                }
            } catch (Exception e) {
                return null;
            }
        }

        public ArrayList<Component> findComponents() {
            ArrayList<Component> compArrayList = new ArrayList<Component>();

            // Look for a resource file that tells me what components to load
            InputStream in = this.getResourceAsStream("components");
            if (in == null) return null;

            InputStreamReader is = new InputStreamReader(in);
            BufferedReader br = new BufferedReader(is);

            String compName = nextComponentName(br);
            while (compName != null) {
                // Find a class with the right name
                try {
                    Class<?> compClass = loadClass(compName);
                    compArrayList.add((Component) compClass.newInstance());

                } catch (Exception e) {
                    e.printStackTrace();
                }

                // Get ready for the next one
                compName = nextComponentName(br);
            }

            return compArrayList;
        }
    }

    public static Component[] readComponents(String componentFolderName) {
        File compFolder = new File(componentFolderName);
        File componentFiles[] = compFolder.listFiles();
        ArrayList<Component> compArrayList = new ArrayList<Component>();
        for (int i = 0; i < componentFiles.length; ++i) {
            try {
                JarClassLoader jcl = new JarClassLoader(componentFiles[i]);
                compArrayList.addAll(jcl.findComponents());
            }
            catch (Exception e) { // TODO: any error handling?
            }
        }
        return compArrayList.toArray(new Component[compArrayList.size()]);
    }
}

C'est en fait travaillé vraiment bien et je peux ouvrir les fichiers jar qui ne sont pas sur mon chemin de classe. Je me demandais, cependant, si je pouvais être un moyen pour un développeur de composants pour déboguer leurs petits composants dans Eclipse sans avoir le code source de mon application dans la réalité. - Je fournir une base de bibliothèque Java dans un fichier jar qui est le Composant de l'interface et l'utilisateur exécute le fichier jar exécutable pour que le programme principal, qui ne le répertoire de numérisation à la charge de leurs Composants. J'aimerais avoir de l'Éclipse exécuter mon application avec les crochets dans leur Composante du projet (de préférence avant de l'exporter en tant que fichier jar). Je pense à quelque chose comme comment Eclipse vous permet d'exécuter vos tests JUnit (et de débogage) en exécutant la JUnit exécutable.

Merci pour toutes les idées, -- Rick