nginx的日志配置

nginx有一个非常灵活的日志记录模式。每个级别的配置可以有各自独立的访问日志。日志格式通过log_format命令来定义。 ngx_http_log_module 是用来定义请求日志格式的。

nginx日志相关的配置有log_format、access_log、open_log_file_cache、log_not_found、log_subrequest、rewrite_log、error_log。这些配置主要分2类：日志记录格式，日志类型及位置。

  • access_log指令

语法: access_log path [format [buffer=size [flush=time]]];

access_log path format gzip[=level] [buffer=size] [flush=time];
access_log syslog:server=address[,parameter=value] [format];
access_log off;

默认值: access_log logs/access.log combined;
配置段: http, server, location, if in location, limit_except

gzip压缩等级。
buffer设置内存缓存区大小。
flush保存在缓存区中的最长时间。
不记录日志：access_log off;
使用默认combined格式记录日志：access_log logs/access.log 或 access_log logs/access.log combined;

  • log_format指令

语法: log_format name string …;
默认值: log_format combined “…”;
配置段: http

name表示格式名称，string表示等义的格式。log_format有一个默认的无需设置的combined日志格式，相当于apache的combined日志格式，如下所示：

log_format  combined  ‘$remote_addr – $remote_user  [$time_local]  ‘
‘ “$request”  $status  $body_bytes_sent  ‘
‘ “$http_referer”  “$http_user_agent” ‘;

如果nginx位于负载均衡器，squid，nginx反向代理之后，web服务器无法直接获取到客户端真实的IP地址了。 $remote_addr获取反向代理的IP地址。反向代理服务器在转发请求的http头信息中，可以增加X-Forwarded-For信息，用来记录 客户端IP地址和客户端请求的服务器地址。如下所示

log_format  porxy  ‘$http_x_forwarded_for – $remote_user  [$time_local]  ‘
‘ “$request”  $status $body_bytes_sent ‘
‘ “$http_referer”  “$http_user_agent” ‘;

日志格式允许包含的变量注释如下：

$remote_addr, $http_x_forwarded_for 记录客户端IP地址
$remote_user 记录客户端用户名称
$request 记录请求的URL和HTTP协议
$status 记录请求状态
$body_bytes_sent 发送给客户端的字节数，不包括响应头的大小； 该变量与Apache模块mod_log_config里的“%B”参数兼容。
$bytes_sent 发送给客户端的总字节数。
$connection 连接的序列号。
$connection_requests 当前通过一个连接获得的请求数量。
$msec 日志写入时间。单位为秒，精度是毫秒。
$pipe 如果请求是通过HTTP流水线(pipelined)发送，pipe值为“p”，否则为“.”。
$http_referer 记录从哪个页面链接访问过来的
$http_user_agent 记录客户端浏览器相关信息
$request_length 请求的长度（包括请求行，请求头和请求正文）。
$request_time 请求处理时间，单位为秒，精度毫秒； 从读入客户端的第一个字节开始，直到把最后一个字符发送给客户端后进行日志写入为止。
$time_iso8601 ISO8601标准格式下的本地时间。
$time_local 通用日志格式下的本地时间。

发送给客户端的响应头拥有“sent_http_”前缀。 比如$sent_http_content_range。

实例如下：

http {
log_format  main  ‘$remote_addr – $remote_user [$time_local] “$request” ‘
‘”$status” $body_bytes_sent “$http_referer” ‘
‘”$http_user_agent” “$http_x_forwarded_for” ‘
‘”$gzip_ratio” $request_time $bytes_sent $request_length’; log_format srcache_log ‘$remote_addr – $remote_user [$time_local] “$request” ‘
‘”$status” $body_bytes_sent $request_time $bytes_sent $request_length ‘
‘[$upstream_response_time] [$srcache_fetch_status] [$srcache_store_status] [$srcache_expire]’;

open_log_file_cache max=1000 inactive=60s;

server {
server_name ~^(www\.)?(.+)$;
access_log logs/$2-access.log main;
error_log logs/$2-error.log;

location /srcache {
access_log logs/access-srcache.log srcache_log;
}
}
}

  • open_log_file_cache指令

语法: open_log_file_cache max=N [inactive=time] [min_uses=N] [valid=time];
open_log_file_cache off;
默认值: open_log_file_cache off;
配置段: http, server, location

对于每一条日志记录，都将是先打开文件，再写入日志，然后关闭。可以使用open_log_file_cache来设置日志文件缓存(默认是off)，格式如下：

参数注释如下：
max:设置缓存中的最大文件描述符数量，如果缓存被占满，采用LRU算法将描述符关闭。
inactive:设置存活时间，默认是10s
min_uses:设置在inactive时间段内，日志文件最少使用多少次后，该日志文件描述符记入缓存中，默认是1次
valid:设置检查频率，默认60s
off：禁用缓存
实例如下：

