java項目依賴包選擇具體實現(xiàn)類示例介紹
正文
最近遇到一個需求場景，開源的工具包，新增了一個高級特性，會依賴json序列化工具，來做一些特殊操作；但是，這個輔助功能并不是必須的，也就是說對于使用這個工具包的業(yè)務(wù)方而言，正常使用完全不需要json相關(guān)的功能；如果我強引用某個json工具，一是對于不適用高級特性的用戶而言沒有必要；二則是我引入的json工具極有可能與使用者的不一致，會增加使用者的成本
因此我希望這個工具包對外提供時，并不會引入具體的json工具依賴；也就是說maven依賴中的<scope>設(shè)置為provided；具體的json序列化的實現(xiàn)，則取決于調(diào)用方自身引入了什么json工具
那么可以怎么實現(xiàn)上面這個方式呢？
1. 任務(wù)說明
上面的簡單的說了一下我們需要做的事情，接下來我們重點盤一下，我們到底是要干什么
核心訴求相對清晰
- 不強引入某個json工具
- 若需要使用高級特性，則直接使用當(dāng)前環(huán)境中已集成的json序列化工具；若沒有提供，則拋異常，不支持
對于上面這個場景，常年使用Spring的我們估計不會陌生，Spring集成了很多的第三方開源組件，根據(jù)具體的依賴來選擇最終的實現(xiàn)，比如日志，可以是logback，也可以是log4j；比如redis操作，可以是jedis，也可以是lettuce
那么Spring是怎么實現(xiàn)的呢？
2.具體實現(xiàn)
在Spring中有個注解名為ConditionalOnClass，表示當(dāng)某個類存在時，才會干某些事情（如初始化bean對象）
它是怎么是實現(xiàn)的呢？（感興趣的小伙伴可以搜索一下，或者重點關(guān)注下 SpringBootCondition 的實現(xiàn)）
這里且拋開Spring的實現(xiàn)姿勢，我們采用傳統(tǒng)的實現(xiàn)方式，直接判斷是否有加載對應(yīng)的類，來判斷有沒有引入相應(yīng)的工具包
如需要判斷是否引入了gson包，則判斷ClassLoader是否有加載com.google.gson.Gson類
public static boolean exist(String name) {
try {
return JsonUtil.class.getClassLoader().loadClass(name) != null;
} catch (Exception e) {
return false;
}
}
上面這種實現(xiàn)方式就可以達到我們的效果了；接下來我們參考下Spring的ClassUtils實現(xiàn)，做一個簡單的封裝，以判斷是否存在某個類
// 這段代碼來自Spring
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
import java.lang.reflect.Array;
import java.util.HashMap;
import java.util.Map;
/**
* @author Spring
*/
public abstract class ClassUtils {
private static final Map<String, Class<?>> primitiveTypeNameMap = new HashMap(32);
private static final Map<String, Class<?>> commonClassCache = new HashMap(64);
private ClassUtils() {
}
public static boolean isPresent(String className) {
try {
forName(className, getDefaultClassLoader());
return true;
} catch (IllegalAccessError var3) {
throw new IllegalStateException("Readability mismatch in inheritance hierarchy of class [" + className + "]: " + var3.getMessage(), var3);
} catch (Throwable var4) {
return false;
}
}
public static boolean isPresent(String className, ClassLoader classLoader) {
try {
forName(className, classLoader);
return true;
} catch (IllegalAccessError var3) {
throw new IllegalStateException("Readability mismatch in inheritance hierarchy of class [" + className + "]: " + var3.getMessage(), var3);
} catch (Throwable var4) {
return false;
}
}
public static Class<?> forName(String name, ClassLoader classLoader) throws ClassNotFoundException, LinkageError {
Class<?> clazz = resolvePrimitiveClassName(name);
if (clazz == null) {
clazz = (Class) commonClassCache.get(name);
}
if (clazz != null) {
return clazz;
} else {
Class elementClass;
String elementName;
if (name.endsWith("[]")) {
elementName = name.substring(0, name.length() - "[]".length());
elementClass = forName(elementName, classLoader);
return Array.newInstance(elementClass, 0).getClass();
} else if (name.startsWith("[L") && name.endsWith(";")) {
elementName = name.substring("[L".length(), name.length() - 1);
elementClass = forName(elementName, classLoader);
return Array.newInstance(elementClass, 0).getClass();
} else if (name.startsWith("[")) {
elementName = name.substring("[".length());
elementClass = forName(elementName, classLoader);
return Array.newInstance(elementClass, 0).getClass();
} else {
ClassLoader clToUse = classLoader;
if (classLoader == null) {
clToUse = getDefaultClassLoader();
}
try {
return Class.forName(name, false, clToUse);
} catch (ClassNotFoundException var9) {
int lastDotIndex = name.lastIndexOf(46);
if (lastDotIndex != -1) {
String innerClassName = name.substring(0, lastDotIndex) + '$' + name.substring(lastDotIndex + 1);
try {
return Class.forName(innerClassName, false, clToUse);
} catch (ClassNotFoundException var8) {
}
}
throw var9;
}
}
}
}
public static Class<?> resolvePrimitiveClassName(String name) {
Class<?> result = null;
if (name != null && name.length() <= 8) {
result = (Class) primitiveTypeNameMap.get(name);
}
return result;
}
public static ClassLoader getDefaultClassLoader() {
ClassLoader cl = null;
try {
cl = Thread.currentThread().getContextClassLoader();
} catch (Throwable var3) {
}
if (cl == null) {
cl = ClassUtils.class.getClassLoader();
if (cl == null) {
try {
cl = ClassLoader.getSystemClassLoader();
} catch (Throwable var2) {
}
}
}
return cl;
}
}
工具類存在之后，我們實現(xiàn)一個簡單的json工具類，根據(jù)已有的json包來選擇具體的實現(xiàn)
public class JsonUtil {
private static JsonApi jsonApi;
private static void initJsonApi() {
if (jsonApi == null) {
synchronized (JsonUtil.class) {
if (jsonApi == null) {
if (ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", JsonUtil.class.getClassLoader())) {
jsonApi = new JacksonImpl();
} else if (ClassUtils.isPresent("com.google.gson.Gson", JsonUtil.class.getClassLoader())) {
jsonApi = new GsonImpl();
} else if (ClassUtils.isPresent("com.alibaba.fastjson.JSONObject", JsonUtil.class.getClassLoader())) {
jsonApi = new JacksonImpl();
} else {
throw new UnsupportedOperationException("no json framework to deserialize string! please import jackson|gson|fastjson");
}
}
}
}
}
/**
* json轉(zhuǎn)實體類，會根據(jù)當(dāng)前已有的json框架來執(zhí)行反序列化
*
* @param str
* @param t
* @param <T>
* @return
*/
public static <T> T toObj(String str, Class<T> t) {
initJsonApi();
return jsonApi.toObj(str, t);
}
public static <T> String toStr(T t) {
initJsonApi();
return jsonApi.toStr(t);
}
}
上面的實現(xiàn)中，根據(jù)已有的json序列化工具，選擇具體的實現(xiàn)類，我們定義了一個JsonApi接口，然后分別gson,jackson,fastjson給出默認的實現(xiàn)類
public interface JsonApi {
<T> T toObj(String str, Class<T> clz);
<T> String toStr(T t);
}
public class FastjsonImpl implements JsonApi {
public <T> T toObj(String str, Class<T> clz) {
return JSONObject.parseObject(str, clz);
}
public <T> String toStr(T t) {
return JSONObject.toJSONString(t);
}
}
public class GsonImpl implements JsonApi {
private static final Gson gson = new Gson();
public <T> T toObj(String str, Class<T> t) {
return gson.fromJson(str, t);
}
public <T> String toStr(T t) {
return gson.toJson(t);
}
}
public class JacksonImpl implements JsonApi{
private static final ObjectMapper jsonMapper = new ObjectMapper();
public <T> T toObj(String str, Class<T> clz) {
try {
return jsonMapper.readValue(str, clz);
} catch (Exception e) {
throw new UnsupportedOperationException(e);
}
}
public <T> String toStr(T t) {
try {
return jsonMapper.writeValueAsString(t);
} catch (Exception e) {
throw new UnsupportedOperationException(e);
}
}
}
最后的問題來了，如果調(diào)用方并沒有使用上面三個序列化工具，而是使用其他的呢，可以支持么？
既然我們定義了一個JsonApi，那么是不是可以由用戶自己來實現(xiàn)接口，然后自動選擇它呢？
現(xiàn)在的問題就是如何找到用戶自定義的接口實現(xiàn)了
3. 擴展機制
對于SPI機制比較熟悉的小伙伴可能非常清楚，可以通過在配置目錄META-INF/services/下新增接口文件，內(nèi)容為實現(xiàn)類的全路徑名稱，然后通過 ServiceLoader.load(JsonApi.class) 的方式來獲取所有實現(xiàn)類
除了SPI的實現(xiàn)方式之外，另外一個策略則是上面提到的Spring的實現(xiàn)原理，借助字節(jié)碼來處理（詳情原理后面專文說明）
當(dāng)然也有更容易想到的策略，掃描包路徑下的class文件，遍歷判斷是否為實現(xiàn)類(額外注意jar包內(nèi)的實現(xiàn)類場景)
接下來以SPI的方式來介紹下擴展實現(xiàn)方式，首先初始化JsonApi的方式改一下，優(yōu)先使用用戶自定義實現(xiàn)
private static void initJsonApi() {
if (jsonApi == null) {
synchronized (JsonUtil.class) {
if (jsonApi == null) {
ServiceLoader<JsonApi> loader = ServiceLoader.load(JsonApi.class);
for (JsonApi value : loader) {
jsonApi = value;
return;
}
if (ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", JsonUtil.class.getClassLoader())) {
jsonApi = new JacksonImpl();
} else if (ClassUtils.isPresent("com.google.gson.Gson", JsonUtil.class.getClassLoader())) {
jsonApi = new GsonImpl();
} else if (ClassUtils.isPresent("com.alibaba.fastjson.JSONObject", JsonUtil.class.getClassLoader())) {
jsonApi = new JacksonImpl();
} else{
throw new UnsupportedOperationException("no json framework to deserialize string! please import jackson|gson|fastjson");
}
}
}
}
}
對于使用者而言，首先是實現(xiàn)接口
package com.github.hui.quick.plugin.test;
import com.github.hui.quick.plugin.qrcode.util.json.JsonApi;
public class DemoJsonImpl implements JsonApi {
@Override
public <T> T toObj(String str, Class<T> clz) {
// ...
}
@Override
public <T> String toStr(T t) {
// ...
}
}
接著就是實現(xiàn)定義, resources/META-INF/services/ 目錄下，新建文件名為 com.github.hui.quick.plugin.qrcode.util.json.JsonApi
內(nèi)容如下
com.github.hui.quick.plugin.test.DemoJsonImpl
然后完工~
小結(jié)
主要介紹一個小的知識點，如何根據(jù)應(yīng)用已有的jar包來選擇具體的實現(xiàn)類的方式；本文介紹的方案是通過ClassLoader來嘗試加載對應(yīng)的類，若能正常加載，則認為有；否則認為沒有；這種實現(xiàn)方式雖然非常簡單，但是請注意，它是有缺陷的，至于缺陷是啥...
除此之外，也可以考慮通過字節(jié)碼的方式來判斷是否有某個類，或者獲取某個接口的實現(xiàn)；文中最后拋出了一個問題，如何獲取接口的所有實現(xiàn)類
常見的方式有下面三類（具體介紹了SPI的實現(xiàn)姿勢，其他的兩種感興趣的可以搜索一下）
- SPI定義方式
- 掃描包路徑
- 字節(jié)碼方式(如Spring，如Tomcat的
@HandlesTypes)
以上就是java項目依賴包選擇具體實現(xiàn)類示例介紹的詳細內(nèi)容，更多關(guān)于java項目依賴包實現(xiàn)類的資料請關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
導(dǎo)入項目出現(xiàn)Java多個工程相互引用異常A cycle was detected in the build path o
今天小編就為大家分享一篇關(guān)于導(dǎo)入項目出現(xiàn)Java多個工程相互引用異常A cycle was detected in the build path of project的解決辦法，小編覺得內(nèi)容挺不錯的，現(xiàn)在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧2018-12-12
java之lombok的構(gòu)建者模式Builder中的泛型寫法說明
這篇文章主要介紹了java之lombok的構(gòu)建者模式Builder中的泛型寫法說明，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-01-01
這篇文章主要介紹了分布式Netty源碼分析EventLoopGroup及介紹，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-03-03
Java實現(xiàn)讀取163郵箱,qq郵箱的郵件內(nèi)容
這篇文章主要利用Java語言實現(xiàn)讀取163郵箱和qq郵箱的郵件內(nèi)容，文中的示例代碼講解詳細，感興趣的小伙伴可以跟隨小編一起動手試一試2022-02-02
這篇文章主要為大家詳細介紹了java圖片添加水印實例代碼，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2015-12-12
Spring Boot的應(yīng)用啟動與關(guān)閉的方法
本篇文章主要介紹了Spring Boot的應(yīng)用啟動與關(guān)閉的方法，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-12-12
nacos中的配置使用@Value注解獲取不到值的原因及解決方案
這篇文章主要介紹了nacos中的配置使用@Value注解獲取不到值的原因分析，本文給大家介紹的非常詳細，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值,需要的朋友可以參考下2023-03-03
Java?中?Class?Path?和?Package的使用詳解
這篇文章主要介紹了Java?中?Class?Path和Package的使用詳解，文章圍繞主題展開詳細的內(nèi)容介紹，具有一定的參考價值，需要的朋友可以參考一下2022-08-08
idea中javaweb的jsp頁面圖片加載不出來問題及解決
這篇文章主要介紹了idea中javaweb的jsp頁面圖片加載不出來問題及解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-07-07
Java中forward轉(zhuǎn)發(fā)與redirect重定向的區(qū)別
轉(zhuǎn)發(fā)和重定向都是常用的頁面跳轉(zhuǎn)方式,但在實現(xiàn)上有一些區(qū)別,本文主要介紹了Java中forward轉(zhuǎn)發(fā)與redirect重定向的區(qū)別,具有一定的參考價值,感興趣的可以了解一下2023-11-11