east – 第58页 – gitweixin

开发博客 5月 18,2021

私域流量干货：微信群如何换群

有了基础群流量之后，就可以根据不同的产品、品牌采用不同的策略进行换群裂变。换群所使用的福利一般是成本可控的产品，比如景区门票、KTV欢唱卡、酒店优惠卡等，利用闲置资源或者低价产品来进行换群。换群就需要在群内推送广告，为了规避风险，每进入一个群，要分别邀请3个马甲号，防止在群内推送广告时被踢出群。

1、活动裂变

比如通过产品发布会、开业典礼、周年庆等活动形式，给予微信好友或者微信群好友一定的活动产品来进行微信群的裂变。我们以健身房开业来举例。活动裂变的步骤大概如下：

1）“大家好，本人有一家健身房周末开业，凡是加我微信的好友可以免费获得一张10次健身卡或者一个大红包！”这个步骤是为了将群内对健身感兴趣的好友引流到微信个人号中，产生第一步的信任关系。

2）要群：“你好，朋友，我新开的健身房周末开业，现在拉我进入3个微信群，我会送你一张10次健身卡或给你发10元红包，可以吗？”每个人都有一些闲置微信群或者认为对自己没有用的微信群，采用求邀请的形式，用户邀请你进群就没有压力，一般都能够满足。

3）再要群：“如果你还有微信群的话能否再多邀请我几个，我给你多发一些红包，等新店开业你带朋友过来时我给你多开几张卡，配私人教练，私教免单！”在第二步要群的基础上挖掘好友的微信群量，因为在他完成第二步时你给他发了红包或者给了礼品卡，他对你已经产生了信任，更容易进行裂变。

2、礼物裂变

在礼品选择时，要使用高性价比，成本低，市场价值大的，同时也要考虑礼物需不需要进行配送，尽量使用不需要配送的礼品。以游乐场门票作为礼品，可以设置如下群裂变流程和话术：

1）“朋友们，我已经领取了价值98元的游乐场门票！本来以为是骗人的，结果真的领到了，大家如果对游乐场感兴趣，可以直接加这个微信号的好友领取啊。”发完这条广告之后，再发一个小红包，让大家对你更有好感。

2）要群：当用户想要领取门票，添加了发放门票的微信个人号为好友之后，可以通过这个话术进行引导：“你好呀，领取门票是不需要任何费用的，我们为了宣传人气推出的活动。参与方式：只要邀请我进入3个本地微信群即可领取，放心，我是不会一进群就发广告的，如果我发广告，你可以撤回群邀请。”让用户感知到你是一个可靠的人，同时打消用户邀请你进群的顾虑，很多人不喜欢邀请别人进群，就是担心此人进群后发广告，会影响到自己的形象。

3）再要群：“你好，如果还有微信群的话可以再邀请我进入几个吗，你可以获得我们额外赠送的赠品或红包。”

3、置换裂变群

置换是用得最多的一种形式，如果你已经积累了1000多个微信群，你可以通过朋友圈、微信群发布你可以给别人换群的资源。

1）“朋友圈的各位朋友，我现在有1000个本地同城吃喝玩乐的群，如果你也想加入更多本地微信群，可以私信我，我们可以换群，你邀请我加入5个微信群，我邀请你加入我的10个微信群。”

2）再要群：“朋友，你还有微信群吗？邀请我加入的微信群越多，我越会双倍邀请你加入我的微信群。”

作者 east

Java 5月 13,2021

Java远程访问工具类

我们都知道，xshell、xftp等是远程访问的利器，但在实际工作中，有时要用java代码实现上面这2个工具的基础功能，远程访问和下载等等：

public class RemoteShellUtil {

    private final static Logger LOGGER = LoggerFactory.getLogger(RemoteShellUtil.class);

    private JSch jsch;

    private Session session = null;

    private String user = null;

    private String password = null;

    private String host = null;