open_log_file_cache max=1000 inactive=20s valid=1m min_uses=2;

  • log_not_found指令

语法: log_not_found on | off;
默认值: log_not_found on;
配置段: http, server, location
是否在error_log中记录不存在的错误。默认是。

  • log_subrequest指令

语法: log_subrequest on | off;
默认值: log_subrequest off;
配置段: http, server, location
是否在access_log中记录子请求的访问日志。默认不记录。

  • rewrite_log指令

由ngx_http_rewrite_module模块提供的。用来记录重写日志的。对于调试重写规则建议开启。 Nginx重写规则指南
语法: rewrite_log on | off;
默认值: rewrite_log off;
配置段: http, server, location, if
启用时将在error log中记录notice级别的重写日志。

  • error_log指令

语法: error_log file | stderr | syslog:server=address[,parameter=value] [debug | info | notice | warn | error | crit | alert | emerg];
默认值: error_log logs/error.log error;
配置段: main, http, server, location
配置错误日志。

基于Redis的分布式锁

应用场景

当多个机器（多个进程）会对同一条数据进行修改时，并且要求这个修改是原子性的。这里有两个限定：（1）多个进程之间的竞争，意味着JDK自带的锁失效；（2）原子性修改，意味着数据是有状态的，修改前后有依赖。

实现方式

  • 基于Redis实现，主要基于redis的setnx（set if not exist）命令；
  • 基于Zookeeper实现；
  • 基于version字段实现，乐观锁，两个线程可以同时读取到原有的version值，但是最终只有一个可以完成操作；

这三种方式中，我接触过第一和第三种。基于redis的分布式锁功能更加强大，可以实现阻塞和非阻塞锁。

基于Redis的实践

锁的实现

  • 锁的key为目标数据的唯一键，value为锁的期望超时时间点；
  • 首先进行一次setnx命令，尝试获取锁，如果获取成功，则设置锁的最终超时时间（以防在当前进程获取锁后奔溃导致锁无法释放）；如果获取锁失败，则检查当前的锁是否超时，如果发现没有超时，则获取锁失败；如果发现锁已经超时（即锁的超时时间小于等于当前时间），则再次尝试获取锁，取到后判断下当前的超时时间和之前的超时时间是否相等，如果相等则说明当前的客户端是排队等待的线程里的第一个尝试获取锁的，让它获取成功即可。
    基于redis实现分布式锁逻辑.png
public class RedisDistributionLock {

    private static final Logger logger = LoggerFactory.getLogger(RedisDistributionLock.class);

    //key的TTL,一天
    private static final int finalDefaultTTLwithKey = 24 * 3600;

    //锁默认超时时间,20秒
    private static final long defaultExpireTime = 20 * 1000;

    private static final boolean Success = true;
    
    @Resource( name = "redisTemplate")
    private RedisTemplate<String, String> redisTemplateForGeneralize;

    /**
     * 加锁,锁默认超时时间20秒
     * @param resource
     * @return
     */
    public boolean lock(String resource) {
        return this.lock(resource, defaultExpireTime);
    }

    /**
     * 加锁,同时设置锁超时时间
     * @param key 分布式锁的key
     * @param expireTime 单位是ms
     * @return
     */
    public boolean lock(String key, long expireTime) {

        logger.debug("redis lock debug, start. key:[{}], expireTime:[{}]",key,expireTime);
        long now = Instant.now().toEpochMilli();
        long lockExpireTime = now + expireTime;

        //setnx
        boolean executeResult = redisTemplateForGeneralize.opsForValue().setIfAbsent(key,String.valueOf(lockExpireTime));
        logger.debug("redis lock debug, setnx. key:[{}], expireTime:[{}], executeResult:[{}]", key, expireTime,executeResult);

        //取锁成功,为key设置expire
        if (executeResult == Success) {
            redisTemplateForGeneralize.expire(key,finalDefaultTTLwithKey, TimeUnit.SECONDS);
            return true;
        }
        //没有取到锁,继续流程
        else{
            Object valueFromRedis = this.getKeyWithRetry(key, 3);
            // 避免获取锁失败,同时对方释放锁后,造成NPE
            if (valueFromRedis != null) {
                //已存在的锁超时时间
                long oldExpireTime = Long.parseLong((String)valueFromRedis);
                logger.debug("redis lock debug, key already seted. key:[{}], oldExpireTime:[{}]",key,oldExpireTime);
                //锁过期时间小于当前时间,锁已经超时,重新取锁
                if (oldExpireTime <= now) {
                    logger.debug("redis lock debug, lock time expired. key:[{}], oldExpireTime:[{}], now:[{}]", key, oldExpireTime, now);
                    String valueFromRedis2 = redisTemplateForGeneralize.opsForValue().getAndSet(key, String.valueOf(lockExpireTime));
                    long currentExpireTime = Long.parseLong(valueFromRedis2);
                    //判断currentExpireTime与oldExpireTime是否相等
                    if(currentExpireTime == oldExpireTime){
                        //相等,则取锁成功
                        logger.debug("redis lock debug, getSet. key:[{}], currentExpireTime:[{}], oldExpireTime:[{}], lockExpireTime:[{}]", key, currentExpireTime, oldExpireTime, lockExpireTime);
                        redisTemplateForGeneralize.expire(key, finalDefaultTTLwithKey, TimeUnit.SECONDS);
                        return true;
                    }else{
                        //不相等,取锁失败
                        return false;
                    }
                }
            }
            else {
                logger.warn("redis lock,lock have been release. key:[{}]", key);
                return false;
            }
        }
        return false;
    }

