java复制代码@Entity
public class User {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    private String username;
    private String password;
}

java复制代码@Entity
public class AuthCode {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    private String username;
    private String code;   
}

java复制代码CREATE TABLE IF NOT EXISTS `spring_security_demo`.`user` (
    `id` INT NOT NULL AUTO_INCREMENT,
    `username` VARCHAR(45) NULL,
    `password` TEXT NULL,
    PRIMARY KEY (`id`));
 
CREATE TABLE IF NOT EXISTS `spring_security_demo`.`auth_code` (
    `id` INT NOT NULL AUTO_INCREMENT,
    `username` VARCHAR(45) NOT NULL,
    `code` VARCHAR(45) NULL,
    PRIMARY KEY (`id`));
)

java复制代码@RestController
public class AuthController {
 
    @Autowired
    private UserService userService;
 
    //添加User
    @PostMapping("/user/add")
    public void addUser(@RequestBody User user) {
        userService.addUser(user);
    }
 
    //通过用户名+密码对用户进行首次认证
    @PostMapping("/user/auth")
    public void auth(@RequestBody User user) {
        userService.auth(user);
    }
 
    //通过用户名+认证码进行二次认证
    @PostMapping("/authcode/check")
    public void check(@RequestBody AuthCode authCode, HttpServletResponse response) {
        if (userService.check(authCode)) {
            response.setStatus(HttpServletResponse.SC_OK);
        } else {
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        }
    }
}

java复制代码public void auth(User user) {
        Optional<User> o =
                userRepository.findUserByUsername(user.getUsername());
 
        if(o.isPresent()) {
            User u = o.get();
            if (passwordEncoder.matches(user.getPassword(), u.getPassword())) {
                 //生成或刷新认证码
                generateOrRenewAutoCode(u);
            } else {
                throw new BadCredentialsException("Bad credentials.");
            }
        } else {
            throw new BadCredentialsException("Bad credentials.");
        }
}

java复制代码private void generateOrRenewAutoCode (User u) {
        String generatedCode = GenerateCodeUtil.generateCode();
 
        Optional<AuthCode> autoCode = autoCodeRepository.findAuthCodeByUsername(u.getUsername());
        if (autoCode.isPresent()) {//如果存在认证码，则刷新该认证码
            AuthCode code = autoCode.get();
            code.setCode(generatedCode);
        } else {//如果没有找到认证码，则生成并保存一个新的认证码
            AuthCode code = new AuthCode();
            code.setUsername(u.getUsername());
            code.setCode(generatedCode);
            autoCodeRepository.save(code);
        }
}

java复制代码public boolean check(AuthCode authCodeToValidate) {
        Optional<AuthCode> authCode = autoCodeRepository.findAuthCodeByUsername(authCodeToValidate.getUsername());
        if (authCode.isPresent()) {
            AuthCode authCodeInStore = authCode.get();
            if (authCodeToValidate.getCode().equals(authCodeInStore.getCode())) {
                return true;
            }
        }
 
        return false;
}

ini复制代码//在class类中使用, XXX代表的是当前类的类名.
Logger logger = LoggerFactory.getLogger(XXX.class);

ini复制代码Logger logger = LoggerFactory.getLogger(this.getClass());

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">

    <!--定义日志文件的存储地址 尽量不要在 LogBack 的配置中使用相对路径-->
    <property name="LOG_HOME" value="${LOG_PATH:-.}" />

    <!--控制台日志， 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度,%msg：日志消息，%n是换行符-->
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>


    <appender name="FILE_ROLL" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 追加日志到原文件结尾 -->
        <Prudent>true</Prudent>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名 每小时生成日志文件-->
            <FileNamePattern>${LOG_HOME}/%d{yy-MM-dd}/asdfsdafasdf.%d{yyyy-MM-dd-HH}.%i.log</FileNamePattern>
            <!--日志文件保留天数-->
            <MaxHistory>30</MaxHistory>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <!-- 除按日志记录之外，还配置了日志文件不能超过10M(默认)，若超过10M，日志文件会以索引0开始， -->
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %method 方法名  %L 行数 %msg：日志消息，%n是换行符-->
            <pattern> %d{HH:mm:ss.SSS} [%thread] %-5level %logger{56}.%method:%L - %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder>
    </appender>

 <!-- 异步输出 -->
   <appender name="ASYNC_FILE_ROLL" class="ch.qos.logback.classic.AsyncAppender">
            <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
            <discardingThreshold>0</discardingThreshold>
            <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
            <queueSize>256</queueSize>
            <!-- 添加附加的appender,最多只能添加一个 -->
            <appender-ref ref="FILE_ROLL"/>
   </appender>


    <!--指定某些类只输出某种级别-->
    <logger name="java.sql.PreparedStatement" level="DEBUG"/>
    <logger name="org.apache.http" level="WARN"/>
    <logger name="ch.qos.logback" level="WARN"/>
    <logger name="o.s.c.annotation" level="INFO"/>
    <logger name="org.springframework.jndi" level="INFO"/>

    <!-- 日志输出级别 -->
    <root level="debug">
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="ASYNC_FILE_ROLL"/>
    </root>

