SQL : insertion d'un CLOB via SQL


CREATE OR REPLACE DIRECTORY documents AS '/tmp';

SELECT monChampClob FROM uneTable WHERE monId=4000100;

DECLARE
l_bfile BFILE;
l_clob CLOB;
BEGIN

UPDATE uneTable
SET ILR_TARIF = EMPTY_CLOB()
WHERE monId=4000100
RETURNING ILR_TARIF INTO l_clob;

l_bfile := BFILENAME('DOCUMENTS', 'CGV.irl.txt');
DBMS_LOB.fileopen(l_bfile, DBMS_LOB.file_readonly);
DBMS_LOB.loadfromfile(l_clob, l_bfile, DBMS_LOB.getlength(l_bfile));
DBMS_LOB.fileclose(l_bfile);

COMMIT;
END;
/

SELECT monChampClob FROM uneTable WHERE monId=4000100;

DROP DIRECTORY documents;



java : reflexion et type primitif

Voici, comment faire de la reflexion avec des type primitif et remplir un JavaBean. Ce petit code peut montre comment appeler un setter qui prend en paramètre un boolean.

A noter :
1) qu'il faut définir le type de paramètres avec le type primitif :

Class[] params = { boolean.class };


2) Puis, lors de lm'appel il faut passer un tableau d'objet pour l'appel à invoke() ... Donc, on passe un tableau de Boolean (ou Integer, etc ...):

Object [] params = {new Boolean(true)};
...
remplirBean(beanARemplir, nomDuChamp, params);


et voilou, c'est magique ...



public static void main(String[] args)
{
Object [] params = {new Boolean(true)};
PtuResultatsBoutonBean beanARemplir = new PtuResultatsBoutonBean();
String nomDuChamp = "repTraitementEnabled";
remplirBean(beanARemplir, nomDuChamp, params);
System.out.println(beanARemplir);
}

private static void remplirBean(PtuResultatsBoutonBean beanARemplir, String nomDuChamp, Object [] valeur) {
Class cl = beanARemplir.getClass();
Class[] params = { boolean.class };
// pour chacune des methodes
String nomSetterAttendu = "set" + nomDuChamp.substring(0, 1).toUpperCase() + nomDuChamp.substring(1, nomDuChamp.length());

// msg erreur
String msg = null;
try {
Method method = cl.getMethod(nomSetterAttendu, params);

// on a trouve le setter et on verifie qu'il est public, que son nom commence par set, et qu'il prend un parametre
if (method != null && Modifier.isPublic(method.getModifiers()) && method.getName().matches("(set[A-Z0-9]+[a-zA-Z0-9]*)")
&& method.getParameterTypes().length == 1) {
method.invoke(beanARemplir, valeur);
}

} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}


J2EE : envoyer message file JMS

Voici, une exemple de code standard d'envoi dans une file JMS :

Tout d'abord l'initialisation :
1) recuperation du contexte JNDI :
jndiContext = InitialContextManager.getInitialContext(
urlAnnuaireJndiDestination);

2) recuperation du contexte JNDI de la ressources par JNDI :
connectionFactory = (QueueConnectionFactory)
jndiContext.lookup(PropertiesManager.getInstance().getString(
"jndi.jms.connectionfactory"));

3) recuperation d'une de la queue :
destQueue = (Queue) jndiContext.lookup(nomJndiFileDestination);


try {
//On garde ces 2 paramètres pour faire un réinit si besoin
urlAnnuaireJndiDestinationReinit=urlAnnuaireJndiDestination;
nomJndiFileDestinationReinit=nomJndiFileDestination;

jndiContext = InitialContextManager.getInitialContext(
urlAnnuaireJndiDestination);
connectionFactory = (QueueConnectionFactory)
jndiContext.lookup(PropertiesManager.getInstance().getString(
"jndi.jms.connectionfactory"));

destQueue = (Queue) jndiContext.lookup(nomJndiFileDestination);
logger.info("JMS Initialisation terminée");
}
catch (Exception e) {
logger.fatal("JMS Initialisation en erreur",e);
throw new ServiceJMSException(e);
}


Puis l'envoie proprement dit :
4) recuperation d'une connexion, d'une session, d'un sender :


