c复制代码#include<stdio.h>
//const 就是因为二维数组是定死的
int search(const int arr[4][4], int num,unsigned int* prow,unsigned int* pcol)
{
	int i = 0;
	//扫描行
	for (i = 0; i < *prow; i++)
	{
		//扫描列
		int j = 0;
		for (j = 0; j < *pcol; j++)
		{
			//与所查数比较判断，有一样的就直接返回
			if (arr[i][j] == num)
			{
				*prow = i;//把坐标传回去
				*pcol = j;
				return 1;//一次返回，之后就不看了，因为已经证明到有这个数了，没必要在做无用功了
			}
		}
	}
	return 0;
}
int main()
{
	int arr[4][4] = { {1,2,8,9},{2,4,9,12},{4,7,10,13},{6,8,11,15} };
	int num = 0;
	while (1)
	{
		unsigned int row = sizeof(arr) / sizeof(arr[0]);
		unsigned int col = sizeof(arr[0]) / sizeof(arr[0][0]);   //把row，col拉进来就是为了每次再来是更新一次
		//长宽，因为下面我们就是用row，col变量没有用其他变量
		printf("请输入你想要找的数:>");
		scanf("%d", &num);
		if (search(arr, num, &row, &col))//把长宽传地址过去用指针prow，pcol接收
		{
			printf("有这个数\n");
			printf("坐标为(%d,%d)\n", row, col);
		}
		else
		{
			printf("没有这个数\n");
		}
	}	
	return 0;
}

c复制代码#include<stdio.h>
//const 就是因为二维数组是定死的
int search(const int arr[4][4], int num,unsigned int* prow,unsigned int* pcol)
{
	int i = 0;
	unsigned int x = 0;
	unsigned int y = *pcol-1;
	while ((x<*prow)&&(y>=0))
	{
		if (arr[x][y] - num > 0)
		{
			y--;
		}
		else if (arr[x][y] - num < 0)
		{
			x++;
		}
		else
		{
			*prow = x;
			*pcol = y;
			return 1;
		}
	}
	return 0;
}
int main()
{
	int arr[4][4] = { {1,2,8,9},{2,4,9,12},{4,7,10,13},{6,8,11,15} };
	int num = 0;
	while (1)
	{
		unsigned int row = sizeof(arr) / sizeof(arr[0]);
		unsigned int col = sizeof(arr[0]) / sizeof(arr[0][0]);   //把row，col拉进来就是为了每次再来是更新一次
		//长宽，因为下面我们就是用row，col变量没有用其他变量
		printf("请输入你想要找的数:>");
		scanf("%d", &num);
		if (search(arr, num, &row, &col))//把长宽传地址过去用指针prow，pcol接收
		{
			printf("有这个数\n");
			printf("坐标为(%d,%d)\n", row, col);
		}
		else
		{
			printf("没有这个数\n");
		}
	}	
	return 0;
}

java复制代码import java.util.ArrayList;
import java.util.List;
 
public class Subject {
   
   private List observers 
      = new ArrayList();
   private int state;
 
   public int getState() {
      return state;
   }
 
   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }
 
   public void attach(Observer observer){
      observers.add(observer);      
   }
 
   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }  
}

csharp复制代码public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}

scala复制代码public class BinaryObserver extends Observer{
 
   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
      System.out.println( "Binary String: " 
      + Integer.toBinaryString( subject.getState() ) ); 
   }
}

scala复制代码public class OctalObserver extends Observer{
 
   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
     System.out.println( "Octal String: " 
     + Integer.toOctalString( subject.getState() ) ); 
   }
}

scala复制代码public class HexaObserver extends Observer{
 
   public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
      System.out.println( "Hex String: " 
      + Integer.toHexString( subject.getState() ).toUpperCase() ); 
   }
}

csharp复制代码public class ObserverPatternDemo {
   public static void main(String[] args) {
      Subject subject = new Subject();
 
      new HexaObserver(subject);
      new OctalObserver(subject);
      new BinaryObserver(subject);
 
      System.out.println("First state change: 15");   
      subject.setState(15);
      System.out.println("Second state change: 10");  
      subject.setState(10);
   }
}

yaml复制代码First state change: 15
Hex String: F
Octal String: 17
Binary String: 1111
Second state change: 10
Hex String: A
Octal String: 12
Binary String: 1010

