jsoup을 사용하여 html을 일반 텍스트로 변환할 때 줄 바꿈을 유지하는 방법은 무엇입니까?
다음 코드가 있습니다.
public class NewClass {
public String noTags(String str){
return Jsoup.parse(str).text();
}
public static void main(String args[]) {
String strings="<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN \">" +
"<HTML> <HEAD> <TITLE></TITLE> <style>body{ font-size: 12px;font-family: verdana, arial, helvetica, sans-serif;}</style> </HEAD> <BODY><p><b>hello world</b></p><p><br><b>yo</b> <a href=\"http://google.com\">googlez</a></p></BODY> </HTML> ";
NewClass text = new NewClass();
System.out.println((text.noTags(strings)));
}
그리고 결과가 나왔습니다.
hello world yo googlez
하지만 나는 선을 깨고 싶다.
hello world
yo googlez
jsoup의 TextNode #get을 확인했습니다.WholeText()는 사용법을 알 수 없습니다.
<br>
해석하는 마크업에서 출력 결과에서 줄 바꿈을 얻으려면 어떻게 해야 합니까?
라인브레이크를 유지하는 실제 솔루션은 다음과 같습니다.
public static String br2nl(String html) {
if(html==null)
return html;
Document document = Jsoup.parse(html);
document.outputSettings(new Document.OutputSettings().prettyPrint(false));//makes html() preserve linebreaks and spacing
document.select("br").append("\\n");
document.select("p").prepend("\\n\\n");
String s = document.html().replaceAll("\\\\n", "\n");
return Jsoup.clean(s, "", Whitelist.none(), new Document.OutputSettings().prettyPrint(false));
}
다음 요건을 충족합니다.
- 원본 html에 newline(\n)이 포함되어 있으면 보존됩니다.
- 원본 html에 br 또는 p 태그가 포함되어 있으면 newline(\n)으로 변환됩니다.
와 함께
Jsoup.parse("A\nB").text();
출력이 있습니다.
"A B"
가 아니라
A
B
이를 위해 사용하는 것은 다음과 같습니다.
descrizione = Jsoup.parse(html.replaceAll("(?i)<br[^>]*>", "br2n")).text();
text = descrizione.replaceAll("br2n", "\n");
Jsoup.clean(unsafeString, "", Whitelist.none(), new OutputSettings().prettyPrint(false));
여기서는 다음 방법을 사용합니다.
public static String clean(String bodyHtml,
String baseUri,
Whitelist whitelist,
Document.OutputSettings outputSettings)
을 건네줌으로써Whitelist.none()
HTML을 사용합니다.
new OutputSettings().prettyPrint(false)
출력이 재포맷되지 않고 줄 바꿈이 유지되는 것을 확인합니다.
에서는 Jsoup v1.11을 사용할 수 .2개Element.wholeText()
.
String cleanString = Jsoup.parse(htmlString).wholeText();
user121196's
응답은 아직 유효합니다.그렇지만wholeText()
는 텍스트의 정렬을 유지합니다.
jsoup을 사용하여 시도합니다.
public static String cleanPreserveLineBreaks(String bodyHtml) {
// get pretty printed html with preserved br and p tags
String prettyPrintedBodyFragment = Jsoup.clean(bodyHtml, "", Whitelist.none().addTags("br", "p"), new OutputSettings().prettyPrint(true));
// get plain text with preserved line breaks by disabled prettyPrint
return Jsoup.clean(prettyPrintedBodyFragment, "", Whitelist.none(), new OutputSettings().prettyPrint(false));
}
보다 복잡한 HTML에서는 위의 솔루션 중 어느 것도 제대로 작동하지 않았습니다.다음과 같이 줄 바꿈을 유지하면서도 성공적으로 변환할 수 있었습니다.
Document document = Jsoup.parse(myHtml);
String text = new HtmlToPlainText().getPlainText(document);
(버전 1.10.3)
지정된 요소를 이동할 수 있습니다.
public String convertNodeToText(Element element)
{
final StringBuilder buffer = new StringBuilder();
new NodeTraversor(new NodeVisitor() {
boolean isNewline = true;
@Override
public void head(Node node, int depth) {
if (node instanceof TextNode) {
TextNode textNode = (TextNode) node;
String text = textNode.text().replace('\u00A0', ' ').trim();
if(!text.isEmpty())
{
buffer.append(text);
isNewline = false;
}
} else if (node instanceof Element) {
Element element = (Element) node;
if (!isNewline)
{
if((element.isBlock() || element.tagName().equals("br")))
{
buffer.append("\n");
isNewline = true;
}
}
}
}
@Override
public void tail(Node node, int depth) {
}
}).traverse(element);
return buffer.toString();
}
그리고 당신의 코드를 위해
String result = convertNodeToText(JSoup.parse(html))
text = Jsoup.parse(html.replaceAll("(?i)<br[^>]*>", "br2n")).text();
text = descrizione.replaceAll("br2n", "\n");
html 자체에 "br2n"이 포함되어 있지 않으면 동작합니다.
그렇게,
text = Jsoup.parse(html.replaceAll("(?i)<br[^>]*>", "<pre>\n</pre>")).text();
보다 신뢰성이 높고 간단하게 동작합니다.
다른 답변이나 이 질문에 대한 코멘트를 보면, 여기 오는 대부분의 사람들은 HTML 문서를 올바르게 포맷한 평문 표현을 제공할 수 있는 일반적인 솔루션을 찾고 있는 것 같습니다.내가 그랬다는 거 알아.
다행히 JSoup은 이를 실현하는 방법에 대한 매우 포괄적인 예를 이미 제공하고 있습니다.HtmlToPlainText.java
:FormattingVisitor
원하는 대로 쉽게 조정할 수 있으며 대부분의 블록 요소 및 줄 바꿈을 처리합니다.
링크의 부패를 방지하기 위해 Jonathan Hedley의 솔루션 전체를 다음에 나타냅니다.
package org.jsoup.examples;
import org.jsoup.Jsoup;
import org.jsoup.helper.StringUtil;
import org.jsoup.helper.Validate;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.jsoup.nodes.TextNode;
import org.jsoup.select.Elements;
import org.jsoup.select.NodeTraversor;
import org.jsoup.select.NodeVisitor;
import java.io.IOException;
/**
* HTML to plain-text. This example program demonstrates the use of jsoup to convert HTML input to lightly-formatted
* plain-text. That is divergent from the general goal of jsoup's .text() methods, which is to get clean data from a
* scrape.
* <p>
* Note that this is a fairly simplistic formatter -- for real world use you'll want to embrace and extend.
* </p>
* <p>
* To invoke from the command line, assuming you've downloaded the jsoup jar to your current directory:</p>
* <p><code>java -cp jsoup.jar org.jsoup.examples.HtmlToPlainText url [selector]</code></p>
* where <i>url</i> is the URL to fetch, and <i>selector</i> is an optional CSS selector.
*
* @author Jonathan Hedley, jonathan@hedley.net
*/
public class HtmlToPlainText {
private static final String userAgent = "Mozilla/5.0 (jsoup)";
private static final int timeout = 5 * 1000;
public static void main(String... args) throws IOException {
Validate.isTrue(args.length == 1 || args.length == 2, "usage: java -cp jsoup.jar org.jsoup.examples.HtmlToPlainText url [selector]");
final String url = args[0];
final String selector = args.length == 2 ? args[1] : null;
// fetch the specified URL and parse to a HTML DOM
Document doc = Jsoup.connect(url).userAgent(userAgent).timeout(timeout).get();
HtmlToPlainText formatter = new HtmlToPlainText();
if (selector != null) {
Elements elements = doc.select(selector); // get each element that matches the CSS selector
for (Element element : elements) {
String plainText = formatter.getPlainText(element); // format that element to plain text
System.out.println(plainText);
}
} else { // format the whole doc
String plainText = formatter.getPlainText(doc);
System.out.println(plainText);
}
}
/**
* Format an Element to plain-text
* @param element the root element to format
* @return formatted text
*/
public String getPlainText(Element element) {
FormattingVisitor formatter = new FormattingVisitor();
NodeTraversor traversor = new NodeTraversor(formatter);
traversor.traverse(element); // walk the DOM, and call .head() and .tail() for each node
return formatter.toString();
}
// the formatting rules, implemented in a breadth-first DOM traverse
private class FormattingVisitor implements NodeVisitor {
private static final int maxWidth = 80;
private int width = 0;
private StringBuilder accum = new StringBuilder(); // holds the accumulated text
// hit when the node is first seen
public void head(Node node, int depth) {
String name = node.nodeName();
if (node instanceof TextNode)
append(((TextNode) node).text()); // TextNodes carry all user-readable text in the DOM.
else if (name.equals("li"))
append("\n * ");
else if (name.equals("dt"))
append(" ");
else if (StringUtil.in(name, "p", "h1", "h2", "h3", "h4", "h5", "tr"))
append("\n");
}
// hit when all of the node's children (if any) have been visited
public void tail(Node node, int depth) {
String name = node.nodeName();
if (StringUtil.in(name, "br", "dd", "dt", "p", "h1", "h2", "h3", "h4", "h5"))
append("\n");
else if (name.equals("a"))
append(String.format(" <%s>", node.absUrl("href")));
}
// appends text to the string builder with a simple word wrap method
private void append(String text) {
if (text.startsWith("\n"))
width = 0; // reset counter if starts with a newline. only from formats above, not in natural text
if (text.equals(" ") &&
(accum.length() == 0 || StringUtil.in(accum.substring(accum.length() - 1), " ", "\n")))
return; // don't accumulate long runs of empty spaces
if (text.length() + width > maxWidth) { // won't fit, needs to wrap
String words[] = text.split("\\s+");
for (int i = 0; i < words.length; i++) {
String word = words[i];
boolean last = i == words.length - 1;
if (!last) // insert a space if not the last word
word = word + " ";
if (word.length() + width > maxWidth) { // wrap and reset counter
accum.append("\n").append(word);
width = word.length();
} else {
accum.append(word);
width += word.length();
}
}
} else { // fits as is, without need to wrap text
accum.append(text);
width += text.length();
}
}
@Override
public String toString() {
return accum.toString();
}
}
}
이것을 시험해 보세요.
public String noTags(String str){
Document d = Jsoup.parse(str);
TextNode tn = new TextNode(d.body().html(), "");
return tn.getWholeText();
}
textNodes()
텍스트 노드 목록을 가져옵니다.그런 다음 연결해서\n
구분자로 사용합니다.여기에 사용하는 스칼라 코드를 나타냅니다.java 포트는 간단해야 합니다.
val rawTxt = doc.body().getElementsByTag("div").first.textNodes()
.asScala.mkString("<br />\n")
jsoup을 사용하여 시도합니다.
doc.outputSettings(new OutputSettings().prettyPrint(false));
//select all <br> tags and append \n after that
doc.select("br").after("\\n");
//select all <p> tags and prepend \n before that
doc.select("p").before("\\n");
//get the HTML from the document, and retaining original new lines
String str = doc.html().replaceAll("\\\\n", "\n");
이것은 html을 텍스트로 번역하는 제 버전입니다(실제로 user121196 answer의 수정 버전입니다).
이것은 줄 바꿈뿐만 아니라 텍스트를 포맷하고 과도한 줄 바꿈, HTML 이스케이프 기호를 제거하여 HTML에서 훨씬 더 좋은 결과를 얻을 수 있습니다(내 경우 메일에서 받고 있습니다).
원래 Scala로 되어 있는데 Java로 쉽게 변경할 수 있습니다.
def html2text( rawHtml : String ) : String = {
val htmlDoc = Jsoup.parseBodyFragment( rawHtml, "/" )
htmlDoc.select("br").append("\\nl")
htmlDoc.select("div").prepend("\\nl").append("\\nl")
htmlDoc.select("p").prepend("\\nl\\nl").append("\\nl\\nl")
org.jsoup.parser.Parser.unescapeEntities(
Jsoup.clean(
htmlDoc.html(),
"",
Whitelist.none(),
new org.jsoup.nodes.Document.OutputSettings().prettyPrint(true)
),false
).
replaceAll("\\\\nl", "\n").
replaceAll("\r","").
replaceAll("\n\\s+\n","\n").
replaceAll("\n\n+","\n\n").
trim()
}
/**
* Recursive method to replace html br with java \n. The recursive method ensures that the linebreaker can never end up pre-existing in the text being replaced.
* @param html
* @param linebreakerString
* @return the html as String with proper java newlines instead of br
*/
public static String replaceBrWithNewLine(String html, String linebreakerString){
String result = "";
if(html.contains(linebreakerString)){
result = replaceBrWithNewLine(html, linebreakerString+"1");
} else {
result = Jsoup.parse(html.replaceAll("(?i)<br[^>]*>", linebreakerString)).text(); // replace and html line breaks with java linebreak.
result = result.replaceAll(linebreakerString, "\n");
}
return result;
}
br을 포함한 해당 html과 임시 줄 바꿈 플레이스 홀더로 사용할 문자열을 호출하여 사용합니다.예를 들어 다음과 같습니다.
replaceBrWithNewLine(element.html(), "br2n")
링크브레이커 플레이스홀더 문자열이 html에 없을 때까지 "1"을 계속 추가하기 때문에 재귀로 인해 newline/linebreaker 플레이스홀더로 사용하는 문자열은 실제로 소스 html에 존재하지 않습니다.Jsoup.clean 메서드에서 특수문자가 발생할 것으로 보이는 포맷 문제는 발생하지 않습니다.
사용자 121196과 Green Beret의 답변을 바탕으로select
및<pre>
s, 나에게 유효한 유일한 솔루션은 다음과 같습니다.
org.jsoup.nodes.Element elementWithHtml = ....
elementWithHtml.select("br").append("<pre>\n</pre>");
elementWithHtml.select("p").prepend("<pre>\n\n</pre>");
elementWithHtml.text();
언급URL : https://stackoverflow.com/questions/5640334/how-do-i-preserve-line-breaks-when-using-jsoup-to-convert-html-to-plain-text
'sourcecode' 카테고리의 다른 글
작년도의 액티브 오더를 받는 방법 (0) | 2022.12.26 |
---|---|
동기 프로그래밍과 비동기 프로그래밍(node.js)의 차이점은 무엇입니까? (0) | 2022.12.26 |
phpMyAdmin 설치 - 오류 1045:접근 거부됨(사용: 비밀번호: NO) (0) | 2022.12.26 |
Java에서 현재 실행 중인 모든 스레드 목록 가져오기 (0) | 2022.12.26 |
한 페이지에 여러 개의 리캡처를 표시하려면 어떻게 해야 하나요? (0) | 2022.12.26 |