精华内容
下载资源
问答
  • 获取所有注解

    2019-09-26 00:39:11
    获取所有注解 obj.getClass().getMethod("myMetch", String.class, int.class).getAnnotations() package net.jeesite.java; import java.lang.annotation.Annotation; import java.lang.annotation.Reten...

    获取所有注解

     

    obj.getClass().getMethod("myMetch", String.class, int.class).getAnnotations()

    package net.jeesite.java;
    
    import java.lang.annotation.Annotation;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.reflect.Method;
    
    @Retention(value = RetentionPolicy.RUNTIME)
    @interface Meta {
    
        String length();
    
        String name();
    
        int age();
    
    }
    
    @Retention(value = RetentionPolicy.RUNTIME)
    @interface MeTe {
    
        String length();
    
        String name();
    
        int age();
    
    }
    
    public class MetaTest {
    
        @Meta(age = 0, length = "2", name = "测试注解")
        public static void myMetch() throws NoSuchMethodException, SecurityException {
            MetaTest obj = new MetaTest();
    
            Class<?> c = obj.getClass();
    
            System.out.println("c:" + c.getConstructors().length);
    
            Method m = c.getMethod("myMetch");
            System.out.println("m:" + m.getName());
            Meta meta = m.getAnnotation(Meta.class);
    
            System.out.println("meta.length():" + meta.length());
            System.out.println("meta.name():" + meta.name());
            System.out.println("meta.age():" + meta.age());
    
        }
    
        @Meta(age = 30, length = "80", name = "测试带参数方法注解")
        @MeTe(age = 30, length = "80", name = "测试带参数方法注解")
        public static void myMetch(String name, int age) throws NoSuchMethodException, SecurityException {
            MetaTest obj = new MetaTest();
    
            Class<?> c = obj.getClass();
    
            System.out.println("c:" + c.getConstructors().length);
    
            Method m = c.getMethod("myMetch", String.class, int.class);
            System.out.println("m:" + m.getName());
            Meta meta = m.getAnnotation(Meta.class);
    
            System.out.println("meta.length():" + meta.length());
            System.out.println("meta.name():" + meta.name());
            System.out.println("meta.age():" + meta.age());
            Annotation[] a = obj.getClass().getMethod("myMetch", String.class, int.class).getAnnotations();
            for (int i = 0; i < a.length; i++) {
                System.out.println(a[i].getClass().getName());
                System.out.println(a[i]);
            }
    
        }
    
        public static void main(String[] args) {
    
            try {
                myMetch("小熊", 31);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (SecurityException e) {
                e.printStackTrace();
            }
        }
    
    }

     

     

    运行结果:

     

    c:1
    m:myMetch
    meta.length():80
    meta.name():测试带参数方法注解
    meta.age():30
    net.jeesite.java.$Proxy1
    @net.jeesite.java.Meta(age=30, length=80, name=测试带参数方法注解)
    net.jeesite.java.$Proxy2
    @net.jeesite.java.MeTe(age=30, length=80, name=测试带参数方法注解)

    转载于:https://www.cnblogs.com/anpajin/p/6351731.html

    展开全文
  • 获取类,方法,构造函数或字段的所有注释,我们使用getAnnotations()方法。此方法返回一个数组Annotation在以下示例中,我们尝试从该sayHi()方法读取所有注释。首先,我们需要获取自身的方法对象。因为sayHi()方法...

    要获取类,方法,构造函数或字段的所有注释,我们使用getAnnotations()方法。此方法返回一个数组Annotation

    在以下示例中,我们尝试从该sayHi()方法读取所有注释。首先,我们需要获取自身的方法对象。因为sayHi()方法具有参数,所以我们不仅需要将方法名称传递给getMethod()方法,而且还需要传递参数的类型。

    该getAnnotations()方法仅返回具有的注释RetentionPolicy.RUNTIME。因为其他保留策略不允许注释在运行时可用。package org.nhooo.example.lang.annotation;

    import java.lang.annotation.Annotation;

    import java.lang.reflect.Method;

    import java.util.HashMap;

    import java.util.Map;

    public class GetAllAnnotation {

    private Map data = new HashMap<>();

    @SuppressWarnings("unchecked")

    public static void main(String args[]) {

    GetAllAnnotation demo = new GetAllAnnotation();

    demo.sayHi("001", "Alice");

    demo.sayHi("004", "Malory");

    try {

    Class clazz = demo.getClass();

    // 要获得sayHi()方法,我们不仅需要传递方法

    // 名称及其参数类型,因此使用getMethod()方法

    // 返回正确的方法供我们使用。

    Method method = clazz.getMethod("sayHi", String.class, String.class);

    //从sayHi()方法获取所有注释。但这实际上

    //将仅返回一个注释。因为只有HelloAnnotation

    // 具有RUNTIME保留策略的注释,这意味着

    // 与sayHi()方法关联的其他注释不是

    // 在运行时可用。

    Annotation[] annotations = method.getAnnotations();

    for (Annotation anno : annotations) {

    System.out.println("Type: " + anno.annotationType());

    }

    } catch (NoSuchMethodException e) {

    e.printStackTrace();

    }

    }

    @SuppressWarnings("unchecked")

    @MyAnnotation("Hi")

    @HelloAnnotation(value = "Hello", greetTo = "Everyone")

    public void sayHi(String dataId, String name) {

    Map data = getData();

    if (data.containsKey(dataId)) {

    System.out.println("Hello " + data.get(dataId));

    } else {

    data.put(dataId, name);

    }

    }

    private Map getData() {

    data.put("001", "Alice");

    data.put("002", "Bob");

    data.put("003", "Carol");

    return data;

    }

    }package org.nhooo.example.lang.annotation;

    public @interface MyAnnotation {

    String value();

    }

    检查HelloAnnotation以下链接上的“如何创建简单注释”。

    此代码段的结果:Hello Alice

    Type: interface org.nhooo.example.lang.annotation.HelloAnnotation

    展开全文
  • 要想获取使用指定注解的类信息,可借助工具: org.reflections.Reflections 此工具将Java反射进行了高级封装,Reflections 通过扫描 classpath,索引元数据,允许在运行时查询这些元数据,也可以保存收集项目...

    要想获取使用指定注解的类信息,可借助工具:

    org.reflections.Reflections

    此工具将Java反射进行了高级封装,Reflections 通过扫描 classpath,索引元数据,允许在运行时查询这些元数据,也可以保存收集项目中多个模块的元数据信息。

    使用 Reflections 可以查询以下元数据信息: 

    1)获得某个类型的所有子类型
    2)获得标记了某个注解的所有类型/成员变量,支持注解参数匹配。
    3)使用正则表达式获得所有匹配的资源文件
    4)获得所有特定签名(包括参数,参数注解,返回值)的方法

    Reflections 依赖 Google 的 Guava 库和 Javassist 库。

    Maven引入方式:

    <dependency>
        <groupId>org.reflections</groupId>
        <artifactId>reflections</artifactId>
        <version>0.9.11</version>
    </dependency>

    sbt引入方式:

    "org.reflections" % "reflections" % "0.9.11"

     

    首先自定义注解:

    package com.today.service.financetask.job

    import
    java.lang.annotation.*; /** * 类功能描述:job 信息注解 * * @author WangXueXing create at 19-5-4 上午9:14 * @version 1.0.0 */ @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Inherited public @interface JobInfo { /** * job id * @return */ String jobId(); /** * job name * @return */ String jobName(); /** * default cron * @return */ String defaultCron(); }

     

    将某些类添加注解:

    package com.today.service.financetask.job

    import
    java.util.Calendar import com.today.api.checkaccount.scala.CheckAccountServiceClient import com.today.api.checkaccount.scala.enums.FlatFormTypeEnum import com.today.api.checkaccount.scala.request.ReconciliationRequest import com.today.service.financetask.job.define.AbstractJob import com.today.service.financetask.utils.JobInfo import org.quartz.JobExecutionContext /** * 自动对账 */ @JobInfo(jobId="CHECK_ACCOUNT_PROCESS", jobName="对账系统自动对账定时任务", defaultCron="0 0 13 * * ?") class CheckAccountJob extends AbstractJob{ /** * start up the scheduled task * * @param context JobExecutionContext */ override def run(context: JobExecutionContext): Unit = { val cal = Calendar.getInstance cal.add(Calendar.DATE, -1) new CheckAccountServiceClient().appReconciliation(new ReconciliationRequest(FlatFormTypeEnum.TODAY_APP,None)) } }

     

    import com.today.service.financetask.action.DailyStatementAction
    import com.today.service.financetask.job.define.AbstractJob
    import com.today.service.financetask.utils.JobInfo
    import org.quartz.JobExecutionContext
    import org.springframework.stereotype.Service
    
    /**
      * 日次处理定时任务处理
      *
      * @author zhangc create at 2018/5/11 14:08
      * @version 0.0.1
      */
    @Service
    @JobInfo(jobId="DAY_TIME_PROCESS", jobName="日次处理定时任务", defaultCron="0 30 2 * * ?")
    class DayTimeProcessJob extends AbstractJob{
      /**
        * start up the scheduled task
        *
        * @param context JobExecutionContext
        */
      override def run(context: JobExecutionContext): Unit = {
        new DailyStatementAction().execute
      }
    }

     

    通过Java反射及Reflections工具类实现被JobInfo注解的所有类信息:

    import java.util
    
    import com.today.service.financetask.utils.JobInfo
    import org.quartz.Job
    import org.reflections.Reflections
    
    import scala.collection.JavaConverters._
    import scala.collection.mutable
    
    /**
      * 通过注解获取所有通用Job信息
      *
      * @author BarryWang create at 2018/5/12 10:45
      * @version 0.0.1
      */
    object JobEnum {
      /**
        * 获取添加JobInfo注解的类信息
        */
      val jobWithAnnotation: util.Set[Class[_]] = new Reflections("com.today.service.financetask.job").getTypesAnnotatedWith(classOf[JobInfo])
    
      /**
        * 获取所有job枚举值
        * @return
        */
      def values : mutable.Set[JobInfo] = jobWithAnnotation.asScala.map(getJobInfo(_))
    
      /**
        * 根据job class 获取job 信息
        * @param jobClass
        * @return
        */
      def getJobInfo(jobClass : Class[_]): JobInfo = jobClass.getAnnotation(classOf[JobInfo])
    
      /**
        * jobId与jobName映射关系
        * @return
        */
      def jobIdNameMap : Map[String, String]={
        jobWithAnnotation.asScala.map{sub =>
          val jobInfo = getJobInfo(sub)
          Map(jobInfo.jobId() -> jobInfo.jobName())
        }.fold(Map())((i,j) => i++j)
      }
    
      /**
        * JobObject与JobEnum映射关系
        * @return
        */
      def jobClassInfoMap: Map[String, JobInfo] = {
        jobWithAnnotation.asScala.map{sub =>
          Map(sub.getName -> getJobInfo(sub))
        }.fold(Map())((i,j) => i++j)
      }
    
      /**
        * jobId与JobEnum映射关系
        * @return
        */
      def jobIdInfoMap: Map[String, JobInfo] = {
        jobWithAnnotation.asScala.map{sub =>
          val jobInfo = getJobInfo(sub)
          Map(jobInfo.jobId() -> jobInfo)
        }.fold(Map())((i,j) => i++j)
      }
    
      /**
        * jobId与JobObject映射关系
        * @return
        */
      def jobIdClassMap: Map[String, Class[_ <: Job]] = {
        jobWithAnnotation.asScala.map{sub =>
          Map(getJobInfo(sub).jobId() -> sub.asInstanceOf[Class[_ <: Job]])
        }.fold(Map[String, Class[_ <: Job]]())((i,j) => i++j)
      }
    
      def main(args: Array[String]): Unit = {
        println(jobIdClassMap)
      }
    }

     

    至此,我们就可以获取所有被特定注解引用的类信息及注解信息,我们就可以全局管理特定类信息。

     

    实现JobEnum后就可以统一对定时任务管理实现:

     

    1.新添加定时任务完全可以制定一个Job子类,其他操作自动维护进去;

    2.每个Job子类里面都需要实现 override def getJobAndApiInfo(context: JobExecutionContext): (String, String, JobEnum) 方法,这个也可以省掉,直接在父类统一实现;

    3.统一修改定时任务开关及时间接口;

    4.统一对定时任务启动时重启,就可以统一重启,不需要单独添加代码启动;

     

    1上面代码片段“将某些类添加注解”

    2父类代码如下:

    import java.io.{PrintWriter, StringWriter}
    
    import com.github.dapeng.core.helper.MasterHelper
    import com.today.api.financetask.scala.enums.TScheduledTaskLogEnum
    import com.today.service.financetask.action.sql.ScheduledTaskLogSql
    import com.today.service.financetask.util.{AppContextHolder, Debug}
    import com.today.service.financetask.utils.JobInfo
    import org.quartz.{Job, JobExecutionContext}
    import org.slf4j.LoggerFactory
    import org.springframework.transaction.TransactionStatus
    import org.springframework.transaction.support.TransactionTemplate
    
    import scala.util.{Failure, Success, Try}
    
    /**
      * the abstract class for job
      */
    trait AbstractJob extends Job{
      /** 日志 */
      val logger = LoggerFactory.getLogger(getClass)
    
      /**
        * execute the job
        * @param context
        */
      override def execute(context: JobExecutionContext): Unit = {
        getJobAndApiInfo(context) match {
          case Some(x) => execute(context, x.jobId, x.jobName)
          case None => logger.error("没有定义JobEnum及对应JobObject,请检查")
        }
      }
    
      /**
        * execute the job
        * @param context
        * @param jobId
        * @param jobName
        */
      def execute(context: JobExecutionContext, jobId : String, jobName: String): Unit = {
        //判断是否是选中的master节点,不是master节点不执行定时任务
        if (!MasterHelper.isMaster("com.today.api.financetask.service.FinanceScheduledService", "1.0.0")) {
          logger.info(s"Can't select master to run the job ${jobId}: ${jobName}")
          return
        }
    
        //记录开始日志
        val logId = ScheduledTaskLogSql.insertScheduledTaskLog(jobId)
        context.put("logId", logId)
        logger.info(s"Starting the job ${jobId}: ${jobName} ...")
    
        //事物处理
        val transactionTemplate: TransactionTemplate = AppContextHolder.getBean("transactionTemplate")
        transactionTemplate.execute((status: TransactionStatus) =>{
          Debug.reset()
          //执行任务
          Try(Debug.trace(s"${jobId}:${jobName}")(run(context))) match
          {
            case Success(x) => {
              logger.info(s"Successfully execute the job ${jobId}: ${jobName}")
              successLog(logId)
            }
            case Failure(e) => {
              logger.error(s"Failure execute the job ${jobId}: ${jobName}", e)
              failureLog(logId, status, e)
            }
          }
          Debug.info()
        })
      }
    
      /**
        * get the api information
        * @return (interface name, interface version, JobEnum)
        */
      def getJobAndApiInfo(context: JobExecutionContext) : Option[JobInfo] ={
        JobEnum.jobClassInfoMap.get(this.getClass.getName)
      }
    
      /**
        * start up the scheduled task
        * @param context JobExecutionContext
        */
      def run(context: JobExecutionContext)
    
      /**
        * 成功日志记录
        * @param logId
        */
      def successLog(logId: Long): Unit ={
        ScheduledTaskLogSql.updateExportReportRecord(logId, TScheduledTaskLogEnum.SUCCESS, "Success")
      }
    
      /**
        * 失败日志记录
        * @param logId
        */
      def failureLog(logId: Long, status: TransactionStatus, e: Throwable): Unit ={
        status.setRollbackOnly()
        ScheduledTaskLogSql.updateExportReportRecord(logId, TScheduledTaskLogEnum.FAILURE, getExceptionStack(e))
      }
    
      /**
        *
        * 功能说明:在日志文件中 ,打印异常堆栈
        * @param e : Throwable
        * @return : String
        */
      def getExceptionStack(e: Throwable): String = {
        val errorsWriter = new StringWriter
        e.printStackTrace(new PrintWriter(errorsWriter))
        errorsWriter.toString
      }
    }

     

    3 统一修改定时任务开关及时间代码如下:

    import com.today.api.financetask.scala.enums.{TScheduledTaskHasDeletedEnum, TScheduledTaskIsStartEnum}
    import com.today.api.financetask.scala.request.StartOrStopByNameRequest
    import com.today.api.financetask.scala.response.ServiceResponse
    import com.today.service.commons.Action
    import com.today.service.commons.Assert.assert
    import com.today.service.commons.exception.CommonException.illegalArgumentException
    import com.today.service.financetask.action.sql.ScheduledTaskActionSql
    import com.today.service.financetask.dto.TScheduledTask
    import com.today.service.financetask.job.define.JobEnum
    import com.today.service.financetask.query.sql.ScheduledTaskQuerySql
    import com.today.service.financetask.util.{CronConverter, QuartzManager}
    
    /**
      * @description: 启停定时任务
      * @author zhangc
      * @date 2018\8\1 0001 15:02
      * @version 1.0.0
      */
    class StartOrStopByNameAction (request: StartOrStopByNameRequest)  extends Action[ServiceResponse] {
      override def preCheck: Unit = {
        assert(!TScheduledTaskIsStartEnum.isUndefined(request.flag.id), illegalArgumentException("错误的启停标志!"))
      }
    
      /**
        * 根据传入的定时任务名称和启停标志,来判断启动或者停止定时任务
        * 如果是1则更新数据库,删除定时任务,重新添加定时任务
        * 如果是0则更新数据库,删除定时任务
        * @return
        */
      override def action: ServiceResponse = {
        val scheduledTask = ScheduledTaskQuerySql.queryByJobId(request.processName)
        val cron = CronConverter.convertHourMinuteToCron(request.processTime)
        val jobInfo = JobEnum.jobIdInfoMap(request.processName)
        //修改定时任务时间, 保存入库
        if(scheduledTask.isEmpty){
          ScheduledTaskActionSql.insertTScheduledTask(
            TScheduledTask(jobInfo.jobName,
              request.processName,
              cron,
              None,
              request.flag.id,
              None,
              null,
              null,
              TScheduledTaskHasDeletedEnum.NO.id))
        } else {
          ScheduledTaskActionSql.updateTaskIsStart(request.flag.id,cron, request.processName)
        }
        request.flag match {
          case TScheduledTaskIsStartEnum.YES =>  QuartzManager.modifyJobTime(request.processName, cron, JobEnum.jobIdClassMap(jobInfo.jobId()))
          case _ =>  QuartzManager.removeJob(request.processName)
        }
    
        ServiceResponse("200","success")
      }
    }

     

    4下面就是统一对定时任务启动时重启,就可以统一重启,不需要单独添加代码启动:

    import com.today.api.financetask.scala.enums.TScheduledTaskIsStartEnum
    import com.today.api.financetask.scala.request.QueryAutoConfigRequest
    import com.today.service.financetask.job._
    import com.today.service.financetask.job.define.JobEnum
    import com.today.service.financetask.query.sql.{AutoConfigQuerySql, ScheduledTaskQuerySql}
    import com.today.service.financetask.util.QuartzManager
    import com.today.service.financetask.utils.JobInfo
    import org.slf4j.LoggerFactory
    import org.springframework.context.ApplicationListener
    import org.springframework.context.event.ContextRefreshedEvent
    import org.springframework.stereotype.Service
    
    /**
      *  类功能描述: 定时器监听器, 服务启动时启动定时器
      *
      * @author BarryWang create at 2018/5/11 12:04
      * @version 0.0.1
      */
    @Service
    class ScheduleStartListener extends ApplicationListener[ContextRefreshedEvent] {
      /** 日志 */
      val logger = LoggerFactory.getLogger(getClass)
    
      /**
        * 启动加载执行定时任务
        */
      override def onApplicationEvent(event: ContextRefreshedEvent): Unit = {
        logger.info("=======服务器重启定时任务启动start=======")
        //启动服务时恢复常规定时任务
        JobEnum.values.foreach(recoveryCommonJob(_))
        logger.info("=======服务器重启定时任务启动end=======")
      }
    
      /**
        * 恢复通用定时任务
        * @param jobInfo 定时任务枚举
        */
      private def recoveryCommonJob(jobInfo: JobInfo)={
        try {
          val jobClass = JobEnum.jobIdClassMap(jobInfo.jobId)
          ScheduledTaskQuerySql.queryByJobId(jobInfo.jobId) match {
            case Some(x) => {
              x.isStart match {
                case TScheduledTaskIsStartEnum.YES.id => {
                  QuartzManager.addJobByCron(jobInfo.jobId, x.jobCron, jobClass)
                  logger.info(s"定时任务:'${jobInfo.jobName}'启动成功!")
                }
                case _ => logger.info(s"定时任务:'${jobInfo.jobName}'is_start标志为0,不启动")
              }
            }
            case None => QuartzManager.addJobByCron(jobInfo.jobId, jobInfo.defaultCron(), jobClass)
          }
        } catch {
          case e : Exception => logger.error(s"定时任务:'${jobInfo.jobName}'启动失败, 失败原因:", e)
        }
      }
    }

     

     

    本部分也是对Quartz实现可配置的分布式定时任务的优化重构,可详见:

    Quartz实现分布式可动态配置的定时任务

    转载于:https://www.cnblogs.com/barrywxx/p/10810055.html

    展开全文
  • 最近项目中遇到一个业务场景,就是在Spring容器启动后获取所有的Bean中实现了一个特定接口的对象,第一个想到的是ApplicationContextAware,在setApplicationContext中去通过ctx获取所有的bean,后来发现好像逻辑...

    最近项目中遇到一个业务场景,就是在Spring容器启动后获取所有的Bean中实现了一个特定接口的对象,第一个想到的是ApplicationContextAware,在setApplicationContext中去通过ctx获取所有的bean,后来发现好像逻辑不对,这个方法不是在所有bean初始化完成后实现的,后来试了一下看看有没有什么Listener之类的,发现了好东西ApplicationListener,然后百度一下ApplicationListener用法,原来有一大堆例子,我也记录一下我的例子好了。

    很简单,只要实现ApplicationListener接口,然后把实现类进行@Component即可,代码如下:

    Java代码  b13ec6c71982d34ac0d26a48854f1837.png

    @Component

    public class ContextRefreshedListener implements ApplicationListener {

    @Override

    public void onApplicationEvent(ContextRefreshedEvent event) {

    // 根容器为Spring容器

    if(event.getApplicationContext().getParent()==null){

    Map beans = event.getApplicationContext().getBeansWithAnnotation(IMobile.class);

    for(Object bean:beans.values()){

    System.err.println(bean==null?"null":bean.getClass().getName());

    }

    System.err.println("=====ContextRefreshedEvent====="+event.getSource().getClass().getName());

    }

    }

    }

    其中,通过event.getApplicationContext().getBeansWithAnnotation获取到所有拥有特定注解的Beans集合,然后遍历所有bean实现业务场景。

    总结思考:这样的功能可以实现系统参数的初始化,获取系统中所有接口服务清单等一系列需要在Spring启动后初始化的功能。

    延生一下:除了以上启动后事件外,还有其他三个事件

    242c094f807c5bbf1f63c2740e7c53af.png

    Closed在关闭容器的时候调用,

    Started理论上在容器启动的时候调用,

    Stopped理论上在容器关闭的时候调用。

    我通过TomcatServer进行启动停止,只看到了Refreshed和Closed,不知道为啥,有空再继续研究

    spring中如何获取注入bean里方法上的注解?

    有这样一个需求,在spring中,想用反射获取一个注入bean中方法的注解一般情况下这样的操作就行了:Method method = bean.getClass().getMethod(...);Annotation[] annotations = method.getAnnotations();这样就能获取注解了。

    spring中如何获取bean的成员变量上的注解?

    package com.vweb.util;

    import com.vweb.webapp.Mouse;

    import com.vweb.webapp.MyAnno;

    import com.vweb.webapp.TestUtil;

    import java.lang.annotation.Annotation;

    import java.lang.reflect.Field;

    import java.util.Arrays;

    import java.util.List;

    publicclassIntactCheckUtil {

    public staticboolean check(Objectobj){// list = Arrays.asList(AnnotationParsing.class.getClassLoader().loadClass(((Class)obj).getClass().getName()).getDeclaredFields());

    List list =Arrays.asList(obj.getClass().getDeclaredFields());

    for(int i=0;i

    Field field=list.get(i);

    if(field.isAnnotationPresent(MyAnno.class)){//是否使用MyAnno注解

    for (Annotation anno : field.getDeclaredAnnotations()) {//获得所有的注解

    if(anno.annotationType().equals(MyAnno.class) ){//找到自己的注解

    if(!((MyAnno)anno).isCanNull()){//注解的值

    if(TestUtil.getFieldValueByName(field.getName(),obj)==null){

    throw new RuntimeException("类:"+Mouse.class+"的属性:"+field.getName()+"不能为空,实际的值:"+TestUtil.getFieldValueByName(field.getName(),obj)+",注解:field.getDeclaredAnnotations()");

    }

    }

    if(!((MyAnno)anno).isCanEmpty()){

    if(TestUtil.getFieldValueByName(field.getName(),obj).equals("")){

    throw new RuntimeException("类:"+Mouse.class+"的属性:"+field.getName()+"不能为空字符串,实际的值:"+TestUtil.getFieldValueByName(field.getName(),obj)+",注解:field.getDeclaredAnnotations()");

    }

    }

    if(!((MyAnno)anno).isCanZero()){

    if(TestUtil.getFieldValueByName(field.getName(),obj).toString().equals("0") || TestUtil.getFieldValueByName(field.getName(),obj).toString().equals("0.0")){

    throw new RuntimeException("类:"+Mouse.class+"的属性:"+field.getName()+"不能为空字符0,实际的值:"+TestUtil.getFieldValueByName(field.getName(),obj)+",注解:field.getDeclaredAnnotations()");

    }

    }

    }

    }

    }

    }

    returntrue;

    }

    }

    备注:注解各参数的使用(以下内容来自互联网http://www.cnblogs.com/peida/archive/2013/04/24/3036689.html)

    java 反射得到属性与属性值

    /*** 得到属性值

    *@paramobj*/

    public static voidreadAttributeValue(Object obj){

    String nameVlues="";//得到class

    Class cls =obj.getClass();//得到所有属性

    Field[] fields =cls.getDeclaredFields();for (int i=0;i

    try{//得到属性

    Field field =fields[i];//打开私有访问

    field.setAccessible(true);//获取属性

    String name =field.getName();//获取属性值

    Object value =field.get(obj);//一个个赋值

    nameVlues += field.getName()+":"+value+",";

    }catch(IllegalAccessException e) {

    e.printStackTrace();

    }

    }//获取最后一个逗号的位置       int lastIndex = nameVlues.lastIndexOf(",");//不要最后一个逗号","

    String result= nameVlues.substring(0,lastIndex);

    System.out.println(result);

    }

    @Target:

    @Target说明了Annotation所修饰的对象范围:Annotation可被用于 packages、types(类、接口、枚举、Annotation类型)、类型成员(方法、构造方法、成员变量、枚举值)、方法参数和本地变量(如循环变量、catch参数)。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。

    取值(ElementType)有:

    1.CONSTRUCTOR:用于描述构造器    2.FIELD:用于描述域    3.LOCAL_VARIABLE:用于描述局部变量    4.METHOD:用于描述方法    5.PACKAGE:用于描述包    6.PARAMETER:用于描述参数    7.TYPE:用于描述类、接口(包括注解类型) 或enum声明

    @Retention定义了该Annotation被保留的时间长短:某些Annotation仅出现在源代码中,而被编译器丢弃;而另一些却被编译在class文件中;编译在class文件中的Annotation可能会被虚拟机忽略,而另一些在class被装载时将被读取(请注意并不影响class的执行,因为Annotation与class在使用上是被分离的)。使用这个meta-Annotation可以对 Annotation的“生命周期”限制。

    取值(RetentionPoicy)有:

    1.SOURCE:在源文件中有效(即源文件保留)    2.CLASS:在class文件中有效(即class保留)    3.RUNTIME:在运行时有效(即运行时保留)

    @Documented:

    该属性用于描述其它类型的annotation应该被作为被标注的程序成员的公共API,因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解,没有成员。

    @Inherited:

    @Inherited 元注解是一个标记注解,@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class,则这个annotation将被用于该class的子类。

    注意:@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation,方法并不从它所重载的方法继承annotation。

    当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME,则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时,反射代码检查将展开工作:检查class和其父类,直到发现指定的annotation类型被发现,或者到达类继承结构的顶层。

    自定义注解:

    使用@interface自定义注解时,自动继承了java.lang.annotation.Annotation接口,由编译程序自动完成其他细节。在定义注解时,不能继承其他的注解或接口。@interface用来声明一个注解,其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称,返回值类型就是参数的类型(返回值类型只能是基本类型、Class、String、enum)。可以通过default来声明参数的默认值。

    定义注解格式:  public @interface 注解名 {定义体}

    注解参数的可支持数据类型:

    1.所有基本数据类型(int,float,boolean,byte,double,char,long,short)    2.String类型    3.Class类型    4.enum类型    5.Annotation类型    6.以上所有类型的数组

    Annotation类型里面的参数该怎么设定:   第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型;     第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和 String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;    第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号.例:下面的例子FruitName注解就只有一个参数成员。

    展开全文
  • Spring 获取自定义注解所有

    千次阅读 2019-06-11 08:45:51
    //获取bean对象 System.out.println("================"+clazz.getName()); ComponentDesc componentDesc = AnnotationUtils.findAnnotation(clazz,ComponentDesc.class); System.out.println("=================...
  • Spring获取注解下的所有类(bean),前提是该类在是spring容器进行了注册。Spring获取注解为null注解类NettyHandler无法获取注解NettyHandler问题分析解决方案调整后代码 注解类NettyHandler import java.lang....
  • 一、注解基本知识1、元注解注解是指注解注解。包括 @Retention @Target @Document @Inherited四种。1. Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去...
  • //获取bean对象 System.out.println("================"+clazz.getName()); ComponentDesc componentDesc = AnnotationUtils.findAnnotation(clazz,ComponentDesc.class); System.out.println("===================...
  • 前言最近在做项目权限,使用shiro实现...这里用了反射,来获取所有接口的信息,接口再多,也不过几秒钟的事。使用Auth.java接口信息对象主要包括授权地址,权限唯一标识,权限名称,创建时间,请求方式packagecom....
  • 获取所有springmvc中注解RequestMapping

    千次阅读 2016-05-05 10:07:59
    检测ClassLoader中所有已加载的类,查找springmvc注解定义的RequestMapping
  • SpringBoot获取自定义注解属性-类-方法 写了个自定义注解,想获取... //获取自定义注解的配置的所有bean final Map<String, Object> beansWithAnnotation = applicationContext.getBeansWithAnnotation(...
  • 作者:俊俊的小熊饼干cnblogs.com/wenjunwei/p/10293490.html前言最近在做项目权限,使用shiro实现restful接口权限管理,对整个...这里用了反射,来获取所有接口的信息,接口再多,也不过几秒钟的事。使用Auth.java...
  • 因为做了RBAC结构的权限模型,又懒得写管理界面,就直接一网打尽,写一个获取所有url路径和swagger文档注解的方法,然后百度了下,大部分都是只获取URL接口路径,我拓展了下,可以加上方法的注解参数。 swagger...
  • 跟汤老师学Java笔记:如何解析注解 完成:第一遍 1. 如何解析注解? 对于生命周期为运行期间(RetentionPolicy.RUNTIME)的注解,可以通过反射获取元素上的注解...作用: 获取所有注解 方法: Annotation annotation =
  • 主要介绍了Spring启动后获取所有拥有特定注解的Bean实例代码,分享了相关代码示例,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
  • 1、元注解注解是指注解注解。包括 @Retention @Target @Document @Inherited四种。1. Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口....
  • 一、注解基本知识1、元注解:@Retention @Target @Document @Inherited2、Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口。3、参数成员...
  • 2)获得标记了某个注解所有类型/成员变量,支持注解参数匹配。 3)使用正则表达式获得所有匹配的资源文件 4)获得所有特定签名(包括参数,参数注解,返回值)的方法--> <dependency> <groupId&...
  • Spring启动后获取所有拥有特定注解的Bean 转载 2016年08月04日 11:00:51 ...
  • 反射机制的常见作用动态的加载类、动态的获取类的信息(属性,方法,构造 器) 动态构造对象 动态调用类和对象的任意方法、构造器 动态调用和处理属性 获取泛型信息处理注解java.lang.Class类 :表示正在运行的Java...
  • 首先来看看使用反射来获取注解名: 只需在获取class后调用getAnnotation方法即可,如下 这里是获取JPA映射b表名,Table.class,使用下面这个可以获取表名 import javax.persistence.Table; annotation.name() 这里...
  • 作者:俊俊的小熊饼干cnblogs.com/wenjunwei/p/10293490.html前言最近在做项目权限,使用shiro实现restful接口权限管理,对整个项目都...这里用了反射,来获取所有接口的信息,接口再多,也不过几秒钟的事。使用Auth...
  • 即可打印出所有注解 org.springframework.beans.factory.annotation.Autowired org.springframework.beans.factory.annotation.Configurable org.springframework.beans.factory.annotation.Lookup org....
  • 使用Reflections快速扫描指定包下自定义的Controller和RequestMapping两个注解,先去扫描加了@Controller注解的类,接着获取这些类下面加了@RequestMapping注解的方法,然后通过Java的反射invoke方...
  • java反射之获取类或接口上的所有方法及其注解(包括实现的接口上的注解) /** * 获取类或接口上的所有方法及方法上的注解(包括方法实现上的注解以及接口上的注解),最完整的工具类,没有现成的工具类 * ...
  • public class Scanner { /** * 从包package中获取所有的Class * * @param packageName * @return */ public Set> getClasses(String packageName) throws Exception { // 第一个class类的集合 //List> classes = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,150
精华内容 1,260
关键字:

获取所有注解