在pom.xml文件中加入<!--mongodb -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-mongodb</artifactId>
<version>1.3.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>2.11.1</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.0</version>
</dependency>
在jdbc.properties的配置文件中添加MongoDB的是数据库链接信息及其他的一些配置##
mongo.dbname=database
mongo.host=127.0.0.1
mongo.port=27017
mongo.connectionsPerHost=8
mongo.threadsAllowedToBlockForConnectionMultiplier=4
mongo.connectTimeout=1500
mongo.maxWaitTime=1500
mongo.autoConnectRetry=true
mongo.socketKeepAlive=true
mongo.socketTimeout=1500
mongo.slaveOk=true<?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:mongo="http://www.springframework.org/schema/data/mongo"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/data/mongo
http://www.springframework.org/schema/data/mongo/spring-mongo-1.7.xsd
http://www.springframework.org/schema/data/repository
http://www.springframework.org/schema/data/repository/spring-repository-1.7.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd" >
<!-- 引入属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties" />
<mongo:db-factory id="mongoDbFactory" dbname="${mongo.dbname}" mongo-ref="mongoClient" />
<mongo:mongo host="${mongo.host}" port="${mongo.port}">
<mongo:options
connections-per-host="${mongo.connectionsPerHost}"
threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"
connect-timeout="${mongo.connectTimeout}"
max-wait-time="${mongo.maxWaitTime}"
auto-connect-retry="${mongo.autoConnectRetry}"
socket-keep-alive="${mongo.socketKeepAlive}"
socket-timeout="${mongo.socketTimeout}"
slave-ok="${mongo.slaveOk}"
write-number="1"
write-timeout="0"
write-fsync="true"/>
</mongo:mongo>
<!--dbname="database" 数据库的集合名 可以在这写死 ，也可以在 数据库链接的配置文件中进行配置 -->
<mongo:db-factory dbname="database" mongo-ref="mongo" />
<bean id="MongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
<constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
</bean>
</beans>因为我在web.xml中配置的是mybatis的监听
<!-- Spring和mybatis的配置文件 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mybatis.xml</param-value>
</context-param>
所以要将spring_mongo.xml 引入到spring_mybatis.xml中
<import resource="classpath:spring-mongo.xml"/>
package com.jk.login.model;
import java.io.Serializable;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
@Document(collection="operationlogs")
public class Operationlogs implements Serializable {
/**
*
*/
private static final long serialVersionUID = 17905552356189433L;
@Id
private String operlogid;//主键
private String operloginId;//操作者
private String operlognsolr;//操作者的角色
private String opertime;//操作时间
private String opercontroller;//全类名
private String operMethod;//方法名
private Integer tomcatport;//方法所在的行
private String operParams;//参数
private String operURI;//方法的请求路径
private String haoshi;//耗时
private String computerIp;//访问使用的设备ip
private String computerName;//访问使用的设备编号
public String getOperlogid() {
return operlogid;
}
public void setOperlogid(String operlogid) {
this.operlogid = operlogid;
}
public String getOperloginId() {
return operloginId;
}
public void setOperloginId(String operloginId) {
this.operloginId = operloginId;
}
public String getOperlognsolr() {
return operlognsolr;
}
public void setOperlognsolr(String operlognsolr) {
this.operlognsolr = operlognsolr;
}
public String getOpertime() {
return opertime;
}
public void setOpertime(String opertime) {
this.opertime = opertime;
}
public String getOpercontroller() {
return opercontroller;
}
public void setOpercontroller(String opercontroller) {
this.opercontroller = opercontroller;
}
public String getOperMethod() {
return operMethod;
}
public void setOperMethod(String operMethod) {
this.operMethod = operMethod;
}
public String getOperParams() {
return operParams;
}
public void setOperParams(String operParams) {
this.operParams = operParams;
}
public String getOperURI() {
return operURI;
}
public void setOperURI(String operURI) {
this.operURI = operURI;
}
public String getComputerIp() {
return computerIp;
}
public void setComputerIp(String computerIp) {
this.computerIp = computerIp;
}
public String getComputerName() {
return computerName;
}
public void setComputerName(String computerName) {
this.computerName = computerName;
}
public Integer getTomcatport() {
return tomcatport;
}
public void setTomcatport(Integer tomcatport) {
this.tomcatport = tomcatport;
}
public String getHaoshi() {
return haoshi;
}
public void setHaoshi(String haoshi) {
this.haoshi = haoshi;
}
}
新建拦截器类
package com.jk.interceptors;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import com.jk.login.model.Operationlogs;
import com.jk.login.model.userlogin;
public class MyInterceptor implements HandlerInterceptor {
@Autowired
private MongoTemplate mongoTemplate;
Operationlogs oper=new Operationlogs();
/*@Id
private String operlogid;//主键
private String operloginId;//操作者
private String operlognsolr;//操作者的角色
private String opertime;//操作时间
private String opercontroller;//全类名
private String operMethod;//方法名
private Integer tomcatport;//方法所在的行
private String operParams;//参数
private String operURI;//方法的请求路径
private String haoshi;//耗时
private String computerIp;//访问使用的设备ip
private String computerName;//访问使用的设备编号
*/
/*
* 可以考虑作权限，日志，事务等等
* 该方法在目标方法调用之前被调用；
* 若返回TURE,则继续调用后续的拦截器和目标方法
* 若返回FALSE,则不会调用后续的拦截器和目标方法
*
* 预处理回调方法，实现处理器的预处理（如检查登陆），第三个参数为响应的处理器，自定义Controller
* 返回值：true表示继续流程（如调用下一个拦截器或处理器）；false表示流程中断（如登录检查失败），
* 不会继续调用其他的拦截器或处理器，此时我们需要通过response来产生响应；
*/
// before the actual handler will be executed-- 在实际的处理程序被执行之前
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
long startTime = System.currentTimeMillis();
request.setAttribute("startTime", startTime);
if (handler instanceof HandlerMethod) {
StringBuilder sb = new StringBuilder(1000);
//打印到控制台
HandlerMethod h = (HandlerMethod) handler;
sb.append("Controller: ").append(h.getBean().getClass().getName()).append("\n");
sb.append("Method : ").append(h.getMethod().getName()).append("\n");
sb.append("Params : ").append(getParamString(request.getParameterMap())).append("\n");
sb.append("URI : ").append(request.getRequestURI()).append("\n");
oper.setOperlogid(UUID.randomUUID().toString());
oper.setTomcatport(request.getServerPort());
oper.setOpercontroller(h.getBean().getClass().getName());
oper.setOperMethod(h.getMethod().getName());
oper.setOperParams(getParamString(request.getParameterMap()));
oper.setOperURI(request.getRequestURI());
SimpleDateFormat sim=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
oper.setOpertime(sim.format(new Date()));
//获取访问者IP
String computerIp = request.getRemoteAddr();
String computerName = "";
if(!computerIp.equals("0:0:0:0:0:0:0:1")){
try {
//获取访问者计算机名称
computerName = InetAddress.getByName(computerIp).getHostName();
} catch (UnknownHostException e) {
e.printStackTrace();
}
}else{
try {
//获取计算机对象
InetAddress addr = InetAddress.getLocalHost();
computerName = addr.toString();
//获取本机的ip地址
computerIp = addr.getHostAddress();
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
oper.setComputerIp(computerIp);
oper.setComputerName(computerName);//访问者计算机名称
System.out.println("执行前"+sb.toString());
}
return true;
}
/**
* 该方法在目标方法调用之后，渲染视图之前被调用；
* 可以对请求域中的属性或视图做出修改
*
* 后处理回调方法，实现处理器的后处理（但在渲染视图之前），此时我们可以通过modelAndView
* （模型和视图对象）对模型数据进行处理或对视图进行处理，modelAndView也可能为null。
*/
// after the handler is executed--在执行处理程序之后
public void postHandle(HttpServletRequest request,
HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
userlogin usr= (userlogin) request.getSession().getAttribute("userMsg");
long startTime = (Long) request.getAttribute("startTime");
long endTime = System.currentTimeMillis();
long executeTime = endTime - startTime;
if(handler instanceof HandlerMethod){
oper.setOperloginId(usr.getcLoginid());
oper.setOperlognsolr(usr.getcName());
oper.setHaoshi(executeTime+"ms");
mongoTemplate.save(oper);
StringBuilder sb = new StringBuilder(1000);
sb.append("CostTime : ").append(executeTime).append("ms").append("\n");
sb.append("-------------------------------------------------------------------------------");
System.out.println("执行后"+sb.toString());
}
}
//获取方法中的参数
private String getParamString(Map<String, String[]> map) {
StringBuilder sb = new StringBuilder();
for(Entry<String,String[]> e:map.entrySet()){
sb.append(e.getKey()).append("=");
String[] value = e.getValue();
if(value != null && value.length == 1){
sb.append(value[0]).append("\t");
}else{
sb.append(Arrays.toString(value)).append("\t");
}
}
return sb.toString();
}
/**
* 在渲染视图之后被调用；
* 可以用来释放资源
*
* 整个请求处理完毕回调方法，即在视图渲染完毕时回调，如性能监控中我们可以在此记录结束时间并输出消耗时间，
* 还可以进行一些资源清理，
* 类似于try-catch-finally中的finally，但仅调用处理器执行链中
*/
public void afterCompletion(HttpServletRequest arg0,
HttpServletResponse arg1, Object arg2, Exception arg3)
throws Exception {
}
}以上配置完成 对项目后台的操作就能记录了 -----这只是简单的实现， 实际项目中要根据具体的业务需求来做完善 。
欢迎大咖们提出意见和建议 点醒我这梦中人 ---谢谢---谢谢---
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
