<dependency>  <groupId>org.springframework</groupId>  <artifactId>spring-jdbc</artifactId>  <version>4.1.1.RELEASE</version></dependency><dependency>  <groupId>commons-pool</groupId>  <artifactId>commons-pool</artifactId>  <version>1.6</version></dependency><dependency>  <groupId>commons-dbcp</groupId>  <artifactId>commons-dbcp</artifactId>  <version>1.4</version></dependency><dependency>  <groupId>mysql</groupId>  <artifactId>mysql-connector-java</artifactId>  <version>5.1.38</version></dependency><dependency>  <groupId>mysql</groupId>  <artifactId>mysql-connector-java</artifactId>  <version>5.1.38</version></dependency> 

 <context:property-placeholder location="classpath*:*.properties"/><bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  <property name="driverClassName" value="${jdbc.driver}"/>  <property name="url" value="${jdbc.url}"/>  <property name="username" value="${jdbc.username}"/>  <property name="password" value="${jdbc.password}"/></bean> 

<dependency>  <groupId>org.htmlparser</groupId>  <artifactId>htmlparser</artifactId>  <version>1.6</version></dependency> 

<dependency>  <groupId>org.apache.httpcomponents</groupId>  <artifactId>httpclient</artifactId>  <version>4.5.2</version></dependency>　

<mirrors>  <mirror>   <id>alimaven</id>   <name>aliyun maven</name>   <url>http://maven.aliyun.com/nexus/content/groups/public/</url>   <mirrorOf>central</mirrorOf>      </mirror></mirrors> 

@Test  public void testFile(){    File seedFile = new File(this.getClass().getResource("/seed.properties").getPath());    System.out.print("===========" + seedFile.length() + "===========" );  }