    public void setUser(String user) {
        this.user = user;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public void exec(String command) {
        if (this.session == null || !this.session.isConnected()) {
            if (!this.Connect(this.user, this.password, this.host)) {
                LOGGER.error("connect failed");
                return;
            }
        }

        BufferedReader reader = null;
        Channel channel = null;

        try {
            channel = this.session.openChannel("exec");
            ((ChannelExec) channel).setCommand(command);
            channel.setInputStream(null);
            ((ChannelExec) channel).setErrStream(System.err);
            channel.setInputStream(null);
            int exitStatus = channel.getExitStatus();
            channel.connect();
            InputStream in = channel.getInputStream();
            reader = new BufferedReader(new InputStreamReader(in));
            String buf;

            while ((buf = reader.readLine()) != null) {
                LOGGER.info(buf);
            }
        } catch (JSchException | IOException e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
        } finally {
            try {
                if (null != reader) reader.close();
                if (null != channel) channel.disconnect();
                this.session.disconnect();
            } catch (IOException e) {
                LOGGER.error(Throwables.getStackTraceAsString(e));
            }

        }

    }

    public Boolean download(String serverPath, String localpath) {
        if (!checkConnect()) return false;

        ChannelSftp channel = null;

        boolean status = false;
        try {
            channel = (ChannelSftp) this.session.openChannel("sftp");
            channel.connect();
            FileOutputStream out = new FileOutputStream(new File(localpath));
            BufferedOutputStream writer = new BufferedOutputStream(out);
            SftpProgressMonitor var10000 = new SftpProgressMonitor() {
                private long current = 0L;

                @Override
                public void init(int i, String s, String s1, long l) {
                }

                public boolean count(long arg0) {
                    this.current += arg0;
                    return true;
                }

                @Override
                public void end() {
                }
            };
            channel.get(serverPath, writer);
            writer.close();
            status = true;
        } catch (Exception e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
        } finally {
            if (null != channel) channel.disconnect();
            this.session.disconnect();
        }

        return status;
    }

    public Boolean upload(String serverPath, String localpath) {
        if (!checkConnect()) return false;

        ChannelSftp channel = null;

        boolean status = false;
        try {
            channel = (ChannelSftp) this.session.openChannel("sftp");
            channel.connect();
            FileInputStream in = new FileInputStream(new File(localpath));
            BufferedInputStream reader = new BufferedInputStream(in);
            SftpProgressMonitor var10000 = new SftpProgressMonitor() {
                private long current = 0L;

                public boolean count(long arg0) {
                    this.current += arg0;
                    return true;
                }

                public void end() {
                }

                public void init(int arg0, String arg1, String arg2, long arg3) {
                }
            };
            channel.put(reader, serverPath);
            reader.close();
            status = true;
        } catch (Exception e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
        } finally {
            if (null != channel) channel.disconnect();
            this.session.disconnect();
        }

        return status;
    }

    private Boolean Connect(String user, String password, String host) {
        try {
            if (null == this.jsch) this.jsch = new JSch();
            this.session = this.jsch.getSession(user, host, 22);
            this.session.setPassword(password);
            Properties config = new Properties();
            config.put("StrictHostKeyChecking", "no");
            this.session.setConfig(config);
            this.session.connect();
            return true;
        } catch (Exception e) {
            LOGGER.error("connect failed, reason{}", Throwables.getStackTraceAsString(e));
            return false;
        }
    }

    private Boolean checkConnect() {
        if (this.session == null || !this.session.isConnected()) {
            return this.Connect(this.user, this.password, this.host);
        }
        return true;
    }
}

作者 east

neo4j 5月 11,2021

Neo4j批量插入Java API实例

@Component
public class DatabaseBatchSaveUtil {

    private final static Logger LOGGER = LoggerFactory.getLogger(DatabaseBatchSaveUtil.class);

    private final static String NEO4j_GET_CURRENT_TIME_FUNCTION = "apoc.date.format(timestamp(),\\\"ms\\\",\\\"yyyy-MM-dd HH:mm:ss\\\",\\\"CTT\\\")";

