java - como escribir en un jframe

¿Cómo puedo escribir mi propio cargador de complementos en Java?

Question

¿Cómo puedo implementar una instalación de complemento en mi programa Java?

Estoy trabajando con Java. Mi proyecto actual es algo relacionado con un hardware de electrónica de propósito general, que tiene un conjunto de comandos personalizados.

Ahora hay una GUI general a través de la cual se puede acceder al hardware. El hardware se comporta de diferentes formas en diferentes entornos, es decir, para diferentes clientes. Ahora el problema es que la GUI debe ser capaz de agregar complementos. El complemento significa que debe ser capaz de otorgarle un servicio particular a un cliente que tenga el privilegio. Desde el lado del cliente, la adición del complemento debe ser simple, como hacer clic en un botón para agregar una instalación en particular.

La razón por la que pienso en complementos es que cada vez se introducirán más instalaciones solo después de entregar el producto principal.

Answer 1

Debe proporcionar las siguientes cosas:

• crea una API que tus plug-ins puedan usar para cambiar / extender el comportamiento de tu programa (en mi humilde opinión, esta es la parte más difícil)
• definir una entrada común a los complementos, por ejemplo, un archivo de propiedades específicas del complemento que define el punto de entrada o puntos de extensión de su complemento (nombre de clase de una clase de complemento que implementa una interfaz)
• carga dinámicamente los complementos desde la ubicación que elijas, por ejemplo, todos los archivos * .jar de un directorio específico (echa un vistazo a URLClassLoader )

Sugerencias API

• Prefiere las interfaces sobre las clases (abstractas)
• podría ser útil ayudar al usuario a ver rápidamente qué interfaces podría implementar (por ej. IAction , notar el I principal) y cuáles son provistas por su aplicación para el uso de complementos (p. ej., WindowManager )

Answer 2

El formato de archivo JAR tiene su propio pequeño sistema para administrar complementos , que se utiliza para varias partes de Java SE, incluida la administración de controladores JDBC. Simplemente defina una interfaz de servicio, coloque archivos JAR con implementaciones en classpath y cargue las implementaciones con ServiceLoader.load .

Answer 3

La idea principal detrás de la implementación de complementos en cualquier lenguaje orientado a objetos, es definir un conjunto de interfaces comunes que el complemento y las clases relacionadas deben implementar, y luego cargarlas y crear instancias a través de la reflexión ...

Puede usar patrones abstractos de fábrica para que cualquier objeto que necesite el complemento pueda ser instanciado ...

Digamos que su arquitectura de complemento solo tiene 3 interfaces y cada complemento debe proporcionar clases que implementen esas interfaces, entonces su arquitectura de complemento podría ser así:

public interface PluginInterfaceA {
//Define API here
};

public interface PluginInterfaceB {
// Define API here
};

public interface PluginInterfaceC {
// Define API here
};

public interface PluginFactory {
/**
 * Creates plugin A object.
 */
PluginInterfaceA createPluginA();
/**
 * Creates plugin B object.
 */
PluginInterfaceB createPluginB();
/**
 * Creates plugin C object.
 */
PluginInterfaceC createPluginC();
};

Y luego deje que los complementos definan en un archivo XML o en un archivo de propiedades el nombre de clase de la fábrica de complementos para el complemento:

Por ejemplo, digamos que su complemento define:

package com.my.plugin;

public class PluginAImpl implements PluginInterfaceA {
// Code for the class
};

public class PluginBImpl implements PluginInterfaceB {
// Code for the class
};

public class PluginCImpl implements PluginInterfaceC {
// Code for the class
};

public class PluginFactoryImpl implements PluginFactory {
public PluginInterfaceA createPluginA() {
  return new PluginAImpl();
}
public PluginInterfaceB createPluginB() {
  return new PluginAImpl();
}
public PluginInterfaceC createPluginC() {
  return new PluginAImpl();
}
};

Y luego defina en el archivo de propiedades // File plugin.properties proporcionado en plugin.jar del plugin plugin.factory.class = com.my.plugin.PluginFactoryImpl;

En tu aplicación puedes hacer

Properties properties = new Properties();
properties.load(this.getClass().getClassLoader().getResourceAsStream("plugin.properties"));

String factoryClass = properties.get("plugin.factory.class");

PluginFactory factory = Class.forName(factoryClass);

PluginInterfaceA interfaceA = factory.createPluginA();
PluginInterfaceB interfaceB = factory.createPluginB();
PluginInterfaceC interfaceC = factory.createPluginC();

// Aquí invoque las clases creadas como lo desee.

Gracias Pablo

Answer 4

Puede agregar un jar o plugin a una aplicación en cualquier momento. No tienes que hacer nada especial para lograr esto.

Si usa OGSi puede administrar esto más fácilmente, admite múltiples versiones del mismo jar y elimínelas mientras se ejecuta la aplicación. Sugiero mirar Apache Karaf + iPOJO