1 日志管理设计
日志页面查询、日志删除、日志添加的实现。
1.1 数据库导入
用户行为日志表设计，针对增删改查数据核对。
CREATE TABLE `sys_logs` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`username` varchar(50) DEFAULT NULL COMMENT '登陆用户名',
`operation` varchar(50) DEFAULT NULL COMMENT '用户操作',
`method` varchar(200) DEFAULT NULL COMMENT '请求方法',
`params` varchar(5000) DEFAULT NULL COMMENT '请求参数',
`time` bigint(20) NOT NULL COMMENT '执行时长(毫秒)',
`ip` varchar(64) DEFAULT NULL COMMENT 'IP地址',
`createdTime` datetime DEFAULT NULL COMMENT '日志记录时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='系统日志';1.2 页面设计
1.3 分页API设计
1.4 分页业务时序分析
2 日志管理列表页面呈现
2.1 PageController的实现
基于日志管理的请求业务，在PageController中添加doLogUI方法，doPageUI方法分别用于返回日志列表页面，日志分页页面。
第一步：在PageController中定义返回日志列表的方法。代码如下：
@RequestMapping("log/log_list")
public String doLogUI() {
return "sys/log_list";
}第二步：在PageController中定义用于返回分页页面的方法。代码如下：
@RequestMapping("doPageUI")
public String doPageUI() {
return "common/page";
}2.2 客户端实现
2.2.1 日志页面跳转
首先准备日志列表页面(/templates/pages/sys/log_list.html)，然后在starter.html页面中点击日志管理菜单时异步加载日志列表页面。
找到项目中的starter.html 页面，页面加载完成以后，注册日志管理菜单项的点击事件，当点击日志管理时，执行事件处理函数。关键代码如下：
$(function(){
doLoadUI("load-log-id","log/log_list")
})
function doLoadUI(id,url){
$("#"+id).click(function(){
$("#mainContentId").load(url);
});
}其中，load函数为jquery中的ajax异步请求函数。
2.2.2 日志页面分页异步加载
$(function(){
$("#pageId").load("doPageUI");
});3 业务实现
3.1 日志管理实现
查询：
数据架构分析
删除：
日志删除架构分析：
第一步：创建SysLog实体类
package com.cy.pj.sys.pojo;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
//实现此接口的对象可以进行序列化和反序列化
//1）序列化：将对象转化为字节的过程，转换以后便于通过网络进行传输或存储到相关介质中
//2）反序列化：将字节转换为对象的过程
//建议：在java中所有用于存储数据的对象都实现Serializable接口
@Data
public class SysLog implements Serializable {
private static final long serialVersionUID = 1L;
private Integer id;
//用户名
private String username;
//用户操作
private String operation;
//请求方法
private String method;
//请求参数
private String params;
//执行时长(毫秒)
private Long time;
//IP地址
private String ip;
//创建时间
private Date createdTime;
}第二步：创建SysLogDao层
package com.cy.pj.sys.dao;
import com.cy.pj.sys.pojo.SysLog;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface SysLogDao {
int insertObject(SysLog entity);
int deleteObjects(@Param("ids") Integer... ids);
/**
* @param username 查询条件(例如查询哪个用户的日志信息)
* @return 总记录数(基于这个结果可以计算总页数)
*/ //int getRowCount(@Param("username") String username);
/**
* @param username 查询条件(例如查询哪个用户的日志信息)
* @param startIndex 当前页的起始位置
* @param pageSize 当前页的页面大小
* @return 当前页的日志记录信息
* 数据库中每条日志信息封装到一个SysLog对象中
*/
List findPageObjects(String username);
}
//// @Param("startIndex")Integer startIndex,
//// @Param("pageSize")Integer pageSize); 第三步：创建mapper文件映射
insert into sys_logs
(username,operation,method,params,time,ip,createdTime)
values
(#{username},#{operation},#{method},#{params},#{time},#{ip},#{createdTime})
delete from sys_Logs
id in
#{id}
or 1=2
from sys_Logs
username like concat("%",#{username},"%")
第四步：创建service接口及实现类
创建pojo类PageOject类：
package com.cy.pj.common.pojo;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
//借助此对象封装业务逻辑结果
@Data
@NoArgsConstructor
public class PageObject implements Serializable {//类泛型:类名<泛型> 约束类中属性，方法参数以及返回值类型
private static final long serialVersionUID = -3130527491950235344L;
/**当前页的页码值*/
private Integer pageCurrent=1;
/**页面大小*/
private Integer pageSize=3;
/**总行数(通过查询获得)*/
private Integer rowCount=0;
/**总页数(通过计算获得)*/
private Integer pageCount=0;
/**当前页记录*/
private List records;
public PageObject(Integer pageCurrent, Integer pageSize, Integer rowCount, List records) {
this.pageCurrent = pageCurrent;
this.pageSize = pageSize;
this.rowCount = rowCount;
this.pageCount=rowCount/pageSize;
this.records = records;
if(this.rowCount%this.pageSize!=0)this.pageCount++;
}
} 创建SysLogService接口：
package com.cy.pj.sys.servive;
import com.cy.pj.common.pojo.PageObject;
import com.cy.pj.sys.pojo.SysLog;
public interface SysLogService {
void saveObject(SysLog entity);
int deleteObjects(Integer... Ids);
/**
* @param username 基于条件查询时的参数名
* @param pageCurrent 当前的页码值
* @return 当前页记录+分页信息
*/
PageObject findPageObjects(
String username,
Integer pageCurrent);
} 创建SysLogServiceImpl实现类：
package com.cy.pj.sys.servive.impl;
import com.cy.pj.common.annotation.RequiredLog;
import com.cy.pj.common.exception.ServiceException;
import com.cy.pj.sys.dao.SysLogDao;
import com.cy.pj.common.pojo.PageObject;
import com.cy.pj.sys.pojo.SysLog;
import com.cy.pj.sys.servive.SysLogService;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class SysLogServiceImpl implements SysLogService {
@Autowired
private SysLogDao sysLogDao;
@Override
public void saveObject(SysLog entity) {
sysLogDao.insertObject(entity);
}
//@requirespermission注解描述的方法为一个权限切入点方法，当登录用户访问此方法时需要授权。
//那如何检测用户是否有访问此方法的权限？
//第一：获取访问此方法时需要的权限标识："sys:log:delete"
//第二：获取登陆用户拥有的菜单访问的权限标识
//第三：判定用户拥有的权限标识中是否包含访问时需要的授权标识，假如包含则授权访问。
@RequiresPermissions("sys:log:delete")
@RequiredLog("日志删除")
@Override
public int deleteObjects(Integer... ids) {
//1,参数校验
if(ids==null||ids.length==0)
throw new IllegalArgumentException("必须提供正确的id值");
//2，基于id删除日志
int rows=sysLogDao.deleteObjects(ids);
//3，检验结果并返回
if(rows==0)
throw new ServiceException("记录可能已经不存在");
return rows;
}
@RequiredLog("日志查询")
@Override
public PageObject findPageObjects(
String name, Integer pageCurrent) {
//1.验证参数合法性
//1.1验证pageCurrent的合法性，
//不合法抛出IllegalArgumentException异常
if(pageCurrent==null||pageCurrent<1)
throw new IllegalArgumentException("当前页码不正确");
// //2.基于条件查询总记录数
// //2.1) 执行查询
// int rowCount=sysLogDao.getRowCount(name);
// //2.2) 验证查询结果，假如结果为0不再执行如下操作
// if(rowCount==0)
// throw new ServiceException("系统没有查到对应记录");
//3.基于条件查询当前页记录(pageSize定义为2)
//3.1)定义pageSize
int pageSize=5;
Page page=PageHelper.startPage(pageCurrent, pageSize);
//3.2)计算startIndex
// int startIndex=(pageCurrent-1)*pageSize;
//3.3)执行当前数据的查询操作
// List records=
// sysLogDao.findPageObjects(name, startIndex, pageSize);
List records=
sysLogDao.findPageObjects(name);
//4.对分页信息以及当前页记录进行封装
//4.1)构建PageObject对象
PageObject pageObject=new PageObject<>();
//4.2)封装数据
// pageObject.setPageCurrent(pageCurrent);
// pageObject.setPageSize(pageSize);
// pageObject.setRowCount(rowCount);
// pageObject.setRecords(records);
// pageObject.setPageCount((rowCount-1)/pageSize+1);
//5.返回封装结果。
return new PageObject<>(pageCurrent,pageSize,(int)page.getTotal(),records);
}
} 设置自定义异常处理ServiceException：
package com.cy.pj.common.exception;
public class ServiceException extends RuntimeException {
private static final long serialVersionUID = 7793296502722655579L;
public ServiceException() {
super();
}
public ServiceException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
public ServiceException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
}
}第五步：创建Controller类
创建pojo返回值对象JsonResult：
package com.cy.pj.common.pojo;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
//封装服务端响应到客户端的数据
@Data
@NoArgsConstructor
public class JsonResult implements Serializable {
private static final long serialVersionUID = 8518978402852081033L;
//SysResult/Result/R
/**状态码*/
private Integer state=1;//1表示SUCCESS,0表示ERROR
/**状态信息*/
private String message="ok";
/**正确数据*/
private Object data;
public JsonResult(String message){
this.message=message;
}
/**一般查询时调用，封装查询结果*/
public JsonResult(Object data) {
this.data=data;
}
/**出现异常时时调用*/
public JsonResult(Throwable t){
this.state=0;
this.message=t.getMessage();
}
}创建SysLogController：
package com.cy.pj.sys.controller;
import com.cy.pj.common.annotation.RequiredLog;
import com.cy.pj.common.pojo.JsonResult;
import com.cy.pj.common.pojo.PageObject;
import com.cy.pj.sys.pojo.SysLog;
import com.cy.pj.sys.servive.SysLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/log/")
public class SysLogController {
@Autowired
private SysLogService sysLogService;
@RequestMapping("doDeleteObjects")
public JsonResult doDeleteObjects(Integer... ids){
sysLogService.deleteObjects(ids);
return new JsonResult("Delete ok");
}
//在Controller类中添加分页请求处理方法，代码参考如下：
@RequestMapping("doFindPageObjects")
public JsonResult doFindPageObjects(String username, Integer pageCurrent) {
PageObject pageObject =
sysLogService.findPageObjects(username, pageCurrent);
return new JsonResult(pageObject);
}
} 设置全局异常控制：
package com.cy.pj.common.web;
import com.cy.pj.common.pojo.JsonResult;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.ShiroException;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authz.AuthorizationException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
@Slf4j
@ControllerAdvice
public class GlobalExceptionHandler {
//JDK中的自带的日志API
@ExceptionHandler(RuntimeException.class)
@ResponseBody
public JsonResult doHandleRuntimeException(
RuntimeException e){
e.printStackTrace();//也可以写日志
log.error("exception msg {}"+e.getMessage());
//异常信息
return new JsonResult(e);//封装
}
@ExceptionHandler(ShiroException.class)
@ResponseBody
public JsonResult doHandleShiroException(
ShiroException e) {
JsonResult r=new JsonResult();
r.setState(0);
if(e instanceof UnknownAccountException) {
r.setMessage("账户不存在");
}else if(e instanceof LockedAccountException) {
r.setMessage("账户已被禁用");
}else if(e instanceof IncorrectCredentialsException) {
r.setMessage("密码不正确");
}else if(e instanceof AuthorizationException) {
r.setMessage("没有此操作权限");
}else {
r.setMessage("系统维护中");
}
e.printStackTrace();
return r;
}
}
日志管理AOP实现
第一步：自定义注解RequiredLog
package com.cy.pj.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)//定义我们的注解可以修饰谁
@Retention(RetentionPolicy.RUNTIME)//定义我们的注解何时有效
public @interface RequiredLog {
String value() default "";
}第二步：切面类SysLogAspect实现
package com.cy.pj.common.aspect;
import com.cy.pj.common.annotation.RequiredLog;
import com.cy.pj.common.util.IPUtils;
import com.cy.pj.sys.pojo.SysLog;
import com.cy.pj.sys.servive.SysLogService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.util.Date;
/**
* @Aspect 注解描述的对象为一个切面对象,在切面对象中定义
* 1)切入点(Pointcut):织入扩展功能的一些连接点的集合
* 2)通知方法(Advice):封装了扩展逻辑的方法
*/
@Slf4j
@Aspect
@Component
public class SysLogAspect {
//通过Pointcut定义一个切入点,@annotation方式为定义切入点的一种方式,
//在这里表示业务对象中由com.cy.pj.common.annotation.RequiredLog注解描述的方法为一些切入点方法
@Pointcut("@annotation(com.cy.pj.common.annotation.RequiredLog)")
public void doLog(){}//doLog方法仅仅是@Pointcut注解的一个载体,方法体内不需要写任何内容
/**
* @Around 注解描述的方法可以在目标方法执行之前和之后做功能扩展
* @param joinPoint 封装了目标方法信息的一个对象(连接点对象)
* @return 目标方法的执行结果
* @throws Throwable
*/ @Around("doLog()")
public Object doAround(ProceedingJoinPoint joinPoint)throws Throwable{
try {
long t1 = System.currentTimeMillis();
Object result = joinPoint.proceed();//去调用目标方法,其返回值为目标方法返回值
long t2 = System.currentTimeMillis();
System.out.println("time:" + (t2 - t1));
//将正常的用户行为日志写入到数据库
saveSysLog(joinPoint, (t2 - t1));
return result;
}catch(Throwable e){
//saveErrorLog(...);也可以将错误日志写入到数据库
logError(joinPoint,e.getMessage());
throw e;
}
}
//将错误日志进行输出并记录
private void logError(ProceedingJoinPoint joinPoint,String exceptionMsg) throws JsonProcessingException {
String targetClassName=joinPoint.getTarget().getClass().getName();
String methodName=joinPoint.getSignature().getName();
String params=new ObjectMapper().writeValueAsString(joinPoint.getArgs());
log.error("error.msg->{}->{}->{}",targetClassName+"."+methodName,params,exceptionMsg);
}
@Autowired
private SysLogService sysLogService;
private void saveSysLog(ProceedingJoinPoint joinPoint,long time) throws NoSuchMethodException, JsonProcessingException {
//1.获取用户行为日志
//获取目标对象类型
Class targetClass=joinPoint.getTarget().getClass();
//获取目标方法的签名信息
MethodSignature ms=(MethodSignature) joinPoint.getSignature();
//获取目标方法?(类中方法的唯一标识是什么:方法名+参数列表)
Method targetMethod=targetClass.getDeclaredMethod(ms.getName(),ms.getParameterTypes());
//获得RequiredLog
RequiredLog requiredLog=targetMethod.getAnnotation(RequiredLog.class);
//获取操作名(RequiredLog中operation的值)
String operation= requiredLog.value();
//2.封装日志信息
SysLog entity=new SysLog();
entity.setUsername("cgb");//将来这个位置为登录用户名
entity.setIp(IPUtils.getIpAddr());
entity.setOperation(operation);//为目标方法指定的一个名字
entity.setMethod(targetClass.getName()+"."+targetMethod.getName());//类全名+方法名
//entity.setParams(Arrays.toString(joinPoint.getArgs()));//调用方法时传递实际参数
entity.setParams(new ObjectMapper().writeValueAsString(joinPoint.getArgs()));
entity.setTime(time);
entity.setCreatedTime(new Date());
//3.保存用户行为值
//sysLogService.saveObject(entity);
//异步写日志(自己new thread,借助池中线程,但非tomcat线程池中线程)
new Thread(){//1M
@Override
public void run() {
sysLogService.saveObject(entity);
}
}.start();
}
}原理分析：