json复制代码spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true # 默认关闭
          url-expression: "'lb://'+serviceId" #路由目标地址表达式，默认值就是"'lb://'+serviceId"
    #配置nacos注册中心
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 #地址

json复制代码@ConfigurationProperties("spring.cloud.gateway.discovery.locator")
public class DiscoveryLocatorProperties {

	//开启标识，默认关闭
	private boolean enabled = false;

	/**
	 * 路由ID前缀，默认为DiscoveryClient的类名称 {@link org.springframework.cloud.client.discovery.DiscoveryClient}
	 */
	private String routeIdPrefix;

	//是否使用SpEL表达式
	private String includeExpression = "true";

	//用来创建路由Route的uri表达式，最终会被解析为类似uri=lb://user-service，可覆盖
	private String urlExpression = "'lb://'+serviceId";

	/**
	 * Option to lower case serviceId in predicates and filters, defaults to false. Useful
	 * with eureka when it automatically uppercases serviceId. so MYSERIVCE, would match
	 * /myservice/**
	 */
	private boolean lowerCaseServiceId = false;
	
	private List<PredicateDefinition> predicates = new ArrayList<>();

	private List<FilterDefinition> filters = new ArrayList<>();

json复制代码public static List<PredicateDefinition> initPredicates() {
		ArrayList<PredicateDefinition> definitions = new ArrayList<>();
		// add a predicate that matches the url at /serviceId/**
		PredicateDefinition predicate = new PredicateDefinition();
		//设置Predicate名称，Path，DiscoveryRouteDefinition会使用PathRoutePredicateFactory
		predicate.setName(normalizeRoutePredicateName(PathRoutePredicateFactory.class));
		//设置Path参数，serviceId会在DiscoveryClientRouteDefinitionLocator#getRouteDefinition中替换为注册中心上的服务名，例如user-service
		predicate.addArg(PATTERN_KEY, "'/'+serviceId+'/**'");
		definitions.add(predicate);
		return definitions;
	}

	public static List<FilterDefinition> initFilters() {
		ArrayList<FilterDefinition> definitions = new ArrayList<>();

		// add a filter that removes /serviceId by default
		FilterDefinition filter = new FilterDefinition();
		//设置使用的过滤器，此处使用RewritePathGatewayFilterFactory，因为后边会重写请求Path
		filter.setName(normalizeFilterFactoryName(RewritePathGatewayFilterFactory.class));
		//同Predicate，会在DiscoveryClientRouteDefinitionLocator#getRouteDefinition中将'service-id'替换为注册中心上的服务名，例如 /user-service/(?<remaining>.*)
		String regex = "'/' + serviceId + '/(?<remaining>.*)'";
		String replacement = "'/${remaining}'";
		filter.addArg(REGEXP_KEY, regex);
		filter.addArg(REPLACEMENT_KEY, replacement);
		definitions.add(filter);

		return definitions;
	}

	@Bean
	public DiscoveryLocatorProperties discoveryLocatorProperties() {
		DiscoveryLocatorProperties properties = new DiscoveryLocatorProperties();
		//设置Predicate
		properties.setPredicates(initPredicates());
		//设置GatewayFilter
		properties.setFilters(initFilters());
		return properties;
	}

json复制代码@Configuration(proxyBeanMethods = false)
	@ConditionalOnProperty(value = "spring.cloud.discovery.reactive.enabled",
			matchIfMissing = true)
	public static class ReactiveDiscoveryClientRouteDefinitionLocatorConfiguration {

		/**
		 *
		 * @param discoveryClient Reactive的实现，如果使用nacos，这里注入的为 {@link com.alibaba.cloud.nacos.discovery.reactive.NacosReactiveDiscoveryClient}
		 */
		@Bean
		@ConditionalOnProperty(name = "spring.cloud.gateway.discovery.locator.enabled")
		public DiscoveryClientRouteDefinitionLocator discoveryClientRouteDefinitionLocator(
				ReactiveDiscoveryClient discoveryClient,
				DiscoveryLocatorProperties properties) {
			return new DiscoveryClientRouteDefinitionLocator(discoveryClient, properties);
		}

	}

	/**
	 * @deprecated In favor of the native reactive service discovery capability.
	 */
	@Configuration(proxyBeanMethods = false)
	@Deprecated
	@ConditionalOnProperty(value = "spring.cloud.discovery.reactive.enabled",
			havingValue = "false")
	public static class BlockingDiscoveryClientRouteDefinitionLocatorConfiguration {

