基于AOP的日志调试

时间：2023-01-14 08:18:20 其他范文收藏本文下载本文

下面是小编帮大家整理的基于AOP的日志调试，本文共9篇，希望对大家的学习与工作有所帮助。

基于AOP的日志调试

篇1：基于AOP的日志调试

public class LoggingInterceptor implements MethodInterceptor { @Override public Object invoke(MethodInvocation invocation) throws Throwable { try { Object result = invocation.proceed; // logging 方法, 参数与返回值 log(invocation.getMethod(), invocation.getArguments(), result); return result; } catch (Throwable throwable) { // logging 方法, 参数与异常 error(invocation.getMethod(), invocation.getArguments(), throwable); throw throwable; } }}

接下来, 我们需要配置这个 , 并向Guice声明它.

public class LoggingModule extends AbstractModule { @Override public void configure() { bindInterceptor(Matchers.any(), Matchers.any(), new LoggingInterceptor()); }}public class Main { public static void main(String[] args) { Injector injector = Guice.createInjector(new BusinessModule(), new LoggingModule()); }}

很简单, 不是吗? 这样我们的业务模块的代码完全不用编写输出日志的代码, 只需要在创建Injector的时候加入LoggingModule就可以了.

等等, 好像忘了去实现如何配置日志输出的位置. 好吧, 这个其实很简单:

篇2：基于AOP的日志调试

还是以用正则表达式匹配要Logging的方法为例:

public class LoggingInterceptor implements MethodInterceptor { private String regex = “*”; public void setMethodRegex(String regex){ this.regex = regex; } @Override public Object invoke(MethodInvocation invocation) throws Throwable { String methodName = invocation.getMethod().getName(); try { Object result = invocation.proceed(); if (methodName.matches(regex)) // logging 方法, 参数与返回值 log(invocation.getMethod(), invocation.getArguments(), result); return result; } catch (Throwable throwable) { if (methodName.matches(regex)) // logging 方法, 参数与异常 error(invocation.getMethod(), invocation.getArguments(), throwable); throw throwable; } }}

而后可借助JMX动态调整regex的值, 来实现运行时的配置. 当然, 肯定还会有其它更好的方法, 如果你知道了不妨分享一下.

小结

本文仅以Guice为例讨论如何改进我们日常开发中调试的问题, 其实这在Spring应用也同样能够实现的, 甚至其它应用AOP的场景都是可行的.

拓展开来, 不仅是Logging, 说不定验证(测试)也是可行的呢!

有句话不是这样说的吗, “思想有多远, 我们就能走多远!”

篇3：基于AOP的日志调试

bindInterceptor(Matchers.any, Matchers.any(), new LoggingInterceptor());

bindInterceptor方法的第一个参数定义了将匹配所有类, 第二个参数定义了将匹配一个类所有方法. 那么, 我们要做的仅仅是通过外部参数调整这两个参数就可以啦. 这儿就演示一个用正则表达式匹配要Logging的方法的例子:

public class MethodRegexMatcher extends AbstractMatcher{ private final Pattern pattern = Pattern.compile(System.getProperty(“logging.method.regex”, “*”)); @Override public boolean matches(Method method) { return pattern.matcher(method.getName()).matches(); }}

可惜这种方法不能在运行时调整, 但这也是可以实现的.

篇4：Spring Aop 日志拦截应用

近期，一个小伙伴遇到了此需求，要解决的问题就是：

记录用户在系统的操作，通过注解来灵活控制。注解可以对方法进行修饰，描述。后面会将注解上描述以及方法被调用时入参记录到数据库。同时还需要对不同的操作进行分类（插入，修改，查看，下载/上传文件之类的），记录用户，时间以及IP，客户端User-agent . 我在这里将部分实现写了出来，实际在项目中可以直接参照进行修改就可以满足以上功能。

开发环境：W7 + Tomcat7 + jdk1.7 + Mysql5

框架：spring,springmvc,hibernate

于是乎，下班后动手写了个小demo,主要使用注解实现，思路如下：

1.打算在service 层切入，所以在springmvc配置文件中排除对service层的扫描

2.在spring配置文件中扫描没有被springmvc扫描的service层，aop对其增强

3.实现注解，注解要能满足记录【方法描述，参数描述，操作类型】等等

4.对拦截到的方法进行统一处理，持久化日志

代码结构图：

1.springmvc-servlet.xml配置

2.spring配置文件中扫描service层,还有其他几个配置文件相关性不大，可以下载项目后查看。这里不再贴出

3.Aop拦截处理，以及注解实现部分

/*** 文件名：Operation.java* 版权：Copyright - BuyanTech.All Rights Reserved.* 描述: * 修改人：Bill* 修改时间：2014/11/03* 修改内容：无*/package com.billstudy.springaop.log.annotation;import java.lang.annotation.Documented;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;import com.billstudy.springaop.log.enums.OperationType;/** * @Descrption该注解描述方法的操作类型和方法的参数意义 */@Target(value = ElementType.METHOD)@Retention(value = RetentionPolicy.RUNTIME)@Documentedpublic @interface Operation { /** * @Description描述操作类型,参见{@linkOperationType ,为必填项 */ OperationType type(); /** * @Description描述操作意义,比如申报通过或者不通过等 */ String desc() default ; /** * @Description描述操作方法的参数意义,数组长度需与参数长度一致,否则无效 */ String[] arguDesc() default {};}

package com.billstudy.springaop.log.aspect;import java.lang.reflect.Method;import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;import javax.servlet.http.HttpServletRequest;import org.apache.log4j.Logger;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 com.billstudy.springaop.log.annotation.Operation;import com.billstudy.springaop.log.operationlog.model.Operationlog;import com.billstudy.springaop.log.operationlog.service.OperationlogManager;/** * 使用注解,aop 实现日志的打印以及保存至数据库。 * @author Bill * @since V.10 4月16日 - 下午8:40:20 */@Aspectpublic class OperationLogAspect { @Autowired private OperationlogManager operationlogManager; @Autowired private HttpServletRequest request; private static final Logger logger = Logger.getLogger(OperationLogAspect.class); private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat(yyyy-MM-dd HH:mm:ss); @Pointcut(@annotation(com.billstudy.springaop.log.annotation.Operation)) public void anyMethod() {} @Around(anyMethod()) public Object doBasicProfiling(ProceedingJoinPoint jp)throws Throwable{ System.err.println(doBasicProfiling...); // 获取签名 MethodSignature signature = (MethodSignature) jp.getSignature(); Method method = signature.getMethod(); // 记录日志 Operation annotation = method.getAnnotation(Operation.class); // 解析参数 Object[] bjParam = jp.getArgs(); String[] arguDesc = annotation.arguDesc(); Object result = null; if(objParam.length == arguDesc.length){// 抽取出方法描述： String paramDesc = extractParam(objParam,arguDesc);System.out.println(paramDesc); // 记录时间 Operationlog log = new Operationlog(); Date sDate = Calendar.getInstance().getTime();String requestStartDesc = 执行开始时间为：+SIMPLE_DATE_FORMAT.format(sDate)+; logger.info(requestStartDesc); System.out.println(M入方法前); result = jp.proceed(); System.out.println(M入方法后); Date eDate = Calendar.getInstance().getTime(); long time = eDate.getTime()-sDate.getTime(); String requestEndDesc = 执行完成时间为：+SIMPLE_DATE_FORMAT.format(eDate)+,本次用时：+time+毫秒！; logger.info(执行完成时间为：+SIMPLE_DATE_FORMAT.format(eDate)+,本次用时：+time+毫秒！);log.setLogCreateTime(sDate); log.setLogDesc(annotation.desc()+ 用时/+requestStartDesc + , + requestEndDesc); log.setLogResult(result+); log.setLogType(annotation.type()+); log.setLogParam(paramDesc);operationlogManager.save(log); logger.info(log.toJsonString()); }else{ result = jp.proceed(); String methodName = signature.getName(); String className = jp.getThis().getClass().getName(); className = className.substring(0, className.indexOf($$)); // 截取掉cglib代理类标志 String errorMsg = 警告：+methodName+ 方法记录日志失败，注解[arguDesc]参数长度与方法实际长度不一致，需要参数+objParam.length+个，实际为+arguDesc.length+个，请检查+className+:+methodName+注解！; logger.warn(errorMsg); System.err.println(errorMsg); } return result; } /** * 根据注解参数以及方法实参拼接出方法描述 * @param objParam * @param arguDesc * @return */ private String extractParam(Object[] objParam, String[] arguDesc) { StringBuilder paramSb = new StringBuilder(); int size = objParam.length-1; for (int i = 0; i < arguDesc.length; i++) { paramSb.append(arguDesc[i]+:+objParam[i]+(i==size?:,)); } return paramSb.toString(); } }

/*** 文件名：OperationType.java* 版权：Copyright 2014-2015 BuyanTech.All Rights Reserved.* 描述: * 修改人：Bill* 修改时间：2014/11/03* 修改内容：无*/package com.billstudy.springaop.log.enums;import java.util.ArrayList;import java.util.Arrays;import java.util.List;public enum OperationType { /** * 新增，添加 */ ADD(新增), /** * 修改，更新 */ UPDATE(修改), /** * 删除 */ DELETE(删除), /** * 下载 */ DOWNLOAD(下载), /** * 查询 */ QUERY(查询), /** * 登入 */ LOGIN(登入), /** * 登出 */ LOGOUT(登出); private String name; private OperationType() { } public String getName() { return name; } private OperationType(String name) { this.name = name; } /** * 获取所有的枚举集合 * @return */ public static ListgetOperationTypes() { return new ArrayList(Arrays.asList(OperationType .values())); } public static void main(String[] args) { System.out.println(Arrays.toString(OperationType.values())); }}

Person/OperationLog类以及数据库脚本：

/*** 文件名：Operationlog.java* 版权：Copyright 2014-2015 BuyanTech.All Rights Reserved.* 描述: * 修改人：Bill* 修改时间：2014/11/03* 修改内容：无*/package com.billstudy.springaop.log.operationlog.model;import javacommon.base.BaseEntity;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.Table;import javax.persistence.Transient;import org.apache.commons.lang.builder.EqualsBuilder;import org.apache.commons.lang.builder.HashCodeBuilder;import org.apache.commons.lang.builder.ToStringBuilder;import org.apache.commons.lang.builder.ToStringStyle;import org.hibernate.annotations.GenericGenerator;import org.hibernate.validator.constraints.Length;import cn.org.rapid_framework.util.DateConvertUtils;/** * @author Bill * @version 1.0 * @date 2014 */@Entity@Table(name = operationlog)public class Operationlog extends BaseEntity implements java.io.Serializable { private static final long serialVersionUID = 5454155825314635342L; // alias public static final String TABLE_ALIAS = 系统日志; public static final String ALIAS_LOG_ID = 日志主键; public static final String ALIAS_LOG_USER_ID = 用户编号; public static final String ALIAS_LOG_USER_NAME = 用户名; public static final String ALIAS_LOG_IP = 用户IP; public static final String ALIAS_LOG_PARAM = 操作参数; public static final String ALIAS_LOG_DESC = 操作描述; public static final String ALIAS_LOG_CREATE_TIME = 操作日期; public static final String ALIAS_LOG_LOGTYPE = 操作类型; public static final String ALIAS_LOG_RESULT = 执行结果; // date formats public static final String FORMAT_LOG_CREATE_TIME = DATE_TIME_FORMAT; // 可以直接使用: @Length(max=50,message=用户名长度不能大于50)显示错误消息 // columns START /** * 日志主键 db_column: logId */ // private String _id; private java.lang.Integer logId; /** * 用户编号 db_column: logUserId */ @Length(max = 255) private java.lang.String logUserId; /** * 用户名 db_column: logUserName */ @Length(max = 255) private java.lang.String logUserName; /** * 用户IP db_column: logIp */ @Length(max = 255) private java.lang.String logIp; /** * 操作参数 db_column: logParam */ @Length(max = 255) private java.lang.String logParam; /** * 操作描述 db_column: logDesc */ @Length(max = 255) private java.lang.String logDesc; /** * 操作日期 db_column: logCreateTime */ private String logType; private java.util.Date logCreateTime; private String logResult; // private // columns END public Operationlog() { } /* * public Operationlog( java.lang.Integer logId ){ this.logId = logId; } * * * * public void setLogId(java.lang.Integer value) { this.logId = value; } */ /* * @Id * * @GeneratedValue(generator = uuid-id) * * @GenericGenerator(name = uuid-id, strategy = uuid) * * @Column(name = _id, unique = true, nullable = false, insertable = true, * updatable = true, length = 128) public String get_id() { return _id; } * * public void set_id(String _id) { this._id = _id; } */ @Id @GeneratedValue(generator = paymentableGenerator) @GenericGenerator(name = paymentableGenerator, strategy = increment) @Column(name = logId, unique = true, nullable = false, insertable = true, updatable = true, length = 10) public java.lang.Integer getLogId() { return this.logId; } public String getLogType() { return logType; } public void setLogId(java.lang.Integer logId) { this.logId = logId; } public void setLogType(String logType) { this.logType = logType; } @Column(name = logUserId, unique = false, nullable = true, insertable = true, updatable = true, length = 255) public java.lang.String getLogUserId() { return this.logUserId; } public void setLogUserId(java.lang.String value) { this.logUserId = value; } @Column(name = logUserName, unique = false, nullable = true, insertable = true, updatable = true, length = 255) public java.lang.String getLogUserName() { return this.logUserName; } public void setLogUserName(java.lang.String value) { this.logUserName = value; } @Column(name = logIp, unique = false, nullable = true, insertable = true, updatable = true, length = 255) public java.lang.String getLogIp() { return this.logIp; } public void setLogIp(java.lang.String value) { this.logIp = value; } @Column(name = logParam, unique = false, nullable = true, insertable = true, updatable = true, length = 65535) public java.lang.String getLogParam() { return this.logParam; } public void setLogParam(java.lang.String value) { this.logParam = value; } @Column(name = logDesc, unique = false, nullable = true, insertable = true, updatable = true, length = 65535) public java.lang.String getLogDesc() { return this.logDesc; } public void setLogDesc(java.lang.String value) { this.logDesc = value; } @Transient public String getLogCreateTimeString() { return DateConvertUtils.format(getLogCreateTime(), FORMAT_LOG_CREATE_TIME); } public void setLogCreateTimeString(String value) { setLogCreateTime(DateConvertUtils.parse(value, FORMAT_LOG_CREATE_TIME, java.util.Date.class)); } @Column(name = logCreateTime, unique = false, nullable = true, insertable = true, updatable = true, length = 0) public java.util.Date getLogCreateTime() { return this.logCreateTime; } public void setLogCreateTime(java.util.Date value) { this.logCreateTime = value; } @Column(name = logResult, unique = false, nullable = true, insertable = true, updatable = true, length = 65535) public String getLogResult() { return logResult; } public void setLogResult(String logResult) { this.logResult = logResult; } public String toString() { return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE) .append(LogId,getLogId()) .append(LogUserId, getLogUserId()) .append(LogUserName, getLogUserName()) .append(LogIp, getLogIp()).append(LogParam, getLogParam()) .append(LogDesc, getLogDesc()) .append(LogDesc, getLogResult()) .append(LogCreateTime, getLogCreateTime()).toString(); } public String toJsonString() { return new StringBuilder({) .append(logId:).append(getLogId()+,) .append(logUserId:).append(getLogUserId() + ,) .append(logUserName:).append(getLogUserName() + ,) .append(logIp:).append(getLogIp() + ,) .append(logParam:).append(getLogParam() + ,) .append(logDesc:).append(getLogDesc() + ,) .append(logCreateTime:) .append(getLogCreateTime() + ,).append(}).toString(); } public int hashCode() { return new HashCodeBuilder() // .append(getLogId()) .append(getLogId()).toHashCode(); } public boolean equals(Object obj) { if (obj instanceof perationlog == false) return false; if (this == obj) return true; Operationlog ther = (Operationlog) obj; return new EqualsBuilder() // .append(getLogId(),other.getLogId()) .append(getLogId(), other.getLogId()).isEquals(); }}

package com.billstudy.springaop.model;import java.io.Serializable;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.Table;import javacommon.base.BaseEntity;import org.hibernate.annotations.GenericGenerator;import org.hibernate.validator.constraints.Length;/** * Person model * * @author Bill * @since V.10 204月16日 - 下午7:57:22 */@Entity@Table(name = person)public class Person extends BaseEntity implements Serializable { private static final long serialVersionUID = 7340067893523769892L; @Length(max = 255) private int id; @Length(max = 255) private String name; @Length(max = 255) private Integer age; @Length(max = 255) private String address; @Id @GeneratedValue(generator = paymentableGenerator) @GenericGenerator(name = paymentableGenerator, strategy = increment) @Column(name = id, unique = true, nullable = false, insertable = true, updatable = true, length = 10) public int getId() { return id; } public void setId(int id) { this.id = id; } @Column(name = name, unique = false, nullable = true, insertable = true, updatable = true, length = 255) public String getName() { return name; } public void setName(String name) { this.name = name; } @Column(name = age, unique = false, nullable = true, insertable = true, updatable = true, length = 255) public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } @Column(name = address, unique = false, nullable = true, insertable = true, updatable = true, length = 255) public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } @Override public String toString() { return Person [id= + id + , name= + name + , age= + age + , address= + address + ]; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((address == null) ? 0 : address.hashCode()); result = prime * result + ((age == null) ? 0 : age.hashCode()); result = prime * result + id; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person ther = (Person) obj; if (address == null) { if (other.address != null) return false; } else if (!address.equals(other.address)) return false; if (age == null) { if (other.age != null) return false; } else if (!age.equals(other.age)) return false; if (id != other.id) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } public Person(String name, Integer age, String address) { super(); this.name = name; this.age = age; this.address = address; } public Person() { // TODO Auto-generated constructor stub } }

CREATE TABLE `person` ( `id` int(255) NOT NULL AUTO_INCREMENT, `name` varchar(255) DEFAULT NULL, `address` varchar(255) DEFAULT NULL, `age` int(255) DEFAULT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

CREATE TABLE `operationlog` ( `logId` int(11) NOT NULL AUTO_INCREMENT COMMENT '日志主键', `logUserId` varchar(255) DEFAULT NULL COMMENT '用户编号', `logUserName` varchar(255) DEFAULT NULL COMMENT '用户名', `logIp` varchar(255) DEFAULT NULL COMMENT '用户IP', `logParam` text COMMENT '操作参数', `logDesc` text COMMENT '操作描述', `logResult` text COMMENT '操作结果', `logType` varchar(255) DEFAULT NULL COMMENT '操作类型', `logCreateTime` datetime DEFAULT NULL COMMENT '操作日期', PRIMARY KEY (`logId`)) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

最后再配置下切面处理类，因为该类部分属性需要从Spring中获取，

我在PersonController里面写了2个方法用做测试，insert / find

package com.billstudy.springaop.controller;import java.io.IOException;import javacommon.base.BaseSpringController;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import com.billstudy.springaop.log.enums.OperationType;import com.billstudy.springaop.model.Person;import com.billstudy.springaop.service.PersonManager;/** * AOP Controller * @author Bill * @since V.10 2015年4月16日 - 下午7:52:11 */@Controllerpublic class PersonController extends BaseSpringController{ @Autowired private PersonManager personManager; /** * Test insert * @since V.10 2015年4月16日 - 下午7:53:18 * @param request * @param response * @throws IOException */ public void insert(HttpServletRequest request,HttpServletResponse response) throws IOException{ /** * 执行描述： * 方法执行到这里时，不会立即进入到save方法 * 而是会进入到 com.billstudy.springaop.log.aspect.OperationLogAspect.doBasicProfiling(ProceedingJoinPoint) * 进行预处理，然后调用proceed方法时才会进入 **/ // 对应的注解：arguDesc={person,姓名,年龄},type=OperationType.ADD,desc=保存 personManager.save(new Person(飞机,10,上海),念念,200); System.out.println(insert...); response.getWriter().print(success); } /** * Test find * @since V.10 2015年4月16日 - 下午7:53:18 * @param request * @param response * @throws IOException */ public void find(HttpServletRequest request,HttpServletResponse response) throws IOException{ // 对应的注解：arguDesc={用户编号},type=OperationType.QUERY,desc=查 Person person = personManager.findById(Integer.parseInt(request.getParameter(id))); System.out.println(find...); response.setContentType(text/html;charset=UTF-8); response.getWriter().print(person.toString()); } }

开启测试模式：

1.直接请求insert方法:

浏览器request to :bill/SpringAopLogDemo/Person/insert.do

好了，下面放开断点了。看看控制台输出，以及数据库日志记录.

控制台：

数据库：

好了，问题到这里就差不多了。关于AOP 相关理论，请自行查阅文档学习噢。这里不描述了，忙着搞别的去了。哈哈。

篇5：关于面试Spring aop

AOP(Aspect-OrientedProgramming)其实是OOP(Object-OrientedPrograming)

思想的补充和完善。我们知道，OOP引进“抽象”、“封装”、“继承”、“多态”等概念,对万事万物进行抽象和封装，来建立一种对象的层次结构，它强调了

一种完整事物的自上而下的关系。但是具体细粒度到每个事物内部的情况，OOP就显得无能为力了。比如日志功能。日志代码往往水平地散布在所有对象层次当

中，却与它所散布到的对象的核心功能毫无关系。对于其他很多类似功能，如事务管理、权限控制等也是如此。这导致了大量代码的重复，而不利于各个模块的重

用。而AOP技

术则恰恰相反，它利用一种称为“横切”的技术，能够剖解开封装的对象内部，并将那些影响了多个类并且与具体业务无关的公共行为封装成一个独立的模块(称

为切面)。更重要的是，它又能以巧夺天功的妙手将这些剖开的切面复原，不留痕迹的融入核心业务逻辑中。这样，对于日后横切功能的编辑和重用都能够带来极大

的方便。AOP技术的具体实现，无非也就是通过动态代理技术或者是在程序编译期间进行静态的“织入”方式。下面是这方面技术的几个基本术语：1、joinpoint(连接点)：是程序执行中的一个精确执行点，例如类中的一个方法。它是一个抽象的概念，在实现AOP时，并不需要去定义一个joinpoint。2、pointcut(切入点)：本质上是一个捕获连接点的结构。在AOP中，可以定义一个pointcut，来捕获相关方法的调用。3、advice(通知)：是pointcut的执行代码，是执行“方面”的具体逻辑。4、aspect(方面)：pointcut和advice结合起来就是aspect，它类似于OOP中定义的一个类，但它代表的更多是对象间横向的关系。5、introduce(引入)：为对象引入附加的方法或属性，从而达到修改对象结构的目的。有的OP工具又将其称为mixin。

所有AOP技术基本上都是基于以上这些概念实现的。

太抽象了，还是赶快上例子吧。下面，我写了一个用springAOP实现的记录方法调用的日志功能的应用实例：目的是记录系统登录功能的执行情况，技术框架简单采用Spring+Struts。

1.登录页面：

username:

password:

2.表单类：

/**

[描述信息：登陆表单类]

* @author bruce.yang

* @version 1.0 Created on -8-13 下午2:04:09

publicclassLoginActionFormextendsActionForm {

privateString username;

privateString password;

//setter,getter方法

}

3.Action类：

/**

[描述信息：登陆Action]

* @author bruce.yang

* @version 1.0 Created on 2013-8-13 下午2:04:38

publicclassLoginActionextendsAction {

privateILoginService loginService;

@Override

publicActionForward execute(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse response)

throws Exception {

LoginActionForm laf = (LoginActionForm) form;

Stringusername = laf.getUsername;

Stringpassword = laf.getPassword();

boolean ret = loginService.login(username, password);

if(ret) {

returnmapping.findForward(“success”);

}

returnmapping.findForward(“fail”);

}

//loginService的setter,getter方法

}

4.service层接口：

publicinterfaceILoginService {

publicboolean login(StringuserName,Stringpassword);

}

publicinterfaceILogService {

publicvoidlog();

publicvoidlogArg(JoinPoint point);

publicvoidlogArgAndReturn(JoinPoint point,ObjectreturnObj);

}

5.service层实现类：

/**

[描述信息：登录Service类]

* @author bruce.yang

* @version 1.0 Created on 2013-8-13 下午1:45:32

publicclassLoginServiceImplimplementsILoginService {

/**

功能实现描述:登录处理逻辑(这里是假实现)

* @see com.bruceyang.login.service.ILoginService#login(java.lang.String, java.lang.String)

* @author: bruce.yang

* @date: Created on 2013-8-13 下午1:45:32

publicbooleanlogin(String userName, String password) {

StringBuffer sb=newStringBuffer();

sb.append(“Target:”).append(“login:”).append(userName).append(“,”).append(password);

System.out.println(sb.toString());

returntrue;

}

/**

[描述信息：操作日志记录Service]

* @author bruce.yang

* @version 1.0 Created on 2013-8-13 下午1:45:32

publicclassLogServiceImplimplementsILogService {

/**

功能实现描述:最简单的情况

* @see com.bruceyang.login.service.ILogService#log()

* @author: bruce.yang

* @date: Created on 2013-8-13 下午1:46:17

publicvoidlog() {

System.out.println(newSimpleDateFormat(“yyyy-MM-dd HH:mm:ss”).format(newDate())+“ *******Log*********”);

}

/**

功能实现描述:有参无返回值的方法

* @see com.bruceyang.login.service.ILogService#logArg(org.aspectj.lang.JoinPoint)

* @author: bruce.yang

* @date: Created on 2013-8-13 下午1:43:43

publicvoidlogArg(JoinPoint point) {

StringBuffer sb=newStringBuffer();

//获取连接点所在的目标对象

Object obj=point.getTarget();

//获取连接点的方法签名对象

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

//获取连接点方法运行时的入参列表

Object[] args = point.getArgs();

sb.append(newSimpleDateFormat(“yyyy-MM-dd HH:mm:ss”).format(newDate())).append(“ ”);

sb.append(obj.toString().substring(0,obj.toString().indexOf('@')));

sb.append(“.”).append(method).append(“ ”);

sb.append(“Args:[”);

if(args !=null) {

for(inti=0;i

Object o=args[i];

sb.append(o);

if(i

sb.append(“,”);

}

sb.append(“]”);

System.out.println(sb.toString());

}

/**

功能实现描述:有参并有返回值的方法

* @see com.bruceyang.login.service.ILogService#logArgAndReturn(org.aspectj.lang.JoinPoint, java.lang.Object)

* @author: bruce.yang

* @date: Created on 2013-8-13 下午1:43:17

publicvoidlogArgAndReturn(JoinPoint point, Object returnObj) {

StringBuffer sb=newStringBuffer();

//获取连接点所在的目标对象

Object obj=point.getTarget();

//获取连接点的方法签名对象

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

//获取连接点方法运行时的入参列表

Object[] args = point.getArgs();

sb.append(newSimpleDateFormat(“yyyy-MM-dd HH:mm:ss”).format(newDate())).append(“ ”);

sb.append(obj.toString().substring(0,obj.toString().indexOf('@')));

sb.append(“.”).append(method).append(“ ”);

sb.append(“Args:[”);

if(args !=null) {

for(inti=0;i

Object o=args[i];

sb.append(o);

if(i

sb.append(“,”);

}

sb.append(“]”).append(“ ”);

sb.append(“Ret:[”).append(returnObj).append(“]”);

System.out.println(sb.toString());

}

6.web.xml：

contextConfigLocation

classpath:config/spring/app*.xml

org.springframework.web.context.ContextLoaderListener

action

org.apache.struts.action.ActionServlet

config

/config/struts/struts-config.xml

debug

detail

action

*.do

7.spring配置信息：

applicationContext.xml：

xsi:schemaLocation=“www.springframework.org/schema/beans

[关于面试Spring aop]

篇6：移动端调试使用日志定位

window.onload = function(){ nerror=handleErr11111111; var txt=”“; function handleErr11111111(msg,url,l){ txt=”本页中存在错误，

移动端调试使用日志定位

，\n\n“ txt+=”错误：“ + msg + ”\n“ // txt+=”URL: “ + url + ”\n“ txt+=”行：“ + l + ”\n\n“ txt+=”点击“确定”继续。\n\n“ alert(txt) return true } // f243 var box = documnt.getElementByd('boxx'); alert(box)}

篇7：AOP 那点事儿（续集）

在上篇中，我们从写死代码，到使用代理；从编程式 Spring AOP 到声明式 Spring AOP，一切都朝着简单实用主义的方向在发展。沿着 Spring AOP 的方向，Rod Johnson（老罗）花了不少心思，都是为了让我们使用 Spring 框架时不会感受到麻烦，但事实却并非如此。那么，后来老罗究竟对 Spring AOP 做了哪些改进呢？

现在继续！

9. Spring AOP：切面

之前谈到的 AOP 框架其实可以将它理解为一个框架，但这个似乎非常武断。比如说，如果它拦截了一个类，那么它就拦截了这个类中所有的方法。类似地，当我们在使用动态代理的时候，其实也遇到了这个问题。需要在代码中对所拦截的方法名加以判断，才能过滤出我们需要拦截的方法，想想这种做法确实不太优雅。在大量的真实项目中，似乎我们只需要拦截特定的方法就行了，没必要拦截所有的方法。于是，老罗同志借助了 AOP 的一个很重要的工具，Advisor（切面），来解决这个问题。它也是 AOP 中的核心！是我们关注的重点！

也就是说，我们可以通过切面，将增强类与拦截匹配条件组合在一起，然后将这个切面配置到 ProxyFactory 中，从而生成代理。

这里提到这个“拦截匹配条件”在 AOP 中就叫做 Pointcut（切点），其实说白了就是一个基于表达式的拦截条件罢了。

归纳一下，Advisor（切面）封装了 Advice（增强）与 Pointcut（切点）。当您理解了这句话后，就往下看吧。

我在 GreetingImpl 类中故意增加了两个方法，都以“good”开头。下面要做的就是拦截这两个新增的方法，而对 sayHello 方法不作拦截。

@Componentpublic class GreetingImpl implements Greeting { @Override public void sayHello(String name) { System.out.println(”Hello! “ + name); } public void goodMorning(String name) { System.out.println(”Good Morning! “ + name); } public void goodNight(String name) { System.out.println(”Good Night! " + name); }}

在 Spring AOP 中，老罗已经给我们提供了许多切面类了，这些切面类我个人感觉最好用的就是基于正则表达式的切面类，

看看您就明白了：

使用元素来进行 AOP 配置，在其子元素中配置切面，包括增强类型、目标方法、切点等信息。

无论您是不能使用注解，还是不愿意使用注解，Spring AOP 都能为您提供全方位的服务。

好了，我所知道的比较实用的 AOP 技术都在这里了，当然还有一些更为高级的特性，由于个人精力有限，这里就不再深入了。

还是依照惯例，给一张牛逼的高清思维导图，总结一下以上各个知识点：

再来一张表格，总结一下各类增强类型所对应的解决方案：

增强类型基于 AOP 接口基于 @Aspect基于Before Advice（前置增强）MethodBeforeAdvice@BeforeAfterAdvice（后置增强）AfterReturningAdvice@AfterAroundAdvice（环绕增强）MethodInterceptor@AroundThrowsAdvice（抛出增强ThrowsAdvice@AfterThrowingIntroductionAdvice（引入增强）DelegatingIntroductionInterceptor@DeclareParents

最后给一张 UML 类图描述一下 Spring AOP 的整体架构：

篇8：调试工作总结

调试工作总结

试工作总结

时间如梭，转眼间调试过程即将结束，回望，这段轰轰烈烈的过程虽然取得了一些成果，但也经历了一段不平凡的考验和磨砺。非常感谢公司给我这个成长的平台，令我在工作中不断的学习，不段的进步，慢慢的提升自身的素质与才能，

回首，我跨进公司这段时间里，这段时间对我来说很重要，可以说是我走过人生很重要的一个阶段，使我学到了很多工作经验，这些日子里领导和同事对我的支持与关爱，令我受用别致，在此我向公司的领导以及全体同事表示最衷心的感谢，有你们的协助才能使我在工作中更加的得心应手，在工作上，围绕中心工作，严以律己，较好的完成各项工作任务。

在工作态度上，能遵章守纪、团结同事、务真求实、乐观上进，始终保持严谨认真的工作态度和一丝不苟，勤勤恳恳，任劳任怨。在生活中发扬艰苦朴素、勤俭耐劳、乐于助人，老老实实做人，勤恳做事，简朴的生活，严格要求自己。

今后努力的方向：随公司各项制度的实行，可以预料我们的工作将更加繁重，要求也更高，需掌握的知识也更高更广。为此，我将更加勤奋的工作，刻苦的学习，努力提高文化素质和各种工作技能，为公司做出应有的贡献。在这调试过程中，作为一个运营管理者，首先提高自身的整体素质，树立起开拓创新、务实高效的形象。我充分认识到自己既是一个管理者，更是一个执行者。要想管理好这项运营工作，除了熟悉业务外，首先要以身作则，这样才能保证设备安全运营。总之，这次TCN的调试，在领导的支持、帮助下，在工程技术专家、前辈的培养下，我在不同的工作岗位上取得了一定的成绩。成绩已成为过去，我面临的是来自新世纪、新技术、新问题的挑战。面对挑战，我深深地认识到自己的不足，差距很大。我必须一如既往地努力学习、勤奋工作，不断地增长知识，提高能力，为企业的发展尽自己的力量。

我自从进入本公司参加此项工作以来，一直从事一线电工工作，主要从以下几个方面来总结：

一、在工作中，坚持谦虚、踏实、勤奋的工作准则，积累了较丰富的实践经验，取得了一定的工作成绩，得到了同事、领导认可。在此期间，完成了全过程多类工业、民用项目电气工程安装、调试、系统启动运行等工作，编写了大量的调试运营表格、调试方案、系统试运行方案，对施工、安装过程中的技术管理、生产管理有了较全面、系统的了解。多年在施工一线的辛勤工作，从广度和深度上很大地拓展了自己的专业技术知识、提高了管理能力。

二、强化理论和业务学习，不断提高自身综合素质

我重视加强理论和业务学习，在工作中，坚持一边工作一边学习，不断提高自身综合素质水平。

1.认真学习相关理论和简单经验，有效快速的完成运营程序。

2.是认真学习工作业务，在学习方法上做到在重点中找重点，抓住重点，并结合自己在这些知识方面存在哪些不足之处，有针对性地进行学习，不断提高自己的办公室业务工作能力。

3.认真学习公司文件及专业技术程序文件等，结合自己工作实际，逐条应用。通过学习，进一步扎实专业知识和实际应用方法。

三、努力工作，安全生产

1、提高职工安全用电意识，增强职工责任心。

2、落实完善安全用电组织体系，健全安全管理规章制度。

3、加强班组用电安全管理，巩固安全基础。

4、确保用电者要确保自身安全和他人安全。

5、在自己平凡而普通的工作岗位上，努力做好本职工作。在具体工作中，当好领导的助手。

6.认真收集各项信息资料，全面、准确地了解和掌握各方面工作，分析工作存在的主要问题，总结工作经验。

7.及时向领导汇报，让领导尽量能全面、准确地了解和掌握最近工作的实际情况，为解决问题作出正确的理由。

8.在对外业的工作中，坚持按照工作要求，积极沟通、认真听取要求，围绕安全第一、质量第一、效益第一为中心。

四、培训学习方面

进场以来，我积极参加各种学习和培训，努力学习电工知识基本知训，供电系统知识，线路装置，照明装置，接地装置，变压器的运行和维护，电动机维修和维护，机床电气控制线路，plc控制等有关知识体系。每次学习，我都学到一些新的理论，并用来指导工作实践，运用到工作中来，对工厂的供电系统，控制系统安全运营会得到更大的收益。

五、在节能降耗方面

在节能方面，我积极运用已学的知识，为工厂的节能降耗方面提出我的见解同时做点微薄贡献。

六、实践生产方面

在生产实践方面，例如：35KV调试运行、电动机的电气故障的查找和排除实例。

1、检查引出线绝缘是否完好，电动机是否过热，查其接线是否符合铭牌规定，绕组和首、尾端电否正确；

2、测绝缘电阻及直流电阻测查绝缘是否损坏。绕组中有否断路、短路及接地等现象；

3、通电检查在上述检查后末发现问题时，可以直接通电试验，用三相调压器开始施加较低的电压，再逐渐上升到额定电压等。

利用上述检查方法，为工厂多台电机查找故障，并将其修好。及时总结各种故障现象及解决方法，并记录在案，用来指导实践，同时也提高自己的业务水平。

4、35KV开关柜内所用变有均匀放电声，查看母排及开关均无异常，对开关及母排清扫、紧固后，送电仍有放电声。经分析结论如下：检查熔断器熔断，熔断后将灭弧的石英砂金属化，使熔断器能在较小故障电流诫过载时动作，这就叫。冶金效应。金属化后的石英砂在熔断器管内有一定的电阻，石英砂成为半导体，接通电源后在熔断器管内形成两极嘶嘶放电声，更换熔断器，故障排除。

5、空气压缩机的.控制装置采用的是自动调整励磁系统，从设备原理到设备本体，是非常复杂的，包括整流部分、自动控制部分、自动运算部分。保护元件采用的是先进的微机保护系统。这些高技术含量、高造价的设备，给调试增加了很大的难度。

我们不能出任何差错，否则将造成不可估量的损失。作为电气调试的主管，我的压力非常大。厂家提供的说明书远远不够，还要收集其他的相关资料。自己亲自对所有资料进行了认真的研究分析，掌握其性能、使用特点，制定现场调试需要考核的参数，并编制相应的调试方案。

回顾这段的调试工作，我在思想上、学习上、工作上取得了新的进步，但我也认识到自己的不足之处，理论知识水平还比较低。今后，我一定认真克服缺点，刻苦学习、勤奋工作，为公司作出自己的贡献！

11月

MSN空间完美搬家到新浪博客！