淙嶙

electron-vue ReferenceError process is not defined

Fri, 05 Mar 2021 15:51:34 +0800

问题：在使用electron-vue时候，运行npn run dev,会出现下面的错误

解决方法：

1、找到根目录下的.electron-vue目录

2、找到该目录下的webpack.renderer.config.js文件，找到这段代码：

new HtmlWebpackPlugin({
  // ...
})

3、用下面的代码将这段代码替换：

new HtmlWebpackPlugin({
      filename: 'index.html',
      template: path.resolve(__dirname, '../src/index.ejs'),
      minify: {
        collapseWhitespace: true,
        removeAttributeQuotes: true,
        removeComments: true
      },
      templateParameters(compilation, assets, options) {
        return {
          compilation: compilation,
          webpack: compilation.getStats().toJson(),
          webpackConfig: compilation.options,
          htmlWebpackPlugin: {
            files: assets,
            options: options
          },
          process,
        };
      },
      nodeModules: process.env.NODE_ENV !== 'production'
        ? path.resolve(__dirname, '../node_modules')
        : false
 }),

4、再找到该目录下的webpack.web.config.js文件，找到这段代码：

new HtmlWebpackPlugin({
  // ...
})

5、用下面的代码将这段代码替换：

new HtmlWebpackPlugin({
      filename: 'index.html',
      template: path.resolve(__dirname, '../src/index.ejs'),
      templateParameters(compilation, assets, options) {
        return {
          compilation: compilation,
          webpack: compilation.getStats().toJson(),
          webpackConfig: compilation.options,
          htmlWebpackPlugin: {
            files: assets,
            options: options
          },
          process,
        };
      },
      minify: {
        collapseWhitespace: true,
        removeAttributeQuotes: true,
        removeComments: true
      },
      nodeModules: false
}),

6、最后重新编译就解决了（注意两个文件替换的内容是不一样的）

小学5年级的数学题: 求最大公约数

Tue, 02 Feb 2021 10:05:25 +0800

题目：有两个木料，一根长2015毫米，另一根长755毫米，要把他们锯成同样大小的小段，不许有剩余，但每锯一次要损耗1毫米的木料，每小段木料最长可以是多少毫米？

分析 网友发出来的，乍一看挺唬人，其实是个简单的求最大公约数的题目，用我们的理解算一下， 设每小段为 x 毫米； 2015的木料锯成 y 段； 755 的木料锯成 z 段；

那么

x * y + y - 1 = 2015;
x * z + z - 1 = 755;

简化下：

( x + 1) * y = 2016;
(x + 1) * z = 756;

那么让 x 最大的，就是 x + 1 也是最大，就转化成立 2016 和 756的最大公约数问题了。

但是对于5年级的小朋友，应该还没有接触函数，那么我这么解释：

1.根据每锯一小段都会损耗1毫米，我们可以把1毫米加到每个小段里面；
2.但是有一个问题，如果锯成2段需要锯1次，聚成3段需要锯2次，也就是说我把损耗1毫米放到每个小段里面，实际上多算了1次，即：多算1毫米；
3.既然两个木料都多算了1次，那我们可以把多计算的1毫米，加到两根总长度里面，木料总长度就变成了 2016毫米和756毫米；
4.问题就转化成了，两根木料2016毫米和756毫米，锯成同样长度的小段，没有损耗。这就是两个数求最大公约数
5.根据第1条，最大公约数其实是比实际的长1毫米的，所有最终结果为：最大公约数减1.

springboot分页-及问题排查

Tue, 12 Jan 2021 13:03:43 +0800

1.正常流程

引入依赖jar包

 <dependency>
   <groupId>com.github.pagehelper</groupId>
   <artifactId>pagehelper-spring-boot-starter</artifactId>
   <version>1.3.0</version>
 </dependency>

 PageHelper.startPage(1, 20);
 List<User> users = userMapper.findAll();
 PageInfo<User> pageInfo= new PageInfo<>(users);

2.问题汇总

注意PageHelper的版本与其他mybatis框架的所依赖的包是否一致 springboot尽量使用pagehelper-spring-boot-starter 如果与mybabtis-plus联合使用，注意jsqlparser的版本。 pagehelper版本过低可能报的错误： java.lang.NoSuchMethodError: net.sf.jsqlparser.statement.select.PlainSelect.getGroupByColumnReferences()Ljava/util/List;

3.源代码地址

https://github.com/pagehelper/pagehelper-spring-boot