		@Bean
		@ConditionalOnProperty(name = "spring.cloud.gateway.discovery.locator.enabled")
		public DiscoveryClientRouteDefinitionLocator discoveryClientRouteDefinitionLocator(
				DiscoveryClient discoveryClient, DiscoveryLocatorProperties properties) {
			return new DiscoveryClientRouteDefinitionLocator(discoveryClient, properties);
		}

	}

json复制代码public class DiscoveryClientRouteDefinitionLocator implements RouteDefinitionLocator {

	private final DiscoveryLocatorProperties properties;

	private final String routeIdPrefix;

	private final SimpleEvaluationContext evalCtxt;

	private Flux<List<ServiceInstance>> serviceInstances;

	public DiscoveryClientRouteDefinitionLocator(ReactiveDiscoveryClient discoveryClient,
			DiscoveryLocatorProperties properties) {
		this(discoveryClient.getClass().getSimpleName(), properties);
		//通过对应注册中心的discoveryClient获取到所有的服务实例
		serviceInstances = discoveryClient.getServices()
				.flatMap(service -> discoveryClient.getInstances(service).collectList());
	}

	private DiscoveryClientRouteDefinitionLocator(String discoveryClientName,
			DiscoveryLocatorProperties properties) {
		this.properties = properties;
		//判断是否有路由ID前缀，如果没有则
		if (StringUtils.hasText(properties.getRouteIdPrefix())) {
			routeIdPrefix = properties.getRouteIdPrefix();
		}
		else {
			routeIdPrefix = discoveryClientName + "_";
		}
		evalCtxt = SimpleEvaluationContext.forReadOnlyDataBinding().withInstanceMethods()
				.build();
	}

	@Override
	public Flux<RouteDefinition> getRouteDefinitions() {

		return serviceInstances.filter(instances -> !instances.isEmpty())
				.map(instances -> instances.get(0)).filter(includePredicate)
				.map(instance -> {
					//创建RouteDefinition
					RouteDefinition routeDefinition = buildRouteDefinition(urlExpr,
							instance);

					final ServiceInstance instanceForEval = new DelegatingServiceInstance(
							instance, properties);

					for (PredicateDefinition original : this.properties.getPredicates()) {
						//根据服务信息重新构建PredicateDefinition
						PredicateDefinition predicate = new PredicateDefinition();
						predicate.setName(original.getName());
						for (Map.Entry<String, String> entry : original.getArgs()
								.entrySet()) {
							//将Path参数值的service-id替换为服务名称，如/user-service/**
							String value = getValueFromExpr(evalCtxt, parser,
									instanceForEval, entry);
							predicate.addArg(entry.getKey(), value);
						}
						routeDefinition.getPredicates().add(predicate);
					}

					for (FilterDefinition original : this.properties.getFilters()) {
						FilterDefinition filter = new FilterDefinition();
						filter.setName(original.getName());
						for (Map.Entry<String, String> entry : original.getArgs()
								.entrySet()) {
							//将Filter的regex -> '/' + serviceId + '/(?<remaining>.*)' 中的serviceId替换为服务ID 如user-service
							String value = getValueFromExpr(evalCtxt, parser,
									instanceForEval, entry);
							filter.addArg(entry.getKey(), value);
						}
						routeDefinition.getFilters().add(filter);
					}

					return routeDefinition;
				});
	}

	protected RouteDefinition buildRouteDefinition(Expression urlExpr,
			ServiceInstance serviceInstance) {
		//获取服务ID，默认小写
		String serviceId = serviceInstance.getServiceId();
		RouteDefinition routeDefinition = new RouteDefinition();
		//设置路由ID
		routeDefinition.setId(this.routeIdPrefix + serviceId);
		//通过Spel解析器生成RouteUri
		String uri = urlExpr.getValue(this.evalCtxt, serviceInstance, String.class);
		routeDefinition.setUri(URI.create(uri));
		//设置元数据信息，包括权重、健康状态等
		routeDefinition.setMetadata(new LinkedHashMap<>(serviceInstance.getMetadata()));
		return routeDefinition;
	}
}

json复制代码public class RewritePathGatewayFilterFactory
		extends AbstractGatewayFilterFactory<RewritePathGatewayFilterFactory.Config> {

	/**
	 * Regexp key.
	 */
	public static final String REGEXP_KEY = "regexp";

	/**
	 * Replacement key.
	 */
	public static final String REPLACEMENT_KEY = "replacement";

	public RewritePathGatewayFilterFactory() {
		super(Config.class);
	}

	@Override
	public List<String> shortcutFieldOrder() {
		return Arrays.asList(REGEXP_KEY, REPLACEMENT_KEY);
	}

	@Override
	public GatewayFilter apply(Config config) {
		String replacement = config.replacement.replace("$\\", "$");
		return new GatewayFilter() {
			@Override
			public Mono<Void> filter(ServerWebExchange exchange,
					GatewayFilterChain chain) {
				ServerHttpRequest req = exchange.getRequest();
				//每次进行重写时，都在上下文中保留一次原址的请求URI
				addOriginalRequestUrl(exchange, req.getURI());
				String path = req.getURI().getRawPath();
				//根据配置的正则进行替换
				// regexp=/user-service/(?<remaining>.*)，replacement=$(remaining)，例如请求的Path为/user-service/api/hello，会被重写为/api/hello。
				String newPath = path.replaceAll(config.regexp, replacement);
				//基于重写后的Path构建新的请求
				ServerHttpRequest request = req.mutate().path(newPath).build();
				//将新的请求URI放入上下文中，供后边的Filter使用
				exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, request.getURI());

				return chain.filter(exchange.mutate().request(request).build());
			}

			@Override
			public String toString() {
				return filterToStringCreator(RewritePathGatewayFilterFactory.this)
						.append(config.getRegexp(), replacement).toString();
			}
		};
	}

json复制代码@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR);
		//判断上下中是否有GATEWAY_ROUTE_ATTR，在RoutePredicateHandlerMapping中放入的
		//如果没有则不执行
		if (route == null) {
			return chain.filter(exchange);
		}
		log.trace("RouteToRequestUrlFilter start");
		//获取请求的URI
		URI uri = exchange.getRequest().getURI();
		//判断是否包含编码的部分，如%
		boolean encoded = containsEncodedParts(uri);
		//获取Route的uri
		URI routeUri = route.getUri();

		//判断是否为其他类型的协议
		if (hasAnotherScheme(routeUri)) {
			// this is a special url, save scheme to special attribute
			// replace routeUri with schemeSpecificPart
			//将当前请求的schema放入上下文中
			exchange.getAttributes().put(GATEWAY_SCHEME_PREFIX_ATTR,
					routeUri.getScheme());
			routeUri = URI.create(routeUri.getSchemeSpecificPart());
		}
		//如果RouteUri以lb开头，必须请求中带有host
		if ("lb".equalsIgnoreCase(routeUri.getScheme()) && routeUri.getHost() == null) {
			// Load balanced URIs should always have a host. If the host is null it is
			// most
			// likely because the host name was invalid (for example included an
			// underscore)
			throw new IllegalStateException("Invalid host: " + routeUri.toString());
		}
		//生成RequestURL，并放入上下文中
		//使用RouteUri的scheme，如果使用lb的话，那么此处生成的mergedUrl则是lb://xxxxxx
		URI mergedUrl = UriComponentsBuilder.fromUri(uri)
				// .uri(routeUri)
				.scheme(routeUri.getScheme()).host(routeUri.getHost())
				.port(routeUri.getPort()).build(encoded).toUri();
		//将新的URL放入请求上下文
		exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, mergedUrl);
		return chain.filter(exchange);
	}

}

