Dubbo Consumer引用服務示例代碼詳解
更新時間：2023年03月02日 10:48:52 作者：Redick01
dubbo中引用遠程服務有兩種方式：服務直連（不經過注冊中心）、基于注冊中心引用服務，在實際線上環(huán)境中我們基本上使用的都是基于注冊中心引用服務的方式，下面我們就圍繞該方式講解分析
Consumer消費者Demo示例
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:property-placeholder/>
<dubbo:application name="serialization-java-consumer">
<dubbo:parameter key="qos.enable" value="true" />
<dubbo:parameter key="qos.accept.foreign.ip" value="false" />
<dubbo:parameter key="qos.port" value="33333" />
</dubbo:application>
<dubbo:registry address="zookeeper://${zookeeper.address:127.0.0.1}:2181"/>
<dubbo:reference id="demoService" check="true" interface="org.apache.dubbo.samples.serialization.api.DemoService"/>
</beans>在之前的章節(jié)中已經知道，Dubbo基于Spring自定義標簽規(guī)范實現(xiàn)了自定義標簽，通過自定義標簽完成了bean的加載，并且通過實現(xiàn)監(jiān)聽Spring容器刷新完畢事件啟動dubbo客戶端。啟動客戶端伴隨著服務發(fā)布和服務的訂閱。
public class DubboConsumer {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/dubbo-demo-consumer.xml");
context.start();
DemoService demoService = context.getBean("demoService", DemoService.class);
String hello = demoService.sayHello("world");
System.out.println(hello);
}
}
dubbo通過<dubbo:reference標簽引用服務，之后在程序中通過Spring的Context依賴查找(getBean)的方式獲取引用的服務的代理實例。<dubbo:reference加載的Bean是ReferenceBean，它實現(xiàn)了FactoryBean接口，getBean時會調用ReferenceBean的getObject()方法，這是獲取引用的入口。getBean方法會判斷Reference對象是否是空的，如果是空的，調用init方法。代碼如下：
@Override
public Object getObject() {
return get();
}
ReferenceConfig#getObject()獲取應用Bean
ReferenceBean繼承了ReferenceConfig，當調用ReferenceBean的getObject()方法會調用ReferenceBean的get()方法。
public synchronized T get() {
if (destroyed) {
throw new IllegalStateException("The invoker of ReferenceConfig(" + url + ") has already destroyed!");
}
// 代理引用如果是空的，調用init
if (ref == null) {
init();
}
return ref;
}
public synchronized void init() {
if (initialized) {
return;
}
if (bootstrap == null) {
bootstrap = DubboBootstrap.getInstance();
bootstrap.init();
}
// 1. 檢查配置ConsumerConfig，有的話檢查配置，沒有就新建一個ConsumerConfig
// 2. 反射創(chuàng)建調用的API
// 3. 初始化ServiceMetadata
// 4. 注冊Consumer
// 5. 檢查ReferenceConfig，RegistryConfig，ConsumerConfig
checkAndUpdateSubConfigs();
checkStubAndLocal(interfaceClass);
// 檢查引用的接口是否mock
ConfigValidationUtils.checkMock(interfaceClass, this);
// consumer的信息
Map<String, String> map = new HashMap<String, String>();
map.put(SIDE_KEY, CONSUMER_SIDE);
// 添加運行時參數(shù)到map，包括：dubbo，release，timestamp，pid
ReferenceConfigBase.appendRuntimeParameters(map);
// 是不是泛化，不是的話進入條件
if (!ProtocolUtils.isGeneric(generic)) {
String revision = Version.getVersion(interfaceClass, version);
if (revision != null && revision.length() > 0) {
map.put(REVISION_KEY, revision);
}
// 獲取方法，生成包裝類，使用javassist，將生成的類放到WRAPPER_MAP中，key是org.apache.dubbo.samples.serialization.api.DemoService類對象，value是包裝類的實例
String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
if (methods.length == 0) {
logger.warn("No method found in service interface " + interfaceClass.getName());
map.put(METHODS_KEY, ANY_VALUE);
} else {
// method放到map，這里method是sayHello
map.put(METHODS_KEY, StringUtils.join(new HashSet<String>(Arrays.asList(methods)), COMMA_SEPARATOR));
}
}
// interface org.apache.dubbo.samples.serialization.api.DemoService
map.put(INTERFACE_KEY, interfaceName);
// 追加其他參數(shù)到map中
AbstractConfig.appendParameters(map, getMetrics());
AbstractConfig.appendParameters(map, getApplication());
AbstractConfig.appendParameters(map, getModule());
// remove 'default.' prefix for configs from ConsumerConfig
// appendParameters(map, consumer, Constants.DEFAULT_KEY);
AbstractConfig.appendParameters(map, consumer);
AbstractConfig.appendParameters(map, this);
MetadataReportConfig metadataReportConfig = getMetadataReportConfig();
if (metadataReportConfig != null && metadataReportConfig.isValid()) {
map.putIfAbsent(METADATA_KEY, REMOTE_METADATA_STORAGE_TYPE);
}
Map<String, AsyncMethodInfo> attributes = null;
if (CollectionUtils.isNotEmpty(getMethods())) {
attributes = new HashMap<>();
for (MethodConfig methodConfig : getMethods()) {
AbstractConfig.appendParameters(map, methodConfig, methodConfig.getName());
String retryKey = methodConfig.getName() + ".retry";
if (map.containsKey(retryKey)) {
String retryValue = map.remove(retryKey);
if ("false".equals(retryValue)) {
map.put(methodConfig.getName() + ".retries", "0");
}
}
AsyncMethodInfo asyncMethodInfo = AbstractConfig.convertMethodConfig2AsyncInfo(methodConfig);
if (asyncMethodInfo != null) {
// consumerModel.getMethodModel(methodConfig.getName()).addAttribute(ASYNC_KEY, asyncMethodInfo);
attributes.put(methodConfig.getName(), asyncMethodInfo);
}
}
}
String hostToRegistry = ConfigUtils.getSystemProperty(DUBBO_IP_TO_REGISTRY);
if (StringUtils.isEmpty(hostToRegistry)) {
hostToRegistry = NetUtils.getLocalHost();
} else if (isInvalidLocalHost(hostToRegistry)) {
throw new IllegalArgumentException("Specified invalid registry ip from property:" + DUBBO_IP_TO_REGISTRY + ", value:" + hostToRegistry);
}
map.put(REGISTER_IP_KEY, hostToRegistry);
// 所有數(shù)據在存到serviceMetadata的attachments中
serviceMetadata.getAttachments().putAll(map);
// 創(chuàng)建Service代理
ref = createProxy(map);
// 設置ServiceMetadata的Service代理引用
serviceMetadata.setTarget(ref);
serviceMetadata.addAttribute(PROXY_CLASS_REF, ref);
ConsumerModel consumerModel = repository.lookupReferredService(serviceMetadata.getServiceKey());
consumerModel.setProxyObject(ref);
consumerModel.init(attributes);
// 標記初始化完畢
initialized = true;
// dispatch a ReferenceConfigInitializedEvent since 2.7.4
dispatch(new ReferenceConfigInitializedEvent(this, invoker));
}ReferenceConfig#createProxy()創(chuàng)建服務代理
@SuppressWarnings({"unchecked", "rawtypes", "deprecation"})
private T createProxy(Map<String, String> map) {
// 是否是InJvm，協(xié)議是InJvm
if (shouldJvmRefer(map)) {
URL url = new URL(LOCAL_PROTOCOL, LOCALHOST_VALUE, 0, interfaceClass.getName()).addParameters(map);
invoker = REF_PROTOCOL.refer(interfaceClass, url);
if (logger.isInfoEnabled()) {
logger.info("Using injvm service " + interfaceClass.getName());
}
} else {
urls.clear();
if (url != null && url.length() > 0) { // user specified URL, could be peer-to-peer address, or register center's address.
String[] us = SEMICOLON_SPLIT_PATTERN.split(url);
if (us != null && us.length > 0) {
for (String u : us) {
URL url = URL.valueOf(u);
if (StringUtils.isEmpty(url.getPath())) {
url = url.setPath(interfaceName);
}
if (UrlUtils.isRegistry(url)) {
urls.add(url.addParameterAndEncoded(REFER_KEY, StringUtils.toQueryString(map)));
} else {
urls.add(ClusterUtils.mergeUrl(url, map));
}
}
}
} else { // assemble URL from register center's configuration
// 如果protocols不是injvm檢查注冊中心
if (!LOCAL_PROTOCOL.equalsIgnoreCase(getProtocol())) {
checkRegistry();
// url列表，將zookeeper://改成registry://
List<URL> us = ConfigValidationUtils.loadRegistries(this, false);
if (CollectionUtils.isNotEmpty(us)) {
for (URL u : us) {
// 監(jiān)控URL
URL monitorUrl = ConfigValidationUtils.loadMonitor(this, u);
// 如果有監(jiān)控配置放到map中
if (monitorUrl != null) {
map.put(MONITOR_KEY, URL.encode(monitorUrl.toFullString()));
}
// 根據map中的信息生成url，這里生成的結果是
/*
registry://127.0.0.1:2181/org.apache.dubbo.registry.RegistryService?application=serialization-java-consumer&dubbo=2.0.2&pid=66793&qos.accept.foreign.ip=false&qos.enable=true&qos.port=33333&refer=application%3Dserialization-java-consumer%26check%3Dtrue%26dubbo%3D2.0.2%26init%3Dfalse%26interface%3Dorg.apache.dubbo.samples.serialization.api.DemoService%26methods%3DsayHello%26pid%3D66793%26qos.accept.foreign.ip%3Dfalse%26qos.enable%3Dtrue%26qos.port%3D33333%26register.ip%3D192.168.58.45%26release%3D2.7.7%26side%3Dconsumer%26sticky%3Dfalse%26timestamp%3D1636532992568®istry=zookeeper&release=2.7.7×tamp=1636533091883
*/
urls.add(u.addParameterAndEncoded(REFER_KEY, StringUtils.toQueryString(map)));
}
}
if (urls.isEmpty()) {
throw new IllegalStateException("No such any registry to reference " + interfaceName + " on the consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion() + ", please config <dubbo:registry address=\"...\" /> to your spring config.");
}
}
}
// 如果引用的URL就1個直接通過refer引用服務，這里和export相似，通過調用鏈實現(xiàn)的
// - ProtocolListenerWrapper
// - - ProtocolFilterWrapper
// - - - RegistryProtocol
if (urls.size() == 1) {
// 通過RegistryProtocol#refer引用服務
invoker = REF_PROTOCOL.refer(interfaceClass, urls.get(0));
} else {
// 如果是引用的服務多個，循環(huán)處理
List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
URL registryURL = null;
for (URL url : urls) {
invokers.add(REF_PROTOCOL.refer(interfaceClass, url));
if (UrlUtils.isRegistry(url)) {
registryURL = url; // use last registry url
}
}
if (registryURL != null) { // registry url is available
// for multi-subscription scenario, use 'zone-aware' policy by default
// 集群處理
URL u = registryURL.addParameterIfAbsent(CLUSTER_KEY, ZoneAwareCluster.NAME);
// The invoker wrap relation would be like: ZoneAwareClusterInvoker(StaticDirectory) -> FailoverClusterInvoker(RegistryDirectory, routing happens here) -> Invoker
// 加入到集群中，這里包含集中集群處理模式，分別是：
invoker = CLUSTER.join(new StaticDirectory(u, invokers));
} else { // not a registry url, must be direct invoke.
invoker = CLUSTER.join(new StaticDirectory(invokers));
}
}
}
// invoer不可用處理
if (shouldCheck() && !invoker.isAvailable()) {
invoker.destroy();
throw new IllegalStateException("Failed to check the status of the service "
+ interfaceName
+ ". No provider available for the service "
+ (group == null ? "" : group + "/")
+ interfaceName +
(version == null ? "" : ":" + version)
+ " from the url "
+ invoker.getUrl()
+ " to the consumer "
+ NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion());
}
if (logger.isInfoEnabled()) {
logger.info("Refer dubbo service " + interfaceClass.getName() + " from url " + invoker.getUrl());
}
/**
* @since 2.7.0
* ServiceData存儲，SPI機制，支持內存和遠程兩種方式
*/
String metadata = map.get(METADATA_KEY);
WritableMetadataService metadataService = WritableMetadataService.getExtension(metadata == null ? DEFAULT_METADATA_STORAGE_TYPE : metadata);
if (metadataService != null) {
URL consumerURL = new URL(CONSUMER_PROTOCOL, map.remove(REGISTER_IP_KEY), 0, map.get(INTERFACE_KEY), map);
metadataService.publishServiceDefinition(consumerURL);
}
// create service proxy
return (T) PROXY_FACTORY.getProxy(invoker, ProtocolUtils.isGeneric(generic));
}創(chuàng)建代理服務會創(chuàng)建Invoker，在引用服務過程中，會判斷協(xié)議是否為injvm，會根據協(xié)議做不同的處理，不是injvm協(xié)議會根據構造的配置信息（map）生成url并將url協(xié)議有zookeeper://改成registry://，然后通過Protocol接口refer方法引用服務，與發(fā)布服務相似，引用服務的過程也會包裝方法的調用鏈，如下：
- ProtocolListenerWrapper
- - ProtocolFilterWrapper
- - - RegistryProtocol
在refer的過程中會對一個服務端的引用和一個服務多個服務端的服務進行區(qū)分處理，對于有多個服務端的服務會進行集群處理（cluster），會講invoker列表加入到集群中，在調用過程中會根據集群策略來選擇不同的策略進行調用，集群策略實現(xiàn)也實現(xiàn)了SPI機制，
RegistryProtocol#refer引用服務
@Override
@SuppressWarnings("unchecked")
public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
// 注冊中心url 將 registry:// 轉成 zookeeper://
url = getRegistryUrl(url);
// 獲取注冊中心
Registry registry = registryFactory.getRegistry(url);
if (RegistryService.class.equals(type)) {
return proxyFactory.getInvoker((T) registry, type, url);
}
// 從url中解析出引用服務信息
Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded(REFER_KEY));
// 獲取分組
String group = qs.get(GROUP_KEY);
// 如果設置分組了，那么使用MergeableCluster策略
if (group != null && group.length() > 0) {
if ((COMMA_SPLIT_PATTERN.split(group)).length > 1 || "*".equals(group)) {
return doRefer(getMergeableCluster(), registry, type, url);
}
}
return doRefer(cluster, registry, type, url);
}RegistryProtocol#doRefer引用服務
private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
// 獲取集群目錄Directory，代表Invoker的集合
RegistryDirectory<T> directory = new RegistryDirectory<T>(type, url);
directory.setRegistry(registry);
directory.setProtocol(protocol);
// all attributes of REFER_KEY
Map<String, String> parameters = new HashMap<String, String>(directory.getConsumerUrl().getParameters());
URL subscribeUrl = new URL(CONSUMER_PROTOCOL, parameters.remove(REGISTER_IP_KEY), 0, type.getName(), parameters);
if (directory.isShouldRegister()) {
directory.setRegisteredConsumerUrl(subscribeUrl);
// 注冊消費者url
registry.register(directory.getRegisteredConsumerUrl());
}
directory.buildRouterChain(subscribeUrl);
// 向ZK發(fā)起訂閱服務，并設置監(jiān)聽，這里比較復雜，最終會在ZookeeperRegistry#doSubscribe做服務訂閱
directory.subscribe(toSubscribeUrl(subscribeUrl));
// 加入集群
Invoker<T> invoker = cluster.join(directory);
List<RegistryProtocolListener> listeners = findRegistryProtocolListeners(url);
if (CollectionUtils.isEmpty(listeners)) {
return invoker;
}
RegistryInvokerWrapper<T> registryInvokerWrapper = new RegistryInvokerWrapper<>(directory, cluster, invoker, subscribeUrl);
for (RegistryProtocolListener listener : listeners) {
listener.onRefer(this, registryInvokerWrapper);
}
return registryInvokerWrapper;
}RegistryDirectory#subscribe訂閱服務
RegistryProtocol#doRefer方法，directory.subscribe會按照下面的調用鏈進行處理，最后調用ZookeeperRegistry#doSubscribe方法向zk注冊數(shù)據訂閱接口，并設置監(jiān)聽。
- RegistryDirectory
- - ListenerRegistryWrapper
- - - FailbackRegistry
- - - - ZookeeperRegistry
@Override
public void doSubscribe(final URL url, final NotifyListener listener) {
try {
if (ANY_VALUE.equals(url.getServiceInterface())) {
String root = toRootPath();
// 初始化監(jiān)聽
ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.computeIfAbsent(url, k -> new ConcurrentHashMap<>());
ChildListener zkListener = listeners.computeIfAbsent(listener, k -> (parentPath, currentChilds) -> {
for (String child : currentChilds) {
child = URL.decode(child);
if (!anyServices.contains(child)) {
anyServices.add(child);
subscribe(url.setPath(child).addParameters(INTERFACE_KEY, child,
Constants.CHECK_KEY, String.valueOf(false)), k);
}
}
});
// 創(chuàng)建zk節(jié)點
zkClient.create(root, false);
List<String> services = zkClient.addChildListener(root, zkListener);
if (CollectionUtils.isNotEmpty(services)) {
for (String service : services) {
service = URL.decode(service);
anyServices.add(service);
subscribe(url.setPath(service).addParameters(INTERFACE_KEY, service,
Constants.CHECK_KEY, String.valueOf(false)), listener);
}
}
} else {
List<URL> urls = new ArrayList<>();
for (String path : toCategoriesPath(url)) {
ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.computeIfAbsent(url, k -> new ConcurrentHashMap<>());
ChildListener zkListener = listeners.computeIfAbsent(listener, k -> (parentPath, currentChilds) -> ZookeeperRegistry.this.notify(url, k, toUrlsWithEmpty(url, parentPath, currentChilds)));
zkClient.create(path, false);
List<String> children = zkClient.addChildListener(path, zkListener);
if (children != null) {
urls.addAll(toUrlsWithEmpty(url, path, children));
}
}
//
notify(url, listener, urls);
}
} catch (Throwable e) {
throw new RpcException("Failed to subscribe " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
}
}DubboProtocol#protocolBindingRefer創(chuàng)建Invoker
refer服務創(chuàng)建Invoker時會調用該方法，該方法會通過getClients創(chuàng)建網絡客戶端，創(chuàng)建客戶端是會判斷客戶端是否為共享鏈接，根據connections創(chuàng)建客戶端ExchangeClient，然后通過initClient初始化客戶端，初始化過程中會判斷是否為延遲的客戶端LazyConnectExchangeClient，不是延遲客戶端，就會通過connect連接服務提供者，與服務提供者連接，具體建立連接流程不在這里說明，會在網絡通信介紹。
@Override
public <T> Invoker<T> protocolBindingRefer(Class<T> serviceType, URL url) throws RpcException {
optimizeSerialization(url);
// 創(chuàng)建RPC Invoker，通過getClients(url)創(chuàng)建網絡客戶端
DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, getClients(url), invokers);
// 將invoker添加到invokers中
invokers.add(invoker);
return invoker;
}
// 創(chuàng)建客戶端數(shù)組
private ExchangeClient[] getClients(URL url) {
// whether to share connection
// 是否共享鏈接
boolean useShareConnect = false;
int connections = url.getParameter(CONNECTIONS_KEY, 0);
List<ReferenceCountExchangeClient> shareClients = null;
// if not configured, connection is shared, otherwise, one connection for one service
if (connections == 0) {
useShareConnect = true;
/*
* The xml configuration should have a higher priority than properties.
* xml配置優(yōu)先級高于properties配置
*/
String shareConnectionsStr = url.getParameter(SHARE_CONNECTIONS_KEY, (String) null);
connections = Integer.parseInt(StringUtils.isBlank(shareConnectionsStr) ? ConfigUtils.getProperty(SHARE_CONNECTIONS_KEY,
DEFAULT_SHARE_CONNECTIONS) : shareConnectionsStr);
// 共享鏈接客戶端
shareClients = getSharedClient(url, connections);
}
// 創(chuàng)建ExchangeClient
ExchangeClient[] clients = new ExchangeClient[connections];
for (int i = 0; i < clients.length; i++) {
if (useShareConnect) {
// 從共享客戶端獲取
clients[i] = shareClients.get(i);
} else {
// 初始化客戶端
clients[i] = initClient(url);
}
}
return clients;
}
// 初始化客戶端
private ExchangeClient initClient(URL url) {
// client type setting.
String str = url.getParameter(CLIENT_KEY, url.getParameter(SERVER_KEY, DEFAULT_REMOTING_CLIENT));
url = url.addParameter(CODEC_KEY, DubboCodec.NAME);
// enable heartbeat by default
url = url.addParameterIfAbsent(HEARTBEAT_KEY, String.valueOf(DEFAULT_HEARTBEAT));
// BIO is not allowed since it has severe performance issue.
if (str != null && str.length() > 0 && !ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str)) {
throw new RpcException("Unsupported client type: " + str + "," +
" supported client type is " + StringUtils.join(ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions(), " "));
}
ExchangeClient client;
try {
// connection should be lazy
if (url.getParameter(LAZY_CONNECT_KEY, false)) {
// 延遲加載客戶端
client = new LazyConnectExchangeClient(url, requestHandler);
} else {
// 通過NettyTransporter connect創(chuàng)建客戶端 與provider建立連接
client = Exchangers.connect(url, requestHandler);
}
} catch (RemotingException e) {
throw new RpcException("Fail to create remoting client for service(" + url + "): " + e.getMessage(), e);
}
return client;
}總結
Dubbo Consumer整個的啟動，引用服務的流程大致就看完了，ReferenceBean實現(xiàn)了Spring的FactoryBean接口，在使用Spring上下文getBean時就會調用到ReferenceBean的getObject方法，這時就會通過創(chuàng)建代理（createProxy），然后通過Protocol的refer方法引用服務；
引用服務的流程大致可以理解為，通過DubboProtocol的refer方法創(chuàng)建DubboInvoker調用getClients方法創(chuàng)建ExchangeClient，然后通過initClient方法初始化網絡客戶端，初始化客戶端過程中會通過Exchangers的connect與服務提供者建立連接，后續(xù)就是網絡客戶端與服務端建立連接這里會和服務提供者相似，通過doOpen初始化網絡客戶端，然后調用doConnect建立連接。
到此這篇關于Dubbo Consumer引用服務示例代碼詳解的文章就介紹到這了,更多相關Dubbo Consumer引用服務內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要給大家介紹了關于如何一文徹底理清SpringBoot CURD處理邏輯、順序的相關資料,CURD是一個數(shù)據庫技術中的縮寫詞,一般的項目開發(fā)的各種參數(shù)的基本功能都是CURD,文中通過代碼介紹的非常詳細,需要的朋友可以參考下2023-10-10
Controller一般指的是MVC架構里的控制層,是對項目里的功能做統(tǒng)一的調度,下面這篇文章主要給大家介紹了關于java中controller層是干什么的相關資料,文中通過圖文介紹的非常詳細,需要的朋友可以參考下2023-03-03
如何使用java agent修改字節(jié)碼并在springboot啟動時自動生效
本文介紹了JavaAgent的使用方法和在SpringBoot中的應用,JavaAgent可以通過修改類的字節(jié)碼,實現(xiàn)對非Spring容器管理對象的AOP處理,演示了如何定義切面邏輯,實現(xiàn)接口mock,感興趣的朋友跟隨小編一起看看吧2024-10-10
IntelliJ?IDEA?2022.1.1創(chuàng)建java項目的詳細方法步驟
最近安裝了IntelliJ IDEA 2022.1.1,發(fā)現(xiàn)新版本的窗口還有些變化的,所以下面這篇文章主要給大家介紹了關于IntelliJ?IDEA?2022.1.1創(chuàng)建java項目的詳細方法步驟,文中通過圖文介紹的非常詳細,需要的朋友可以參考下2022-07-07
這篇文章主要介紹了java迭代器模式，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2021-09-09
Spring Boot配置Thymeleaf（gradle）的簡單使用
今天小編就為大家分享一篇關于Spring Boot配置Thymeleaf（gradle）的簡單使用，小編覺得內容挺不錯的，現(xiàn)在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧2018-12-12
Lucene是一個全文搜索框架，而不是應用產品。因此它并不像www.baidu.com 或者google Desktop那么拿來就能用，它只是提供了一種工具讓你能實現(xiàn)這些產品。接下來通過本文給大家介紹使用Lucene實現(xiàn)一個簡單的布爾搜索功能2017-04-04
這篇文章主要介紹了Mybatis常用分頁插件實現(xiàn)快速分頁處理的方法。非常不錯具有參考借鑒價值，感興趣的朋友一起看看2016-10-10
java實現(xiàn)zip,gzip,7z,zlib格式的壓縮打包
本文是利用Java原生類和apache的commons實現(xiàn)zip,gzip,7z,zlib的壓縮打包，如果你要是感興趣可以進來了解一下。2016-10-10
這篇文章主要介紹了Guava Cache的使用簡介，幫助大家更好的理解和學習使用Guava Cache，感興趣的朋友可以了解下2021-03-03