Spring WebFlux WebSocket 推送

Mon, 16 Nov 2020 19:52:42 +0800

关于websocket的资料一大堆，但是关于webflux websocket的有用的太少了，由于项目中需要使用，花了几天时间终于搞通了，今天把主要关于推送的部分总结出来，便于以后参考 1. 服务端增加maven依赖

<properties>
        <java.version>1.8</java.version>
        <spring.version>5.2.3.RELEASE</spring.version>
        <reactor-netty.version>0.9.2.RELEASE</reactor-netty.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-reactor-netty</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>io.projectreactor.netty</groupId>
            <artifactId>reactor-netty</artifactId>
            <version>${reactor-netty.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-undertow</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

创建annotation (可以不这样实现，只是这样实现维护更容易些)

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface WebSocketMapping {
    String value() default "/ws";
}

定义映射

public class WebSocketHandlerMapping extends SimpleUrlHandlerMapping {
    private final Map<String, WebSocketHandler> webSocketHandlerMap = new ConcurrentHashMap<>();

    /**
     * 将使用WebSocketMapping自定义注解的bean放入handlerMapping
     *
     * @throws BeansException 异常
     */
    @Override
    public void initApplicationContext() throws BeansException {
        Map<String, Object> beanMap = obtainApplicationContext().getBeansWithAnnotation(WebSocketMapping.class);
        beanMap.values().forEach(bean -> {
            //使用WebSocketMapping注解的类 不是WebSocketHandler接口的实现,抛出异常
            if (!(bean instanceof WebSocketHandler)) {
                throw new RuntimeException(String.format("Controller [%s] doesn't implement WebSocketHandler interface.",
                        bean.getClass().getName()));
            }
            WebSocketMapping annotation = AnnotationUtils.getAnnotation(bean.getClass(), WebSocketMapping.class);
            //webSocketMapping 映射到管理中
            webSocketHandlerMap.put(annotation.value(), (WebSocketHandler) bean);
        });
        super.setOrder(Ordered.HIGHEST_PRECEDENCE);
        super.setUrlMap(webSocketHandlerMap);
        super.initApplicationContext();
    }
}

设置mapping和adapter

@Configuration
public class WebSocketConfiguration {

    @Bean
    public HandlerMapping webSocketMapping() {
        return new WebSocketHandlerMapping();
    }

    @Bean
    public WebSocketHandlerAdapter webSocketHandlerAdapter() {
        return new WebSocketHandlerAdapter();
    }

}

至此配置相关的就好了写handler

@Component
@WebSocketMapping("/hello-ws")
@Slf4j
public class HelloWordWebSocketHandler implements WebSocketHandler {

    @Override
    public Mono<Void> handle(WebSocketSession session) {
        EmitterProcessor<String> emitterProcessor = EmitterProcessor.create();
        return session.receive().doOnSubscribe(s -> {
            log.info("发起连接:{}", s);
            //可以将 emitterProcessor 放入一个给客户端发送消息的类中
            send(session,emitterProcessor);
            session.send(emitterProcessor.map(session::textMessage)).toProcessor();
        }).doOnTerminate(() -> {
            //连接中断，关闭session等信息
            log.info("doOnTerminate");
        }).doOnComplete(() -> {
            //处理完成
            log.info("doOnComplete");
        }).doOnCancel(() -> {
            log.info("doOnCancel");
        }).doOnNext(message -> {
           //持续接收消息处理
           if (message.getType().equals(WebSocketMessage.Type.BINARY)) {
           log.info("收到二进制消息");
           } else if (message.getType().equals(WebSocketMessage.Type.TEXT)) {
           String content = message.getPayloadAsText();
           log.info("收到文本消息 :{}", content);
           } else if (message.getType().equals(WebSocketMessage.Type.PING)) {
           log.info("收到ping消息");
           } else if (message.getType().equals(WebSocketMessage.Type.PONG)) {
           log.info("收到pong消息");
           }
           }).doOnError(e -> log.error("doOnError", e)).doOnRequest(r -> log.info("doOnRequest,{}", r)).then();
           }
        }).doOnError(e -> log.error("doOnError", e)).doOnRequest(r -> log.info("doOnRequest,{}", r)).then();
    }


    private void send(WebSocketSession session,EmitterProcessor<String> emitterProcessor)  {
        //只做演示使用，不要这样写
        try {
            for (int i=0; i<10; i++){
                log.info("发送消息给客户端: {} ",i);
                emitterProcessor.onNext(String.format("给客户端%s 推送消息 %d",session.getId(),i));
                TimeUnit.SECONDS.sleep(1);
            }
        } catch (InterruptedException e) {
            log.error("InterruptedException",e);
        }
    }
}

