Heck's Blog

项目要做一个后台消息推送，在测试过程中,发现每隔1分半自由,WebSocket会走OnError方法,将异常抛出,异常是java.io.EOFException.然后走@OnClose方法,将连接自动关闭,首先需要加上心跳，并且将nginx中加上proxy_read_timeout 设置为 2000s。

     heartCheckFun(){
        var that = this;
        //心跳检测,每20s心跳一次
        that.heartCheck = {
          timeout: 20000,
          timeoutObj: null,
          serverTimeoutObj: null,
          reset: function(){
            clearTimeout(this.timeoutObj);
            clearTimeout(this.serverTimeoutObj);
            return this;
          },
          start: function(){
            var self = this;
            this.timeoutObj = setTimeout(function(){
              //这里发送一个心跳，后端收到后，返回一个心跳消息，
              //onmessage拿到返回的心跳就说明连接正常
              that.websocketSend("HeartBeat");
              console.info("客户端发送心跳");
              self.serverTimeoutObj = setTimeout(function(){//如果超过一定时间还没重置，说明后端主动断开了
                that.websock.close();//如果onclose会执行reconnect，我们执行ws.close()就行了.如果直接执行reconnect 会触发onclose导致重连两次
              }, self.timeout)
            }, this.timeout)
          }
        }
      },

nginx的设置为:
location /{
      proxy_pass http://xx.xxx.xxx.xx:xxxx;
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";
      proxy_read_timeout 2000s;
      keepalive_timeout  2000s;
            proxy_set_header   Host    $host;
      proxy_set_header   X-Real-IP   $remote_addr;
      proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
  }

尽管设置2000s,但是当到达设置时间,如果websocket没有进行通讯,还是会断开连接.可以前端做一个心跳检测,每隔20秒钟发起一次通信就行.

希望能帮到你;

  location / {
      proxy_http_version 1.1;    
      proxy_set_header Upgrade $http_upgrade;    
      proxy_set_header Connection "Upgrade";    
      proxy_set_header X-real-ip $remote_addr;
      proxy_set_header X-Forwarded-For $remote_addr;
      proxy_pass http://localhost:6633/;
    }

最近在做项目时，需要要工具类中对属性进行赋值，里面有appID和appsecret，因为这两个都是相对固定不会变动的东西，所以配在配置文件 或者数据库配置表最好，这边使用的是配置文件(application.yml)，然后通过@Value()属性注入到对应的属性中。
刚开始在做的时候，启动项目后发现通过使用@Value注解对这两个属性进行赋值，结果两个都注不进去。

这个让我很苦恼，通过查找资料。找到了通过set的办法进行注入，并成功。

解决办法：

   1.将这两个私有属性的set方法从私有变成公开(private -->>> public);

   2.生成这两个静态属性的set方法；

   3.将原来在静态属性上的@Value() 注解改到设在 set方法上；

   4.去除这两个静态属性set方法的static关键字

类上面的@Compoent 注解一定要有，一定要注意set方法是没有static的，否则取不到值的。

Tess4j Issue in Windows: java.lang.UnsatisfiedLinkError: The specified module could not be found in instance.doOCR(imageFile)

Tess4j在本地跑的时候没有问题，放到windows server2008 r2服务器上的时候就报下面找不到模块的错误：

