xml复制代码		<!--引入swagger2依赖-->
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger2</artifactId>
			<version>2.9.2</version>
		</dependency>
		<!--引入swaggerui-->
		<dependency>
			<groupId>com.github.xiaoymin</groupId>
			<artifactId>swagger-bootstrap-ui</artifactId>
			<version>1.9.3</version>
		</dependency>

java复制代码@Configuration
@EnableSwagger2
public class Swagger2Config {

    @Bean
    public Docket createRestApi(){

        return  new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
            .apis(RequestHandlerSelectors.basePackage("com.example.jxauflea.controller"))// 扫描接口的包路径
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("接口文档")// swagger文档的标题
                .description("")// 自定义相关描述
                .contact(new Contact("xxx","http:localhost/doc.html","xxx@xxx.com"))
                .version("1.0")// 当前的版本
                .build();
    }

}

xml复制代码    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>25.1-jre</version>
    </dependency>

bash复制代码sudo bin/elasticsearch-plugin list

arduino复制代码sudo bin/elasticsearch-plugin remove [pluginname]

css复制代码sudo bin/elasticsearch-plugin remove [pluginname] [pluginname] ... [pluginname]

bash复制代码sudo bin/elasticsearch-plugin remove [pluginname]
sudo bin/elasticsearch-plugin install [pluginname]

bash复制代码sudo bin/elasticsearch-plugin install analysis-smartcn

xml复制代码<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

xml复制代码<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.70</version>
</dependency>

yaml复制代码spring:
  redis:
    database: 0 #选择第一个数据库,可选0-15
    host: 127.0.0.1
    port: 6379
    password:   #无密码留空 ,有密码则设置密码

arduino复制代码
@Configuration
public class MyRedisConfig {

    /**
     * 指定FastJson序列化
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){

        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        GenericFastJsonRedisSerializer jsonRedisSerializer = new GenericFastJsonRedisSerializer();
        template.setDefaultSerializer(jsonRedisSerializer);
        template.setKeySerializer(jsonRedisSerializer);
        template.setValueSerializer(jsonRedisSerializer);
        return template;
    }
}

typescript复制代码@Autowired
private RedisTemplate<String,Object> redisTemplate;

ini复制代码@GetMapping("/string1")
public R string1() {
    long start = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        String uuid = UUID.randomUUID().toString();
        redisTemplate.opsForValue().set(uuid, uuid);
    }
    long end = System.currentTimeMillis();
    return R.success("redisTemplate单线程,存储 100000 key:需要时间", end - start);
}

ini复制代码    @GetMapping("/string100")
    public ResultVo string100() throws InterruptedException {
        redisTemplate.hasKey("123");

        CountDownLatch countDownLatch = new CountDownLatch(100000);
        ExecutorService pool = Executors.newFixedThreadPool(100);

        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            pool.execute(() -> {
                String uuid = UUID.randomUUID().toString();
                redisTemplate.opsForValue().set(uuid, uuid);
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();

        return ResultVo.success("redisTemplate 100线程 并发,存储 100000 Key 需要时间", end - start);
    }

ini复制代码@GetMapping("/stringPipe")
public ResultVo stringPipe() throws InterruptedException {

    long start = System.currentTimeMillis();
    redisTemplate.executePipelined((RedisCallback) redisConnection ->{
            for (int i = 0; i < 100000; i++) {
                byte[] uuid = UUID.randomUUID().toString().getBytes();
                redisConnection.set(uuid, uuid);
            }
            return null;
    }, redisTemplate.getDefaultSerializer());

    long end = System.currentTimeMillis();
    return ResultVo.success("redisTemplate 管道 ,存储 100000 Key 需要时间", end - start);
}

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

java复制代码@Slf4j
public class OkHttpDemo {

    // 创建OkHttpClient对象, 并设置超时时间 添加拦截器LoginInterceptor
    private static final OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
        	.addInterceptor(new LoginInterceptor())
            .build();

    public static void main(String[] args) throws IOException {
        String url = "http://www.baidu.com";
        Request request = new Builder()
                .url(url)
                .get() // 不写,默认是GET请求
                .build();
		
        Call call = okHttpClient.newCall(request);
        // 异步调用
        call.enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                log.info("请求失败,异常信息为: {}", e.getMessage());
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response)
                    throws IOException {
                log.info("请求成功,返回信息为: {}", response.body().toString());
            }
        });
    }
}

java复制代码@Slf4j
public class LoginInterceptor implements Interceptor {

    /**
     * 统计登录接口完成时间
     */
    @NotNull
    @Override
    public Response intercept(@NotNull Chain chain) throws IOException {

        Request request = chain.request();
        long begin = System.currentTimeMillis();
        Response  response = chain.proceed(request);
        long end = System.currentTimeMillis();

        // 请求路径中有/login 统计花费时间
        if (request.url().toString().contains("/login")) {
            log.info("接口处理总用时: {} ", end - begin);
        }

        return response;
    }
}

