SpringBoot 動態代理實現三方介面呼叫

mysgk發表於2021-11-29

在某些業務場景中，我們只需要業務程式碼中定義相應的介面或者相應的註解，並不需要實現對應的邏輯。

比如 mybatis和feign：在 mybatis 中，我們只需要定義對應的mapper介面；在 feign 中，我們只需要定義對應業務系統中的介面即可。

那麼在這種場景下，具體的業務邏輯時怎麼執行的呢，其實原理都是動態代理。

我們這裡不具體介紹動態代理，主要看一下它在springboot專案中的實際應用，下面我們模仿feign來實現一個呼叫三方介面的 httpclient。

一、定義註解

定義好註解，方便後面掃描使用了該註解的類和方法

package com.mysgk.blogdemo.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * @author mysgk
 * @link https://www.cnblogs.com/mysgk/p/15619895.html
 * <p>
 * 這裡應該還有一個註解來標識方法，demo為了方便都使用該註解
 */
@Retention(RUNTIME)
@Target({TYPE, METHOD})
@Documented
public @interface MyHttpClient {
}

二、建立動態代理類

用於產生代理類並執行對應方法

package com.mysgk.blogdemo.proxy;

import org.springframework.beans.factory.FactoryBean;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author mysgk
 * @link https://www.cnblogs.com/mysgk/p/15619895.html
 */
public class RibbonAopProxyFactory<T> implements FactoryBean<T>, InvocationHandler {

	private Class<T> interfaceClass;

	public Class<T> getInterfaceClass() {
		return interfaceClass;
	}

	public void setInterfaceClass(Class<T> interfaceClass) {
		this.interfaceClass = interfaceClass;
	}

	@Override
	public T getObject() throws Exception {
		final Class[] interfaces = {interfaceClass};
		return (T) Proxy.newProxyInstance(this.getClass().getClassLoader(), interfaces, this);
	}

	@Override
	public Class<?> getObjectType() {
		return interfaceClass;
	}

	@Override
	public boolean isSingleton() {
		return true;
	}

	/**
	 * 真正執行的方法,會被aop攔截
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		return "invoke " + interfaceClass.getName() + "." + method.getName() + " , do anything ..";
	}
}

三、注入spring容器

在專案啟動時，掃描第一步定義的註解，生成該類的實現類，並將其注入到spring容器

package com.mysgk.blogdemo.start;

import cn.hutool.core.util.ClassUtil;
import cn.hutool.core.util.StrUtil;
import com.mysgk.blogdemo.annotation.MyHttpClient;
import com.mysgk.blogdemo.proxy.RibbonAopProxyFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.stereotype.Component;
import java.util.Set;

/**
 * @author mysgk
 * @link https://www.cnblogs.com/mysgk/p/15619895.html
 */
@Component
public class ScanHttpClients implements BeanDefinitionRegistryPostProcessor {

	public void run(BeanDefinitionRegistry registry) {

		Set<Class<?>> scanPackage = ClassUtil.scanPackageByAnnotation("com.mysgk", MyHttpClient.class);

		for (Class<?> cls : scanPackage) {
			BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(cls);
			GenericBeanDefinition definition = (GenericBeanDefinition) builder.getRawBeanDefinition();
			definition.getPropertyValues().add("interfaceClass", definition.getBeanClassName());
			definition.setBeanClass(RibbonAopProxyFactory.class);
			definition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE);
			String beanName = StrUtil.removePreAndLowerFirst(cls.getSimpleName(), 0) + "RibbonClient";
			registry.registerBeanDefinition(beanName, definition);
		}
	}

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		run(registry);
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

	}
}

四、編寫攔截器

攔截動態代理生成的方法，實現我們真正的業務邏輯


package com.mysgk.blogdemo.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

/**
 * @author mysgk
 * @link https://www.cnblogs.com/mysgk/p/15619895.html
 */
@Component
@Aspect
public class InterceptAnnotation {

	@Autowired
	RestTemplate ribbonLoadBalanced;

	@Pointcut("@annotation(com.mysgk.blogdemo.annotation.MyHttpClient)")
	public void execute() {

	}

	@Around("execute()")
	public Object interceptAnnotation(ProceedingJoinPoint joinPoint) throws Throwable {
		/**
		 * 此處省略 獲取 url, httpMethod, requestEntity, responseType 等引數的處理過程
		 */
		ResponseEntity<?> exchange = ribbonLoadBalanced.exchange("http://www.baidu.com", HttpMethod.GET, HttpEntity.EMPTY, Object.class);
		return exchange.getBody();
	}

}

五、建立客戶端呼叫類

此類實現將遠端介面當做本地方法呼叫

package com.mysgk.blogdemo.client;

import com.mysgk.blogdemo.annotation.MyHttpClient;
import org.springframework.web.bind.annotation.PostMapping;