if(connectionFactory==null ){
logger.error("JMS Connection Factory null, tentative de réinitialisation.");
init(urlAnnuaireJndiDestinationReinit, nomJndiFileDestinationReinit);
}

connection = connectionFactory.createQueueConnection();
session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);

qSender = session.createSender(destQueue);

ObjectMessage message = session.createObjectMessage();
message.setJMSCorrelationID(idMessage);
message.setObject(objetAEnvoyer);

//message.setJMSExpiration(30000);

if(replyServerName!=null){
message.setStringProperty(REPLY_SERVER_NAME,replyServerName);
}
if(replyQueueName!=null){
message.setStringProperty(REPLY_QUEUE_NAME,replyQueueName);
}

qSender.send(message);

// Release Sender
if (qSender != null) {
try {
qSender.close();
} catch (JMSException vJMSException) {
logger.error("Error close QueueSender " + vJMSException.getStackTrace());
}
}

//Release QueueSession
if (session != null) {
try {
session.close();
} catch (JMSException vJMSException) {
logger.error("Error close QueueSession " + vJMSException.getStackTrace());
}
}

//Release QueueConnection
if (connection != null) {
try {
connection.close();
} catch (JMSException vJMSException) {
logger.error("Error close QueueConnection " + vJMSException.getStackTrace());
}
}


J2EE : ejb serviceLocator

Voici, le code classique d'un serviceLocator. Ce service utilise des caches, des ressources récupérés par JNDI, et les mets en cache.

A noter : que l'on utilise le code ejbHome.getHomeHandle() pour garder une reference sur les EJB distants ...


/**
* Donne l'instance de l'EJBHome. Celui-ci est placé dans un cache, d'où il sera extrait au prochain appel.
* @param jndiAdress String
* @param jndiHomeName String
* @param homeClass Class
* @throws ServiceLocatorException
* @return EJBHome ou EJBLocalHome
*/
private Object getHome(String jndiAdress, String jndiHomeName, Class homeClass, boolean homeDistante)
throws ServiceLocatorException {
Object home = null;
InitialContext context = null;
String cacheKey = jndiAdress + jndiHomeName;

try {
//On prend la home dans le cache si elle y est.
if (cacheEnabled && cache.get(cacheKey) != null) {
if (homeDistante) {
HomeHandle homeHandle = (HomeHandle) cache.get(cacheKey);
home = (EJBHome) homeHandle.getEJBHome();
}
}
if (cacheEnabled && cacheLocal.get(cacheKey) != null) {
if (!homeDistante) {
home = (EJBLocalHome) cacheLocal.get(cacheKey);
}
}
//Sinon on la cherche dans l'annuaire JNDI
else {
context = InitialContextManager.getInitialContext(jndiAdress);
Object objReference = context.lookup(jndiHomeName);

//Si la home est distante il faut faire un narrow
if (homeDistante) {
home = (EJBHome) PortableRemoteObject.narrow(objReference, homeClass);
EJBHome ejbHome = (EJBHome) home;
if (cacheEnabled) {
cache.put(cacheKey, ejbHome.getHomeHandle());
}
}
//Pas besoin de narrow si elle est locale
else {
home = (EJBLocalHome) objReference;
EJBLocalHome ejbLocalHome = (EJBLocalHome) home;
if (cacheEnabled) {
cacheLocal.put(cacheKey, ejbLocalHome);
}
}
}

}
catch (RemoteException rex) {
throw new ServiceLocatorException(rex);
}
catch (NamingException ex) {
throw new ServiceLocatorException(ex);
}
finally {
if (context != null) {
try {
context.close();
}
catch (NamingException ex1) { //rien
}
}
}

return home;
}



ubuntu : choisir la version de java ...

voici, quelques astuces trouvées sur le très bon forum ubuntu.fr ...

tout d'abord, lorsque l'on fait du java EE ... comment changer la jvm opensource iced tea, en celle de Sun ...

sudo update-alternatives --config java

puis, il ne vous reste qu'à chosir la version souhaitée ...

Puis, comment supprimer le lancement d'un service, configurer via /etc/init.d ...

sudo update-rc.d tomcat6 remove