java复制代码 public static final class Builder {
      @NotNull
      private Dispatcher dispatcher;
      @NotNull
      private ConnectionPool connectionPool;
      @NotNull
      private final List interceptors;
      private int callTimeout;
      private int connectTimeout;
      private int readTimeout;
      private int writeTimeout;
      private int pingInterval;
      private long minWebSocketMessageToCompress;
      @Nullable
      private RouteDatabase routeDatabase;
     
 }

java复制代码  open class Builder {
    internal var url: HttpUrl? = null
    internal var method: String
    internal var headers: Headers.Builder
    internal var body: RequestBody? = null

    /** A mutable map of tags, or an immutable empty map if we don't have any. */
    internal var tags: MutableMap<Class<*>, Any> = mutableMapOf()

    constructor() {
      this.method = "GET"
      this.headers = Headers.Builder()
    }

    internal constructor(request: Request) {
      this.url = request.url
      this.method = request.method
      this.body = request.body
      this.tags = if (request.tags.isEmpty()) {
        mutableMapOf()
      } else {
        request.tags.toMutableMap()
      }
      this.headers = request.headers.newBuilder()
    }
  }

java复制代码    override fun execute(): Response {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

    timeout.enter()
    callStart()
    try {
      client.dispatcher.executed(this)
      return getResponseWithInterceptorChain()
    } finally {
      client.dispatcher.finished(this)
    }
  }

   override fun enqueue(responseCallback: Callback) {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

    callStart()
    client.dispatcher.enqueue(AsyncCall(responseCallback))
  }

java复制代码  internal fun getResponseWithInterceptorChain(): Response {
    // Build a full stack of interceptors.
    val interceptors = mutableListOf<Interceptor>()
    interceptors += client.interceptors
    interceptors += RetryAndFollowUpInterceptor(client)
    interceptors += BridgeInterceptor(client.cookieJar)
    interceptors += CacheInterceptor(client.cache)
    interceptors += ConnectInterceptor
    if (!forWebSocket) {
      interceptors += client.networkInterceptors
    }
    interceptors += CallServerInterceptor(forWebSocket)

    val chain = RealInterceptorChain(
        call = this,
        interceptors = interceptors,
        index = 0,
        exchange = null,
        request = originalRequest,
        connectTimeoutMillis = client.connectTimeoutMillis,
        readTimeoutMillis = client.readTimeoutMillis,
        writeTimeoutMillis = client.writeTimeoutMillis
    )

    var calledNoMoreExchanges = false
    try {
      val response = chain.proceed(originalRequest)
      if (isCanceled()) {
        response.closeQuietly()
        throw IOException("Canceled")
      }
      return response
    } catch (e: IOException) {
      calledNoMoreExchanges = true
      throw noMoreExchanges(e) as Throwable
    } finally {
      if (!calledNoMoreExchanges) {
        noMoreExchanges(null)
      }
    }
  }