2.客户端

public class WSClient {
    public static void main(final String[] args) {
        Flux<String> input = Flux.<String>generate(sink -> sink.next(String.format("{ message: 'got message', date: '%s' }", new Date())))
                .delayElements(Duration.ofSeconds(7));
        EmitterProcessor<String> output = EmitterProcessor.create();
        final WebSocketClient client = new ReactorNettyWebSocketClient();
        Mono<Void> sessionMono = client.execute(URI.create("ws://localhost:8005/hello-ws") , session ->
                session.send(input.map(session::textMessage))
                        .thenMany(session.receive().map(WebSocketMessage::getPayloadAsText).subscribeWith(output).then())
                        .then());
        output.doOnSubscribe(s-> sessionMono.subscribe()).doOnNext(System.out::println).blockLast(Duration.ofSeconds(20));
    }
}

leetcode - 4寻找两个正序数组的中位数

Sat, 22 Aug 2020 17:17:35 +0800

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。

请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0
示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

leetcode - 3无重复字符的最长子串

Sat, 22 Aug 2020 10:40:46 +0800

给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。
示例
1: 输入: “abcabcbb”
输出: 3

解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:
输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:
输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是子串的长度，”pwke” 是一个子序列，不是子串。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s == null || "".equals(s)){
            return 0;
        }
        int maxLength = 0;
        int startIndex = 0;
        int endIndex = 1;
        int len = s.length();
        for (; endIndex < len; endIndex++) {
            char c = s.charAt(endIndex);
            int index = s.indexOf(c, startIndex);
            if (index < endIndex){
                maxLength = Math.max(maxLength, endIndex - startIndex);
                startIndex = index+1;
            }
        }
        return Math.max(maxLength, endIndex - startIndex);
    }
}

1.设置三个变量，一个存历史最长不重复串，一个当前子串起始下标，一个存结束下标；
2.遍历s字符串
3.取遍历到的字符c，判断字符是否在子串中出现过,若出现过走4，否则继续走2遍历。
4.取当前（不重复的）串长度与历史最大长度maxLength的最大值，设置为maxLength，新串开始下标设置成重复字符出现的下一个位置。继续2.
5.遍历完成后，将最大值子串长度返回。

leetcode - 2两数相加

Fri, 21 Aug 2020 17:09:06 +0800

给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
先上代码：

