fastjson 定义JSON 工具类

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.32</version>
</dependency>

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;
import java.util.List;

public final class JsonUtil {
  /**
   * 隐藏构造器
   */
  private JsonUtil() {
  }

  public static boolean isEmpty(final CharSequence cs) {
    return cs == null || cs.length() == 0;
  }

  /**
   * 将JSON字符串反序列化为Java对象。
   * @param <T> 泛型
   * @param json com.alibaba.fastjson.JSON对象
   * @param classOfT 类的泛型，用于简单类型的反序列化。
   * <p><strong>参数类型：</strong>xxx.class</p>
   * @return Java对象
   */
  public static <T> T fromJson(final JSON json, final Class<T> classOfT) {
    return JSON.toJavaObject(json, classOfT);
  }

  /**
   * 将JSON字符串反序列化为Java对象。
   * @param <T> 泛型
   * @param json JSON字符串
   * @param classOfT 类的泛型，用于简单类型的反序列化。
   * <p><strong>参数类型：</strong>xxx.class</p>
   * @return Java对象 <ol><li>json字符串为空时返回null；<li>json字符串为无效JSON格式时，会输出log日志，返回null；</li></ol>
   */
  public static <T> T fromJson(final String json, final Class<T> classOfT) {
    return fromJson(json, (Type) classOfT);
  }

  /**
   * 将JSON字符串反序列化为Java对象。
   * @param <T> 泛型
   * @param json JSON字符串
   * @param typeOfT 包含泛型类型。 com.alibaba.fastjson.TypeReference；
   * <p><strong>参数类型：</strong>java.lang.reflect.Type typeOfT = new TypeReference&lt;T&gt;(){}.getType();</p>
   * @return Java对象 <ol><li>json字符串为空时返回null；<li>json字符串为无效JSON格式时，会输出log日志，返回null；</li></ol>
   */
  public static <T> T fromJson(final String json, final Type typeOfT) {
    if (isEmpty(json)) {
      return null;
    }
    return JSON.parseObject(json, typeOfT);

  }

  /**
   * 将JSON字符串反序列化为Java对象。
   * @param <T> 泛型
   * @param is JSON输入流
   * @param classOfT 类的泛型，用于简单类型的反序列化。
   * <p><strong>参数类型：</strong>xxx.class</p>
   * @return Java对象 <ol><li>json字符串为空时返回null；<li>json字符串为无效JSON格式时，会输出log日志，返回null；</li></ol>
   * @throws IOException 读取数据流异常
   */
  public static final <T> T fromJson(final InputStream is, final Class<T> classOfT) throws IOException {
    return fromJson(is, (Type) classOfT);
  }

  /**
   * 将JSON字符串反序列化为Java对象。
   * @param <T> 泛型
   * @param is JSON输入流
   * @param typeOfT 包含泛型类型。 com.alibaba.fastjson.TypeReference；
   * <p><strong>参数类型：</strong>java.lang.reflect.Type typeOfT = new TypeReference&lt;T&gt;(){}.getType();</p>
   * @return Java对象 <ol><li>json字符串为空时返回null；<li>json字符串为无效JSON格式时，会输出log日志，返回null；</li></ol>
   * @throws IOException 读取数据流异常
   */
  public static <T> T fromJson(final InputStream is, final Type typeOfT) throws IOException {
    return JSON.parseObject(is, typeOfT);
  }

  /**
   * 将JSON字符串反序列化为List对象。
   * @param <T> 泛型
   * @param json JSON字符串
   * @param classOfT List包裹的对象的泛型。 用于简单类型的反序列化。
   * @return Java对象 <ol><li>json字符串为空时返回null；<li>json字符串为无效JSON格式时，会输出log日志，返回null；</li></ol>
   */
  public static <T> List<T> fromJsonList(final String json, final Class<T> classOfT) {
    if (isEmpty(json)) {
      return null;
    }
    return JSON.parseArray(json, classOfT);
  }

  /**
   * 将Java对象序列化成JSON字符串。
   * @param obj Java对象
   * @return JSON字符串
   */
  public static String toJson(final Object obj) {
    if (null == obj) {
      return null;
    }
    return JSON.toJSONString(obj);
  }

  /**
   * 将Java对象序列化成JSON字符串。
   * @param obj Java对象
   * @param features 序列化选项
   * @return JSON字符串
   */
  public static String toJson(final Object obj, final SerializerFeature... features) {
    if (null == obj) {
      return null;
    }
    return JSON.toJSONString(obj, features);
  }

  /**
   * 将Java对象序列化成JSON字符串。关闭引用检测
   * <p style="color:red">关闭引用检测后，重复引用对象时就不会被$ref代替，但是在循环引用时也会导致StackOverflowError异常。</p>
   * @param obj Java对象
   * @return JSON字符串
   */
  public static String toJsonNoRef(final Object obj) {
    return toJson(obj, SerializerFeature.DisableCircularReferenceDetect);
  }

  /**
   * 将Java对象序列化成JSON字符串。
   * <p>输出null值。</p>
   * <ul><li>数值字段如果为null,输出为0,而非null</li>
   * <li>List字段如果为null,输出为[],而非null</li>
   * <li>字符类型字段如果为null,输出为"",而非null</li>
   * <li>Boolean字段如果为null,输出为false,而非null</li></ul>
   * @param obj Java对象
   * @return JSON字符串
   */
  public static String toJsonWriteNull(final Object obj) {
    return toJson(obj, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullNumberAsZero,
        SerializerFeature.WriteNullListAsEmpty, SerializerFeature.WriteNullStringAsEmpty,
        SerializerFeature.WriteNullBooleanAsFalse);
  }

