Nicksxs's Blog

寻找原因

这次碰到一个比较奇怪的问题，应该统一发布脚本统一给应用启动参数传了个 -Dserver.port=xxxx，其实这个端口会作为 dubbo 的服务端口，并且应用也不提供 web 服务，但是在启动的时候会报embedded servlet container failed to start. port xxxx was already in use就觉得有点奇怪，仔细看了启动参数猜测可能是这个问题，有可能是依赖的二方三方包带了 spring-web 的包，然后基于 springboot 的 auto configuration 会把这个自己加载，就在本地复现了下这个问题，结果的确是这个问题。

解决方案

老版本 设置 spring 不带 web 功能

比较老的 springboot 版本，可以使用

SpringApplication app = new SpringApplication(XXXXXApplication.class);
app.setWebEnvironment(false);
app.run(args);

新版本

新版本的 springboot (>= 2.0.0)可以在 properties 里配置

spring.main.web-application-type=none

或者

SpringApplication app = new SpringApplication(XXXXXApplication.class);
app.setWebApplicationType(WebApplicationType.NONE);

这个枚举里还有其他两种配置

public enum WebApplicationType {

	/**
	 * The application should not run as a web application and should not start an
	 * embedded web server.
	 */
	NONE,

	/**
	 * The application should run as a servlet-based web application and should start an
	 * embedded servlet web server.
	 */
	SERVLET,

	/**
	 * The application should run as a reactive web application and should start an
	 * embedded reactive web server.
	 */
	REACTIVE

}

相当于是把none 的类型和包括 servlet 和 reactive 放进了枚举类进行控制。

题目介绍

Given a 2D grid of size m x n and an integer k. You need to shift the grid k times.

In one shift operation:

Element at grid[i][j] moves to grid[i][j + 1].
Element at grid[i][n - 1] moves to grid[i + 1][0].
Element at grid[m - 1][n - 1] moves to grid[0][0].
Return the 2D grid after applying shift operation k times.

示例

Example 1:

Input: grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1
Output: [[9,1,2],[3,4,5],[6,7,8]]

Example 2:

Input: grid = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4
Output: [[12,0,21,13],[3,8,1,9],[19,7,2,5],[4,6,11,10]]

Example 3:

Input: grid = [[1,2,3],[4,5,6],[7,8,9]], k = 9
Output: [[1,2,3],[4,5,6],[7,8,9]]

提示

• m == grid.length
• n == grid[i].length
• 1 <= m <= 50
• 1 <= n <= 50
• -1000 <= grid[i][j] <= 1000
• 0 <= k <= 100

解析

这个题主要是矩阵或者说数组的操作，并且题目要返回的是个 List，所以也不用原地操作，只需要找对位置就可以了，k 是多少就相当于让这个二维数组头尾衔接移动 k 个元素

代码

public List<List<Integer>> shiftGrid(int[][] grid, int k) {
        // 行数
        int m = grid.length;
        // 列数
        int n = grid[0].length;
        // 偏移值，取下模
        k = k % (m * n);
        // 反向取下数量，因为我打算直接从头填充新的矩阵
        /*
         *    比如
         *    1 2 3
         *    4 5 6
         *    7 8 9
         *    需要变成
         *    9 1 2
         *    3 4 5
         *    6 7 8
         *    就要从 9 开始填充
         */
        int reverseK = m * n - k;
        List<List<Integer>> matrix = new ArrayList<>();
        // 这类就是两层循环
        for (int i = 0; i < m; i++) {
            List<Integer> line = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                // 数量会随着循环迭代增长, 确认是第几个
                int currentNum = reverseK + i * n +  (j + 1);
                // 这里处理下到达矩阵末尾后减掉 m * n
                if (currentNum > m * n) {
                    currentNum -= m * n;
                }
                // 根据矩阵列数 n 算出在原来矩阵的位置
                int last = (currentNum - 1) % n;
                int passLine = (currentNum - 1) / n;

                line.add(grid[passLine][last]);
            }
            matrix.add(line);
        }
        return matrix;
    }

结果数据

比较慢

断断续续地看完了马伯庸老师的《长安的荔枝》，一开始是看这本书在排行榜排得很高，又是马伯庸的，之前看过他的《古董局中局》，还是很有意思的，而且正好是比较短的，不过前后也拖了蛮久才看完，看完后读了下马老师自己写的后记，就特别有感触。
整个故事是围绕一个上林署监事李善德被委任一项给贵妃送荔枝的差事展开，“长安回望绣成堆，山顶千门次第开，一骑红尘妃子笑，无人知是荔枝来”，以前没细究过这个送荔枝的过程，但是以以前的运输速度和保鲜条件，感觉也不是太现实，所以主人公一开始就以为只是像以往一样是送荔枝干这种，能比较方便运输，不容易变质的，结果发现其实是同僚在坑他，这次是要在贵妃生辰的时候给贵妃送来新鲜的岭南荔枝，用比较时兴的词来说，这就是个送命题啊，鲜荔枝一日色变，两日香变，三日味变，同僚的还有杜甫跟韩承，都觉得老李可以直接写休书了，保全家人，不然就是全家送命，李善德也觉得基本算是判刑了，而且其实是这事被转了几次，最后到老李所在的上林署，主管为了骗他接下这个活还特意在文书上把荔枝鲜的“鲜”字贴住，那会叫做“贴黄”，变成了荔枝“煎”，所以说官场险恶，大家都想把这烫手山芋丢出去，结果丢到了我们老实的老李头上，但是从接到这个通知到贵妃的生辰六月初一还有挺长的时间，其实这个活虽然送命，但是在前期这个“荔枝使”也基本就是类似带着尚方宝剑，御赐黄马褂的职位，随便申请经费，不必像常规的部门费用需要定预算，申请后再层层审批，而是特事特批特办的耍赖做法，所以在这段时间是能够潇洒挥霍一下的。其实可以好好地捞一波给妻女，然后写下和离，在自己死后能让她们过的好一些，但最后还是在杜甫的一番劝导下做出了尝试一番的决定，因为也没其他办法，既是退无可退，何不向前拼死一搏，其实说到这，我觉得看这本书感觉有所收获的第一点，有时候总觉得事情没戏了，想躺平放弃了，但是这样其实这个结果是不会变好的，尝试努力，拼尽全力搏一搏，说不定会有所改观，至少不会变更坏了。

