Miscellanea: java web

Visualizzazione post con etichetta java web. Mostra tutti i post

martedì 18 febbraio 2014

Impossibile effettuare il download di file con IE7 IE8. Impossibile aprire il sito internet. Sito non disponibile o non trovato.

Sono incappato in questo errore quando in una web application tentavo di scaricare un documento.
L'errore si verificava solo in alcune macchine di un dominio aziendale e solo con i browser IE7 ed IE8.
Con tutti gli altri browser, Firefox, Chrome, etc.e anche con IE9 e IE10 invece funzionava correttamente.
L'errore effettivamente non è molto parlante e abbiamo perso parecchio tempo prima di capire il reale motivo.
Dal sito della microsoft e da alcuni blog si evince che in presenza di alcuni header nella cache come :


response.setHeader("Pragma", "No-cache");
response.setHeader("Cache-Control","no-cache,no-store,max-age=0");
response.setDateHeader("Expires", 1);

viene segnalato questo errore.
Il motivo francamente non si capisce bene, e sembrerebbe una sorta di bug visto che anche dal sito della microsoft consigliano di reimpostare il browser oppure di settare un parametro sul regedit di sistema (vedi qui e anche qui ).
Per risolvere noi abbiamo inserito i seguenti header:


response.setHeader("Cache-Control", "cache, must-revalidate");
response.setHeader("Pragma", "public");

giovedì 19 aprile 2012

Java Web Gestione Versioning

Lo scopo di questo post è mostrare una soluzione di aggiornamento versione sw Web, automatizzando la creazione della versione con uno script di ant e quindi mostrando sulle pagine della Web App la versione a cui si riferiscono.

L’effetto finale sarà di questo tipo:

I valori della versione sono presi dal file MANIFEST.MF presente dentro la directory WebContent/META-INF del progetto. Il MANIFEST è così definito:

Manifest-Version: 1.0

Ant-Version: Apache Ant 1.8.2

Created-By: 1.6.0_29-b11 (Sun Microsystems Inc.)

Company: NOME AZIENDA

Author: Mario Rossi

Implementation-Title: PROGETTO TEST

Implementation-Version: 1.0.1

Implementation-Build: 1

Build-time: 19/04/2012 01:58:59

La lettura di questi valori avviene all’interno di una servlet denominata InitServlet ( utilizzando la classe Manifest definita nel package java.util.jar ) e posta come caricamento allo start up dell’applicazione (parametro <load-on-startup>0</load-on-startup> definito sul web.xml).

Il metodo init della servlet si presenta in questo modo:

