思维网络|站长博客|陈配锋

分类： 未分类

  • Springboot2整合log4j2

    1、引入依赖

    		<!-- 引入log4j2依赖 -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-simple</artifactId>
			<version>1.7.25</version>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-api</artifactId>
			<version>2.18.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-core</artifactId>
			<version>2.18.0</version>
		</dependency>
		<!--<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-log4j2</artifactId>
		</dependency>-->

    2、在resources中添加配置文件log4j2.xml

    <?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
<configuration monitorInterval="10">

    <!--先定义所有的appender-->
    <appenders>

        <!--*********************控制台日志***********************-->
        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <!--<PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>-->
            <!--设置日志格式及颜色-->
            <PatternLayout
                    pattern="%style{%d{ISO8601}}{bright,green} %highlight{%-5level} [%style{%t}{bright,blue}] %style{%C{}}{bright,yellow}: %msg%n%style{%throwable}{red}"
                    disableAnsi="false" noConsoleNoAnsi="false"/>
        </console>
        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，这个也挺有用的，适合临时测试用-->
        <!--<File name="log" fileName="log/test.log" append="false">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>-->

        <!--*********************文件日志***********************-->
        <!--all级别日志-->
        <RollingFile name="RollingFileAll"
                     fileName="./logs/all.log"
                     filePattern="./logs/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <!--设置日志格式-->
            <PatternLayout>
                <pattern>%d %p %C{} [%t] %m%n</pattern>
            </PatternLayout>
            <Policies>
                <!-- 设置日志文件切分参数 -->
                <!--<OnStartupTriggeringPolicy/>-->
                <!--设置日志基础文件大小，超过该大小就触发日志文件滚动更新-->
                <SizeBasedTriggeringPolicy size="100 MB"/>
                <!--设置日志文件滚动更新的时间，依赖于文件命名filePattern的设置-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <!--设置日志的文件个数上限，不设置默认为7个，超过大小后会被覆盖；依赖于filePattern中的%i-->
            <DefaultRolloverStrategy max="100"/>
        </RollingFile>

        <!-- debug，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileDebug"
                     fileName="./logs/debug.log"
                     filePattern="./logs/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <!--只记录debug及以上级别的日志-->
            <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <!-- 设置日志文件切分参数 -->
                <!--<OnStartupTriggeringPolicy/>-->
                <!--设置日志基础文件大小，超过该大小就触发日志文件滚动更新-->
                <SizeBasedTriggeringPolicy size="100 MB"/>
                <!--设置日志文件滚动更新的时间，依赖于文件命名filePattern的设置-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>

        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileInfo"
                     fileName="./logs/info.log"
                     filePattern="./logs/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <!--只记录info及以上级别的日志-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <!-- 设置日志文件切分参数 -->
                <!--<OnStartupTriggeringPolicy/>-->
                <!--设置日志基础文件大小，超过该大小就触发日志文件滚动更新-->
                <SizeBasedTriggeringPolicy size="100 MB"/>
                <!--设置日志文件滚动更新的时间，依赖于文件命名filePattern的设置-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>

        <RollingFile name="RollingFileWarn"
                     fileName="./logs/warn.log"
                     filePattern="./logs/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
            <!--只记录warn及以上级别的日志-->
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <!-- 设置日志文件切分参数 -->
                <!--<OnStartupTriggeringPolicy/>-->
                <!--设置日志基础文件大小，超过该大小就触发日志文件滚动更新-->
                <SizeBasedTriggeringPolicy size="100 MB"/>
                <!--设置日志文件滚动更新的时间，依赖于文件命名filePattern的设置-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>

        <RollingFile name="RollingFileError"
                     fileName="./logs/error.log"
                     filePattern="./logs/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log">
            <!--只记录error及以上级别的日志-->
            <ThresholdFilter level="ERROR" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <!-- 设置日志文件切分参数 -->
                <!--<OnStartupTriggeringPolicy/>-->
                <!--设置日志基础文件大小，超过该大小就触发日志文件滚动更新-->
                <SizeBasedTriggeringPolicy size="100 MB"/>
                <!--设置日志文件滚动更新的时间，依赖于文件命名filePattern的设置-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>

        <!-- sql输出文件 -->
        <RollingFile name="SQL"
                     fileName="./logs/sql.log"
                     filePattern="./logs/$${date:yyyy-MM}/sql-%d{yyyy-MM-dd}-%i.log">
            <!--<ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY"/>-->
            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <!-- 设置日志文件切分参数 -->
                <!--<OnStartupTriggeringPolicy/>-->
                <!--设置日志基础文件大小，超过该大小就触发日志文件滚动更新-->
                <SizeBasedTriggeringPolicy size="100 MB"/>
                <!--设置日志文件滚动更新的时间，依赖于文件命名filePattern的设置-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>

    </appenders>

    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>

        <!-- 根日志设置 -->
        <root level="all">
            <appender-ref ref="RollingFileAll" level="all"/>
            <appender-ref ref="Console" level="debug"/>
            <appender-ref ref="RollingFileDebug" level="debug"/>
            <appender-ref ref="RollingFileInfo" level="info"/>
            <appender-ref ref="RollingFileWarn" level="warn"/>
            <appender-ref ref="RollingFileError" level="error"/>
        </root>

        <!--只记录spring的info及以上级别的日志-->
        <logger name="org.springframework" level="WARN"/>

        <!--只记录hibernate的info及以上级别的日志-->
        <logger name="org.hibernate" level="WARN">
            <!-- 添加如下设置，控制台会再打印一次 -->
            <!-- <AppenderRef ref="Console"/> -->
        </logger>

       <!-- <logger name="com.zero4j" level="DEBUG" additivity="false">
            <appender-ref ref="Console"/>
        </logger>-->

    </loggers>