json复制代码@Override
	@SuppressWarnings("Duplicates")
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		URI url = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
		String schemePrefix = exchange.getAttribute(GATEWAY_SCHEME_PREFIX_ATTR);
		//如果不是lb的请求，则不执行
		if (url == null
				|| (!"lb".equals(url.getScheme()) && !"lb".equals(schemePrefix))) {
			return chain.filter(exchange);
		}
		// preserve the original url
		//保留原始的请求地址
		addOriginalRequestUrl(exchange, url);

		if (log.isTraceEnabled()) {
			log.trace("LoadBalancerClientFilter url before: " + url);
		}
		//负载均衡获取真实的服务信息
		final ServiceInstance instance = choose(exchange);

		if (instance == null) {
			throw NotFoundException.create(properties.isUse404(),
					"Unable to find instance for " + url.getHost());
		}

		URI uri = exchange.getRequest().getURI();

		// if the `lb:<scheme>` mechanism was used, use `<scheme>` as the default,
		// if the loadbalancer doesn't provide one.
		String overrideScheme = instance.isSecure() ? "https" : "http";
		if (schemePrefix != null) {
			overrideScheme = url.getScheme();
		}
		//使用最终调用服务信息构建URI
		URI requestUrl = loadBalancer.reconstructURI(
				new DelegatingServiceInstance(instance, overrideScheme), uri);

		if (log.isTraceEnabled()) {
			log.trace("LoadBalancerClientFilter url chosen: " + requestUrl);
		}
		//将请求URI放入上下文，供NettyRoutingFilter使用
		exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, requestUrl);
		return chain.filter(exchange);
	}

	protected ServiceInstance choose(ServerWebExchange exchange) {
		//此处调用RibbonLoadBalancer负载均衡获取真实服务信息
		return loadBalancer.choose(
				((URI) exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR)).getHost());
	}