    public static void batchSaveNodeFromDatabase(String jdbcConnectString, String sql, BaseNode baseNode, Map<String, String> columnMap) {
        try {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("call apoc.periodic.iterate('call apoc.load.jdbc(\\\"").append(jdbcConnectString).append("\\\",\\\"").append(sql).append("\\\")', '");
            stringBuilder.append("merge (a:").append(baseNode.typeGetter()).append("{").append(baseNode.uniqueFieldNameGetter()).append(":").append("row.").append(columnMap.get(baseNode.uniqueFieldNameGetter()));
            if (baseNode instanceof CarNode) {
                stringBuilder.append(",vehicleCodeType:row.vehicleCodeTypeStr");
            }
            stringBuilder.append("}) ").append("set ");
            columnMap.forEach((neo4jColumn, dbColumn) -> stringBuilder.append("a.").append(neo4jColumn).append(" = row.").append(dbColumn).append(","));
            if (columnMap.containsKey("updateTime"))
                stringBuilder.deleteCharAt(stringBuilder.length() - 1);
            else stringBuilder.append("a.updateTime = ").append(NEO4j_GET_CURRENT_TIME_FUNCTION);
            stringBuilder.append("' ").append(",{batchSize:1000,iterateList:true})");

            LocalDateTime startTime = LocalDateTime.now();
            CyberQueryExecuteUtil.executeBatchUpdateQuery(stringBuilder.toString());

            LOGGER.info("Save node: {} from database {}, cost {} second", baseNode.typeGetter(), jdbcConnectString, Duration.between(startTime, LocalDateTime.now()).getSeconds());

            Thread.sleep(20000);
        } catch (Exception e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
        }
    }

    public static void batchSaveRelationFromDatabase(String jdbcConnectString, String sql, BaseRelation baseRelation, Map<String, String> columnMap) {
        try {
            BaseNode startNode = baseRelation.getStartNode();
            BaseNode endNod = baseRelation.getEndNode();

            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("call apoc.periodic.iterate('call apoc.load.jdbc(\\\"").append(jdbcConnectString).append("\\\",\\\"").append(sql).append("\\\")', '");

            stringBuilder.append("merge (n:").append(startNode.typeGetter()).append("{").append(startNode.uniqueFieldNameGetter()).append(":").append("row.").append(columnMap.get("startNode"));
            if (startNode instanceof CarNode) {
                stringBuilder.append(",vehicleCodeType:row.vehicleCodeTypeStr");
            }
            stringBuilder.append("}) with * ");

            stringBuilder.append("merge (m:").append(endNod.typeGetter()).append("{").append(endNod.uniqueFieldNameGetter()).append(":").append("row.").append(columnMap.get("endNode"));
            if (endNod instanceof CarNode) {
                stringBuilder.append(",vehicleCodeType:row.vehicleCodeTypeStr2");
            }
            stringBuilder.append("}) with * ");

            stringBuilder.append("merge (n)-[r:").append(baseRelation.getType());
            if (columnMap.containsKey("startTime") || columnMap.containsKey("endTime")) {
                stringBuilder.append("{");
                if (columnMap.containsKey("startTime"))
                    stringBuilder.append("startTime:row.").append(columnMap.get("startTime")).append(",");

                if (columnMap.containsKey("endTime"))
                    stringBuilder.append("endTime:row.").append(columnMap.get("endTime"));
                else stringBuilder.deleteCharAt(stringBuilder.length() - 1);

                stringBuilder.append("}");
            }
            stringBuilder.append("]-(m)");

            columnMap.remove("startNode");
            columnMap.remove("endNode");

            if (!columnMap.isEmpty()) {
                stringBuilder.append(" set  ");
                columnMap.forEach((neo4jColumn, dbColumn) -> stringBuilder.append("r.").append(neo4jColumn).append(" = row.").append(dbColumn).append(","));
                if (columnMap.containsKey("updateTime"))
                    stringBuilder.deleteCharAt(stringBuilder.length() - 1);
                else stringBuilder.append("r.updateTime = ").append(NEO4j_GET_CURRENT_TIME_FUNCTION);
            }

            stringBuilder.append("' ").append(",{batchSize:1000,iterateList:true})");

            LocalDateTime startTime = LocalDateTime.now();
            CyberQueryExecuteUtil.executeBatchUpdateQuery(stringBuilder.toString());

            LOGGER.info("Save relation: {} from database {}, cost {} second", baseRelation.getType(), jdbcConnectString, Duration.between(startTime, LocalDateTime.now()).getSeconds());

            Thread.sleep(20000);
        } catch (Exception e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
        }
    }
}

作者 east

neo4j 5月 9,2021

Neo4j增删改查Java API实例

@Component
public class QueryDao {
    private static final Logger LOGGER = LoggerFactory.getLogger(StatisticDao.class);