    private Object getKeyWithRetry(String key, int retryTimes) {
        int failTime = 0;
        while (failTime < retryTimes) {
            try {
                return redisTemplateForGeneralize.opsForValue().get(key);
            } catch (Exception e) {
                failTime++;
                if (failTime >= retryTimes) {
                    throw e;
                }
            }
        }
        return null;
    }

    /**
     * 解锁
     * @param key
     * @return
     */
    public boolean unlock(String key) {
        logger.debug("redis unlock debug, start. resource:[{}].",key);
        redisTemplateForGeneralize.delete(key);
        return Success;
    }
}

自定义注解使用分布式锁

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RedisLockAnnoation {

    String keyPrefix() default "";

    /**
     * 要锁定的key中包含的属性
     */
    String[] keys() default {};

    /**
     * 是否阻塞锁；
     * 1. true：获取不到锁，阻塞一定时间；
     * 2. false：获取不到锁，立即返回
     */
    boolean isSpin() default true;

    /**
     * 超时时间
     */
    int expireTime() default 10000;

    /**
     * 等待时间
     */
    int waitTime() default 50;

    /**
     * 获取不到锁的等待时间
     */
    int retryTimes() default 20;
}

实现分布式锁的逻辑

@Component
@Aspect
public class RedisLockAdvice {

    private static final Logger logger = LoggerFactory.getLogger(RedisLockAdvice.class);

    @Resource
    private RedisDistributionLock redisDistributionLock;

    @Around("@annotation(RedisLockAnnoation)")
    public Object processAround(ProceedingJoinPoint pjp) throws Throwable {
        //获取方法上的注解对象
        String methodName = pjp.getSignature().getName();
        Class<?> classTarget = pjp.getTarget().getClass();
        Class<?>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
        Method objMethod = classTarget.getMethod(methodName, par);
        RedisLockAnnoation redisLockAnnoation = objMethod.getDeclaredAnnotation(RedisLockAnnoation.class);

        //拼装分布式锁的key
        String[] keys = redisLockAnnoation.keys();
        Object[] args = pjp.getArgs();
        Object arg = args[0];
        StringBuilder temp = new StringBuilder();
        temp.append(redisLockAnnoation.keyPrefix());
        for (String key : keys) {
            String getMethod = "get" + StringUtils.capitalize(key);
            temp.append(MethodUtils.invokeExactMethod(arg, getMethod)).append("_");
        }
        String redisKey = StringUtils.removeEnd(temp.toString(), "_");

        //执行分布式锁的逻辑
        if (redisLockAnnoation.isSpin()) {
            //阻塞锁
            int lockRetryTime = 0;
            try {
                while (!redisDistributionLock.lock(redisKey, redisLockAnnoation.expireTime())) {
                    if (lockRetryTime++ > redisLockAnnoation.retryTimes()) {
                        logger.error("lock exception. key:{}, lockRetryTime:{}", redisKey, lockRetryTime);
                        throw ExceptionUtil.geneException(CommonExceptionEnum.SYSTEM_ERROR);
                    }
                    ThreadUtil.holdXms(redisLockAnnoation.waitTime());
                }
                return pjp.proceed();
            } finally {
                redisDistributionLock.unlock(redisKey);
            }
        } else {
            //非阻塞锁
            try {
                if (!redisDistributionLock.lock(redisKey)) {
                    logger.error("lock exception. key:{}", redisKey);
                    throw ExceptionUtil.geneException(CommonExceptionEnum.SYSTEM_ERROR);
                }
                return pjp.proceed();
            } finally {
                redisDistributionLock.unlock(redisKey);
            }
        }
    }
}

