arduino复制代码feign.client.config.default.connectTimeout=2000
feign.client.config.default.readTimeout=5000

ini复制代码# 单个服务 连接超时时间
feign.client.config.{这里填写服务名称}.connectTimeout = 5000
# 单个服务 读超时时间
feign.client.config.{这里填写服务名称}.readTimeout = 10000

ini复制代码#首先是开启 Hystrix
feign.hystrix.enabled = true

# 全局设置超时
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds: 30000

#服务级别设置超时
hystrix.command.{这里填写服务名称}.execution.isolation.thread.timeoutInMilliseconds: 30000

kotlin复制代码public interface MemberService {
    @RequestMapping("/getUsers")
    List<User> getUsers(String name);
}

arduino复制代码# 方法级别设置超时
hystrix.command.MemberService#getUser(String).execution.isolation.thread.timeoutInMilliseconds = 3000

go复制代码服务消费者method配置 > 服务提供者method > 服务消费者interface级配置 > 服务提供者interface级配置 > 服务消费者全局配置
注意：是否允许重试以服务提供者注解标识为最高优先级，只有服务提供方注解显示的表明可以重试，才能执行重试。如果注解没有，默认不可重试。

xml复制代码            <dependency>
                <groupId>org.example</groupId>
                <artifactId>openfeign-strengthen-plugin-annotation</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>

