API de gestion de bibliothèque de contenu Web

Appel asynchrone des méthodes d'API de bibliothèque de contenu Web

Bien que les fonctions d'API de bibliothèque de contenu Web puissent être appelées de manière asynchrone, si vous les exécutez sur des bibliothèques de contenu Web comportant de grandes quantités de données, leur exécution nécessitera énormément de temps. Par exemple, si ces méthodes sont appelées à partir d'une page JSP, il se peut que la page JSP soit invalidée en raison d'une expiration de session.

WebSphere® Application Server utilise un mécanisme connu sous le nom de beans asynchrones. Un bean asynchrone est un objet Java qui peut être exécuté de manière asynchrone. Le bean asynchrone "objet Work" est utilisé pour appeler des méthodes d'API de bibliothèque de contenu Web de manière asynchrone.

Un objet Work (représenté par l'interface com.ibm.websphere.asynchbeans.Work) étend java.lang.Runnable. Il est utilisé pour exécuter un bloc de code en tant qu'unité d'exécution indépendante. WebSphere® Application Server gère un pool d'unités d'exécution indépendantes qui peuvent être affectées à l'exécution du code encapsulé dans des instances Work. Ce pool d'unités d'exécution est géré par WorkManager. Il est utilisé pour générer des unités d'exécution destinées à exécuter des objets Work et à les contrôler. WebSphere® Application Server gère des gestionnaires de tâches pour chacun des serveurs d'applications contenus sur un nœud particulier. Le modèle dans cette rubrique utilise le gestionnaire de tâches par défaut (wm/wpsWorkManager) pour le serveur d'applications HCL Portal. Il gère un pool de 300 unités d'exécution. Il est possible de créer d'autres instances du gestionnaire de tâches (Work manager) avec des pools d'unités d'exécution personnalisées. Pour ce faire, utilisez la console WebSphere® Integrated Solutions Console pour le serveur HCL Portal.

L'exemple utilise la classe DeleteWork pour implémenter l'interface Work :

package deletesample;

import com.ibm.workplace.wcm.api.*;
import javax.naming.*;

public class DeleteWork implements com.ibm.websphere.asynchbeans.Work
{
   private String m_username = null;
   
   private String m_password = null;
   
   private String m_libraryToDelete = null;

   public DeleteWork(String username, String password, String library)
   {
      m_username = username;
      m_password = password;
      m_libraryToDelete = library;
   }
   
   public void release()
   {
   }     

   public void run()
   {
	      try
	      {
		// Construct and inital Context
	    	InitialContext ctx = new InitialContext();

		// Retrieve WebContentService and WebContentLibraryService using JNDI name
		WebContentService webContentService = (WebContentService) 
     ctx.lookup("portal:service/wcm/WebContentService");
		WebContentLibraryService webContentLibraryService = (WebContentLibraryService) 
    ctx.lookup("portal:service/wcm/WebContentLibraryService");

		Workspace ws = webContentService.getRepository().getWorkspace(m_username, m_password);
		DocumentLibrary docLib = ws.getDocumentLibrary(m_libraryToDelete);
		LibraryTaskResult res = webContentLibraryService.deleteLibrary(ws, docLib);

		// Once you get the result object back, print status to StandardOut
		if (res.getResultType() == ResultTypes.OPERATION_SUCCESS)
		{
			System.out.println("Successfully Deleted Library " + m_libraryToDelete);
		}
		else
		{
			System.out.println("Failed To Delete Library " + m_libraryToDelete);
		}
	      }
	      catch (Exception e)
	      {
	                e.printStackTrace();
	      }
   }
}

La méthode d'exécution correspond à ce qui est requis pour implémenter cette interface. C'est là que vous encapsulez la méthode de bibliothèque à exécuter dans une unité d'exécution distincte de l'unité d'exécution appelante. Dans l'exemple précédent, DeleteWork est instancié, transmettant les données d'identification, ainsi que la bibliothèque à supprimer. Dans run(), le référentiel est connecté et une instance Workspace est obtenue, car DocumentLibrary correspond à la bibliothèque à supprimer. deleteLibrary() est ensuite appelé pour exécuter réellement la suppression. Une fois cette méthode achevée, l'objet Result peut être interrogé pour déterminer l'état de la suppression. Ceci peut alors être consigné ou traité comme requis.

Le fichier JSP suivant est utilisé pour appeler l'objet DeleteWork :

<%@ page import="java.util.*" %>
<%@ page import="java.io.*" %>
<%@ page import="java.lang.*" %>
<%@ page import="com.ibm.workplace.wcm.api.*" %>
<%@ page import="com.aptrix.identity.*" %>
<%@ page import="com.ibm.workplace.wcm.services.library.*" %>
<%@ page import="com.ibm.workplace.wcm.services.*" %>
<%@ page import="com.ibm.workplace.wcm.services.repository.*" %>
<%@ page import="com.ibm.websphere.asynchbeans.*" %> 
<%@ page import="javax.naming.*" %> 
<%@ page import="deletesample.DeleteWork" %> 



<%
/*
 *  JSP Sample to demonstrate how to delete a WCM Library 
 *  making use of the WebSphere Application Server
 *  Work asynchronous bean. 
 */

try 
{
   //obtain a work manager instance - the work manager manages a pool of threads 
   //which can be used to invoke the functionality encapsulated
   // within a work instance
   InitialContext ctx  = new InitialContext();
   com.ibm.websphere.asynchbeans.WorkManager wm  =
   (com.ibm.websphere.asynchbeans.WorkManager)
	       ctx.lookup("wm/wpsWorkManager");

   //create a new work instance
   DeleteWork workItem = new DeleteWork(request.getParameter("username"), request.getParameter("password"), 
   request.getParameter("library")); 
   //spawn a thread to run the create work instance
   wm.startWork(workItem);
    
     
		
} 
catch (Exception e)  
{
%>  <%= e.toString() %><%
}%>

Pour pouvoir exécuter un objet Work, il est nécessaire d'effectuer une recherche JNDI afin d'obtenir l'instance du gestionnaire de tâches par défaut d'HCL Portal. Une fois cette opération effectuée, la classe DeleteWork peut être instanciée. Pour exécuter DeleteWork sur une unité d'exécution distincte, appelez la méthode startWork() sur le gestionnaire de tâches WorkManager transmettant l'instance DeleteWork. Par exemple, wm.startWork(workItem);. Le journal System.out peut être examiné pour déterminer à quel moment DeleteWork se termine.