Cet article est le premier d’une serie mémo, visant à permettre un copier/coller pour trouver la réponse à une question.

Note pour ceux qui ont installés Oracle XE via le paquet Debian « .deb ».

Sous Debian/Ubuntu, Oracle XE est installé dans : /usr/lib/oracle/
Toutes les commandes de cet article ont pour base : /usr/lib/oracle/xe/app/oracle/product/10.2.0/server/bin

1) Configurer votre PATH correctement :

ORACLE_HOME=/usr/lib/oracle/xe/app/oracle/product/10.2.0/server
PATH=$PATH:$ORACLE_HOME/bin
export ORACLE_HOME
export ORACLE_SID=XE

2) Pour réaliser le dump :

./exp SYSTEM/[password] FULL=y FILE=[path]/[file].dmp LOG=dba.log CONSISTENT=y

3) Pour restaurer le dump :

./imp SYSTEM/[password] FULL=y FIlE=[path]/[file].dmp

Launchy est donc un lanceur d’applications que vous appellez via l’utilisation d’un raccourci clavier (ALT+SPACE), ou comme moi (SHIFT+SPACE), et dans lequel vous tapez quelques lettres pour ouvrir très rapidement vos logiciels.

Launchy est très configurable, et modulaire via l’utilisation de nombreux plugins. Vous pourrez par exemple taper « firefox (TAB) google.fr » pour ouvrir google via firefox.

Une petite note négative, ce sont les presque 6Mo de mémoires utilisée par Launchy 2.1.2, cela semble un peu élévé pour un lanceur d’applications.

Cette petite note ne change rien au fait que je le recommande activement, car il va augmenter votre rapidité et votre productivité sur votre ordinateur sous Windows ou Linux.

Voici une vidéo, un test réalisé par CNET:

Télécharger Lanchy : http://www.launchy.net

Liste des méthodes « magiques » en PHP5 :

• __construct()
• __destruct()
• __set()
• __get()
• __call()
• __toString()
• __sleep()
• __wakeup()
• __isset()
• __unset()
• __autoload()
• __clone()

__construct()
Cette méthode est appelée lors de la construction d’un objet.

__destruct()
Cette méthode est appelée lors de la destruction d’un objet.

__set()
Cette méthode est appelée automatiquement lors de l’assignation d’une valeur à un attribut inexistant.

__get()
Cette méthode est appelée automatiquement lors de la lecture d’une valeur à un attribut inexistant.

__call()
Cette méthode est appelée automatiquement lors de l’appel à une méthode inexistante.

__toString()
Cette méthode est appelée lors de la tentative d’interprétation d’un objet en String. (via un echo ou print…)

__sleep()
Cette méthode sert à la sérialisation d’un objet en PHP5. Elle doit définir la façon dont PHP doit le sérialiser.

__wakeup()
Cette méthode doit définir la dé-sérialisation d’un objet en PHP5.

__isset()
Cette méthode est utilisée lors de la vérification de l’existence d’un attribut via un appel à la méthode « isset »..

__unset()
Méthode appelée lors de la destruction de l’objet.

__autoload()
Cette méthode est appelée lorsque vous essayez de charger un objet dans un fichier séparé sans l’avoir précédemment chargé via un include, include_once, require ou require_once.

__clone()
cette méthode définie la façon de cloner un objet.


Exemple :

 <?php
 
    class MyClass {
        public $Name;
 
        public function __set($var, $val) {
             echo ("La propriétée : ".$var." - Valeur : ".$val);
        }
 
    }
 
    $systemvars = new MyClass();
    $systemvars->adminEmail = 'toto@toto.fr';
?>

Ceci résulte dans la sortie suivante :

        La propriétée : adminEmail - Valeur : toto@toto.fr

Ce n’est pas une bonne pratique !

En effet, à part dans des cas isolés, il est fortement recommendé de definir clairement vos bean, avec des propriétées, des setters et des getters.


La bonne pratique voudrait :

 <?php
 
    class MyClass {
        private $adminEmail;
 
        public function setAdminEmail ($var) {
             $this->adminEmail = $var;
        }
 
        public function getAdminEmail() {
             return $this->adminEmail;
        }
 
    }
 
    $systemvars = new MyClass();
    $systemvars->setAdminEmail ('toto@toto.fr');