</configuration>

yaml复制代码logging:
  file:
    path: ./logs/

arduino复制代码    作者：ZOUZDC
    链接：https://juejin.cn/post/7028963866063306760
    来源：稀土掘金
    著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

ini复制代码# log_bin是ON，就说明打开了 OFF就是关闭状态。
show variables like 'log_bin';
# log_bin相关的内容都能查到
show variables like '%log_bin%';
​
# 设置开启log_bin 一般情况下都是通过配置进行设置
SET SQL_LOG_BIN=1

sql复制代码show variables like '%datadir%';

ini复制代码# 日志格式
# Statement模式，每一条会修改数据的sql都会记录在binlog中。
# Row模式，5.1.5版本的MySQL才开始支持row,它不记录sql语句上下文相关信息，仅保存哪条记录被修改。
# Mixed模式，一般的语句修改使用statment格式保存binlog，如一些函数，statement无法完成主从复制的操作，则采用row格式保存binlog，MySQL会根据执行的每一条具体的sql语句来区分对待记录的日志形式，也就是在Statement和Row之间选择一种。
# 设置日志格式
binlog_format = mixed
​
# 设置日志路径，需要注意的是该路经需要mysql用户有写权限
log-bin = /data/mysql/logs/mysql-bin.log
​
# 设置binlog清理时间
expire_logs_days = 7
​
# binlog每个日志文件大小
max_binlog_size = 100m
​
# binlog缓存大小
binlog_cache_size = 4m
​
# 最大binlog缓存大小
max_binlog_cache_size = 512m

sql复制代码"Host=xxxx;Port=5432;Database=postgres;Username=postgres;Password=xxxxx;"

typescript复制代码@Slf4j
public class Main {
    public static void main(String[] args) throws Exception {
        //A服务的数据
        Map<Long,String> mp = new HashMap<>();
        Long l = 123456789000L;
        mp.put(l,"123");
        log.info("key：{}",l);

        // B服务通过网络请求得到A服务的响应文本
        String s1 = JSON.toJSONString(mp);
        log.info("json文本：{}",s1);

        // 将文本转换成Map对象
        Map<Long,String> mp2 = JSON.parseObject(s1,Map.class);
        log.info("json文本转换的Map对象：{}",mp2);

        // 通过key取值
        log.info("通过key：{}得到的值：{}",l,mp2.get(l));
    }
}

typescript复制代码public class Main {
    public static void main(String[] args) throws Exception {
        //A服务的数据
        Map<Long,String> mp = new HashMap<>();
        Long l = 123456789L;
        mp.put(l,"123");

        // B服务通过网络请求得到A服务的响应文本
        String s1 = JSON.toJSONString(mp);
        log.info("json文本：{}",s1);

        // 将文本转换成Map对象
        Map<Long,String> mp2 = JSON.parseObject(s1,Map.class);
        log.info("json文本转换的Map对象：{}",mp2);

        // 通过key取值
        log.info("通过key：{}得到的值：{}",l,mp2.get(l));
    }
}

javascript复制代码Map<Long,String> mp2 = JSON.parseObject(s1,Map.class);