java.lang.UnsatisfiedLinkError: The specified module could not be found.

       at com.sun.jna.Native.open(Native Method) ~[jna.jar:4.2.1 (b0)]
       at com.sun.jna.NativeLibrary.loadLibrary(NativeLibrary.java:263) ~[jna.jar:4.2.1 (b0)]
       at com.sun.jna.NativeLibrary.getInstance(NativeLibrary.java:403) ~[jna.jar:4.2.1 (b0)]
       at com.sun.jna.Library$Handler.<init>(Library.java:147) ~[jna.jar:4.2.1 (b0)]
       at com.sun.jna.Native.loadLibrary(Native.java:502) ~[jna.jar:4.2.1 (b0)]
       at com.sun.jna.Native.loadLibrary(Native.java:481) ~[jna.jar:4.2.1 (b0)]
       at net.sourceforge.tess4j.util.LoadLibs.getTessAPIInstance(Unknown Source) ~[tess4j-3.0.jar:na]
       at net.sourceforge.tess4j.TessAPI.<clinit>(Unknown Source) ~[tess4j-3.0.jar:na]
       at net.sourceforge.tess4j.Tesseract.init(Unknown Source) ~[tess4j-3.0.jar:na]
       at net.sourceforge.tess4j.Tesseract.doOCR(Unknown Source) ~[tess4j-3.0.jar:na]
       at net.sourceforge.tess4j.Tesseract.doOCR(Unknown Source) ~[tess4j-3.0.jar:na]
       at net.sourceforge.tess4j.Tesseract.doOCR(Unknown Source) ~[tess4j-3.0.jar:na]
       at ocr.OCRController.handleFileUpload(OCRController.java:109) ~[classes/:na]
       at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_51]
       at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_51]
       at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_51]
       at java.lang.reflect.Method.invoke(Method.java:497) ~[na:1.8.0_51]

我搜索并发现人们建议更新Visual VisualC++可重分发软件包，我做了Visual Studio 2013，但结果却没有帮助，我仍然得到同样的问题。我不知道我做错了什么，下面是我的代码。

ITesseract instance = new Tesseract(); // JNA Interface Mapping

instance.setDatapath(new File(datapath).getPath());
instance.setLanguage("eng");      
try {
       String result = instance.doOCR(imageFile); //error here
} catch (TesseractException e) {
       System.err.println(e.getMessage());
}


此问题与Windows无关。
我已经把版本换回3.0
<dependency>
       <groupId>net.sourceforge.tess4j</groupId>
       <artifactId>tess4j</artifactId>
       <version>3.0.0</version>
</dependency>
替换所有以前的maven依赖项，就好了。

今天在项目中发现一个问题:使用shiro的时候，虽然隐藏掉了一些菜单，但是当我们通过get请求直接访问菜单的时候还是会访问到，也就是shiro可以在界面实现隐藏一些信息，但是没有真正的根据权限码验证请求，于是想自己在后台实现验证。
　　
需求:有权限(权限码是systemmanager:settings)的人可以点击系统设置跳转到系统设置页面，没权限的人看不到菜单，但是通过get访问可以访问到，于是需要在后台拦截。

实现思路:在需要精确验证的方法开始先验证权限，如果验证成功啥也不做，验证失败的话就抛出一个没有权限的异常。在拦截器中捕捉到异常就记录日志，并返回到提醒页面。


1.　　验证Shiro权限的工具类(此工具还可以进一步完善，封装为判断是否有指定角色，或者有任意角色)


package com.microxiang.common.util;

import com.microxiang.common.constant.ResultCode;
import com.microxiang.common.exception.user.NoPermissionException;
import com.microxiang.common.system.vo.LoginUser;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;

/**
* 验证shiro权限的工具类
*
* @author jiangjun
*/
@Slf4j
public class ShiroPermissionUtils {

    private ShiroPermissionUtils() {

    }

    /**
     * 检查当前用户是否有权限(任意一项)
     *
     * @param permissionCodes 任意权限
     * @throws NoPermissionException
     */
    public static void checkPermissionAny(String... permissionCodes) {
        if (permissionCodes == null || permissionCodes.length == 0) {
            return;
        }

        // 获取用户信息
        Subject currentUser = SecurityUtils.getSubject();
        for (String permission : permissionCodes) {
            boolean permitted = currentUser.isPermitted(permission);// 判断是否有权限
            if (permitted) {
                return;
            }
        }

        // 没权限就抛出一个异常
        Object principal = currentUser.getPrincipal();
        if (principal instanceof LoginUser) {
            LoginUser user = (LoginUser) principal;
            log.error("user {} no permission !", user.getUsername());
        }
        throw new NoPermissionException("user no permission !");
    }