?>

Il est important pour la pérennité du code de respecter les bonnes pratiques, mais parfois, il faut être flexible, voila l’idée de cet article.

1) Une petite explication :

Le framework spring (http://www.springframework.org) met à notre disposition tous les outils utiles à la création de documents PDF. Spring etant un framework MVC propre, la creation d’un Fichier Excel passe par la réalisation d’un Controller et d’une Vue qui etend AbstractExcelView.

Voici un exemple de code…

2) Un controller… :

Alors voici un exemple de controller Spring très simple, qui va juste deposer dans le model une valeur de test, utile pour valider le fonctionnement de notre vue.

Chemin : com.tellaw.test.controllers

package com.tellaw.test.controllers;
 
import java.util.*;
import javax.servlet.http.*;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.web.servlet.ModelAndView;
 
@SuppressWarnings("unchecked")
public class ExcelController extends AbstractController
{
 
	protected final Log logger = LogFactory.getLog(getClass());
 
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
 
    	Map<String, Object> model = new HashMap<String, Object>();
	model.put ("testValue", "Ma String de test de ma vue Excel !!!");
        return new ModelAndView("excel-view", "model", model);
 
    }
 
}

3) Une vue excel :

Voici la vue, qui va permettre de mettre en forme le document Excel. La vue se base sur l’API POI de Apache, permettant l’exploitation de documents microsofts (excels, words, powerpoints…) en Java.

Chemin : com.tellaw.test.controllers

package com.tellaw.test.view;
 
import java.util.*;
 
import javax.servlet.http.*;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.hssf.util.Region;
import org.springframework.web.servlet.view.document.AbstractExcelView;
 
@SuppressWarnings("unchecked")
public class ExcelExportView extends AbstractExcelView  {
 
    protected final Log logger = LogFactory.getLog(getClass());
    private static String SHEET_NAME = "feuille";
 
    protected void buildExcelDocument(	  Map model, 
    							HSSFWorkbook workbook, 
    							HttpServletRequest request, 
    							HttpServletResponse response ) {
 
        model = (Map<String, Object>)model.get("model");
 
        // Get Active Datas
        workbook = addSkeleton( workbook );
 
    	// Define Style
    	HSSFCellStyle style = workbook.createCellStyle();
        HSSFFont boldFont = workbook.createFont();
        boldFont.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
        style.setFillForegroundColor( HSSFColor.LIGHT_TURQUOISE.index );
        style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
        style.setFont(boldFont);
 
    	// Define headers
        cell = getCell( sheet, 1, 1 );
        cell.setCellStyle( style );
 
        // Number
    	setText ( cell , model.get("testValue") );
 
    }
 
    private HSSFWorkbook addSkeleton ( HSSFWorkbook workbook ) {
 
    	HSSFSheet sheet;
        HSSFCell cell;
 
    	sheet = workbook.createSheet( ExcelExportView.SHHET_NAME );
 
    	// Define Style
    	HSSFCellStyle style = workbook.createCellStyle();
        HSSFFont boldFont = workbook.createFont();
        boldFont.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
        style.setFont(boldFont);
 
    	// Define headers
        cell = getCell( sheet, 3, 1 );
        cell.setCellStyle(style);
    	setText ( cell , "valeur de test du model ?" );
 
    	autoSizeCols( sheet );
 
    	return workbook;
    }
 
}

4) Configurer sur contexte Spring :

Il suffit ensuite de faire le wiring de ces objets dans le contexte de Spring…

Chemin : WEB-INF/springapp-servlet.xml (propre à mon test)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
		xmlns:p="http://www.springframework.org/schema/p"
       	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       	xmlns:aop="http://www.springframework.org/schema/aop"
       	xmlns:tx="http://www.springframework.org/schema/tx"
       	xmlns:context="http://www.springframework.org/schema/context"
       	xsi:schemaLocation="
       		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
       		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
       		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
 
	<!-- 
		Abstract Controller
	 -->
	<bean id="abstractController" abstract="true" class="com.tellaw.test.controllers.AbstractController"/>
 
	<!-- EXCEL Export controller -->
    <bean 	id="excelView" 
    		class="com.tellaw.test.controllers.ExcelExportView">
    </bean>
 
    <bean 	id="excelController" 
    		class="com.tellaw.test.controllers.ExcelController"
    		parent="abstractController"/>
 
	<!-- 
		Url Mapping Definition With Authentication
	 -->
    <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
 
        <property name="mappings">
            <props>
                <prop key="/report.xls">excelController</prop>
            </props>
        </property>
    </bean>
 
	<!-- 
		View Resolver
	 -->
    <bean class="org.springframework.web.servlet.view.ResourceBundleViewResolver">
        <property name="basename" value="views"/>
    </bean>
 
 
