ini复制代码var inorderTraversal = function(root) {
   let res  = [];//最后要返回的数组
   let stack = [];//我们用来存储遍历过程中遇到的元素
   //root == null 并且 stack.length == 0(循环退出)    
   while(root||stack.length){
        while(root){//当前元素存在就循环
           stack.push(root);//把当前元素入栈，不是入的值，而是当前的整个元素
           root = root.left;//继续找它的左孩子
        }
        //该元素没有左孩子，那么我们就应该打印该元素
        let target  = stack.pop();//返回该元素并出栈
        res.push(target.val);//将该元素的值压入要返回的栈里边
        root = target.right;//遍历该元素的右孩子，因为左边和中间（父结点）已经遍历过了
   }
   return res;//返回最终的结果
};

shell复制代码docker pull mysql:8.0.27

shell复制代码docker run 
    --name some-mysql 
    -p 3306:3306 
    -e MYSQL_ROOT_PASSWORD=my-secret-pw 
    -d mysql:tag

shell复制代码docker run 
	--name some-mysql 
	-p 3306:3306 
	-v /my/custom/data:/var/lib/mysql 
	-e MYSQL_ROOT_PASSWORD=my-secret-pw 
	-d mysql:tag

shell复制代码docker run 
	--name some-mysql 
	-p 3306:3306 
	-v /my/custom/data:/var/lib/mysql  
	-v /my/custom/conf:/etc/mysql/conf.d 
	-e MYSQL_ROOT_PASSWORD=my-secret-pw 
	-d mysql:tag

shell复制代码docker pull nginx:1.21.3

shell复制代码docker run 
--name some-nginx 
-v /some/content:/usr/share/nginx/html:ro # :ro 代表只读，容器内数据改变不影响外部
-d nginx:tag

shell复制代码docker run --name tmp-nginx -d nginx
docker cp tmp-nginx:/etc/nginx/nginx.conf /host/path/nginx.conf
docker rm -f tmp-nginx

ini复制代码upstream myservers {
    server 192.168.1.8;
    server 192.168.1.9;
    server 192.168.1.10;
}
server {
    location / {
        proxy_pass http://myservers/;
    }
}

shell复制代码docker run 
--name my-custom-nginx-container 
-v /host/path/nginx.conf:/etc/nginx/nginx.conf
-d nginx:tag

shell复制代码docker pull redis:6.2.5

shell复制代码docker run --name some-redis -p 6379:6379 -d redis:tag

shell复制代码docker run 
	--name some-redis 
	-p 6379:6379 
	-v /var/docker/redis/data:/data 
	-d redis:tag

shell复制代码docker run 
	--name some-redis 
	-p 6379:6379 
	-v /var/docker/redis/data:/data 
	-d redis:tag
	redis-server --appendonly yes # 可在 run 命令后直接追加启动后容器要执行的命令

shell复制代码# 设置为 0.0.0.0，即开启远程访问
bind 0.0.0.0
# 开启 AOF
appendonly yes
# 设置端口
port 6379
# 设置访问密码
requirepass xxxxx

shell复制代码docker run 
	--name some-redis 
	-p 6379:6379 
	-v /var/docker/redis/data:/data 
	-v /var/docker/redis/redis.conf:/etc/redis.conf # 挂载配置文件
	-d redis:tag
	redis-server /etc/redis.conf # 启动 server 时使用配置文件

shell复制代码docker pull rabbitmq:3.8.23-management

shell复制代码# 15672 Web 管理页面端口
# 5672 通信端口
docker run \
	--name rabbitmq \
	-p 15672:15672 \
	-p 5672:5672 \
	-d rabbitmq:3.8.23-management

shell复制代码 # RABBITMQ_DEFAULT_USER 用户名
 # RABBITMQ_DEFAULT_PASS 密码
 docker run \
         --name rabbitmq \
         -p 15672:15672 \
         -p 5672:5672 \
         -e RABBITMQ_DEFAULT_USER=admin \
         -e RABBITMQ_DEFAULT_PASS=xxxx \
         -d rabbitmq:3.8.23-management