less复制代码 /**
             * 注解放在 interface 上,则该 interface 下所有的方法 共享该配置
             */
            @RpcInfo(connectTimeout = 2,connectTimeoutUnit = TimeUnit.SECONDS, readTimeout = 1, readTimeoutUnit = TimeUnit.SECONDS, followRedirects = false)
            public interface MemberService {
            
                /**
                 * 注解放在 method 上
                 * 则该 method  RPC调用 时使用该配置。
                 * 方法上的配置优先级大于 interface 级别,
                 * 同时存在时,以 method 上的为准
                 * connectTimeout 连接超时时间
                 * connectTimeoutUnit 连接超时时间的单位 默认为毫秒
                 * readTimeout 读取超时时间
                 * readTimeoutUnit 读取超时时间单位 默认为毫秒
                 * followRedirects 是否重定向 默认为否
                 * maxAutoRetriesNextServer 切换实例的重试次数 默认为 0 次 禁止重试
                 * maxAutoRetries 对当前实例的重试次数 默认为 0 次 禁止重试
                 * isAllowedRetry 是否允许重试 默认为 false 不允许
                 */
                @RequestMapping("/getUsers")
                @RpcInfo(connectTimeout = 2,connectTimeoutUnit = TimeUnit.SECONDS, 
                        readTimeout = 1, readTimeoutUnit = TimeUnit.SECONDS, followRedirects = false, 
                        maxAutoRetriesNextServer = 1, maxAutoRetries = 1, isAllowedRetry = true)
                List<User> getUsers(String name);
            
                @PostMapping(value = "/uploadFile", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
                @RpcInfo(connectTimeout = 5,connectTimeoutUnit = TimeUnit.SECONDS, readTimeout = 2, readTimeoutUnit = TimeUnit.SECONDS)
                String handleFileUpload(@RequestPart(value = "file") MultipartFile file);
            }

xml复制代码        <dependency>
             <groupId>org.example</groupId>
             <artifactId>openfeign-strengthen-plugin-start</artifactId>
             <version>1.0-SNAPSHOT</version>
        </dependency>

yaml复制代码  feign:
    client:
      rpcConfig:
        #单个方法维度的配置
        #接口名称 + # + 方法名称 + (参数类型, 参数类型...)
        #包名 + 接口名称 + # + 方法名称 + (参数类型, 参数类型...) com.huihuang.service.MemberService#getUsers(String)
        MemberService#getUsers(String):
          connectTimeout: 1 #连接超时
          connectTimeoutUnit: SECONDS #超时时间单位
          readTimeout: 1 #读取超时
          readTimeoutUnit: SECONDS
          followRedirects: false #是否允许重定向
          maxAutoRetries: 2 # 对当前实例的重试次数
          maxAutoRetriesNextServer: 1 # 切换实例的重试次数
        #按接口维度配置 优先级低于 单个方法维度的配置
        #接口名称
        #包名 + 接口名称 com.huihuang.service.MemberService
        MemberService:
          connectTimeout: 1 #连接超时
          connectTimeoutUnit: SECONDS #超时时间单位
          readTimeout: 1 #读取超时
          readTimeoutUnit: SECONDS
          followRedirects: false #是否允许重定向
          maxAutoRetries: 2 # 对当前实例的重试次数
          maxAutoRetriesNextServer: 1 # 切换实例的重试次数
        #全局维度配置 优先级低于 单个方法维度 和 接口维度 的配置
        default:
          connectTimeout: 1 #连接超时
          connectTimeoutUnit: SECONDS #超时时间单位
          readTimeout: 1 #读取超时
          readTimeoutUnit: SECONDS
          followRedirects: false #是否允许重定向
          maxAutoRetries: 2 # 对当前实例的重试次数
          maxAutoRetriesNextServer: 1 # 切换实例的重试次数

csharp复制代码$ ./apisix_request.sh "/public-service/public"
Defaulted container "apisix" out of: apisix, wait-etcd (init)
{"data":"public data"}

javascript复制代码$ ./apisix_request.sh "/protected-service/protected"
Defaulted container "apisix" out of: apisix, wait-etcd (init)
<html>
<head><title>403 Forbidden</title></head>
<body>
<center><h1>403 Forbidden</h1></center>
<hr><center>openresty</center>
</body>
</html>

bash复制代码请勿省略版本号
go get github.com/go-redis/redis/v8

go复制代码1、第一种
import "github.com/go-redis/redis/v8"

rdb := redis.NewClient(&redis.Options{
	Addr:	  "localhost:6379",
	Password: "", // no password set
	DB:		  0,  // use default DB
})

2、第二种
opt, err := redis.ParseURL("redis://<user>:<pass>@localhost:6379/<db>")
if err != nil {
	panic(err)
}

rdb := redis.NewClient(opt)

bash复制代码
import (
	"context"
	"github.com/go-redis/redis/v8"
	"log"
)

var rdb *redis.Client

// GetRedis 获取连接
func GetRedis() *redis.Client {
	return rdb
}

func InitRedis() {
	rdb =  redis.NewClient(&redis.Options{
		Addr:     Redis.Host + ":" + Redis.Port,
		Password: Redis.Password,
		DB:       Redis.DB,
	})
	_,err := rdb.Ping(context.Background()).Result()
	if err != nil{
		log.Printf("redis connect get failed.%v",err)
		return
	}
	log.Printf("redis init success")
}

bash复制代码1、存值
var ctx = context.Background()

func SetString(key string,value interface{}) error  {
	if key == "" || value == nil {
		return  errors.New(common.ArgsIsNull)
	}
	rdb := config.GetRedis()
	err := rdb.Set(ctx,key,value,0).Err()
	if err != nil {
		return errors.New(err.Error())
	}
	log.Infof("push key: %v, value: %v",key,value)
	return nil
}


2、取值
func GetString(key string) (interface{},error)  {
	if key == "" {
		return  "",errors.New(common.ArgsIsNull)
	}
	rdb := config.GetRedis()
	res,err := rdb.Get(ctx,key).Result()
	if err == redis.Nil{
		return "",errors.New(fmt.Sprintf(common.ResIsNull,key))
	}
	if err != nil {
		return "",errors.New(err.Error())
	}
	return res,nil
}

bash复制代码func  Test(test *testing.T)  {
	err := SetString("1", "12")
	if err != nil {
		return
	}
}
func  Test1(test *testing.T)  {
	res,err := GetString("12")
	if err != nil {
		log.Debug(err)
	}else {
		log.Debug(res)
	}
}

bash复制代码1、redis控制台
Connecting ...

Connected.
redis:0>get 1
"12"

2、代码获取
=== RUN   Test1
2021-09-03 20:30:38	DEBUG	redis/redis_test.go:40	12
--- PASS: Test1 (0.00s)
PASS

go复制代码func Receive(key ...string) error {
	if len(key) <= 0 {
		return errors.New(common.ArgsIsNull)
	}
	rdb := config.GetRedis()
	sub := rdb.Subscribe(ctx, key...)
	defer time.AfterFunc(time.Second, func() {
		_ = sub.Close()
	})
	_, err := sub.Receive(ctx)
	if err != nil {
		return errors.New(err.Error())
	}
	// 设置channel参数 https://github.com/go-redis/redis/issues/1850
	ch := sub.Channel(
		redis.WithChannelSize(100),
		redis.WithChannelHealthCheckInterval(10*time.Second),
		redis.WithChannelSendTimeout(3000 * time.Second),
	)
	for msg := range ch {
		// todo 执行操作
		fmt.Println(msg.Channel, msg.Payload)
	}
	return nil
}

go复制代码func Publish(key string, value interface{}) error {
	if key == "" || value == nil {
		return errors.New(common.ArgsIsNull)
	}
	rdb := config.GetRedis()
	err := rdb.Publish(ctx, key, value).Err()
	if err != nil {
		return errors.New(err.Error())
	}
	log.Infof("Publish key: %v, value: %v", key, value)
	return nil
}

bash复制代码type Msg struct {
	Title   string `form:"title" json:"title" binding:"required"`     // 标题
	Content string `form:"content" json:"content" binding:"required"` // 内容
}

bash复制代码redis: can't marshal *dto.Msg (implement encoding.BinaryMarshaler)

go复制代码func (m *Msg) MarshalBinary() (data []byte, err error) {
	return json.Marshal(m)
}

go复制代码func  Test3(test *testing.T)  {
	msg := &dto.Msg{Title: "123123",Content: "123123"}
	marshal, err1 := json.Marshal(msg)
	if err1 != nil {
		return
	}
	err := Publish(common.Sms,marshal)
	if err != nil {
		log.Debug(err)
	}
}

yaml复制代码stages:
  - test
  - build
  - deploy
  
  
before_script:
  - apt-get install rubygems ruby-dev -y
run-test:
  script:
    - ruby --version

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds"
   debug="false">
   <contextName>paymentContext</contextName>
   <property name="log.path" value="./logs" />
   <!--输出到控制台 -->
   <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
      <encoder>
         <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{76}.%M(%line) - %msg%n</pattern>
         <charset>UTF-8</charset>
      </encoder>
   </appender>

   <!-- 全部日志 -->
   <appender name="all" class="ch.qos.logback.core.rolling.RollingFileAppender">
      <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
         <fileNamePattern>${log.path}/ff/vv.%d{yyyy-MM-dd}.log</fileNamePattern>
         <maxHistory>60</maxHistory>
      </rollingPolicy>
      <encoder>
         <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{76}.%M(%line) - %msg%n</pattern>
         <charset>UTF-8</charset>
      </encoder>
   </appender>

   <!-- 输出到warn -->
   <appender name="warn" class="ch.qos.logback.core.rolling.RollingFileAppender">
      <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
         <fileNamePattern>${log.path}/ff/vv.warn.%d{yyyy-MM-dd}.log</fileNamePattern>
         <maxHistory>60</maxHistory>
      </rollingPolicy>
      <encoder>
         <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{76}.%M(%line) - %msg%n</pattern>
         <charset>UTF-8</charset>
      </encoder>
      <filter class="ch.qos.logback.classic.filter.LevelFilter"><!-- 只打印WARN日志 -->
         <level>WARN</level>
         <onMatch>ACCEPT</onMatch>
         <onMismatch>DENY</onMismatch>
      </filter>
   </appender>
   
   <!-- 输出到error -->
   <appender name="error" class="ch.qos.logback.core.rolling.RollingFileAppender">
      <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
         <fileNamePattern>${log.path}/ff/vv.error.%d{yyyy-MM-dd}.log</fileNamePattern>
         <maxHistory>60</maxHistory>
      </rollingPolicy>
      <encoder>
         <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{76}.%M(%line) - %msg%n</pattern>
         <charset>UTF-8</charset>
      </encoder>
      <filter class="ch.qos.logback.classic.filter.LevelFilter"><!-- 只打印ERROR日志 -->
         <level>ERROR</level>
         <onMatch>ACCEPT</onMatch>
         <onMismatch>DENY</onMismatch>
      </filter>
   </appender>

   <root level="info">
      <appender-ref ref="console" />
      <appender-ref ref="all" />
      <appender-ref ref="warn" />
      <appender-ref ref="error" />
   </root>

</configuration>

xml复制代码<build>
    <plugins>
        <plugin>
            <!--打包时去除第三方依赖-->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <layout>ZIP</layout>
                <includes>
                    <include>
                        <groupId>non-exists</groupId>
                        <artifactId>non-exists</artifactId>
                    </include>
                </includes>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <!-- 指定打包的jar包输出路径 -->
                <outputDirectory>target/hhh</outputDirectory>
                <excludes>
                    <exclude>**/static/**</exclude>
                    <exclude>**/templates/**</exclude>
                    <exclude>**/*.properties</exclude>
                    <exclude>**/*.xml</exclude>
                    <exclude>**/*.yml</exclude>
                </excludes>
                <forceCreation>true</forceCreation>
            </configuration>
        </plugin>
        <!--拷贝第三方依赖文件到指定目录-->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <!--target/lib是依赖jar包的输出目录，根据自己喜好配置-->
                        <outputDirectory>target/hhh/lib</outputDirectory>
                        <excludeTransitive>false</excludeTransitive>
                        <stripVersion>false</stripVersion>
                        <includeScope>runtime</includeScope>
                    </configuration>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-antrun-plugin</artifactId>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>run</goal>
                    </goals>
                    <configuration>
                        <target>
                            <copy todir="target/hhh/resources">
                                <fileset dir="target/classes">
                                    <exclude name="com/**" />
                                    <exclude name="org/**" />
                                    <include name="**/static/**" />
                                    <include name="**/templates/**" />
                                    <include name="**/*.properties" />
                                    <include name="**/*.xml" />
                                    <include name="**/*.yml" />
                                </fileset>
                            </copy>
                        </target>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>

    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.*</include>
            </includes>
        </resource>
    </resources>

</build>

sh复制代码#!/bin/bash
#这里可替换为你自己的执行程序，BASE_PROJECT_NAME为部署时项目基础路径(bin盛放启动脚本，项目基础路径指的是bin的上层路径),其他代码无需更改
APP_NAME=common-project-1.0-SNAPSHOT.jar

BASE_PROJECT_NAME="icp-service"

JAVA_OPTS="-server -Xms10m -Xmx20m -XX:NewRatio=2 -XX:SurvivorRatio=8 -XX:+PrintGCDetails -XX:+UseSerialGC"

#使用说明，用来提示输入参数
usage() {
echo "Usage: sh 脚本名.sh [start|stop|restart|status]"
exit 1
}

#检查程序是否在运行
is_exist(){
pid=`ps -ef|grep $APP_NAME|grep -v grep|awk '{print $2}' `
#如果不存在返回1，存在返回0
if [ -z "${pid}" ]; then
return 1
else
return 0
fi
}

#启动方法
start(){
is_exist
if [ $? -eq "0" ]; then
echo "${APP_NAME} is already running. pid=${pid} ."
else
nohup java $JAVA_OPTS -cp lib/*:resources/:../$BASE_PROJECT_NAME/$APP_NAME com.xxx.CommonApplication  >/dev/null 2>&1 &
echo "${APP_NAME} start success"
fi
}

#停止方法
stop(){
is_exist
if [ $? -eq "0" ]; then
kill -9 $pid
else
echo "${APP_NAME} is not running"
fi
}

#输出运行状态
status(){
is_exist
if [ $? -eq "0" ]; then
echo "${APP_NAME} is running. Pid is ${pid}"
else
echo "${APP_NAME} is NOT running."
fi
}

#重启
restart(){
stop
start
}

#根据输入参数，选择执行对应方法，不输入则执行使用说明
case "$1" in
"start")
start
;;
"stop")
stop
;;
"status")
status
;;
"restart")
restart
;;
*)
usage
;;
esac

java复制代码/** Return if four letter word found and responded to, otw false **/
    private boolean checkFourLetterWord(final Channel channel,
            ChannelBuffer message, final int len) throws IOException
    {
        // We take advantage of the limited size of the length to look
        // for cmds. They are all 4-bytes which fits inside of an int
        if (!FourLetterCommands.isKnown(len)) {
            return false;
        }

        String cmd = FourLetterCommands.getCommandString(len);

        channel.setInterestOps(0).awaitUninterruptibly();
        packetReceived();

        final PrintWriter pwriter = new PrintWriter(
                new BufferedWriter(new SendBufferWriter()));

        // ZOOKEEPER-2693: don't execute 4lw if it's not enabled.
        // 根据代码可以看到这个地方是用来判断是否启用这个指令，如果不启用，就会返回这条信息。
        if (!FourLetterCommands.isEnabled(cmd)) {
            LOG.debug("Command {} is not executed because it is not in the whitelist.", cmd);
            NopCommand nopCmd = new NopCommand(pwriter, this, cmd +
                    " is not executed because it is not in the whitelist.");
            nopCmd.start();
            return true;
        }

        LOG.info("Processing " + cmd + " command from "
                + channel.getRemoteAddress());

       if (len == FourLetterCommands.setTraceMaskCmd) {
            ByteBuffer mask = ByteBuffer.allocate(8);
            message.readBytes(mask);
            mask.flip();
            long traceMask = mask.getLong();
            ZooTrace.setTextTraceLevel(traceMask);
            SetTraceMaskCommand setMask = new SetTraceMaskCommand(pwriter, this, traceMask);
            setMask.start();
            return true;
        } else {
            CommandExecutor commandExecutor = new CommandExecutor();
            return commandExecutor.execute(this, pwriter, len, zkServer,factory);
        }
    }

java复制代码 /**
     * Check if the specified command is enabled.
     *
     * In ZOOKEEPER-2693 we introduce a configuration option to only
     * allow a specific set of white listed commands to execute.
     * A command will only be executed if it is also configured
     * in the white list.
     *
     * @param command The command string.
     * @return true if the specified command is enabled
     */
    public synchronized static boolean isEnabled(String command) {
        // whiteListInitialized这个值不用关心，它就是是否初始化过的标记，默认是false，第一次进入这个方法体后，whiteListedCommands相关命令加载完成后，就认为初始化完成了，这个值就为true了
        if (whiteListInitialized) {
            return whiteListedCommands.contains(command);
        }

        // 根据下面这几行代码，便可以看出，这些４字指令，是配置在ＶＭ变量内的，而key值是ZOOKEEPER_4LW_COMMANDS_WHITELIST，其实它的常量定义在最上面，这个常量的值为：zookeeper.4lw.commands.whitelist
        //看下面的代码便知道，４字指令的格式是用逗号（,）分隔，也可以直接用*，则会把cmd2String里已经缓存的所有指令，迭代的添加到whiteListedCommands这个白名单里
        String commands = System.getProperty(ZOOKEEPER_4LW_COMMANDS_WHITELIST);
        if (commands != null) {
            String[] list = commands.split(",");
            for (String cmd : list) {
                if (cmd.trim().equals("*")) {
                    for (Map.Entry<Integer, String> entry : cmd2String.entrySet()) {
                        whiteListedCommands.add(entry.getValue());
                    }
                    break;
                }
                if (!cmd.trim().isEmpty()) {
                    whiteListedCommands.add(cmd.trim());
                }
            }
        }

        // It is sad that isro and srvr are used by ZooKeeper itself. Need fix this
        // before deprecating 4lw.
        if (System.getProperty("readonlymode.enabled", "false").equals("true")) {
            whiteListedCommands.add("isro");
        }
        // zkServer.sh depends on "srvr".
        whiteListedCommands.add("srvr");
        whiteListInitialized = true;
        LOG.info("The list of known four letter word commands is : {}", Arrays.asList(cmd2String));
        LOG.info("The list of enabled four letter word commands is : {}", Arrays.asList(whiteListedCommands));
        return whiteListedCommands.contains(command);
    }

java复制代码    // specify all of the commands that are available
    static {
        cmd2String.put(confCmd, "conf");
        cmd2String.put(consCmd, "cons");
        cmd2String.put(crstCmd, "crst");
        cmd2String.put(dirsCmd, "dirs");
        cmd2String.put(dumpCmd, "dump");
        cmd2String.put(enviCmd, "envi");
        cmd2String.put(getTraceMaskCmd, "gtmk");
        cmd2String.put(ruokCmd, "ruok");
        cmd2String.put(setTraceMaskCmd, "stmk");
        cmd2String.put(srstCmd, "srst");
        cmd2String.put(srvrCmd, "srvr");
        cmd2String.put(statCmd, "stat");
        cmd2String.put(wchcCmd, "wchc");
        cmd2String.put(wchpCmd, "wchp");
        cmd2String.put(wchsCmd, "wchs");
        cmd2String.put(mntrCmd, "mntr");
        cmd2String.put(isroCmd, "isro");
        cmd2String.put(telnetCloseCmd, "telnet close");
    }

bash复制代码    ZOOMAIN="-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=$JMXPORT -Dcom.sun.management.jmxremote.authenticate=$JMXAUTH -Dcom.sun.management.jmxremote.ssl=$JMXSSL -Dzookeeper.jmx.log4j.disable=$JMXLOG4J org.apache.zookeeper.server.quorum.QuorumPeerMain"
  fi
else
    echo "JMX disabled by user request" >&2
    ZOOMAIN="org.apache.zookeeper.server.quorum.QuorumPeerMain"
fi
# 这里就是我添加的
# 如果不想添加在这里，注意位置和赋值的顺序
ZOOMAIN="-Dzookeeper.4lw.commands.whitelist=* ${ZOOMAIN}"

arduino复制代码public interface Expression {
   public boolean interpret(String context);
}

kotlin复制代码public class TerminalExpression implements Expression {
   
   private String data;
 
   public TerminalExpression(String data){
      this.data = data; 
   }
 
   @Override
   public boolean interpret(String context) {
      if(context.contains(data)){
         return true;
      }
      return false;
   }
}

java复制代码public class OrExpression implements Expression {
    
   private Expression expr1 = null;
   private Expression expr2 = null;
 
   public OrExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {      
      return expr1.interpret(context) || expr2.interpret(context);
   }
}

java复制代码public class AndExpression implements Expression {
    
   private Expression expr1 = null;
   private Expression expr2 = null;
 
   public AndExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {      
      return expr1.interpret(context) && expr2.interpret(context);
   }
}

java复制代码public class InterpreterPatternDemo {
 
   //规则：Robert 和 John 是男性
   public static Expression getMaleExpression(){
      Expression robert = new TerminalExpression("Robert");
      Expression john = new TerminalExpression("John");
      return new OrExpression(robert, john);    
   }
 
   //规则：Julie 是一个已婚的女性
   public static Expression getMarriedWomanExpression(){
      Expression julie = new TerminalExpression("Julie");
      Expression married = new TerminalExpression("Married");
      return new AndExpression(julie, married);    
   }
 
   public static void main(String[] args) {
      Expression isMale = getMaleExpression();
      Expression isMarriedWoman = getMarriedWomanExpression();
 
      System.out.println("John is male? " + isMale.interpret("John"));
      System.out.println("Julie is a married women? " 
      + isMarriedWoman.interpret("Married Julie"));
   }
}

csharp复制代码John is male? true
Julie is a married women? true

rust复制代码fn main() {
    let arr = vec![1, 2, 3];
    let new_arr = arr;

    // 无奖竞猜，打印啥
    println!("{:?}", arr);
}

js复制代码const { config } = require('@swc/core/spack');

module.exports = config({
  entry: {
    web: './src/index.js',
    // 可以配置多入口
  },
  output: {
    path: './bundle/',
  },
  module: {},
  options:{},
});

js复制代码const Visitor = require('@swc/core/Visitor').default;
const { transformSync } = require('@swc/core');

module.exports = class ConsoleStripper extends Visitor {
  visitCallExpression(expression) {
    if (expression.callee.type !== 'MemberExpression') {
      return expression;
    }
    // 判断代码类型以及对应的value是否为console
    if (
      expression.callee.object.type === 'Identifier' &&
      expression.callee.object.value === 'console'
    ) {
      // 如果是就替换为`void 0`
      if (expression.callee.property.type === 'Identifier') {
        return {
          type: 'UnaryExpression',
          span: expression.span,
          operator: 'void',
          argument: {
            type: 'NumericLiteral',
            span: expression.span,
            value: 0,
          },
        };
      }
    }

    return expression;
  }
};

const out = transformSync(
  `
if (foo) {
    console.log("Foo")
} else {
    console.log("Bar")
}`,
  {
    plugin: (m) => new ConsoleStripper().visitProgram(m),
  }
);

js复制代码transformSync(src, options) {
  
        // ...
  
        const { plugin } = options, newOptions = __rest(options, ["plugin"]);
  	// 是否有plugin
        if (plugin) {
            const m = typeof src === "string" ? this.parseSync(src, (_c = options === null || options === void 0 ? void 0 : options.jsc) === null || _c === void 0 ? void 0 : _c.parser, options.filename) : src;
            return this.transformSync(plugin(m), newOptions);
        }
  	// 最终的输出都是bindings.transformSync
        return bindings.transformSync(isModule ? JSON.stringify(src) : src, isModule, toBuffer(newOptions));
    }

js复制代码function loadBinding(dirname, filename = 'index', packageName) {
   
    // 获取系统信息
    const triples = triples_1.platformArchTriples[PlatformName][ArchName];
    
    // 遍历系统信息
    for (const triple of triples) {
        if (packageName) {
            try {
                // 获取到需要加载的二进制文件路径
                // /Users/xx/swc-demo/node_modules/@swc/core-darwin-x64/swc.darwin-x64.node
                return require(
                  require.resolve(
                    `${packageName}-${triple.platformArchABI}`,
                    { paths: [dirname] }
                  ));
            }
            catch (e) {
               // ...
            }
        }
       // ...
}