java复制代码@Slf4j
public class OkHttpUtils {
    
        // 创建OkHttpClient对象, 并设置超时时间 
    private static final OkHttpClient client = new OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
            .build();

    /**
     * 同步GET请求
     *
     * @param url 请求地址
     */
    public static String getRequest(String url) {
        try {
            // 1 创建OkHttpClient对象 
            // 2 构建Request对象
            Request request = new Request.Builder()
                    .get()// 不写默认为GET请求
                    .url(url)
                    .build();
            // 3 发起请求获取响应值
            Response response = client.newCall(request).execute();
            // 4 根据响应结果判断
            if (response.isSuccessful()) {
                return response.body().string();
            } else {
                throw new RuntimeException("请求异常,错误码为: " + response.code());
            }
        } catch (Exception e) {
            log.info("请求失败,错误信息为= {} ", e.getMessage());
        }
        return null;
    }
    
    /**
     * 同步POST请求
     *
     * @param url 请求地址
     * @param params 请求参数
     */
    public static String postRequest(String url, Map<String, String> params) {

        try {
            // 1 创建OkHttpClient对象
            // 2 构建请求体
            MultipartBody body = new MultipartBody.Builder()
                    .setType(MediaType.parse("multipart/form-data"))
                    .addFormDataPart("username", params.get("username"))
                    .addFormDataPart("password", params.get("password"))
                    .build();
            // 3 构建Request对象
            Request request = new Request.Builder()
                    .post(body)
                    .url(url)
                    .build();
            // 4 发起请求获取响应值
            Response response = client.newCall(request).execute();

            // 5 根据响应结果判断
            if (response.isSuccessful()) {
                return response.body().string();
            } else {
                throw new RuntimeException("请求异常,错误码为: " + response.code());
            }
        } catch (Exception e) {
            log.info("请求失败,错误信息为= {} ", e.getMessage());
        }
        return null;
    }
    
    
    /**
     * 同步GET请求
     */
    public static String getRequest(String url) throws IOException {
        Request request = new Builder().url(url).build();
        Response response = execute(request);

        if (response.isSuccessful()) {
            return response.body().string();
        } else {
            throw new ArithmeticException("请求异常,错误码为: " + response.code());
        }

    }

    /**
     * 同步请求
     */
    public static Response execute(Request request) throws IOException {
        return client.newCall(request).execute();
    }
    
    /**
     * 开启异步线程访问网络, 需要返回结果
     */
    public static void enqueue(Request request, Callback callback) {
        client.newCall(request).enqueue(callback);
    }

    /**
     * 开启异步线程访问网络,不需要返回结果( Callback 返回为空)
     */
    public static void enqueue(Request request) {
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                log.info("请求失败,异常信息为: {} ", e.getMessage());
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response)
                    throws IOException {
                log.info("请求成功");
            }
        });
    }
    
}

php复制代码//批量设置过期时间
public static function myPut(array $data, $ttl = 0)
{
    if (empty($data)) {
        return false;
    }

    $pipeline = Redis::connection('cache')
        ->multi(\Redis::PIPELINE);
    foreach ($data as $key => $value) {
        if (empty($value)) {
            continue;
        }
        if ($ttl == 0) {
            $pipeline->set(trim($key), $value);
        } else {
            $pipeline->set(trim($key), $value, $ttl);
        }
    }
    $pipeline->exec();
}

php复制代码<?php

namespace App\Model\House;

.
.
.

class HouseLikeRecallUser
{
    protected $_userid = '';
    protected $_availableUser = [];
    protected $_recallFlagKey = '';

    const TYPE_TTL_HOUSE_LIKE_RECALL = 60 * 30; //半小时后可以再次接收到喜欢的xxx进入通知
    const TYPE_TTL_HOUSE_LIKE_RECALL_FLAG = 60 * 60 * 8; //8小时重复登录不触发