public void init(ServletConfig servletConfig) throws ServletException {

try

{

ServletContext servletCtx = servletConfig.getServletContext();

String contextRoot = servletCtx.getRealPath("");

String fManifest = contextRoot+File.separator+"META-INF"+File.separator+"MANIFEST.MF";

InputStream stream =new FileInputStream(fManifest);

Manifest manifest = new Manifest( stream);

Attributes attr = manifest.getMainAttributes();

String SOFTWARE_VERSION = attr.getValue(Attributes.Name.IMPLEMENTATION_VERSION);

servletCtx.setAttribute( "IMPLEMENTATION_VERSION", SOFTWARE_VERSION);

String BUIL_TIME = attr.getValue("Build-time");

servletCtx.setAttribute( "BUILT_TIME", BUIL_TIME);

}

catch(Exception ex){

ex.printStackTrace();

}

A questo punto definiamo una jsp che si occupi di recuperare i valori salvati nel contesto dell’applicazione e di mostrarli a video.

Di seguito il codice:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

String webVersion = (String)getServletConfig().getServletContext().getAttribute("IMPLEMENTATION_VERSION");

if(webVersion == null){

webVersion = "undefined";

}

if (webVersion.equals("${build.version}")){

webVersion = "sviluppo";

}

String buildTime = (String)getServletConfig().getServletContext().getAttribute("BUILT_TIME");

if(buildTime == null){

buildTime = "undefined";

}

String versione = "Versione "+webVersion +" del "+buildTime;

request.setAttribute("versione", versione);

<tr>

<td>

${versione}<br/><br/><br/>

</td>

</tr>

</table>

Tale jsp sarà inclusa nelle nostre pagine Web tramite il classico <jsp:include page=”version.jsp”></jsp:include>

Si può automatizzare il processo di creazione versione ricorrendo ad un semplice script di Ant, che chiede all’utente di impostare la versione e quindi aggiorna il manifest. Ho definito quindi allo stesso livello della directory src una directory ant con la seguente struttura:

versionCreator.xml è così definito:

<?xml version="1.0" encoding="UTF-8"?>

</tstamp>

<description>Prepare for a build tasks</description>

<input message="Versione attuale: ${current.build.version}${line.separator}Inserire una nuova versione (di default è quella attuale):"

addproperty="build.version"

defaultvalue="${current.build.version}"

<echo file="ant/versioning/build.version">current.build.version=${build.version}</echo>

</target>

</manifest>

</target>

</project>

Lanciando da Eclipse il target manifest verrà chiesto di impostare la versione, riportando la versione attualmente presente come valore di default nella casella di testo.

In questo modo:

mercoledì 29 febbraio 2012

Configurare log4j per una Web Application

Una pratica comune quando si configura una Web Application per utilizzare log4j è la seguente.
Definiamo innanzitutto un appender per il log della nostra applicazione e poi tramite una servlet che si carica all'attivazione dell'applicazione configuriamo il log4j.
Nel nostro caso la servlet cerca un parametro definito a livello di Web-xml (un context parameter) e, se lo trova valorizzato allora cerca il log4j.properties nella directory specificata, altrimenti utilizza l'impostazione di default.
Ricordiamo che i livelli di log previsti dal frqamework log4j sono i seguenti:

TRACE;
DEBUG;
INFO;
WARN;
ERROR;
FATAL.

log4j.properties

##############################################################
################### DEFINIZIONE DEI LOGGER ###################
##############################################################

log4j.rootLogger=INFO,ApplicationConsoleLog

#Gestione log4j generale per l'Applicazione

log4j.logger.WebTest.MyLogger=DEBUG, ApplicationLog

###############################################################
########## DEFINIZIONE DEGLI APPENDER DEFINITI SOPRA ##########
                        ###### CONSOLE ########
                        #######################
log4j.appender.ApplicationConsoleLog=org.apache.log4j.ConsoleAppender
log4j.appender.ApplicationConsoleLog.layout=org.apache.log4j.PatternLayout

                        ###### EXCEPTION ######
                        #######################
log4j.appender.ApplicationLog=org.apache.log4j.RollingFileAppender
log4j.appender.ApplicationLog.File=
log4j.appender.ApplicationLog.MaxFileSize=2000KB
log4j.appender.ApplicationLog.MaxBackupIndex=10
log4j.appender.ApplicationLog.layout=org.apache.log4j.PatternLayout
log4j.appender.ApplicationLog.layout.ConversionPattern=%d{dd-MM-yyyy HH\:mm\:ss} -%p- %m%n

Sono definiti 2 logger, un ApplicationConsoleLog   che opera solo a livello di console dell'application server e poi un ApplicationLog che si occupa di loggare su File.
Il codice della Servlet è il seguente:

InitServlet

public class InitServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    private static final String LOG4J_FILE_PROP="log4j.appender.ApplicationLog.File";

    /**
     * @see HttpServlet#HttpServlet()
     */
    public InitServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
    * @see Servlet#init(ServletConfig)
    */
    public void init(ServletConfig config) throws ServletException {
       super.init(config);
       ServletContext ctx=config.getServletContext();
       StringBuffer log4jConf=new StringBuffer();
       log4jConf.append(getConfigPath(ctx));
       log4jConf.append(File.separator);
       log4jConf.append("log4j.properties");
       try
       {
       File log4JFile=new File(log4jConf.toString());
       if(log4JFile.exists()){
           InputStream stream=new FileInputStream(log4JFile);
           Properties log4jProp = new Properties();
           log4jProp.load(stream);

           if(log4jProp.getProperty(LOG4J_FILE_PROP).trim().equals("")){
               String logDir=getLogFileDefault(ctx);
               log4jProp.setProperty(LOG4J_FILE_PROP, logDir);


           }
           PropertyConfigurator.configure(log4jProp);
           Logger.getLogger("WebTest.MyLogger").warn("###########################\nLog4j CARICATO CON SUCCESSO");
       }
       }
       catch(Exception ex){
           ex.printStackTrace();
       }

    }
    private String getLogFileDefault(ServletContext ctx){
       StringBuffer sb=new StringBuffer();
       sb.append(ctx.getRealPath(""));
       sb.append(File.separator);
       sb.append("logs");
       sb.append(File.separator);
       sb.append("log.log");
       return sb.toString();
    }
    /**
    * Cerco la directory contenente il file di configurazione di log4j <br>
    * nella directory specificata nel context parameter"locationConfig"<br>
    * se il percorso non è specificato allora lo cerco dentro la directory config della web-app
    * @param ctx
    * @return
    */
    private String getConfigPath(ServletContext ctx) {
       String path="";
       String nome="locationConfig";
       path = ctx.getInitParameter(nome);
       if(path==null || path.trim().equals("")){
           // non � stato configurato via Web Xml
           path=ctx.getRealPath("")+File.separator+"config";
       }
       return path;
    }

}

web.xml

....

<servlet>
    <description></description>
    <display-name>InitServlet</display-name>
    <servlet-name>InitServlet</servlet-name>
    <servlet-class>it.servlet.InitServlet</servlet-class>
    <load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>InitServlet</servlet-name>
    <url-pattern>/InitServlet</url-pattern>
</servlet-mapping>
<context-param>
<param-name>locationConfig</param-name>
<param-value></param-value>
</context-param>

.....

Per richiamare il nostro log all'interno del codice Java sarà sufficiente scrivere:

.......

private static Logger log=Logger.getLogger("WebTest.MyLogger");

.......