Problem mit regulären Ausdruck in Zusammenhang mit HTML

FFlash

Mitglied
Hallo,

ich wollte einen regulären Ausdruck schreiben mitdem ich aus einem HTML-Text den Dateinamen aus allen IMG-Tags auslesen kann.

Ich habe auch schon es mit

Java:
"<img src=\".*">"
versucht. Das funktioniert auch mit einen Bild im Text. Aber nicht mit mehreren Bildern.

Nun meine Frage: Wie muss ich meine regulären Ausdruck umschreiben damit ich ich immer den Dateinamen aus den IMG-Tags erhalt egal wo der IMG-Tag steht und wieviele es sind?

Ich habe auch schon Onkel Goggle gefragt, aber nicht etwas brauchbares gefunden.
 
Klammern drum und + oder * dran für Wiederholung?

am deutlichsten wäre ein kleines main-Programm mit einem möglichst kurzen Beispiel-String aus deinem HTML,
das Pattern, was du sonst noch von RegEx verwendest (matches() oder find()?)
Ausgabe usw,
so wie es im Moment nicht funktioniert und auch textuell was stattdessen passieren soll
 
Hallo,

am deutlichsten wäre ein kleines main-Programm mit einem möglichst kurzen Beispiel-String aus deinem HTML

mit einem kleinen Beispiel kann ich nicht dienen, da ich den Code nicht rausgeben darf. Ist außerdem zu viel Code.....


Klammern drum und + oder * dran für Wiederholung?

Was meinst Du damit?


das Pattern, was du sonst noch von RegEx verwendest (matches() oder find()?)

Ich verwende Pattern auf einen Matcher und danach find(), da mich die Position interessiert.


Am Bestem erkläre ich das Ganz mal:
Ich will aus einem HTML-Text die IMG-Tags so umwandelt, dass ich die Bilder in eine E-Mail einbetten kann und dann das Ganze über JavaMail verschicken kann ohne das die Bilder nachgeladen werden müssen.
 
> Was meinst Du damit?

hier ein Beispiel:
aus x wird (x)*

> da ich den Code nicht rausgeben darf. Ist außerdem zu viel Code.....

viel Code will auch keiner sehen sondern einfache Beispiele die sich um das Problem drehen, nicht um irrelevante Dinge

Java:
public class Test
{
    public static void main(String[] args)
    {
        String st = "img img img";
        Pattern p = Pattern.compile("i");
        Matcher m = p.matcher(st);
        while (m.find())
        {
            System.out.println("found: " + m.group());
        }
    }
}
ist das geheimer Firmencode?
da ich mir nun die Mühe machen musste statt du, werde ich entsprechend weniger Zeit für die Antwort deiner Frage haben,
Pech gehabt 😉
 
Hallo,

ist das geheimer Firmencode? [/qoute]
ja, ist es.

Außerdem geht es mir darum, aus einen IMG-Tag die scr , also die Quelldatei, auszulesen und den Namen und Speicherort zu speichern und dann die Tag so umzuschreiben, dass die Bilder in einer E-Mail einzubetten um diese dann über JavaMail zu versenden.

Damit wir uns auch richtig versteht, es geht mir nur darum wie ich im Hilfe er regulären Ausdrücke die Start und Endpositionen des vollständigen Dateinem rauszufinden.;-)
 
immer noch gilt: ändere bitte das nun von mir gepostete Programm soweit, dass der Fehler sichtbar wird,
füge paar Testzeilen HTML rein, ruhig nur Dummy-Daten, keine geheimen Firma-Img-Dateinamen,
dazu dein bisheriges Pattern usw. damit der Fehler sichtbar wird,

denkbar ist vielleicht dass das .* aus <img src=\".*"> alles bis zum Ende des letzten img-Tags konsumiert,
da kann man versuchen den RegEx so zu konfigurieren, dass er nur wenig in .* zusammenfasst

siehe
Quantifiers (The Java™ Tutorials > Essential Classes > Regular Expressions)
[..]
Differences Among Greedy, Reluctant, and Possessive Quantifiers
[..]
To illustrate, consider the input string xfooxxxxxxfoo.


Enter your regex: .*foo // greedy quantifier
Enter input string to search: xfooxxxxxxfoo
I found the text "xfooxxxxxxfoo" starting at index 0 and ending at index 13.

Enter your regex: .*?foo // reluctant quantifier
Enter input string to search: xfooxxxxxxfoo
I found the text "xfoo" starting at index 0 and ending at index 4.
I found the text "xxxxxxfoo" starting at index 4 and ending at index 13.
[..]

oder etwas natürlicher:
statt .* suche nur nach allem außer >, also [^>]*
 
Ok ok,
Dann gibt es jetzt ein kleines Beispiel:
[Java]
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.Authenticator;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;