go复制代码        if (negative) {
            if (i > this.np + 1) {
                if (result >= -2147483648L && type != 76) {
                    if (type == 83) {
                        return (short)((int)result);
                    } else if (type == 66) {
                        return (byte)((int)result);
                    } else {
                        return (int)result;
                    }
                } else {
                    return result;
                }
            } else {
                throw new NumberFormatException(this.numberString());
            }
        } else {
            result = -result;
            if (result <= 2147483647L && type != 76) {
                if (type == 83) {
                    return (short)((int)result);
                } else if (type == 66) {
                    return (byte)((int)result);
                } else {
                    return (int)result;
                }
            } else {
                return result;
            }
        }

javascript复制代码Map<Long,String> mp2 = JSON.parseObject(s1,new TypeReference<Map<Long,String>>(){});

typescript复制代码@RestController
@RequestMapping("/a")
public class TestController {

    @GetMapping("/b")
    public Map<Long, String> b() {
        Map<Long, String> mp = new HashMap<>();
        mp.put(1L,"123");
        mp.put(123456789L,"456");
        mp.put(123456789000L,"789");
        return mp;
    }
}

dart复制代码@Autowired
RestTemplate restTemplate;

@Test
public void restTemplate() throws Exception {
    ParameterizedTypeReference<Map<Long, String>> typeRef = new ParameterizedTypeReference<Map<Long, String>>() {};
    Map<Long, String> mp = restTemplate.exchange("http://127.0.0.1:8080/a/b", HttpMethod.GET, new HttpEntity<>(null), typeRef).getBody();

    log.info("mp:{}", mp);
    log.info("获取key为:{} 的值：{}",1L,mp.get(1L));
    log.info("获取key为:{} 的值：{}",123456789L,mp.get(123456789L));
    log.info("获取key为:{} 的值：{}",123456789000L,mp.get(123456789000L));
}

json复制代码// 公共部分
{
    "code":0,
    "msg":"成功",
    "data":{
        // 业务数据
    }
}

kotlin复制代码@Data
public class BaseBean<T> {
    private Integer code;

    private String msg;

    private T data;
}

sql复制代码@GetMapping("/user")
public BaseBean<User> user() {
    // 这里去获取User
    BaseBean<User> user = new BaseBean<>();
    return user;
}

swift复制代码@GetMapping("/goods")
public BaseBean<Goods> goods() {
    // 这里去获取商品
    BaseBean<Goods> goods = new BaseBean<>();
    return user;
}

xml复制代码<!--easy rules核心库-->
<dependency>
    <groupId>org.jeasy</groupId>
    <artifactId>easy-rules-core</artifactId>
    <version>4.1.0</version>
</dependency>

<!--规则定义文件格式，支持json,yaml等-->
<dependency>
    <groupId>org.jeasy</groupId>
    <artifactId>easy-rules-support</artifactId>
    <version>4.1.0</version>
</dependency>

<!--支持mvel规则语法库-->
<dependency>
    <groupId>org.jeasy</groupId>
    <artifactId>easy-rules-mvel</artifactId>
    <version>4.1.0</version>
</dependency>

scss复制代码RulesEngineParameters parameters = new RulesEngineParameters() 
    .rulePriorityThreshold(10) 
    .skipOnFirstAppliedRule(true) 
    .skipOnFirstFailedRule(true) 
    .skipOnFirstNonTriggeredRule(true); 
RulesEngine rulesEngine = new DefaultRulesEngine(parameters);

typescript复制代码public class RuleClass {

    @Rule(priority = 1)
    public static class FizzRule {
        @Condition
        public boolean isFizz(@Fact("number") Integer number) {
            return number % 5 == 0;
        }

        @Action
        public void printFizz() {
            System.out.print("fizz");
        }
    }

    @Rule(priority = 2)
    public static class BuzzRule {
        @Condition
        public boolean isBuzz(@Fact("number") Integer number) {
            return number % 7 == 0;
        }

        @Action
        public void printBuzz() {
            System.out.print("buzz");
        }
    }

    public static class FizzBuzzRule extends UnitRuleGroup {

        public FizzBuzzRule(Object... rules) {
            for (Object rule : rules) {
                addRule(rule);
            }
        }

        @Override
        public int getPriority() {
            return 0;
        }
    }

    @Rule(priority = 3)
    public static class NonFizzBuzzRule {

        @Condition
        public boolean isNotFizzNorBuzz(@Fact("number") Integer number) {
            // can return true, because this is the latest rule to trigger according to
            // assigned priorities
            // and in which case, the number is not fizz nor buzz
            return number % 5 != 0 || number % 7 != 0;
        }

        @Action
        public void printInput(@Fact("number") Integer number) {
            System.out.print(number);
        }
    }

}

