Archives mensuelles : janvier 2014

Export / Import dump Oracle

Comment faire un dump et le restaurer avec les commandes « expdp » et « impdp »

Pour faire le dump, il faut être sur un environnement qui a un client Oracle installé. Les variables d’environnement doivent être placées pour que le système puisse permettre d’accéder aux commander expdp et impdp.

Pré-requis :

– Il faut que le fichier tnsnames.ora soit configuré avec la base que l’on veut attaquer. Se fichier se situe dans l’installation d’Oracle. Ex : /opt/oracle/11.2.0/network/admin/tnsnames.ora

MA_BASE_DE_DONNEES.world=(DESCRIPTION=(ADDRESS=(COMMUNITY=TCP.world)(PROTOCOL=TCP)(Host=XXXXX)(Port=XXXXX))(CONNECT_DATA=(SID=MA_BASE_DE_DONNEES)))

– Il faut que dans la base on ait crée un « directory » qui pointe sur l’emplacement sur le FS qui contiendra les dumps :

CREATE OR REPLACE DIRECTORY MON_DIRECTORY AS '/cheminDeMonRepertoire';
GRANT READ, WRITE ON DIRECTORY MON_DIRECTORY TO MON_USER_ORACLE;

Lancer la commande « expdp » :

expdp ORACLE_USER/ORACLE_PASSWORD@ORACLE_SID DIRECTORY=ORACLE_DUMP_DIRECTORY_NAME DUMPFILE=ORACLE_DUMP_FILE_NAME SCHEMAS=ORACLE_SHEMAS logfile=ORACLE_DUMP_LOG_FILE

Pour le restore, lancer la commande « impdp » :

impdp ORACLE_USER/ORACLE_PASSWORD@ORACLE_SID DIRECTORY=ORACLE_DUMP_DIRECTORY_NAME logfile=ORACLE_IMP_LOG_FILE table_exists_action=replace exclude=user exclude=sequence
Publicités

Spring AOP et l’interception d’exceptions

Pour des besoins d’interception d’exceptions globales sur un package d’une application, Spring AOP (Aspect Oriented Programming) permet de mettre en place des tissages non pas dans le code écrit mais directement autour du byte code.

L’intérêt d’une telle solution est de ne pas toucher au code existant mais d' »envelopper » l’application avec du code additionnel qui sera déclenché sur certaines conditions.

Pour mettre en place une telle solution il est nécessaire :

  • de rajouter des dépendances dans le fichier pom.xml
  • de compléter le fichier de configuration Spring
  • de créer une classe qui sera responsable des traitements voulus

1. Ajout des dépendances pour Spring AOP

Ajouter les dependances suivantes dans le fichier pom.xml

<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>catalina</artifactId>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
<scope>provided</scope>
 </dependency>
 <dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<scope>provided</scope>
 </dependency>

2. Modifier la configuration Spring

Ajouter la configuration AOP dans le fichier de configuration Spring Xml

<!--************* Gestionnaire des aspects (AOP) *********************** -->
<aop:config>
    <aop:aspect id="loggingAspect" ref="rootErrorInterceptor">
        <aop:after-throwing method="afterThrowing" throwing="ex" pointcut="execution(* fr.appli.web.front.*.*(..))"/>
    </aop:aspect>
</aop:config>

<bean id="rootErrorInterceptor" class="fr.appli.web.front.it.intercepteurs.RootErrorInterceptor"/>
<!-- Fin de la configuration AOP -->

Dans cette configuration on stipule que :

  • L’identifiant de notre aspect est « loggingAspect »
  • Qu’il fait référence à un bean qui est nommé « rootErrorInterceptor »
  • Nous utilisons un déclencheur de type « aop:after-throwing ». On trouve d’autres types d’advice comme : Before, After, Throws et Around). Pour notre cas nous utilisons « Throws »
  • La méthode a invoquer est « afterThrowing » de notre bean « rootErrorInterceptor »
  • Il traite l’exception « ex » dans les paramètres de notre méthode
  • Le le champ d’application de notre tissage est l’espace de nommage « fr.appli.web.front.*.*(..) », ce qui veut dire que toute méthode et classe qui se trouve dans ce package sera concerné
  • La déclaration de notre bean « rootErrorInterceptor » qui va intercepter notre exception et la traiter
  • La classe qui est décrite par notre bean : « fr.appli.web.front.it.intercepteurs.RootErrorInterceptor »

3. Créer notre classe de traitement des exceptions

Créer une classe qui va effectuer certains traitement lorsque une exception du type défini dans les paramètres est interceptée. Ici nous traitons toutes les exceptions de type « Exception » mais on pourrait être plus précis et traiter que certaines exceptions précises. Toute fois, le fait de catcher les exceptions par l’AOP n’empêche pas la propagation des exceptions mais permet de faire un traitement particulier lors de la levée de ceux-ci.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.ThrowsAdvice;
public class RootErrorInterceptor implements ThrowsAdvice {
 /** Le logger pour la classe RootErrorInterceptor */
 private static final Logger LOGGER = LoggerFactory.getLogger(RootErrorInterceptor.class);

/** La methode declenchee a la levee d une exception du type RuntimeException */
 public void afterThrowing(RuntimeException ex) {
 // Do something with remote exception
 LOGGER.error("Declenche sur la levée d'une exception de type Exception !");
 }
}