系统用户行为日志记录

http://hi.baidu.com/xbnh0217/item/fd78f92a010dedc1ef10f1a7

man1900.iteye.com/blog/648107

blog.csdn.net/kimylrong/article/details/7639346

http://blog.csdn.net/javazhichizhe/article/details/6468687

导读：作者Frank Wiles发 表了一篇博文，Frank Wiles曾在很多演讲里说过，改进你的系统的最好的方法是先避免做“蠢事”。并不是说你或你开发的东西“蠢”，只是有些决定很容易被人们忽略掉其暗含的 牵连，认识不到这样做对系统维护尤其是系统升级带来多大的麻烦。作为一个顾问，像这样的事情我到处都能见到，我还从来没有见过做出这样的决定的人有过好的 结果的。

 

图片，文件，二进制数据

 

既然数据库支持BLOB类型的数据，把文件塞进BLOB字段里一定没有错了！？错，不是这样的！别的先不提，在很多数据库语言里，处理大字段都不是很容易。

 

把文件存放在数据库里有很多问题：

 

• 对数据库的读/写的速度永远都赶不上文件系统处理的速度
• 数据库备份变的巨大，越来越耗时间
• 对文件的访问需要穿越你的应用层和数据库层

 

这后两个是真正的杀手。把图片缩略图存到数据库里？很好，那你就不能使用nginx或其它类型的轻量级服务器来处理它们了。

 

给自己行个方便吧，在数据库里只简单的存放一个磁盘上你的文件的相对路径，或者使用S3或CDN之类的服务。

 

短生命期数据

 

使用情况统计数据，测量数据，GPS定位数据，session数据，任何只是短时间内对你有用，或经常变化的数据。如果你发现自己正在使用定时任务从某个表里删除有效期只有一小时，一天或数周的数据，那说明你没有找对正确的做事情的方法。使用redis， statsd/graphite， Riak，它们都是干这种事情更合适的工具。这建议也适用于对于收集那些短生命期的数据。

 

当然，用挖土机在后花园里种土豆也是可行的，但相比起从储物间里拿出一把铲子，你预约一台挖土机、等它赶到你的园子里挖坑，这显然更慢。你要选择合适的工具来处理手头上的事。

 

日志文件

 

把日志数据存放到数据库里，表面上看起来似乎不错，而且“将来也许我需要对这些数据进行复杂的查询”，这样的话很得人心。这样做并不是一个特别差的做法，但如果你把日志数据和你的产品数据存放到一个数据库里就非常不好了。

 

也许你的日志记录做的很保守，每次web请求只产生一条日志。对于整个网站的每个事件来说，这仍然会产生大量的数据库插入操作，争夺你用户需要的数据库资源。如果你的日志级别设置为verbose或debug，那等着看你的数据库着火吧。

 

你应该使用一些比如Splunk Loggly或纯文本文件来存放你的日志数据。这样去查看它们也许会不方便，但这样的时候不多，甚至有时候你需要写出一些代码来分析出你想要的答案，但总的来说是值得的。

 

可是稍等一下，你是那片不一样的雪花，你遇到的问题会如此的不同，所以，如果你把上面提到的三种东西中的某一种放到了数据库里也不会有问题。不，你错了，不，你不特殊。相信我。

 

译文出自：外刊IT评论

 

英文出自：revsys

/*******************************************************************************************************************/

日志文件是一个随处都在使用的文件,它可以很好的记录程序的运行状态和出错信息,几乎每一个安装程序都有它的安装文件..在我们用java开发web项目中,会经常需要记录用户的一些登陆,访问,操作信息.如:一个办公系统,它的日志文件需要记录:
………
Wed May 19 13:35:50 CST 2004:张三登陆了该系统
Wed May 19 13:35:53 CST 2004:张三插入了一条"下周计划"记录 id:1048
Wed May 19 13:35:54 CST 2004:李四登陆了该系统
Wed May 19 13:35:55 CST 2004:张三删除了一条"上周总结"记录, d:1024
Wed May 19 13:35:59 CST 2004:张三退出了该系统
................
实现思路:
1. 为了很好的实现这个记录类,必须要使用”单态”模式,这样该类不必每次调用的时候都需要生成它的实例,初始化i/o.(这在一定程度上是很耗费时间的).
2. 为了防止多线程同时操作(写)日志文件,造成文件”死锁”,必须考虑同步,使用synchronized关键字.
3. 为了不必关心该类唯一实例的生成,而直接使用该类的静态方法实现日志的记录
4. 为了更方便的配置日志文件的路径,使用属性文件配置.

废话太多了,不像搞程序的了,直接看代码,所有的注释在代码中说明:


import java.io.*;
import java.util.*;
public class LogWriter {
  private static final String DefalutLogFilePathName="c:\\logtext.log";//默认的日志文件的路径和文件名称
  private static LogWriter logwriter; //该类的唯一的实例
  private static InputStream fin; //属性配置文件的输入流
  private static Properties pro; //class Properties's supper is Hashtable class
  private static PrintWriter out; //output stream
  private static String logFileName; //output file name
  private LogWriter() {
    outInit();//init out put stream,实例化PrintWriter out 对象.
  }
  /**保存你想保存在日志文件中的信息,实现同步
   * out put the message infomation
   * @param message infomation
   */
  public static synchronized void log(String message) {
    if (logwriter == null || (out == null)){
      logwriter = new LogWriter();
    }
    if (out != null) {
      out.println(new java.util.Date() + ":" + message);
    }
  }
  /**把异常信息保存在日志文件中,实现同步
   * out put the Excetion infomation
   * @param message infomation
   */
  public static synchronized void log(Exception ex) {
    if (logwriter == null || (out == null))
      logwriter = new LogWriter();
    if (out != null) {
      out.println(new java.util.Date() + ":" );
      ex.printStackTrace(out);
    }
  }
  /**
   *输出文件流的init
   */
  private void outInit() {
    if (logFileName == null)
      logFileName = getlogFileName(); //从属性文件中类获得日志文件的路径
    try {
      if (out == null) {//如果输出i/o没有实例,则生成一个信的
        out = new PrintWriter(new FileWriter(logFileName, true), true); ; //
        //其中的FileWriter()中的第二个参数的含义是:是否在文件中追加内容
      }
    }
    catch (IOException ex) {
      System.out.println("无法打开日志文件:"+logFileName);
      ex.printStackTrace();
      out = null;
    }
  }
  /**
   *根据配置文件.来获得日志文件的位置
   *
   * @return logFileName
   */
  private String getlogFileName() {
    try {
      if (pro == null) {
        pro = new java.util.Properties();
        fin = getClass().getResourceAsStream("log.properties"); //在类的当前位置,查找属性配置文件log.properties
        pro.load(fin);//载入配置文件
        fin.close();
      }
    }
    catch (IOException ex) {
       System.err.println("无法打开属性配置文件: log.properties" );
      ex.printStackTrace();
    }
    return pro.getProperty("logfile",DefalutLogFilePathName);
    //根据属性值获得日志文件路径,第二个参数是:如果找不到"logfile"标志,就返回的默认值
  }
  /**你也可以在所有的日志都记录完成的时候,调用该方法,释放资源.
   * free all the resouce,this is secuty method
   */
  public void free() {
    try {
      this.logwriter = null;
      if (out != null)
        this.out.close();
      if (fin != null)
        this.fin.close();
    }
    catch (IOException ex) {
      ex.printStackTrace();
    }
  }
}

●类的具体使用::
1.,把该类编译好, 新建立属性配置文件:log.properties,并确保把它放倒你的这个编译好的类所在的位置
文件内容如下:当然你可以把路径修改为你想要的路径
logfile=e:\\logtext.log
2.. 使用举例:
使用1:
LogWriter.log("张三登陆了该系统");
logWriter.log("张三删除了xxx条记录:记录id:");
使用2:
try{
}
catch (Exception ex) {
LogWriter.log(ex);
}
● 几点说明:
一.其中的 getClass().getResourceAsStream("文件名称")不支持static的调用,
所以要把该类换为非static,但是它的调用仅仅在于outinit()中调用,而outinit()
也仅仅在私有的构造函数中调用,而私有构造函数可以在静态的static 中被调用,
这样就达到了可以利用静态方法来调用随时输入日志,并保证了仅仅有一个实例

二.如果你了解log4J的话,可以使用该类似方法,把log4j封装一下,实现静态方便的调用.

三.我同时使用多个线程测试过该类.没有发现问题.因为对java才研究了一年.如果高手们看出其中的错误或者不足之处,也请多多赐教.谢谢.具体问题可联:qq:29189725

/*******************************************************************************************************************/

import java.io.*;
import java.util.*;
/**
  *
  * <p>Title: LOG 日志记录</p>
  * <p>Description:
  * 此类主要用来记录系统中发生的重大事件，以及由于程序本身所产生的错误信息</p>
  * <p>Copyright: Copyright (c) 2003</p>
  * <p>Company: hoten </p>
  * @author lqf
  * @version 1.0
  */
////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////
public class Log{
  /**
   * 用来记录系统重大事件
   * @param msg　重大事件
   * @param fileName　日志文件的路径及名称
   */

    public static void printBytes(byte[] msg,String logFile){
         StringBuffer sb = new StringBuffer(100);
         for(int i=0;i<msg.length;i++){
             sb.append((int)msg[i]);
             sb.append(",");
         }
         printEvent(sb.toString(),logFile);
   }
  public synchronized static void printEvent(String msg,String fileName)
   {
      msg = new String( "时间："+CTime.getTime(CTime.YYMMDDhhmmss) + " 事件消息:  " + msg);
      if(fileName!=null) printToFile(msg,fileName);
      else print(msg);
      return;
   }

