Das Beispiel dieses Artikels beschreibt, wie die Datei-Upload- und Download-Funktion in struts2 in Java implementiert wird. Teilen Sie es als Referenz mit allen. Die spezifische Analyse lautet wie folgt:
1.Datei hochladen
Der erste ist der Code der JSP-Seite
Definieren Sie ein Upload-Tag auf der JSP-Seite
Kopieren Sie den Codecode wie folgt:<tr>
<td align="right" bgcolor="#F5F8F9"><b>Anhang:</b></td>
<td bgcolor="#FFFFFF">
<input type="file" name="upload" />
</td>
<td bgcolor="#FFFFFF"></td>
</tr>
Dann werden die in BaseAction definierten zugehörigen Attribute weggelassen (Sie können sie auch in Ihrer eigenen Aktion definieren, ändern Sie einfach den Zugriffsmodifikator).
Kopieren Sie den Codecode wie folgt:/**
*Aktionsbasisklasse
**/
Die öffentliche Klasse BaseAction erweitert ActionSupport {
protected List<Datei> upload;
protected List<String> uploadContentType; //Dateityp
protected List<String> uploadFileName; //Dateiname
protected String savePath; //Speicherpfad
}
Dann gibt es in Action eine Upload-Methode, deren Code wie folgt lautet:
Kopieren Sie den Codecode wie folgt:/**
* 8. Anhänge hochladen * @param upload
*/
public void uploadAccess(List<File> upload){
versuchen {
if (null != upload) {
for (int i = 0; i < upload.size(); i++) {
String path = getSavePath() + ""+ getUploadFileName().get(i);
System.out.println(path);
item.setAccessory(getUploadFileName().get(i));
FileOutputStream fos = new FileOutputStream(path);
FileInputStream fis = new FileInputStream(getUpload().get(i));
byte[] buffer = neues byte[1024];
int len = 0;
while ((len = fis.read(buffer)) > 0) {
fos.write(buffer, 0, len);
}
fis.close();
fos.close();
}
}
} Catch (Ausnahme e) {
logger.error("Fehler beim Hochladen des Anhangs.", e);
}
}
Dann lautet der Kopiercode meiner Datei struts2.xml wie folgt: <action name="itemRDAction_*" method="{1}">
<param name="savePath">e:upload</param>
<interceptor-ref name="defaultStack">
<param name="fileUpload.allowedTypes">
application/octet-stream,image/pjpeg,image/bmp,image/jpg,image/png,image/gif,image/jpeg,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/vnd. ms-excel
</param>
<param name="fileUpload.maximumSize">8000000</param>
</interceptor-ref>
<result name="show_item_rd_upd"> /WEB-INF/jsp/page_item/updItem_rd.jsp</result>
<result name="show_item_rd_list"> /WEB-INF/jsp/page_item/listItem_rd.jsp</result>
<result name="show_item_rd_push"> /WEB-INF/jsp/page_item/pushItem_rd.jsp</result>
</action>
savePath ist der Speicherpfad, fileUpload.allowedTypes wird verwendet, um die Dateigrößenbeschränkung für den Upload-Dateityp fileUpload.maximumSize zu begrenzen
2.Datei herunterladen
Kopieren Sie zunächst den Download-Link-Code auf der Seite wie folgt: <tr>
<td align="right" bgcolor="#F5F8F9"><b>Anhang:</b></td>
<td bgcolor="#FFFFFF">
<div>${item.accessory}</div>
<c:if test="${!empty item.accessory}">
<div style="float: left;"><a style="color: black; text-decoration: none;" href="download.action?filename=${item.accessory}">Herunterladen</a>< /div>
</c:if>
</td>
<td bgcolor="#FFFFFF"></td>
</tr>
Als nächstes kommt der Code für DownloadAction:
Kopieren Sie den Codecode wie folgt:/**
* DownloadAction
*
* @author zhaoxz
*
*/
@Controller("downloadAction")
@Scope("Prototyp")
öffentliche Klasse DownloadAction erweitert BaseAction {
/**
*
*/
private static final long serialVersionUID = -4278687717124480968L;
private static Logger logger = Logger.getLogger(DownloadAction.class);
privater String-Dateiname;
privater InputStream inputStream;
privater String savePath;
private String mimeType;
public InputStream getInputStream() {
versuchen {
String path = getSavePath() + "//"+ new String(filename.getBytes("ISO8859-1"), "utf-8");
System.out.println(path);
mimeType = ServletActionContext.getServletContext().getMimeType(path)+ ";charset=UTF-8";
inputStream = new FileInputStream(path);
String agent = request.getHeader("USER-AGENT");
System.out.println(agent);
if (null != agent) {
if (-1 != agent.indexOf("Firefox")) {// Firefox
mimeType = mimeType.replace("UTF-8", "ISO8859-1");
} else {// IE7+ Chrome
System.out.println("IE,Chrome");
filename = new String(filename.getBytes("ISO8859-1"),"utf-8");
Dateiname = java.net.URLEncoder.encode(Dateiname, "UTF-8");
}
}
} Catch (Ausnahme e) {
logger.error("Fehler beim Herunterladen der Dateiinformationen.", e);
}
if (null == inputStream) {
System.out.println("getResource error");
}
return inputStream;
}
public void setInputStream(InputStream inputStream) {
this.inputStream = inputStream;
}
@Override
public Stringexecute() löst eine Ausnahme aus {
Rückkehr ERFOLGREICH;
}
/****************************** fertig ***************** ******* **********/
öffentlicher String getSavePath() {
return this.savePath;
}
public void setSavePath(String savePath) {
this.savePath = savePath;
}
öffentlicher String getFilename() {
Dateiname zurückgeben;
}
public void setFilename(String filename) {
this.filename = Dateiname;
}
}
Dann gibt es die Datei struts2.xml:
Kopieren Sie den Code wie folgt: <action name="download">
<param name="savePath">E:/upload</param>
<result type="stream">
<param name="contentType">${mimeType}</param>
<param name="contentDisposition">attachment;filename="${filename}"</param>
<param name="inputName">inputStream</param>
</result>
</action>
Achten Sie beim Herunterladen auf das Kodierungsformat, dann sollte es kein Problem geben.
Beim Hochladen sind Probleme aufgetreten
1. Beim Hochladen großer Dateien tritt ein Fehler auf
Folgende Fehler treten auf:
1. 24.02.2012 11:06:31,937 ERROR (org.apache.struts2.dispatcher.Dispatcher:512) – Aktion oder Ergebnis konnten nicht gefunden werden
Für die Aktion com.iman.portal.action.QuestionActionImpl und das Ergebnis problemPage - action - file:/E:/myeclipse/workspaces/portal/WebRoot/WEB-INF/classes/struts2/struts-question.xml:51 ist kein Ergebnis definiert: 55
2. Die Anfrage wurde abgelehnt, da ihre Größe (2973652) das konfigurierte Maximum (2097152) überschreitet.
Chinesische Bedeutung: Die Anfrage wurde abgelehnt, da ihre Größe (2973652) das konfigurierte Maximum (2097152) überschreitet.
Unter Berücksichtigung der Benutzererfahrung ist es notwendig, solche Ausnahmen beim Hochladen von Anhängen abzufangen. Die Lösung lautet wie folgt:
1. Die hochgeladenen Dateien werden während des Upload-Vorgangs zunächst im Cache gespeichert. Fügen Sie aus Sicherheitsgründen einen temporären Speicherpfad zur Datei struts.properties des Projekts hinzu, obwohl der physische Pfad des Servers festgelegt wurde.
Kopieren Sie den Code wie folgt: struts.multipart.saveDir=/temp
2. Da die Größe des Datei-Uploads später geändert werden kann, unabhängig davon, ob dies die Standardeinstellung ist oder nicht, fügen Sie der Datei struts.properties des Projekts die folgende Konfiguration hinzu:
Kopieren Sie den Code wie folgt: <!-- Die zulässige Upload-Dateigröße beträgt 2 MB -->
<konstanter Name="struts.multipart.maxSize" value="2097152"/>
3. Struts.xml-Konfiguration
Kopieren Sie den Code wie folgt: <!-- So ändern Sie das Problem -->
<Aktionsname="updateProblem" method="updateProblem">
<interceptor-ref name="fileUpload"/>
<interceptor-ref name="defaultStack" />
<result name="input">/page/question/page/problemPage.jsp</result>
</action>
4. Der wichtigste und kritischste Schritt
Der FileUpload-Interceptor bestimmt den Dateityp und die Dateigröße erst, nachdem die Datei auf den Server hochgeladen wurde. Wenn wir in Aktion nichts tun, wird die Ausnahme dem Benutzer angezeigt. Daher habe ich mir eine Möglichkeit überlegt, die Ausnahmeinformationen als Fehlermeldung auf Aktionsebene festzulegen. Das heißt, überschreiben Sie die Methode addActionError.
Kopieren Sie den Codecode wie folgt: @Override
public void addActionError(String anErrorMessage) {
// Hier müssen wir zunächst feststellen, ob es sich um einen Fehler handelt, den wir ersetzen möchten, bevor wir ihn verarbeiten.
if (anErrorMessage.startsWith("die Anfrage wurde aufgrund ihrer Größe abgelehnt")) {
Mustermuster = Pattern.compile("d+");
Matcher m = pattern.matcher(anErrorMessage);
// Einmal abgleichen
m.find();
String s1 =m.group();//Größe der hochgeladenen Datei
// Erneut abgleichen
m.find();
String s2 =m.group();//begrenzte Größe
if(!s1.equals("") && !s2.equals("")){
fileUploadErrorMessage="Die Größe der von Ihnen hochgeladenen Datei (" + Long.valueOf(s1)/1024 + "Bytes) überschreitet die zulässige Größe (" + Long.valueOf(s2)/1024/1024 + "M)";
getRequest().setAttribute("fileUploadErrorMessage","Die Datei ist zu groß und überschreitet die zulässige Größe ("+Long.valueOf(s2)/1024/1024+"M). Der Upload ist fehlgeschlagen!");
// Ersetzen Sie die Informationen
super.addActionError(fileUploadErrorMessage);
}
} else {// Andernfalls behandeln Sie es gemäß der ursprünglichen Methode
super.addActionError(anErrorMessage);
}
}
Ja, verwenden Sie <s:fielderror/> <s:fielderror/> auf der Rückgabeseite, um den Fehlerinhalt in addActionError abzurufen.
Da ich die Fehlerursache nicht auf der Seite anzeigen und ein Eingabeaufforderungsfeld anzeigen möchte, füge ich die Informationen in das Anforderungsobjekt ein.
Beim Laden der Seite wird die folgende js-Überprüfung hinzugefügt:
Kopieren Sie den Codecode wie folgt: // Bestimmen Sie, ob die Datei erfolgreich hochgeladen wurde
var message="${request.fileUploadErrorMessage}";
if(message!=null && ""!=trim(message) && message!="null"){
self.parent.diag.close();
Warnung (Nachricht);
zurückkehren;
}
Hier sind einige Referenzen zum Verständnis von Dongdong:
struts.multipart.maxSize steuert die maximale Größe der vom gesamten Projekt hochgeladenen Dateien
Die MaximumSize-Attribute der Interceptoren struts.multipart.maxSize und fileUpload haben unterschiedliche Arbeitsteilungen, die wie folgt zusammengefasst werden:
1.struts.multipart.maxSize steuert die maximale Größe der hochgeladenen Dateien im gesamten Projekt.
Wird diese Größe überschritten, wird im Hintergrund ein Fehler gemeldet und das Programm kann eine so große Datei nicht verarbeiten. In fielderror wird die folgende Eingabeaufforderung angezeigt:
Die Anfrage wurde abgelehnt, da ihre Größe (16272982) das konfigurierte Maximum (9000000) überschreitet.
2. Das MaximumSize-Attribut des FileUpload-Interceptors muss kleiner als der Wert von struts.multipart.maxSize sein.
Der Standardwert für struts.multipart.maxSize beträgt 2M. Wenn MaximumSize größer als 2M ist, muss der Wert von struts.multipart.maxSize größer als MaximumSize eingestellt werden.
3. Wenn die hochgeladene Datei größer als struts.multipart.maxSize ist, meldet das System einen Fehler. Wenn die hochgeladene Datei zwischen struts.multipart.maxSize und MaximumSize liegt, fordert das System Folgendes auf:
Datei zu groß: Datei „MSF Concept.ppt“ „upload__5133e516_129ce85285f__7ffa_00000005.tmp“ 6007104
Wenn die hochgeladene Datei kleiner als MaximumSize ist, ist der Upload erfolgreich.
Kopieren Sie den Code wie folgt: <action name="UploadFile">
<result name="UploadFileResult">/pages/ShowOtherFiles.jsp</result>
<result name="JGBsuccess">/pages/JGBdetail.jsp</result>
<interceptor-ref name="fileUpload">
<param name="savePath">/data</param>
<param name="maximumSize">52428800</param>
</interceptor-ref>
<interceptor-ref name="defaultStack"></interceptor-ref>
</action>
Beim Hochladen großer Dateien tritt ein Fehler auf.
Problem: Fehler beim Hochladen großer Dateien...
Lösung: Ändern Sie die Parameter in der Datei struts.xml wie folgt. Kopieren Sie den Code wie folgt: <constant name="struts.multipart.maxSize" value="55000000"/>
<Aktionsname="UploadFile">
<result name="UploadFileResult">/www.VeVB.COm/ ShowOtherFiles.jsp</result>
<result name="JGBsuccess">/pages/JGBdetail.jsp</result>
<interceptor-ref name="fileUpload">
<param name="savePath">/data</param>
<param name="maximumSize">52428800</param>
</interceptor-ref>
<interceptor-ref name="defaultStack"></interceptor-ref>
</action>
Die Beziehung zwischen der Größe in der Datei struts.xml und der tatsächlichen Dateigröße: 1048576 (Bytes) = 1024*1024 = 1 MB tatsächliche Dateigröße.
struts.multipart.maxSize steuert die maximale Größe der vom gesamten Projekt hochgeladenen Dateien
Die MaximumSize-Attribute der Interceptoren struts.multipart.maxSize und fileUpload haben unterschiedliche Arbeitsteilungen, die wie folgt zusammengefasst werden:
1.struts.multipart.maxSize steuert die maximale Größe der hochgeladenen Dateien im gesamten Projekt. Wird diese Größe überschritten, wird im Hintergrund ein Fehler gemeldet und das Programm kann eine so große Datei nicht verarbeiten. In fielderror wird die folgende Eingabeaufforderung angezeigt:
Die Anfrage wurde abgelehnt, da ihre Größe (16272982) das konfigurierte Maximum (9000000) überschreitet.
2. Das MaximumSize-Attribut des FileUpload-Interceptors muss kleiner sein als der Wert von struts.multipart.maxSize.
Der Standardwert für struts.multipart.maxSize beträgt 2M. Wenn MaximumSize größer als 2M ist, muss der Wert von struts.multipart.maxSize größer als MaximumSize eingestellt werden.
3. Wenn die hochgeladene Datei größer als struts.multipart.maxSize ist, meldet das System einen Fehler. Wenn die hochgeladene Datei zwischen struts.multipart.maxSize und MaximumSize liegt, fordert das System Folgendes auf:
Datei zu groß: Datei „MSF Concept.ppt“ „upload__5133e516_129ce85285f__7ffa_00000005.tmp“ 6007104
Wenn die hochgeladene Datei kleiner als MaximumSize ist, ist der Upload erfolgreich.
Einschränkungen für den Dateityp beim Hochladen
Konfigurieren Sie den Datei-Upload-Interceptor
Der Standardstack von struts2 enthält bereits den Fileupload-Interceptor. Wenn Sie den Parameter „allowedTypes“ hinzufügen möchten, müssen Sie einen neuen Standardstack schreiben, ihn kopieren und ändern:
Kopieren Sie den Code wie folgt: <Interceptors>
<interceptor-stack name="myDefaultStack">
<interceptor-ref name="Exception"/>
<interceptor-ref name="alias"/>
<interceptor-ref name="servletConfig"/>
<interceptor-ref name="i18n"/>
<interceptor-ref name=www.VeVB.COm/>
<interceptor-ref name="chain"/>
<interceptor-ref name="debugging"/>
<interceptor-ref name="profiling"/>
<interceptor-ref name="scopedModelDriven"/>
<interceptor-ref name="modelDriven"/>
<interceptor-ref name="fileUpload">
<param name="allowedTypes">
Bild/PNG, Bild/Gif, Bild/JPEG
</param>
</interceptor-ref>
<interceptor-ref name="checkbox"/>
<interceptor-ref name="staticParams"/>
<interceptor-ref name="actionMappingParams"/>
<interceptor-ref name="params">
<param name="excludeParams">dojo..*,^struts..*</param>
</interceptor-ref>
<interceptor-ref name="conversionError"/>
<interceptor-ref name="validation">
<param name="excludeMethods">Eingabe, Zurück, Abbrechen, Durchsuchen</param>
</interceptor-ref>
<interceptor-ref name="workflow">
<param name="excludeMethods">Eingabe, Zurück, Abbrechen, Durchsuchen</param>
</interceptor-ref>
</interceptor-stack>
</interceptors>
<default-interceptor-ref name="myDefaultStack"></default-interceptor-ref>
Ändern Sie den kopierten Code im Code nur wie folgt: <interceptor-ref name="fileUpload">
<param name="allowedTypes">
Bild/PNG, Bild/Gif, Bild/JPEG
</param>
</interceptor-ref>
Der Interceptor-Stack wird wie oben innerhalb des <package>-Tags und außerhalb des <action>-Tags konfiguriert. Wenn wir ihn als Standard-Interceptor definieren, ist dies nicht erforderlich
Fügen Sie es in das <action>-Tag ein. Wenn nicht, müssen Sie einen Interceptor einfügen. Der Code lautet wie folgt: <action>
<result name="input">/error/dbError.jsp</result>
<interceptor-ref name="myDefaultStack"></interceptor-ref>
</action>
Die Fehleraktion „Datei-Upload“ gibt die Eingabe direkt zurück, sodass keine Notwendigkeit besteht, „Eingabe“ in der Aktion zurückzugeben.
Sie können den Pfad und die Größe Ihrer Upload-Anfrage auch außerhalb des <package>-Tags definieren:
Kopieren Sie den Code wie folgt: <constant name="struts.multipart.saveDir" value="/upload/detailed"></constant>
<constant name="struts.multipart.maxSize" value="1024"></constant>
Der wichtigste Punkt: Das Formular zum Hochladen von Dateien muss Folgendes enthalten: enctype="multipart/form-data". Andernfalls wird ein Eingabefehler gemeldet.
Ich hoffe, dass dieser Artikel für die Java-Programmierung aller hilfreich sein wird.