黑马堂高手论坛手机网_2015黑马net基础就业班_黑马论坛基础分(2)

3、关键指标

⊙浏览量PV

定义：页面浏览量即为PV(Page View)，是指所有用户浏览页面的总和，一个独立用户每打开一个页面就被记录1 次。

分析：网站总浏览量，可以考核用户对于网站的兴趣，就像收视率对于电视剧一样。但是对于网站运营者来说，更重要的是，每个栏目下的浏览量。

计算公式：记录计数

⊙注册用户数

计算公式：对访问member.php?mod=register的url，计数

⊙IP数

定义：一天之内，访问网站的不同独立IP 个数加和。其中同一IP无论访问了几个页面，独立IP 数均为1。黑马论坛基础分

分析：这是我们最熟悉的一个概念，无论同一个IP上有多少电脑，或者其他用户，从某种程度上来说，独立IP的多少，是衡量网站推广活动好坏最直接的数据。

公式：对不同ip，计数

⊙跳出率

定义：只浏览了一个页面便离开了网站的访问次数占总的访问次数的百分比，即只浏览了一个页面的访问次数 / 全部的访问次数汇总。

分析：跳出率是非常重要的访客黏性指标，它显示了访客对网站的兴趣程度：跳出率越低说明流量质量越好，访客对网站的内容越感兴趣，这些访客越可能是网站的有效用户、忠实用户。

计算公式：(1)统计一天内只出现一条记录的ip，称为跳出数

(2)跳出数/PV

⊙版块热度排行榜

定义：版块的访问情况排行。

分析：巩固热点版块成绩，加强冷清版块建设。同时对学科建设也有影响。

计算公式：按访问次数统计排序

4、项目开发步骤

1.使用flume把日志数据导入到hdfs中

2.对数据进行清洗、清洗后的数据易于我们使用

3.明细日志使用hbase存储，能够利用ip、时间查询

4.使用hive进行数据的多维分析

5.把hive分析结果使用sqoop导出到mysql中

6.提供视图工具供用户使用

上面介绍了项目的一些基本情况，下面我们将详细介绍项目的开发过程：

1、把日志数据上传到HDFS中进行处理

如果是日志服务器数据较小、压力较小，可以直接使用shell命令把数据上传到HDFS中；

如果是日志服务器数据较大、压力较答，使用NFS在另一台服务器上上传数据；

如果日志服务器数据非常多、数据量大，使用flume进行数据处理；

[root@hadoop11 mydata]# hadoop fs -put access_2013_05_30.log  /hmbbs_logs/
[root@hadoop11 mydata]# hadoop fs -lsr /hmbbs_logs/
lsr: DEPRECATED: Please use 'ls -R' instead.
-rw-r--r--   3 root supergroup   61084192 2016-07-22 14:42 /hmbbs_logs/access_2013_05_30.log

2、使用MapReduce对数据进行清洗，清洗后的数据易于我们的使用

清洗标准：将Apache log日志清洗成我们熟悉的日志格式。

①

访问状态和本次流量字段去掉

②

过滤掉静态记录，只要动态记录；

GET /static 或者 GET /uc_server 开头的行文本舍弃

过滤掉了开头和结尾的标志信息；

GET /POST /

HTTP/1.1HTTP/1.0

清洗日志的MapReduce源代码：

package Hmbbs;

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;
;