</configuration>

    3、在需要日志的类中添加静态变量（如果使用lombok的@Log4j2注解则可以省略这步）

    public final static Logger logger = LogManager.getLogger(MerchantDailySettlementQuartz.class.getName());

    4、打印日志

    		log.debug("debug:执行生成商户日结算单定时器");

		log.info("info:执行生成商户日结算单定时器");

		log.warn("warn:执行生成商户日结算单定时器");

     

  • 证书格式转换： pem转成ppk

    1. 下载Puttygen.exe:

    http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html

    2. 双击启动Puttygen.exe

    3. 载入私钥（点击左上角的“文件-载入私钥”）：

    20220822183521

    4. 提示导入成功后，点击“保存私钥”即可：

    20220822183521

     

  • 阿里云ECS服务器由密码登录改为密钥登录

    1、获取私钥20220827161812

     

    2、私钥绑定ECS

    20220827161812

    3、生成公钥

    传到阿里云ECS的任意一个地方，执行以下指令获得公钥并自动添加到/root/.ssh/authorized_keys中：

    ssh-keygen -y -f /私钥的绝对路径/私钥名称  >>/root/.ssh/authorized_keys

    如果报权限不足，则需要先执行：

    chmod 400 /私钥的绝对路径/私钥名称

    若有多个用户，则执行多次ssh-keygen指令即可追加到/root/.ssh/authorized_keys中

    4、后续链接使用阿里云申请私钥时下载的文件即可。

     

    附加禁止密码登录root账号的方法

    找到配置文件/etc/ssh/sshd_config，修改PasswordAuthentication属性为no后执行service sshd restart命令即可生效，配置如下图：

    20220827161812

    但是要注意，禁止密码登录后，如果密钥无法登录，后期只能挂在liveCD盘（类似于PE取消关于密码的设置）

  • 海马遥控器匹配

    1、把车停好，四门关好

    2、熄火把钥匙，然后把左前门（驾驶室旁边主控门）开关三次

    3、在三秒内插入钥匙并连续开关五次（不用起动发动机）

    4、以上步骤在十秒内完成，拔出钥匙按旧遥控器上的开钥和关钥键，此时可听到遥控反应，遥控反应后再按新遥控器上的开钥和关钥，如果遥控器有反应则说明遥控匹配成功。

    5、据说此方法可以用于福来美、普力马、海福星（未验证）

  • 115转存助手ui优化版v3.6 (143.2022.0616.1)

    脚本文件：

    115转存助手ui优化版v3.6 (143.2022.0616.1)

     

    git仓库：

    https://github.com/Nerver4Ever/SevenSha1UIAdvancedHelper

  • java使用jedis执行lua脚本

    1、引入依赖

    		<!-- Jedis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
		</dependency>

    2、编写配置文件

    #Redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.database=3

spring.redis.password=
spring.redis.timeout=2000