shell复制代码# RABBITMQ_DEFAULT_VHOST 指定虚拟主机名称
 docker run \
         --name rabbitmq \
         -p 15672:15672 \
         -p 5672:5672 \
         -e RABBITMQ_DEFAULT_USER=admin \
         -e RABBITMQ_DEFAULT_PASS=xxxx \
         -e RABBITMQ_DEFAULT_VHOST=demoMQ \
         -d rabbitmq:3.8.23-management

shell复制代码docker run \
	--name rabbitmq \
	-p 15672:15672 \
	-p 5672:5672 \
	-v /var/docker/rabbitmq/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
	-v /var/docker/rabbitmq/data:/var/lib/rabbitmq \
	-d rabbitmq:3.8.23-management

js复制代码@Configuration
public class RabbitMQConfig {

	// -------------------------topic队列
	// 创建队列
	@Bean
	public Queue topicQueue() {
		return new Queue("topic.mess");
	}
}

js复制代码public class ProducerController {
	@Autowired
	private RabbitTemplate rabbitTemplate;

	@GetMapping("/sendMessage")
	public Object sendMessage() {
		new Thread(() -> {
			//for (int i = 0; i < 100; i++) {

				Date date = new Date();
				String value = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(date);
				System.out.println("send message {}" + value);
				City city= new City();
				city.setCityName("aaaa");
				city.setDescription("bbb");
				city.setProvinceId((long)111);
				rabbitTemplate.convertAndSend("topic.mess", city); //使用默认的队列
				
			//}
		}).start();
		return "ok";
	}
}

js复制代码@Component
@RabbitListener(queues = "topic.mess") //topic交换机
public class Consumer2 {

	@RabbitHandler
	public void consumeMessage(City city) {
		System.out.println("consume message {} 2222222:" + city);
	}
}

js复制代码@Configuration
public class RabbitMQConfig {

	// -------------------------topic队列
	// 创建队列
	@Bean
	public Queue topicQueue() {
		return new Queue("topic.mess");
	}

	@Bean
	public Queue topicQueue2() {
		return new Queue("topic.mess2");
	}

	// 创建 topic 类型的交换器
	@Bean
	public TopicExchange topicExchange() {
		return new TopicExchange("topic");
	}


	// 使用路由键（routingKey）把队列（Queue）绑定到交换器（Exchange） Topic交换器通过routingKey与队列绑定
	@Bean
	public Binding bindingA(Queue topicQueue, TopicExchange topicExchange) {
		return BindingBuilder.bind(topicQueue).to(topicExchange).with("topic.mess");
	}

	@Bean
	public Binding bindingB(Queue topicQueue2, TopicExchange topicExchange) {
		return BindingBuilder.bind(topicQueue2).to(topicExchange).with("topic.#");
	}
}

js复制代码@RestController
public class ProducerController {
	@Autowired
	private RabbitTemplate rabbitTemplate;

	@GetMapping("/sendMessage")
	public Object sendMessage() {
		new Thread(() -> {
			//for (int i = 0; i < 100; i++) {

				Date date = new Date();
				String value = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(date);
				System.out.println("send message {}" + value);
				City city= new City();
				city.setCityName("aaaa");
				city.setDescription("bbb");
				city.setProvinceId((long)111);
				rabbitTemplate.convertAndSend("topic", "topic.mess", city);
				rabbitTemplate.convertAndSend("topic", "topic.mess2", city);
			//}
		}).start();
		return "ok";
	}
}

js复制代码@Component
@RabbitListener(queues = "topic.mess") //topic交换机
public class Consumer2 {

	@RabbitHandler
	public void consumeMessage(City city) {
		System.out.println("consume message {} 2222222:" + city);
	}
}