</beans>

5) Mapper la vue via un properties :

J’aime bien séparer le mapping des vues dans un fichier Properties externe, voici le détail du mien :

Chemin : ressources/views.properties (propre à mon test et à ma compilation maven)

excel-view.(class)=com.tellaw.test.controllers.ExcelExportView

5) Annèxes, et la suite ????

• Framework Spring : http://www.springframework.org
• Apache POI (Apache POI – Java API To Access Microsoft Format Files): http://poi.apache.org/

Alors, riot, ca permet de faire quoi ?

1) C’est un CMS très simple à mettre en oeuvre.

En fait Riot propose un service de CRUD (CReate Update Delete) de données pour vos POJO (Plain Old Java Object) via l’utilisation d’un DAO générique (en général, il est très simple de mapper ses POJO sur Hibernate avec riot).

Pour cela il met à votre disposition 3 fichiers :

• list-config.xml -> Qui configure les listes d’objets de l’interface.
• form-config.xml -> Qui configure le formulaire d’edition du pojo, et des regles de validations de données.
• editor-config.xml -> Qui sert de colle entre les deux éléments précédents.

Un article complet va détailler toutes ces fonctionnalitées.

2) Un système basé sur l’utilisation de modules.

Riot propose de simplifier l’utilisation de modules dans vos templates. Il suffit de définir des zone, et d’indiquer dans la configuration XML spring (soit via la syntaxe compacte riot, soit la syntaxe Spring), quels modules doivent etres empilés.

<template:definition name= »/posts.html » view-name= »default.ftl »>
<template:insert slot= »navigation » url= »/inc/navigation.html » />
<template:insert slot= »content » url= »/inc/all-posts.ftl » />
</template:definition>

3) Un ré-ecriture des URLs très simple.

La ré-écriture d’url tourne souvent à une enorme usine à gaz, alors que c’est en réalité quelque chose de très très simple, et systématique sur un site web.

Riot met donc en oeuvre des variable dans le nommage des bean, afin de mettre des URL « SEO compliantes ».

<bean name= »/some/@{myparam}/page.html » id= »myController » class= »eg.MyController » />

Votre page aura l’url : /some/45/page.html. Pas mal non ? Ligne de code ????? 0!

Pour appeler ce controlleur depuis un template, pas question de codé l’url en dur, utilisez :

<a href= »${common.urlForHandler(’myController’, myparam)} »>
${category.title}
</a>

4) les controlleurs génériques.

Généralement, une majoritée de pages Web, se contente de recuperer des objets et d’en afficher le contenu. Alors pourquoi utiliser de multiple controlleur pour faire cette opération ?

Riot propose un controlleur générique, suivant la syntaxe :

<generic:controller id= »postDetail » name= »/post-@{id:Long}.html »
view-name= »/inc/post-detail.ftl »>
<generic:hql hql= »from Post p where p.id = :id » />
</generic:controller>

Qui va recuperer l’objet « post » et le passer simplement à la vue.

5) Overriding de configuration Spring

La c’est assez sympa, le principe est de se dire, que parfois, il faut pouvoir redéfinir un élément de configuration, sans redéfinir le bean complet. Pour cela, Riot propose quelques éléments :

<override:properties ref= »someBean »>
<property name= »foo » value= »bar » />
</override:properties>

6) Plus beaucoup d’autres choses…

• Push-up qui permettent la communication entre « modules »
• Squelette de base pour débuter un projet.
• Plus beaucoup d’élements à decouvrir.

Attention tout bonheur à ses petit defauts…

Un gros manque de documentation sur le projet. Mais une communauté plus que réactive.

• Site : http://www.riotfamily.org/
• Le groupe google : http://groups.google.com/group/riotfamily