java复制代码
public class RuleClient {
    public static void main(String[] args) {
        // create a rules engine
        RulesEngineParameters parameters = new RulesEngineParameters().skipOnFirstAppliedRule(true);
        RulesEngine fizzBuzzEngine = new DefaultRulesEngine(parameters);

        // create rules
        Rules rules = new Rules();
        rules.register(new FizzRule());
        rules.register(new BuzzRule());
        rules.register(new RuleClass.FizzBuzzRule(new RuleClass.FizzRule(), new RuleClass.BuzzRule()));
        rules.register(new NonFizzBuzzRule());

        // fire rules
        Facts facts = new Facts();
        for (int i = 1; i <= 100; i++) {
            facts.put("number", i);
            fizzBuzzEngine.fire(rules, facts);
            System.out.println();
        }
    }

}

scss复制代码Rule rule = new RuleBuilder()
    .name("myRule")
    .description("myRuleDescription")
    .priority(3)
    .when(condition)
    .then(action1)
    .then(action2)
    .build();

yaml复制代码---
name: "three"
description: "print three"
priority: 0
condition: "number % 3 == 0"
actions:
 - "System.out.println("three")"
 
---
name: "five"
description: "print five"
priority: 1
condition: "number % 5 == 0"
actions:
 - "System.out.println("five")"
 
---
name: "seven"
description: "print seven"
priority: 2
condition: "number % 7 == 0"
actions:
 - "System.out.println("seven")"
 
---
name: "itself"
description: "print the number itself otherwise"
priority: 3
condition: "true"
actions:
 - "System.out.println(number)"

java复制代码
public class RuleClient {

    public static void main(String[] args) throws FileNotFoundException {
        RulesEngine rulesEngine = new DefaultRulesEngine();
        Rules rules = MVELRuleFactory.createRulesFrom(new FileReader("rules.yml"));

        Facts facts = new Facts();
        for (int i = 1; i <= 20; i++) {
            System.out.println("====== " + i + " ======");
            facts.put("number", i);
            rulesEngine.fire(rules, facts);
        }
    }
}

scss复制代码
public class MVELTestRule {

    public static void main(String[] args) {

        //规则引擎
//        RulesEngine rulesEngine = new DefaultRulesEngine();
        DefaultRulesEngine rulesEngine = new DefaultRulesEngine();
        rulesEngine.registerRuleListener(new MyRuleListener());

//        ((DefaultRulesEngine) rulesEngine).registerRuleListener(new MyRuleListener());

        //规则
        MVELRule ageRule = new MVELRule()
                .name("my rule")
                .description("test demo rule")
                .priority(1)
                .when("user.age > 18")
                .then("map.put('code',200);map.put('msg','success');myResult.setCode('200');myResult.setMsg('success');");

        Rules rules = new Rules();
        rules.register(ageRule);

        Facts facts = new Facts();

        User user   = new User();
        user.setAge(19);
        facts.put("user", user);
        Map<String, String> map  = new HashMap();
        MyResult myResult = new MyResult();
        facts.put("map", map);
        facts.put("myResult", myResult);

        rulesEngine.fire(rules, facts);
        System.out.println(map);
        System.out.println(myResult);

    }
}

typescript复制代码public class MyRuleListener implements RuleListener {

    @Override
    public boolean beforeEvaluate(Rule rule, Facts facts) {
      return true;  
    }

    @Override
    public void afterEvaluate(Rule rule, Facts facts, boolean b) {
       System.out.println("---MyRuleListener------afterEvaluate-----");
    }

    @Override
    public void beforeExecute(Rule rule, Facts facts) {
      System.out.println("---MyRuleListener------beforeExecute-----");
    }

    @Override
    public void onSuccess(Rule rule, Facts facts) {
 
      System.out.println("---MyRuleListener------onSuccess-----");
    }

    @Override
    public void onFailure(Rule rule, Facts facts, Exception e) {
       System.out.println("---MyRuleListener------onFailure-----");
    }
 
 }

scss复制代码  ((DefaultRulesEngine) rulesEngine).registerRuleListener(new MyRuleListener());