js复制代码// --------FanoutExchange绑定
	// -------------------------Fanout 队列
	@Bean
	FanoutExchange fanoutExchange() {
		return new FanoutExchange("fanoutExchange");
	}
	@Bean
	public Queue fanoutQueue() {
		return new Queue("fanoutqueue");
	}
	@Bean
	public Queue fanoutQueue2() {
		return new Queue("fanoutqueue2");
	}
	@Bean
	public Binding bindingC(Queue fanoutQueue, FanoutExchange fanoutExchange) {
		return BindingBuilder.bind(fanoutQueue).to(fanoutExchange);
	}
	@Bean
	public Binding bindingD(Queue fanoutQueue2, FanoutExchange fanoutExchange) {
		return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
	}

js复制代码@RestController
public class ProducerController {
	@Autowired
	private RabbitTemplate rabbitTemplate;

	@GetMapping("/sendMessage")
	public Object sendMessage() {
		new Thread(() -> {
			//for (int i = 0; i < 100; i++) {

				Date date = new Date();
				String value = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(date);
				System.out.println("send message {}" + value);
				City obj = new City();
				obj.setCityName("aaaa");
				obj.setDescription("bbb");
				obj.setProvinceId((long)111);
				rabbitTemplate.convertAndSend("fanoutExchange","", value); //使用默认的队列
				
			//}
		}).start();
		return "ok";
	}
}

js复制代码@Component
@RabbitListener(queues = "fanoutqueue2")
public class Consumer {

	@RabbitHandler
	public void consumeMessage(String message) {
		System.out.println("consume message {} 1111111:" + message);
	}
}

java复制代码String testA = "一生清澈";

java复制代码String testB = new String("一生清澈");

java复制代码String testA = "一生清澈";
String testB = "一生清澈";

// 判断字符串的内存地址是否相等
System.out.println(testA == testB);

java复制代码// 通过直接赋值的方式创建字符串
String testA = "一生清澈";
// 通过调用构造方法的方式创建字符串
String testB = new String("一生清澈");

// 判断字符串的内存地址是否相等
System.out.println(testA == testB);

java复制代码// 通过反射获取字符串类的字符数组
Field value = String.class.getDeclaredField("value");
// 设置私有变量的访问权限
value.setAccessible(true);

// 通过反射获取testA对象的字符数组
char[] testACharArray = (char[]) value.get(testA);
// 通过反射获取testB对象的字符数组
char[] testBCharArray = (char[]) value.get(testB);

// 判断字符数组的地址是否相同
System.out.println(testACharArray == testBCharArray);

rust复制代码pub trait Fly {
    fn fly(&self) -> bool;
}
struct Duck;
struct Pig;
// impl block
impl Fly for Duck {
    fn fly(&self) -> bool {
        return true;
    }
}
impl Fly for Pig {
    fn fly(&self) -> bool {
        return false;
    }
}
// use Triat
fn fly_static<T: Fly>(s: T) -> bool {
    s.fly()
}
fn fly_dyn(s: &Fly) -> bool {
    s.fly()
}

fn main() {
	let pig = Pig;
	assert_eq!(fly_static::<Pig>(pig), false);
	let duck = Duck;
	assert_eq!(fly_static::<Duck>(duck), true);
	assert_eq!(fly_dyn(&Pig), false);
	assert_eq!(fly_dyn(&Duck), true);
}

bash复制代码com.netflix.loadbalancer.BaseLoadBalancer.Pinger#runPinger

java复制代码public synchronized void start(final UpdateAction updateAction) {
    if (isActive.compareAndSet(false, true)) {
        final Runnable wrapperRunnable = new Runnable() {
            @Override
            public void run() {
                if (!isActive.get()) {
                    if (scheduledFuture != null) {
                        scheduledFuture.cancel(true);
                    }
                    return;
                }
                try {
                    updateAction.doUpdate();
                    lastUpdated = System.currentTimeMillis();
                } catch (Exception e) {
                    logger.warn("Failed one update cycle", e);
                }
            }
        };

        scheduledFuture = getRefreshExecutor().scheduleWithFixedDelay(
                wrapperRunnable,
                initialDelayMs,
                refreshIntervalMs,
                TimeUnit.MILLISECONDS
        );
    } else {
        logger.info("Already active, no-op");
    }
}

