public static void main(String[] args) {
    Payment payment = new Payment("AliPay");
    Pay proxy = ProxyUtil.createProxy(payment);

    proxy.pay(amount);
}

class Payment implements Pay {

    @Overide
    public payResp pay(BigDecimal payAmount) {
        // Payment Business...
    }
}

interface Pay {

    abstract payResp pay(BigDecimal payAmount);
}

class ProxyUtils {
    public static Pay createProxy(Payment payment) {
        return (Pay) Proxy.newProxyInstance(
            ProxyUtil.class.getClassLoader(),
            new Class[]{ Pay.class },
            new InvocationHandler() {

                @Overide
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    // Payment Environment Init...
                    // Payment Safe Guard...
                    return method.invoke(payment, args);
                }
            }
        );
    }
}

Class clazz;
clazz = Class.forName("com.yourpackage.TargetClass");
// 参数
clazz = TargetClass.class;
// 有实例时
clazz = instance.getClass();

Properties prop = new Properties();
FileInputStream fis = new FileInputStream(ROOT + "src/main/resources/application.properties");
String dataSourceUrl = (String) perp.get("dataSource");
String dbName = (String) extractDbName(dataSourceUrl);

Class clazz = Class.forName(dbName);
Constructor con = clazz.getDeclaredConstructor();
Object o = con.newInstance();

...

void createEntry(int hash, K key, V value, int bucketIdx) {
    Entry<K, V> e = table[bucketIdx];
    // 这里使用头插法，在槽位头部插入新元素，并指向e，成为新的槽位引用
    table[bucketIdx] = new Entry<>(hash, key, value, e); 
    size++;
}

public Entry(int h, K k, V v, Entry<K, V> n) {
    this.value = v;
    this.next = n;
    this.key = k;
    this.hash = h;
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-dependencies</artifactId>
    <version>2024.0.0</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }
}

@Configuration
public class BeanConfiguration {

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

@Override
public UserBorrowDetail getUserBorrowDetailByUid(int uid) {
    List<Borrow> borrow = borrowMapper.getBorrowByUid(uid);
    RestTemplate restTemplate = new RestTemplate();
    User user = restTemplate.getForObject("http://userservice/user/"+uid, User.class);
    List<Book> bookList = borrow
            .stream()
            .map(b -> restTemplate.getForObject("http://bookservice/book/"+b.getBid(), Book.class))
            .collect(Collectors.toList());
    return new UserBorrowDetail(user, bookList);
}

public class LoadBalancerConfig {
      //将官方提供的 RandomLoadBalancer 注册为Bean
    @Bean
    public ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory){
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

@Configuration
@LoadBalancerClient(value = "userservice",
                    configuration = LoadBalancerConfig.class)
public class BeanConfiguration {

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

@SpringBootApplication
@EnableFeignClients
public class SomeApplication {
    public static void main(String[] args) {
        SpringApplication.run(SomeApplication.class, args);
    }
}

@FeignClient("userservice")   // 声明为userservice服务的HTTP请求客户端
public interface UserClient {

      // 路径保证和UserService微服务提供的一致即可
    @RequestMapping("/user/{uid}")
    User getUserById(@PathVariable("uid") int uid);  // 参数和返回值也保持一致
}

@Resource
UserClient userClient;

@Override
public UserBorrowDetail getUserBorrowDetailByUid(int uid) {

    // RestTemplate方法
    RestTemplate template = new RestTemplate();
    User user = template.getForObject("http://userservice/user/"+uid, User.class);
    // OpenFeign方法，更直观的方法调用
    User user = userClient.getUserById(uid);

}

@Configuration
public class FeignConfig implements RequestInterceptor {
 
    @Override
    public void apply(RequestTemplate requestTemplate) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        requestTemplate.header("token", request.getHeader("token"));
    }
}

@FeignClient(value = "SomeService", configuration = FeignConfig.class)
public interface SomeService {

String lockKey = req.getBusinessUniqueKey() + "-" + req.getBusinessCode();
RLock lock = null;
try {
    lock = redissonClient.getLock(lockKey);
    boolean tryLock = lock.tryLock(0, TimeUnit.SECONDS);
    if (!tryLock) {
        LOG.info("获取锁失败");
        throw new BusinessException(BusinessExceptionEnum.CONFIRM_ORDER_TICKET_COUNT_ERROR);
    }

    // Business Code

} catch (InterruptedException e) {
    throw new RuntimeException(e);
} finally {
    LOG.info("释放锁");
    if (lock != null && lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}