    /**
     * 检查当前用户是否有权限(所有的)
     *
     * @param permissionCodes 任意权限
     * @throws NoPermissionException
     */
    public static void checkPermissionAll(String... permissionCodes) {
        if (permissionCodes == null || permissionCodes.length == 0) {
            return;
        }

        // 获取用户信息
        Subject currentUser = SecurityUtils.getSubject();
        for (String permission : permissionCodes) {
            boolean permitted = currentUser.isPermitted(permission);// 判断是否有权限
            if (!permitted) {
                // 没权限就抛出一个异常
                Object principal = currentUser.getPrincipal();
                if (principal instanceof LoginUser) {
                    LoginUser user = (LoginUser) principal;
                    log.error("user {} no permission !", user.getUsername());
                }
                throw new NoPermissionException("no permission ");
            }
        }
    }
}

Spring Boot项目在多环境下（开发、生产或测试环境）调用不同配置文件方式:

我们知道，一个项目在开发环境、测试环境、生产环境，不同的环境会有不同的配置，比如数据库的配置就不同，那么怎么样才能做到，不用每次换环境的时候，都去修改这些配置呢，下面以我写的一个小案例来作说明。

如下图是我项目的三个配置文件，其中，application.yml是启动服务时，服务器会自动加载的配置文件，而application-dev.yml代表的是开发环境的配置文件，application-prod.yml代表的是生产环境的配置文件，后两个文件在启动服务时，服务器不会自动加载，那么在不同的环境中时怎么调用不同的文件的呢？



方式一、修改配置文件方式

    修改application.yml配置文件，具体内容如下图：



这样，在启动服务时，服务器就会通过application.yml文件去调用application-dev.yml文件。同理，若active: prod,那么服务在启动时，服务器就会调用application-prod.yml文件。也就是说，在开发环境时，只需将application.yml配置文件配置为"dev",而生产环境时，只需将“dev”改为“prod”就可以了。

通过IDE创建一个springboot项目

<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>//这行红色
</plugin>

提示spring-boot-maven-plugin not found。在网上找了有说是通过添加<pluginRepositories>过解决，但是测试之后发觉不起作用。 经过多次尝试，最终spring-boot-maven-plugin指定版本后成功解决。 修改后的pom.xml文件

<plugin>  
<groupId>org.springframework.boot</groupId>  
<artifactId>spring-boot-maven-plugin</artifactId>  
<version>2.1.3.RELEASE</version>
</plugin>

其实说白了就是没有加上这些Maven插件的版本号，导致Maven无法自动下载插件到本地，基本上提示这个not found的错误都是这个问题引起的。

maven-surefire-plugin、maven-compiler-plugin
这些插件也会出现这种问题，解决方案同上。只要你本地有下这些插件，不管哪个版本，就不会提示这个错误，去掉版本号也无所谓。

一般情况下我们springboot用Application的main方法启动 ，怎么配置成tomcat启动呢？
首先有几个步骤：

1、<packaging>jar</packaging> 改为=> <packaging>war</packaging>

2、  排除springboot内置和tomcat容器（注：这一步可选）      
      
       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!-- 移除嵌入式tomcat插件--> 
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- 移除内嵌Tomcat需要重新添加servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet.version}</version>
            <scope>provided</scope>
        </dependency>

3、修改启动类，并重写初始化方法
我们平常用main方法启动的方式，都有一个App的启动类，代码如下：

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

分布式事务了解吗？你们是如何解决分布式事务问题的？
一般来说，分布式事务的实现主要有以下 5 种方案：

XA 方案
TCC 方案
本地消息表
可靠消息最终一致性方案
最大努力通知方案

两阶段提交方案/XA方案
所谓的 XA 方案，即：两阶段提交，有一个事务管理器的概念，负责协调多个数据库（资源管理器）的事务，事务管理器先问问各个数据库你准备好了吗？如果每个数据库都回复 ok，那么就正式提交事务，在各个数据库上执行操作；如果任何其中一个数据库回答不 ok，那么就回滚事务。

这种分布式事务方案，比较适合单块应用里，跨多个库的分布式事务，而且因为严重依赖于数据库层面来搞定复杂的事务，效率很低，绝对不适合高并发的场景。如果要玩儿，那么基于 Spring + JTA 就可以搞定，自己随便搜个 demo 看看就知道了。

