精华内容
下载资源
问答
  • 主要介绍了Spring启动后获取所有拥有特定注解的Bean实例代码,分享了相关代码示例,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
  • 获取所有类的注解,方法的注解,如果是controller获取url package com.picc.vx.portal.util; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperation; import org.springframework.web....

    场景:

    获取所有类的注解,方法的注解 ,如果是controller获取url

    package com.picc.vx.portal.util;
    
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    import java.io.File;
    import java.io.FileFilter;
    import java.io.IOException;
    import java.lang.reflect.Method;
    import java.net.JarURLConnection;
    import java.net.URL;
    import java.net.URLDecoder;
    import java.util.Enumeration;
    import java.util.Iterator;
    import java.util.LinkedHashSet;
    import java.util.Set;
    import java.util.jar.JarEntry;
    import java.util.jar.JarFile;
    
    public class ClassUtil {
    
        public static void main(String[] args) {
    
            // 包下面的类
            Set<Class<?>> classSet = getClasses("com.picc.vx.portal.ctrl");
            if (classSet == null) {
                return;
            }
    
            System.out.println(classSet.size() + "");
            // 某类或者接口的子类
            Set<Class<?>> inInterface = getByInterface(Object.class, classSet);
            System.out.println(inInterface.size() + "");
    
            for (Class<?> clazz : classSet) {
                Api api = clazz.getDeclaredAnnotation(Api.class);
                if(null == api){
                    continue;
                }
                String operateName = api.tags()[0];
    
                RequestMapping requestMapping = clazz.getDeclaredAnnotation(RequestMapping.class);
                if (null == requestMapping) {
                    continue;
                }
                String url = requestMapping.value()[0];
    
                System.out.println("url:" + url);
                // 获取方法上的注解
                Method[] methods = clazz.getDeclaredMethods();
                for (Method method : methods) {
                    ApiOperation apiOperation = method.getAnnotation(ApiOperation.class);
                    if (null == apiOperation) {
                        continue;
                    }
                    String name = apiOperation.value();
                    PostMapping postMapping = method.getAnnotation(PostMapping.class);
                    String subUrl = "";
                    if (null != postMapping) {
                        subUrl = postMapping.value()[0];
                    } else {
                        GetMapping getMapping = method.getAnnotation(GetMapping.class);
                        if (null != getMapping) {
                            subUrl = getMapping.value()[0];
                        }
                    }
                    System.out.println(operateName+":"+name + ":" + url + subUrl);
                }
            }
    
        }
    
        /**
         * 从包package中获取所有的Class
         *
         * @param pack
         * @return
         */
        public static Set<Class<?>> getClasses(String pack) {
    
            // 第一个class类的集合
            Set<Class<?>> classes = new LinkedHashSet<>();
            // 是否循环迭代
            boolean recursive = true;
            // 获取包的名字 并进行替换
            String packageName = pack;
            String packageDirName = packageName.replace('.', '/');
            // 定义一个枚举的集合 并进行循环来处理这个目录下的things
            Enumeration<URL> dirs;
            try {
                dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
                // 循环迭代下去
                while (dirs.hasMoreElements()) {
                    // 获取下一个元素
                    URL url = dirs.nextElement();
                    // 得到协议的名称
                    String protocol = url.getProtocol();
                    // 如果是以文件的形式保存在服务器上
                    if ("file".equals(protocol)) {
                        System.err.println("file类型的扫描");
                        // 获取包的物理路径
                        String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                        // 以文件的方式扫描整个包下的文件 并添加到集合中
                        findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                    } else if ("jar".equals(protocol)) {
                        // 如果是jar包文件
                        // 定义一个JarFile
                        // System.err.println("jar类型的扫描");
                        JarFile jar;
                        try {
                            // 获取jar
                            jar = ((JarURLConnection) url.openConnection()).getJarFile();
                            // 从此jar包 得到一个枚举类
                            Enumeration<JarEntry> entries = jar.entries();
                            // 同样的进行循环迭代
                            while (entries.hasMoreElements()) {
                                // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                                JarEntry entry = entries.nextElement();
                                String name = entry.getName();
                                // 如果是以/开头的
                                if (name.charAt(0) == '/') {
                                    // 获取后面的字符串
                                    name = name.substring(1);
                                }
                                // 如果前半部分和定义的包名相同
                                if (name.startsWith(packageDirName)) {
                                    int idx = name.lastIndexOf('/');
                                    // 如果以"/"结尾 是一个包
                                    if (idx != -1) {
                                        // 获取包名 把"/"替换成"."
                                        packageName = name.substring(0, idx).replace('/', '.');
                                    }
                                    // 如果可以迭代下去 并且是一个包
                                    if ((idx != -1) || recursive) {
                                        // 如果是一个.class文件 而且不是目录
                                        if (name.endsWith(".class") && !entry.isDirectory()) {
                                            // 去掉后面的".class" 获取真正的类名
                                            String className = name.substring(packageName.length() + 1, name.length() - 6);
                                            try {
                                                // 添加到classes
                                                classes.add(Class.forName(packageName + '.' + className));
                                            } catch (ClassNotFoundException e) {
                                                e.printStackTrace();
                                            }
                                        }
                                    }
                                }
                            }
                        } catch (IOException e) {
                            // log.error("在扫描用户定义视图时从jar包获取文件出错");
                            e.printStackTrace();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            return classes;
        }
    
        /**
         * 以文件的形式来获取包下的所有Class
         *
         * @param packageName
         * @param packagePath
         * @param recursive
         * @param classes
         */
        public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
                                                            Set<Class<?>> classes) {
            // 获取此包的目录 建立一个File
            File dir = new File(packagePath);
            // 如果不存在或者 也不是目录就直接返回
            if (!dir.exists() || !dir.isDirectory()) {
                // log.warn("用户定义包名 " + packageName + " 下没有任何文件");
                return;
            }
            // 如果存在 就获取包下的所有文件 包括目录
            File[] dirfiles = dir.listFiles(new FileFilter() {
                // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
                public boolean accept(File file) {
                    return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
                }
            });
            // 循环所有文件
            for (File file : dirfiles) {
                // 如果是目录 则继续扫描
                if (file.isDirectory()) {
                    findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
                            classes);
                } else {
                    // 如果是java类文件 去掉后面的.class 只留下类名
                    String className = file.getName().substring(0, file.getName().length() - 6);
                    try {
                        // 添加到集合中去
                        // classes.add(Class.forName(packageName + '.' + className));
                        // 经过回复同学的提醒,这里用forName有一些不好,会触发static方法,没有使用classLoader的load干净
                        classes.add(
                                Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
                    } catch (ClassNotFoundException e) {
                        // log.error("添加用户自定义视图类错误 找不到此类的.class文件");
                        e.printStackTrace();
                    }
                }
            }
        }
    
        // --------------------------------------------------------------------------------------------------------
    
        @SuppressWarnings({"rawtypes", "unchecked"})
        public static Set<Class<?>> getByInterface(Class clazz, Set<Class<?>> classesAll) {
            Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
            // 获取指定接口的实现类
            if (!clazz.isInterface()) {
                try {
                    /**
                     * 循环判断路径下的所有类是否继承了指定类 并且排除父类自己
                     */
                    Iterator<Class<?>> iterator = classesAll.iterator();
                    while (iterator.hasNext()) {
                        Class<?> cls = iterator.next();
                        /**
                         * isAssignableFrom该方法的解析,请参考博客:
                         * http://blog.csdn.net/u010156024/article/details/44875195
                         */
                        if (clazz.isAssignableFrom(cls)) {
                            if (!clazz.equals(cls)) {// 自身并不加进去
                                classes.add(cls);
                            } else {
    
                            }
                        }
                    }
                } catch (Exception e) {
                    System.out.println("出现异常");
                }
            }
            return classes;
        }
    
    }

     

    展开全文
  • 首先来看看使用反射来获取注解名: 只需在获取class后调用getAnnotation方法即可,如下 这里是获取JPA映射b表名,Table.class,使用下面这个可以获取表名 import javax.persistence.Table; annotation.name() 这里...
  • 即可打印出所有注解 org.springframework.beans.factory.annotation.Autowired org.springframework.beans.factory.annotation.Configurable org.springframework.beans.factory.annotation.Lookup org....

    引入依赖包

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

    编写如下java代码:

    import org.reflections.Reflections;
    
    import java.lang.annotation.Annotation;
    
    
    public class Main {
        public static void main(String[] args) {
            new Reflections("org.springframework")
                    .getSubTypesOf(Annotation.class)
                    .stream()
                    .map(clazz->clazz.getName())
                    .sorted()
                    .forEach(System.out::println);
        }
    }
    

    即可打印出所有的注解

    org.springframework.beans.factory.annotation.Autowired
    org.springframework.beans.factory.annotation.Configurable
    org.springframework.beans.factory.annotation.Lookup
    org.springframework.beans.factory.annotation.Qualifier
    org.springframework.beans.factory.annotation.Required
    org.springframework.beans.factory.annotation.Value
    org.springframework.cache.annotation.CacheConfig
    org.springframework.cache.annotation.CacheEvict
    org.springframework.cache.annotation.CachePut
    org.springframework.cache.annotation.Cacheable
    org.springframework.cache.annotation.Caching
    org.springframework.cache.annotation.EnableCaching
    org.springframework.context.annotation.Bean
    org.springframework.context.annotation.ComponentScan
    org.springframework.context.annotation.ComponentScan$Filter
    org.springframework.context.annotation.ComponentScans
    org.springframework.context.annotation.Conditional
    org.springframework.context.annotation.Configuration
    org.springframework.context.annotation.DependsOn
    org.springframework.context.annotation.Description
    org.springframework.context.annotation.EnableAspectJAutoProxy
    org.springframework.context.annotation.EnableLoadTimeWeaving
    org.springframework.context.annotation.EnableMBeanExport
    org.springframework.context.annotation.Import
    org.springframework.context.annotation.ImportResource
    org.springframework.context.annotation.Lazy
    org.springframework.context.annotation.Primary
    org.springframework.context.annotation.Profile
    org.springframework.context.annotation.PropertySource
    org.springframework.context.annotation.PropertySources
    org.springframework.context.annotation.Role
    org.springframework.context.annotation.Scope
    org.springframework.context.event.EventListener
    org.springframework.core.annotation.AliasFor
    org.springframework.core.annotation.Order
    org.springframework.format.annotation.DateTimeFormat
    org.springframework.format.annotation.NumberFormat
    org.springframework.jmx.export.annotation.ManagedAttribute
    org.springframework.jmx.export.annotation.ManagedMetric
    org.springframework.jmx.export.annotation.ManagedNotification
    org.springframework.jmx.export.annotation.ManagedNotifications
    org.springframework.jmx.export.annotation.ManagedOperation
    org.springframework.jmx.export.annotation.ManagedOperationParameter
    org.springframework.jmx.export.annotation.ManagedOperationParameters
    org.springframework.jmx.export.annotation.ManagedResource
    org.springframework.lang.NonNull
    org.springframework.lang.NonNullApi
    org.springframework.lang.NonNullFields
    org.springframework.lang.Nullable
    org.springframework.lang.UsesJava7
    org.springframework.lang.UsesJava8
    org.springframework.lang.UsesSunHttpServer
    org.springframework.lang.UsesSunMisc
    org.springframework.objenesis.instantiator.annotations.Instantiator
    org.springframework.scheduling.annotation.Async
    org.springframework.scheduling.annotation.EnableAsync
    org.springframework.scheduling.annotation.EnableScheduling
    org.springframework.scheduling.annotation.Scheduled
    org.springframework.scheduling.annotation.Schedules
    org.springframework.stereotype.Component
    org.springframework.stereotype.Controller
    org.springframework.stereotype.Indexed
    org.springframework.stereotype.Repository
    org.springframework.stereotype.Service
    org.springframework.validation.annotation.Validated

     

    展开全文
  • 自定义了Controller和RequestMapping两个注解,先去扫描加了@Controller注解的类,接着扫描这些类下面加了@RequestMapping注解的方法,然后通过Java的反射invoke方法去调用加了RequestMapping注解的方法并输出注解上...

    Reflections 通过扫描 classpath,索引元数据,允许在运行时查询这些元数据,也可以保存收集项目中多个模块的元数据信息。

    使用Reflections快速扫描指定包下自定义的Controller和RequestMapping两个注解,先去扫描加了@Controller注解的类,接着获取这些类下面加了@RequestMapping注解的方法,然后通过Java的反射invoke方法去调用加了RequestMapping注解的方法并输出注解上的信息。

    Maven 项目导入

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

    annotation包下面自定义了两个注解。

    Controller.java:

    package annotationTest.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.TYPE)// 注解会在class字节码文件中存在,在运行时可以通过反射获取到
    @Retention(RetentionPolicy.RUNTIME)//定义注解的作用目标**作用范围字段、枚举的常量/方法
    @Documented//说明该注解将被包含在javadoc中
    public @interface Controller {
        String value() default "";
    }
    

    RequestMapping.java

    package annotationTest.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface RequestMapping {
        String value() default "";
    
        /**
         * 是否为序列号
         *
         * @return
         */
        boolean id() default false;
    
        /**
         * 字段名称
         *
         * @return
         */
        String name() default "";
    
        /**
         * 字段描述
         *
         * @return
         */
        String description() default "";
    }
    

    在model包下面定义了一个存放RequestMapping注解方法的对象

    ExecutorBean.java

    package annotationTest.model;
    
    import java.lang.reflect.Method;
    
    public class ExecutorBean {
        private Object object;
    
        private Method method;
    
        public Object getObject() {
            return object;
        }
    
        public void setObject(Object object) {
            this.object = object;
        }
    
        public Method getMethod() {
            return method;
        }
    
        public void setMethod(Method method) {
            this.method = method;
        }
    }
    

    service包下面定义了几个类,其中有两个类使用了自定义的Controller注解

    SunService.java

    package annotationTest.service;
    
    import annotationTest.annotation.Controller;
    import annotationTest.annotation.RequestMapping;
    
    @Controller
    public class SunService {
        @RequestMapping(id = true, name = "test1", description = "sun测试1", value = "/test1")
        public void test1() {
            System.out.println("SunService->test1()");
        }
    
        @RequestMapping(id = true, name = "test2", description = "sun测试2", value = "/test2")
        public void test2() {
            System.out.println("SunService->test2()");
        }
    }
    

    MoonService.java

    package annotationTest.service;
    
    import annotationTest.annotation.Controller;
    import annotationTest.annotation.RequestMapping;
    
    @Controller
    public class MoonService {
        @RequestMapping(id = true, name = "moon测试3", description = "/test3", value = "/test3")
        public void test3() {
            System.out.println("MoonService->test3()");
        }
    
        @RequestMapping(id = true, name = "moon测试4", description = "/test4", value = "/test4")
        public void test4() {
            System.out.println("MoonService->test4()");
        }
    }
    

    Stars.java

    package annotationTest.service;
    
    import annotationTest.annotation.RequestMapping;
    
    public class Stars {
        @RequestMapping(id = true, name = "test1", description = "stars测试1", value = "/test1")
        public void test1() {
            System.out.println("Stars->test1()");
        }
    }
    

    util包下面定义了一个工具类,来对包进行扫描获取自定义注解的类和方法

    AnnoManageUtil.java

    package annotationTest.util;
    
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    import annotationTest.annotation.Controller;
    import annotationTest.annotation.RequestMapping;
    import annotationTest.model.ExecutorBean;
    import org.reflections.Reflections;
    
    public final class AnnoManageUtil {
    
        /**
         * 获取指定文件下面的RequestMapping方法保存在mapp中
         *
         * @param packageName
         * @return
         */
        public static Map<String, ExecutorBean> getRequestMappingMethod(String packageName) {
            Reflections reflections = new Reflections(packageName);
            Set<Class<?>> classesList = reflections.getTypesAnnotatedWith(Controller.class);
    
            // 存放url和ExecutorBean的对应关系
            Map<String, ExecutorBean> mapp = new HashMap<String, ExecutorBean>();
            for (Class classes : classesList) {
                //得到该类下面的所有方法
                Method[] methods = classes.getDeclaredMethods();
    
                for (Method method : methods) {
                    //得到该类下面的RequestMapping注解
                    RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
                    if (null != requestMapping) {
                        ExecutorBean executorBean = new ExecutorBean();
                        try {
                            executorBean.setObject(classes.newInstance());
                        } catch (InstantiationException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                        executorBean.setMethod(method);
                        mapp.put(requestMapping.value(), executorBean);
    
                    }
                }
            }
            return mapp;
        }
    
    }
    

    test包下面是一个测试的类

    package annotationTest.test;
    
    import java.lang.reflect.InvocationTargetException;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import annotationTest.annotation.Controller;
    import annotationTest.annotation.RequestMapping;
    import annotationTest.model.ExecutorBean;
    import annotationTest.util.AnnoManageUtil;
    
    public class Test {
        public static void main(String[] args) {
            List<Class<?>> classesList = null;
            classesList = AnnoManageUtil.getPackageController("annotationTest.service", Controller.class);
            Map<String, ExecutorBean> mmap = new HashMap<String, ExecutorBean>();
            AnnoManageUtil.getRequestMappingMethod(classesList, mmap);
            ExecutorBean bean = mmap.get("/test1");
    
            try {
                bean.getMethod().invoke(bean.getObject());
                RequestMapping annotation = bean.getMethod().getAnnotation(RequestMapping.class);
                System.out.println("注解名称:" + annotation.name() + "\t注解描述:" + annotation.description());
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }
    

    运行得到:

    其他

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

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

      Reflections 依赖 Google 的 Guava 库和 Javassist 库。

    2. 使用注解修饰了类/方法/成员变量等之后,这些注解不会自己生效,必须由这些注解的开发者提供相应的工具来提取并处理注解信息(当然,只有当定义注解时使用了@Retention(RetentionPolicy.RUNTIME)修饰,JVM才会在装载class文件时提取保存在class文件中的注解,该注解才会在运行时可见,这样我们才能够解析).

    3. Java使用Annotation接口来代表程序元素前面的注解,该接口是所有注解的父接口。

    4. java5在java.lang.reflect包下新增了 用AnnotatedElement接口代表程序中可以接受注解的程序元素.

    5. AnnotatedElement接口的实现类有:Class(类元素)、Field(类的成员变量元素)、Method(类的方法元素)、Package(包元素),每一个实现类代表了一个可以接受注解的程序元素类型。

    6. 这样, 我们只需要获取到Class、 Method、 Filed等这些实现了AnnotatedElement接口的类的实例,通过该实例对象调用该类中的方法(AnnotatedElement接口中抽象方法的重写) 就可以获取到我们想要的注解信息了。

    7. 获得Class类的实例有三种方法:

      • 利用对象调用getClass()方法获得Class实例
      • 利用Class类的静态的forName()方法,使用类名获得Class实例
      • 运用.class的方式获得Class实例,如:类名.class
    8. AnnotatedElement接口提供的抽象方法(在该接口的实现类中重写了这些方法):

      • <T extends Annotation> T getAnnotation(Class< T> annotationClass)&lt T extends Annotation>为泛型参数声明,表明A的类型只能是Annotation类型或者是Annotation的子类。
        功能:返回该程序元素上存在的、指定类型的注解,如果该类型的注解不存在,则返回null
      • Annotation[] getAnnotations()
        功能:返回此元素上存在的所有注解,包括没有显示定义在该元素上的注解(继承得到的)。(如果此元素没有注释,则返回长度为零的数组。)
      • < T extends Annotation> T getDeclaredAnnotation(Class < T> annotationClass)
        功能:这是Java8新增的方法,该方法返回直接修饰该程序元素、指定类型的注解(忽略继承的注解)。如果该类型的注解不存在,返回null.
      • Annotation[] getDeclaredAnnotations()
        功能:返回直接存在于此元素上的所有注解,该方法将忽略继承的注释。(如果没有注释直接存在于此元素上,则返回长度为零的一个数组。)
      • boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
        功能:判断该程序元素上是否存在指定类型的注解,如果存在则返回true,否则返回false。
      • &ltT extends Annotation> T[] getAnnotationsByTpye(Class<T> annotationClass)
        功能: 因为java8增加了重复注解功能,因此需要使用该方法获得修饰该程序元素、指定类型的多个注解。
      • <T extends Annotation> T[] getDeclaredAnnotationsByTpye(Class<T>annotationClass)
        功能: 因为java8增加了重复注解功能,因此需要使用该方法获得直接修饰该程序元素、指定类型的多个注解。

    Class提供了getMethod()、getField()以及getConstructor()方法(还有其他方法),这些方法分别获取与方法、域变量以及构造函数相关的信息,这些方法返回Method、Field 以及Constructor类型的对象。

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

    千次阅读 2019-06-11 08:45:51
    //获取bean对象 System.out.println("================"+clazz.getName()); ComponentDesc componentDesc = AnnotationUtils.findAnnotation(clazz,ComponentDesc.class); System.out.println("=================...
    
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.context.ApplicationListener;
    import org.springframework.context.event.ContextRefreshedEvent;
    import org.springframework.core.annotation.AnnotationUtils;
    
    import java.lang.annotation.Annotation;
    import java.util.Map;
    import java.util.Set;
    
    
    public class ComponentScannerConfigurerBk implements ApplicationListener<ContextRefreshedEvent>, ApplicationContextAware {
        private ComponentScannerConfigurer registrationCenter;
    
    
        private ApplicationContext applicationContext;
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext = applicationContext;
        }
    
        @Override
        public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
            Class<? extends Annotation> annotationClass = ComponentDesc.class;
            Map<String,Object> beanWhithAnnotation = applicationContext.getBeansWithAnnotation(annotationClass);
            Set<Map.Entry<String,Object>> entitySet = beanWhithAnnotation.entrySet();
            for (Map.Entry<String,Object> entry :entitySet){
                Class<? extends Object> clazz = entry.getValue().getClass();//获取bean对象
                System.out.println("================"+clazz.getName());
                ComponentDesc componentDesc = AnnotationUtils.findAnnotation(clazz,ComponentDesc.class);
                System.out.println("==================="+componentDesc.channel());
    
            }
        }
    }
    

     

    展开全文
  • 简单demo,导入即可运行。
  • //获取bean对象 System.out.println("================"+clazz.getName()); ComponentDesc componentDesc = AnnotationUtils.findAnnotation(clazz,ComponentDesc.class); System.out.println("===================...
  • springboot读取所有自定义注解

    千次阅读 2020-12-28 16:34:07
    自定义注解 Permission package org.com.rsmall.wx.ann; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang....
  • 获取带有指定注解所有类对象

    千次阅读 2020-11-03 20:25:15
    获取带有指定注解所有类对象 最近在项目上需要实现一个功能:项目启动的时候需要获取带有指定注解所有类的类对象,通过类对象去操作类中的方法和属性 一开始也想到了使用反射,自己写的代码有点多,不好扩展,...
  • NULL 博文链接:https://zhaohaiyang.iteye.com/blog/1483811
  • 主要介绍了Java基于反射机制实现全部注解获取的方法,结合实例形式分析了java反射机制获取注解的具体实现方法与操作注意事项,需要的朋友可以参考下
  • //获取类上所有注解 Annotation[] annotations = r.getAnnotations(); //获取类上指定的注解 ClassAnnotation classAnnotation =r.getAnnotation(ClassAnnotation.class); //注解的全限定类名 String aClass = ...
  • } //获取类中的所有的方法 Method[] methods = cls.getMethods(); for (Method method : methods) { RequiresPermissions annotation = method.getAnnotation(RequiresPermissions.class); ApiOperation ...
  • } // 类注解 /** * class function quanxian 方法注解 * @test 权限 */ // 调用 $result = getControllers('../app/controller'); dump($result); foreach ($result as $v) { $m = getActions($v); dump($m); }
  • java 通过反射获取类上注解,方法上注解注解里的值及方法参数,项目为maven项目。导入时记得选择maven项目
  • aop 获取注解注释的方法 有时,我想记录(通过slf4j和log4j )方法的每次执行,查看其接收的参数,返回的内容以及每次执行花费的时间。 这是我在AspectJ , jcabi-aspects和Java 6注释的帮助下所做的事情: public...
  • 自定义注解和通过反射获取注解
  • Spring获取注解下的所有类(bean),前提是该类在是spring容器进行了注册。Spring获取注解为null注解类NettyHandler无法获取注解NettyHandler问题分析解决方案调整后代码 注解类NettyHandler import java.lang....
  • 因为做了RBAC结构的权限模型,又懒得写管理界面,就直接一网打尽,写一个获取所有url路径和swagger文档注解的方法,然后百度了下,大部分都是只获取URL接口路径,我拓展了下,可以加上方法的注解参数。 swagger...
  • java中借助Spring获取所有带有指定注解的接口、类、对象 原创 2016年11月19日 15:34:06 标签:J2EE /Spring /注解 /java /Annotation 4885 最近因为遇到有这个需求,花了两天的时间...
  • 需求 近来项目中有个新需求,审计记录中除了...项目加载时获取所有的Controller类 - 路径 - 接口名 - 接口说明 - 接口发布说明到系统全局变量 日志记录时根据url获取接口发布说明 实现代码 import java.util.ArrayList
  • 最近项目中遇到一个业务场景,就是在Spring容器启动后获取所有的Bean中实现了一个特定接口的对象,第一个想到的是ApplicationContextAware,在setApplicationContext中去通过ctx获取所有的bean,后来发现好像逻辑...
  • java获取类与方法的注解注释

    千次阅读 2020-09-03 17:12:10
    第一、获取注解 @Test(description = "获取类、方法注解") public void test(){ //类注解信息 Annotation[] annotations = zwliu.class.getAnnotations(); String s = annotations[0].toString(); System.out....
  • oracle获取当前用户下所有的表名和表注释 select a.table_name,b.comments from user_tables a,user_tab_comments b where a.table_name=b.table_name order by table_name;
  • 利用反射获取requestMapping注解的value,springMvc实现路径映射功能的逻辑
  • sqlite 注解获取建表sql

    2017-03-06 16:05:01
    在sqlite 中,利用注解,反射,将jave bean转为建表语句。利用反射将cursor构建bean或者list.
  • python的注解是通过装饰器模式实现的,@注解本质是一个函数 def my_annotation(**kwds): def decorate(fn): for item in kwds.items(): print(item) return fn return decorate @my_annotation(value="this ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,084,339
精华内容 433,735
关键字:

获取所有注解