#Jedis
#最大空闲数
spring.redis.jedis.pool.max-idle=6
#最大连接数
spring.redis.jedis.pool.max-active=10
#最小空闲数
spring.redis.jedis.pool.min-idle=2
#连接超时
spring.redis.jedis.pool.timeout=2000

    3、编写配置类

    package com.zero4j.config;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class JedisConfig {

    private Logger logger = LoggerFactory.getLogger(JedisConfig.class);

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;

    @Bean
    public JedisPool jedisPool(){

        JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMinIdle(minIdle);
        jedisPoolConfig.setMaxTotal(maxActive);

        JedisPool jedisPool = new JedisPool(jedisPoolConfig,host,port,timeout,password);

        logger.info("JedisPool连接成功:"+host+"\t"+port);

        return jedisPool;
    }

}

    4、实现业务逻辑

    	@Autowired
	private JedisPool jedisPool;

     

    		Jedis jedis = null;

		try {
			jedis = jedisPool.getResource();
			String poolId = "pool1";
			String poolLuaRedisKey = "cardLottery." + poolId + "-lua-shaKey";
			String poolLuaRedisValue = jedis.get(poolLuaRedisKey);
			byte[] shaKey = null;
			if(poolLuaRedisValue!=null){
				shaKey = poolLuaRedisValue.getBytes();
			}
			if (shaKey == null) {
				ClassPathResource cps = new ClassPathResource("lua/test.lua");
				InputStream in = cps.getInputStream();
				byte[] data = new byte[in.available()];
				in.read(data);
				shaKey = jedis.scriptLoad(data);
				jedis.set("cardLottery." + poolId + "-lua-shaKey", new String(shaKey));
			}

			System.out.println("本次执行的lua脚本的sha为：" + new String(shaKey));

			List<String> keys = new ArrayList<>();
			keys.add(poolId);
			keys.add("100");
			keys.add("0.5");
			List<String> vals = new ArrayList<>();
			for (int i = 0; i < 10; i++) {
				Date _startTime = new Date();
				Object result = jedis.evalsha(new String(shaKey), keys, vals);
				Date _endTime = new Date();
				long _timeCross = _endTime.getTime() - _startTime.getTime();
				System.out.println("lua的第" + (i + 1) + "次执行花了" + _timeCross + "毫秒，执行结果：" + result);
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally {
			if(jedis!=null){
				jedis.close();
			}
		}

    5、Lua脚本

    local key = 'cardPool.'..KEYS[1]..'-bucket' -- redis中令牌桶对象的key
local initTokens = tonumber(KEYS[2]) -- {初始化时的令牌数}
local probability = tonumber(KEYS[3]) -- {中奖概率：小于0的数字（百分比概念）}

print(probability)

local bucket = redis.call('hgetall', key) -- 当前 key 的令牌桶对象
local currentTokens -- 当前token数量
local runCount -- 累计执行次数统计

-- 若当前桶未初始化,先初始化令牌桶
if table.maxn(bucket) == 0 then
    -- 初始桶内令牌
    currentTokens = initTokens
    runCount = 0
    redis.call('hset', key, 'stock', currentTokens)
    redis.call('hset', key, 'probability', probability)
    redis.call('hset', key, 'runCount', 0)
elseif table.maxn(bucket) == 6 then
    currentTokens = tonumber(bucket[2])
    probability = tonumber(bucket[4])
    runCount = tonumber(bucket[6])
end

-- 如果当前桶内令牌小于 0,抛出异常
assert(currentTokens >= 0)

redis.call('hset', key, 'runCount', runCount + 1)

if currentTokens == 0 then  -- 如果当前令牌 == 0, 返回false
    return -1
else    -- 如果当前令牌 大于 0, 则执行抽奖逻辑
    if probability<> nil or probability >= 1 or math.random() <= probability then -- 如果中奖概率大于或等于1，生成随机的小数如果在probability内，则中奖
        -- 更新当前桶内的令牌 -1, 返回true
        redis.call('hset', key, 'stock', currentTokens - 1)
        return 1
    else
        return 0
    end
end

    注意：如果Lua脚本返回是true和false的类型，则jedis实际获得的值为1和null。

     

  • java使用lua脚本操作redis的相关笔记

    Lua脚本

    local key = 'cardPool.'..KEYS[1]..'-stock' -- redis中令牌桶对象的key
local initTokens = tonumber(KEYS[2]) -- {初始化时的库存数量}

local bucket = redis.call('hgetall', key) -- 当前 key 的令牌桶对象
local currentTokens -- 当前token数量
local runCount -- 累计运行次数统计

-- 若当前桶未初始化,先初始化令牌桶
if table.maxn(bucket) == 0 then
    -- 初始桶内令牌
    currentTokens = initTokens
    runCount = 0
elseif table.maxn(bucket) == 4 then
    currentTokens = tonumber(bucket[2])
    runCount = tonumber(bucket[4])
end

-- 如果当前桶内令牌小于 0,抛出异常
assert(currentTokens >= 0)

-- 如果当前令牌 == 0, 返回false
if currentTokens == 0 then
    redis.call('hset', key, 'tokensRemaining', currentTokens)
    redis.call('hset', key, 'runCount', runCount + 1)
    return false
else
    -- 如果当前令牌 大于 0, 更新当前桶内的令牌 -1, 返回true
    redis.call('hset', key, 'tokensRemaining', currentTokens - 1)
    redis.call('hset', key, 'runCount', runCount + 1)
    return true
end

    JAVA运行Lua脚本：

    		DefaultRedisScript<Boolean> redisScript = new DefaultRedisScript<>();
		redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/test.lua")));
		redisScript.setResultType(Boolean.class);

		Boolean result = true;
		long count = 0;
		do{
			Date _startTime = new Date();
			List<String> keys = Arrays.asList("pool1", "10000");
			try{
				result = redisTemplate.execute(redisScript, keys);
			}catch(Exception e){
				e.printStackTrace();
			}
			Date _endTime = new Date();
			long _timeCross = _endTime.getTime()- _startTime.getTime();
			count++;
			System.out.println("lua的第"+count+"次执行花了"+_timeCross+"毫秒");
		}while(result==true);

    注意hgetall返回的redis变量读取方式

  • lua脚本将两个字符串变量相加的方法

    C = A..B,用..连接，或者C=table.concat({A,B})，后面这种写着麻烦，不过组合大量字符串时效率高。

  • Restful 返回数据格式

    返回数据的一般格式：

    {
    “code”: 1,
    “mssage”: “返回的信息”,
    “data”: {
    “list”:[
    {
    “title”:”xxx”,
    “contents”:”xxx”,
    },{
    “title”:”xxx”,
    “contents”:”xxx”,
    }
    ]
    “total”:21,
    },
    “extra”: {},
    “pageNum”: 3,
    “pageSize”: 20,
    “totalSize”: 235
    }

    code的一般含义

    public enum ResultCode {

  /* 成功状态码 */
  SUCCESS(0, "成功"),

  /* 令牌失效 */
  TOKEN_INVALID(401,"令牌失效"),

  SERVER_ERROR(400, "服务器错误"),

  /*参数错误 10001-19999 */

  PARAM_IS_INVALID(10001, "参数无效"),
  PARAM_IS_BLANK(10002, "参数为空"),
  PARAM_TYPE_BIND_ERROR(10003, "参数类型错误"),
  PARAM_NOT_COMPLETE(10004, "参数缺失"),

  /* 用户错误：20001-29999*/
  USER_NOT_LOGGED_IN(20001, "用户未登录"),
  USER_LOGIN_ERROR(20002, "账号不存在或密码错误"),
  USER_ACCOUNT_FORBIDDEN(20003, "账号已被禁用"),
  USER_NOT_EXIST(20004, "用户不存在"),
  USER_HAS_EXISTED(20005, "用户已存在"),
  Cert_HAS_EXISTED(20006, "认证已存在"),


  /* 业务错误：30001-39999 */
  CREATE_FAIL(30001, "创建失败"),

  /* 系统错误：40001-49999 */
  SYSTEM_INNER_ERROR(40001, "系统繁忙，请稍后重试"),

  /* 数据错误：50001-599999 */
  RESULE_DATA_NONE(50001, "数据未找到"),
  DATA_IS_WRONG(50002, "数据有误"),
  DATA_ALREADY_EXISTED(50003, "数据已存在"),

  /* 接口错误：60001-69999 */
  INTERFACE_INNER_INVOKE_ERROR(60001, "内部系统接口调用异常"),
  INTERFACE_OUTTER_INVOKE_ERROR(60002, "外部系统接口调用异常"),
  INTERFACE_FORBID_VISIT(60003, "该接口禁止访问"),
  INTERFACE_ADDRESS_INVALID(60004, "接口地址无效"),
  INTERFACE_REQUEST_TIMEOUT(60005, "接口请求超时"),
  INTERFACE_EXCEED_LOAD(60006, "接口负载过高"),

  /* 权限错误：70001-79999 */
  PERMISSION_NO_ACCESS(70001, "只有标签 Owner ,才具备删除权限"),
  PERMISSION_NO_PHONE_ACCESS(70002,"此认证标签已有员工认证，不可以进行删除");
  
}

     

  • 使用uniapp的安心打包制作ios安装文件时出现PKCS12 import (wrong password?)

    假如你确定你的证书密码是对的，就是死活不成功，出现如下提示：

    [Info] begin copyFile files to ipa...
[Info] begin replace files to ipa...
[Info] begin update mobileprovision to ipa...
[Info] begin outPut t_entitlements_full plist file...
[Info] begin outPut outPutEntitlements plist file...
[Info] begin verifyPlistFiles
[Info] begin update files to ipa...
[Info] begin createKeychain...
[Info] begin unlockKeychain...
[Info] begin setListKeychains...
[Info] begin importAppleCerts...
[Info] 1 certificate imported.
[Info] 1 certificate imported.
[Info] 1 certificate imported.
[Info] begin importSecurity...
[Error] security: SecKeychainItemImport: MAC verification failed during PKCS12 import (wrong password?)
[Error] importSecurity failed
[Info] Package make result:Failed.    Reason:

    那有可能是因为导出p12证书的时候密码过于简单，不符合要求，导致后续证书使用时的安检失败引起的。请重新导出新的、且符合密码强度要求的p12证书。