电信采集项目总结

这是我结合老师的文档整理出来的知识。

一、功能

1. 定期采集radwtmp文件，整理成BIDR数据清单，将数据存储到数据库表t_detail_X(1-31)。

2. 使用技术：TCP/IP、JDBC。

二、模块

客户端：负责采集数据。

服务端：负责接收数据。

客户端	配置模块	配置模块	服务端
	日志模块	日志模块
	采集模块	入库模块
	备份模块	备份模块
	网络模块	网络模块

三、 Jar包

1. BIDR类：用来分装采集好的数据。

2. 接口：

Gather接口客户端采集模块

负责采集指定文件中的数据。

eg: #briup1660|037:wKgB1660A|7|1239110900|44.211.221.247
　　#briup4418|037:wKgB4418A|7|1239138480|251.196.223.191

#用户名|NAS-IP|上线/下线|时间（秒）|IP地址

处理数据：

1. 读取行数据，通过IO流进行读取，

2. 采集数据情况：

第一种情况数据:用户上线了同时也下线了，
　第二种情况数据:用户上线了但是还没有下线

3. 判断数据是上线（“7”），还是下线（“8”）；

4. 用集合封装数据

第一种情况数据，封装好数据之后就传给服务器，第二种情况数据，进行数据的备份，在下一次的采集中，需要把备份的数据重新读出来使用（因为用户可能在下一次采集中下线了）。

5.第二次读取数据的时候,如何从第一次读完数据的下一行开始读，可以记录一下本次总共读取N个字节,下一次可以直接跳过N个字节,接着读。
　　　　 6.在读取过程中或者处理过程中,如果出现了异常,需要把数据进行备份。

7.注意重要信息的日志记录。

Client端和Server端通过TCP/IP协议进行通信。

DBStore接口：入库模块

建表语句（oracle）：

BEGIN
　　FOR i IN 1..31 LOOP
　　EXECUTE IMMEDIATE
　　'CREATE TABLE t_detail_'||TO_CHAR(i)||
　　'(
　　aaa_login_name VARCHAR2(30),
　　login_ip VARCHAR2(32),
　　login_date DATE,
　　logout_date DATE,
　　nas_ip VARCHAR2(32),
　　time_duration NUMBER(10)
　　)';
　　END LOOP;
　　END;
　　/

删除表语句：

BEGIN
　　FOR i IN 1..31 LOOP
　　EXECUTE IMMEDIATE
　　'DROP TABLE t_detail_'||TO_CHAR(i);
　　END LOOP;
　　END;
　　/

注意：最后的”/ ”,一定要写上，这是结束标识。

Logger接口：日志模块，负责记录系统运行过程中一些重要的信息。

知识点：

Configuration接口:配置模块

1.产生各个模块对象
　　2.读取各个模块所需的信息,并且把信息注入到每个模块中
　　注:这时候需要每个模块都实现接口WossModule。
　　3.如果某个模块A中需要用到配置模块,那么就需要把自己(因为自己就是配置模块)注入到这个模块A中。
　　注:这时候需要模块A实现接口ConfigurationAWare。

WossModule接口

　　　　例如:模块A中需要使用一些参数(比如读取xml的路径、连接数据的地址等等),模块A就需要实现WossModule接口,那么这个模块A就有一个方法:
　　　　init(Properties p)

　　　　将来我们就可以调用这个init方法,把数据注入到模块A中。

四．代码实现：

电信采集项目总结

GatherImpl类：package com.briup.client;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import com.briup.common.BackupImpl;
import com.briup.common.LoggerImpl;
import com.briup.util.BIDR;
import com.briup.woss.client.Gather;

public class GatherImpl implements Gather{

	FileInputStream fis=null;
	BufferedReader br=null;
	InputStreamReader isr=null;

	Map<String, BIDR> map=null;
	BackupImpl backup=new BackupImpl();

	private static String filepath;
	private static String nasp;
	private static String logger;
	@Override
	public void init(Properties arg0) {
		 filepath= arg0.getProperty("src-file");
		 nasp = arg0.getProperty("nas-ip");
		  logger = arg0.getProperty("logger");
	}