这个方案，我们很少用，一般来说某个系统内部如果出现跨多个库的这么一个操作，是不合规的。我可以给大家介绍一下， 现在微服务，一个大的系统分成几十个甚至几百个服务。一般来说，我们的规定和规范，是要求每个服务只能操作自己对应的一个数据库。

如果你要操作别的服务对应的库，不允许直连别的服务的库，违反微服务架构的规范，你随便交叉胡乱访问，几百个服务的话，全体乱套，这样的一套服务是没法管理的，没法治理的，可能会出现数据被别人改错，自己的库被别人写挂等情况。

如果你要操作别人的服务的库，你必须是通过调用别的服务的接口来实现，绝对不允许交叉访问别人的数据库。


TCC 方案
TCC 的全称是：Try、Confirm、Cancel。

Try 阶段：这个阶段说的是对各个服务的资源做检测以及对资源进行锁定或者预留。
Confirm 阶段：这个阶段说的是在各个服务中执行实际的操作。
Cancel 阶段：如果任何一个服务的业务方法执行出错，那么这里就需要进行补偿，就是执行已经执行成功的业务逻辑的回滚操作。（把那些执行成功的回滚）
这种方案说实话几乎很少人使用，我们用的也比较少，但是也有使用的场景。因为这个事务回滚实际上是严重依赖于你自己写代码来回滚和补偿了，会造成补偿代码巨大，非常之恶心。

比如说我们，一般来说跟钱相关的，跟钱打交道的，支付、交易相关的场景，我们会用 TCC，严格保证分布式事务要么全部成功，要么全部自动回滚，严格保证资金的正确性，保证在资金上不会出现问题。

而且最好是你的各个业务执行的时间都比较短。

但是说实话，一般尽量别这么搞，自己手写回滚逻辑，或者是补偿逻辑，实在太恶心了，那个业务代码很难维护。

​
本地消息表
本地消息表其实是国外的 ebay 搞出来的这么一套思想。

这个大概意思是这样的：

A 系统在自己本地一个事务里操作同时，插入一条数据到消息表；
接着 A 系统将这个消息发送到 MQ 中去；
B 系统接收到消息之后，在一个事务里，往自己本地消息表里插入一条数据，同时执行其他的业务操作，如果这个消息已经被处理过了，那么此时这个事务会回滚，这样保证不会重复处理消息；
B 系统执行成功之后，就会更新自己本地消息表的状态以及 A 系统消息表的状态；
如果 B 系统处理失败了，那么就不会更新消息表状态，那么此时 A 系统会定时扫描自己的消息表，如果有未处理的消息，会再次发送到 MQ 中去，让 B 再次处理；
这个方案保证了最终一致性，哪怕 B 事务失败了，但是 A 会不断重发消息，直到 B 那边成功为止。
这个方案说实话最大的问题就在于严重依赖于数据库的消息表来管理事务啥的，会导致如果是高并发场景咋办呢？咋扩展呢？所以一般确实很少用。

今天使用RequestBody接受前端传过来的参数，以前接受字符串数组非常成功，这次把形参改成了List，原本以为顺利接受参数并映射成User的list结构，结果竟然在我取user.getId()时报了com.alibaba.fastjson.JSONObject cannot be cast to xxx的错。

后端：
@RequestMapping("/insertUser")
public void insertBlank(@RequestBody List userList) {
     User user = userList.get(0);
     System.out.println(user.getId());
}


我的user对象没有转换成功，还是一个一个JSONObject，但是请观察，JSONArray转换成了ArrayList。

　　嗯，配置的映射转换器生效了，结果表明，RequestBody能直接将json对象映射成java对象，但仅限于第一层的对象，至于嵌套的对象，则需要开发者自己去转换。

@RequestMapping("/insertUser")
public void insertUser(@RequestBody List list) {
    List userList = list.stream().map(json -> JSONObject.toJavaObject(json, User.class)).collect(Collectors.toList());
   service.insertUser(userList);
}