    //初始化 传入setRecalled 的过期时间
    public function __construct($userid)
    {
        $this->_userid = $userid;
        //登录后给喜欢我的人推送校验：同一场次重复登录不重复发送
        $this->_recallFlagKey = CacheKey::getCacheKey(CacheKey::TYPE_HOUSE_LIKE_RECALL_FLAG, $this->_userid);
    }

    //设置当前用户推送标示
    public function setRecalled()
    {
        Cache::put($this->_recallFlagKey, 1, self::TYPE_TTL_HOUSE_LIKE_RECALL_FLAG);
    }

    //获取当前用户是否触发推送
    public function canRecall()
    {
        $res = false;
        if (empty(Cache::get($this->_recallFlagKey))) {
            $houseOpen = HouseOpen::getCurrentOpen();
            if ($houseOpen['status'] == HouseOpen::HOUSE_STATUS_OPEN) {
                $res = true;
            }
        }
        return $res;
    }

    //获取需要推送用户
    public function getAvailableUser()
    {
        //获得最近喜欢我的用户
        $recentLikeMeUser = UserRelationSingle::getLikeMeUserIds($this->_userid, 100, Utility::getBeforeNDayTimestamp(7));

        //获得最近喜欢我的用户的 RECALL缓存标记
        foreach ($recentLikeMeUser as $userid) {
            $batchKey[] = CacheKey::getCacheKey(CacheKey::TYPE_HOUSE_LIKE_RECALL, $userid);
        }

        //获得最近喜欢我的且已经推送过的用户
        $cacheData = [];
        if (!empty($batchKey)) {
            $cacheData = Redis::connection('cache')->mget($batchKey);
        }

        //计算最近喜欢我的用户 和 已经推送过的用户 的差集：就是需要推送的用户
        $this->_availableUser = array_diff($recentLikeMeUser, $cacheData);
        return $this->_availableUser;
    }

    //更新已经推送的用户
    public function updateRecalledUser()
    {
        //批量更新差集用户
        $recalledUser = [];
        foreach ($this->_availableUser as $userid) {
            $cacheKey = CacheKey::getCacheKey(CacheKey::TYPE_HOUSE_LIKE_RECALL, $userid);
            $recalledUser[$cacheKey] = $userid;
        }
        //批量更新 设置过期时间
        self::myPut($recalledUser, self::TYPE_TTL_HOUSE_LIKE_RECALL);
    }

    //批量设置过期时间
    public static function myPut(array $data, $ttl = 0)
    {
        if (empty($data)) {
            return false;
        }

        $pipeline = Redis::connection('cache')
            ->multi(\Redis::PIPELINE);
        foreach ($data as $key => $value) {
            if (empty($value)) {
                continue;
            }
            if ($ttl == 0) {
                $pipeline->set(trim($key), $value);
            } else {
                $pipeline->set(trim($key), $value, $ttl);
            }
        }
        $pipeline->exec();
    }
}

php复制代码public function handle()
{
    $userid = $this->_userid;
    $houseLikeRecallUser = new HouseLikeRecallUser($userid);
    if ($houseLikeRecallUser->canRecall()) {
        $recallUserIds = $houseLikeRecallUser->getAvailableUser();
        $houseLikeRecallUser->setRecalled();
        $houseLikeRecallUser->updateRecalledUser();
        //群发推送消息
        .
        .
        .
    }
}