    public List<BaseNode> queryNodeByPage(BaseNode baseNode, LocalDateTime lastTime, long pageNum, int pageSize) {
        long skip = pageNum * pageSize;
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("MATCH (n:").append(baseNode.typeGetter());
        if (StringUtils.hasText(baseNode.uniqueValueGetter()))
            stringBuilder.append("{").append(baseNode.uniqueFieldNameGetter()).append(": '").append(baseNode.uniqueValueGetter()).append("'}");
        stringBuilder.append(") ");
        if (null != lastTime)
            stringBuilder.append("WHERE n.updateTime is null OR n.updateTime <= '").append(lastTime.format(Constant.NORMAL_TIME_FORMATTER)).append("' ");
        stringBuilder.append("RETURN n SKIP ").append(skip).append(" LIMIT ").append(pageSize);
        return Lists.newArrayList(CyberQueryExecuteUtil.executeEntityQuery(stringBuilder.toString(), BaseNode.class));
    }

    public List<BaseNode> queryNodeByUniqueValue(BaseNode entity) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("MATCH (n:").append(entity.typeGetter()).append("{").append(entity.uniqueFieldNameGetter()).append(": '");
        if (entity instanceof CarNode) {
            String[] carArray = entity.uniqueValueGetter().split(Constant.carNoTypeSplit);
            stringBuilder.append(carArray[0]).append("'");
            if (1 < carArray.length) {
                stringBuilder.append(",vehicleCodeType:'");
                if (2 > carArray[1].length()) stringBuilder.append("0");
                stringBuilder.append(carArray[1]).append("'");
            }
        } else stringBuilder.append(entity.uniqueValueGetter()).append("'");
        stringBuilder.append("}) RETURN n");
        return Lists.newArrayList(CyberQueryExecuteUtil.executeEntityQuery(stringBuilder.toString(), BaseNode.class));
    }

