精华内容
下载资源
问答
  • 访问量
    千次阅读
    2022-02-09 15:49:59
    location /setup {
       stub_status; #启用模块监控
       #出于安全,可以引用nginx密码验证
       auth_basic	"login password";
       auth_basic_user_file /apps/nginx/passwd/.htpasswd ;
       #也可以增加ip限制
       allow IP;
       deny all;   
    }
    

    访问

    http://ip:prot/setup
    

    在这里插入图片描述

    Active connections:当前处于活动状态的客户端连接数,包括连接等待空闲连接数=Reading+Writing+Waiting
    accepts:统计总值,nginx自启动后已接受的客户端请求总量
    handled:统计总值,你滚下自启动后已处理完成的客户端请求总数,一般等于accepts
    requests:统计总值,nginx自启动以来,客户端发来的请求数
    Reading:当前状态,正在读取客户端请求报文首部的连接数,数值越大,说明排队现象严重,性能不足
    Writing:当前状态,正在向客户端发送响应报文过程中的连接数,数值越大,说明访问量大
    Waiting:当前状态,正在等待客户端发出请求的空闲连接数,开启keep-alive的情况下,=active-(reading+writing)
    
    

    提取当前数值

    curl localhost:80/setup 2> /dev/null | grep "Reading"|awk '{print $2,$4,$6}'
    或
    curl localhost:80/setup 2> /dev/null |awk '/Reading/{print $2,$4,$6}'
    
    更多相关内容
  • 统计Nginx访问量

    千次阅读 2022-03-03 13:08:58
    用户对同一页面的多次访问,访问量累积。 UV(Unique Visitor):指通过互联网浏览这个网页的人,电脑称为一个访客、手机也称为一个访客,一天之内相同的客户端只能被计算一次。 IP(Internet Protocol):指...

    PV(Page View):即页面浏览量或者点击量,用户每一次对网站中每个页面访问均记录1个PV。用户对同一页面的多次访问,访问量累积。

    UV(Unique Visitor):指通过互联网浏览这个网页的人,电脑称为一个访客、手机也称为一个访客,一天之内相同的客户端只能被计算一次。

    IP(Internet Protocol):指独立IP访问站点的IP总数,一天内相同IP只能算一次。

    VV(Visit View):指所有访客一天内访问网站的次数,当访客完成所有浏览并最终关闭网站的所有页面时变完成了一次访问,同一访客一天内可能有多次访问行为,访问次数累积。

    Nginx的配置文件

    在这里插入图片描述

    cat access.log

    在这里插入图片描述

    查看各个访问量

    1.根据访问IP统计UV

    awk '{print $1}'  /var/log/nginx/access.log|sort | uniq -c |wc -l
    

    2.统计访问URL统计PV

    awk '{print $7}' /var/log/nginx/access.log|wc -l
    

    3.查询访问最频繁的URL

    awk '{print $7}' /var/log/nginx/access.log|sort | uniq -c |sort -n -k 1 -r|more
    

    4.查询访问最频繁的IP

    awk '{print $1}' /var/log/nginx/access.log|sort | uniq -c |sort -n -k 1 -r|more
    

    5.根据时间段统计查看日志

    cat  /var/log/nginx/access.log| sed -n '/14\/Mar\/2017:21/,/14\/Mar\/2017:22/p'|more
    

    针对每天的访问信息写一个脚本,并将统计信息输出到/pv.html文件里面,之保留30天的信息。方便直接浏览此页面查看,但要限制特定IP才能访问此页面,其他IP的403

    year=`date +%Y`  
     
    month=`date +%m`
     
    datedate=`date +%F`
     
    date=`date +%Y%m%d`
     
    pv=`awk '{print $7}' /xx/logs/nginx/xxx/"$year"/"$month"/"$datedate"-access.log | wc -l`
     
    ip=`awk '{print $1}' /xx/logs/nginx/xxx/"$year"/"$month"/"$datedate"-access.log | sort -n | uniq -c | wc -l`
     
    echo -e "\n$date Pv is $pv;; $date Ip is $ip.." >> /xx/xxx/pv.htm l sort -rn /xx/xxx/pv.html | sed -i '31d' /xx/xxx/pv.html | sort -r
    

    此外还要修改nginx配置文件

    location = /pv.html {
     
    allow  xxx.xxx.xxx.xxx;
     
    deny allow;
     
    }
    
    nginx -r
    dervice nginx reload
    

    最后,将pv.sh加入定时任务

    crontab -e
    
    展开全文
  • 之前开发系统的时候客户提到了一个需求:需要统计某些页面的访问量,记得当时还纠结了一阵子,不知道怎么去实现这个功能,后来还是在大佬的带领下借助 Redis 实现了这个功能。今天又回想起了这件事,正好和大家分享...

    前言

    之前开发系统的时候客户提到了一个需求:需要统计某些页面的访问量,记得当时还纠结了一阵子,不知道怎么去实现这个功能,后来还是在大佬的带领下借助 Redis 实现了这个功能。今天又回想起了这件事,正好和大家分享一下 Spring Boot 整合 Redis 实现访问量统计的全过程。

    首先先解释一下为什么需要借助 Redis,其实原因也很简单,就是因为它非常快(每秒可执行大约110000次的 SET 操作,每秒大约可执行81000次的 GET 操作),我们就可以把访问量暂存在 Redis 中,当有人访问页面的时候,就直接在 Redis 中执行 +1 的操作,然后再每隔一段时间把 Redis 中的访问量的数值写入到数据库中就搞定了~

    肯定有小伙伴会想:如果我们不借助 Redis 而是直接操作数据库的话会怎么样呢?

    访问量的统计是需要频繁读写的,如果不用 Redis 做缓存而是直接操作数据库的话,就会对数据库带来巨大的压力,试想一下如果此时有成千上万个人同时访问页面的话,数据库很可能在这一瞬间造成数据库的崩溃。对于这种高读写的场景,就需要直接在 Redis 上读写,等到合适的时间,再将数据批量写到数据库中。所以通常来说,在必要的时候引入Redis,可以减少MySQL(或其他)数据库的压力。

    Spring Boot 整合 Redis

    怎么创建 Spring Boot 项目这里就不提了,直接上重点——整合 Redis

    引入依赖、增加配置

    首先还是需要引入 Redis 依赖

    <!-- 集成Redis -->
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    

    接下来就在配置文件中增加 Redis 的相关配置

    # spring配置
    spring:
      # redis配置
      redis:
        host: 127.0.0.1
        port: 6379
        database: 0
        jedis:
          pool:
            max-active: 200
            max-idle: 500
            min-idle: 8
            max-wait: 10000
        timeout: 5000
    

    P.S. 如果 Redis 设置了密码,别忘了增加 password 配置哦 ~

    翠花!上代码

    首先在 Utils 包内新增一个 RedisUtil

    package com.media.common.utils;
    
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    
    import javax.annotation.Resource;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @program: media
     * @description: RedisUtil
     * @author: 庄霸.liziye
     * @create: 2021-12-15 10:02
     **/
    @Component
    public final class RedisUtil {
    
        @Resource
        private RedisTemplate<String, Object> redisTemplate;
    
        // =============================common============================
        /**
         * 指定缓存失效时间
         * @param key  键
         * @param time 时间(秒)
         */
        public boolean expire(String key, long time) {
            try {
                if (time > 0) {
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据key 获取过期时间
         * @param key 键 不能为null
         * @return 时间(秒) 返回0代表为永久有效
         */
        public long getExpire(String key) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
    
        /**
         * 判断key是否存在
         * @param key 键
         * @return true 存在 false不存在
         */
        public boolean hasKey(String key) {
            try {
                return redisTemplate.hasKey(key);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 删除缓存
         * @param key 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public void del(String... key) {
            if (key != null && key.length > 0) {
                if (key.length == 1) {
                    redisTemplate.delete(key[0]);
                } else {
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
    
    
        // ============================String=============================
    
        /**
         * 普通缓存获取
         * @param key 键
         * @return 值
         */
        public Object get(String key) {
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         * @param key   键
         * @param value 值
         * @return true成功 false失败
         */
    
        public boolean set(String key, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 普通缓存放入并设置时间
         * @param key   键
         * @param value 值
         * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
    
        public boolean set(String key, Object value, long time) {
            try {
                if (time > 0) {
                    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                } else {
                    set(key, value);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 递增
         * @param key   键
         * @param delta 要增加几(大于0)
         */
        public long incr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
    
        /**
         * 递减
         * @param key   键
         * @param delta 要减少几(小于0)
         */
        public long decr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
    
        // ================================Map=================================
    
        /**
         * HashGet
         * @param key  键 不能为null
         * @param item 项 不能为null
         */
        public Object hget(String key, String item) {
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取hashKey对应的所有键值
         * @param key 键
         * @return 对应的多个键值
         */
        public Map<Object, Object> hmget(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet
         * @param key 键
         * @param map 对应多个键值
         */
        public boolean hmset(String key, Map<String, Object> map) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * HashSet 并设置时间
         * @param key  键
         * @param map  对应多个键值
         * @param time 时间(秒)
         * @return true成功 false失败
         */
        public boolean hmset(String key, Map<String, Object> map, long time) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value, long time) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 删除hash表中的值
         *
         * @param key  键 不能为null
         * @param item 项 可以使多个 不能为null
         */
        public void hdel(String key, Object... item) {
            redisTemplate.opsForHash().delete(key, item);
        }
    
    
        /**
         * 判断hash表中是否有该项的值
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public boolean hHasKey(String key, String item) {
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
    
        /**
         * hash递增 如果不存在,就会创建一个 并把新增后的值返回
         *
         * @param key  键
         * @param item 项
         * @param by   要增加几(大于0)
         */
        public double hincr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
    
        /**
         * hash递减
         *
         * @param key  键
         * @param item 项
         * @param by   要减少记(小于0)
         */
        public double hdecr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, -by);
        }
    
    
        // ============================set=============================
    
        /**
         * 根据key获取Set中的所有值
         * @param key 键
         */
        public Set<Object> sGet(String key) {
            try {
                return redisTemplate.opsForSet().members(key);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
    
        /**
         * 根据value从一个set中查询,是否存在
         *
         * @param key   键
         * @param value 值
         * @return true 存在 false不存在
         */
        public boolean sHasKey(String key, Object value) {
            try {
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 将数据放入set缓存
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSet(String key, Object... values) {
            try {
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
    
        /**
         * 将set数据放入缓存
         *
         * @param key    键
         * @param time   时间(秒)
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSetAndTime(String key, long time, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().add(key, values);
                if (time > 0) {
                    expire(key, time);
                }
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
    
        /**
         * 获取set缓存的长度
         *
         * @param key 键
         */
        public long sGetSetSize(String key) {
            try {
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
    
        /**
         * 移除值为value的
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
    
        public long setRemove(String key, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        // ===============================list=================================
    
        /**
         * 获取list缓存的内容
         *
         * @param key   键
         * @param start 开始
         * @param end   结束 0 到 -1代表所有值
         */
        public List<Object> lGet(String key, long start, long end) {
            try {
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
    
        /**
         * 获取list缓存的长度
         *
         * @param key 键
         */
        public long lGetListSize(String key) {
            try {
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
    
        /**
         * 通过索引 获取list中的值
         *
         * @param key   键
         * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
         */
        public Object lGetIndex(String key, long index) {
            try {
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         */
        public boolean lSet(String key, Object value) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 将list放入缓存
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         */
        public boolean lSet(String key, Object value, long time) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
    
        }
    
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, List<Object> value) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
    
        }
    
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         * @return
         */
        public boolean lSet(String key, List<Object> value, long time) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 根据索引修改list中的某条数据
         *
         * @param key   键
         * @param index 索引
         * @param value 值
         * @return
         */
    
        public boolean lUpdateIndex(String key, long index, Object value) {
            try {
                redisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 移除N个值为value
         *
         * @param key   键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
    
        public long lRemove(String key, long count, Object value) {
            try {
                Long remove = redisTemplate.opsForList().remove(key, count, value);
                return remove;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
        
    }
    
    

    然后再新增一个 RedisConfig 类

    package com.media.common.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.data.redis.core.RedisOperations;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericToStringSerializer;
    
    
    /**
     * @program: media
     * @description: RedisConfiguration
     * @author: 庄霸.liziye
     * @create: 2021-12-15 10:16
     **/
    @Configuration
    @ConditionalOnClass(RedisOperations.class)
    @EnableConfigurationProperties(RedisProperties.class)
    public class RedisConfig {
    
        /**
         * 设置 redisTemplate 的序列化设置
         * @param redisConnectionFactory
         * @return
         */
        @Bean
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            // 1.创建 redisTemplate 模版
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            // 2.关联 redisConnectionFactory
            template.setConnectionFactory(redisConnectionFactory);
            // 3.创建 序列化类
            GenericToStringSerializer genericToStringSerializer = new GenericToStringSerializer(Object.class);
            // 6.序列化类,对象映射设置
            // 7.设置 value 的转化格式和 key 的转化格式
            template.setValueSerializer(genericToStringSerializer);
            template.setKeySerializer(new StringRedisSerializer());
            template.afterPropertiesSet();
            return template;
        }
    }
    
    

    有些眼尖的小伙伴会发现在 RedisUtil 工具类中,我们在 private RedisTemplate<String, Object> redisTemplate 上增加的是 @Resource 注解,并非是 @Autowire 注解。
    在这里插入图片描述
    原因也很简单,在源码中我们可以看到 RedisTemplate 指定的是泛型,如果在注入 RedisTemplate 时,值的部分使用了 Object ,那么再使用@AutoWired 注解注入就会报空指针的错误,所以需要使用 @Resource 注解(二者的区别是前者是根据类型注入后者是根据名字注入,具体的这里就不详细说,有兴趣的小伙伴可自行百度查阅😄)

    Redis 的相关代码到这里就写完了, 接下来我们就以“记录A页面的访问量”为需求,写一个简单的业务逻辑,代码仅供参考哦 ~

    首先我们新建一个数据库表,表结构很简单,只有三个字段,分别是ID、访问量、统计时间
    在这里插入图片描述
    我们再写一下操作这个表的 CRUD 方法(这个也很简单,相信各位小伙伴都可以脑补出来 (●’◡’●) 所以在这里就不写具体代码了)

    此处略去一万个字…😄

    下面我们写一个监听类:

    package com.media.picture.handler;
    
    import com.media.common.utils.DateUtils;
    import com.media.common.utils.RedisUtil;
    import com.media.picture.domain.MamPictureView;
    import com.media.picture.service.IMamPictureViewService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.core.Ordered;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    /**
     * @program: media
     * @description: ListenHandler
     * @author: 庄霸.liziye
     * @create: 2021-12-15 10:54
     **/
    @Component
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public class ListenHandler {
    
        @Autowired
        private RedisUtil redisUtil;
    
        @Autowired
        private IMamPictureViewService iMamPictureViewService;
    
        public ListenHandler(){
            System.out.println("开始初始化");
        }
        
        @PostConstruct
        public void init() {
            System.out.println("Redis及数据库开始初始化");
            //插入一条空数据
            MamPictureView mamPictureView = new MamPictureView();
            mamPictureView.setViewNum(Long.valueOf(0));
            int viewId = iMamPictureViewService.insertMamPictureView(mamPictureView);
    
            redisUtil.set("pageA_id", viewId);
            redisUtil.set("pageA_count", 0);
            System.out.println("Redis及数据库初始化完毕");
        }
    }
    
    

    监听器的作用就是当项目启动后,在数据库表中插入一条空记录,并且在 Redis 中存入这条空记录的 id,并且将其访问量初始化为0。

    最后我们再写一下跳转A页面的方法:

    
    @Autowired
    private RedisUtil redisUtil;
    
    @GetMapping("/toPageA")
    public String toPageA()
    {
        redisUtil.incr("pageA_count",1);
        System.out.println("访问量:"+redisUtil.get("pageA_count"));
        return "/pageA";
    }
    

    这时候代码就全部搞定了,我们启动一下项目,看看执行效果👇
    在这里插入图片描述
    我们每点跳转一次页面,Redis 中的访问量就会执行+1操作,实现了访问量的记录,最后一步就是把 Redis 中记录的访问量写入数据库就大功告成啦~

    我这里选择的是使用定时任务的方式写入,每间隔一段时间写入一次(为了能看到明显的效果,就写成了每间隔40秒执行一次)👇

    @Scheduled(cron = "*/40 * * * * ?")
    public void viewCount2DB(){
        System.out.println("准备从redis写入mysql");
        MamPictureView mamPictureView = new MamPictureView();
        mamPictureView.setViewId(Long.valueOf((String) redisUtil.get("pageA_id")));
        mamPictureView.setViewNum(Long.valueOf((String) redisUtil.get("pageA_count")));
        iMamPictureViewService.updateMamPictureView(mamPictureView);
        System.out.println("写入完毕");
    }
    

    在这里插入图片描述
    P.S. 写入数据库的过程就很简单了,而且有很多办法可以实现写入的操作,这里的定时任务只作为参考哦~ o( ̄▽ ̄)ブ

    小结

    本人经验有限,有些地方可能讲的没有特别到位,如果您在阅读的时候想到了什么问题,欢迎在评论区留言,我们后续再一一探讨🙇‍

    希望各位小伙伴动动自己可爱的小手,来一波点赞+关注 (✿◡‿◡) 让更多小伙伴看到这篇文章~ 蟹蟹呦(●’◡’●)

    如果文章中有错误,欢迎大家留言指正;若您有更好、更独到的理解,欢迎您在留言区留下您的宝贵想法。

    你在被打击时,记起你的珍贵,抵抗恶意;
    你在迷茫时,坚信你的珍贵,抛开蜚语;
    爱你所爱 行你所行 听从你心 无问东西

    展开全文
  • 页面指标分析、访问量分析 Tableau文件 一、实验目的 1、掌握不同大数据可视化图示的应用范围与场景 2、掌握大数据可视化工具Tableau在具体可视化场景中的使用 二、实验内容 1、网站流量的页面指标分析。 2、网站...

    页面指标分析、访问量分析

    Tableau文件
    一、实验目的
    1、掌握不同大数据可视化图示的应用范围与场景
    2、掌握大数据可视化工具Tableau在具体可视化场景中的使用

    二、实验内容
    1、网站流量的页面指标分析。
    2、网站流量的访问量分析。

    三、实验流程
    1、页面指标分析
    在网站流量统计分析中,网站页面浏览数一般是一个时期内的网页浏览总数以及每天平均网页浏览数,主要指标可以分为3类:网站流量指标、用户行为指标、用户浏览网站的方式。
    (1)页面访问次数
    访问次数是指访客完整打开网站页面进行访问的次数,访问次数是网站访问速度的衡量标准。创建页面访问次数可视化,操作步骤如下:
    ①将工作表1命名为页面访问次数;
    ②将度量下的“staytime”拖放到行功能区, 调整为平均值;
    ③将“uv”拖到列功能区;
    ④将维度下的“category”拖放到“标记”卡的“颜色”中;
    ⑤将度量下的“uv”拖放到“标记”卡的“大小”中;
    ⑥将维度下的“page”拖放到“标记”卡的“详细信息”中;
    ⑦将维度下的“date”拖放到“筛选器”上,周期为月, 并选择“显示筛选器”;
    ⑧将维度下的“category”拖放到“筛选器”上, 并选择“显示筛选器”。
    完成后如下图所示:
    在这里插入图片描述

    可以看到,搜索类网站访问量最多,时间停留也最长,而注册类网站访问量多,但停留时间短。
    

    (2)平均停留时间
    平均访问时长是用户访问网站的平均停留时间,平均访问时长=总访问时长/访问次数。如果用户不喜欢网站的内容,可能稍微看一眼就关闭网页,平均访问时长就很短。
    创建平均停留时间可视化,操作步骤如下:
    ①新建工作表,命名为平均停留时间;
    ②将度量下的“staytime”拖放到行功能区, 调整为平均值;
    ③维度下的“province”拖放到列功能区;
    ④将维度下的“category”拖放到“标记”卡的“颜色”中;
    ⑤将维度下的“date”拖放到“筛选器”上,周期为月,并选择“显示筛选器”;
    ⑥将维度下的“category”拖放到“筛选器”上, 并选择“显示筛选器”。
    完成后如下图所示:
    在这里插入图片描述

    可以看到,江西、福建、河北、云南等地平均停留时间较长,而西藏、甘肃等地网站停留时间较短。

    (3)区域热门页面
    通过各个页面浏览数的比例分析重要信息是否被用户关注, 通过对各个栏目页面浏览数量比例分析可以看出用户对哪些信息比较关注, 也可以获得访问网站首页的用户比例。 这些数据对于各个重要网页的重点推广具有重要意义。
    创建区域热门页面可视化,操作步骤如下所示:
    ①新建工作表,命名为区域热门页面;
    ②将维度下的“page”拖放到行功能区, 将维度下的“region”拖放到列功能区, 将度量下的“uv”拖放到列功能区;
    ③将维度下的“category”拖放到“标记”卡的“颜色”中;
    ④点击工具栏中的降序按钮;
    ⑤将维度下的“date”拖放到“筛选器”上,周期为月,并选择“显示筛选器”;
    ⑥将维度下的“category”拖放到“筛选器”上, 并选择“显示筛选器”。
    完成后如下图所示:
    在这里插入图片描述

    可以看到,index、download等网页在各地区中访问量最高。

    (4)创建页面指标分析仪表盘
    ①新建仪表盘(1000*600),命名为页面指标分析;
    ②分别将页面访问次数等3个工作表拖入画布中;
    ③关闭相同的右侧筛选器;
    ④右键右侧筛选器中的category和date,点击应用于工作表,选择选定工作表,然后勾选其他两个工作表,确定;
    ⑤隐藏页面访问次数等3个工作表。
    完成的布局如下图:
    在这里插入图片描述

    2、访问量分析
    网站访问量分析是指在获得网站访问量基本数据的情况下对有关数据进行统计分析, 从中发现用户访问网站的规律, 并将这些规律与网络营销策略等结合。访问量分析将围绕访问量地图、 各省市访问量、 区域访问量、 访问量趋势4个方面进行。
    (1)访问量地图
    网站访问统计分析报告的基础数据源于网站流量统计信息, 不过价值远高于原始数据资料。 可以通过地图的形式比较全国各个省市的网站访问量大小。
    创建访问量地图可视化,操作步骤如下:
    ①创建新工作表,命名为访问量地图;
    ②将度量下的“纬度(生成)”和“经度(生成)”分别拖放到行功能区和列功能区;
    ③将维度下的“category”拖放到“标记”卡的“颜色”中;
    ④将度量下的“uv”和拖放到“标记”卡的“大小”中;
    ⑤将维度下的“province”拖放到“标记”卡的“详细信息”中;
    ⑥点击标记卡中的饼图;
    ⑦将维度下的“province”拖放到“标记”卡的“标签”中;
    ⑧将维度下的“date”拖放到“筛选器”上, 并选择“显示筛选器”;
    ⑨将维度下的“category”拖放到“筛选器”上, 并选择“显示筛选器”。
    完成后如下图所示:
    在这里插入图片描述

    可以看到,山东、辽宁、广东等地的访问量较高,而新疆、西藏等地的访问量非常低
    

    (2)各省市访问量
    由于不同省市人文地理、 生活习惯和经济发展水平等的差异影响人们的网络访问偏好, 因此可以从中挖掘网站流量的区域分布特征。
    创建各省市访问量可视化,操作步骤如下:
    ①创建新工作表,命名为各省市访问量;
    ②将维度下的“category”拖放到列功能区, 将维度下的“province”拖放到行功能区;
    ③将度量下的“uv”拖放到“标记”卡的“文本”中;
    ④将维度下的“date”拖放到“筛选器”功能区, 统计频率调整为月, 并单击筛选条件, 选择“显示筛选器”。
    完成后如下图所示:

    在这里插入图片描述

    (3)访问量趋势
    对网站页面访问量进行分析,从中分析网站流量的发展趋势,并将这些数据与网站所处阶段与特点结合分析。
    ①创建新工作表,命名为访问量趋势;
    ②将维度下的“date”拖放到列功能区, 统计频度调整为月;
    ③将度量下的“uv”拖放到行功能区;
    ④将维度下的“category”拖放到“标记”卡的“颜色”中;
    ⑤将度量下的“uv”拖放到“标记”卡的“标签”中;
    ⑥将维度下的“category”拖放到“筛选器”功能区, 并单击筛选条件, 选择“显示筛选器”。
    完成后如下图所示:
    在这里插入图片描述

    (4)访问量树图使用。
    访问量即页面浏览量或单击量, 用户每一次对网站中的每个网页访问均被记录一次。 PV(Page View, 即页面浏览量), 因为一个独立IP可以产生多个PV, 所以PV个数≥独立IP个数。
    创建访问量树图,操作步骤如下:
    ①创建新工作表,命名为访问量树图;
    ②将维度下的“category”拖放到“标记”卡的“颜色”中;
    ③将度量下的“uv”拖放到“标记”卡的“大小”中;
    ④单击右上方的“智能显示”按钮, 在界面上选择“树地图”。
    ⑤将度量下的“uv”拖放到“标记”卡的“标签”中,然后点击“总和(uv)”,点击快速表计算,合计百分比;
    ⑥将维度下的“date”拖放到“筛选器”功能区, 统计频率调整为月, 并单击筛选条件, 选择“显示筛选器”。
    完成后如下图所示:

    在这里插入图片描述

    (5)创建访问量分析仪表盘
    ①新建仪表盘(1000*600),命名为访问量分析;
    ②分别将访问量地图等4个工作表拖入画布中;
    ③关闭相同的右侧筛选器;
    ④右键右侧筛选器中的category和date,点击应用于工作表,选择选定工作表,然后勾选其他两个工作表,确定;
    ⑤隐藏访问量地图等4个工作表。
    完成的布局如下图:

    在这里插入图片描述

    四、实验成果要求
    1、完成页面指标分析、访问量分析多个指标面板的创建。
    2、保存Tableau文件并提交实验结果。

    展开全文
  • 实现用户访问量/功能访问量的统计信息的查询-接上篇过滤器 拦截器前言1、情景分析与介绍1.1 数据库表1.1.1 设计表1.1.2 visit_records_number用户访问数 数据展示1.1.3 visit_records_function各功能的用户点击量 ...
  • 如何提高CSDN博客的访问量

    万次阅读 多人点赞 2019-11-03 10:05:03
    虽然不是很多,但小菌已经非常满足了,毕竟在CSDN上开源分享,总结经验才是最重要的,访问量,点赞数,评论数等附加数据则是用来评判博客内容质量好坏以及其本身受欢迎程度。最近小菌去浏览了一下博客周排行榜以及总排行榜...
  • python爬虫增加访问量

    万次阅读 多人点赞 2019-08-20 16:37:19
    看着自己少得可怜的访问量,突然有一个想用爬虫刷访问量的想法,主要也是抱着尝试的心态,学习学习。 第一版:网上借鉴了一下 以下代码运行在 python3 import urllib.request import time # 使用build_opener...
  • 一、提高浏览的技巧 相信很多人都这么想过:“我文章写的这么好,怎么就没人看呢?”; 或者这样想过:“这文章写得明明比我烂很多,凭什么这么多浏览?”; 虽然在我看来这是极其严重的内耗,对自己一点帮助...
  • 目前对于系统中常见的一种统计维度就是每天独立的用户访问量及UV,对于此类统计一般有几点需要考虑,第一:数据量很多,如果不做合理的设计,后期在进行聚合处理时会非常麻烦。第二:每天累计的大量数据会对系统存储...
  • csdn如何增加访问量

    千次阅读 热门讨论 2019-12-11 18:21:45
    按,访问量从高到底排序勒一下,发现访问最高的才5k左右,那家大牛,动不动一篇博客就是上w,大致总结勒一下,综合本人博客文章内容的一个访问量排名,发现提高访问量有如下几点: 1.标题得夸张,符合软件行业...
  • 网站用户访问量统计—Django

    千次阅读 2019-08-08 20:25:30
    最近准备弃用Django自带的admin,将个人博客网站接入hadmin后台模板,同时想要实现用户访问量统计功能。在网上查了一下具体实现方法。众说纷纭,有接入第三方的、有js实现的、有后端代码实现的,第三方的话很简单,...
  • 我们通过美国和全球的自然流量吸引了访问量最高的前100个站点。 然后,我们使用了网站浏览器 和关键字浏览器(我们的竞争分析和关键字研究工具)来更深入地研究其中一些网站为什么受欢迎以及其流量来自何处。 让我们...
  • //设置txt文档路径(count.txt用来记录总访问量,countday.txt用来记录日访问量) public static final String countPath="D:\\project\\src\\main\\webapp\\WEB-INF\\count.txt"; public static final String ...
  • 记录网站访问量

    千次阅读 2020-06-30 11:43:46
    3、访问主页时增加访问量 4、前端获取点击量或在项目关闭前,将点击量存入数据库(ContextController) 数据库 create table context( click_num int ) dao层 接口 public interface ContextM.
  • 两行代码搞定博客访问量统计

    千次阅读 2021-06-11 09:35:40
    我的博客有访客统计功能啦,看看实现的效果原始计数代码| 总访问量 次 | 总访客数 人 修改后的代码加上设置的初始值20000,| 总访问量 次 | 总访客数 人 $(document).ready(function() {var int = setinterval...
  • 在日常的网站使用中,经常会碰到页面的访问量(或者访问者人数)统计。那么,在Spring Boot中该如何实现这个功能呢?我们的想法是比较简单的,那就是将访问量储存在某个地方,要用的时候取出来即可,储存的位置可选择...
  • vue项目中统计页面访问量PV UV

    千次阅读 2020-12-22 07:12:23
    PV:page view 页面的访问量、浏览量。UV:Unique Visitor 一天24小时内,你的网站访问的IP数量。我们以vue项目来举例,每访问一个页面,都会经过main.js文件,所以我们在main.js中调用接口,将页面链接,名称等参数...
  • 不知不觉,二哥 CSDN 博客访问量破 1000 万了,这个成绩,全网也没几个吧? 虽然CSDN 被很多人鄙视过,二哥甚至也发过牢骚,但滴水之恩,当涌泉相报!二哥是从这里出发的,那就应该更加深爱着这个平台才对! 所以我...
  • 【开发经验】redis访问量统计

    千次阅读 2021-01-14 21:13:50
    文章目录前言一、问题思路1、...如果真是这样,这里阐述一个通过redis使用hyperloglog数据结构实现访问量统计,请大家参考。 一、问题思路 需求:实现某个接口每天调用了多少次,每个用户只记录一次。 1、数据库统计
  • 今天分享限制某个IP访问nginx服务器的方法,对于有异常访问攻击服务器或被爬虫过度访问骚扰的场景非常有用
  • 在网站推广活动之前,业务方根据经验评估出的系统访问量PV,然后根据各个系统所占的流量比例,计算出每个子系统的访问量,比如商品列表1000万,商品详情1500万,下单500万等,然后根据每个系统和数据库的交互次数,来算出...
  • 如何增加访问量、阅读量

    千次阅读 2019-02-12 11:09:19
    玩博客有一段时间了,有时候看见自己那少得可怜的博客访问量和博文阅读数,心想怎么样才能提高自己的博客访问量博文阅读数呢,结合自身搞过web方面的经历发现:这个博文阅读量就是当你打开对应博文的网址,后端程序...
  • javaweb之统计网站访问量小案例

    千次阅读 多人点赞 2019-02-20 17:04:52
    javaweb之统计网站访问量小案例
  • 如何实现网站访问量统计 不利用站长之家实现网站访问量统计 一行代码实现访问量统计 1. 访问http://www.amazingcounters.com/index.php网站 2. 进入网站后选择Sign Up 3. 选择一个能看的统计数字界面 4. 然后拉到底...
  • 微信小程序快速提升访问量方法

    千次阅读 2020-12-09 11:14:05
    2、流量主开通的条件是独立访客(UV)不低于1000,1000人说多不多,说少也不少,因为小程序是没有链接的,是不可以进行一个流量刷取的,独立访客是需要1000个实实在在的用户,并不是访问量。 3、开发好小程序之后,...
  • CSDN博客访问量问题

    千次阅读 2018-03-29 18:35:43
    亲测,发现CSDN博客访问量算法有问题。 随意打开自己任意一片博客,刷新,都算一次访问了,但短时间内持续刷新没有算访问量。 过几分钟,重新刷新,又算一次访问量访问量又 +1。 话说CSDN,这个访问量的算法...
  • Web并发页面访问量统计实现

    万次阅读 热门讨论 2018-01-21 09:49:56
    Web并发页面访问量统计实现 页面访问量统计,可能在上学的时候就讲过如何简单实现,例如在servletContext中保存一个页页面访问次数,然后每访问一次加1;或者每访问一次就把操作记录保存到数据库,这样的处理方式,...
  • 根据nginx日志统计ip访问量

    千次阅读 2019-10-23 13:01:06
    根据nginx日志统计ip访问量,由浅入深,逐步讲解。涉及命令 awk、sort、uniq nginx access.log 日志内容截图如下: nginx access.log日志统计第一列 ip [root@izbp1845cet96se1qmb5ekz logs]# ls access....
  • 如何查看服务器当前的并发访问量

    千次阅读 2020-04-14 08:37:06
    服务器访问人数可以通过命令:netstat -pnt |grep:80列出 比如此时请求服务器上一个页面,通过该命令可以查看结果,后面的ESTABLISHED表示服务器正在被访问,可以通过添加wc-l统计数量,最终命令是:netstat -pnt...
  • hexo博客添加访问量统计

    千次阅读 2019-07-03 14:15:13
    1、配置是否开启不蒜子访问量统计功能 在themes/yilia/_config.yml添加属性 # 是否开启访问量统计功能(不蒜子) busuanzi: enable: true 2、引入不蒜子并添加站点访问量 在themes/yilia/layout/_partial/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,320,162
精华内容 928,064
关键字:

访问量