json复制代码public void nacosServicesWatch() {

	// nacos doesn't support watch now , publish an event every 30 seconds.
	this.publisher.publishEvent(
			new HeartbeatEvent(this, nacosWatchIndex.getAndIncrement()));

}

csharp复制代码public abstract class AbstractCustomer {
   protected String name;
   public abstract boolean isNil();
   public abstract String getName();
}

typescript复制代码public class RealCustomer extends AbstractCustomer {
 
   public RealCustomer(String name) {
      this.name = name;    
   }
   
   @Override
   public String getName() {
      return name;
   }
   
   @Override
   public boolean isNil() {
      return false;
   }
}

scala复制代码public class NullCustomer extends AbstractCustomer {
 
   @Override
   public String getName() {
      return "Not Available in Customer Database";
   }
 
   @Override
   public boolean isNil() {
      return true;
   }
}

arduino复制代码public class CustomerFactory {
   
   public static final String[] names = {"Rob", "Joe", "Julie"};
 
   public static AbstractCustomer getCustomer(String name){
      for (int i = 0; i < names.length; i++) {
         if (names[i].equalsIgnoreCase(name)){
            return new RealCustomer(name);
         }
      }
      return new NullCustomer();
   }
}

ini复制代码public class NullPatternDemo {
   public static void main(String[] args) {
 
      AbstractCustomer customer1 = CustomerFactory.getCustomer("Rob");
      AbstractCustomer customer2 = CustomerFactory.getCustomer("Bob");
      AbstractCustomer customer3 = CustomerFactory.getCustomer("Julie");
      AbstractCustomer customer4 = CustomerFactory.getCustomer("Laura");
 
      System.out.println("Customers");
      System.out.println(customer1.getName());
      System.out.println(customer2.getName());
      System.out.println(customer3.getName());
      System.out.println(customer4.getName());
   }
}

复制代码Customers
Rob
Not Available in Customer Database
Julie
Not Available in Customer Database

yml复制代码filebeat:
spool_size: 1024                                    # 最大可以攒够 1024 条数据一起发送出去
idle_timeout: "5s"                                  # 否则每 5 秒钟也得发送一次
registry_file: "registry"                           # 文件读取位置记录文件，会放在当前工作目录下。
config_dir: "path/to/configs/contains/many/yaml"    # 如果配置过长，可以通过目录加载方式拆分配置
prospectors:                                        # 有相同配置参数的可以归类为一个 prospector
   -
       fields:
           log_source: "sample"                    # 类似logstash的 add_fields，此处的"log_source"用来标识该日志来源于哪个项目
       paths:
           - /var/log/system.log                   # 指明读取文件的位置
           - /var/log/wifi.log
       include_lines: ["^ERR", "^WARN"]            # 只发送包含这些字样的日志
       exclude_lines: ["^OK"]                      # 不发送包含这些字样的日志
   -
       document_type: "apache"                     # 定义写入ES时的 _type 值
       ignore_older: "24h"                         # 超过24小时没更新内容的文件不再监听。
       scan_frequency: "10s"                       # 每10秒钟扫描一次目录，更新通配符匹配上的文件列表
       tail_files: false                           # 是否从文件末尾开始读取
       harvester_buffer_size: 16384                # 实际读取文件时，每次读取16384字节
       backoff: "1s"                               # 每1秒检测一次文件是否有新的一行内容需要读取
       paths:
           - "/var/log/apache/*"                   # 可以使用通配符
       exclude_files: ["/var/log/apache/error.log"]
   -
       input_type: "stdin"                         # 除了 "log"，还有 "stdin"
       multiline:                                  # 多行合并
           pattern: '^[[:space:]]'
           negate: false
           match: after