/**
  *已知的代码：
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode head = new ListNode(0);
        ListNode next = head;
        //进位
        int carry = 0;
        while(l1 != null || l2 != null || carry !=0){
            int v1 = l1 == null ? 0 : l1.val;
            int v2 = l2 == null ? 0 : l2.val;
             int v = v1 + v2 + carry;
             carry = v / 10;
             next.next = new ListNode(v%10);
             next = next.next;
             l1 = l1 != null ? l1.next : null;
             l2 = l2 != null ? l2.next : null;
        }
        return head.next;
    }
}

依次取两个链表的个位十位百位 … ，分别相加(个位对个位十位对十位…) ,保留进位,进位参与下一个高位运算（carry），将结果保存在新的链表返回。

leetcode - 1.两数之和

Fri, 21 Aug 2020 16:09:21 +0800

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
先上代码：

class Solution {
        public int[] twoSum(int[] nums, int target) {
            for (int i = 0; i < nums.length-1; i++) {
                for (int j = i+1 ; j < nums.length; j++) {
                    if (target == nums[i]+ nums[j]){
                        return new int[]{i,j};
                    }
                }
            }
        throw new RuntimeException("not found");
        }
    }

解析

从一个数组找两个数，它们的和为target。找第一个数需要一层循环遍历，找第二个数需要第二层遍历（或者用其他结构如：list.contain()），遍历时匹配两数和等于target的，找到将下标返回。

git代码写错分支恢复

Thu, 13 Aug 2020 20:29:01 +0800

起因：同事拉分支时是从dev拉的（原本应该从master），后续写的代码都在新分支上，也提交了，也推远程分支了。

分析：

由于远程也有代码，也不需要去做备份工作了，可以尽情的试错。可以试着用代码的回滚、暂存、切换分支、提取暂存代码、解决冲突（如果有）、提交代码…

git reset有三种模式： –soft –mixed –hard
git reset –soft commitId
//commitId 就是git log 查看到的 commit编号（SHA-1）
将HEAD引用指向给定提交（commitId）位置，索引（暂存区）和工作目录的内容是不变的，在三个命令中对现有的版本状态改动是最小的。

git reset –mixed commitId
reset的默认模式，将HEAD引用指向给定的commitId，注意：这时候索引（暂存区）内容也变了，工作目录内容不变。这个命令也就是所把commitId之后提交的状态都去掉了，文件还在，commitId之后有哪些修改都会保留，并且可以通过git status查看。

git reset –hard commitId
将HEAD引用指向给定的commitId，同时，索引（暂存区）内容和工作目录内容（文件）都会变成这个commitId对应的内容。也就是说给定的commitId之后的所有修改（文件）都会丢失。这个命令会用在发版时现在定位到指定commitId（清除commitId之后文件），然后合并分支，然后发版。类似的情况都可以用。

图表表示：

方式	影响范围
soft	HEAD
mixed	HEAD，Index/Cache
hard	HEAD，Index/Cache, working Tree

除了reset –hard外都可以用于本次操作。
当把代码reset后，就可以按照：暂存，切分支，取暂存，合并了

过程： 1.恢复到修改前的commitId，可以通过git log 查看，我是用sourceTree直接就找到commitId了
git reset d3b0972165dd522d79ac52cc3ac8842b8b6c53b1 Unstaged changes after reset: M pom.xml M …..其他的修改文件

可以通过git status再看下 git status

通过git stash 把暂存区的文件存储起来 git stash

切换分支 git chechout feature/XXX

恢复 git stash pop

MongoDB副本集

Thu, 30 Jul 2020 11:17:10 +0800

MongoDB的复制

MongoDB复制是将数据同步在多个服务器的过程.
复制提供了数据的冗余备份,并在多个服务器上存储数据副本,提高数据的可用性,并可以保证数据的安全行.
复制还允许您从硬件故障和服务中断中恢复数据.

复制的作用

保障数据的安全性
实现数据的高可用
灾难恢复
无需停机维护(如备份,重建索引,压缩)
分布式读取数据

MongoDB的复制原理

MongoDB的复制至少需要两个节点.其中一个是主节点,负责处理客户端的请求,其余的都是从节点,负责复制主节点上的数据.
MongoDB各个节点常见的搭配方式: 一主一从、一主多从.
实现复制的方式: 主节点记录在其上的所有操作oplog,从节点定期轮询主节点读取这些操作,然后对自己的数据副本执行这些操作,从而保证从节点的数据与主节点一致.
MongoDB的复制结构图:

从上结构图中,客户端从主节点读取数据,在客户端写入数据到主节点时,主节点与从节点进行数据交互保障数据的一致性.

副本集特征

N个节点的集群
任何节点都可作为主节点
所有的写入操作都在主节点上
自动故障转移
自动恢复

MongoDB副本集的设置

1 关闭正在运行的MongoDB服务器
通过指定–replSet选项启动MongoDB. –replSet基本语法格式如下.

  mongod --port  `PORT` --dbpath `DB_DATA_PATH` --replSet `REPLICA_SET_INSTANCE_NAME`
    // example
   mongod --port 27017 --dbpath "/data/db0" --replSet rs0

以上命令会启动一个名为rs0的MongoDB的实例,其端口号为:27017
启动后打开命令提示框并连接上MongoDB服务,在Mongo客户端使用rs.initiate() 来启动一个新的副本集.
我们可以使用rs.conf()来查看副本集的配置.
查看副本集状态使用rs.status()命令.

副本集添加成员

添加副本集的成员，我们需要使用多台服务器来启动mongo服务。进入Mongo客户端，并使用rs.add()方法来添加副本集的成员。

语法
rs.add() 命令基本语法格式如下：

>rs.add(HOST_NAME:PORT)

实例
假设你已经启动了一个名为mongod1.net，端口号为27017的Mongo服务。在客户端命令窗口使用rs.add() 命令将其添加到副本集中，命令如下所示：

>rs.add("mongod1.net:27017")

MongoDB中你只能通过主节点将Mongo服务添加到副本集中，判断当前运行的Mongo服务是否为主节点可以使用命令db.isMaster() 。

MongoDB的副本集与我们常见的主从有所不同，主从在主机宕机后所有服务将停止，而副本集在主机宕机后，副本会接管主节点成为主节点，不会出现宕机的情况。