  /**
   * JSON字符串转换为JSONObject对象
   * @param json JSON字符串
   * @return JSONObject对象
   */
  public static JSONObject toJsonObj(final String json) {
    return JSON.parseObject(json);
  }
}

基础base类

import java.io.Serializable;


/**
 * @ClassName: BaseBean
 * @Description:curd父类bean
 * @author  df.l
 * @date 2021年11月04日
 * @Copyright boulderai8tech.com
 */
public abstract class BaseBean implements Serializable {
  private static final long serialVersionUID = -1805283690606975260L;

  /**
   * 转换成JSON字符串
   * @return JSON字符串
   */
  public String toJson() {
    return JsonUtil.toJson(this);
  }

  /**
   * 重写toString方法
   * @return JSON字符串
   * @see Object#toString()
   */
  @Override
  public String toString() {
    return this.toJson();
  }
}

c3p0配置

import java.util.Date;
import java.util.Objects;


/**
 * @ClassName: C3p0ConfigEntity
 * @Description:数据库连接池配置
 * @author 
 * @date
 * @Copyright
 */
public class C3p0ConfigEntity extends BaseBean {
    private static final long serialVersionUID = -2007678110412798920L;

    /**
     *     c3p0配置相关参数，不注释，自己区看c3p0东西
     */
    private String dbName;
    private String  driverClass;
    private String jdbcUrl;
    private String userName;
    private String password;
    private int initialPoolSize;
    private int maxIdleTime;
    private int maxPoolSize;
    private int minPoolSize;
    private int maxStatements;
    private Boolean testConnectionOnCheckout=false;
    private Boolean testConnectionOnCheckin=false;
    private int acquireIncrement=3;
    private Boolean autoCommitOnClose=false;
    private int priority;
    private int status;
    private Date modifyTime;
    private Boolean canDropOdpsTable=false;

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        C3p0ConfigEntity that = (C3p0ConfigEntity) o;
        return Objects.equals(dbName, that.dbName);
    }

    public Boolean getCanDropOdpsTable() {
        return canDropOdpsTable;
    }

    public void setCanDropOdpsTable(Boolean canDropOdpsTable) {
        this.canDropOdpsTable = canDropOdpsTable;
    }

    @Override
    public int hashCode() {
        return Objects.hash(dbName);
    }

    public String getDbName() {
        return dbName;
    }

    public void setDbName(String dbName) {
        this.dbName = dbName;
    }

    public String getDriverClass() {
        return driverClass;
    }

    public void setDriverClass(String driverClass) {
        this.driverClass = driverClass;
    }


    public String getJdbcUrl() {
        return jdbcUrl;
    }

    public void setJdbcUrl(String jdbcUrl) {
        this.jdbcUrl = jdbcUrl;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getInitialPoolSize() {
        return initialPoolSize;
    }

    public void setInitialPoolSize(int initialPoolSize) {
        this.initialPoolSize = initialPoolSize;
    }

    public int getMaxIdleTime() {
        return maxIdleTime;
    }

    public void setMaxIdleTime(int maxIdleTime) {
        this.maxIdleTime = maxIdleTime;
    }

    public int getMaxPoolSize() {
        return maxPoolSize;
    }

    public void setMaxPoolSize(int maxPoolSize) {
        this.maxPoolSize = maxPoolSize;
    }

    public int getMinPoolSize() {
        return minPoolSize;
    }

    public void setMinPoolSize(int minPoolSize) {
        this.minPoolSize = minPoolSize;
    }

    public int getMaxStatements() {
        return maxStatements;
    }

    public void setMaxStatements(int maxStatements) {
        this.maxStatements = maxStatements;
    }

    public Boolean getTestConnectionOnCheckout() {
        return testConnectionOnCheckout;
    }

    public void setTestConnectionOnCheckout(Boolean testConnectionOnCheckout) {
        this.testConnectionOnCheckout = testConnectionOnCheckout;
    }

    public Boolean getTestConnectionOnCheckin() {
        return testConnectionOnCheckin;
    }

    public void setTestConnectionOnCheckin(Boolean testConnectionOnCheckin) {
        this.testConnectionOnCheckin = testConnectionOnCheckin;
    }

    public int getAcquireIncrement() {
        return acquireIncrement;
    }

    public void setAcquireIncrement(int acquireIncrement) {
        this.acquireIncrement = acquireIncrement;
    }

    public Boolean getAutoCommitOnClose() {
        return autoCommitOnClose;
    }

    public void setAutoCommitOnClose(Boolean autoCommitOnClose) {
        this.autoCommitOnClose = autoCommitOnClose;
    }

    public int getPriority() {
        return priority;
    }

    public void setPriority(int priority) {
        this.priority = priority;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public Date getModifyTime() {
        return modifyTime;
    }

    public void setModifyTime(Date modifyTime) {
        this.modifyTime = modifyTime;
    }

    @Override
    public String toString() {
        return "C3p0ConfigEntity{" +
                "dbName='" + dbName + '\'' +
                ", driverClass='" + driverClass + '\'' +
                ", jdbcUrl='" + jdbcUrl + '\'' +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", initialPoolSize=" + initialPoolSize +
                ", maxIdleTime=" + maxIdleTime +
                ", maxPoolSize=" + maxPoolSize +
                ", minPoolSize=" + minPoolSize +
                ", maxStatements=" + maxStatements +
                ", testConnectionOnCheckout=" + testConnectionOnCheckout +
                ", testConnectionOnCheckin=" + testConnectionOnCheckin +
                ", acquireIncrement=" + acquireIncrement +
                ", autoCommitOnClose=" + autoCommitOnClose +
                ", priority=" + priority +
                ", status=" + status +
                ", modifyTime=" + modifyTime +
                '}';
    }
}