L'ERP opensource vu par Apache

Les projets de la fondation Apache ont ceci de particulier que leur licence permet une grande permissivité et une grande possibilité d'intégration dans d'autre projets. Il existe un projet particulièrement intérressant qui est OfBiz. Il s'agit d'une librairie destinée à la réalisation de logiciels de gestion et de site de e-commerce. Elle a permis le lancement de nombreux projets d'ERP opens-source comme Neogia ou OpenTabs.

à voir :

OFBiz

OpenTabs

Neogia

Hello BCEL

Voici un autre exemple de programme autour de BCEL. Il s'agit d'un générateur de classe "Hello World". Ce programme instancie et appel ensuite la méthode qui va bien pour afficher le message "Hello World"

import org.apache.bcel.generic.*;
import org.apache.bcel.*;
import java.io.*;

public class FabriqueDeClasseHelloWorld implements Constants {
 private InstructionFactory fabriquePourInstructions;
 private ConstantPoolGen listeDesConstantesDeLaNouvelleClasse;
 private ClassGen classeAConstruire;

 // nom de la nouvelle classe à créer
 static private String classNameTarget() {
  return "HelloWorld3";
 }

 public FabriqueDeClasseHelloWorld() {
  classeAConstruire = new ClassGen(classNameTarget(), "java.lang.Object",
    classNameTarget()+".java", ACC_PUBLIC | ACC_SUPER, new String[] {});
  listeDesConstantesDeLaNouvelleClasse = classeAConstruire
    .getConstantPool();
  fabriquePourInstructions = new InstructionFactory(classeAConstruire,
    listeDesConstantesDeLaNouvelleClasse);
 }

 public void create(OutputStream out) throws IOException {
  creationDuConstructeur();
  creationMethodeMain();
  classeAConstruire.getJavaClass().dump(out);
 }

 private void creationDuConstructeur() {
  InstructionList il = new InstructionList();
  MethodGen method = new MethodGen(ACC_PUBLIC, Type.VOID, Type.NO_ARGS,
    new String[] {}, "", classNameTarget(), il,
    listeDesConstantesDeLaNouvelleClasse);

  InstructionHandle ih_0 = il.append(fabriquePourInstructions.createLoad(Type.OBJECT, 0));
  System.out.println(ih_0.getInstruction().getName());

  InstructionHandle ins2 = il.append(fabriquePourInstructions.createInvoke(
    "java.lang.Object", "", Type.VOID, Type.NO_ARGS,
    Constants.INVOKESPECIAL));
  System.out.println(ins2.getInstruction().getName());

  InstructionHandle ih_4 = il.append(fabriquePourInstructions.createReturn(Type.VOID));
  System.out.println(ih_4.getInstruction().getName());

  method.setMaxStack();
  method.setMaxLocals();
  classeAConstruire.addMethod(method.getMethod());
  il.dispose();
 }

 private void creationMethodeMain() {
  System.out.println("\nListe des instructions de la méthode main");
  InstructionList il = new InstructionList();

  // on rajoute une méthode main sans paramètre
  MethodGen method = new MethodGen(ACC_PUBLIC | ACC_STATIC, Type.VOID,
    Type.NO_ARGS, new String[] {}, "main", classNameTarget(), il,
    listeDesConstantesDeLaNouvelleClasse);

  InstructionHandle ins1 = il.append(fabriquePourInstructions.createFieldAccess(
    "java.lang.System", "err",
    new ObjectType("java.io.PrintStream"), Constants.GETSTATIC));

  System.out.println(ins1.getInstruction().getName());

  InstructionHandle ins2 = il.append(new PUSH(
    listeDesConstantesDeLaNouvelleClasse,
    "Hello world sur la sortie erreur!"));
  System.out.println(ins2.getInstruction().getName());

  InstructionHandle ins3 = il.append(fabriquePourInstructions.createInvoke(
    "java.io.PrintStream", "println", Type.VOID,
    new Type[] { Type.STRING }, Constants.INVOKEVIRTUAL));

  System.out.println(ins3.getInstruction().getName());

  InstructionHandle ins4 = il.append(fabriquePourInstructions.createReturn(Type.VOID));
  System.out.println(ins4.getInstruction().getName());

  method.setMaxStack();
  method.setMaxLocals();
  // on rajoute la nouvelle méthode à la classe
  classeAConstruire.addMethod(method.getMethod());
  il.dispose();
 }

 public static void main(String[] args) throws Exception {
  FabriqueDeClasseHelloWorld creator = new FabriqueDeClasseHelloWorld();

  // on doit avoir un répertoire build ou se trouve les .class fabriqués
  creator.create(new FileOutputStream("build/" + classNameTarget()
    + ".class"));

  /*
   * attention, pour que cette partie fonctionne il faut que le répertoire
   * build se trouve dans le classpath
   */

  // on récupère la classe que l'on vient de créer
  Class cls = Class.forName(classNameTarget());
  
  // on fait une instance de cette classe
  Object obj = cls.newInstance();
  
  // l'unique méthode est le main. On fait un appel sur ce main
  obj.getClass().getMethods()[0].invoke(obj);
  

 }
}