mybatis 在作为轻量级 orm 框架，如果要使用类似于 in 查询的语句，除了直接替换字符串，还可以使用 foreach 标签
在mybatis的 dtd 文件中可以看到可以配置这些字段，

<!ELEMENT foreach (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
<!ATTLIST foreach
collection CDATA #REQUIRED
item CDATA #IMPLIED
index CDATA #IMPLIED
open CDATA #IMPLIED
close CDATA #IMPLIED
separator CDATA #IMPLIED
>

collection 表示需要使用 foreach 的集合，item 表示进行迭代的变量名，index 就是索引值，而 open 跟 close
代表拼接的起始和结束符号，一般就是左右括号，separator 则是每个 item 直接的分隔符

例如写了一个简单的 sql 查询

<select id="search" parameterType="list" resultMap="StudentMap">
    select * from student
    <where>
        id in
        <foreach collection="list" item="item" open="(" close=")" separator=",">
            #{item}
        </foreach>
    </where>
</select>

这里就发现了一个问题，collection 对应的这个值，如果传入的参数是个 HashMap，collection 的这个值就是以此作为
key 从这个 HashMap 获取对应的集合，但是这里有几个特殊的小技巧，
在上面的这个方法对应的接口方法定义中

public List<Student> search(List<Long> userIds);

我是这么定义的，而 collection 的值是list，这里就有一点不能理解了，但其实是 mybatis 考虑到使用的方便性，
帮我们做了一点点小转换，我们翻一下 mybatis 的DefaultSqlSession 中的代码可以看到

@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
  try {
    MappedStatement ms = configuration.getMappedStatement(statement);
    return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}
// 就是在这帮我们做了转换
  private Object wrapCollection(final Object object) {
  if (object instanceof Collection) {
    StrictMap<Object> map = new StrictMap<Object>();
    map.put("collection", object);
    if (object instanceof List) {
      // 如果类型是list 就会转成以 list 为 key 的 map
      map.put("list", object);
    }
    return map;
  } else if (object != null && object.getClass().isArray()) {
    StrictMap<Object> map = new StrictMap<Object>();
    map.put("array", object);
    return map;
  }
  return object;
  }

题目介绍

Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

1. Open brackets must be closed by the same type of brackets.
2. Open brackets must be closed in the correct order.

示例

Example 1:

Input: s = “()”
Output: true

Example 2:

Input: s = “()[]{}”
Output: true

Example 3:

Input: s = “(]”
Output: false

Constraints:

• 1 <= s.length <= 10^4
• s consists of parentheses only '()[]{}'.

解析

easy题，并且看起来也是比较简单的，三种括号按对匹配，直接用栈来做，栈里面存的是括号的类型，如果是左括号，就放入栈中，如果是右括号，就把栈顶的元素弹出，如果弹出的元素不是左括号，就返回false，如果弹出的元素是左括号，就继续往下走，如果遍历完了，如果栈里面还有元素，就返回false，如果遍历完了，如果栈里面没有元素，就返回true

代码

class Solution {
    public boolean isValid(String s) {

        if (s.length() % 2 != 0) {
            return false;
        }
        Stack<String> stk = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '{' || s.charAt(i) == '(' || s.charAt(i) == '[') {
                stk.push(String.valueOf(s.charAt(i)));
                continue;
            }
            if (s.charAt(i) == '}') {
                if (stk.isEmpty()) {
                    return false;
                }
                String cur = stk.peek();
                if (cur.charAt(0) != '{') {
                    return false;
                } else {
                    stk.pop();
                }
                continue;
            }
            if (s.charAt(i) == ']') {
                if (stk.isEmpty()) {
                    return false;
                }
                String cur = stk.peek();
                if (cur.charAt(0) != '[') {
                    return false;
                } else {
                    stk.pop();
                }
                continue;
            }
            if (s.charAt(i) == ')') {
                if (stk.isEmpty()) {
                    return false;
                }
                String cur = stk.peek();
                if (cur.charAt(0) != '(') {
                    return false;
                } else {
                    stk.pop();
                }
                continue;
            }

        }
        return stk.size() == 0;
    }
}