    public boolean isNodeExistAndFreshLastWeek(BaseNode entity) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("MATCH (n:").append(entity.typeGetter());
        stringBuilder.append("{").append(entity.uniqueFieldNameGetter()).append(": '").append(entity.uniqueValueGetter()).append("'");
        if (entity instanceof CarNode) {
            CarNode carNode = (CarNode) entity;
            if (StringUtils.hasText(carNode.getVehicleCodeType()))
                stringBuilder.append(",vehicleCodeType:'").append(carNode.getVehicleCodeType()).append("'");
        }
        stringBuilder.append("}) WHERE n.updateTime >= '")
                .append(LocalDateTime.now().minusDays(7L).format(Constant.NORMAL_TIME_FORMATTER)).append("' RETURN count(n)");
        Long count = CyberQueryExecuteUtil.executeCountQuery(stringBuilder.toString());
        return 1L <= count;
    }

    public List<BaseRelation> queryEndNodeByStartNodeAndRelationType(BaseNode entity, BaseRelation relationship, BaseNode baseNode) {
        StringBuilder stringBuilder = createBaseCQL(entity, relationship, baseNode);
        stringBuilder.append("RETURN n,m,r");
        return Lists.newArrayList(CyberQueryExecuteUtil.executeEntityQuery(stringBuilder.toString(), relationship.getClass()));
    }

    public List<BaseRelation> queryEndNodeByStartNodeAndRelationType(BaseNode entity, BaseRelation relationship, BaseNode baseNode, LocalDateTime startTime, LocalDateTime endTime) {
        StringBuilder stringBuilder = createBaseCQL(entity, relationship, baseNode);
        stringBuilder.append("WHERE 1=1 ");
        if (null != startTime)
            stringBuilder.append("AND r.startTime > '").append(startTime.format(Constant.NORMAL_TIME_FORMATTER)).append("' ");
        if (null != endTime)
            stringBuilder.append("AND r.endTime < '").append(endTime.format(Constant.NORMAL_TIME_FORMATTER)).append("' ");
        stringBuilder.append("RETURN n,m,r");
        return Lists.newArrayList(CyberQueryExecuteUtil.executeEntityQuery(stringBuilder.toString(), relationship.getClass()));
    }

    public List<BaseRelation> queryRelationByStartNode(BaseNode entity, BaseRelation relationship, BaseNode baseNode) {
        StringBuilder stringBuilder = createBaseCQL(entity, relationship, baseNode);
        stringBuilder.append("WHERE r.joinCount IS NOT NULL ");
        if (null != relationship.getStartTime())
            stringBuilder.append("AND r.startTime > '").append(relationship.getStartTime().format(Constant.NORMAL_TIME_FORMATTER)).append("' ");
        if (null != relationship.getEndTime())
            stringBuilder.append("AND r.endTime < '").append(relationship.getEndTime().format(Constant.NORMAL_TIME_FORMATTER)).append("' ");
        stringBuilder.append("RETURN n,m,r ");
        stringBuilder.append("ORDER BY r.joinCount DESC, r.confidence DESC LIMIT 10");
        return Lists.newArrayList(CyberQueryExecuteUtil.executeEntityQuery(stringBuilder.toString(), relationship.getClass()));
    }

   
    public List<Map<String, Object>> statisticFollowHistory(BaseNode entity, BaseNode baseNode, boolean last3Day) {
        StringBuilder stringBuilder = createBaseCQL(entity, FollowRelation.builder().build(), baseNode);
        if (last3Day)
            stringBuilder.append("WHERE r.endTime >= '")
                    .append(LocalDate.now().minusDays(3L).atStartOfDay().format(Constant.NORMAL_TIME_FORMATTER))
                    .append("' ");
        stringBuilder.append("WITH n,m,");
        stringBuilder.append("SUM(r.joinCount)");
        //stringBuilder.append(last3Day ? "SUM(r.joinCount)" : "COUNT(r)");
        stringBuilder.append(" AS r_count RETURN n,m,r_count ORDER BY r_count DESC LIMIT 5");
        return CyberQueryExecuteUtil.executeOriginResultQuery(stringBuilder.toString());
    }

    public List<FollowRelation> queryLatestByStartNode(BaseNode entity, BaseNode baseNode) {
        StringBuilder stringBuilder = createBaseCQL(entity, FollowRelation.builder().build(), baseNode);
        stringBuilder.append("RETURN n,m,r ORDER BY r.endTime DESC LIMIT 5");
        return Lists.newArrayList(CyberQueryExecuteUtil.executeEntityQuery(stringBuilder.toString(), FollowRelation.class));
    }

    private StringBuilder createBaseCQL(BaseNode entity, BaseRelation relationship, BaseNode baseNode) {
        StringBuilder stringBuilder = new StringBuilder("MATCH ");
        stringBuilder.append("(n:").append(entity.typeGetter()).append("{").append(entity.uniqueFieldNameGetter()).append(": '").append(entity.uniqueValueGetter()).append("'");
        if (entity instanceof CarNode) {
            CarNode carNode = (CarNode) entity;
            if (StringUtils.hasText(carNode.getVehicleCodeType()))
                stringBuilder.append(",vehicleCodeType:'").append(carNode.getVehicleCodeType()).append("'");
        }
        stringBuilder.append("})");
        stringBuilder.append("-");
        stringBuilder.append("[r:").append(relationship.getType()).append("]");
        stringBuilder.append("-");
        stringBuilder.append("(m:").append(baseNode.typeGetter()).append(") ");
        return stringBuilder;
    }
}

/**
 * @author Ricardo.H.Wu
 * @time 2020/8/3 11:04
 */
@Data
public abstract class BaseNode {

    @Id
    @GeneratedValue
    private Long id;

    @Convert(Neo4jLocalDateTimeConvert.class)
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime updateTime = LocalDateTime.now();

    public abstract String typeGetter();

    public abstract String uniqueFieldNameGetter();

    public abstract String uniqueValueGetter();

    public abstract void uniqueValueSetter(String uniqueValue);

    public DtoNeo4jNode convertToResponseEntity() {
        return DtoNeo4jNode.builder()
                .label(typeGetter())
                .id(uniqueValueGetter())
                .data(this)
                .build();
    }
}

@Data
public abstract class BaseRelation {

@Id
@GeneratedValue
private Long id;

@StartNode
private BaseNode startNode;

@EndNode
private BaseNode endNode;

@Convert(Neo4jLocalDateTimeConvert.class)
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime startTime;

@Convert(Neo4jLocalDateTimeConvert.class)
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime endTime;

@Convert(Neo4jLocalDateTimeConvert.class)
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime updateTime = LocalDateTime.now();

public abstract String getType();

public abstract DtoNeo4jEdge convertToResponseEntity();

}