java复制代码@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

java复制代码/**
 * A callable that runs under established access control settings
 */
static final class PrivilegedCallable<T> implements Callable<T> {
	private final Callable<T> task;
	private final AccessControlContext acc;

	PrivilegedCallable(Callable<T> task) {
		this.task = task;
		this.acc = AccessController.getContext();
	}

	public T call() throws Exception {
		try {
			return AccessController.doPrivileged(
				new PrivilegedExceptionAction<T>() {
					public T run() throws Exception {
						return task.call();
					}
				}, acc);
		} catch (PrivilegedActionException e) {
			throw e.getException();
		}
	}
}

java复制代码private final Callable<T> task;
private final AccessControlContext acc;

java复制代码PrivilegedCallable(Callable<T> task) {
	this.task = task;
	this.acc = AccessController.getContext();
}

java复制代码public static AccessControlContext getContext(){
	AccessControlContext acc = getStackAccessControlContext();
	if (acc == null) {
		return new AccessControlContext(null, true);
	} else {
		return acc.optimize();
	}
}

java复制代码private static native AccessControlContext getStackAccessControlContext();

java复制代码public T call() throws Exception {
	try {
		return AccessController.doPrivileged(
			new PrivilegedExceptionAction<T>() {
				public T run() throws Exception {
					return task.call();
				}
			}, acc);
	} catch (PrivilegedActionException e) {
		throw e.getException();
	}
}

java复制代码@CallerSensitive
public static native <T> T
    doPrivileged(PrivilegedExceptionAction<T> action,
                 AccessControlContext context)
    throws PrivilegedActionException;

java复制代码/**
 * A callable that runs under established access control settings and
 * current ClassLoader
 */
static final class PrivilegedCallableUsingCurrentClassLoader<T> implements Callable<T> {
	private final Callable<T> task;
	private final AccessControlContext acc;
	private final ClassLoader ccl;

	PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
		SecurityManager sm = System.getSecurityManager();
		if (sm != null) {
			sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
			sm.checkPermission(new RuntimePermission("setContextClassLoader"));
		}
		this.task = task;
		this.acc = AccessController.getContext();
		this.ccl = Thread.currentThread().getContextClassLoader();
	}

	public T call() throws Exception {
		try {
			return AccessController.doPrivileged(
				new PrivilegedExceptionAction<T>() {
					public T run() throws Exception {
						Thread t = Thread.currentThread();
						ClassLoader cl = t.getContextClassLoader();
						if (ccl == cl) {
							return task.call();
						} else {
							t.setContextClassLoader(ccl);
							try {
								return task.call();
							} finally {
								t.setContextClassLoader(cl);
							}
						}
					}
				}, acc);
		} catch (PrivilegedActionException e) {
			throw e.getException();
		}
	}
}

java复制代码private final Callable<T> task;
private final AccessControlContext acc;
private final ClassLoader ccl;

java复制代码PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
	SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
		sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
		sm.checkPermission(new RuntimePermission("setContextClassLoader"));
	}
	this.task = task;
	this.acc = AccessController.getContext();
	this.ccl = Thread.currentThread().getContextClassLoader();
}

java复制代码public T call() throws Exception {
	try {
		return AccessController.doPrivileged(
			new PrivilegedExceptionAction<T>() {
				public T run() throws Exception {
					Thread t = Thread.currentThread();
					ClassLoader cl = t.getContextClassLoader();
					if (ccl == cl) {
						return task.call();
					} else {
						t.setContextClassLoader(ccl);
						try {
							return task.call();
						} finally {
							t.setContextClassLoader(cl);
						}
					}
				}
			}, acc);
	} catch (PrivilegedActionException e) {
		throw e.getException();
	}
}

java复制代码/**
 * A callable that runs given task and returns given result
 */
static final class RunnableAdapter<T> implements Callable<T> {
	final Runnable task;
	final T result;
	RunnableAdapter(Runnable task, T result) {
		this.task = task;
		this.result = result;
	}
	public T call() {
		task.run();
		return result;
	}
}