/**
 * @author mysgk
 * @link https://www.cnblogs.com/mysgk/p/15619895.html
 */
@MyHttpClient
public interface MyHttpClientTest {

	@MyHttpClient
	@PostMapping(value = "test/t1")
	Object test(String param);

}

六、main方法測試

注入客戶端進行呼叫

package com.mysgk.blogdemo;

import com.mysgk.blogdemo.client.MyHttpClientTest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @author mysgk
 * @link https://www.cnblogs.com/mysgk/p/15619895.html
 */
@SpringBootApplication
@RestController
public class Main {

	@Bean
	RestTemplate restTemplate() {
		return new RestTemplate();
	}

	@Autowired
	MyHttpClientTest myHttpClientTest;

	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}

	@GetMapping("/t1")
	public Object t1() {
		return myHttpClientTest.test("1");
	}
}

七、啟動專案

訪問 127.0.0.1:8080/t1,得到如下結果

此時我們呼叫的是

myHttpClientTest.test

但是真正執行的是

RibbonAopProxyFactory.invoke

此時返回的應該是

invoke com.mysgk.blogdemo.client.MyHttpClientTest.test  , do anything ..

由於我們使用aop攔截了該方法，所以最終的結果是訪問到了baidu
呼叫流程圖

最後附上pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>bolgdemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            <version>2.1.5.RELEASE</version>
            <exclusions>
                <exclusion>
                    <artifactId>httpclient</artifactId>
                    <groupId>org.apache.httpcomponents</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <artifactId>httpclient</artifactId>
            <groupId>org.apache.httpcomponents</groupId>
            <version>4.5.13</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>

    </build>
</project>

Android 動態代理以及利用動態代理實現 ServiceHook
2017-02-25
AndroidHook
MyBatis進階--介面代理方式實現Dao 和動態SQL
2021-05-23
MyBatisSQL
Laravel 如何實現既能靜態呼叫，又能動態呼叫
2018-12-04
Laravel
Ruby如何實現動態方法呼叫
2013-10-18
C#動態呼叫WCF介面
2017-06-13
C#
利用動態建立自動化介面實現VB的函式指標呼叫 (轉)
2008-01-06
函式指標
JavaScript代理模式，怎麼實現物件的動態代理？
2023-10-08
JavaScript模式物件
mybatis-plus原始碼解析(三)----Mapper介面動態代理呼叫過程
2018-05-07
MyBatis原始碼APP
純手寫實現JDK動態代理
2019-01-24
JDK
CGLib動態代理原理及實現
2018-11-01
CGLib
RPC核心實現原理-動態代理
2023-02-28
RPC
反射-動態代理的概述和實現
2017-06-11
反射
實現呼叫API介面
2018-07-25
API
itchat—python實現呼叫微信介面的第三方模組
2018-03-16
Python
SAP ABAP和Java的動態代理實現
2020-08-22
Java
細說JDK動態代理的實現原理
2018-11-19
JDK
Java使用Porxy和InvocationHandler實現動態代理
2017-06-06
Java
Java代理設計模式(Proxy)的四種具體實現：靜態代理和動態代理
2018-08-29
Java設計模式
[動態代理三部曲：下] - 從動態代理，看Retrofit的原始碼實現
2018-08-22
原始碼
【乾貨】JDK動態代理的實現原理以及如何手寫一個JDK動態代理
2018-10-18
JDK
Mybatis之介面程式設計--JAVA動態代理的最佳展現
2018-09-03
MyBatis程式設計Java
SmartSql使用教程（2）—使用動態代理實現CURD
2019-05-17
SQL
go如何實現類似java的動態代理
2016-10-16
GoJava
Java JDK 動態代理使用及實現原理分析
2016-08-08
JavaJDK
Java代理(jdk靜態代理、動態代理和cglib動態代理)
2019-01-28
JavaJDKCGLib
SpringBoot Restful 介面實現
2022-06-03
Spring BootREST
靜態代理和動態代理
2019-05-15
FastHook——巧妙利用動態代理實現非侵入式AOP
2019-03-31
ASTHook
JDK 和 CGLib 實現動態代理和區別
2021-07-29
JDKCGLib
Go | Go 結合 Consul 實現動態反向代理
2021-02-27
Go
JDK動態代理實現原理詳解（原始碼分析）
2020-10-24
JDK原始碼
Java JDK 動態代理（AOP）使用及實現原理分析
2016-08-07
JavaJDK
使用Go呼叫第三方介面
2021-08-11
Go
代理模式詳解:靜態代理、JDK動態代理與Cglib動態代理
2021-03-09
模式JDKCGLib
介面呼叫超時的實現原理
2020-06-28
java靜態代理和動態代理
2016-04-15
Java
動態代理
2023-02-08
設計模式學習筆記（七）代理模式以及動態代理的實現
2022-03-28
設計模式筆記