作者 east

neo4j 5月 8,2021

Neo4j封装的基础查询Java API

import com.alibaba.fastjson.JSON;
import com.google.common.base.Throwables;
import com.google.common.collect.Lists;
import org.neo4j.ogm.model.QueryStatistics;
import org.neo4j.ogm.model.Result;
import org.neo4j.ogm.session.Session;
import org.neo4j.ogm.session.SessionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


@Component
public class CyberQueryExecuteUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(CyberQueryExecuteUtil.class);

    private static SessionFactory SESSION_FACTORY;

    @Autowired
    public void init(SessionFactory sessionFactory) {
        SESSION_FACTORY = sessionFactory;
    }

    /**
     * 执行统计方法
     *
     * @param cql cypher查询语句
     * @return 统计结果
     */
    public static Long executeCountQuery(String cql) {
        try {
            Session session = SESSION_FACTORY.openSession();
            Long count = session.queryForObject(Long.class, cql, new HashMap<>());
            session.clear();
            LOGGER.debug("Neo4j cypher query: [{}], result: [{}]", cql, count);
            return count;
        } catch (Exception e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
            return 0L;
        }
    }

    /**
     * 执行实体查询方法
     *
     * @param cql       cypher查询语句
     * @param className 实体类型
     * @return 查询结果
     */
    public static <T> Iterable<T> executeEntityQuery(String cql, Class<T> className) {
        try {
            Session session = SESSION_FACTORY.openSession();
            Iterable<T> response = session.query(className, cql, new HashMap<>());
            session.clear();
            LOGGER.debug("Neo4j cypher query: [{}]", cql);
            return response;
        } catch (Exception e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
            return new ArrayList<>();
        }
    }

    /**
     * 执行实体查询方法
     *
     * @param cql cypher查询语句
     * @return 查询原始结果
     */
    public static List<Map<String, Object>> executeOriginResultQuery(String cql) {
        try {
            Session session = SESSION_FACTORY.openSession();
            Result response = session.query(cql, new HashMap<>());
            session.clear();
            LOGGER.debug("Neo4j cypher query: [{}], status: [{}]", cql, JSON.toJSONString(response.queryStatistics()));
            return Lists.newArrayList(response.queryResults());
        } catch (Exception e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
            return new ArrayList<>();
        }
    }

    /**
     * 执行neo4j更新语句
     *
     * @param cql cypher更新语句
     */
    public static void executeUpdateQuery(String cql) {
        try {
            Session session = SESSION_FACTORY.openSession();
            Result result = session.query(cql, new HashMap<>());
            QueryStatistics queryStatistics = result.queryStatistics();
            session.clear();
            LOGGER.debug("Neo4j execute cql: [{}] contain update:[{}], status: [{}]", cql, queryStatistics.containsUpdates(), JSON.toJSON(queryStatistics));
        } catch (Exception e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
        }
    }

    /**
     * 执行neo4j批量更新语句
     *
     * @param cql cypher批量更新语句
     */
    public static void executeBatchUpdateQuery(String cql) {
        try {
            Session session = SESSION_FACTORY.openSession();
            Result result = session.query(cql, new HashMap<>());
            QueryStatistics queryStatistics = result.queryStatistics();
            session.clear();
            LOGGER.debug("Neo4j batch save cql: [{}] contain update:[{}], status: [{}]", cql, queryStatistics.containsUpdates(), JSON.toJSON(queryStatistics));
        } catch (Exception e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
        }
    }

    /**
     * 执行neo4j批量更新语句
     *
     * @param cql cypher批量更新语句
     */
    public static void executeBatchUpdateQuery(String cql, Map<String, Object> param) {
        try {
            Session session = SESSION_FACTORY.openSession();
            Result result = session.query(cql, param);
            QueryStatistics queryStatistics = result.queryStatistics();
            session.clear();
            LOGGER.debug("Neo4j batch save cql: [{}] contain update:[{}], status: [{}]", cql, queryStatistics.containsUpdates(), JSON.toJSON(queryStatistics));
        } catch (Exception e) {
            LOGGER.error(Throwables.getStackTraceAsString(e));
        }
    }
}