	@Override
	public Collection<BIDR> gather() throws Exception {
		//		#briup1660|037:wKgB1660A|7|1239110900|44.211.221.247
		//Map<String, BIDR> map=new HashMap<String, BIDR>();
		//读 文件
		List<BIDR> list=new ArrayList<BIDR>();
		Object load = backup.load("list", true);
		if(load!=null){
			Map<String, BIDR> m = (Map<String, BIDR>) backup.load("list", true);
			map.putAll(m);
		}
		LoggerImpl log = (LoggerImpl) Class.forName(logger).newInstance();
		br=new BufferedReader(new InputStreamReader(new FileInputStream(filepath)));
		String str=null;
		//以行为单位进行读取数据
		while((str=br.readLine())!=null){
			//以“|”进行截取字符串
			String[] split=str.split("\\|");
			//System.out.println(spilt[0]);
			log.info("开始收集数据....");
			//判断是上线还是下线
			if("7".equals(split[2])){
				BIDR bidrs=new BIDR();
				bidrs.setAAA_login_name(split[0]);
				bidrs.setNAS_ip(nasp);
				bidrs.setLogin_date(new Timestamp(Long.parseLong(split[3])*1000));
				bidrs.setLogin_ip(split[4]);
				//map.put(split[4], bidrs);
				list.add(bidrs);

			}
			else{
				//BIDR b=map.get(split[4]);

				for(BIDR o:list){
					//
					if(split[4].equals(o.getLogin_ip())&o.getLogin_date()!=null){
						o.setLogout_date(new Timestamp(Long.parseLong(split[3])*1000));
						//时间差
						o.setTime_deration((int) (o.getLogout_date().getTime()-o.getLogout_date().getTime()));

						//
					}	
				}
			}
		}
		//
		int n=0;
		for(int i=0;i<list.size();i++){
			if(list.get(i).getLogout_date()==null){
				backup.store("backup.txt", list.get(i), false);
			    list.remove(list.get(i));
			    n++;
			}

		}
		 System.out.println("数目为-------"+n);
		return list;
	}
}

ClientImpl类：
	package com.briup.client;

import java.io.BufferedReader;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Collection;
import java.util.Properties;
import com.briup.util.BIDR;
import com.briup.woss.client.Client;

public class ClientImpl implements Client{

	public static String port1;
	public static String host1;
	@Override
	public void init(Properties pp) {
	 port1 = pp.getProperty("port");
	 host1 = pp.getProperty("ip");

	}

	@Override
	public void send(Collection<BIDR> arg0) throws Exception {
		Socket socket=null;
		String host=host1;
		int port=Integer.parseInt(port1);

		ObjectOutputStream oos=null;
		BufferedReader br=null;
		socket=new Socket(host,port);
		System.out.println("已经连接到服务器");
		oos=new ObjectOutputStream(socket.getOutputStream());
		oos.writeObject(arg0);

	}

}

ServerImpl类：
package com.briup.server;

import java.util.List;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Collection;
import java.util.Properties;

import com.briup.common.ConfigurationImpl;
import com.briup.common.LoggerImpl;
import com.briup.util.BIDR;
import com.briup.util.Configuration;
import com.briup.util.Logger;
import com.briup.woss.ConfigurationAWare;
import com.briup.woss.server.Server;

public class ServerImpl implements Server,ConfigurationAWare{
	public static String port1;
	//private static String logger;
	LoggerImpl log;
	@Override
	public void init(Properties arg0) {
		/* logger = arg0.getProperty("logger");
		 System.out.println(logger);
	*/
		port1 = arg0.getProperty("serverport");
	}
	@Override
	public Collection<BIDR> revicer() throws Exception {
		ServerSocket server=null;
		int port=Integer.parseInt(port1);
		Socket socket=null;
		ObjectInputStream ois=null;



		server=new ServerSocket(port);
		System.out.println("服务器已经启动--");
		log.info("server start...");
		socket=server.accept();
		ois=new ObjectInputStream(socket.getInputStream());

		List<BIDR> list=(List<BIDR>) ois.readObject();
		System.out.println(list.size());

		ois.close();
		socket.close();
		server.close();

		return list;
	}

	@Override
	public void shutdown() {


	}

	@Override
	public void setConfiguration(Configuration arg0) {
		try {
			log = (LoggerImpl) arg0.getLogger();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}	
}
　
DBStoreImpl类：package com.briup.server;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Properties;

import com.briup.client.GatherImpl;
import com.briup.common.ConfigurationImpl;
import com.briup.util.BIDR;
import com.briup.woss.server.DBStore;

public class DBStoreImpl implements DBStore{

	private static String driver;
	private static String url;
	private static String user;
	private static String password;

	@Override
	public void init(Properties arg0) {
		driver=arg0.getProperty("driver");
		url=arg0.getProperty("url");
		user=arg0.getProperty("userName");
		password=arg0.getProperty("passWord");

	}

	@Override
	public void saveToDB(Collection<BIDR> arg0) throws Exception {
		//#briup1660|037:wKgB1660A|7|1239110900|44.211.221.247
		Connection conn=null;
		PreparedStatement pst=null;
		Class.forName(driver);
		conn=DriverManager.getConnection(url,user,password);
		for(BIDR bidr:arg0){
			SimpleDateFormat sdf= new SimpleDateFormat("dd");
			String dateStr=sdf.format(bidr.getLogin_date());
			int parseInt = Integer.parseInt(dateStr);
			String string= "t_detail_"+parseInt;
			String sql="insert into "+string+" values(?,?,?,?,?,?)";
			pst=conn.prepareStatement(sql);
			pst.setString(1, bidr.getAAA_login_name());
			pst.setString(2, bidr.getNAS_ip());
			pst.setTimestamp(3, bidr.getLogin_date());
			pst.setTimestamp(4, bidr.getLogout_date());
			pst.setString(5, bidr.getLogin_ip());
			pst.setInt(6,bidr.getTime_deration());
			pst.execute();
			pst.close();
			}
		if(pst!=null)pst.close();
		if(conn!=null)conn.close();	
	}
}　

BackupImpl类：
	package com.briup.common;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;
import java.util.Properties;

import com.briup.util.BackUP;

public class BackupImpl implements BackUP{
	private String filepath="src/com/briup/file";

