项目我上传到github中，感兴趣的可以下载下来看看，希望大神可以在以后多多指点。
github代码地址：https://github.com/sjctt/spartacus
本章相关技术：UDP网络通信、java线程池多线程处理、redis。
先来整理一下syslog模块的结构路径：
spartacus_datacollection/src/main/java/spartacus_services //放置系统服务模块
spartacus_datacollection/src/main/java/spartacus_services/syslog_service //syslog服务模块
spartacus_datacollection/src/main/java/spartacus_services/syslog_service/entity //实体类存放路径
spartacus_datacollection/src/main/java/spartacus_services/syslog_service/logic //逻辑层
spartacus_datacollection/src/main/java/com/data //放置数据库操作相关文件
spartacus_datacollection/src/main/java/com/entity //实体类存放路径
spartacus_datacollection/src/main/java/com/operate //数据库操作对象
spartacus_datacollection/src/main/resources/config //存放数据库配置文件
1. 数据库操作对象封装
在采集端中，对于数据库仅用到redis，这里我把redis的操作封装了一下，考虑到后期可能涉及的redis分布式部署，我在这里这是redis可以通过配置文件配置连接模式采用单实例还是集群模式，当然在目前我们主要先采用单例模式开发。
redis.Properties redis配置文件
###################### Redis Config ######################
#--------------------------------------------------------------------------------
#Configure whether cluster is enabled
#true:Single false:cluster
redis_cluster=false
# Redis Single instance deployment
#In a single instance, enable the following configuration
redis_host=127.0.0.1
redis_port=6379
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# Redis cluster deployment
#In a cluster, enable the following configuration
#redis_nodes=[host1:port1,host1:port2,host2:port1,host2:port2,host3:port1,host3:port2]
redis_nodes=[10.0.0.6:7001,10.0.0.6:7002,10.0.0.5:7001,10.0.0.5:7002,10.0.0.4:7001,10.0.0.4:7002]
#--------------------------------------------------------------------------------
redis_pwd=abcd1234!
#######################################################redis配置实体类
package com.data.entity;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
/**
* @author Song
* @category redis的配置对象
* @serial
*【2019年9月4日】 建立对象
*/
public class redisconfig
{
private boolean Initialization;
private String redis_cluster;
private String redis_host;
private int redis_port;
private String redis_nodes;
private String redis_pwd;
private Jedis con_single;
private JedisCluster con_cluster;
/**
* 获取redis的初始化状态
* @return true: 已经过初始化 false: 未经过初始化
**/
public boolean isInitialization() {
return Initialization;
}
/**
* 设置redis的初始化状态
* @param initialization true: 已经过初始化 false: 未经过初始化
**/
public void setInitialization(boolean initialization) {
Initialization = initialization;
}
/**
* 获取redis的集群模式开启状态
* @return true: 集群模式开启 false: 集群模式关闭
**/
public String getRedis_cluster() {
return redis_cluster;
}
/**
* 设置redis的集群模式开启状态
* @return true: 集群模式开启 false: 集群模式关闭
**/
public void setRedis_cluster(String redis_cluster) {
this.redis_cluster = redis_cluster;
}
/**
* 获取redis的单实例模式的服务器地址
**/
public String getRedis_host() {
return redis_host;
}
/**
* 设置redis的单实例模式的服务器地址
**/
public void setRedis_host(String redis_host) {
this.redis_host = redis_host;
}
/**
* 获取redis的单实例模式的服务器端口
**/
public int getRedis_port() {
return redis_port;
}
/**
* 设置redis的单实例模式的服务器端口
**/
public void setRedis_port(int redis_port) {
this.redis_port = redis_port;
}
/**
* 获取redis的集群模式下的nodes信息
**/
public String getRedis_nodes() {
return redis_nodes;
}
/**
* 设置redis的集群模式下的nodes信息
**/
public void setRedis_nodes(String redis_nodes) {
this.redis_nodes = redis_nodes;
}
/**
* 获取redis的连接密码
**/
public String getRedis_pwd() {
return redis_pwd;
}
/**
* 设置redis的连接密码
**/
public void setRedis_pwd(String redis_pwd) {
this.redis_pwd = redis_pwd;
}
/**
* 获取单实例模式的连接类
**/
public Jedis getCon_single() {
return con_single;
}
/**
* 设置单实例模式的连接类
**/
public void setCon_single(Jedis con_single) {
this.con_single = con_single;
}
/**
* 获取集群模式的连接类
**/
public JedisCluster getCon_cluster() {
return con_cluster;
}/**
* 设置集群模式的连接类
**/
public void setCon_cluster(JedisCluster con_cluster) {
this.con_cluster = con_cluster;
}
}
redis操作对象
package com.data.operate;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.Properties;
import java.util.Set;
import com.data.entity.redisconfig;
import net.sf.json.JSONArray;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;
import spartacus_public.bll.spartacus_debug;
import spartacus_public.entity.enums.LogLevelEnum;
/**
* @author Song
* @category redis的数据控制对象，运行依据redis.Properties配置文件
* @serial
*【2019年9月4日】 建立对象，支持单实例及集群模式的操作
*/
public class redis_dop
{
public static redisconfig redisconfig=new redisconfig();//redis的运行模式 false:单实例运行 true:集群模式运行
//#region 初始化redis
/**
* @author Song
* @category 初始化redis连接对象
* @serial
*【2019年9月4日】 系统会自动依据redis的运行模式，选择对应的单例或集群连接方式。
*/
public void Initialization()
{
try
{
if(!redisconfig.isInitialization())
{
//#region 读取配置文件
InputStream is = getClass().getClassLoader().getResourceAsStream("config/redis.Properties");
Properties properties = new Properties();
properties.load(is);
redisconfig.setRedis_cluster(properties.getProperty("redis_cluster"));
redisconfig.setRedis_host(properties.getProperty("redis_host"));
redisconfig.setRedis_port(Integer.parseInt(properties.getProperty("redis_port")));
redisconfig.setRedis_nodes(properties.getProperty("redis_nodes").replace("[", "").replace("]", ""));
redisconfig.setRedis_pwd(properties.getProperty("redis_pwd"));
redisconfig.setInitialization(true);
//#endregion
}
if(redisconfig.getRedis_cluster().equals("true"))
{
//集群模式
redisconfig.setCon_cluster(cluster_redis_connection());
}
else
{
//单实例模式
redisconfig.setCon_single(single_redis_connection());
}
}
catch (Exception e)
{
if(spartacus_debug.isdebug)
{
//记录debug日志
spartacus_debug.writelog(LogLevelEnum.emergency.getText()+" scService[10010]：redis初始化失败，"+e.getMessage());
}
redisconfig = null;
}
}
//#endregion
//#region 连接单实例redis
/**
* @author Song
* @category 连接单实例redis
* @serial
* 【2019年9月4日】 创建此对象
* @throws Exception 连接失败时会抛出catch异常
* */
private Jedis single_redis_connection() throws Exception
{
Jedis jedis = new Jedis(redisconfig.getRedis_host(),Integer.parseInt(redisconfig.getRedis_host()));
jedis.auth(redisconfig.getRedis_pwd());
return jedis;
}
//#endregion
//#region 连接集群redis
/**
* @author Song
* @category 连接集群redis
* @serial
* 【2019年9月4日】 创建此对象
* @throws Exception 连接失败时会抛出catch异常
* */
private JedisCluster cluster_redis_connection() throws Exception
{
String[] redis_nodes = redisconfig.getRedis_nodes().split(",");
Set<HostAndPort> nodes = new LinkedHashSet<HostAndPort>();
for (String nodeinfo : redis_nodes)
{
//循环添加node节点
String[] node= nodeinfo.split(":");
nodes.add(new HostAndPort(node[0], Integer.parseInt(node[1])));
}
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(99);//最大连接数
jedisPoolConfig.setMaxWaitMillis(30000);//最大等待时间
JedisCluster redisCluster = new JedisCluster(nodes,1000,1000,1,redisconfig.getRedis_pwd(), jedisPoolConfig);
return redisCluster;
}
//#endregion
//#region 添加字符串对象
/**
* @author Song
* @category 向redis中添加String对象
* @param key String对象的key值，相当于id
* @param value 要存入的字符串内容
* @serial
* 【2019年9月4日】 创建此对象
* */
public boolean redis_set_string(String key,String value)
{
String result = " fail";
if(redisconfig.getRedis_cluster().equals("true"))
{
JedisCluster cluster = redisconfig.getCon_cluster();
result = cluster.set(key, value);
}
else if(redisconfig.getRedis_cluster().equals("false"))
{
Jedis single = redisconfig.getCon_single();
result = single.set(key, value);
}
if(result.equals("OK"))
{
return true;
}
else
{
return false;
}
}
//#endregion
//#region 获取字符串对象
/**
* @author Song
* @category 获取redis中的String对象
* @param key 要获取的String对象的key值
* @serial
* 【2019年9月4日】 创建此对象
* */
public String redis_get_string(String key)
{
String result = "";
if(redisconfig.getRedis_cluster().equals("true"))
{
JedisCluster cluster = redisconfig.getCon_cluster();
result = cluster.get(key);
}
else if(redisconfig.getRedis_cluster().equals("false"))
{
Jedis single = redisconfig.getCon_single();
result = single.get(key);
}
return result;
}
//#endregion
//#region 删除字符串对象
/**
* @author Song
* @category 删除redis中的String对象
* @param key 要删除的String对象的key值
* @serial
* 【2019年9月4日】 创建此对象
* */
public boolean redis_del_string(String key)
{
Long result = 0L;
if(redisconfig.getRedis_cluster().equals("true"))
{
JedisCluster cluster = redisconfig.getCon_cluster();
result = cluster.del(key);
}
else if(redisconfig.getRedis_cluster().equals("false"))
{
Jedis single = redisconfig.getCon_single();
result = single.del(key);
}
if(result>0)
{
return true;
}
else
{
return false;
}
}
//#endregion
//#region 修改字符串对象
/**
* @author Song
* @category 编辑redis中的String对象
* @param key 要编辑的String对象的key值
* @param newValue 新的value值
* @serial
* 【2019年9月4日】 创建此对象
* */
public boolean redis_edit_string(String key,String newValue)
{
String result = "";
if(redisconfig.getRedis_cluster().equals("true"))
{
JedisCluster cluster = redisconfig.getCon_cluster();
result = cluster.getSet(key,newValue);
}
else if(redisconfig.getRedis_cluster().equals("false"))
{
Jedis single = redisconfig.getCon_single();
result = single.getSet(key,newValue);
}
if(!result.equals(""))
{
return true;
}
else
{
return false;
}
}
//#endregion
//#region 字符串模糊查询
public boolean redis_contains_string(String key,String query)
{
boolean result = false;
if(redisconfig.getRedis_cluster().equals("true"))
{
JedisCluster cluster = redisconfig.getCon_cluster();
Boolean iskey = cluster.exists(key);
if(iskey)
{
result = cluster.get(key).contains(query);
}else {
result = false;
}
}
else if(redisconfig.getRedis_cluster().equals("false"))
{
Jedis single = redisconfig.getCon_single();
Boolean iskey = single.exists(key);
if(iskey)
{
result = single.get(key).contains(query);
}else {
result = false;
}
}
return result;
}
//#endregion
//#region 添加list对象
/**
* @author Song
* @category 向redis中添加List对象
* @param key List对象的key值，相当于表名
* @param objectList list对象，可接收一个泛型集合
* @serial
* 【2019年9月4日】 创建此对象
* */
public <T> void redis_set_list(String key,ArrayList<T> objectList)
{
if(redisconfig.getRedis_cluster().equals("true"))
{
JedisCluster cluster = redisconfig.getCon_cluster();
String jsonstr = JSONArray.fromObject(objectList).toString();
cluster.rpush(key, jsonstr);
}
else if(redisconfig.getRedis_cluster().equals("false"))
{
Jedis single = redisconfig.getCon_single();
String jsonstr = JSONArray.fromObject(objectList).toString();
single.rpush(key, jsonstr);
}
}
//#endregion
//#region 移除list中指定的对象
/**
* @author Song
* @category 从list中移除指定的条目
* @param key List对象的key值，相当于表名
* @param count 需要移除的条目数
* @serial
* 【2019年9月4日】 创建此对象
* */
public <T> void redis_del_list(String key,int count)
{
if(redisconfig.getRedis_cluster().equals("true"))
{
JedisCluster cluster = redisconfig.getCon_cluster();
cluster.ltrim(key, count,-1);//设置保留从x到末尾的对象，范围外的对象将被删除
}
else if(redisconfig.getRedis_cluster().equals("false"))
{
Jedis single = redisconfig.getCon_single();
single.ltrim(key, count,-1);//设置保留从x到末尾的对象，范围外的对象将被删除
}
}
//#endregion
//#region 获取list中的对象
/**
* @author Song
* @category 从list中获取指定数量的对象
* @param key List对象的key值，相当于表名
* @param count 需要获取的条目数，这里为下标，如获取10条，count应为9 -1为获取所有
* @serial
* 【2019年9月4日】 创建此对象
* */
public ArrayList<String> redis_get_list(String key,int count)
{
ArrayList<String> datalist = new ArrayList<String>();
if(redisconfig.getRedis_cluster().equals("true"))
{
JedisCluster cluster = redisconfig.getCon_cluster();
datalist = (ArrayList<String>) cluster.lrange(key, 0, count);
}
else if(redisconfig.getRedis_cluster().equals("false"))
{
Jedis single = redisconfig.getCon_single();
datalist = (ArrayList<String>) single.lrange(key, 0, count);
}
return datalist;
}
//#endregion
//#region 关闭连接
public void close()
{
if(redisconfig.getCon_cluster()!=null)
{
redisconfig.getCon_cluster().close();
}
if(redisconfig.getCon_single()!=null)
{
redisconfig.getCon_single().close();
}
redisconfig=new redisconfig();
}
//#endregion
}
pom.xml添加redis驱动
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.1.0</version>
</dependency>项目我上传到github中，感兴趣的可以下载下来看看，希望大神可以在以后多多指点。
github代码地址：https://github.com/sjctt/spartacus
1823
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