kubernetes（k8s）第七部分之yaml文件详解

# yaml格式的pod定义文件完整内容：
apiVersion: v1       #必选，版本号，例如v1
kind: Pod       #必选，Pod
metadata:       #必选，元数据
name: string       #必选，Pod名称
namespace: string    #必选，Pod所属的命名空间
labels:      #自定义标签
– name: string     #自定义标签名字
annotations:       #自定义注释列表
– name: string
spec:         #必选，Pod中容器的详细定义
containers:      #必选，Pod中容器列表
– name: string     #必选，容器名称
image: string    #必选，容器的镜像名称
imagePullPolicy: [Always | Never | IfNotPresent] #获取镜像的策略 Alawys表示下载镜像 IfnotPresent表示优先使用本地镜像，否则下载镜像，Nerver表示仅使用本地镜像
command: [string]    #容器的启动命令列表，如不指定，使用打包时使用的启动命令
args: [string]     #容器的启动命令参数列表
workingDir: string     #容器的工作目录
volumeMounts:    #挂载到容器内部的存储卷配置
– name: string     #引用pod定义的共享存储卷的名称，需用volumes[]部分定义的的卷名
mountPath: string    #存储卷在容器内mount的绝对路径，应少于512字符
readOnly: boolean    #是否为只读模式
ports:       #需要暴露的端口库号列表
– name: string     #端口号名称
containerPort: int   #容器需要监听的端口号
hostPort: int    #容器所在主机需要监听的端口号，默认与Container相同
protocol: string     #端口协议，支持TCP和UDP，默认TCP
env:       #容器运行前需设置的环境变量列表
– name: string     #环境变量名称
value: string    #环境变量的值
resources:       #资源限制和请求的设置
limits:      #资源限制的设置
cpu: string    #Cpu的限制，单位为core数，将用于docker run –cpu-shares参数
memory: string     #内存限制，单位可以为Mib/Gib，将用于docker run –memory参数
requests:      #资源请求的设置
cpu: string    #Cpu请求，容器启动的初始可用数量
memory: string     #内存清楚，容器启动的初始可用数量
livenessProbe:     #对Pod内个容器健康检查的设置，当探测无响应几次后将自动重启该容器，检查方法有exec、httpGet和tcpSocket，对一个容器只需设置其中一种方法即可
exec:      #对Pod容器内检查方式设置为exec方式
command: [string]  #exec方式需要制定的命令或脚本
httpGet:       #对Pod内个容器健康检查方法设置为HttpGet，需要制定Path、port
path: string
port: number
host: string
scheme: string
HttpHeaders:
– name: string
value: string
tcpSocket:     #对Pod内个容器健康检查方式设置为tcpSocket方式
port: number
initialDelaySeconds: 0  #容器启动完成后首次探测的时间，单位为秒
timeoutSeconds: 0   #对容器健康检查探测等待响应的超时时间，单位秒，默认1秒
periodSeconds: 0    #对容器监控检查的定期探测时间设置，单位秒，默认10秒一次
successThreshold: 0
failureThreshold: 0
securityContext:
privileged:false
restartPolicy: [Always | Never | OnFailure]#Pod的重启策略，Always表示一旦不管以何种方式终止运行，kubelet都将重启，OnFailure表示只有Pod以非0退出码退出才重启，Nerver表示不再重启该Pod
nodeSelector: obeject  #设置NodeSelector表示将该Pod调度到包含这个label的node上，以key：value的格式指定
imagePullSecrets:    #Pull镜像时使用的secret名称，以key：secretkey格式指定
– name: string
hostNetwork:false      #是否使用主机网络模式，默认为false，如果设置为true，表示使用宿主机网络
volumes:       #在该pod上定义共享存储卷列表
– name: string     #共享存储卷名称 （volumes类型有很多种）
emptyDir: {}     #类型为emtyDir的存储卷，与Pod同生命周期的一个临时目录。为空值
hostPath: string     #类型为hostPath的存储卷，表示挂载Pod所在宿主机的目录
path: string     #Pod所在宿主机的目录，将被用于同期中mount的目录
secret:      #类型为secret的存储卷，挂载集群与定义的secre对象到容器内部
scretname: string
items:
– key: string
path: string
configMap:     #类型为configMap的存储卷，挂载预定义的configMap对象到容器内部
name: string
items:
– key: string
path: string

linux下如何实现mysql数据库每天定时自动备份

需要将数据库进行每天定时自动备份，所以网上找了各种方式就行了测试，遇到很多坑，特此记录下来，步骤是东拼西凑的，虽然也是网上找的，但都是经过亲自测试，一定能用，针对部署时期遇到的问题和解决方式都记录了下来。