   public synchronized static void printError(Throwable e,String msg,String fileName)
   {
      StringBuffer errors=new StringBuffer(100);
      errors.append("时间：");
      errors.append(CTime.getTime(CTime.YYMMDDhhmmssxxx));
      errors.append("　消息：");
      errors.append(msg);
      errors.append(" Exception: ");
      if(fileName!=null) {
            printToFile(errors.toString().trim(),fileName);
            try {
                e.printStackTrace(new PrintWriter(new FileWriter(fileName,true),true));//
            }
            catch (Exception ex) {
            }
      }
      else print(errors.toString().trim());
      return;
   }
/**
 * 记录应程序本身发生的错误，主要给程序员观察。
 * @param e　　一个Ｅｘｃｅｐｔｉｏｎ
 * @param mobile　用户手机号码
 * @param msg　　　用户发送的消息
 * @param fileName　日志文件的路径及名称
 */
   public synchronized static void printError(Throwable e,String mobile,String msg,String fileName)
   {
      StringBuffer errors=new StringBuffer(100);
      errors.append("时间：");
      errors.append(CTime.getTime(CTime.YYMMDDhhmmssxxx));
      errors.append("　手机号码:");
      errors.append(mobile);
      errors.append("　消息：");
      errors.append(msg);
      errors.append(" Exception: ");
      if(fileName!=null) {
            printToFile(errors.toString().trim(),fileName);
            try {
                e.printStackTrace(new PrintWriter(new FileWriter(fileName,true),true));//
            }
            catch (Exception ex) {
            }
      }
      else print(errors.toString().trim());
      return;
   }
/**把错误消息打印到屏幕上
 *
 * @param msg　错误消息
 */
   private static void print(String msg)
   {
       System.out.println(msg);
   }
/**
 * 把消息打印到指定文件
 * @param msg　错误消息
 * @param fileName　指定的文件
 */

   private static void printToFile(String msg,String fileName) //打印到文件中
   {
      BufferedWriter mBufWriter = null;
      try
      {
         if(!createFile(fileName)) return ;
         FileWriter fileWriter = new FileWriter(fileName, true);
         mBufWriter = new BufferedWriter(fileWriter);

         mBufWriter.write(msg);
         mBufWriter.newLine();

         mBufWriter.flush();
         mBufWriter.close();
      }
      catch (Throwable e)
      {
         try { mBufWriter.close(); } catch (Throwable t) {};
      }
      return;
   }
/**
 * 用来创建文件和文件夹
 * @param fileName　文件或文件夹名称
 * @return
 * @throws IOException
 * @throws Exception
 */

  private static boolean createFile(String fileName)throws IOException ,Exception{
        File file = new File(fileName);
         if (file.exists()) /* does file exist? If so, can it be written to */
         {
            if (file.canWrite() == false)
               return false;
         }
         else
         {
           String path = null;  /* Does not exist.  Create the directories */

           int firstSlash = fileName.indexOf(File.separatorChar);
           int finalSlash = fileName.lastIndexOf(File.separatorChar);

           if (finalSlash == 0) { /* error, not valid path */ }
           else if (finalSlash == 1) /* UNIX root dir */
           {
             path = File.separator;
           }
           else if (firstSlash == finalSlash)
           { /* for example c:\  Then make sure slash is part of path */
             path = fileName.substring(0,finalSlash+1);
           }
           else
           { path = fileName.substring(0,finalSlash); }

           File dir = new File(path);
           dir.mkdirs();
         }
         return true;
  }

/*******************************************************************************************************************/

import java.util.*;
/**
 * <p>Title: Time  </p>
 * <p>Description: </p>
 *      此类主要用来取得本地系统的系统时间并用下面5种格式显示
 *              1.　YYMMDDHH         8位
 *              2.　YYMMDDHHmm       10位
 *              3.　YYMMDDHHmmss     12位
 *              4.　YYYYMMDDHHmmss   14位
 *              5.　YYMMDDHHmmssxxx  15位 (最后的xxx 是毫秒)
 * <p>Copyright: Copyright (c) 2003</p>
 * <p>Company: hoten </p>
 * @author lqf
 * @version 1.0
 */
public class CTime {
    public static final int YYMMDDhhmmssxxx=15;
    public static final int YYYYMMDDhhmmss=14;
    public static final int YYMMDDhhmmss=12;
    public static final int YYMMDDhhmm=10;
    public static final int YYMMDDhh=8;
/**
 * 取得本地系统的时间，时间格式由参数决定
 * @param format 时间格式由常量决定
 * @return　String 具有format格式的字符串
 */
    public synchronized static String  getTime(int format){
        StringBuffer cTime=new StringBuffer(10);
        Calendar time=Calendar.getInstance();
        int miltime=time.get(Calendar.MILLISECOND);
        int second=time.get(Calendar.SECOND);
        int minute=time.get(Calendar.MINUTE);
        int hour=time.get(Calendar.HOUR_OF_DAY);
        int day =time.get(Calendar.DAY_OF_MONTH);
        int month=time.get(Calendar.MONTH)+1;
        int year =time.get(Calendar.YEAR);
        if(format!=14){
            if(year>=2000) year=year-2000;
            else year=year-1900;
        }
        if(format>=2){
            if(format==14) cTime.append(year);
            else    cTime.append(getFormatTime(year,2));
        }
        if(format>=4)
            cTime.append(getFormatTime(month,2));
        if(format>=6)
            cTime.append(getFormatTime(day,2));
        if(format>=8)
            cTime.append(getFormatTime(hour,2));
        if(format>=10)
            cTime.append(getFormatTime(minute,2));
        if(format>=12)
            cTime.append(getFormatTime(second,2));
        if(format>=15)
            cTime.append(getFormatTime(miltime,3));
        return cTime.toString();
    }
/**
 *　产生任意位的字符串
 * @param time 要转换格式的时间
 * @param format　转换的格式
 * @return　String 转换的时间
 */
    private synchronized static String getFormatTime(int time,int format){
        StringBuffer numm=new StringBuffer();
        int length=String.valueOf(time).length();

        if(format<length) return null;

        for(int i=0 ;i<format-length ;i++){
            numm.append("0");
        }
        numm.append(time);
        return numm.toString().trim();
    }
}

 

 

/*******************************************************************************************************************/

系统操作日志

2009-06-27 09:44 1934人阅读 评论(1) 收藏 举报

数据库applicationsessionhttpmoduleeventsserver