typescript复制代码public class MyRulesEngineListener implements RulesEngineListener {
    @Override
    public void beforeEvaluate(Rules rules, Facts facts) {
        System.out.println("---MyRulesEngineListener------beforeEvaluate-----");
    }

    @Override
    public void afterExecute(Rules rules, Facts facts) {
        System.out.println("---MyRulesEngineListener------afterExecute-----");
    }
}

scss复制代码((DefaultRulesEngine) rulesEngine).registerRulesEngineListener(new MyRulesEngineListener());

scss复制代码// create facts
Facts facts = new Facts();

// create rules
Rules rules = new Rules();
rules.register(new HelloWorldRule());

// create a rules engine and fire rules on known facts
RulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.fire(rules, facts);

java复制代码public interface Appendable {

    Appendable append(CharSequence csq) throws IOException;

    Appendable append(CharSequence csq, int start, int end) throws IOException;

    Appendable append(char c) throws IOException;
}

java复制代码abstract class AbstractStringBuilder implements Appendable, CharSequence {
    
    @Override
    public AbstractStringBuilder append(CharSequence s) {
        ...
    }

    @Override
    public AbstractStringBuilder append(CharSequence s, int start, int end) {
        ...
    }

    @Override
    public AbstractStringBuilder append(char c) {
        ...
    }
}

java复制代码public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{

    @Override
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }

    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
    ...
}

xml复制代码 <dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>1.2.2.RELEASE</version>
 </dependency>

java复制代码@Slf4j
public class RetryDemo {

    public static boolean retryMethod(Integer param) {
        int i = new Random().nextInt(param);
        log.info("随机生成的数:{}", i);

        if (1 == i) {
            log.info("为1,返回true.");
            return true;
        } else if (i < 1) {
            log.info("小于1,抛出参数异常.");
            throw new IllegalArgumentException("参数异常");
        } else if (i > 1 && i < 10) {
            log.info("大于1,小于10,抛出参数异常.");
            return false;
        } else {
            //为其他
            log.info("大于10,抛出自定义异常.");
            throw new RemoteAccessException("大于10,抛出自定义异常");
        }
    }

}

java复制代码@Slf4j
public class SpringRetryTest {

    /**
     * 重试间隔时间ms,默认1000ms
     */
    private long fixedPeriodTime = 1000L;
    /**
     * 最大重试次数,默认为3
     */
    private int maxRetryTimes = 3;
    /**
     * 表示哪些异常需要重试
     * key一定要为Throwable异常的子类    Class<? extends Throwable>
     * value为true表示需要重试
     */
    private Map<Class<? extends Throwable>, Boolean> exceptionMap = new HashMap<>();


    @Test
    public void test() {

        // 1 添加异常的处理结果 true为需要重试 false为不需要重试
        exceptionMap.put(RemoteAccessException.class, true);

        // 2 构建重试模板实例
        RetryTemplate retryTemplate = new RetryTemplate();

        // 3 设置重试回退操作策略  设置重试间隔时间
        FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
        backOffPolicy.setBackOffPeriod(fixedPeriodTime);

        // 4 设置重试策略  设置重试次数 设置异常处理结果
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(maxRetryTimes, exceptionMap);

        //5 重试模板添加重试策略 添加回退操作策略
        retryTemplate.setRetryPolicy(retryPolicy);
        retryTemplate.setBackOffPolicy(backOffPolicy);
    
        // 6 调用方法
        Boolean resp = retryTemplate.execute(
                // RetryCallback 重试回调方法
                retryContext -> {
                    boolean result = RetryDemo.retryMethod(110);
                    log.info("方法返回结果= {}", result);
                    return result;
                },
                // RecoveryCallback 异常回调方法
                retryContext -> {
                    //
                    log.info("超过最大重试次数或者抛出了未定义的异常!!!");
                    return false;
                }
        );

        log.info("接口返回结果 = {}",resp);

    }

}
/*
	// 查看结果
	[main] INFO com.cf.demo.SpringRetry.SpringRetryTest - 超过最大重试次数或者抛出了未定义的异常!!!
	[main] INFO com.cf.demo.SpringRetry.SpringRetryTest - 接口返回结果 = false
*/