	@Override
	public void init(Properties arg0) {

	}

	@Override
	public Object load(String arg0, boolean flag) throws Exception {
		File file=new File(filepath,arg0);
		if(!file.exists()){
			return null;
		}
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file));
		Object object = ois.readObject();
		ois.close();
		if(flag){
			file.delete();
		}
		return object;
	}

	@Override
	public void store(String arg0, Object arg1, boolean arg2) throws Exception {
		File file=new File(filepath,arg0);
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file));
		oos.writeObject(arg1);
		oos.flush();
		oos.close();

	}
}
LoggerImpl类
	package com.briup.common;

import java.util.Properties;
import org.apache.log4j.PropertyConfigurator;
import com.briup.util.Logger;

public class LoggerImpl implements Logger{

	//private static 
	private static String loggerName1;
	public static org.apache.log4j.Logger log;



	@Override
	public void init(Properties arg0) {
		loggerName1=arg0.getProperty("log-properties"); 
		 PropertyConfigurator.configure(loggerName1);
		 log=org.apache.log4j.Logger.getRootLogger(); 
	}

	@Override
	public void debug(String arg0) {
		log.debug(arg0);
	}

	@Override
	public void error(String arg0) {
		log.error(arg0);
	}

	@Override
	public void fatal(String arg0) {
		log.fatal(arg0);
	}

	@Override
	public void info(String arg0) {
		log.info(arg0);
	}

	@Override
	public void warn(String arg0) {
		log.warn(arg0);
	}



}
ConfigurationImpl类：
	package com.briup.common;

import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import com.briup.client.ClientImpl;
import com.briup.client.GatherImpl;
import com.briup.server.DBStoreImpl;
import com.briup.server.ServerImpl;
import com.briup.util.BackUP;
import com.briup.util.Configuration;
import com.briup.util.Logger;
import com.briup.woss.ConfigurationAWare;
import com.briup.woss.WossModule;
import com.briup.woss.client.Client;
import com.briup.woss.client.Gather;
import com.briup.woss.server.DBStore;
import com.briup.woss.server.Server;

public class ConfigurationImpl implements Configuration{

	private static Properties pp;//存储配置信息初始化

	static{
		try {
			SAXReader reader=new SAXReader();
			File file=new File("src/com/briup/file/conf.xml");
			Document document = reader.read(file);
			Element root = document.getRootElement();
			List<Element> list2 = root.elements();
			pp=new Properties();
			for(Element e2:list2){
				String name = e2.getName();
				String classvalue = e2.attributeValue("class");
				pp.put(name, classvalue);
				List<Element> list3 = e2.elements();
				for(Element e3:list3){
					pp.put(e3.getName(), e3.getText());
				}

			}

		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Override
	public BackUP getBackup() throws Exception {
		String property = pp.getProperty("backup");
		 Object newInstance = Class.forName(property).newInstance();
		BackupImpl backupImpl=(BackupImpl) newInstance;
		backupImpl.init(pp);
		return backupImpl;
	}

	@Override
	public Client getClient() throws Exception {
		String clientp = pp.getProperty("client");
		ClientImpl clientI = (ClientImpl) Class.forName(clientp).newInstance();
		clientI.init(pp);
		return clientI;
	}

	@Override
	public DBStore getDBStore() throws Exception {
		String dbp = pp.getProperty("dbstore");
		DBStoreImpl dbI = (DBStoreImpl) Class.forName(dbp).newInstance();
		dbI.init(pp);
		return dbI;
	}

	@Override
	public Gather getGather() throws Exception {
		String gatherp = pp.getProperty("gather");
		GatherImpl gatherI = (GatherImpl) Class.forName(gatherp).newInstance();
	gatherI.init(pp);
		return gatherI;
	}

	@Override
	public Logger getLogger() throws Exception {
		String loggerp = pp.getProperty("logger");
		System.out.println(loggerp);
		LoggerImpl loggerI = (LoggerImpl) Class.forName(loggerp).newInstance();
		System.out.println(loggerI+"oooo");
		loggerI.init(pp);
		return loggerI;
	}

	@Override
	public Server getServer() throws Exception {
		String serverp = pp.getProperty("server");
		ServerImpl serverI = (ServerImpl) Class.forName(serverp).newInstance();
		serverI.init(pp);
		return serverI;
	}

总结：

老师带我们做了这个项目，我收获了很多，融汇了我之前学过的知识点，我就有个体会，学以致用，才能更好的理解。之前有些不懂的知识点也能更好的理解了。

秒客网

电信采集项目总结

相关文章