java复制代码private static final class TaskCallable<V> implements Callable<V> {

	private Task<V> task;
	private TaskCallable() { }

	@Override 
	public V call() throws Exception {
		task.started = true;
		task.runLater(() -> {
			task.setState(State.SCHEDULED);
			task.setState(State.RUNNING);
		});
		try {
			final V result = task.call();
			if (!task.isCancelled()) {
				task.runLater(() -> {
					task.updateValue(result);
					task.setState(State.SUCCEEDED);
				});
				return result;
			} else {
				return null;
			}
		} catch (final Throwable th) {
			task.runLater(() -> {
				task._setException(th);
				task.setState(State.FAILED);
			});
			if (th instanceof Exception) {
				throw (Exception) th;
			} else {
				throw new Exception(th);
			}
		}
	}
}

java复制代码task.started = true;
task.runLater(() -> {
	task.setState(State.SCHEDULED);
	task.setState(State.RUNNING);
});

java复制代码private final ObjectProperty<V> value = new SimpleObjectProperty<>(this, "value");

java复制代码try {
	final V result = task.call();
	if (!task.isCancelled()) {
		task.runLater(() -> {
			task.updateValue(result);
			task.setState(State.SUCCEEDED);
		});
		return result;
	} else {
		return null;
	}
}

java复制代码catch (final Throwable th) {
	task.runLater(() -> {
		task._setException(th);
		task.setState(State.FAILED);
	});
	if (th instanceof Exception) {
		throw (Exception) th;
	} else {
		throw new Exception(th);
	}
}

java复制代码public class ClassLoaderTest {
    public static void main(String[] args) throws Exception {
        //自定义类加载器
        ClassLoader myLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name)
                    throws ClassNotFoundException {
                try {
                    String fileName = name.substring(name.lastIndexOf(".") + 1)
                            + ".class";
                    InputStream is = getClass().getResourceAsStream(fileName);
                    if (is == null) {
                        return super.loadClass(name);
                    }
                    byte[] b = new byte[is.available()];
                    is.read(b);
                    return defineClass(name, b, 0, b.length);
                } catch (IOException e) {
                    throw new ClassNotFoundException(name);
                }
            }
        };
        //使用自定义类加载器来加载类ClassLoaderTest
        Class newClass = myLoader.loadClass("com.ikang.JVM.classloader.ClassLoaderTest");
        //反射获取实例
        Object obj1 = newClass.newInstance();
        //获取实例所属的类全路径名
        System.out.println(obj1.getClass());


        //原生的类加载器来加载类ClassLoaderTest
        Class<?> oldClass = ClassLoaderTest.class.getClassLoader().loadClass("com.ikang.JVM.classloader.ClassLoaderTest");
        //反射获取实例
        Object obj2 = oldClass.newInstance();
        //获取实利所属的类全路径名
        System.out.println(obj2.getClass());


        //直接获取ClassLoaderTest类的类全路径名
        System.out.println(ClassLoaderTest.class);


        /*从上面的上个输出中,开起来它们属于同一个类,但是实际上并不是,如下判断*/
        System.out.println(obj1 instanceof ClassLoaderTest);
        System.out.println(obj2 instanceof ClassLoaderTest);
    }
}

java复制代码URL[] urls = Launcher.getBootstrapClassPath().getURLs();
Arrays.stream(urls).forEach(System.out::println);
/*for (URL url : urls) {
    System.out.println(url.toExternalForm());
}*/

java复制代码file:/C:/Program%20Files/Java/jdk1.8.0_144/jre/lib/resources.jar
file:/C:/Program%20Files/Java/jdk1.8.0_144/jre/lib/rt.jar
file:/C:/Program%20Files/Java/jdk1.8.0_144/jre/lib/sunrsasign.jar
file:/C:/Program%20Files/Java/jdk1.8.0_144/jre/lib/jsse.jar
file:/C:/Program%20Files/Java/jdk1.8.0_144/jre/lib/jce.jar
file:/C:/Program%20Files/Java/jdk1.8.0_144/jre/lib/charsets.jar
file:/C:/Program%20Files/Java/jdk1.8.0_144/jre/lib/jfr.jar
file:/C:/Program%20Files/Java/jdk1.8.0_144/jre/classes