   1、  我想实现：

  我想设置一个JSP程序,只要有用户登陆网站(管理员或非法的),不管登录成功或失败都把登陆的用户名(登陆信息,执行页面)记录到数据库中,还有登陆后 台后对网站的修改也要做个记录,比如修改过新闻,删除留言,修改过网站配置等都有记录,不要求可恢复,能记录七天,或是1000条记录这样就可以了.多的 记录可以自动删除....类似的功能该如何实现？

   ————思路：

  a, 写个公用函数:
function doRecordLog(username, action, content)
    ' 该函数内部实现记录用户操作日志功能
end function
 b, 各页面需要记录日志的操作都调用这个函数.

————思路2：

   四种办法：

a.每页生成一个不同session，如果该页结束，将值付给变量传递到数据库保存。
b.为每条记录设置新建时的日期，修改时的日期，分别保存在数据库中，显示在管理页面，如果看到哪条记录是新修改的，就会是新的日期，新建的日期是不会变的。
c.放置一个访问统计页，统计每位后台管理者访问过的路径，我有用访问统计，能查看到来者的每个脚印，和对方的IP，不过是用在前台，当然后台也可以用的。
d.如果你想控制管理者的操作权限，可以设置多个管理组，为不同的组设置不同的管理权限，就像window一样，有管理员权限和guest权限，这样有些用户只能看而不能修改。

我就一直用第二种办法，查看更新情况的。

 

CREATE TABLE eventlog(
cid int primary key not null,
csort varchar(50) null,
cusername varchar(50) null,
ctime datetime,
cdo varchar(250) null,
cip varchar(20)
)

程序
先调用数据库
然后
<%
Function events(csort,cusername,cdo)
cip = Request.ServerVariables("HTTP_X_FORWARDED_FOR")
If cip = "" Then
cip = Request.ServerVariables("REMOTE_ADDR")
End If
ctime=now()
safesql="select * from tb_eventlog"
set rsyss=server.CreateObject("adodb.recordset")
rsyss.open safesql,con,1,3
rsyss.addnew
rsyss("csort")=csort
rsyss("cusername")=cusername
rsyss("cdo")=cdo
rsyss("ctime")=ctime
rsyss("cip")=cip
rsyss.update
rsyss.close
End Function
%>

 

不就写日记吗？

一般比较合理的作法是，先将操作中进行一闪的格式。
比如：一个管理员对数据库做了一些调整，他删除了某一个用户，那么在删除用户的同时应该向日志中记录。

这个肯定是管理员，首先它是登陆的，那么可以用session("userID")保存其登陆状态的，同时取出该值，向日记数据库中记录，这样首先做到了定位人的目的，当然这个操作是在删除用户中进行的，那么可以在动作中注明的。所以数据库的建立很清楚了：
userid      datetime     active
userid是用存放是谁做的动作
datetime用来存放在何时的动作
active用来指明动作，比如删除用户等文本方式存储
如有需要可以对该数据表进行扩充。
管理员在删除用户时，先将动作写入了日记数据库，然后才开始做删除用户的动作。这样完全记录了管理员的动作。

访问网页，可以在登陆后进行的。
比如有一个网页是abc.asp
那么在abc.asp最开始的地方测试session("userid")如果存在则，向日记数据库中插入记录，userid插入 session("userid"),当前时间插入到datetime中，将字符串“访问了abc网页”插入到active中，这样你取出记录可以看到， 某一用户在某一时间，访问了abc网页。当然如果访问网页过多，可以将这一段写出来，导入到每个网页中。就可以了！

至于怎么控制网页的开始，这是一个重定向的问题。
比如，你在后台中写了关闭网站中的某个页面，则可以用一个application("vis")变量来控制。点击关闭时，执行了一个事 件，application("vis")="false"，反之，将这个值取为true,在application-start事件中先义其打开或关 闭。

运行该网页时最开始，去取application("vis")的值，若是true，则显示该页，不用有动作，若是false则将网页定向到另一个提示网页中！

当然，我这里是以application为例的，其实你也可以存入数据库中的，所以存入的作为配置。这样即使重启服务器也不会丢失的！只不过这里的原理就是这样！

简单不？它和写普通页面没有什么区别的！所谓的后台只不过是管理员登陆的！实际上对于开发来说是不分前台后台的。这个名词只是网页功能的区分而已！

在执行操作或进入某页时调用
<%'如在用户登录时
events "用户登录",session("username"),"成功登录后台管理"

'在信息修改时
events "企业荣誉",session("username"),"修改荣誉分类名称"

%>这样子就可以了

第二个没看懂你说的是什么意思
那你在页面前面加一个判断不就行了
先设定一个表
页面  值（0/1）
在每页
用
if Request.ServerVariables("SERVER_PORT")<>"80" then
     userurl = "http://"&Request.ServerVariables("SERVER_NAME")& ":" & Request.ServerVariables("SERVER_PORT")& Request.ServerVariables("URL")
    else
     userurl = "http://"&Request.ServerVariables("SERVER_NAME")& Request.ServerVariables("URL")
end if
取你的网址
userurl=right(UserUrl,InstrRev(UserUrl,"/")+1)取你网址中的网页名
然后
读你表里网页名相同的 在进行判断 如果值为0就是关闭了如果值为1就是可以看
你后台里在做一个页来控制页是否关闭就行了