1、创建备份目录：
为了方便，在/home保存备份文件；

cd
mkdir /home/dbback
cd /home/dbback
2、创建备份Shell脚本:
注意把以下命令中的DatabaseName换为实际的数据库名称；
当然，你也可以使用其实的命名规则！

vi bkDatabaseName.sh
输入/粘贴以下内容：

#!/bin/bash
mysqldump -uusername -ppassword DatabaseName > /home/dbback/DatabaseName_$(date +%Y%m%d_%H%M%S).sql
对备份进行压缩：

#!/bin/bash
mysqldump -uusername -ppassword DatabaseName | gzip > /home/dbback/DatabaseName_$(date +%Y%m%d_%H%M%S).sql.gz
注意：
把 username 替换为实际的用户名；
把 password 替换为实际的密码；
把 DatabaseName 替换为实际的数据库名；

3、添加可执行权限：
chmod u+x bkDatabaseName.sh
添加可执行权限之后先执行一下，看看脚本有没有错误，能不能正常使用；

./bkDatabaseName.sh
注：这里可能会报错
Warning: Using a password on the command line interface can be insecure.
导出MySQL数据库的时候采用mysqldump命令，出现”Warning: Using a password on the command line interface can be insecure.”的错误提示，当然数据库肯定也没有能备份下来。这个问题应该是在MySQL5.6+版本的时候就有出现，可能是为了确保数据库的安全性采用的保护机制。

解决方法、修改数据库配置文件

1、我们需要修改数据库配置文件，这个要看我们数据库的配置的，有些是在/etc/my.cnf，有些是/etc/my.conf

我们需要在[client]部分添加脚本：

host=localhost
user=数据库用户
password=’数据库密码’

这里参数要修改成我们自己的。

2、采用命令导出和导入数据库

其实在这个时候，我们如果采用”详解使用mysqldump命令备份还原MySQL数据用法整理”介绍的方法也是可以使用的，虽然依旧有错误提示，但是数据库还是可以导出的。您肯定和老左一样是追求细节的人，一点点问题都不能有，但我们可以用下面的命令导出和导入，就没有错误提示。

#导出数据库

mysqldump –defaults-extra-file=/etc/my.cnf database > database.sql

#导入数据库

mysql –defaults-extra-file=/etc/my.cnf database < database.sql

这里我们可以看到上面的命令和以前常用的快速导入和导入命令有所不同了，需要加载我们配置的MYSQL配置文件，这个红色部分要根据我们实际的路径修改。用这样的命令导出备份和导入是没有错误提示的。

4、添加计划任务
检测或安装 crontab
确认crontab是否安装：
执行 crontab 命令如果报 command not found，就表明没有安装

# crontab
-bash: crontab: command not found
如时没有安装 crontab，需要先安装它，具体步骤请参考：
CentOS下使用yum命令安装计划任务程序crontab
使用rpm命令从CentOS系统盘安装计划任务程序crontab

添加计划任务
执行命令：

crontab -e
这时就像使用vi编辑器一样，可以对计划任务进行编辑。
输入以下内容并保存：

*/1 * * * * /home/backup/bkDatabaseName.sh
具体是什么意思呢？

意思是每一分钟执行一次shell脚本“/home/backup/bkDatabaseName.sh”。

1、额外学习，crontab用法
crontab命令用于安装、删除或者列出用于驱动cron后台进程的表格。用户把需要执行的命令序列放到crontab文件中以获得执行。
每个用户都可以有自己的crontab文件。/var/spool/cron下的crontab文件不可以直接创建或者直接修改。该crontab文件是通过crontab命令创建的

在crontab文件中如何输入需要执行的命令和时间。该文件中每行都包括六个域，其中前五个域是指定命令被执行的时间，最后一个域是要被执行的命令。
每个域之间使用空格或者制表符分隔。格式如下：
minute hour day-of-month month-of-year day-of-week commands
合法值 00-59 00-23 01-31 01-12 0-6 (0 is sunday)
除了数字还有几个个特殊的符号就是”*”、”/”和”-“、”,”，*代表所有的取值范围内的数字，”/”代表每的意思,”/5″表示每5个单位，”-“代表从某个数字到某个数字,”,”分开几个离散的数字。

-l 在标准输出上显示当前的crontab。
-r 删除当前的crontab文件。
-e 使用VISUAL或者EDITOR环境变量所指的编辑器编辑当前的crontab文件。当结束编辑离开时，编辑后的文件将自动安装。

 

2、例子：
每天早上6点
0 6 * * * echo “Good morning.” >> /tmp/test.txt //注意单纯echo，从屏幕上看不到任何输出，因为cron把任何输出都email到root的信箱了。

