Client Java

    Le client Java permet d’interagir avec Flower Core à travers les web services exposés.

    Cette documentation s’appuie sur l’utilisation de Maven et Spring Boot.

    pom.xml

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>com.acme.samples</groupId>
    	<artifactId>batch-sample</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	
    	<dependencies>
    		<dependency>
    			<groupId>com.flower.docs.core</groupId>
    			<artifactId>flower-docs-ws-client</artifactId>
    			<version>2.4.2</version>
    		</dependency>
    	</dependencies>
    </project>
    

    Spring Boot est un framework de développement facilitant la mise en place d’application Java.

    Application

    @SpringBootApplication
    @ComponentScan("com.flower.docs.security.authentication")
    @Import(ClientSecurityConfiguration.class)
    @ImportResource({ "classpath:flower-docs-services-webservices.xml" })
    public class SampleBatch
    {
        private static final Logger LOGGER = LoggerFactory.getLogger(SampleBatch.class);
    
        public static void main(String[] args)
        {
            SpringApplication.run(SampleBatch.class, args);
        }
    
        @Override
        public void run(String... args) throws Exception
        {
        }
    }
    

    Accès aux services

    L’accès aux services Flower s’appuie sur le contexte Spring. Pour récupérer une instance de service, il suffit d’utiliser l’annotation @Autowired.

    Par exemple, pour accéder au service de gestion de documents :

    @Autowired
    private DocumentService documentService;
    

    Compte de service

    Le développement d’une application qui interagit avec Flower requiert généralement l’utilisation d’un compte de service utilisé pour effectuer les opérations auprès de Flower Core.

    Pour cela, le client Java fournit une classe utilitaire permettant de simplifier la gestion de l’authentification.

    @Autowired
    private Authenticator authenticator;
    ...
    authenticator.authenticate("scopeId"); 
    

    La configuration du compte utilisé se fait à travers les propriétés :

    flower.user=<identifiant de l'utilisateur>
    flower.password=<mot de passe>
    

    Ces propriétés peuvent être soit passées dans le fichier de configuration Spring application.properties soit en tant que propriétés de la JVM.

    Génération d’un token

    Le service AuthenticationService expose la méthode login

    @Autowired
    AuthenticationService service;
    ...
    ContextHelper.setScope(new Id("GEC"));
    Token token = service.login("user","password");
    

    Cette section fournit un exemple d’application basée sur Spring Boot permettant la recherche de document.

    
    @SpringBootApplication
    @ComponentScan("com.flower.docs.security.authentication")
    @Import(ClientSecurityConfiguration.class)
    @ImportResource({ "classpath:flower-docs-services-webservices.xml" })
    public class Sample implements CommandLineRunner
    {
        private static final Logger LOGGER = LoggerFactory.getLogger(Sample.class);
    
        public static void main(String[] args)
        {
            SpringApplication.run(Sample.class, args);
        }
    
        @Autowired
        private Authenticator authenticator;
    
        @Autowired
        private DocumentService documentService;
    
        @Override
        public void run(String... arg0) throws Exception
        {
            authenticator.authenticate("GEC");
            SearchRequest request = SearchRequestBuilder.init().max(0).build();
            SearchResponse response = documentService.search(request);
            LOGGER.info("Found {} documents", response.getFound());
        }
    }
    

    Les requêtes de recherche permettent de demander à Flower de renvoyer des résultats en fonction de différents critères. Ces requêtes de recherche sont composées de la façon suivante :

    Les clauses

    Clause Select

    La selectClause permet de définir les champs à remonter. Elle est constituée d’une liste de valeurs fields.

    Clauses Filter

    Les filterClauses permettent de définir des filtres à appliquer sur la recherche. Une filterClause est composée de la façon suivante :

    • criteria : les critères de ce filtre
    • filterClauses : les sous-filtres

    Une clause Filter va pouvoir en contenir une ou plusieurs autres afin de pouvoir effectuer des requêtes complexes avec des opérateurs logiques ET et OU. Pour celà, il existe deux types de clause Filter :

    • AndClause : Clause ET, un opérateur logique ET est appliqué entre les ses critères et ses sous-clauses
    • OrClause : Clause OU, un opérateur logique OU est appliqué entre les ses critères et ses sous-clauses

    Clauses Order

    Les orderClauses permettent de définir l’ordre dans lequel les résultats seront remontés. Elles sont composées de la façon suivante :

    • name : le nom du critère sur lequel trier
    • type : le type du critère
    • ascending : tri par ordre croissant ou non

    Contexte

    Il est possible d’ajouter les critères de contextes context dans une requête afin de pouvoir faire des traitement spécifique en fonction d’un contexte de recherche préalablement défini. Ces critères ne seront pas utilisés pour filtrer ou ajouter des colonnes dans le tableau de résultats.

    Minimum et maximum

    • start : Défini le début de la page de recherche
    • max : Défini le nombre maximum de résultats à retourner

    Exemple
    <bean class="com.flower.docs.domain.search.SearchRequest">
    	<property name="selectClause">
    		<bean class="com.flower.docs.domain.search.SelectClause">
    			<property name="fields">
    				<list>
    					<value>name</value>
    					<value>classid</value>
    					<value>creationDate</value>
    					<value>lastUpdateDate</value>
    				</list>
    			</property>
    		</bean>
    	</property>
    	<property name="filterClauses">
    		<list>
    			<bean class="com.flower.docs.domain.search.AndClause">
    				<property name="criteria">
    					<list>
    						<bean class="com.flower.docs.domain.search.Criterion">
    							<property name="name" value="name" />
    							<property name="type">
    								<value type="com.flower.docs.domain.search.Types">STRING</value>
    							</property>
    							<property name="operator">
    								<value type="com.flower.docs.domain.search.Operators">STARTS_WITH</value>
    							</property>
    							<property name="values">
    								<list>
    									<value>Agent</value>
    								</list>
    							</property>					
    						</bean>
    					</list>
    				</property>
    			</bean>
    		</list>
    	</property>
    	<property name="orderClauses">
    		<list>
    			<bean class="com.flower.docs.domain.search.OrderClause">
    				<property name="name" value="creationDate" />
    				<property name="ascending" value="false" />
    			</bean>
    		</list>
    	</property>
    </bean>
    

    Les APIs Flower s’appuient sur la couche d’abstraction de framework de log SLF4J. Ce framework permet de s’abstraire du framework de log utilisé. Par défaut, l’implémentation utilisée est Logback.


    Pour instancier un logger, il suffit de :

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    ...
    private static final Logger LOGGER = LoggerFactory.getLogger(SampleApp.class);
    ...
    LOGGER.info("Found {} documents", response.getFound());
    
    

    La configuration des niveaux de log est identidique à celle de Flower : Logs