Spring 使用 AOP+注解 来记录方法执行时间

一直以来都知道Spring支持一种叫做面向切面编程(AOP)的东西,但是一直都没有自己尝试使用过. 直到最近为了Debug方法,记录使用时间猛然发现AOP正好适合使用在这个场景下.为了灵活的使用AOP,我选择了使用注解来作为标记,当某个特定的注解被使用的时候将会自动触发这个切面.

1.注解的编写

package org.jzbk.rssplus.aspect.annotation;

import java.lang.annotation.*;

/**
 * Created by Kotarou on 2017/1/11.
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Timed {
    boolean displayArgs() default false;
}

将注解设置为运行时RetentionPolicy.RUNTIME, 在编译时不会丢失这个注解信息.

设置注解主体为方法和类.

注解内部保存一个displayArgs的boolean变量,用于判断是否输出传入参数.

 

2. 编写AOP类

package org.jzbk.rssplus.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
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.jzbk.rssplus.aspect.annotation.Timed;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * Created by Kotarou on 2017/1/11.
 */
@Aspect
@Component
public class TimedAOP {
    final private Logger logger = LoggerFactory.getLogger(getClass());

    @Pointcut("@annotation(org.jzbk.rssplus.aspect.annotation.Timed) || @target(org.jzbk.rssplus.aspect.annotation.Timed)")
    public void annotationProcessor() {
    }

    @Pointcut("execution(public * org.jzbk.rssplus..*.*(..))")
    public void publicMethod() {
    }

    @Around(value = "publicMethod() && annotationProcessor()")
    public Object count(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        final String methodName = proceedingJoinPoint.getSignature().getName();

        Long startTime = System.currentTimeMillis();
        Object result = proceedingJoinPoint.proceed();
        Long finishTime = System.currentTimeMillis();

        Signature signature = proceedingJoinPoint.getSignature();
        String[] packageName = signature.getDeclaringTypeName().split("\\.");
        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < packageName.length; ++i) {
            if (i < packageName.length - 1) {
                stringBuilder.append(packageName[i].substring(0, 1));
            } else {
                stringBuilder.append(packageName[i]);
            }
            stringBuilder.append(".");
        }

        logger.info("Executing: " + stringBuilder + signature.getName() + " took: " + (finishTime - startTime) + " ms");


        Method method = ((MethodSignature) proceedingJoinPoint.getSignature()).getMethod();

        if (method.getDeclaringClass().isInterface()) {
            method = proceedingJoinPoint.getTarget().getClass().getDeclaredMethod(methodName, method.getParameterTypes());
        }

        // 方法上的注解优先级比类上的注解高,可以覆盖类上注解的值
        Timed timed = null;
        if (method.isAnnotationPresent(Timed.class)) {
            //处理方法上的注解
            timed = method.getAnnotation(Timed.class);
            if (timed.displayArgs()) {
                logArgs(proceedingJoinPoint.getArgs());
            }
        } else {
            //处理类上面的注解
            Object target = proceedingJoinPoint.getTarget();
            if (target.getClass().isAnnotationPresent(Timed.class)) {
                timed = target.getClass().getAnnotation(Timed.class);
                if (timed.displayArgs()) {
                    logArgs(proceedingJoinPoint.getArgs());
                }
            }
        }

        return result;
    }

    private void logArgs(Object[] args) {
        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < args.length; ++i) {
            stringBuilder.append("[");
            stringBuilder.append(i);
            stringBuilder.append("]: ");
            stringBuilder.append(args[i].toString());

            if (i < args.length - 1) {
                stringBuilder.append(", ");
            }
        }

        if (!stringBuilder.toString().isEmpty())
            logger.info("Argument List: " + stringBuilder);
        else
            logger.info("Argument List: Empty");
    }
}

 

AOP的切入点为使用了Timed的方法或者类.

方法上面的注解优先级比类上面的高,可以在方法上使用注解来覆盖掉类上注解的值.

 

演示:

在类上面增加注解,并设置displayArgs为true

 

在某个方式上覆盖注解冰将displayArgs设置为false

 

运行tomcat,查看日志

 

结果和期望中的一样.

Spring Boot加载Properties文件的方法

最近使用Spring Boot框架写了一个小网站.感觉Spring Boot写网站十分的优雅

本文将介绍如何在Spring Boot内引用Properties的值

1.开启文件扫描

2.在需要引入配置文件的Class上使用@PropertySource注解.

3.在Class中的属性上使用@Value注解来注入配置文件中的值.

 

演示

package org.jzbk.example.util;

import lombok.Getter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Getter
@Component
@PropertySource(value = "classpath:versionInfo.properties")
public class VersionInfo {
    @Value("${example.platform}")
    private String platform;

    @Value("${example.version}")
    private String version;

    @Value("${example.branch}")
    private String branch;

    @Value("${example.buildDate}")
    private String buildDate;
}

 

Spring Session整合Redisson

前言:

Redisson是一个在Redis的基础上实现的Java驻内存数据网格(In-Memory Data Grid)。它不仅提供了一系列的分布式的Java常用对象,还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离(Separation of Concern),从而让使用者能够将精力更集中地放在处理业务逻辑上。 (摘自官方WIKI)

 

Redisson在3.2.0版本里新增了对Spring-Session整合的支持.本文将介绍整合Spring-Boot Spring-Session Redisson的方法

1. 添加依赖

Maven

<dependency>
   <groupId>org.springframework.session</groupId>
   <artifactId>spring-session</artifactId>
   <version>1.2.2.RELEASE</version>
</dependency>
<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.2.0</version>
</dependency>

 

Gradle

compile 'org.springframework.session:spring-session:1.2.2.RELEASE'  
compile group: 'org.redisson', name: 'redisson', version:'3.2.0'

 

2.创建配置文件RedisConfig.java

package org.jzbk.example.configuration;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.spring.session.config.EnableRedissonHttpSession;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;

import java.io.IOException;

@EnableRedissonHttpSession
public class RedisConfig {
    @Bean(destroyMethod = "shutdown")
    public RedissonClient getRedis() throws IOException {
        return Redisson.create(
                Config.fromYAML(
                        new ClassPathResource("redisson.yaml").getInputStream()
                )
        );
    }
}

因为我的redisson.yaml在classpath根目录下,所以直接使用ClassPathResource,请根据实际情况来修改.

 

3.修改application.properties,增加下列配置

spring.session.store-type=redis
server.session.timeout=7200

 

4.启动项目,刷新页面即可看到成功整合成功.

 

参考: https://github.com/redisson/redisson/wiki/14.-Integration%20with%20frameworks#145-spring-session

Spring Boot使用@Cacheable注解

通常,我使用Hibernate的@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)注解来缓存@Entity类.

在JAP2规范内另一个注解@Cacheable有与Hibernate的@Cache的一样的功能使用@Cacheable的条件如下.

1.Entity Class实现Serializable接口

2.在Entity Class前加入@Cacheable(true)

例如

@Entity
@Cacheable(true) 
public class UserEntity implements Serializable {
 // properties
}

 

3.在配置文件内开启缓存[1]

spring.jpa.properties.javax.persistence.sharedCache.mode=ENABLE_SELECTIVE

 

参考: http://docs.oracle.com/javaee/6/tutorial/doc/gkjio.html [1]

http://stackoverflow.com/questions/31585698/spring-boot-jpa2-hibernate-enable-second-level-cache