//本程序的目的是通过MapReduce对Hmbbs中的日志数据进行清洗时
public class HmbbsCleaner  
{
        public static String path1="";//指定文件的输入路径
        public static String path2="";//指定日志的输出路径
        public static void main(String[] args) throws Exception
        {
            path1 = args[0];
            path2 = args[1];

            Configuration conf = new Configuration();
            conf.set("fs.defaultFS", "hdfs://hadoop11:9000/");
            FileSystem fileSystem = FileSystem.get(conf);
            if(fileSystem.exists(new Path(path2)))
            {
                fileSystem.delete(new Path(path2), true);
            }
            Job job = Job.getInstance(conf, "HmbbsCleaner");
            job.setJarByClass(HmbbsCleaner.class);//jar包
            //编写驱动
            FileInputFormat.setInputPaths(job, new Path(path1));
            job.setInputFormatClass(TextInputFormat.class);
            job.setMapperClass(MyMapper.class);
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(NullWritable.class);
            job.setNumReduceTasks(1);//指定Reducer的任务数量为1
            job.setPartitionerClass(HashPartitioner.class);
            job.setReducerClass(MyReducer.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(NullWritable.class);
            FileOutputFormat.setOutputPath(job, new Path(path2));
            job.setOutputFormatClass(TextOutputFormat.class);

            //提交任务
            job.waitForCompletion(true);
        }
      public static class MyMapper extends Mapper<LongWritable, Text, Text, NullWritable>
      {
            protected void map(LongWritable k1, Text v1,Context context)throws IOException, InterruptedException
            {
                 String string = v1.toString();//获取待记录
                 Parselogs parselogs = new Parselogs();
                try
                {
                     String[] sub = parselogs.parseString(string);
                     if(sub[2].startsWith("GET /static")||sub[2].startsWith("GET /uc_server"))
                            return ;//对于静态的记录直接过滤掉，不进行任何处理

                     if(sub[2].startsWith("GET /"))
                     {
                            sub[2] = sub[2].substring("GET /".length());
                     }
                     if(sub[2].startsWith("POST /"))
                     {
                            sub[2] = sub[2].substring("POST /".length());
                     }//过滤掉了开头和结尾的标志信息
                     if(sub[2].endsWith(" HTTP/1.1"))
                     {
                            sub[2] = sub[2].substring(0, sub[2].length()-" HTTP/1.1".length());
                     }
                     if(sub[2].endsWith(" HTTP/1.0"))
                     {
                            sub[2] = sub[2].substring(0, sub[2].length()-" HTTP/1.0".length());
                     }
                     Text k2 = new Text();
                     k2.set(sub[0]+"\t"+sub[1]+"\t"+sub[2]);//三个字段之间以制表符进行分开
                     context.write(k2, NullWritable.get()); 
                } 

                catch (ParseException e)
                {
                    e.printStackTrace();
                }
            }
      }
      public static class MyReducer extends Reducer<Text, NullWritable, Text, NullWritable>
      {
                protected void reduce(Text k2, Iterable<NullWritable> v2s,Context context)throws IOException, InterruptedException
                {
                     for (NullWritable v2 : v2s)
                    {
                         Text k3 = k2;
                         context.write(k3, NullWritable.get());
                    }
                }
      }
}
class Parselogs //Parselogs这个类用来对字符串进行解析
{
     public String[]  parseString(String str) throws ParseException
     {
        String  str1 = parseIp(str);
        String  str2 = parseDate(str);
        String  str3 = parseUrl(str);
        //String  str4 = parseStatus(str);
        //String  str5 = parseFlow(str);
        //String[] str66 = new String[]{str1,str2,str3,str4,str5};
        String[] str66 = new String[]{str1,str2,str3};//在这里只获取与本次项目有关的数据
        return str66;
     }
     public String parseIp(String str)//对ip地址进行解析的方法
     {
          String[] splited = str.split(" - - ");//用指定的正则表达式进行切分，获取我们需要的字段
          return splited[0];
     }
     public String parseDate(String str) throws ParseException
     {
         String[] splited = str.split(" - - ");//用指定的正则表达式进行切分，获取我们需要的字段
         int index1 = splited[1].indexOf("[");
         int index2 = splited[1].indexOf("]");
         String substring = splited[1].substring(index1+1, index2);//到此获取了时间字段30/May/2013:17:38:20 +0800
         SimpleDateFormat 1 = new SimpleDateFormat("dd/MMM/yyyy:HH:mm:ss", Locale.ENGLISH);//匹配我们给定的字符串，并将其解析成对应的时间
         SimpleDateFormat 2 = new SimpleDateFormat("yyyyMMddHHmmss");//匹配我们给定的字符串
         Date parse = 1.parse(substring);
         String format = 2.format(parse);
         return format;
     }
     public String parseUrl(String str)//获取访问的url
     {
          int index1 = str.indexOf("]");
          int index2= str.lastIndexOf("\"");
          String substring = str.substring(index1+3, index2);
          return substring;
     }
     public String parseStatus(String str)//获取访问的状态
     {
         int index1= str.lastIndexOf("\"");
         String str2 = str.substring(index1+1).trim();
         String[] splited = str2.split(" ");
         return splited[0];
     }
     public String parseFlow(String str)//获取访问的状态
     {
         int index1= str.lastIndexOf("\"");
         String str2 = str.substring(index1+1).trim();
         String[] splited = str2.split(" ");
         return splited[1];
     }
}

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-28332-2.html