作者 east

广告联盟 5月 5,2021

admob如何收款和升级SDK提醒

最近探索了不少网赚模式，觉得开发app还是有一些优势。个人站长觉得竞争更大，网站做大了还怕被攻击，没不断更新网站内容会被搜索网站降权。app是上架后就可以躺赚，只要不被应用商店下架或移动广告升级。开网店要回答用户咨询，要打包、要处理退货等繁琐环节。

如果做国外app，首选是用admob，如果还有旧版本SDK，要注意升级到新的版本，才不会没广告展示。下面是admob的SDK升级提醒：

请阅读以下内容，了解这些更改会如何影响您的应用。

Google 移动广告 SDK Android v20.0.0 和 iOS v8.0.0 将于 2021 年初发布。更新到这样的主要版本后，一些现有的 API 将被更改或弃用。请考虑如下事项：

•在这些版本推出之前，请考虑根据下面的迁移指南更新现有应用中 API 的使用。•在 GMA SDK 版本 8.0.0 (iOS) 或 20.0.0 (Android) 推出之后，请确保所有的应用都已根据下面的迁移指南进行了更新，然后再发布您的应用。•如果将 GMA SDK 更新为版本 8.0.0 (iOS) 或 20.0.0 (Android)，但没有同时根据迁移指南对以下 API 进行更改，会导致应用的构建或编译出现问题，且可能会影响收入。•升级到版本 8.0.0 (iOS) 或 20.0.0 (Android) 时对 GMA SDK 的破坏性更改不会破坏面向较旧 SDK 版本的现有实现方式。

下面列出了在更新到最新版 SDK 之前需要执行相应操作的主要 API 更改。如需查看更改（包括其他破坏性更改）的完整列表，请参阅下面的迁移指南。

尊敬的发布商：

您好！从 2018 年 1 月 23 日起，我们将不再支持低于 7.0.0 版的 Android 版和 iOS 版 Google 移动广告 SDK。为确保在此日期之后能继续投放 AdMob 广告，请升级至最新版的 Google 移动广告 SDK。

新版 SDK 推出了多种新功能，不仅能帮助您提高收入，还有助于打造出色的用户体验。具体包括：新增了一些广告格式、改进了中介报告功能、提升了广告投放的稳定性，等等。

您可以在此处以及我们的版本说明（Android 版/iOS 版）中，详细了解这些功能并查看我们的通告。

admob如何收款

admob收款建议用招商银行，之前也用中国银行，后来中国银行要收手续费了。招商银行收款招商银行总部地址和 SWIFT BIC 就可以。

收款行：China Merchants Bank, H.O. Shenzhen, China

SWIFTCODE：CMBCCNBS

例如：

在国内上不了adsense，如何文明上网，在这里ZC问题不好直接分享，可以加下面微信（微信号: tao17youhui)，备注：adsense，拉到交流分享群，分享更多app及网赚经验。

作者 east

大数据开发 5月 4,2021

大数据即席查询框架技术选型

目前应用比较广泛的几种即席查询框架有Druid、Kylin、Presto、Impala、Spark SQL和Elasticsearch，针对响应时间、数据支持、技术特点等方面的对比如表

针对上表的对比情况，分析汇总如下。

● Druid：实时处理时序数据的OLAP数据库，因为它的索引首先按照时间进行分片，查询的时候也是按照时间线去路由索引的。

● Kylin：核心是Cube，Cube是一种预计算技术，基本思路是预先对数据进行多维索引，查询时只扫描索引而不访问原始数据，从而提高查询速度。

● Presto：它没有使用MapReduce，大部分场景下比Hive快一个数量级，其中的关键是所有的处理都在内存中完成。

● Impala：基于内存运算，速度快，支持的数据源没有Presto多。

● Spark SQL：基于Spark平台上的一个OLAP框架，基本思路是增加机器以实现并行计算，从而提高查询速度。

● Elasticsearch：最大的特点是使用倒排索引解决了索引存在的问题。根据研究，Elasticsearch在数据获取和聚集时用的资源比在Druid中高。框架选型如下。

● 从超大数据的查询效率来看：Druid > Kylin > Presto >Spark SQL。