每两个小时
0 */2 * * * echo “Have a break now.” >> /tmp/test.txt

晚上11点到早上8点之间每两个小时和早上八点
0 23-7/2，8 * * * echo “Have a good dream” >> /tmp/test.txt

每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点
0 11 4 * 1-3 command line

1月1日早上4点
0 4 1 1 * command line SHELL=/bin/bash PATH=/sbin:/bin:/usr/sbin:/usr/bin MAILTO=root //如果出现错误，或者有数据输出，数据作为邮件发给这个帐号 HOME=/

每小时执行/etc/cron.hourly内的脚本
01 * * * * root run-parts /etc/cron.hourly
每天执行/etc/cron.daily内的脚本
02 4 * * * root run-parts /etc/cron.daily

每星期执行/etc/cron.weekly内的脚本
22 4 * * 0 root run-parts /etc/cron.weekly

每月去执行/etc/cron.monthly内的脚本
42 4 1 * * root run-parts /etc/cron.monthly

注意: “run-parts”这个参数了，如果去掉这个参数的话，后面就可以写要运行的某个脚本名，而不是文件夹名。

每天的下午4点、5点、6点的5 min、15 min、25 min、35 min、45 min、55 min时执行命令。
5，15，25，35，45，55 16，17，18 * * * command

每周一，三，五的下午3：00系统进入维护状态，重新启动系统。
00 15 * * 1，3，5 shutdown -r +5

每小时的10分，40分执行用户目录下的innd/bbslin这个指令：
10，40 * * * * innd/bbslink

每小时的1分执行用户目录下的bin/account这个指令：
1 * * * * bin/account

每天早晨三点二十分执行用户目录下如下所示的两个指令（每个指令以;分隔）：
20 3 * * * （/bin/rm -f expire.ls logins.bad;bin/expire$#@62;expire.1st）

每年的一月和四月，4号到9号的3点12分和3点55分执行/bin/rm -f expire.1st这个指令，并把结果添加在mm.txt这个文件之后（mm.txt文件位于用户自己的目录位置）。
12,55 3 4-9 1,4 * /bin/rm -f expire.1st$#@62;$#@62;mm.txt

5、测试任务是否执行
很简单，我们就执行几次“ls”命令，看看一分钟过后文件有没有被创建就可以了！

如果任务执行失败了，可以通过以下命令查看任务日志：

# tail -f /var/log/cron
输出类似如下

Maven WEB 项目使用ProGuard进行混淆，最佳解决方案

近期公司的Android项目做了混淆，虽说对于保护代码并不是100%的，但混淆后的代码可以使那些不法份子难以阅读，这样也能对代码的保护做出贡献。
于是，公司写的一大堆WEB项目也想做保护。但几大问题随之而来：

公司的所有项目全部是Maven项目，网上的混淆方案不是陈旧就是无效
网上的大部分解决方案感觉像是对简单DEMO进行混淆，根本不能用于复杂的WEB项目中
网上的大部分解决方案是针对Android项目的，针对WEB的少之又少
针对以上问题，本人花费一个月研究了WEB+Maven项目的混淆，终于收获果实，解决了这一大空缺难题。

项目介绍
就如之前所述，我们要混淆的项目绝不是一个简单的WEB DEMO，必须要包含了大量第三方框架。
本文中介绍的项目使用了主流的一些框架：

Spring 4.1.1.RELEASE
SpringMVC 4.1.1.RELEASE
JackSon 2.5.0
MyBatis 3.3.0
Shiro 1.2.3
Log4J 1.2.17
SLF4J 1.7.10
Druid Pool 1.0.15
patchca 1.0.0
Jetty 9.2.7.v20150116
项目包结构

该项目是典型的Maven WEB项目，对于Maven WEB项目的结构不再赘述，这里对各种包做一下解释：

annotation 注解包，里面是自己写的注解类，主要混淆对象
controller SpringMVC的控制器包，主要混淆对象
credntials Shiro的自定义凭证，次要混淆对象
dao DAO包，主要混淆对象
exception 异常包，自定义了一些异常，主要混淆对象
filter Shiro的自定义过滤器，次要混淆对象
interceptor Shiro的自定义拦截器，次要混淆对象
job SpringTASK的定时任务包，次要混淆对象
mapper Mybatis的XML映射文件包，非混淆对象
model 实体包，非混淆对象
realm Shiro的自定义域包，次要混淆对象
service 实体的服务包，次要混淆对象
token Shiro的自定义令牌包，次要混淆对象
utils 公司自己的工具类，主要混淆对象
主要混淆对象 对类的名称、属性、方法名都进行混淆
次要混淆对象 对类的名称不混淆，类的属性、方法名选择性混淆
非混淆对象 不进行混淆，混淆后可能出现异常