public class Test {
private static final String SMTP_AUTH_USER = "geheim";
private static final String SMTP_AUTH_PWD = "geheim";
private static final String SMTP_SEND_FROM = "geheim";
private static final String SMTP_SEND_SERVER = "geheim";
public void sendTest(String messagetext, String subject, String recipient, ArrayList<File> attachments) throws Exception {
Properties props = new Properties();
props.put("mail.smtp.host", SMTP_SEND_SERVER);
props.put("mail.smtp.auth", "true");
Authenticator auth = new SMTPAuthenticator();
Session session = Session.getDefaultInstance(props, auth);
Message msg = new MimeMessage(session);
InternetAddress addressFrom = new InternetAddress(SMTP_SEND_FROM);
msg.setFrom(addressFrom);
InternetAddress addressTo = new InternetAddress(recipient);
msg.setRecipient(Message.RecipientType.TO, addressTo);
// Message
Message message = new MimeMessage(session);
// Headers
message.setSubject(subject);
message.setFrom(new InternetAddress(SMTP_SEND_FROM));
message.addRecipient(Message.RecipientType.TO, addressTo);
// Message Parts
BodyPart messageBodyPart = new MimeBodyPart();
//--------------------------------------------------------------
Matcher matcher = Pattern.compile("<img src=\".*+[^>]+>").matcher(messagetext);


ArrayList<IntegerPositionen> alIntegerPositionen = new ArrayList<IntegerPositionen>();
while(matcher.find()) {
alIntegerPositionen.add(new IntegerPositionen(matcher.start(), matcher.end()));
}
//--------------------------------------------------------------
ArrayList<File> alFile = new ArrayList<File>();
int counter = 0;
Collections.reverse(alIntegerPositionen);
for(int i = 0; i < alIntegerPositionen.size(); i++) {
int startposition = alIntegerPositionen.get(i).getStart() + 10;
int endposition = alIntegerPositionen.get(i).getEnd() - 2;
String filename = messagetext.substring(startposition, endposition);
File file = new File(filename);
alFile.add(file);
messagetext = messagetext.substring(0, alIntegerPositionen.get(i).getStart()) + "<img src=\"cid:bild" + counter + "\">" + messagetext.substring(alIntegerPositionen.get(i).getEnd());
counter++;
}
//--------------------------------------------------------------
// Content des Body Parts
messageBodyPart.setContent(messagetext, "text/html");
//--------------------------------------------------------------


// Multipart definieren
MimeMultipart multipart = new MimeMultipart("related");
// Body Part dem Multipart hinzufügen
multipart.addBodyPart(messageBodyPart);

//--------------------------------------------------------------
for(int i = 0; i < alFile.size(); i++) {
// Image Part definieren
messageBodyPart = new MimeBodyPart();
// Lesen des Images und Zuordnung an den Part
DataSource fds = new FileDataSource(alFile.get(i));
messageBodyPart.setDataHandler(new DataHandler(fds));
// Header Verbindung zum HTML: wie beim Header
messageBodyPart.setHeader("Content-ID", "bild" + i);
// Dem Multipart Objekt hinzufügen
multipart.addBodyPart(messageBodyPart);
}

//--------------------------------------------------------------
for(int i = 0; i < attachments.size(); i++) {
// Der zweite Teil des Multipart-Objektes ist der binäre Datei-Inhalt:
messageBodyPart = new MimeBodyPart();
// Datei-Anhang präparieren nach Aufgabenstellung:
messageBodyPart.setDataHandler(new DataHandler(new FileDataSource(attachments.get(i))));
messageBodyPart.setFileName(attachments.get(i).getName());
// Zweiten Teil hinzufügen:
multipart.addBodyPart(messageBodyPart);
}
//--------------------------------------------------------------
// Multipart mit Message assoziieren
message.setContent(multipart);
// Message senden
Transport.send(message);
}
private static class SMTPAuthenticator extends javax.mail.Authenticator {

@Override
public PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(SMTP_AUTH_USER, SMTP_AUTH_PWD);
}
}
private static class IntegerPositionen {
private int start = 0;
private int end = 0;
@SuppressWarnings("unused")
private IntegerPositionen() {

}
public IntegerPositionen(int start, int end) {
this.start = start;
this.end = end;
}
public int getStart() {
return this.start;
}
public int getEnd() {
return this.end;
}
}
public void Main() throws Exception {
String messagetext = "Dies ist ein Test.Mit Bildern --><img src=\"C:/Bilder/1.jpg\"> <img src=\"C:/Bilder/2.jpg\">";
String subject = "Testmail";
String recipient = "geheim";
ArrayList<File> attachments = new ArrayList<File>();
new Test().sendTest(messagetext, subject, recipient, attachments);

}
}

[/Java]
Der für mich interessante Teil ist der hier(und wo der Fehler auftritt):
[Java=47]Matcher matcher = Pattern.compile("<img src=\".*+[^>]+>").matcher(messagetext);[/Java]

Der Sinn der Funktion ist schnell erklärt: Der Dateipfad soll so umgewandelt werden, dass jedes einzelne Bild in der E-Mail nicht als Attachment an die E-Mail angefügt werden, sondern in der E-Mail mitversand werden sollen.
Ich hoffe, ich habe mich einigermassen deutlich ausgedrückt.
Mehr kann ich nicht erklären. (Firmengeheimnis) Daher bitte ich um Verständnis.

statt .* suche nur nach allem außer >, also [^>]*

werde ich mal versuchen.....
 
warum du jetzt soviel Code zu Email postest ist mir nicht ganz verständlich,
folgendes scheint vorerst zu laufen,
Java:
public class Test
{
    public static void main(String[] args)
        throws Exception
    {
        String st = "Dies ist ein Test.Mit Bildern --><img src=\"C:/Bilder/1.jpg\"> <img src=\"C:/Bilder/2.jpg\">";
        Pattern p = Pattern.compile("<img src=\"[^>]+>");
        Matcher m = p.matcher(st);
        while (m.find())
        {
            System.out.println("found: " + m.group());
        }
    }
}
falls weitere Probleme bestehen: einfach das kurze Testprogramm erweitern
 

Zurück
Oben