csharp复制代码public class Singleton {
​
    // 用static、final修饰
    private static final Singleton INSTANCE = new Singleton();
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

arduino复制代码public enum Singleton {
​
    // 单例对象
    INSTANCE;
    // 其它方法   
}

csharp复制代码public class Singleton {
​
    // 静态内部类
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    } 
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

csharp复制代码public class Singleton {
​
    // 属性
    private static Singleton instance;
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

csharp复制代码public class Singleton {
​
    // volatile修饰，保证原子性
    private static volatile Singleton instance;
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

bash复制代码小明接了个项目，业务方的需求里面有很多组织管理、人员管理、事件管理的需求，这些业务有面向终端客户的查询，也有面向内部管理人员的管理。需求的复杂度不高，很多都是表单的增删改查，但架不住需求点太多，小明还是得加班加点的当搬砖码农。其实，针对这类场景，有很多公司尝试使用打破分层界限的编码工具，比如宇宙第一编码语言PHP、ruby/rails等，方便快捷，奈何业务复杂了以后，都得慢慢迁移到企业级开发语言java上。也有公司，开始尝试低代码平台，通过简单的托拉拽就完成后台管理界面的开发，奈何，现在的低代码开发还真只能胜任上面需求中的增删改查。

arduino复制代码有没有一种办法，在java的企业级开发中，既能满足复杂的需求开发；又可以快速的完成简单的增删改查（有一定的业务逻辑），同时能保证技术的统一性和延续性呢？ fluent-mybatis在完成了对mybatis封装，实现了在java代码中使用流式语言，满足条件设置、复杂关联、嵌套、union、多数据库支持、个性化扩展等便捷能力外。现在又推出了，专门面向表单级的增删改查，声明即实现的一剑封喉的能力。
呵呵呵，作者吹牛不用上税啊，我们来看个简单的例子：

我们定义一个spring rest api接口如下

java复制代码@RestController
@FormService(table = "student")
public interface StudentQueryApi {
    @PostMapping("/student")
    Student findStudentBy(@RequestBody StudentQuery student);
    
    @PostMapping("/listStudentBy")
    List<Student> listStudentBy(@RequestBody StudentQuery student);
}

@Data
@Accessors(chain = true)
public class StudentQuery implements Serializable {
    private String userName;

    @Entry(type = EntryType.LikeLeft)
    private String address;

    @Entry(type = Between)
    private Integer[] age;

    private Integer gender;
    /**
     * 默认正序
     */
    @Entry(type = EntryType.OrderBy, value = "userName")
    private boolean byUserName = true;
    /**
     * 默认倒序
     */
    @Entry(type = EntryType.OrderBy, value = "age")
    private boolean byAge;
}

@Data
@Accessors(chain = true)
public class Student implements Serializable {

    private String userName;

    private String status;

    private String phone;

    @Entry("email")
    private String hisEmail;

    private Integer age;

    private String address;
}

java复制代码@FormServiceScan({"你定义api的package路径"})
public class SpringConfig {
    // 你其它bean配置
}

java复制代码    @Tables(url = URL, username = "root", password = "password",
        srcDir = SrcDir, testDir = TestDir, basePack = BasePack + 2,
        gmtCreated = "gmt_created", gmtModified = "gmt_modified", logicDeleted = "is_deleted",
        tables = {
            @Table(value = {"student", "student_score"},
                columns = @Column(value = "version", isLarge = true)
            ),
        relations = {
            @Relation(method = "findDeskMate", type = RelationType.OneWay_0_1,
                source = "student", target = "student", where = "id=desk_mate_id"),
            @Relation(source = "student", target = "student_score", type = RelationType.TwoWay_1_N,
                where = "id=student_id")
        })
    static class RelationDef1 {
    }

markdown复制代码1. Student和同桌是1 vs 1的关系
2. Student和成绩Score是 1 vs N关系

java复制代码@FluentMybatis(
    table = "student",
    schema = "fluent_mybatis"
)
public class StudentEntity extends RichEntity {
    // ... 省略属性定义
    
  /**
   * 1对1关联查询方法
   */
  @RefMethod("deskMateId = id")
  public StudentEntity findDeskMate() {
    return super.invoke("findDeskMate", true);
  }

  /**
   * 1对多关联查询方法
   */
  @RefMethod("studentId = id")
  public List<StudentScoreEntity> findStudentScoreList() {
    return super.invoke("findStudentScoreList", true);
  }
}

java复制代码@Data
@Accessors(chain = true)
public class Student {
    private Long id;

    private String userName;

    private String status;

    private String phone;

    @Entry("email")
    private String hisEmail;

    private Integer age;

    private String address;
    /**
     * 同桌对象, 对应 findDeskMate方法
     */
    private Student deskMate;
    /**
     * 分数列表, 属性名称是scores, 无法按规则和findStudentScoreList对应
     * 需在 @Entry 注解中显式指定关联方法
     */
    @Entry(value = "findStudentScoreList")
    private List<Score> scores;
}

java复制代码@BeforeEach
void setup() {
    // 准备2个学生的数据，互为同桌
    ATM.dataMap.student.table(2)
        .env.values("test_env")
        .userName.values("li ming", "xiao qiang")
        .age.values(23, 34)
        .email.values("xxx@test")
        .address.values("hangzhou binjiang")
        .deskMateId.values(2, 1)
        .cleanAndInsert();
    // 准备3条成绩数据，liming有二门成绩，小强一门成绩
    ATM.dataMap.studentScore.table(3)
        .env.values("test_env")
        .studentId.values(1, 1, 2)
        .subject.values("yuwen", "english")
        .score.values(79, 67, 98)
        .cleanAndInsert();
}
    
@Test
void listEntity() {
    List<Student> students = service.listStudentBy(new StudentQuery()
        .setAddress("hangzhou")
        .setAge(new Integer[]{20, 40}));
        
    // 验证列表数据
    want.object(students).eqDataMap(
        ATM.dataMap.student.entity(2)
            .userName.values("li ming", "xiao qiang")
            .age.values(23, 34)
            .address.values("hangzhou binjiang")
            .kv("hisEmail", "xxx@test")
    );
    /* 同桌的同桌 = 自己 */
want.object(students.get(0)).eqReflect(students.get(1).getDeskMate(), EqMode.IGNORE_DEFAULTS);
    /* 验证成绩列表 */
    want.object(students.get(0).getScores()).eqDataMap(new DataMap(2)
        .kv("score", 79, 67)
        .kv("subject", "yuwen", "english"));
    want.object(students.get(1).getScores()).eqDataMap(new DataMap(1)
        .kv("score", 98)
        .kv("subject", "english"));
}

shell复制代码==>  Preparing: SELECT `id`, `...省略字段` FROM `student` WHERE `is_deleted` = ? AND `env` = ? AND `address` LIKE ? AND `age` BETWEEN ? AND ? ORDER BY `user_name` ASC, `age` DESC 
==> Parameters: false(Boolean), test_env(String), hangzhou%(String), 20(Integer), 40(Integer) 
<==      Total: 2 
==>  Preparing: SELECT `id`, `...省略字段` FROM `student` WHERE `is_deleted` = ? AND `env` = ? AND `desk_mate_id` IN (?, ?) 
==> Parameters: false(Boolean), test_env(String), 1(Long), 2(Long) 
<==      Total: 2 
==>  Preparing: SELECT `id`, `...省略字段` FROM `student_score` WHERE `is_deleted` = ? AND `env` = ? AND `student_id` IN (?, ?)
==> Parameters: false(Boolean), test_env(String), 1(Long), 2(Long)
<==      Total: 3

xml复制代码    <dependency>
        <groupId>com.github.atool</groupId>
        <artifactId>fluent-mybatis</artifactId>
        <version>1.9.3</version>
    </dependency>
    <dependency>
        <groupId>com.github.atool</groupId>
        <artifactId>fluent-mybatis-processor</artifactId>
        <version>1.9.3</version>
        <scope>provided</scope>
    </dependency>

markdown复制代码    3
   / \
  9  20
    /  \
   15   7

csharp复制代码[
  [3],
  [20,9],
  [15,7]
]

java复制代码    List<List<Integer>> ret = new ArrayList<>();

    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        if (root!=null) {
            Deque<TreeNode> stack = new LinkedList<>();
            stack.push(root);
            dfs(stack);
        }
        return ret;
    }

    public void dfs(Deque<TreeNode> currentLevel) {
        if (currentLevel.size() < 1)
            return;
        List<Integer> temp = new ArrayList<>();
        Deque<TreeNode> nextLevel = new LinkedList<>();
        // 遍历当前层级
        while (!currentLevel.isEmpty()){
            TreeNode treeNode = currentLevel.pop();
            temp.add(treeNode.val);
            // 因为需要添加下一层，所以是 size + 1
            if((ret.size() + 1) % 2 == 1) { // 奇数层：先加左边，再加右边
                if (treeNode.left != null){
                    nextLevel.push(treeNode.left);
                }
                if (treeNode.right != null){
                    nextLevel.push(treeNode.right);
                }
            } else {    // 偶数层：先加右边，再加左边
                if (treeNode.right != null){
                    nextLevel.push(treeNode.right);
                }
                if (treeNode.left != null){
                    nextLevel.push(treeNode.left);
                }
            }
        }
        ret.add(temp);
        dfs(nextLevel);
    }

java复制代码public static void main(String[] args) {
    TreeNode treeNode = new TreeNode(1,
            new TreeNode(2,new TreeNode(4), null),
            new TreeNode(3, null, new TreeNode(5)));
    new Number103().zigzagLevelOrder(treeNode);
}

xml复制代码<dependency>
    <groupId>com.github.houbb</groupId>
    <artifactId>nlp-hanzi-similar</artifactId>
    <version>1.0.0</version>
</dependency>

java复制代码double rate1 = HanziSimilarHelper.similar('末', '未');

复制代码0.9629629629629629

java复制代码double rate = HanziSimilarBs.newInstance()
                .jiegouRate(10)
                .sijiaoRate(8)
                .bushouRate(6)
                .bihuashuRate(2)
                .pinyinRate(1)
                .similar('末', '未');

复制代码入人 0.9
人入 0.9

java复制代码double rate = HanziSimilarHelper.similar('人', '入');

java复制代码/**
 * 相似度
 *
 * @param context 上下文
 * @return 结果
 * @since 1.0.0
 */
@Override
public double similar(final IHanziSimilarContext context) {
    final String charOne = context.charOne();
    final String charTwo = context.charTwo();

    //1. 是否相同
    if(charOne.equals(charTwo)) {
        return 1.0;
    }

    //2. 是否用户自定义
    Map<String, Double> defineMap = context.userDefineData().dataMap();
    String defineKey = charOne+charTwo;
    if(defineMap.containsKey(defineKey)) {
        return defineMap.get(defineKey);
    }

    //3. 通过权重计算获取
    //3.1 四角编码
    IHanziSimilar sijiaoSimilar = context.sijiaoSimilar();
    double sijiaoScore = sijiaoSimilar.similar(context);

    //3.2 结构
    IHanziSimilar jiegouSimilar = context.jiegouSimilar();
    double jiegouScore = jiegouSimilar.similar(context);

    //3.3 部首
    IHanziSimilar bushouSimilar = context.bushouSimilar();
    double bushouScore = bushouSimilar.similar(context);

    //3.4 笔画
    IHanziSimilar biahuashuSimilar = context.bihuashuSimilar();
    double bihuashuScore = biahuashuSimilar.similar(context);

    //3.5 拼音
    IHanziSimilar pinyinSimilar = context.pinyinSimilar();
    double pinyinScore = pinyinSimilar.similar(context);

    //4. 计算总分
    double totalScore = sijiaoScore + jiegouScore + bushouScore + bihuashuScore + pinyinScore;
    //4.1 避免浮点数比较问题
    if(totalScore <= 0) {
        return 0;
    }

    //4.2 正则化
    double limitScore = context.sijiaoRate() + context.jiegouRate()
            + context.bushouRate() + context.bihuashuRate() + context.pinyinRate();

    return totalScore / limitScore;
}

less复制代码@Data
@NoArgsConstructor
@AllArgsConstructor
public class Node {
    public int val;
    public Node next;

    public Node(int anInt) {
        this.val = anInt;
    }
}

ini复制代码public static void main(String[] args) {
        /**
         * 拆分链表，注意最后一项的处理
         */
        Node head = new Node(1, new Node(9, new Node(2, new Node(8, new Node(3, new Node(7, new Node(
                4, new Node(6, new Node(5, new Node(5, new Node(6, new Node(4))))))))))));

        //为了后面代码的统一，建了两个虚拟头结点
        Node node0 = new Node(-1, head);
        Node node1 = new Node(-1, head.next);

        Node head0 = node0;
        Node head1 = node1;
        int i = 0;

        while (head != null) {
            if (i % 2 == 0) {
                node0.next = head;
                node0 = node0.next;
            } else {
                node1.next = head;
                node1 = node1.next;
            }
            head = head.next;
            i++;
        }
        //循环结束之后这里要注意 处理一下，不然总会有一个子链表多一个元素
        if (i % 2 == 0) {
            node0.next = null;
        } else {
            node1.next = null;
        }
        System.out.println(head0.next);
        System.out.println(head1.next);

ini复制代码private static Node reverse(Node head) {
        Node cur = head;
        Node pre = null;
        Node tmp;
        while (cur != null) {
            tmp = cur.next;
            cur.next = pre;

            pre = cur;
            cur = tmp;
        }
        return pre;
    }

ini复制代码private static Node merge(Node node0, Node node1){
        Node node = new Node(0);
        Node head = node;
        while (node0 !=null){
            if (node1 != null && node0.val <= node1.val){
                node.next = node0;
                node0 = node0.next;
            }else {
                if (node1 != null){
                    node.next = node1;
                    node1 = node1.next;
                }
            }
            node = node.next;
        }
        if (node1 != null){
            node.next = node1;
        }
        return head.next;
    }

ini复制代码public class ReSort {
    public static void main(String[] args) {
        /**
         * 拆分链表，注意最后一项的处理
         */
        Node head = new Node(1, new Node(9, new Node(2, new Node(8, new Node(3, new Node(7, new Node(
                4, new Node(6, new Node(5, new Node(5, new Node(6, new Node(4))))))))))));

        Node node0 = new Node(0, head);
        Node node1 = new Node(0, head.next);

        Node head0 = node0;
        Node head1 = node1;
        int i = 0;

        while (head != null) {
            if (i % 2 == 0) {
                node0.next = head;
                node0 = node0.next;
            } else {
                node1.next = head;
                node1 = node1.next;
            }
            head = head.next;
            i++;
        }
        if (i % 2 == 0) {
            node0.next = null;
        } else {
            node1.next = null;
        }
        System.out.println(head0.next);
        System.out.println(head1.next);

        Node reverse = reverse(head1.next);
        Node merge = merge(head0.next, reverse);
        System.out.println(merge);


    }


    /**
     * 双指针法实现链表翻转
     * @param head
     * @return
     */
    private static Node reverse(Node head) {
        Node cur = head;
        Node pre = null;
        Node tmp;
        while (cur != null) {
            tmp = cur.next;
            cur.next = pre;

            pre = cur;
            cur = tmp;
        }
        return pre;
    }

    //合并链表
    private static Node merge(Node node0, Node node1){
        Node node = new Node(0);
        Node head = node;
        while (node0 !=null){
            if (node1 != null && node0.val <= node1.val){
                node.next = node0;
                node0 = node0.next;
            }else {
                if (node1 != null){
                    node.next = node1;
                    node1 = node1.next;
                }
            }
            node = node.next;
        }
        if (node1 != null){
            node.next = node1;
        }
        return head.next;
    }


}