java复制代码public static void main(String[] args) {
    File[] dirs = getExtClassLoaderFile();
    //递归展示jar包
    for (File dir : dirs) {
        showFile(dir.getPath());
    }
}

/**
 * ExtClassLoader类中获取路径的代码
 * 加载<JAVA_HOME>/lib/ext目录中的类库目录
 */
static File[] getExtClassLoaderFile() {
    String s = System.getProperty("java.ext.dirs");
    File[] dirs;
    if (s != null) {
        StringTokenizer st =
                new StringTokenizer(s, File.pathSeparator);
        int count = st.countTokens();
        dirs = new File[count];
        for (int i = 0; i < count; i++) {
            dirs[i] = new File(st.nextToken());
        }
    } else {
        dirs = new File[0];
    }
    return dirs;
}

/**
 * 递归展示jar包
 */
static void showFile(String path) {
    File file = new File(path);
    if (file.exists()) {
        if (file.isFile()) {
            if (file.getName().endsWith(".jar")) {
                System.out.println(file.getAbsolutePath());
                return;
            }
        }
        File[] files = file.listFiles();
        for (File file1 : files) {
            if (file1.isFile()) {
                if (file1.getName().endsWith(".jar")) {
                    System.out.println(file1.getAbsolutePath());
                }
            } else {
                showFile(file1.getPath());
            }
        }
    }
}

java复制代码ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);

java复制代码protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // 先检查是否被加载过
        Class<?> c = findLoadedClass(name);
        //如果没被加载过
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                //如果父加载器不为null,则首先让父加载器尝试加载该类
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    //否则,使用dBootstrapClassloader来加载
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {       
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }
            //父类没有加载成功
            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                //尝试子类加载器加载
                c = findClass(name);

                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        //根据条件判断是否进行链接操作
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

csharp复制代码public FeignContext() {
	super(FeignClientsConfiguration.class, "feign", "feign.client.name");
}

typescript复制代码@Autowired(required = false)
private FeignClientProperties feignClientProperties;

@Autowired(required = false)
private List<AnnotatedParameterProcessor> parameterProcessors = new ArrayList<>();

@Autowired(required = false)
private List<FeignFormatterRegistrar> feignFormatterRegistrars = new ArrayList<>();

@Bean
@ConditionalOnMissingBean
public Contract feignContract(ConversionService feignConversionService) {
	boolean decodeSlash = feignClientProperties == null || feignClientProperties.isDecodeSlash();
	return new SpringMvcContract(this.parameterProcessors, feignConversionService, decodeSlash);
}

@Bean
public FormattingConversionService feignConversionService() {
	FormattingConversionService conversionService = new DefaultFormattingConversionService();
	for (FeignFormatterRegistrar feignFormatterRegistrar : this.feignFormatterRegistrars) {
		feignFormatterRegistrar.registerFormatters(conversionService);
	}
	return conversionService;
}

less复制代码@Data
@AllArgsConstructor
public class Student {
	private final Long id;
	private final String name;
}

typescript复制代码public class StringToStudentConverter implements Converter<String, Student> {
	@Override
	public Student convert(String from) {
		String[] split = from.split(",");
		return new Student(
				Long.parseLong(split[0]),
				split[1]);
	}
}

typescript复制代码@Configuration(proxyBeanMethods = false)
public class TestConfig implements WebMvcConfigurer {
	@Override
	public void addFormatters(FormatterRegistry registry) {
		registry.addConverter(new StringToStudentConverter());
	}
}

less复制代码@RestController
@RequestMapping("/test")
public class TestController {
	@GetMapping("/string-to-student")
	public Student stringToStudent(@RequestParam("student") Student student) {
		return student;
	}
}

json复制代码{
    "id": 1,
    "name": "zhx"
}

