java - run - ¿Configurar embarcadero incrustado con web.xml?

jetty server

Question

Estoy tratando de generar tanto una guerra con mi aplicación web como un archivo jar autónomo con embarcadero integrado. Para el embarcadero incrustado (la distribución de archivos jar) agrego un servlet de la siguiente manera:

public static void main(String[] args) throws Exception {
Server server = new Server(8080);
ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
context.setContextPath("/");
server.setHandler(context);
context.addServlet(new ServletHolder(new HelloServlet()),"/*");
server.start();
server.join();
}

La distribución del archivo war utiliza un archivo web.xml que contiene lo siguiente en la sección de la aplicación web:

<servlet>
<servlet-class>com.example.HelloServlet</servlet-class>
<servlet-name>SimplestServer</servlet-name>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>

Esto funciona. Sin embargo, quiero deshacerme de la duplicación entre los dos enfoques. Es decir, cuando agregue un nuevo servlet, quiero tener que configurarlo en una sola ubicación. ¿Puedo cargar y usar el archivo web.xml desde el embarcadero incrustado?

Answer 1

Terminé usando el enfoque de Joakim, pero apuntando al directorio de la webapp en lugar del archivo war.

public static void main(String[] args) throws Exception {
Server server = new Server(8080);
String rootPath = SimplestServer.class.getClassLoader().getResource(".").toString();
WebAppContext webapp = new WebAppContext(rootPath + "../../src/main/webapp", "");
server.setHandler(webapp);
server.start();
server.join();
}

Answer 2

Use un org.eclipse.jetty.webapp.WebAppContext

Ejemplo:

package jetty;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.webapp.WebAppContext;
public class OnWebApp
{
public static void main(String[] args) throws Exception
{
// Create a basic jetty server object that will listen on port 8080.
// Note that if you set this to port 0 then a randomly available port
// will be assigned that you can either look in the logs for the port,
// or programmatically obtain it for use in test cases.
Server server = new Server(8080);
// The WebAppContext is the entity that controls the environment in
// which a web application lives and breathes. In this example the
// context path is being set to "/" so it is suitable for serving
// root context requests and then we see it setting the location of
// the war. A whole host of other configurations are available,
// ranging from configuring to support annotation scanning in the
// webapp (through PlusConfiguration) to choosing where the webapp
// will unpack itself.
WebAppContext webapp = new WebAppContext();
webapp.setContextPath("/");
webapp.setWar("path/to/my/test.war");
// A WebAppContext is a ContextHandler as well so it needs to be set to
// the server so it is aware of where to send the appropriate requests.
server.setHandler(webapp);
// Start things up! By using the server.join() the server thread will
// join with the current thread.
// See http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html#join()
// for more details.
server.start();
server.join();
}
}

Tenga en cuenta que construirá un archivo WAR normal y lo usará con Jetty.

Si tiene requisitos especiales como el análisis de anotación o JNDI, deberá ingresar a las especificaciones de configuración.

// Enable parsing of jndi-related parts of web.xml and jetty-env.xml
org.eclipse.jetty.webapp.Configuration.ClassList classlist =
org.eclipse.jetty.webapp.Configuration.ClassList.setServerDefault(server);
// Enable JNDI
classlist.addAfter("org.eclipse.jetty.webapp.FragmentConfiguration",
"org.eclipse.jetty.plus.webapp.EnvConfiguration",
"org.eclipse.jetty.plus.webapp.PlusConfiguration");
// Enable Annotation Scanning
classlist.addBefore("org.eclipse.jetty.webapp.JettyWebXmlConfiguration",
"org.eclipse.jetty.annotations.AnnotationConfiguration");

Para obtener un ejemplo más largo de esto en un WebAppContext, consulte el ejemplo de ServerWithAnnotations.

También tenga en cuenta que tendrá todas las reglas del cargador de clases de webapp en su lugar usando esta técnica también. Lo que significa que tendrá un cargador de clases para la aplicación web y otro para el servidor. Esto es importante de entender

Hay algunos ajustes que puede hacer al WebAppContext para cargadores de clases, pero no puede eliminarlos, simplemente controle cómo se comportan.

WebAppContext webapp = new WebAppContext();
// ... various setup of the webapp ...
// Flip the classloader priority from servlet spec where webapp is first to
// Standard java behavior of parent (aka Server classloader) is first.
webapp.setParentLoaderPriority(true);

Ver también:

• WebAppContext.setClassLoader(ClassLoader classloader)
• WebAppContext.addServerClass(String classOrPackage)
• WebAppContext.addSystemClass(String classOrPackage)