Maven 配置(pom.xml)
本文的重头戏，使用Maven集成的ProGuard插件，混淆配置不用单独建立文件

<?xml version=”1.0″ encoding=”UTF-8″?>
<project xmlns=”http://maven.apache.org/POM/4.0.0″
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”>
<modelVersion>4.0.0</modelVersion>
<packaging>war</packaging>
<groupId>…</groupId>
<artifactId>zhukun.shiro-spring</artifactId>
<version>1.0-SNAPSHOT</version>

<!– 属性–>
<properties>
<!– 项目编码–>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!– 单元测试包–>
<junit.version>4.12</junit.version>
<!– JAVAEE支持包–>
<jstl.version>1.2</jstl.version>
<servlet.version>3.1.0</servlet.version>
<!– 日志包–>
<log4j.version>1.2.17</log4j.version>
<slf4j.version>1.7.10</slf4j.version>
<aspectj.version>1.6.12</aspectj.version>
<!– commons支持–>
<commons-logging.version>1.1.3</commons-logging.version>
<commons-collections.version>3.2.1</commons-collections.version>
<commons-fileupload.version>1.3.1</commons-fileupload.version>
<!– shiro安全框架–>
<shiro.version>1.2.3</shiro.version>
<!– druid连接池–>
<druid.version>1.0.15</druid.version>
<!– 数据库及数据库框架–>
<mysql.version>5.1.30</mysql.version>
<mybatis.version>3.3.0</mybatis.version>
<mybatis-spring.version>1.2.3</mybatis-spring.version>
<!– Mybatis分页插件–>
<mybatis-paginator.version>1.2.16</mybatis-paginator.version>
<!– Mybatis生成器插件–>
<mybatis-generator.version>1.3.2</mybatis-generator.version>
<!– Spring及SpringMVC支持包–>
<spring.version>4.1.1.RELEASE</spring.version>
<jackson.version>2.5.0</jackson.version>
<!– 验证码支持包–>
<patchca.version>1.0.0</patchca.version>
<!– Jetty插件–>
<jetty.version>9.2.7.v20150116</jetty.version>
<!– Maven编译插件–>
<maven-compiler.version>2.3.2</maven-compiler.version>
</properties>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>${jstl.version}</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>${aspectj.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>${commons-logging.version}</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>${shiro.version}</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>${shiro.version}</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>${shiro.version}</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-ehcache</artifactId>
<version>${shiro.version}</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-quartz</artifactId>
<version>${shiro.version}</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>${commons-collections.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>${druid.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>${servlet.version}</version>
</dependency>
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>${commons-fileupload.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>${mybatis-spring.version}</version>
</dependency>
<dependency>
<groupId>com.github.miemiedev</groupId>
<artifactId>mybatis-paginator</artifactId>
<version>${mybatis-paginator.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>${jackson.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>${jackson.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.patchca</groupId>
<artifactId>patchca</artifactId>
<version>${patchca.version}</version>
</dependency>
</dependencies>

<build>
<finalName>shiro-spring</finalName>
<!–使Maven打包时能打包src目录下的XML文件–>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
</resource>
<resource>
<directory>src/main/resources</directory>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${maven-compiler.version}</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>${jetty.version}</version>
<configuration>
<webApp>
<contextPath>/shiro-spring</contextPath>
</webApp>
<httpConnector>
<!– 设置端口–>
<port>8080</port>
</httpConnector>
</configuration>
</plugin>

<!– MyBatis自动生成Mapper插件–>
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>${mybatis-generator.version}</version>
<configuration>
<verbose>true</verbose>
<overwrite>true</overwrite>
</configuration>
</plugin>

<!– ProGuard混淆插件–>
<plugin>
<groupId>com.github.wvengen</groupId>
<artifactId>proguard-maven-plugin</artifactId>
<version>2.0.11</version>
<executions>
<execution>
<!– 混淆时刻，这里是打包的时候混淆–>
<phase>package</phase>
<goals>
<!– 使用插件的什么功能，当然是混淆–>
<goal>proguard</goal>
</goals>
</execution>
</executions>
<configuration>
<!– 是否将生成的PG文件安装部署–>
<attach>true</attach>
<!– 是否混淆–>
<obfuscate>true</obfuscate>
<!– 指定生成文件分类 –>
<attachArtifactClassifier>pg</attachArtifactClassifier>
<options>
<!– JDK目标版本1.7–>
<option>-target 1.7</option>
<!– 不做收缩（删除注释、未被引用代码）–>
<option>-dontshrink</option>
<!– 不做优化（变更代码实现逻辑）–>
<option>-dontoptimize</option>
<!– 不路过非公用类文件及成员–>
<option>-dontskipnonpubliclibraryclasses</option>
<option>-dontskipnonpubliclibraryclassmembers</option>
<!– 优化时允许访问并修改有修饰符的类和类的成员 –>
<option>-allowaccessmodification</option>
<!– 确定统一的混淆类的成员名称来增加混淆–>
<option>-useuniqueclassmembernames</option>
<!– 不混淆所有包名，本人测试混淆后WEB项目问题实在太多，毕竟Spring配置中有大量固定写法的包名–>
<option>-keeppackagenames</option>
<!– 不混淆所有特殊的类–>
<option>-keepattributes Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,LocalVariable*Table,*Annotation*,Synthetic,EnclosingMethod</option>
<!– 不混淆所有的set/get方法，毕竟项目中使用的部分第三方框架（例如Shiro）会用到大量的set/get映射–>
<option>-keepclassmembers public class * {void set*(***);*** get*();}</option>

<!– 不混淆job包下的所有类名，且类中的方法也不混淆–>
<option>-keep class com.chinatelecom.gz.wy.zhukun.shiro_spring.job.** { &lt;methods&gt;; }</option>
<!– 不混淆filter包下的所有类名，这里主要是对Shiro的路踢人过滤器混淆，对类的属性和方法进行了混淆–>
<option>-keep class com.chinatelecom.gz.wy.zhukun.shiro_spring.filter.** </option>
<!– 不混淆凭证包下的所有类名，但对类中的属性、方法进行混淆，原因是Spring配置中用到了这个类名–>
<option>-keep class com.chinatelecom.gz.wy.zhukun.shiro_spring.credntials.** </option>
<!– 混淆目的同上，这个是拦截器的包，包中有防止重复提交的拦截器–>
<option>-keep class com.chinatelecom.gz.wy.zhukun.shiro_spring.interceptor.** </option>
<!– 混淆目的同上，这个是域包，包中有用户登录域–>
<option>-keep class com.chinatelecom.gz.wy.zhukun.shiro_spring.realm.** </option>
<!– 不混淆model包中的所有类以及类的属性及方法，实体包，混淆了会导致ORM框架及前端无法识别–>
<option>-keep class com.chinatelecom.gz.wy.zhukun.shiro_spring.model.** {*;}</option>
<!– 以下两个包因为大部分是Spring管理的Bean，不对包类的类名进行混淆，但对类中的属性和方法混淆–>
<option>-keep class com.chinatelecom.gz.wy.zhukun.shiro_spring.service.** </option>
<option>-keep class com.chinatelecom.gz.wy.zhukun.shiro_spring.dao.**</option>
</options>
<outjar>${project.build.finalName}-pg.jar</outjar>
<!– 添加依赖，这里你可以按你的需要修改，这里测试只需要一个JRE的Runtime包就行了 –>
<libs>
<lib>${java.home}/lib/rt.jar</lib>
</libs>
<!– 加载文件的过滤器，就是你的工程目录了–>
<inFilter>com/chinatelecom/gz/wy/zhukun/shiro_spring/**</inFilter>
<!– 对什么东西进行加载，这里仅有classes成功，毕竟你也不可能对配置文件及JSP混淆吧–>
<injar>classes</injar>
<!– 输出目录–>
<outputDirectory>${project.build.directory}</outputDirectory>
</configuration>
</plugin>
</plugins>
</build>
</project>

以上代码中的注释足够各位参考了，若有问题欢迎留言

执行
clean package -DskipTests

使用Maven运行以上代码，执行完成后在target目录中会生成三个文件：

classes-pg.jar 混淆后的classes文件，里面包含完整的项目结构
proguard_map.txt 混淆内容的映射
proguard_seed.txt 参与混淆的类
混淆完成后，将classes-pg.jar解压到应用服务器覆盖原有的classes文件，通常目录为

X:\jetty9或tomcat7\webapps\shiro-spring\WEB-INF\classes

运行服务，项目运行正常

反编译
既然是混淆了的代码，那我们现在作为盗码者来反编译一下classes文件

可以看出，混淆成功了，盗码者读起来不是一二般的痛苦，我们的目的已经达到

遗留问题
虽然混淆是在Maven打包的时候进行，但是生成的war包及classes目录并未混淆，还需要将jar包中的内容提取，比较麻烦，不知道有没有让生成的war包就是已经混淆的办法。
本人的JAVA环境是JDK1.7 64位，其它的JDK并未尝试
不能对Spring等配置文件混淆，这样包结构还是存在，减弱了盗码者的读码难度