typescript复制代码public class StudentFormatter implements Formatter<Student> {
	@Override
	public Student parse(String text, Locale locale) throws ParseException {
		String[] split = text.split(",");
		return new Student(
				Long.parseLong(split[0]),
				split[1]);
	}

	@Override
	public String print(Student object, Locale locale) {
		return object.getId() + "," + object.getName();
	}
}

typescript复制代码@Configuration(proxyBeanMethods = false)
public class TestConfig implements WebMvcConfigurer {
	@Override
	public void addFormatters(FormatterRegistry registry) {
		registry.addFormatter(new StudentFormatter());
	}
}

typescript复制代码@Bean
public FeignFormatterRegistrar getFeignFormatterRegistrar() {
	return registry -> {
		registry.addFormatter(new StudentFormatter());
	};
}

less复制代码@FeignClient(name = "test-server", contextId = "test-server")
public interface TestClient {
	@GetMapping("/test/string-to-student")
	Student get(@RequestParam("student") Student student);
}

scss复制代码public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) {
    //获取当前参数属于方法的第几个
	int parameterIndex = context.getParameterIndex();
	//获取参数类型
	Class<?> parameterType = method.getParameterTypes()[parameterIndex];
	//要保存的解析的方法元数据 MethodMetadata
	MethodMetadata data = context.getMethodMetadata();

    //如果是 Map，则指定 queryMap 下标，直接返回
    //这代表一旦使用 Map 作为 RequestParam，则其他的 RequestParam 就会被忽略，直接解析 Map 中的参数作为 RequestParam
	if (Map.class.isAssignableFrom(parameterType)) {
		checkState(data.queryMapIndex() == null, "Query map can only be present once.");
		data.queryMapIndex(parameterIndex);
        //返回解析成功
		return true;
	}
	RequestParam requestParam = ANNOTATION.cast(annotation);
	String name = requestParam.value();
	//RequestParam 的名字不能是空
	checkState(emptyToNull(name) != null, "RequestParam.value() was empty on parameter %s", parameterIndex);
	context.setParameterName(name);
    
	Collection<String> query = context.setTemplateParameter(name, data.template().queries().get(name));
	//将 RequestParam 放入 方法元数据 MethodMetadata
	data.template().query(name, query);
	//返回解析成功
	return true;
}

typescript复制代码//由于初始化顺序以及 NamedContextFactory 的 Configuration 初始化的原因，这里需要注入 ObjectFactory 而不是直接注入 HttpMessageConverters 防止找不到 Bean
@Autowired
private ObjectFactory<HttpMessageConverters> messageConverters;

@Bean
@ConditionalOnMissingBean
public Decoder feignDecoder() { 
	return new OptionalDecoder(new ResponseEntityDecoder(new SpringDecoder(this.messageConverters)));
}

@Bean
@ConditionalOnMissingBean
@ConditionalOnMissingClass("org.springframework.data.domain.Pageable")
public Encoder feignEncoder(ObjectProvider<AbstractFormWriter> formWriterProvider) {
	return springEncoder(formWriterProvider, encoderProperties);
}

@Bean
@ConditionalOnClass(name = "org.springframework.data.domain.Pageable")
@ConditionalOnMissingBean
public Encoder feignEncoderPageable(ObjectProvider<AbstractFormWriter> formWriterProvider) {
	PageableSpringEncoder encoder = new PageableSpringEncoder(springEncoder(formWriterProvider, encoderProperties));

	if (springDataWebProperties != null) {
		encoder.setPageParameter(springDataWebProperties.getPageable().getPageParameter());
		encoder.setSizeParameter(springDataWebProperties.getPageable().getSizeParameter());
		encoder.setSortParameter(springDataWebProperties.getSort().getSortParameter());
	}
	return encoder;
}

@Bean
@ConditionalOnClass(name = "org.springframework.data.domain.Pageable")
@ConditionalOnMissingBean
public QueryMapEncoder feignQueryMapEncoderPageable() {
	return new PageableSpringQueryMapEncoder();
}