java复制代码	/**
	 * Keep executing the callback until it either succeeds or the policy dictates that we
	 * stop, in which case the recovery callback will be executed.
	 *
	 * @see RetryOperations#execute(RetryCallback, RecoveryCallback)
	 * @param retryCallback the {@link RetryCallback}
	 * @param recoveryCallback the {@link RecoveryCallback}
	 * @throws TerminatedRetryException if the retry has been manually terminated by a
	 * listener.
	 */
	@Override
	public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback,
			RecoveryCallback<T> recoveryCallback) throws E {
		return doExecute(retryCallback, recoveryCallback, null);
	}

java复制代码	/**
	 * Setter for {@link RetryPolicy}.
	 *
	 * @param retryPolicy the {@link RetryPolicy}
	 */
	public void setRetryPolicy(RetryPolicy retryPolicy) {
		this.retryPolicy = retryPolicy;
	}

java复制代码AlwaysRetryPolicy：允许无限重试，直到成功，可能会导致死循环

CircuitBreakerRetryPolicy：有熔断功能的重试策略，需设置3个参数openTimeout、resetTimeout和delegate

CompositeRetryPolicy：组合重试策略，有两种组合方式，乐观组合重试策略是指只要有一个策略允许即可以重试，
悲观组合重试策略是指只要有一个策略不允许即可以重试，但不管哪种组合方式，组合中的每一个策略都会执行
    
ExceptionClassifierRetryPolicy：设置不同异常的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试
    
NeverRetryPolicy：只允许调用RetryCallback一次，不允许重试
    
SimpleRetryPolicy：固定次数重试策略，默认重试最大次数为3次，RetryTemplate默认使用的策略

TimeoutRetryPolicy：超时时间重试策略，默认超时时间为1秒，在指定的超时时间内允许重试

java复制代码	/**
	 * Setter for {@link BackOffPolicy}.
	 *
	 * @param backOffPolicy the {@link BackOffPolicy}
	 */
	public void setBackOffPolicy(BackOffPolicy backOffPolicy) {
		this.backOffPolicy = backOffPolicy;
	}

java复制代码ExponentialBackOffPolicy：指数退避策略，需设置参数sleeper、initialInterval、maxInterval和multiplier，initialInterval指定初始休眠时间，默认100毫秒，maxInterval指定最大休眠时间，默认30秒，multiplier指定乘数，即下一次休眠时间为当前休眠时间*multiplier

ExponentialRandomBackOffPolicy：随机指数退避策略，引入随机乘数可以实现随机乘数回退

FixedBackOffPolicy：固定时间的退避策略，需设置参数sleeper和backOffPeriod，sleeper指定等待策略，默认是Thread.sleep，即线程休眠，backOffPeriod指定休眠时间，默认1秒
    
NoBackOffPolicy：无退避算法策略，每次重试时立即重试

