今天完成的事情：

SpringAOP+注解实现简单的日志管理

自定义一个类aop

public class Aop {
    private String className;
    private String methodName;
    private Date logTime;
    private long comsumeTime;

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Date getLogTime() {
        return logTime;
    }

    public void setLogTime(Date logTime) {
        this.logTime = logTime;
    }

    public long getConsumeTime() {
        return comsumeTime;
    }

    public void setConsumeTime(long consumeTime) {
        this.comsumeTime = consumeTime;
    }
}

然后定义切点及输出

/**
 * API接口性能分析
 * @author admin
 */
@Component
@Aspect
public class AopAspect {

    private static Logger logger = Logger.getLogger(Aop.class);
    //引入日志配置

    /**
     * 定义切点函数
     */
    @Pointcut("execution(* com.controller.*.*(..))   ||  execution(* com.service.*.*(..))")
    void timer() {
    }

    @Around("timer()")
    public Object logTimer(ProceedingJoinPoint thisJoinPoint) throws Throwable {
        //获取目标类名称
        String className = thisJoinPoint.getTarget().getClass().getName();
        //获取目标类方法名称
        String methodName = thisJoinPoint.getSignature().getName();
        // 计时并调用目标函数
        long start = System.currentTimeMillis();
        Object result = thisJoinPoint.proceed();
        long time = System.currentTimeMillis() - start;
        logger.info("执行" + className + "中的方法:" + methodName + ",消耗时间为：" + time + "ms");
        return result;
    }
}

log4j.properties

log4j.rootLogger = INFO,Console,logfile
#日志输出到控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
#日志输出到文件
log4j.appender.logfile = org.apache.log4j.DailyRollingFileAppender
log4j.appender.logfile.File = ${art.root}/log/AllLog.log
#是否追加写进文件
log4j.appender.logfile.Append = true
#输出DEBUG级别日志到文件中
log4j.appender.logfile.Threshold = DEBUG
log4j.appender.logfile.layout = org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

在web.xml加上相关配置

<!--关于log4j的相关配置-->
<context-param>
  <param-name>log4jConfigLocation</param-name>
  <param-value>classpath:log4j.properties</param-value>
</context-param>
<!--加载log4j配置文件-->
<listener>
  <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>

运行后结果

使用nginx获取图片

在nginx.conf里加上以下内容

因为之前配置过反向代理resin，得把那些配置给删掉，不然一直访问都是resin

保存后测试一下

然后把图片上传到设置的路径

重启一遍nginx

把项目部署到tomcat

使用postman测试查询接口

平均速度为40-70ms左右

明天计划的事情：做好任务三深度总结，提交任务，开始任务四
遇到的问题：无
收获：

AOP：

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术

AOP是什么：

(1)是一种编程范式，不是编程语言

(2)解决特定问题，不能解决所有问题

(3)是OOP的补充，不是替代

AOP初衷:

1.解决代码重复问题，增加代码的可读性与可维护性

2.关注点分离，使程序员可以将更多的精力放在开发主要功能中。

SpringAOP的两种实现方式：

1.基于xml配置的方式

2.基于注解的方式(重点)

AOP术语

1、通知(Advice)

切面类有自己要完成的工作，切面类的工作就称为通知。通知定义了切面是做什么以及何时使用。

"做什么"，即切面类中定义的方法是干什么的；

"何时使用"，即5种通知类型，是在目标方法执行前，还是目标方法执行后等等；

"何处做"，即通知定义了做什么，何时使用，但是不知道用在何处，而切点定义的就是告诉通知应该用在

哪个类的哪个目标方法上，从而完美的完成横切点功能。

Spring切面定义了5种类型通知：

1）前置通知(Before)：在目标方法被调用之前调用通知功能。

2）后置通知(After)：在目标方法完成之后调用通知，不会关心方法的输出是什么。

3）返回通知(After-returning)： 在目标方法成功执行之后调用通知。

4）异常通知(After-throwing)：在目标方法抛出异常后调用通知。

5）环绕通知(Around)：通知包裹了被通知的方法，在被通知的方法调用之前和之后执行自定义的行为。

2、连接点(Join point)

在我们的应用程序中有可能有数以万计的时机可以应用通知，而这些时机就被称为连接点。

连接点是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、

甚至修改一个字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。

连接点是一个虚概念，可以把连接点看成是切点的集合。

下面我们看看切点是神马鬼?

3、切点(Poincut)

连接点谈的是一个飘渺的大范围，而切点是一个具体的位置，用于缩小切面所通知的连接点的范围。

前面说过，通知定义的是切面的"要做什么"和"在何时做"，是不是没有去哪里做，而切点就定义了"去何处做"。

切点的定义会匹配通知所要织入的一个或多个连接点。我们通常使用明确的类和方法名称，或者是使用

正则表达式定义所匹配的类和方法名称来指定切点。说白了，切点就是让通知找到"发泄的地方"。

4、切面(Aspect)

切面是通知和切点的结合，通知和切点共同定义了切面的全部内容。因为通知定义的是切面的

"要做什么"和"在何时做"，而切点定义的是切面的"在何地做"。将两者结合在一起，就可以完美的

展现切面在何时，何地，做什么(功能)。

5、引入(Introduction)

引入这个概念就比较高大尚，引入允许我们向现有的类添加新方法或属性。

主要目的是想在无需修改A的情况下，引入B的行为和状态。

6、织入(Weaving)

织入是把切面应用到目标对象并创建新的代理对象的过程。切面在指定的连接点被织入到目标对象中。

在目标对象的生命周期里有多个点可以进行织入:

编译期: 

    切面在目标类编译时被织入。需要特殊的编译器，是AspectJ的方式，不是spring的菜。

类加载期: 

    切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器，它可以在目标类被引入应用之前

    增强该目标类的字节码。AspectJ5支持这种方式。

运行期:  

     切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态的创建

     一个代理对象。而这正是Spring AOP的织入切面的方式。