Spark项目之电商用户行为分析大数据平台之（十）IDEA项目搭建及工具类介绍

一、创建Maven项目

创建项目，名称为LogAnalysis

二、常用工具类

2.1　配置管理组建

ConfigurationManager.java

 import java.io.InputStream;
 import java.util.Properties;

 /**
  * 配置管理组件
  *
  * 1、配置管理组件可以复杂，也可以很简单，对于简单的配置管理组件来说，只要开发一个类，可以在第一次访问它的
  *         时候，就从对应的properties文件中，读取配置项，并提供外界获取某个配置key对应的value的方法
  * 2、如果是特别复杂的配置管理组件，那么可能需要使用一些软件设计中的设计模式，比如单例模式、解释器模式
  *         可能需要管理多个不同的properties，甚至是xml类型的配置文件
  * 3、我们这里的话，就是开发一个简单的配置管理组件，就可以了
  *
  */
 public class ConfigurationManager {

     // Properties对象使用private来修饰，就代表了其是类私有的
     // 那么外界的代码，就不能直接通过ConfigurationManager.prop这种方式获取到Properties对象
     // 之所以这么做，是为了避免外界的代码不小心错误的更新了Properties中某个key对应的value
     // 从而导致整个程序的状态错误，乃至崩溃
     private static Properties prop = new Properties();

     static {
         try {
             InputStream in = ConfigurationManager.class
                     .getClassLoader().getResourceAsStream("conf.properties");
             prop.load(in);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     /**
      * 获取指定key对应的value
      *
      * @param key
      * @return value
      */
     public static String getProperty(String key) {

         return prop.getProperty(key);
     }

     /**
      * 获取整数类型的配置项
      * @param key
      * @return value
      */
     public static Integer getInteger(String key) {
         String value = getProperty(key);
         try {
             return Integer.valueOf(value);
         } catch (Exception e) {
             e.printStackTrace();
         }
         return 0;
     }

     /**
      * 获取布尔类型的配置项
      * @param key
      * @return value
      */
     public static Boolean getBoolean(String key) {
         String value = getProperty(key);
         try {
             return Boolean.valueOf(value);
         } catch (Exception e) {
             e.printStackTrace();
         }
         return false;
     }

     /**
      * 获取Long类型的配置项
      * @param key
      * @return
      */
     public static Long getLong(String key) {
         String value = getProperty(key);
         try {
             return Long.valueOf(value);
         } catch (Exception e) {
             e.printStackTrace();
         }
         return 0L;
     }

2.2　常量的接口

Constants.java

 /**
  * 常量接口
  * @author Administrator
  *
  */
 public interface Constants {

     /**
      * 项目配置相关的常量
      */
     String JDBC_DRIVER = "jdbc.driver";
     String JDBC_DATASOURCE_SIZE = "jdbc.datasource.size";
     String JDBC_URL = "jdbc.url";
     String JDBC_USER = "jdbc.user";
     String JDBC_PASSWORD = "jdbc.password";
     String JDBC_URL_PROD = "jdbc.url.prod";
     String JDBC_USER_PROD = "jdbc.user.prod";
     String JDBC_PASSWORD_PROD = "jdbc.password.prod";
     String SPARK_LOCAL = "spark.local";
     String SPARK_LOCAL_TASKID_SESSION = "spark.local.taskid.session";
     String SPARK_LOCAL_TASKID_PAGE = "spark.local.taskid.page";
     String SPARK_LOCAL_TASKID_PRODUCT = "spark.local.taskid.product";
     String KAFKA_METADATA_BROKER_LIST = "kafka.metadata.broker.list";
     String KAFKA_TOPICS = "kafka.topics";

     /**
      * Spark作业相关的常量
      */
     String SPARK_APP_NAME_SESSION = "UserVisitSessionAnalyzeSpark";
     String SPARK_APP_NAME_PAGE = "PageOneStepConvertRateSpark";
     String FIELD_SESSION_ID = "sessionid";
     String FIELD_SEARCH_KEYWORDS = "searchKeywords";
     String FIELD_CLICK_CATEGORY_IDS = "clickCategoryIds";
     String FIELD_AGE = "age";
     String FIELD_PROFESSIONAL = "professional";
     String FIELD_CITY = "city";
     String FIELD_SEX = "sex";
     String FIELD_VISIT_LENGTH = "visitLength";
     String FIELD_STEP_LENGTH = "stepLength";
     String FIELD_START_TIME = "startTime";
     String FIELD_CLICK_COUNT = "clickCount";
     String FIELD_ORDER_COUNT = "orderCount";
     String FIELD_PAY_COUNT = "payCount";
     String FIELD_CATEGORY_ID = "categoryid";

     String SESSION_COUNT = "session_count";

     String TIME_PERIOD_1s_3s = "1s_3s";
     String TIME_PERIOD_4s_6s = "4s_6s";
     String TIME_PERIOD_7s_9s = "7s_9s";
     String TIME_PERIOD_10s_30s = "10s_30s";
     String TIME_PERIOD_30s_60s = "30s_60s";
     String TIME_PERIOD_1m_3m = "1m_3m";
     String TIME_PERIOD_3m_10m = "3m_10m";
     String TIME_PERIOD_10m_30m = "10m_30m";
     String TIME_PERIOD_30m = "30m";

     String STEP_PERIOD_1_3 = "1_3";
     String STEP_PERIOD_4_6 = "4_6";
     String STEP_PERIOD_7_9 = "7_9";
     String STEP_PERIOD_10_30 = "10_30";
     String STEP_PERIOD_30_60 = "30_60";
     String STEP_PERIOD_60 = "60";

     /**
      * 任务相关的常量
      */
     String PARAM_START_DATE = "startDate";
     String PARAM_END_DATE = "endDate";
     String PARAM_START_AGE = "startAge";
     String PARAM_END_AGE = "endAge";
     String PARAM_PROFESSIONALS = "professionals";
     String PARAM_CITIES = "cities";
     String PARAM_SEX = "sex";
     String PARAM_KEYWORDS = "keywords";
     String PARAM_CATEGORY_IDS = "categoryIds";
     String PARAM_TARGET_PAGE_FLOW = "targetPageFlow";

 }

2.3　时间日期工具类

DateUtils.java

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Calendar;
 import java.util.Date;

 /**
  * 时间日期工具类
  * */
 public class DateUtils {

     public static final SimpleDateFormat TIME_FORMAT =
             new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     public static final SimpleDateFormat DATE_FORMAT =
             new SimpleDateFormat("yyyy-MM-dd");
     public static final SimpleDateFormat DATEKEY_FORMAT =
             new SimpleDateFormat("yyyyMMdd");

     /**
      * 判断第一个时间是否在第二个时间之前
      * */
     public static boolean before(String firstTime,String secondTime){
         try {
             Date first = TIME_FORMAT.parse(firstTime);
             Date second = TIME_FORMAT.parse(secondTime);

             if(first.before(second)){
                 return true;
             }
         } catch (ParseException e) {
             e.printStackTrace();
         }
         return false;
     }

     /**
      * 判断第一个时间是否在第二个时间之后
      * */
     public static boolean after(String firstTime,String secondTime){
         try {
             Date first = TIME_FORMAT.parse(firstTime);
             Date second = TIME_FORMAT.parse(secondTime);

             if(first.after(second)){
                 return true;
             }
         }catch (ParseException e){
             e.printStackTrace();
         }
         return false;
     }

     /**
      * 计算2个时间的差值(单位为秒)
      * */
     public static int minus(String firstTime,String secondTime){
         try {
             Date first = TIME_FORMAT.parse(firstTime);
             Date second = TIME_FORMAT.parse(secondTime);
             long millisecond = first.getTime() - second.getTime();
             return Integer.valueOf(String.valueOf(millisecond/1000));
         }catch (ParseException e){
             e.printStackTrace();
         }
         return 0;
     }

     /**
      * 获取年月日和小时
      * */
     public static String getDateHour(String datetime){
         String date = datetime.split(" ")[0];
         String hourMinuteSecond = datetime.split(" ")[1];
         String hour = hourMinuteSecond.split(":")[0];
         return date+"_"+hour;
     }

     /**
      * 获取当天的日期
      * */
     public static String getTodayDate(){
         return DATE_FORMAT.format(new Date());
     }

     /**
      * 获取昨天的日期
      * */
     public static String getYesterdayDate(){
         Calendar calendar = Calendar.getInstance();
         calendar.setTime(new Date());
         calendar.add(Calendar.DAY_OF_YEAR,-1);

         Date time = calendar.getTime();
         return DATE_FORMAT.format(time);
     }

     /**
      * 格式化日期（yyyy-MM-dd）
      */
     public static String formatDate(Date date) {
         return DATE_FORMAT.format(date);
     }

     /**
      * 格式化时间（yyyy-MM-dd HH:mm:ss）
      */
     public static String formatTime(Date date) {
         return TIME_FORMAT.format(date);
     }

     /**
      * 解析时间字符串
      */
     public static Date parseTime(String time) {
         try {
             return TIME_FORMAT.parse(time);
         } catch (ParseException e) {
             e.printStackTrace();
         }
         return null;
     }

     /**
      * 格式化日期key
      */
     public static String formatDateKey(Date date) {
         return DATEKEY_FORMAT.format(date);
     }

     /**
      * 格式化日期key
      */
     public static Date parseDateKey(String datekey) {
         try {
             return DATEKEY_FORMAT.parse(datekey);
         } catch (ParseException e) {
             e.printStackTrace();
         }
         return null;
     }

     /**
      * 格式化时间，保留到分钟级别
      */
     public static String formatTimeMinute(Date date) {
         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmm");
         return sdf.format(date);
     }
 }

2.4　数字格式化工具类

NumberUtils.java

 import java.math.BigDecimal;

 /**
  * 数字格式化工具类
  * @author Administrator
  *
  */
 public class NumberUtils {

     /**
      * 格式化小数
      * @param num 字符串
      * @param scale 四舍五入的位数
      * @return 格式化小数
      */
     public static double formatDouble(double num, int scale) {
         BigDecimal bd = new BigDecimal(num);
         return bd.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
     }

 }

2.5　参数工具类

ParamUtils.java

 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.bw.conf.ConfigurationManager;
 import com.bw.constant.Constants;

 /**
  * 参数工具类
  * @author Administrator
  *
  */
 public class ParamUtils {

     /**
      * 从命令行参数中提取任务id
      * @param args 命令行参数
      * @return 任务id
      */
     public static Long getTaskIdFromArgs(String[] args, String taskType) {
         boolean local = ConfigurationManager.getBoolean(Constants.SPARK_LOCAL);

         if(local) {
             return ConfigurationManager.getLong(taskType);
         } else {
             try {
                 if(args != null && args.length > 0) {
                     return Long.valueOf(args[0]);
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }

         return null;
     }

     /**
      * 从JSON对象中提取参数
      * @param jsonObject JSON对象
      * @return 参数
      */
     public static String getParam(JSONObject jsonObject, String field) {
         JSONArray jsonArray = jsonObject.getJSONArray(field);
         if(jsonArray != null && jsonArray.size() > 0) {
             return jsonArray.getString(0);
         }
         return null;
     }

 }

2.6　字符串工具类

StringUtils.java

 /**
  * 字符串工具类
  * @author Administrator
  *
  */
 public class StringUtils {

     /**
      * 判断字符串是否为空
      * @param str 字符串
      * @return 是否为空
      */
     public static boolean isEmpty(String str) {
         return str == null || "".equals(str);
     }

     /**
      * 判断字符串是否不为空
      * @param str 字符串
      * @return 是否不为空
      */
     public static boolean isNotEmpty(String str) {
         return str != null && !"".equals(str);
     }

     /**
      * 截断字符串两侧的逗号
      * @param str 字符串
      * @return 字符串
      */
     public static String trimComma(String str) {
         if(str.startsWith(",")) {
             str = str.substring(1);
         }
         if(str.endsWith(",")) {
             str = str.substring(0, str.length() - 1);
         }
         return str;
     }

     /**
      * 补全两位数字
      * @param str
      * @return
      */
     public static String fulfuill(String str) {
         if(str.length() == 2) {
             return str;
         } else {
             return "0" + str;
         }
     }

     /**
      * 从拼接的字符串中提取字段
      * @param str 字符串
      * @param delimiter 分隔符
      * @param field 字段
      * @return 字段值
      */
     public static String getFieldFromConcatString(String str,
             String delimiter, String field) {
         try {
             String[] fields = str.split(delimiter);
             for(String concatField : fields) {
                 // searchKeywords=|clickCategoryIds=1,2,3
                 if(concatField.split("=").length == 2) {
                     String fieldName = concatField.split("=")[0];
                     String fieldValue = concatField.split("=")[1];
                     if(fieldName.equals(field)) {
                         return fieldValue;
                     }
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null;
     }

     /**
      * 从拼接的字符串中给字段设置值
      * @param str 字符串
      * @param delimiter 分隔符
      * @param field 字段名
      * @param newFieldValue 新的field值
      * @return 字段值
      */
     public static String setFieldInConcatString(String str,
             String delimiter, String field, String newFieldValue) {
         String[] fields = str.split(delimiter);

         for(int i = 0; i < fields.length; i++) {
             String fieldName = fields[i].split("=")[0];
             if(fieldName.equals(field)) {
                 String concatField = fieldName + "=" + newFieldValue;
                 fields[i] = concatField;
                 break;
             }
         }

         StringBuffer buffer = new StringBuffer("");
         for(int i = 0; i < fields.length; i++) {
             buffer.append(fields[i]);
             if(i < fields.length - 1) {
                 buffer.append("|");
             }
         }

         return buffer.toString();
     }

 }

2.7　校验工具类

ValidUtils.java

 /**
  * 校验工具类
  * @author Administrator
  *
  */
 public class ValidUtils {

     /**
      * 校验数据中的指定字段，是否在指定范围内
      * @param data 数据
      * @param dataField 数据字段
      * @param parameter 参数
      * @param startParamField 起始参数字段
      * @param endParamField 结束参数字段
      * @return 校验结果
      */
     public static boolean between(String data, String dataField,
             String parameter, String startParamField, String endParamField) {
         String startParamFieldStr = StringUtils.getFieldFromConcatString(
                 parameter, "\\|", startParamField);
         String endParamFieldStr = StringUtils.getFieldFromConcatString(
                 parameter, "\\|", endParamField);
         if(startParamFieldStr == null || endParamFieldStr == null) {
             return true;
         }

         int startParamFieldValue = Integer.valueOf(startParamFieldStr);
         int endParamFieldValue = Integer.valueOf(endParamFieldStr);

         String dataFieldStr = StringUtils.getFieldFromConcatString(
                 data, "\\|", dataField);
         if(dataFieldStr != null) {
             int dataFieldValue = Integer.valueOf(dataFieldStr);
             if(dataFieldValue >= startParamFieldValue &&
                     dataFieldValue <= endParamFieldValue) {
                 return true;
             } else {
                 return false;
             }
         }

         return false;
     }

     /**
      * 校验数据中的指定字段，是否有值与参数字段的值相同
      * @param data 数据
      * @param dataField 数据字段
      * @param parameter 参数
      * @param paramField 参数字段
      * @return 校验结果
      */
     public static boolean in(String data, String dataField,
             String parameter, String paramField) {
         String paramFieldValue = StringUtils.getFieldFromConcatString(
                 parameter, "\\|", paramField);
         if(paramFieldValue == null) {
             return true;
         }
         String[] paramFieldValueSplited = paramFieldValue.split(",");  

         String dataFieldValue = StringUtils.getFieldFromConcatString(
                 data, "\\|", dataField);
         if(dataFieldValue != null) {
             String[] dataFieldValueSplited = dataFieldValue.split(",");

             for(String singleDataFieldValue : dataFieldValueSplited) {
                 for(String singleParamFieldValue : paramFieldValueSplited) {
                     if(singleDataFieldValue.equals(singleParamFieldValue)) {
                         return true;
                     }
                 }
             }
          }

         return false;
     }

     /**
      * 校验数据中的指定字段，是否在指定范围内
      * @param data 数据
      * @param dataField 数据字段
      * @param parameter 参数
      * @param paramField 参数字段
      * @return 校验结果
      */
     public static boolean equal(String data, String dataField,
             String parameter, String paramField) {
         String paramFieldValue = StringUtils.getFieldFromConcatString(
                 parameter, "\\|", paramField);
         if(paramFieldValue == null) {
             return true;
         }

         String dataFieldValue = StringUtils.getFieldFromConcatString(
                 data, "\\|", dataField);
         if(dataFieldValue != null) {
             if(dataFieldValue.equals(paramFieldValue)) {
                 return true;
             }
          }

         return false;
     }

 }