package java.util.regex;import java.util.Objects;public final class Matcher implements MatchResult {  /**   * The Pattern object that created this Matcher.   */  Pattern parentPattern;   /**   * The storage used by groups. They may contain invalid values if   * a group was skipped during the matching.   */  int[] groups;   /**   * The range within the sequence that is to be matched. Anchors   * will match at these "hard" boundaries. Changing the region   * changes these values.   */  int from, to;   /**   * Lookbehind uses this value to ensure that the subexpression   * match ends at the point where the lookbehind was encountered.   */  int lookbehindTo;   /**   * The original string being matched.   */  CharSequence text;   /**   * Matcher state used by the last node. NOANCHOR is used when a   * match does not have to consume all of the input. ENDANCHOR is   * the mode used for matching all the input.   */  static final int ENDANCHOR = 1;  static final int NOANCHOR = 0;  int acceptMode = NOANCHOR;   /**   * The range of string that last matched the pattern. If the last   * match failed then first is -1; last initially holds 0 then it   * holds the index of the end of the last match (which is where the   * next search starts).   */  int first = -1, last = 0;   /**   * The end index of what matched in the last match operation.   */  int oldLast = -1;   /**   * The index of the last position appended in a substitution.   */  int lastAppendPosition = 0;   /**   * Storage used by nodes to tell what repetition they are on in   * a pattern, and where groups begin. The nodes themselves are stateless,   * so they rely on this field to hold state during a match.   */  int[] locals;   /**   * Boolean indicating whether or not more input could change   * the results of the last match.   *   * If hitEnd is true, and a match was found, then more input   * might cause a different match to be found.   * If hitEnd is true and a match was not found, then more   * input could cause a match to be found.   * If hitEnd is false and a match was found, then more input   * will not change the match.   * If hitEnd is false and a match was not found, then more   * input will not cause a match to be found.   */  boolean hitEnd;   /**   * Boolean indicating whether or not more input could change   * a positive match into a negative one.   *   * If requireEnd is true, and a match was found, then more   * input could cause the match to be lost.   * If requireEnd is false and a match was found, then more   * input might change the match but the match won't be lost.   * If a match was not found, then requireEnd has no meaning.   */  boolean requireEnd;   /**   * If transparentBounds is true then the boundaries of this   * matcher's region are transparent to lookahead, lookbehind,   * and boundary matching constructs that try to see beyond them.   */  boolean transparentBounds = false;   /**   * If anchoringBounds is true then the boundaries of this   * matcher's region match anchors such as ^ and $.   */  boolean anchoringBounds = true;   /**   * No default constructor.   */  Matcher() {  } /** * All matchers have the state used by Pattern during a match. */Matcher(Pattern parent, CharSequence text) {  this.parentPattern = parent;  this.text = text;   // Allocate state storage  int parentGroupCount = Math.max(parent.capturingGroupCount, 10);  groups = new int[parentGroupCount * 2];  locals = new int[parent.localCount];   // Put fields into initial states  reset();}..../** * Returns the input subsequence matched by the previous match. * * <p> For a matcher <i>m</i> with input sequence <i>s</i>, * the expressions <i>m.</i><tt>group()</tt> and * <i>s.</i><tt>substring(</tt><i>m.</i><tt>start(),</tt> <i>m.</i><tt>end())</tt> * are equivalent. </p> * * <p> Note that some patterns, for example <tt>a*</tt>, match the empty * string. This method will return the empty string when the pattern * successfully matches the empty string in the input. </p> * * @return The (possibly empty) subsequence matched by the previous match, *     in string form * * @throws IllegalStateException *     If no match has yet been attempted, *     or if the previous match operation failed */public String group() {  return group(0);}/** * Returns the input subsequence captured by the given group during the * previous match operation. * * <p> For a matcher <i>m</i>, input sequence <i>s</i>, and group index * <i>g</i>, the expressions <i>m.</i><tt>group(</tt><i>g</i><tt>)</tt> and * <i>s.</i><tt>substring(</tt><i>m.</i><tt>start(</tt><i>g</i><tt>),</tt> <i>m.</i><tt>end(</tt><i>g</i><tt>))</tt> * are equivalent. </p> * * <p> <a href="Pattern.html#cg">Capturing groups</a> are indexed from left * to right, starting at one. Group zero denotes the entire pattern, so * the expression <tt>m.group(0)</tt> is equivalent to <tt>m.group()</tt>. * </p> * * <p> If the match was successful but the group specified failed to match * any part of the input sequence, then <tt>null</tt> is returned. Note * that some groups, for example <tt>(a*)</tt>, match the empty string. * This method will return the empty string when such a group successfully * matches the empty string in the input. </p> * * @param group *     The index of a capturing group in this matcher's pattern * * @return The (possibly empty) subsequence captured by the group *     during the previous match, or <tt>null</tt> if the group *     failed to match part of the input * * @throws IllegalStateException *     If no match has yet been attempted, *     or if the previous match operation failed * * @throws IndexOutOfBoundsException *     If there is no capturing group in the pattern *     with the given index */public String group(int group) {  if (first < 0)    throw new IllegalStateException("No match found");  if (group < 0 || group > groupCount())    throw new IndexOutOfBoundsException("No group " + group);  if ((groups[group*2] == -1) || (groups[group*2+1] == -1))    return null;  return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();}/** * Attempts to find the next subsequence of the input sequence that matches * the pattern. * * <p> This method starts at the beginning of this matcher's region, or, if * a previous invocation of the method was successful and the matcher has * not since been reset, at the first character not matched by the previous * match. * * <p> If the match succeeds then more information can be obtained via the * <tt>start</tt>, <tt>end</tt>, and <tt>group</tt> methods. </p> * * @return <tt>true</tt> if, and only if, a subsequence of the input *     sequence matches this matcher's pattern */public boolean find() {  int nextSearchIndex = last;  if (nextSearchIndex == first)    nextSearchIndex++;   // If next search starts before region, start it at region  if (nextSearchIndex < from)    nextSearchIndex = from;   // If next search starts beyond region then it fails  if (nextSearchIndex > to) {    for (int i = 0; i < groups.length; i++)      groups[i] = -1;    return false;  }  return search(nextSearchIndex);} /** * Initiates a search to find a Pattern within the given bounds. * The groups are filled with default values and the match of the root * of the state machine is called. The state machine will hold the state * of the match as it proceeds in this matcher. * * Matcher.from is not set here, because it is the "hard" boundary * of the start of the search which anchors will set to. The from param * is the "soft" boundary of the start of the search, meaning that the * regex tries to match at that index but ^ won't match there. Subsequent * calls to the search methods start at a new "soft" boundary which is * the end of the previous match. */boolean search(int from) {  this.hitEnd = false;  this.requireEnd = false;  from    = from < 0 ? 0 : from;  this.first = from;  this.oldLast = oldLast < 0 ? from : oldLast;  for (int i = 0; i < groups.length; i++)    groups[i] = -1;  acceptMode = NOANCHOR;  boolean result = parentPattern.root.match(this, from, text);  if (!result)    this.first = -1;  this.oldLast = this.last;  return result;}...} 

boolean search(int from) {  this.hitEnd = false;  this.requireEnd = false;  from    = from < 0 ? 0 : from;  this.first = from;  this.oldLast = oldLast < 0 ? from : oldLast;  for (int i = 0; i < groups.length; i++)    groups[i] = -1;  acceptMode = NOANCHOR;  boolean result = parentPattern.root.match(this, from, text);  if (!result)    this.first = -1;  this.oldLast = this.last;  return result;}