   ——————————操作日志————————

    a、 日志里大概会记录：谁在什么时间什么地方做了什么操作
所以写一个类似的过程，addlog(user,time,place,operate)在需要记录的地方调用即可．
比如要记录登陆过程，则在登陆完成之后记录，登陆的用户名，时间，（这里地方可以不记录了，因为应该只有一个登陆点吧），操作则是登陆．
其他地方类似的如此调用去记录．

b、 我是放在一个单独的日志文件里的，按日期来命名
procedure WriteToTxt(content:string);
var
F: Textfile;
path,name:string;
begin
  name:=FormatDateTime('yyyy-mm-dd',now);//取得日期
    path:=ExtractFilePath(Application.ExeName)+'log/'+ name+'.txt';//日志存取路径
    AssignFile(F,path);
    if FileExists(path) =False then
    ReWrite(F);
    Append(F);
    Writeln(F,'['+DateTimeToStr(Now())+']:'+content); //写入日志文件
    Closefile(F);
end;

在具体的操作后面调用就OK了

 

 在OA项目中，需要记录用户都进行了什么操作，事件包括增加、删除和修改，希望记录成类似以下格式：

用户XXX在2007年X月X日增加了一个产品类别XXX
用户XXX在2007年X月X日删除了一个用户XXX

现在请教大家，除了在增删改的时候另外再运行一个存储过程记录这些信息外，有没有其他什么更简单的方法啊，感谢赐教~~感谢参与~

——————解答：

用文本文件记录吧，用追加文本    我的习惯做法是在数据库中建立日志表。
再编写一些方法，在用户进行增删改查时触发。
向表中添加数据           

  可以考虑通过   HttpModule   统一处理，
但是，你得考虑如何捕获用户进行了什么操作

/*******************************************************************************************************************/

JAVA反射与AOP双剑合璧详细记录操作日志

分类： Core Java 2012-06-06 19:33 5441人阅读 评论(0) 收藏 举报

aopjavastringapiobjectpair

       运用AOP来记录用户的操作日志在项目中比较常见，优点是只需在一个地方编写Advice，通过AOP声明(织入)然后就可以记录很多不同的操作 (API)。但是也有其缺点，因为Advice服务于不同的API，而各个API的参数，返回值不同，甚至服务的对象都不一样，那么能做到的也只能是判断 是否有异常，异常的具体信息等简单的内容。如果想要个性化的为每一个API都记录执行参数，返回值，甚至Target的属性时就无能为力，因为能够拿到对 象，但是不知道到底是什么类型的。本文就利用Java反射机制来获取这些信息。

 

       首先要能使用反射，那么就必须知道方法或者属性名称，所以需要配置相关信息。本示例中用Bean的属性(Field)来配置。一个操作对应一个API， 由开发人员配置。最后记录的信息以key=value的形式保存，key就是key，容易理解，value是指对对象(参数和返回值两种)的field属 性值，如果嵌套多层则用.(dot)隔开。值得注意的的参数的情形，[0]表示第一个参数，[1]表示第二个参数。之所以使用序号是由于Java参数名在 编译完之后会丢失，如果AOP使用AspectJ编译的话可以保存。XML文件具体设置如下：

<apis>
     <api name="ServerWebServiceImp.login">
      <params>
        <param key="user_name" value="[0]" />
        <param key="password" value="[1]" />
      </params>
      <returns>
        <return key="aspclient_id" value="ASPClient_Id" />
        <return key="user_id" value="users_Id" />
      </returns>
      </api>
</apis>

需要把XML解析为JavaBean存到内存里面，解析引擎有很多选择，如Dom4j等。具体的解析过程不贴了，很简单，JavaBean如下：

/**
 * API实体类
 */
public class ApiEntity {
    // 名称
    private String name;
    // API的参数
    private List<Pair> params;
    // API返回值
    private List<Pair> returns;