output.elasticsearch:
 hosts: ["127.0.0.1:9200"]                     # The elasticsearch host

yml复制代码filebeat.inputs:
- type: log
 enabled: true
 paths:
   - D:\BaiduNetdiskDownload\jmeter\apache-jmeter-4.0\bin\jmeter.log
 multiline.pattern: ^[0-9]{4}-[0-9]{2}-[0-9]{2}
 multiline.negate: true
 multiline.match: after
output.elasticsearch:
 hosts: ["127.0.0.1:9200"]

python复制代码@decorate
def target():
	print('running target()')

# 相当于
def target():
	print('running target()')

target = decorate(target)

python复制代码functools.lru_cache(maxsize=128, typed=False)

python复制代码from functools import singledispatch
import numbers
import html

@singledispatch				#  标记处理 object 类型的基函数
def htmlize(obj):
    content = html.escape(repr(obj))
    return '<pre>{}</pre>'.format(content)

@htmlize.register(str)		# 各个专门函数使用 @«base_function».register(«type») 装饰。
def _(text):			# 专门函数的名称无关紧要；_ 是个不错的选择
    content = html.escape(text).replace('\n', '<br>\n')
    return '<p>{0}</p>'.format(content)

@htmlize.register(numbers.Integral)
def _(n):
    return '<pre>{0} (0x{0:x})</pre>'.format(n)

python复制代码registry = set()

def register(active=True):		# 接受一个可选的关键字参数
    def decorate(func):			# 真正的装饰器
        print('running register(active=%s)->decorate(%s)' % (active, func))
        
        if active:		# 只有 active 参数的值（从闭包中获取）是 True 时才注册 func
            registry.add(func)
        else:			# 如果 active 不为真，而且 func 在 registry 中，那么把它删除
            registry.discard(func)
        return func		# decorate 是装饰器，必须返回一个函数
    
    return decorate

@register(active=False)	# @register 工厂函数必须作为函数调用，并且传入所需的参数
def f1():
	print('running f1()')
    
@register()		# 即使不传入参数，register 也必须作为函数调用，即要返回真正的装饰器 decorate
def f2():
	print('running f2()')

go复制代码type Captcha struct {
	Id      string `json:"id,omitempty"`      //验证码ID
	ImgUrl  string `json:"img_url,omitempty"` //验证码图像地址
	Refresh string `json:"refresh,omitempty"` //重新获取
	Verify  string `json:"verify,omitempty"`  //验证
}

//GenerateId
/* @Description: 生成验证码Id
 * @receiver c
 * @param ctx
 */
func (c *Captcha) GenerateId(ctx *gin.Context) {
	//获取验证码验证数字长度
	var length = variable.ConfigYml.GetInt("Captcha.Length")
	//自定义验证码数字长度
	captchaId := captcha.NewLen(length)
	//提供相关信息
	c.Id = captchaId
	c.ImgUrl = captchaId + ".png"
	c.Refresh = c.ImgUrl + "?reload=1"
	c.Verify = captchaId + "/这里替换为正确的验证码进行验证"
	response.Success(ctx, "验证码信息", c)
}

go复制代码//GetImg
/* @Description: 生成验证码的图片
 * @receiver c
 * @param ctx
 */
func (c *Captcha) GetImg(ctx *gin.Context) {
	//通过param获取验证码Id
	captchaId := ctx.Param(captchaIdKey)
	//根据路径的最后一个斜杠， 将路径划分为目录部分和文件名部分。 例 http://localhost:20201/captcha/  JUpvESBqAcPxvSVz5Cy9.png
	_, file := path.Split(ctx.Request.URL.Path)
	//获取扩展名 .png
	ext := path.Ext(file)
	//获取路径上的Id
	id := file[:len(file)-len(ext)]
	//验证参数是否获取正常
	if ext == "" || captchaId == "" {
		response.Fail(ctx, http.StatusBadRequest, consts.CaptchaGetParamsInvalidCode, consts.CaptchaGetParamsInvalidMsg)
		return
	}
	//当获取到 Reload 就重新加载一个
	if ctx.Query(Reload) != "" {
		//重载为给定的验证码生成并记住新的数字。
		captcha.Reload(id)
	}
	//设置http协议
	ctx.Header("Cache-Control", "no-cache, no-store, must-revalidate")
	ctx.Header("Expires", "0")
	var vBytes bytes.Buffer
	if ext == ".png" {
		ctx.Header("Content-Type", "image/png")
		//写入图片的二进制信息
		_ = captcha.WriteImage(&vBytes, id, Width, Height)
		//读取文件内容并输出的方法
		http.ServeContent(ctx.Writer, ctx.Request, id+ext, time.Time{}, bytes.NewReader(vBytes.Bytes()))
	}
}

