From 117d0ece117ba52d3d3fda39dd99dfa90ae58dae Mon Sep 17 00:00:00 2001 From: Zed Date: Wed, 4 Mar 2020 14:43:11 +0800 Subject: [PATCH 1/4] =?UTF-8?q?REPORT-27588=20jackson-databind=E5=AE=89?= =?UTF-8?q?=E5=85=A8=E6=BC=8F=E6=B4=9E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../jsontype/impl/SubTypeValidator.java | 49 +++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/fine-jackson/src/com/fr/third/fasterxml/jackson/databind/jsontype/impl/SubTypeValidator.java b/fine-jackson/src/com/fr/third/fasterxml/jackson/databind/jsontype/impl/SubTypeValidator.java index 970c29171..e2e52655b 100644 --- a/fine-jackson/src/com/fr/third/fasterxml/jackson/databind/jsontype/impl/SubTypeValidator.java +++ b/fine-jackson/src/com/fr/third/fasterxml/jackson/databind/jsontype/impl/SubTypeValidator.java @@ -88,6 +88,55 @@ public class SubTypeValidator // [databind#2341]: jdom/jdom2 (2.9.9.1) s.add("org.jdom.transform.XSLTransformer"); s.add("org.jdom2.transform.XSLTransformer"); + + // [databind#2387], [databind#2460]: EHCache + s.add("net.sf.ehcache.transaction.manager.DefaultTransactionManagerLookup"); + s.add("net.sf.ehcache.hibernate.EhcacheJtaTransactionManagerLookup"); + + // [databind#2389]: logback/jndi + s.add("ch.qos.logback.core.db.JNDIConnectionSource"); + + // [databind#2410]: HikariCP/metricRegistry config + s.add("com.zaxxer.hikari.HikariConfig"); + // [databind#2449]: and sub-class thereof + s.add("com.zaxxer.hikari.HikariDataSource"); + + // [databind#2420]: CXF/JAX-RS provider/XSLT + s.add("org.apache.cxf.jaxrs.provider.XSLTJaxbProvider"); + + // [databind#2462]: commons-configuration / -2 + s.add("org.apache.commons.configuration.JNDIConfiguration"); + s.add("org.apache.commons.configuration2.JNDIConfiguration"); + + // [databind#2469]: xalan2 + s.add("org.apache.xalan.lib.sql.JNDIConnectionPool"); + + // [databind#2478]: comons-dbcp, p6spy + s.add("org.apache.commons.dbcp.datasources.PerUserPoolDataSource"); + s.add("org.apache.commons.dbcp.datasources.SharedPoolDataSource"); + s.add("com.p6spy.engine.spy.P6DataSource"); + + // [databind#2498]: log4j-extras (1.2) + s.add("org.apache.log4j.receivers.db.DriverManagerConnectionSource"); + s.add("org.apache.log4j.receivers.db.JNDIConnectionSource"); + + // [databind#2526]: some more ehcache + s.add("net.sf.ehcache.transaction.manager.selector.GenericJndiSelector"); + s.add("net.sf.ehcache.transaction.manager.selector.GlassfishSelector"); + + // [databind#2620]: xbean-reflect + s.add("org.apache.xbean.propertyeditor.JndiConverter"); + + // [databind#2631]: shaded hikari-config + s.add("org.apache.hadoop.shaded.com.zaxxer.hikari.HikariConfig"); + + // [databind#2634]: ibatis-sqlmap, anteros-core + s.add("com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig"); + s.add("br.com.anteros.dbcp.AnterosDBCPConfig"); + + // [databind#2642]: javax.swing (jdk) + s.add("javax.swing.JEditorPane"); + DEFAULT_NO_DESER_CLASS_NAMES = Collections.unmodifiableSet(s); } From 12035a1ef2d160fec7a8258c45ad9ea27d6122eb Mon Sep 17 00:00:00 2001 From: Maksim Date: Tue, 31 Mar 2020 21:00:52 +0800 Subject: [PATCH 2/4] =?UTF-8?q?=E6=9A=82=E6=97=B6=E5=85=BC=E5=AE=B9?= =?UTF-8?q?=E6=97=A7=E7=89=88=E6=9C=AC=E6=96=B0=E5=BC=95=E6=93=8E=E6=8F=92?= =?UTF-8?q?=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- build.third_step1-jdk11.gradle | 1 + build.third_step1.gradle | 1 + .../mathcs/backport/java/util/Arrays.java | 798 ++++++++++++++++++ 3 files changed, 800 insertions(+) create mode 100644 fine-deprecated-utils/src/edu/emory/mathcs/backport/java/util/Arrays.java diff --git a/build.third_step1-jdk11.gradle b/build.third_step1-jdk11.gradle index 9007d2927..6279a3f14 100644 --- a/build.third_step1-jdk11.gradle +++ b/build.third_step1-jdk11.gradle @@ -31,6 +31,7 @@ sourceSets{ main{ java{ srcDirs=[ + "${srcDir}/fine-deprecated-utils/src", "${srcDir}/fine-asm/src", "${srcDir}/fine-antlr4/src", "${srcDir}/fine-aspectj/src", diff --git a/build.third_step1.gradle b/build.third_step1.gradle index 3a87cb298..a4857239b 100644 --- a/build.third_step1.gradle +++ b/build.third_step1.gradle @@ -32,6 +32,7 @@ sourceSets{ main{ java{ srcDirs=[ + "${srcDir}/fine-deprecated-utils/src", "${srcDir}/fine-asm/src", "${srcDir}/fine-antlr4/src", "${srcDir}/fine-aspectj/src", diff --git a/fine-deprecated-utils/src/edu/emory/mathcs/backport/java/util/Arrays.java b/fine-deprecated-utils/src/edu/emory/mathcs/backport/java/util/Arrays.java new file mode 100644 index 000000000..99ad131d2 --- /dev/null +++ b/fine-deprecated-utils/src/edu/emory/mathcs/backport/java/util/Arrays.java @@ -0,0 +1,798 @@ +package edu.emory.mathcs.backport.java.util; + +import java.lang.reflect.Array; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; + +/** + * 该类由前面版本third包反编译生成，用于兼容新引擎旧版本插件，7-8月份删除 + */ +@Deprecated +public class Arrays { + private Arrays() { + } + + public static void sort(long[] a) { + java.util.Arrays.sort(a); + } + + public static void sort(long[] a, int fromIndex, int toIndex) { + java.util.Arrays.sort(a, fromIndex, toIndex); + } + + public static void sort(int[] a) { + java.util.Arrays.sort(a); + } + + public static void sort(int[] a, int fromIndex, int toIndex) { + java.util.Arrays.sort(a, fromIndex, toIndex); + } + + public static void sort(short[] a) { + java.util.Arrays.sort(a); + } + + public static void sort(short[] a, int fromIndex, int toIndex) { + java.util.Arrays.sort(a, fromIndex, toIndex); + } + + public static void sort(char[] a) { + java.util.Arrays.sort(a); + } + + public static void sort(char[] a, int fromIndex, int toIndex) { + java.util.Arrays.sort(a, fromIndex, toIndex); + } + + public static void sort(byte[] a) { + java.util.Arrays.sort(a); + } + + public static void sort(byte[] a, int fromIndex, int toIndex) { + java.util.Arrays.sort(a, fromIndex, toIndex); + } + + public static void sort(double[] a) { + java.util.Arrays.sort(a); + } + + public static void sort(double[] a, int fromIndex, int toIndex) { + java.util.Arrays.sort(a, fromIndex, toIndex); + } + + public static void sort(float[] a) { + java.util.Arrays.sort(a); + } + + public static void sort(float[] a, int fromIndex, int toIndex) { + java.util.Arrays.sort(a, fromIndex, toIndex); + } + + public static void sort(Object[] a) { + java.util.Arrays.sort(a); + } + + public static void sort(Object[] a, int fromIndex, int toIndex) { + java.util.Arrays.sort(a, fromIndex, toIndex); + } + + public static void sort(Object[] a, Comparator c) { + java.util.Arrays.sort(a, c); + } + + public static void sort(Object[] a, int fromIndex, int toIndex, Comparator c) { + java.util.Arrays.sort(a, fromIndex, toIndex, c); + } + + public static int binarySearch(long[] a, long key) { + return java.util.Arrays.binarySearch(a, key); + } + + public static int binarySearch(int[] a, int key) { + return java.util.Arrays.binarySearch(a, key); + } + + public static int binarySearch(short[] a, short key) { + return java.util.Arrays.binarySearch(a, key); + } + + public static int binarySearch(char[] a, char key) { + return java.util.Arrays.binarySearch(a, key); + } + + public static int binarySearch(byte[] a, byte key) { + return java.util.Arrays.binarySearch(a, key); + } + + public static int binarySearch(double[] a, double key) { + return java.util.Arrays.binarySearch(a, key); + } + + public static int binarySearch(float[] a, float key) { + return java.util.Arrays.binarySearch(a, key); + } + + public static int binarySearch(Object[] a, Object key) { + return java.util.Arrays.binarySearch(a, key); + } + + public static int binarySearch(Object[] a, Object key, Comparator c) { + return java.util.Arrays.binarySearch(a, key, c); + } + + public static boolean equals(long[] a, long[] a2) { + return java.util.Arrays.equals(a, a2); + } + + public static boolean equals(int[] a, int[] a2) { + return java.util.Arrays.equals(a, a2); + } + + public static boolean equals(short[] a, short[] a2) { + return java.util.Arrays.equals(a, a2); + } + + public static boolean equals(char[] a, char[] a2) { + return java.util.Arrays.equals(a, a2); + } + + public static boolean equals(byte[] a, byte[] a2) { + return java.util.Arrays.equals(a, a2); + } + + public static boolean equals(boolean[] a, boolean[] a2) { + return java.util.Arrays.equals(a, a2); + } + + public static boolean equals(double[] a, double[] a2) { + return java.util.Arrays.equals(a, a2); + } + + public static boolean equals(float[] a, float[] a2) { + return java.util.Arrays.equals(a, a2); + } + + public static boolean equals(Object[] a, Object[] a2) { + return java.util.Arrays.equals(a, a2); + } + + public static void fill(long[] a, long val) { + java.util.Arrays.fill(a, val); + } + + public static void fill(long[] a, int fromIndex, int toIndex, long val) { + java.util.Arrays.fill(a, fromIndex, toIndex, val); + } + + public static void fill(int[] a, int val) { + java.util.Arrays.fill(a, val); + } + + public static void fill(int[] a, int fromIndex, int toIndex, int val) { + java.util.Arrays.fill(a, fromIndex, toIndex, val); + } + + public static void fill(short[] a, short val) { + java.util.Arrays.fill(a, val); + } + + public static void fill(short[] a, int fromIndex, int toIndex, short val) { + java.util.Arrays.fill(a, fromIndex, toIndex, val); + } + + public static void fill(char[] a, char val) { + java.util.Arrays.fill(a, val); + } + + public static void fill(char[] a, int fromIndex, int toIndex, char val) { + java.util.Arrays.fill(a, fromIndex, toIndex, val); + } + + public static void fill(byte[] a, byte val) { + java.util.Arrays.fill(a, val); + } + + public static void fill(byte[] a, int fromIndex, int toIndex, byte val) { + java.util.Arrays.fill(a, fromIndex, toIndex, val); + } + + public static void fill(boolean[] a, boolean val) { + java.util.Arrays.fill(a, val); + } + + public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val) { + java.util.Arrays.fill(a, fromIndex, toIndex, val); + } + + public static void fill(double[] a, double val) { + java.util.Arrays.fill(a, val); + } + + public static void fill(double[] a, int fromIndex, int toIndex, double val) { + java.util.Arrays.fill(a, fromIndex, toIndex, val); + } + + public static void fill(float[] a, float val) { + java.util.Arrays.fill(a, val); + } + + public static void fill(float[] a, int fromIndex, int toIndex, float val) { + java.util.Arrays.fill(a, fromIndex, toIndex, val); + } + + public static void fill(Object[] a, Object val) { + java.util.Arrays.fill(a, val); + } + + public static void fill(Object[] a, int fromIndex, int toIndex, Object val) { + java.util.Arrays.fill(a, fromIndex, toIndex, val); + } + + public static Object[] copyOf(Object[] original, int newLength) { + return copyOf(original, newLength, original.getClass()); + } + + public static Object[] copyOf(Object[] original, int newLength, Class newType) { + Object[] arr = newType == Object[].class ? new Object[newLength] : (Object[])Array.newInstance(newType.getComponentType(), newLength); + int len = original.length < newLength ? original.length : newLength; + System.arraycopy(original, 0, arr, 0, len); + return arr; + } + + public static byte[] copyOf(byte[] original, int newLength) { + byte[] arr = new byte[newLength]; + int len = original.length < newLength ? original.length : newLength; + System.arraycopy(original, 0, arr, 0, len); + return arr; + } + + public static short[] copyOf(short[] original, int newLength) { + short[] arr = new short[newLength]; + int len = original.length < newLength ? original.length : newLength; + System.arraycopy(original, 0, arr, 0, len); + return arr; + } + + public static int[] copyOf(int[] original, int newLength) { + int[] arr = new int[newLength]; + int len = original.length < newLength ? original.length : newLength; + System.arraycopy(original, 0, arr, 0, len); + return arr; + } + + public static long[] copyOf(long[] original, int newLength) { + long[] arr = new long[newLength]; + int len = original.length < newLength ? original.length : newLength; + System.arraycopy(original, 0, arr, 0, len); + return arr; + } + + public static char[] copyOf(char[] original, int newLength) { + char[] arr = new char[newLength]; + int len = original.length < newLength ? original.length : newLength; + System.arraycopy(original, 0, arr, 0, len); + return arr; + } + + public static float[] copyOf(float[] original, int newLength) { + float[] arr = new float[newLength]; + int len = original.length < newLength ? original.length : newLength; + System.arraycopy(original, 0, arr, 0, len); + return arr; + } + + public static double[] copyOf(double[] original, int newLength) { + double[] arr = new double[newLength]; + int len = original.length < newLength ? original.length : newLength; + System.arraycopy(original, 0, arr, 0, len); + return arr; + } + + public static boolean[] copyOf(boolean[] original, int newLength) { + boolean[] arr = new boolean[newLength]; + int len = original.length < newLength ? original.length : newLength; + System.arraycopy(original, 0, arr, 0, len); + return arr; + } + + public static Object[] copyOfRange(Object[] original, int from, int to) { + return copyOfRange(original, from, to, original.getClass()); + } + + public static Object[] copyOfRange(Object[] original, int from, int to, Class newType) { + int newLength = to - from; + if (newLength < 0) { + throw new IllegalArgumentException(from + " > " + to); + } else { + Object[] arr = newType == Object[].class ? new Object[newLength] : (Object[])Array.newInstance(newType.getComponentType(), newLength); + int ceil = original.length - from; + int len = ceil < newLength ? ceil : newLength; + System.arraycopy(original, from, arr, 0, len); + return arr; + } + } + + public static byte[] copyOfRange(byte[] original, int from, int to) { + int newLength = to - from; + if (newLength < 0) { + throw new IllegalArgumentException(from + " > " + to); + } else { + byte[] arr = new byte[newLength]; + int ceil = original.length - from; + int len = ceil < newLength ? ceil : newLength; + System.arraycopy(original, from, arr, 0, len); + return arr; + } + } + + public static short[] copyOfRange(short[] original, int from, int to) { + int newLength = to - from; + if (newLength < 0) { + throw new IllegalArgumentException(from + " > " + to); + } else { + short[] arr = new short[newLength]; + int ceil = original.length - from; + int len = ceil < newLength ? ceil : newLength; + System.arraycopy(original, from, arr, 0, len); + return arr; + } + } + + public static int[] copyOfRange(int[] original, int from, int to) { + int newLength = to - from; + if (newLength < 0) { + throw new IllegalArgumentException(from + " > " + to); + } else { + int[] arr = new int[newLength]; + int ceil = original.length - from; + int len = ceil < newLength ? ceil : newLength; + System.arraycopy(original, from, arr, 0, len); + return arr; + } + } + + public static long[] copyOfRange(long[] original, int from, int to) { + int newLength = to - from; + if (newLength < 0) { + throw new IllegalArgumentException(from + " > " + to); + } else { + long[] arr = new long[newLength]; + int ceil = original.length - from; + int len = ceil < newLength ? ceil : newLength; + System.arraycopy(original, from, arr, 0, len); + return arr; + } + } + + public static char[] copyOfRange(char[] original, int from, int to) { + int newLength = to - from; + if (newLength < 0) { + throw new IllegalArgumentException(from + " > " + to); + } else { + char[] arr = new char[newLength]; + int ceil = original.length - from; + int len = ceil < newLength ? ceil : newLength; + System.arraycopy(original, from, arr, 0, len); + return arr; + } + } + + public static float[] copyOfRange(float[] original, int from, int to) { + int newLength = to - from; + if (newLength < 0) { + throw new IllegalArgumentException(from + " > " + to); + } else { + float[] arr = new float[newLength]; + int ceil = original.length - from; + int len = ceil < newLength ? ceil : newLength; + System.arraycopy(original, from, arr, 0, len); + return arr; + } + } + + public static double[] copyOfRange(double[] original, int from, int to) { + int newLength = to - from; + if (newLength < 0) { + throw new IllegalArgumentException(from + " > " + to); + } else { + double[] arr = new double[newLength]; + int ceil = original.length - from; + int len = ceil < newLength ? ceil : newLength; + System.arraycopy(original, from, arr, 0, len); + return arr; + } + } + + public static boolean[] copyOfRange(boolean[] original, int from, int to) { + int newLength = to - from; + if (newLength < 0) { + throw new IllegalArgumentException(from + " > " + to); + } else { + boolean[] arr = new boolean[newLength]; + int ceil = original.length - from; + int len = ceil < newLength ? ceil : newLength; + System.arraycopy(original, from, arr, 0, len); + return arr; + } + } + + public static List asList(Object[] a) { + return java.util.Arrays.asList(a); + } + + public static int hashCode(long[] a) { + if (a == null) { + return 0; + } else { + int hash = 1; + + for(int i = 0; i < a.length; ++i) { + long e = a[i]; + hash = 31 * hash + (int)(e ^ e >>> 32); + } + + return hash; + } + } + + public static int hashCode(int[] a) { + if (a == null) { + return 0; + } else { + int hash = 1; + + for(int i = 0; i < a.length; ++i) { + hash = 31 * hash + a[i]; + } + + return hash; + } + } + + public static int hashCode(short[] a) { + if (a == null) { + return 0; + } else { + int hash = 1; + + for(int i = 0; i < a.length; ++i) { + hash = 31 * hash + a[i]; + } + + return hash; + } + } + + public static int hashCode(char[] a) { + if (a == null) { + return 0; + } else { + int hash = 1; + + for(int i = 0; i < a.length; ++i) { + hash = 31 * hash + a[i]; + } + + return hash; + } + } + + public static int hashCode(byte[] a) { + if (a == null) { + return 0; + } else { + int hash = 1; + + for(int i = 0; i < a.length; ++i) { + hash = 31 * hash + a[i]; + } + + return hash; + } + } + + public static int hashCode(boolean[] a) { + if (a == null) { + return 0; + } else { + int hash = 1; + + for(int i = 0; i < a.length; ++i) { + hash = 31 * hash + (a[i] ? 1231 : 1237); + } + + return hash; + } + } + + public static int hashCode(float[] a) { + if (a == null) { + return 0; + } else { + int hash = 1; + + for(int i = 0; i < a.length; ++i) { + hash = 31 * hash + Float.floatToIntBits(a[i]); + } + + return hash; + } + } + + public static int hashCode(double[] a) { + if (a == null) { + return 0; + } else { + int hash = 1; + + for(int i = 0; i < a.length; ++i) { + long e = Double.doubleToLongBits(a[i]); + hash = 31 * hash + (int)(e ^ e >>> 32); + } + + return hash; + } + } + + public static int hashCode(Object[] a) { + if (a == null) { + return 0; + } else { + int hash = 1; + + for(int i = 0; i < a.length; ++i) { + Object e = a[i]; + hash = 31 * hash + (e == null ? 0 : e.hashCode()); + } + + return hash; + } + } + + public static int deepHashCode(Object[] a) { + if (a == null) { + return 0; + } else { + int hash = 1; + + for(int i = 0; i < a.length; ++i) { + Object e = a[i]; + hash = 31 * hash + (e instanceof Object[] ? deepHashCode((Object[])e) : (e instanceof byte[] ? hashCode((byte[])e) : (e instanceof short[] ? hashCode((short[])e) : (e instanceof int[] ? hashCode((int[])e) : (e instanceof long[] ? hashCode((long[])e) : (e instanceof char[] ? hashCode((char[])e) : (e instanceof boolean[] ? hashCode((boolean[])e) : (e instanceof float[] ? hashCode((float[])e) : (e instanceof double[] ? hashCode((double[])e) : (e != null ? e.hashCode() : 0)))))))))); + } + + return hash; + } + } + + public static boolean deepEquals(Object[] a1, Object[] a2) { + if (a1 == a2) { + return true; + } else if (a1 != null && a2 != null) { + int len = a1.length; + if (len != a2.length) { + return false; + } else { + for(int i = 0; i < len; ++i) { + Object e1 = a1[i]; + Object e2 = a2[i]; + if (e1 != e2) { + if (e1 == null) { + return false; + } + + boolean eq = e1.getClass() == e2.getClass() && !e1.getClass().isArray() ? (e1 instanceof Object[] && e2 instanceof Object[] ? deepEquals((Object[])e1, (Object[])e2) : (e1 instanceof byte[] && e2 instanceof byte[] ? equals((byte[])e1, (byte[])e2) : (e1 instanceof short[] && e2 instanceof short[] ? equals((short[])e1, (short[])e2) : (e1 instanceof int[] && e2 instanceof int[] ? equals((int[])e1, (int[])e2) : (e1 instanceof long[] && e2 instanceof long[] ? equals((long[])e1, (long[])e2) : (e1 instanceof char[] && e2 instanceof char[] ? equals((char[])e1, (char[])e2) : (e1 instanceof boolean[] && e2 instanceof boolean[] ? equals((boolean[])e1, (boolean[])e2) : (e1 instanceof float[] && e2 instanceof float[] ? equals((float[])e1, (float[])e2) : (e1 instanceof double[] && e2 instanceof double[] ? equals((double[])e1, (double[])e2) : e1.equals(e2)))))))))) : e1.equals(e2); + if (!eq) { + return false; + } + } + } + + return true; + } + } else { + return false; + } + } + + public static String toString(long[] a) { + if (a == null) { + return "null"; + } else if (a.length == 0) { + return "[]"; + } else { + StringBuffer buf = new StringBuffer(); + buf.append('[').append(a[0]); + + for(int i = 1; i < a.length; ++i) { + buf.append(", ").append(a[i]); + } + + buf.append(']'); + return buf.toString(); + } + } + + public static String toString(int[] a) { + if (a == null) { + return "null"; + } else if (a.length == 0) { + return "[]"; + } else { + StringBuffer buf = new StringBuffer(); + buf.append('[').append(a[0]); + + for(int i = 1; i < a.length; ++i) { + buf.append(", ").append(a[i]); + } + + buf.append(']'); + return buf.toString(); + } + } + + public static String toString(short[] a) { + if (a == null) { + return "null"; + } else if (a.length == 0) { + return "[]"; + } else { + StringBuffer buf = new StringBuffer(); + buf.append('[').append(a[0]); + + for(int i = 1; i < a.length; ++i) { + buf.append(", ").append(a[i]); + } + + buf.append(']'); + return buf.toString(); + } + } + + public static String toString(char[] a) { + if (a == null) { + return "null"; + } else if (a.length == 0) { + return "[]"; + } else { + StringBuffer buf = new StringBuffer(); + buf.append('[').append(a[0]); + + for(int i = 1; i < a.length; ++i) { + buf.append(", ").append(a[i]); + } + + buf.append(']'); + return buf.toString(); + } + } + + public static String toString(byte[] a) { + if (a == null) { + return "null"; + } else if (a.length == 0) { + return "[]"; + } else { + StringBuffer buf = new StringBuffer(); + buf.append('[').append(a[0]); + + for(int i = 1; i < a.length; ++i) { + buf.append(", ").append(a[i]); + } + + buf.append(']'); + return buf.toString(); + } + } + + public static String toString(boolean[] a) { + if (a == null) { + return "null"; + } else if (a.length == 0) { + return "[]"; + } else { + StringBuffer buf = new StringBuffer(); + buf.append('[').append(a[0]); + + for(int i = 1; i < a.length; ++i) { + buf.append(", ").append(a[i]); + } + + buf.append(']'); + return buf.toString(); + } + } + + public static String toString(float[] a) { + if (a == null) { + return "null"; + } else if (a.length == 0) { + return "[]"; + } else { + StringBuffer buf = new StringBuffer(); + buf.append('[').append(a[0]); + + for(int i = 1; i < a.length; ++i) { + buf.append(", ").append(a[i]); + } + + buf.append(']'); + return buf.toString(); + } + } + + public static String toString(double[] a) { + if (a == null) { + return "null"; + } else if (a.length == 0) { + return "[]"; + } else { + StringBuffer buf = new StringBuffer(); + buf.append('[').append(a[0]); + + for(int i = 1; i < a.length; ++i) { + buf.append(", ").append(a[i]); + } + + buf.append(']'); + return buf.toString(); + } + } + + public static String toString(Object[] a) { + if (a == null) { + return "null"; + } else if (a.length == 0) { + return "[]"; + } else { + StringBuffer buf = new StringBuffer(); + buf.append('[').append(a[0]); + + for(int i = 1; i < a.length; ++i) { + buf.append(", ").append(a[i]); + } + + buf.append(']'); + return buf.toString(); + } + } + + public static String deepToString(Object[] a) { + if (a == null) { + return "null"; + } else { + StringBuffer buf = new StringBuffer(); + deepToString(a, buf, new ArrayList()); + return buf.toString(); + } + } + + private static void deepToString(Object[] a, StringBuffer buf, List seen) { + seen.add(a); + buf.append('['); + + for(int i = 0; i < a.length; ++i) { + if (i > 0) { + buf.append(", "); + } + + Object e = a[i]; + if (e == null) { + buf.append("null"); + } else if (!e.getClass().isArray()) { + buf.append(e.toString()); + } else if (e instanceof Object[]) { + if (seen.contains(e)) { + buf.append("[...]"); + } else { + deepToString((Object[])e, buf, seen); + } + } else { + buf.append(e instanceof byte[] ? toString((byte[])e) : (e instanceof short[] ? toString((short[])e) : (e instanceof int[] ? toString((int[])e) : (e instanceof long[] ? toString((long[])e) : (e instanceof char[] ? toString((char[])e) : (e instanceof boolean[] ? toString((boolean[])e) : (e instanceof float[] ? toString((float[])e) : (e instanceof double[] ? toString((double[])e) : "")))))))); + } + } + + buf.append(']'); + seen.remove(seen.size() - 1); + } +} \ No newline at end of file From dd4dfd1e158892fd00d2cbdee98ec91aeb2fe3e3 Mon Sep 17 00:00:00 2001 From: "Hugh.C" Date: Thu, 2 Apr 2020 11:50:19 +0800 Subject: [PATCH 3/4] =?UTF-8?q?REPORT-29126=20=E5=AF=BC=E5=87=BApdf?= =?UTF-8?q?=EF=BC=8C=E5=AD=97=E4=BD=93=E5=8A=A0=E7=B2=97=E6=95=88=E6=9E=9C?= =?UTF-8?q?=E6=B2=A1=E6=9C=89=E4=BA=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/com/fr/third/com/lowagie/text/pdf/PdfGraphics2D.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/fine-itext-old/src/com/fr/third/com/lowagie/text/pdf/PdfGraphics2D.java b/fine-itext-old/src/com/fr/third/com/lowagie/text/pdf/PdfGraphics2D.java index ee5a7cfcf..9f4db7192 100755 --- a/fine-itext-old/src/com/fr/third/com/lowagie/text/pdf/PdfGraphics2D.java +++ b/fine-itext-old/src/com/fr/third/com/lowagie/text/pdf/PdfGraphics2D.java @@ -429,10 +429,11 @@ public class PdfGraphics2D extends Graphics2D { // Simulate a bold font. // 30有点粗 ，换成40 float strokeWidth = font.getSize2D() * (weight.floatValue() - TextAttribute.WEIGHT_REGULAR.floatValue()) / 40f; + //重点是这个渲染模式的设置，其他无所谓 + cb.setTextRenderingMode(PdfContentByte.TEXT_RENDER_MODE_FILL_STROKE); if (strokeWidth != 1) { + cb.setLineWidth(strokeWidth); if(realPaint instanceof Color){ - cb.setTextRenderingMode(PdfContentByte.TEXT_RENDER_MODE_FILL_STROKE); - cb.setLineWidth(strokeWidth); Color color = (Color)realPaint; int alpha = color.getAlpha(); if (alpha != currentStrokeGState) { From f08da31e9c28fe8f92aa9a2bc146719153aa2299 Mon Sep 17 00:00:00 2001 From: "Hugh.C" Date: Thu, 2 Apr 2020 12:19:14 +0800 Subject: [PATCH 4/4] =?UTF-8?q?REPORT-29126=20=E5=AF=BC=E5=87=BApdf?= =?UTF-8?q?=EF=BC=8C=E5=AD=97=E4=BD=93=E5=8A=A0=E7=B2=97=E6=95=88=E6=9E=9C?= =?UTF-8?q?=E6=B2=A1=E6=9C=89=E4=BA=86=EF=BC=88=E6=BC=8F=E6=8F=90=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/com/fr/third/com/lowagie/text/pdf/PdfGraphics2D.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fine-itext-old/src/com/fr/third/com/lowagie/text/pdf/PdfGraphics2D.java b/fine-itext-old/src/com/fr/third/com/lowagie/text/pdf/PdfGraphics2D.java index 9f4db7192..f184556e6 100755 --- a/fine-itext-old/src/com/fr/third/com/lowagie/text/pdf/PdfGraphics2D.java +++ b/fine-itext-old/src/com/fr/third/com/lowagie/text/pdf/PdfGraphics2D.java @@ -447,9 +447,9 @@ public class PdfGraphics2D extends Graphics2D { cb.setGState(gs); } cb.setColorStroke(color); - restoreTextRenderingMode = true; } } + restoreTextRenderingMode = true; } }