● 从支持的数据源种类来看：Presto > Spark SQL > Kylin >Druid。

作者 east

广告联盟 5月 3,2021

adsense对比propellerads使用实测

注册门槛：我是先有了admob账号，然后再开adsense账号，开的过程也是一波三折，刚开始被拒绝过，后来终于成功了。看到adsense广告单价比admob的高，当时有点小兴奋。

用户体验： adsense广告用户体验还是比较好，虽然也有弹窗，但广告看起来没那么讨厌。我用中国ip看propellerads觉得广告看起来有些low，还有些是用成人电影诱导用户。觉得用户一看这广告，会觉得我的网站是垃圾网站。

广告单价：adsense广告能自动匹配内容，广告点击率还是可以的。Google作为大公司，广告主比较信赖，投放广告出得起价钱。最近adsense由于无效流量问题被暂停几天，才不得不找别的广告代替。在adsense再不济一天几美元的，在
propellerads 就变得很惨淡了。在adsense，美国(US)是我第一收入来源，在
propellerads 不知为什么，收入为零。

propellerads 总收入

propellerads 各个国家收入

adsense收入

adsense各个国家收入比例

结论：网站还是优先使用adsense的广告，但是adsense相对严格，以后可能会由于无效流量被暂停广告（不是自己刷及能控制的），最好有多个adsense帐号，并且没有帐户关联来规避风险，同时测试别的广告平台来做备份。

作者 east

数据仓库 5月 2,2021

数据仓库分层及命名规则

数据仓库中的数据要想真正发挥最大的作用，必须对数据仓库进行分层，数据仓库分层的优点如下。

● 把复杂问题简单化。可以将一个复杂的任务分解成多个步骤来完成，每层只处理单一的步骤。

● 减少重复开发。规范数据分层，通过使用中间层数据，可以大大减少重复计算量，增加计算结果的复用性。

● 隔离原始数据。使真实数据与最终统计数据解耦。数据仓库具体如何分层取决于设计者对数据仓库的整体规划，不过大部分的思路是相似的。

本数据仓库分为五层，如下所述。

● ODS层：原始数据层，存放原始数据，直接加载原始日志、数据，数据保持原貌不做处理。

● DWD层：明细数据层，对ODS层数据进行清洗（去除空值、脏数据、超过极限范围的数据）、维度退化、脱敏等。

● DWS层：服务数据层，以DWD层的数据为基础，按天进行轻度汇总。

● DWT层：主题数据层，以DWS层的数据为基础，按主题进行汇总，获得每个主题的全量数据表。

● ADS层：数据应用层，面向实际的数据需求，为各种统计报表提供数据。数据仓库分层后要遵守一定的数据仓库命名规范，本项目中的规范如下。

1.表命名ODS层命名为ods_表名。

DWD层命名为dwd_dim/fact_表名。DWS层命名为dws_表名。

DWT层命名为dwt_购物车。ADS层命名为ads_表名。临时表命名为tmp_×××。用户行为表以.log为后缀。

2.脚本命名脚本命名格式为数据源to目标_db/log.sh。用户行为需求相关脚本以.log为后缀；业务数据需求相关脚本以.db为后缀。

作者 east

数据仓库 4月 28,2021

关系型数据库（关系模型）转变为数据仓库（维度模型）示例

关系模型示意如图1所示，严格遵循第三范式（3NF）。从图1中可以看出，模型较为松散、零碎，物理表数量多，但数据冗余程度低。由于数据分布于众多的表中，因此这些数据可以更为灵活地被应用，功能性较强。关系模型主要应用于OLTP中，为了保证数据的一致性及避免冗余，大部分业务系统的表都是遵循第三范式的。

维度模型示意如图2所示，其主要应用于OLAP中，通常以某一张事实表为中心进行表的组织，主要面向业务，其特征是可能存在数据的冗余，但用户能方便地得到数据。关系模型虽然数据冗余程度低，但在大规模数据中进行跨表分析、统计、查询时，会造成多表关联，这会大大降低执行效率。所以通常我们采用维度模型建模，把各种相关表整理成事实表和维度表两种。所有的维度表围绕事实表进行解释。

图1 关系模型示意

图2 维度模型示意

作者 east

微信小程序、h5程序倒计时工具类