go复制代码//CheckCode
/* @Description: 校验验证码传来的数字
 * @receiver c
 * @param ctx
 */
func (c *Captcha) CheckCode(ctx *gin.Context) {
	//获取验证码ID 与验证码的值
	captchaId := ctx.Param(captchaIdKey)
	value := ctx.Param(captchaValueKey)
	//去存储器中进行验证
	if captcha.VerifyString(captchaId, value) {
		response.Success(ctx, consts.CaptchaCheckParamsOk)
	} else {
		response.Fail(ctx, http.StatusBadRequest, consts.CaptchaCheckParamsInvalidCode, consts.CaptchaCheckParamsInvalidMsg)
	}
}

go复制代码	// 创建一个验证码路由
	verifyCode := router.Group("captcha")
	{
		// 验证码业务，该业务无需专门校验参数，所以可以直接调用控制器
		verifyCode.GET("/", (&captcha.Captcha{}).GenerateId)                          //  获取验证码ID
		verifyCode.GET("/:captcha_id", (&captcha.Captcha{}).GetImg)                   // 获取图像地址
		verifyCode.GET("/:captcha_id/:captcha_value", (&captcha.Captcha{}).CheckCode) // 校验验证码
	}

go复制代码func init() {
	//对存储器进行自定义设置
	//设置一次清理过期验证码的数量
	collectNum := variable.ConfigYml.GetInt("Captcha.CollectNum")
	//过期时间
	expiration := variable.ConfigYml.GetDuration("Captcha.Expiration")
	// 返回一个新的标准内存存储器
	s := captcha.NewMemoryStore(collectNum, expiration)
	//设置一个新的存储器
	captcha.SetCustomStore(s)
}

go复制代码func (c *Captcha) GetAudio(ctx *gin.Context) {
	//通过param获取验证码Id
	captchaId := ctx.Param(captchaIdKey)
	//根据路径的最后一个斜杠， 将路径划分为目录部分和文件名部分。 例 http://localhost:20201/captcha/  JUpvESBqAcPxvSVz5Cy9.wav
	_, file := path.Split(ctx.Request.URL.Path)
	//获取扩展名 .wav
	ext := path.Ext(file)
	//获取路径上的Id
	id := file[:len(file)-len(ext)]
	//验证参数是否获取正常
	if ext == "" || captchaId == "" {
		response.Fail(ctx, http.StatusBadRequest, consts.CaptchaGetParamsInvalidCode, consts.CaptchaGetParamsInvalidMsg)
		return
	}
	ctx.Header("Cache-Control", "no-cache, no-store, must-revalidate")
	ctx.Header("Pragma", "no-cache")
	ctx.Header("Expires", "0")
	//当获取到 Reload 就重新加载一个
	if ctx.Query(Reload) != "" {
		//重载为给定的验证码生成并记住新的数字。
		captcha.Reload(id)
	}
	var vBytes bytes.Buffer
	if ext == ".wav" {
		ctx.Header("Content-Type", "audio/wav")
		//写入audio的二进制信息
		_ = captcha.WriteAudio(&vBytes, id, Lang)
		//读取文件内容并输出的方法
		http.ServeContent(ctx.Writer, ctx.Request, id+ext, time.Time{}, bytes.NewReader(vBytes.Bytes()))
	}
}

xml复制代码<root>
	<book bid="1">
		<author>橡皮擦（擦姐）</author>
	</book>
	<book bid="2">
		<author>橡皮擦（擦哥）</author>
	</book>
</root>

xpath复制代码/html/body/root/book[@bid=1]

xpath复制代码标签名[@属性=‘属性值’]	 # 如果是属性值为数字，去掉双引号也是可以的

python复制代码/html/body/div[2]/div[5]