    public ApiEntity() {
        params = new ArrayList<ApiEntity.Pair>();
        returns = new ArrayList<ApiEntity.Pair>();
    }

    public void addParam(ApiEntity.Pair pair) {
        params.add(pair);
    }

    public void addReturn(ApiEntity.Pair pair) {
        returns.add(pair);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Pair> getParams() {
        return params;
    }

    public void setParams(List<Pair> params) {
        this.params = params;
    }

    public List<Pair> getReturns() {
        return returns;
    }

    public void setReturns(List<Pair> returns) {
        this.returns = returns;
    }

    public static class Pair {
        private String key;
        private String value;

        public String getKey() {
            return key;
        }

        public void setKey(String key) {
            this.key = key;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }
    }
}

 

         上面是说明如何设置以及表示API，下面就需要利用设置的内容来具体处理参数以及返回值。通常我们记录的是JavaBean的属性值，但是也会出现 List，Map，甚至HttpSession的Attribute。为了能够处理所有的内容，我们需要设置一个插件的钩子，有特殊需求的人可以自己去处 理获取对象内容的过程。声明一个接口：

/**
 * 如何获取对象的值或者属性值接口
 */
public interface ValueGetter {
/**
* 判断是否可以处理该对象的属性值
* 
* @param target
*            需要处理的对象,已经保证不会为NULL
* @param key
*            配置文件中的key值,起辅助作用
* @param fieldName
*            对应的属性名称,已经保证不会为空
* @return
*/
Boolean canGet(Object target, String key, String fieldName);


/**
* 获取对象的属性值
* 
* @param target
*            需要处理的对象,已经保证不会为NULL
* @param fieldName
*            对应的属性名称,已经保证不会为空
* @return
*/
Object getValue(Object target, String fieldName);
}

 

具有特殊需求的开发人员可以实现该接口并注册，那么框架自动会调用个性化的实现。下面是普通的JavaBean实现，框架自己提供的，主要用到Java的反射机制：

/**
 * 默认的JavaBean获取属性实现. 支持处理私有的,父类的属性
 */
public class JavaBeanValueGetter implements ValueGetter {
    @Override
    public Boolean canGet(Object target, String key, String fieldName) {
        Field field = getField(target.getClass(), fieldName);
        if (field != null) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public Object getValue(Object target, String fieldName) {
        Field field = getField(target.getClass(), fieldName);
        Object fieldValue = null;

        if (field != null) {
            field.setAccessible(true);
            try {
                fieldValue = field.get(target);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return fieldValue;
    }

    @SuppressWarnings("rawtypes")
    private Field getField(Class c, String fieldName) {
        Field field = null;

        try {
            field = c.getDeclaredField(fieldName);
        } catch (NoSuchFieldException e) {
            Class parentClass = c.getSuperclass();
            if (parentClass != null) {
                field = getField(parentClass, fieldName);
            }
        }

        return field;
    }
}

Around的Advice实现我也不贴了，主要用Spring的AOP实现。该Advice里面会维护一个 List<ValueGetter>，并且BeanValueGetter为第一个(效率的考虑，用得最多的是 BeanValueGetter)。下面举一个最简单的例子:

public class Customer {
    private String name;
    private Address address;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
}

public class Address {
    private String roadNo;

    public String getRoadNo() {
        return roadNo;
    }

    public void setRoadNo(String roadNo) {
        this.roadNo = roadNo;
    }
}

API为 public Long saveCustomer(Customer customer);

配置文件为

<api name="saveCustomer">
    <params>
        <param key="roadNo" value="[0].address.roadNo" />
    </params>
    <returns>
        <return key="customer_id" value="" />
    </returns>
</api>

特别说明： .表示的嵌套属性先分割开再处理，处理的逻辑单元为没有点的情形，逐级调用，roadNo调用了两次BeanValueGetter。value为空表示对象自己，不再获取属性值。

最后的描述信息可能为：saveCustomer{params(roadNo=1024),returns(customer_id=67)}

 

  上面只是展示了最简单的情形，你可以添加更多的API属性，比如API描述信息，所属模块等。总之就是使用XML配置+Java反射+AOP详细记录操作日志信息。

/*******************************************************************************************************************/

利用Spring AOP与JAVA注解为系统增加日志功能

博客分类：

• Spring

AOPJavaSpringApacheStruts 

Spring AOP一直是Spring的一个比较有特色的功能，利用它可以在现有的代码的任何地方，嵌入我们所想的逻辑功能，并且不需要改变我们现有的代码结构。

 

鉴于此，现在的系统已经完成了所有的功能的开发，我们需要把系统的操作日志记录起来，以方便查看某人某时执行了哪一些操作。Spring AOP可以方便查看到某人某时执行了哪一些类的哪一些方法，以及对应的参数。但是大部分终端用户看这些方法的名称时，并不知道这些方法名代码了哪一些操 作，于是方法名对应的方法描述需要记录起来，并且呈现给用户。我们知道，AOP拦截了某些类某些方法后，我们可以取得这个方法的详细定义，通过详细的定 义，我们可以取得这个方法对应的注解，在注解里我们就可以比较方便把方法的名称及描述写进去。于是，就有以下的注解定义。代码如下所示：

 

package com.htsoft.core.log;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @company  广州宏天软件有限公司
 * @description 类的方法描述注解
 * @author csx
 * @create 2010-02-03
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Action {
    /**
     * 方法描述
     * @return
     */
    public String description() default "no description";
}

 

 

在我们需要拦截的方法中加上该注解：

 

 

/**
 *
 * @author csx
 *
 */
public class AppUserAction extends BaseAction {
    /**
     * 添加及保存操作
     */
    @Action(description="添加或保存用户信息")
    public String save() {
             ....
        }
       /**
     * 修改密码
     *
     * @return
     */
    @Action(description="修改密码")
    public String resetPassword() {
              ....
        }
}

 

现在设计我们的系统日志表，如下所示：

 

设计嵌入的逻辑代码，以下类为所有Struts Action的方法都需要提前执行的方法。（对于get与set的方法除外，对于没有加上Action注解的也除外）

 

package com.htsoft.core.log;

import java.lang.reflect.Method;
import java.util.Date;

import javax.annotation.Resource;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.ProceedingJoinPoint;

import com.htsoft.core.util.ContextUtil;
import com.htsoft.oa.model.system.AppUser;
import com.htsoft.oa.model.system.SystemLog;
import com.htsoft.oa.service.system.SystemLogService;

public class LogAspect {

    @Resource
    private SystemLogService systemLogService;

    private Log logger = LogFactory.getLog(LogAspect.class);

    public Object doSystemLog(ProceedingJoinPoint point) throws Throwable {

        String methodName = point.getSignature().getName();

        // 目标方法不为空
        if (StringUtils.isNotEmpty(methodName)) {
            // set与get方法除外
            if (!(methodName.startsWith("set") || methodName.startsWith("get"))) {

                Class targetClass = point.getTarget().getClass();
                Method method = targetClass.getMethod(methodName);

                if (method != null) {

                    boolean hasAnnotation = method.isAnnotationPresent(Action.class);

                    if (hasAnnotation) {
                        Action annotation = method.getAnnotation(Action.class);

                        String methodDescp = annotation.description();
                        if (logger.isDebugEnabled()) {
                            logger.debug("Action method:" + method.getName() + " Description:" + methodDescp);
                        }
                        //取到当前的操作用户
                        AppUser appUser=ContextUtil.getCurrentUser();
                        if(appUser!=null){
                            try{
                                SystemLog sysLog=new SystemLog();

                                sysLog.setCreatetime(new Date());
                                sysLog.setUserId(appUser.getUserId());
                                sysLog.setUsername(appUser.getFullname());
                                sysLog.setExeOperation(methodDescp);

                                systemLogService.save(sysLog);
                            }catch(Exception ex){
                                logger.error(ex.getMessage());
                            }
                        }

                    }
                }

            }
        }
        return point.proceed();
    }

}

 

通过AOP配置该注入点：

 

<aop:aspectj-autoproxy/>
<bean id="logAspect" class="com.htsoft.core.log.LogAspect"/>
 <aop:config>
        <aop:aspect ref="logAspect">
            <aop:pointcut id="logPointCut" expression="execution(* com.htsoft.oa.action..*(..))"/>
            <aop:around pointcut-ref="logPointCut" method="doSystemLog"/>
        </aop:aspect>
</aop:config>

 

  注意，由于AOP的默认配置是使用代理的方式进行嵌入代码运行，而StrutsAction中若继承了ActionSupport会报错误，错误是由于其使用了默认的实现接口而引起的。所以Action必须为POJO类型。

 

如我们操作了后台的修改密码，保存用户信息的操作后，系统日志就会记录如下的情况。

 

 

 

• 查看图片附件

/*******************************************************************************************************************/

Spring MVC 拦截Action 获取action中的参数并转码(续)

 

Spring拦截类

package com.teamsun.aop;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import com.teamsun.common.EnCodingUtil;
import com.teamsun.req.ParameterRequestWrapper;

public class ActionBeforeHandler implements HandlerInterceptor {

 @Override
 public void afterCompletion(HttpServletRequest arg0,
   HttpServletResponse arg1, Object arg2, Exception arg3)
   throws Exception {
  System.out.println("========afterCompletion=========================");

 }

 @Override
 public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,
   Object arg2, ModelAndView arg3) throws Exception {
  
  System.out.println("========postHandle=========================");
 }

 @Override
 public boolean preHandle(HttpServletRequest req, HttpServletResponse res,
   Object arg2) throws Exception {
  
  Map map =req.getParameterMap();//获取页面提交到action前参数
  
  Map param = new HashMap<String, Object>();//将参数存放到新的的map中
  
  if(map!=null && !map.isEmpty()){
   
   Set<String> keys =map.keySet();
   
   Iterator<String> it = keys.iterator();
   while(it.hasNext()){
    String key = it.next();
    Object t =map.get(key);
    
    if(t instanceof String){//给String转码
     if(t != null){
      t =  EnCodingUtil.getValue((String)t);
     }
    }if(t instanceof String[]){//给String数组转码
     if(t != null){
      String args[] = (String[])t;
      for (int i = 0; i < args.length; i++) {
       args[i] =  EnCodingUtil.getValue(args[i]);//转码类
      }
       t = args;
     }
    }else {//给类转码
     t =  EnCodingUtil.getClass(t);
    }
    
    param.put(key, t);
   }
  }
  
  ParameterRequestWrapper p = new ParameterRequestWrapper(req,param);//使用新建的参数类，不然系统向原有的参数map中存放参数报错
  
  System.out.println("拦截成功");
  System.out.println("========进入方法开始=========================");
  System.out.println("进入类"+arg2.getClass().getName()+""+req.getParameter("dept"));
  
  System.out.println("========进入方法结束=========================");
  return true;
 }

}

 

ParameterRequestWrapper 

 

package com.teamsun.req;

import java.util.Enumeration;
import java.util.Map;
import java.util.Vector;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

/**
 * 用来存放jsp提交到action中的参数
 * @author Administrator
 *
 */
public class ParameterRequestWrapper extends HttpServletRequestWrapper {

 public ParameterRequestWrapper(HttpServletRequest request) {
  super(request);

 }

 private Map params;

 public ParameterRequestWrapper(HttpServletRequest request, Map newParams) {
  super(request);
  this.params = newParams;
 }

 public Map getParameterMap() {
  return params;
 }

 public Enumeration getParameterNames() {
  Vector l = new Vector(params.keySet());
  return l.elements();
 }

 public String[] getParameterValues(String name) {
  Object v = params.get(name);
  if (v == null) {
   return null;
  } else if (v instanceof String[]) {
   return (String[]) v;
  } else if (v instanceof String) {
   return new String[] { (String) v };
  } else {
   return new String[] { v.toString() };
  }
 }

 public String getParameter(String name) {
  Object v = params.get(name);
  if (v == null) {
   return null;
  } else if (v instanceof String[]) {
   String[] strArr = (String[]) v;
   if (strArr.length > 0) {
    return strArr[0];
   } else {
    return null;
   }
  } else if (v instanceof String) {
   return (String) v;
  } else {
   return v.toString();
  }

 }
}

 

Spring AOp配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:jee="http://www.springframework.org/schema/jee"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xsi:schemaLocation="
            http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd
            http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.0.xsd
            http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsd
            http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsd
            http://www.springframework.org/schema/jeehttp://www.springframework.org/schema/jee/spring-jee-3.0.xsd
            http://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"
 default-autowire="byName" default-lazy-init="true">
 
 
 <bean id="beforeAdvice" class="com.teamsun.aop.BeforeAdvice"></bean>
 <bean id="afterAdvice" class="com.teamsun.aop.AfterAdvice"></bean>
 <bean id="interceptorAdvice" class="com.teamsun.aop.Compareterceptor"></bean>
 
  
  <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
  <aop:config>
  <aop:pointcut id="actionOp"
   expression="execution(* *..action..*Action*.*(..)) " />
   
   <aop:pointcut id="serviceOperation"
   expression="execution(* *..teamsun..*Impl*.*(..)) " />

  <aop:advisor pointcut-ref="actionOp"
   advice-ref="beforeAdvice" />
  <aop:advisor pointcut-ref="serviceOperation"
   advice-ref="beforeAdvice" />

 </aop:config>
 <context:annotation-config />
 <context:component-scan base-package="com.**.student" />
 <context:component-scan base-package="com.**.impl" />
 <context:component-scan base-package="com.**.action" />
 
 
<!--  <bean id="urlMapping" -->
<!--   class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"> -->
<!--   <property name="mappings"> -->
<!--    -->
<!--   <props> -->
<!--   <prop key="/AddAction.do">addAction</prop> -->
<!--   </props> -->
<!--   </property> -->
<!--   <property name="interceptors"> -->
<!--   <list> -->
<!--   <bean class="com.teamsun.aop.ActionBeforeHandler"/> -->
<!--   </list> -->
<!--   </property> -->
<!-- </bean>-->
<mvc:interceptors>
 <bean class="com.teamsun.aop.ActionBeforeHandler"></bean>
</mvc:interceptors>

</beans>