【Java基础】Java注解简单入门
注解简单来说就是配置,是特别的配置,之前常用的配置文件,可以用注解替换。然后通过反射去获取注解的信息。
如何定义一个注解
你在IDE中新建一个注解定义,是这样的结构的:
package com.nicchagil.exercise.springbootexercise.annotation;
public @interface MyFirstAnnotation {
}
然后大概有4个对上述结构加上一些配置,当然,这配置是以注解的形式添加的=_=!
此注解使用在哪里
此注解会应用的哪里,可通过如下配置:
保留在什么时候
保留到什么时候:
注解体现在文档中
@Documented
子类是否继承父类的注解
@Inherited
用反射获取注解的信息
我们先定义一个注解:
package com.nicchagil.exercise.springbootexercise.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;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PojoPostProcessing {
public Class targetClass();
public String[] whiteProperties();
}
使用注解,比如这里我设置到一个方法上:
@PojoPostProcessing(targetClass=User.class, whiteProperties={"name"})
public List<User> selectXxx(String id) {
......
}
反射获取注解的信息:
@Test
public void test() throws NoSuchMethodException, SecurityException, ClassNotFoundException {
Class clazz = Class.forName("com.nicchagil.exercise.springbootexercise.service.UserService");
Method method = clazz.getMethod("selectXxx", String.class);
boolean isAnnotationPresent = method.isAnnotationPresent(PojoPostProcessing.class);
if (!isAnnotationPresent) {
return;
}
PojoPostProcessing dpp = (PojoPostProcessing)method.getAnnotation(PojoPostProcessing.class);
this.logger.info("dpp : {}", dpp);
}
日志:
dpp : @com.nicchagil.exercise.springbootexercise.annotation.PojoPostProcessing(targetClass=class com.nicchagil.exercise.springbootexercise.mapper.entity.User, whiteProperties=[name])
在Spring AOP中解析注解,然后实体你注解需要做的业务
比如以下就是在Spring AOP中拦截到方法,通过JoinPoint
获取反射的Method
,然后看是否有指定注解,如果有注解,后面就是关于此注解要做的业务逻辑了:
package com.nicchagil.exercise.springbootexercise.aop;
import java.lang.reflect.Method;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import com.nicchagil.exercise.springbootexercise.annotation.PojoPostProcessing;
@Aspect
@Configuration
public class ServiceControllerLogAop {
private Logger logger = LoggerFactory.getLogger(this.getClass());
@Pointcut("execution(* com.nicchagil.exercise.springbootexercise.service.*Service.*(..))")
public void myPointcut() {
}
@AfterReturning("myPointcut()")
public void myBefore(JoinPoint joinPoint) {
/* 获取方法对象 */
Signature signature = joinPoint.getSignature();
if (signature == null && !(signature instanceof MethodSignature)) {
return;
}
MethodSignature methodSignature = (MethodSignature)signature;
Method method = methodSignature.getMethod();
/* 是否有指定注解 */
boolean isAnnotationPresent = method.isAnnotationPresent(PojoPostProcessing.class);
if (!isAnnotationPresent) {
return;
}
/* 获取注解信息 */
PojoPostProcessing dpp = (PojoPostProcessing)method.getAnnotation(PojoPostProcessing.class);
this.logger.info("dpp : {}", dpp);
}
}
过滤注解方法的返回值的指定属性
将属性置空的工具类:
package com.nicchagil.exercise.springbootexercise.util;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.core.MethodParameter;
public class BeanClearUtils {
private static Logger logger = LoggerFactory.getLogger(BeanClearUtils.class);
public static void clearProperty(Object obj, String[] whiteProperty) {
List<PropertyDescriptor> clearList = BeanClearUtils.getClearProperty(obj.getClass(), whiteProperty);
try {
for (PropertyDescriptor pd : clearList) {
MethodParameter mp = BeanUtils.getWriteMethodParameter(pd);
Method method = mp.getMethod();
method.invoke(obj, new Object[] {null});
}
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
throw new RuntimeException("设置空属性失败", e);
}
}
/**
* 获取需要清除的字段列表
*/
public static List<PropertyDescriptor> getClearProperty(Class<?> clazz, String[] whiteProperty) {
PropertyDescriptor[] allPropertyDescriptor = BeanUtils.getPropertyDescriptors(clazz);
/* 需保留的字段 */
Set<String> whitePropertySet = new HashSet<String>(Arrays.asList(whiteProperty));
whitePropertySet.add("class"); // 此字段无须清除
/* 需清除的字段 */
List<PropertyDescriptor> clearList = new ArrayList<PropertyDescriptor>();
for (PropertyDescriptor propertyDescriptor : allPropertyDescriptor) {
if (!whitePropertySet.contains(propertyDescriptor.getName())) {
clearList.add(propertyDescriptor);
}
}
return clearList;
}
}
定义注解:
package com.nicchagil.exercise.springbootexercise.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;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PojoPostProcessing {
public String[] whiteProperties();
}
处理注解逻辑:
package com.nicchagil.exercise.springbootexercise.aop;
import java.lang.reflect.Method;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import com.nicchagil.exercise.springbootexercise.annotation.PojoPostProcessing;
import com.nicchagil.exercise.springbootexercise.util.BeanClearUtils;
@Aspect
@Configuration
public class BeanPropertyFilterAop {
private Logger logger = LoggerFactory.getLogger(this.getClass());
@Pointcut("execution(* com.nicchagil.exercise.springbootexercise.service.*Service.*(..))")
public void myPojoPostProcessingPointcut() {
}
@AfterReturning(value = "myPojoPostProcessingPointcut()", returning = "returnObject")
public void myAfter(JoinPoint joinPoint, Object returnObject) {
/* 获取方法对象 */
Signature signature = joinPoint.getSignature();
if (signature == null && !(signature instanceof MethodSignature)) {
return;
}
MethodSignature methodSignature = (MethodSignature) signature;
Method method = methodSignature.getMethod();
/* 是否有指定注解 */
boolean isAnnotationPresent = method.isAnnotationPresent(PojoPostProcessing.class);
if (!isAnnotationPresent) {
return;
}
/* 获取注解信息 */
PojoPostProcessing dpp = (PojoPostProcessing) method.getAnnotation(PojoPostProcessing.class);
this.logger.info("dpp : {}", dpp);
/* 只保留bean的指定属性值(其它属性值置空) */
logger.info("before bean : {}", returnObject);
BeanClearUtils.clearProperty(returnObject, dpp.whiteProperties());
logger.info("after bean : {}", returnObject);
}
}
使用注解:
@PojoPostProcessing(whiteProperties={"name", "createTime"})
作者:Nick Huang 博客:http://www.cnblogs.com/nick-huang/
本博客为学习、笔记之用,以笔记形式记录学习的知识与感悟。学习过程中可能参考各种资料,如觉文中表述过分引用,请务必告知,以便迅速处理。如有错漏,不吝赐教。
如果本文对您有用,点赞或评论哦;如果您喜欢我的文章,请点击关注我哦~
本博客为学习、笔记之用,以笔记形式记录学习的知识与感悟。学习过程中可能参考各种资料,如觉文中表述过分引用,请务必告知,以便迅速处理。如有错漏,不吝赐教。
如果本文对您有用,点赞或评论哦;如果您喜欢我的文章,请点击关注我哦~