UniformRandomBackOffPolicy：随机时间退避策略，需设置sleeper、minBackOffPeriod和maxBackOffPeriod，该策略在[minBackOffPeriod,maxBackOffPeriod之间取一个随机休眠时间，minBackOffPeriod默认500毫秒，maxBackOffPeriod默认1500毫秒

java复制代码 <dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>1.2.2.RELEASE</version>
 </dependency>

 <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.1</version>
 </dependency>

java复制代码@Service
@Slf4j
public class SpringRetryDemo {


    /**
     * 重试所调用方法
     * @return
     */
    // delay=2000L表示延迟2秒 multiplier=2表示两倍 即第一次重试2秒后,第二次重试4秒后,第三次重试8秒后
    @Retryable(value = {RemoteAccessException.class}, maxAttempts = 3, backoff = @Backoff(delay = 2000L, multiplier = 2))
    public boolean call(Integer param) {
        return RetryDemo.retryMethod(param);
    }

    /**
     * 超过最大重试次数或抛出没有指定重试的异常
     * @param e
     * @param param
     * @return
     */
    @Recover
    public boolean recover(Exception e, Integer param) {
        log.info("请求参数为: ", param);
        log.info("超过最大重试次数或抛出没有指定重试的异常, e = {} ", e.getMessage());
        return false;
    }

}

java复制代码@SpringBootApplication
@EnableRetry
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

java复制代码@RunWith(SpringRunner.class)
@SpringBootTest(classes = DemoApplication.class)
@Slf4j
public class DemoApplicationTests {

    @Autowired
    private SpringRetryDemo springRetryDemo;

    @Test
    public void testRetry() {
        boolean result = springRetryDemo.call(110);
        log.info("方法返回结果为: {}", result);
    }
}
/*	运行结果:

    随机生成的数:77
    大于10,抛出自定义异常.
    随机生成的数:23
    大于10,抛出自定义异常.
    随机生成的数:82
    大于10,抛出自定义异常.
    请求参数为: 
    超过最大重试次数或抛出没有指定重试的异常, e = 大于10,抛出自定义异常 
    方法返回结果为: false
*/

java复制代码@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@EnableAspectJAutoProxy(proxyTargetClass = false)
@Import(RetryConfiguration.class)
@Documented
public @interface EnableRetry {

	/**
	 * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
	 * to standard Java interface-based proxies. The default is {@code false}.
	 *
	 * @return whether to proxy or not to proxy the class
	 */
	boolean proxyTargetClass() default false;

}

java复制代码@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Retryable {

	/**
	 * Retry interceptor bean name to be applied for retryable method. Is mutually
	 * exclusive with other attributes.
	 * @return the retry interceptor bean name
	 */
	String interceptor() default "";

	/**
	 * Exception types that are retryable. Synonym for includes(). Defaults to empty (and
	 * if excludes is also empty all exceptions are retried).
	 * @return exception types to retry
	 */
	Class<? extends Throwable>[] value() default {};

	/**
	 * Exception types that are retryable. Defaults to empty (and if excludes is also
	 * empty all exceptions are retried).
	 * @return exception types to retry
	 */
	Class<? extends Throwable>[] include() default {};

	/**
	 * Exception types that are not retryable. Defaults to empty (and if includes is also
	 * empty all exceptions are retried).
	 * @return exception types to retry
	 */
	Class<? extends Throwable>[] exclude() default {};

	/**
	 * A unique label for statistics reporting. If not provided the caller may choose to
	 * ignore it, or provide a default.
	 *
	 * @return the label for the statistics
	 */
	String label() default "";

	/**
	 * Flag to say that the retry is stateful: i.e. exceptions are re-thrown, but the
	 * retry policy is applied with the same policy to subsequent invocations with the
	 * same arguments. If false then retryable exceptions are not re-thrown.
	 * @return true if retry is stateful, default false
	 */
	boolean stateful() default false;

	/**
	 * @return the maximum number of attempts (including the first failure), defaults to 3
	 */
	int maxAttempts() default 3;

	/**
	 * @return an expression evaluated to the maximum number of attempts (including the first failure), defaults to 3
	 * Overrides {@link #maxAttempts()}.
	 * @since 1.2
	 */
	String maxAttemptsExpression() default "";

	/**
	 * Specify the backoff properties for retrying this operation. The default is a
	 * simple {@link Backoff} specification with no properties - see it's documentation
	 * for defaults.
	 * @return a backoff specification
	 */
	Backoff backoff() default @Backoff();

	/**
	 * Specify an expression to be evaluated after the {@code SimpleRetryPolicy.canRetry()}
	 * returns true - can be used to conditionally suppress the retry. Only invoked after
	 * an exception is thrown. The root object for the evaluation is the last {@code Throwable}.
	 * Other beans in the context can be referenced.
	 * For example:
	 * <pre class=code>
	 *  {@code "message.contains('you can retry this')"}.
	 * </pre>
	 * and
	 * <pre class=code>
	 *  {@code "@someBean.shouldRetry(#root)"}.
	 * </pre>
	 * @return the expression.
	 * @since 1.2
	 */
	String exceptionExpression() default "";

}

java复制代码@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(RetryConfiguration.class)
@Documented
public @interface Backoff {

	/**
	 * Synonym for {@link #delay()}.
	 *
	 * @return the delay in milliseconds (default 1000)
	 */
	long value() default 1000;

	/**
	 * A canonical backoff period. Used as an initial value in the exponential case, and
	 * as a minimum value in the uniform case.
	 * @return the initial or canonical backoff period in milliseconds (default 1000)
	 */
	long delay() default 0;

	/**
	 * The maximimum wait (in milliseconds) between retries. If less than the
	 * {@link #delay()} then the default of
	 * {@value org.springframework.retry.backoff.ExponentialBackOffPolicy#DEFAULT_MAX_INTERVAL}
	 * is applied.
	 *
	 * @return the maximum delay between retries (default 0 = ignored)
	 */
	long maxDelay() default 0;

	/**
	 * If positive, then used as a multiplier for generating the next delay for backoff.
	 *
	 * @return a multiplier to use to calculate the next backoff delay (default 0 =
	 * ignored)
	 */
	double multiplier() default 0;

	/**
	 * An expression evaluating to the canonical backoff period. Used as an initial value
	 * in the exponential case, and as a minimum value in the uniform case.
	 * Overrides {@link #delay()}.
	 * @return the initial or canonical backoff period in milliseconds.
	 * @since 1.2
	 */
	String delayExpression() default "";

	/**
<<<<<<< HEAD
	 * An expression evaluating to the maximum wait (in milliseconds) between retries.
	 * If less than the {@link #delay()} then ignored.
=======
	 * An expression evaluating to the maximimum wait (in milliseconds) between retries.
	 * If less than the {@link #delay()} then the default of
	 * {@value org.springframework.retry.backoff.ExponentialBackOffPolicy#DEFAULT_MAX_INTERVAL}
	 * is applied.
>>>>>>> Fix @Backoff JavaDocs - maxDelay
	 * Overrides {@link #maxDelay()}
	 *
	 * @return the maximum delay between retries (default 0 = ignored)
	 * @since 1.2
	 */
	String maxDelayExpression() default "";

	/**
	 * Evaluates to a vaule used as a multiplier for generating the next delay for backoff.
	 * Overrides {@link #multiplier()}.
	 *
	 * @return a multiplier expression to use to calculate the next backoff delay (default 0 =
	 * ignored)
	 * @since 1.2
	 */
	String multiplierExpression() default "";

	/**
	 * In the exponential case ({@link #multiplier()} &gt; 0) set this to true to have the
	 * backoff delays randomized, so that the maximum delay is multiplier times the
	 * previous delay and the distribution is uniform between the two values.
	 *
	 * @return the flag to signal randomization is required (default false)
	 */
	boolean random() default false;

}

java复制代码@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Import(RetryConfiguration.class)
@Documented
public @interface Recover {
}

sh复制代码sh nacos-config.sh -h 10.0.100.254 -p 8848 -g SEATA_GROUP

conf复制代码registry {
  type = "nacos"

  nacos {
    application = "seata-server"
    serverAddr = "10.0.100.254:8848"
    group = "SEATA_GROUP"
    namespace = ""
    cluster = "default"
    username = ""
    password = ""
  }
   }
   
   config {
  type = "file"

  nacos {
    serverAddr = "10.0.100.254:8848"
    namespace = ""
    group = "SEATA_GROUP"
    username = ""
    password = ""
    dataId = "seataServer.properties"
  }
   }

csharp复制代码/**
 * 执行操作记录线程
 */
@Slf4j
public class OperationLogHandler implements Runnable{

    // 操作存放队列++++++
    private static ConcurrentLinkedQueue<OperationRecord> holderList = new ConcurrentLinkedQueue();

    private OperationRecordService recordService = SpringBeanUtil.getBeanByClass(OperationRecordService.class);

    @Override
    public void run() {
        for (;;){
            Iterator<OperationRecord> iterator = holderList.iterator();
            // 为空时 休眠
            while (iterator.hasNext()){
                OperationRecord record = iterator.next();
                if (record == null) {
                    iterator.remove();
                    continue;
                }
                // 执行落库操作
                boolean saveRet = recordService.save(record);
                log.info("异步保存用户操作日志结果为：{}",saveRet);
                iterator.remove();
            }
        }
    }

    /**
     * 添加记录到队列（具体业务逻辑调用）
     * @param operationRecords
     */
    public static void addOpLogs(List<OperationRecord> operationRecords){
        if (CollectionUtil.isEmpty(operationRecords)){
            return;
        }
        boolean addRet = holderList.addAll(operationRecords);
        log.info("添加操作日志到链表，结果：{}",addRet);
    }
}

typescript复制代码@Component
public class SyncOperationLogListener implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        run();
    }

    public void run(){
    	// 使用线程池方式启动
        ThreadPoolUtil.getThreadPoolExecutor()
                .execute(new OperationLogHandler());
        System.out.println("=== operationLog handler start success ===");
    }
}