class UserFactory {
    public static UserDao getDao() {
        String classValue = context.getProperty("userDao");
        Class clazz = Class.forName(classValue);
    }
}

AnnotationConfigApplicationContext context = 
    new AnnotationConfigApplicationContext(AppConfig.class);
// resource/application.xml
ClassPathXmlApplicationContext context = 
    new ClassPathXmlApplicationContext("application.xml")

UserService userService = (UserService) context.getBean("userService");

for (Field field: userService.getClass().getFields()) {
    if (field.isAnnotationPresent(Autowired.class)) {
        field.set(userService, value);
    }
}

@PostContruct
public init() {
    ...
}

for (Method method: userService.getClass().getMethods()) {
    if (method.isAnnotationPresent(PostConstruct.class)) {
        method.invoke(userService, null);
    }
}

<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();
    }
}

public ThreadPoolExecutor(
    @Range(from = 0, to = Integer.MAX_VALUE) int  corePoolSize,
    @Range(from = 1, to = Integer.MAX_VALUE) int  maximumPoolSize,
    @Range(from = 0, to = Long.MAX_VALUE)    long keepAliveTime,
    @NotNull TimeUnit unit,
    @NotNull BlockingQueue<Runnable> workQueue,
    @NotNull ThreadFactory threadFactory,
    @NotNull RejectedExecutionHandler handler
) { ... }

// Example
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
    5,
    10,
    0L,
    TimeUnit.SECONDS,
    new ArrayBlockingQueue<Runnable>(10), // 10为容量
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.AbortPolicy()
);