java注解@Resource机制怎么取到注入过的Bean

java注解@Resource机制如何取到注入过的Bean

SSH2项目整合案例

在ApplicationContextxml中Spring注入Bean(以BaseDao为类)，以下两种方法通过Java Application测试：

第一种：

ApplicationContext act = new ClassPathXmlApplicationContext("ApplicationContextxml");

baseDao = actgetBean("baseDao");

Systemoutprintln(baseDao);

测试结果：打印出来不为空，即已经成功取得对象。

第二种：

首先已经在ApplicationContextxml添加了<context:annoation-config />

//定义属性

@Resource

BaseDao baseDao;

//测试方法

Systemoutprintln(baseDao);

测试结果：打印出来为空。

但是我Tomcat启动后，通过浏览器访问，在Debug模式下，查看baseDao的确可以获取到，为什么Java Application测试却不能获取。

我一个小猜测：是不是@Resource注解依赖Tomcat服务器运行。

[解决办法]

@Resource

是运行时注入，要依赖WEB容器。

第一种配置文件其实是通过XML文件直接构造BEAN

[解决办法]

LS别误导人

@Resource和@Autowired

是spring用来做注解式注入的标记

区别在于resource按照名称装配,autowired按照类型装配

resource标记是java5的一部分,autowired是spring自身的标记,autowired也可以配合Qualifier达到名称装配的目的

在app项目应用spring自动装配应该在xml中配置

<context:component-scan base-package="comproject" />

这个才是注解自动扫描的配置

<context:annoation-config />

这个标记主要用在spring-mvc中

[解决办法]

没有看我说的吗

依赖注入完全不需要依靠应用服务器

IoC是Spring框架核心的一部分

[解决办法]

应用本身不对所依赖的进行创建和管理。交给第三方容器来处理。

[解决办法]

ApplicationContext act = new ClassPathXmlApplicationContext("ApplicationContextxml");

第二种有这一句么？如果没有的话 Spring 怎么会帮你注入呢？

[解决办法]

不知道lz是否用的spring 30x，既然用全注解，写testcase，那么按照标准的目录结构来看，应该是在src/test/java/和src/test/resources中写testcase和存放资源文件。

那么，

在你的testcase中，

class上面应该有这样的类似描述：

XML code@RunWith(SpringJUnit4ClassRunnerclass) //指定测试用例的运行器 这里是指定了Junit4//指定Spring的配置文件 /为classpath下@ContextConfiguration({"/liehuo-applicationContext-DAOxml", "/liehuo-applicationContext-Servicexml", "/liehuo-applicationContext-Transactionxml", "/liehuo-applicationContext-DataSourcexml"}) //指定Spring的配置文件 /为classpath下 //@Transactional //对所有的测试方法都使用事务，并在测试完成后回滚事务 //@Rollback(false) //这里设置为false，就让事务不回滚public class DAOTestCase extends AbstractTransactionalJUnit4SpringContextTests{ protected Log logger = LogFactorygetLog(getClass()); public DAOTestCase(){ }}

[解决办法]

只要启动了spring容器，就可以使用注解注入。不一定要web容器的。

但是你必须在类上标注@Service ,@Repository之类的 让spring管理类。

@Resource 是java定义的规范，不单可一注入spring的资源，

也可以按jndi注入ejb对象

[解决办法]

需要添加：

<context:component-scan base-package="comproject" />

让spring扫描。

定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK15及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

你说的应该是注解吧，注释本身就是一种说明性的作用，JAVA文件在被编译到CLASS文件后是不存在注释的，注解不一样，可以通过反射获取，但是JAVA文件被编译后，注解也不一定存在，这个取决于你所定义注解的生命周期。

使用注解

在一般的Java开发中，最常接触到的可能就是@Override和@SupressWarnings这两个注解了。使用@Override的时候只需要一个简单的声明即可。这种称为标记注解（marker annotation ），它的出现就代表了某种配置语义。而其它的注解是可以有自己的配置参数的。配置参数以名值对的方式出现。使用 @SupressWarnings的时候需要类似@SupressWarnings({"uncheck", "unused"})这样的语法。在括号里面的是该注解可供配置的值。由于这个注解只有一个配置参数，该参数的名称默认为value，并且可以省略。而花括号则表示是数组类型。在JPA中的@Table注解使用类似@Table(name = "Customer", schema = "APP")这样的语法。从这里可以看到名值对的用法。在使用注解时候的配置参数的值必须是编译时刻的常量。

从某种角度来说，可以把注解看成是一个XML元素，该元素可以有不同的预定义的属性。而属性的值是可以在声明该元素的时候自行指定的。在代码中使用注解，就相当于把一部分元数据从XML文件移到了代码本身之中，在一个地方管理和维护。

开发注解

在一般的开发中，只需要通过阅读相关的API文档来了解每个注解的配置参数的含义，并在代码中正确使用即可。在有些情况下，可能会需要开发自己的注解。这在库的开发中比较常见。注解的定义有点类似接口。下面的代码给出了一个简单的描述代码分工安排的注解。通过该注解可以在源代码中记录每个类或接口的分工和进度情况。

@Retention(RetentionPolicyRUNTIME)

@Target(ElementTypeTYPE)

public @interface Assignment {

    String assignee();

    int effort();

    double finished() default 0;

}

@interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型。可以通过default来声明参数的默认值。在这里可以看到@Retention和@Target这样的元注解，用来声明注解本身的行为。@Retention用来声明注解的保留策略，有CLASS、RUNTIME和SOURCE这三种，分别表示注解保存在类文件、JVM运行时刻和源代码中。只有当声明为RUNTIME的时候，才能够在运行时刻通过反射API来获取到注解的信息。@Target用来声明注解可以被添加在哪些类型的元素上，如类型、方法和域等。

处理注解

在程序中添加的注解，可以在编译时刻或是运行时刻来进行处理。在编译时刻处理的时候，是分成多趟来进行的。如果在某趟处理中产生了新的Java源文件，那么就需要另外一趟处理来处理新生成的源文件。如此往复，直到没有新文件被生成为止。在完成处理之后，再对Java代码进行编译。JDK 5中提供了apt工具用来对注解进行处理。apt是一个命令行工具，与之配套的还有一套用来描述程序语义结构的Mirror API。Mirror API（comsunmirror）描述的是程序在编译时刻的静态结构。通过Mirror API可以获取到被注解的Java类型元素的信息，从而提供相应的处理逻辑。具体的处理工作交给apt工具来完成。编写注解处理器的核心是AnnotationProcessorFactory和AnnotationProcessor两个接口。后者表示的是注解处理器，而前者则是为某些注解类型创建注解处理器的工厂。

以上面的注解Assignment为例，当每个开发人员都在源代码中更新进度的话，就可以通过一个注解处理器来生成一个项目整体进度的报告。 首先是注解处理器工厂的实现。

public class AssignmentApf implements AnnotationProcessorFactory {  

    public AnnotationProcessor getProcessorFor(Set<AnnotationTypeDeclaration> atds, AnnotationProcessorEnvironment env) {

        if (atdsisEmpty()) {

           return AnnotationProcessorsNO_OP;

        }

        return new AssignmentAp(env); //返回注解处理器

    } 

    public Collection<String> supportedAnnotationTypes() {

        return CollectionsunmodifiableList(ArraysasList("annotationAssignment"));

    }

    public Collection<String> supportedOptions() {

        return CollectionsemptySet();

    }

}

AnnotationProcessorFactory接口有三个方法：getProcessorFor是根据注解的类型来返回特定的注解处理器；supportedAnnotationTypes是返回该工厂生成的注解处理器所能支持的注解类型；supportedOptions用来表示所支持的附加选项。在运行apt命令行工具的时候，可以通过-A来传递额外的参数给注解处理器，如-Averbose=true。当工厂通过 supportedOptions方法声明了所能识别的附加选项之后，注解处理器就可以在运行时刻通过AnnotationProcessorEnvironment的getOptions方法获取到选项的实际值。注解处理器本身的基本实现如下所示。

public class AssignmentAp implements AnnotationProcessor { 

    private AnnotationProcessorEnvironment env;

    private AnnotationTypeDeclaration assignmentDeclaration;

    public AssignmentAp(AnnotationProcessorEnvironment env) {

        thisenv = env;

        assignmentDeclaration = (AnnotationTypeDeclaration) envgetTypeDeclaration("annotationAssignment");

    }

    public void process() {

        Collection<Declaration> declarations = envgetDeclarationsAnnotatedWith(assignmentDeclaration);

        for (Declaration declaration : declarations) {

           processAssignmentAnnotations(declaration);

        }

    }

    private void processAssignmentAnnotations(Declaration declaration) {

        Collection<AnnotationMirror> annotations = declarationgetAnnotationMirrors();

        for (AnnotationMirror mirror : annotations) {

            if (mirrorgetAnnotationType()getDeclaration()equals(assignmentDeclaration)) {

                Map<AnnotationTypeElementDeclaration, AnnotationValue> values = mirrorgetElementValues();

                String assignee = (String) getAnnotationValue(values, "assignee"); //获取注解的值

            }

        }

    }   

}

注解处理器的处理逻辑都在process方法中完成。通过一个声明（Declaration）的getAnnotationMirrors方法就可以获取到该声明上所添加的注解的实际值。得到这些值之后，处理起来就不难了。

在创建好注解处理器之后，就可以通过apt命令行工具来对源代码中的注解进行处理。 命令的运行格式是apt -classpath bin -factory annotationaptAssignmentApf src/annotation/work/java，即通过-factory来指定注解处理器工厂类的名称。实际上，apt工具在完成处理之后，会自动调用javac来编译处理完成后的源代码。

JDK 5中的apt工具的不足之处在于它是Oracle提供的私有实现。在JDK 6中，通过JSR 269把自定义注解处理器这一功能进行了规范化，有了新的javaxannotationprocessing这个新的API。对Mirror API也进行了更新，形成了新的javaxlangmodel包。注解处理器的使用也进行了简化，不需要再单独运行apt这样的命令行工具，Java编译器本身就可以完成对注解的处理。对于同样的功能，如果用JSR 269的做法，只需要一个类就可以了。

@SupportedSourceVersion(SourceVersionRELEASE_6)

@SupportedAnnotationTypes("annotationAssignment")

public class AssignmentProcess extends AbstractProcessor {

    private TypeElement assignmentElement; 

    public synchronized void init(ProcessingEnvironment processingEnv) {

        superinit(processingEnv);

        Elements elementUtils = processingEnvgetElementUtils();

        assignmentElement = elementUtilsgetTypeElement("annotationAssignment");

    } 

    public boolean process(Set< extends TypeElement> annotations, RoundEnvironment roundEnv) {

        Set< extends Element> elements = roundEnvgetElementsAnnotatedWith(assignmentElement);

        for (Element element : elements) {

            processAssignment(element);

        }

    }

    private void processAssignment(Element element) {

        List< extends AnnotationMirror> annotations = elementgetAnnotationMirrors();

        for (AnnotationMirror mirror : annotations) {

            if (mirrorgetAnnotationType()asElement()equals(assignmentElement)) {

                Map< extends ExecutableElement,  extends AnnotationValue> values = mirrorgetElementValues();

                String assignee = (String) getAnnotationValue(values, "assignee"); //获取注解的值

            }

        }

    } 

}

仔细比较上面两段代码，可以发现它们的基本结构是类似的。不同之处在于JDK 6中通过元注解@SupportedAnnotationTypes来声明所支持的注解类型。另外描述程序静态结构的javaxlangmodel包使用了不同的类型名称。使用的时候也更加简单，只需要通过javac -processor annotationpapAssignmentProcess Demo1java这样的方式即可。

上面介绍的这两种做法都是在编译时刻进行处理的。而有些时候则需要在运行时刻来完成对注解的处理。这个时候就需要用到Java的反射API。反射API提供了在运行时刻读取注解信息的支持。不过前提是注解的保留策略声明的是运行时。Java反射API的AnnotatedElement接口提供了获取类、方法和域上的注解的实用方法。比如获取到一个Class类对象之后，通过getAnnotation方法就可以获取到该类上添加的指定注解类型的注解。

实例分析

下面通过一个具体的实例来分析说明在实践中如何来使用和处理注解。假定有一个公司的雇员信息系统，从访问控制的角度出发，对雇员的工资的更新只能由具有特定角色的用户才能完成。考虑到访问控制需求的普遍性，可以定义一个注解来让开发人员方便的在代码中声明访问控制权限。

@Retention(RetentionPolicyRUNTIME)

@Target(ElementTypeMETHOD)

public @interface RequiredRoles {

    String[] value();

}

下一步则是如何对注解进行处理，这里使用的Java的反射API并结合动态代理。下面是动态代理中的InvocationHandler接口的实现。

public class AccessInvocationHandler<T> implements InvocationHandler {

    final T accessObj;

    public AccessInvocationHandler(T accessObj) {

        thisaccessObj = accessObj;

    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        RequiredRoles annotation = methodgetAnnotation(RequiredRolesclass); //通过反射API获取注解

        if (annotation != null) {

            String[] roles = annotationvalue();

            String role = AccessControlgetCurrentRole();

            if (!ArraysasList(roles)contains(role)) {

                throw new AccessControlException("The user is not allowed to invoke this method");

            }

        }

        return methodinvoke(accessObj, args);

    } 

}

在具体使用的时候，首先要通过ProxynewProxyInstance方法创建一个EmployeeGateway的接口的代理类，使用该代理类来完成实际的 *** 作。

import javalangannotationRetention;

import javalangannotationRetentionPolicy;

@Retention(value=RetentionPolicyRUNTIME)

public @interface MyAnnotation {

String name();

}

public class AnnonTestA {

public void methodA(){

}

@MyAnnotation(name="111")

public void methodA(String a) throws Exception{

AnnonTestBmethodB("methodA",Stringclass);

}

}import javalangannotationAnnotation;

import javalangreflectMethod;

public class AnnonTestB {

public static void methodB(String methodName, Class<> parameterTypes) throws Exception {

AnnonTestA annonTestA = new AnnonTestA();

// 获取AnnotationTest2的Class实例

Class<AnnonTestA> c = AnnonTestAclass;

// 获取需要处理的方法Method实例

Method method = cgetMethod(methodName, parameterTypes);

Method[] methods = cgetMethods();

// 判断该方法是否包含MyAnnotation注解

if (methodisAnnotationPresent(MyAnnotationclass)) {

// 获取该方法的MyAnnotation注解实例

MyAnnotation myAnnotation = method

getAnnotation(MyAnnotationclass);

// 执行该方法

// methodinvoke(annonTestA, "12345");

// 获取myAnnotation

String value1 = myAnnotationname();

Systemoutprintln(value1);

}

// 获取方法上的所有注解

Annotation[] annotations = methodgetAnnotations();

for (Annotation annotation : annotations) {

Systemoutprintln(annotation);

}

}

}import javaio;

import javalangannotationAnnotation;

import javalangreflectMethod;

public class TestString {

public static void main(String[] args) throws Exception {

AnnonTestA annonTestA = new AnnonTestA();

annonTestAmethodA("123");

}

}

代码都给上了，不明白再追问吧。

参考地址：>

随着互联网的不断发展，java编程开发依然是目前互联网行业中的主流编程开发语言。今天我们就通过案例分析来了解一下，java框架的使用都有哪些要点。

需求简介

可以使用注解标记类为组件，并自动扫描包路径，识别组件类。

获取注解信息，将组件类注册到容器中，供以后的访问使用。

解析组件之间的依赖关系，初始化组件类，并注入相关依赖。

从容器中获取组件类的实例，并正常调用相应的方法。

项目框架

整个项目大致分为以下几个包：

annotation包中定义了一些容器所需要的注解，比如Component，Service等注解。

container包是容器的主要实现，负责处理容器的相关功能，如依赖注入等。

context包定义了上下文环境，负责扫描组件，以及依赖解析等过程。

exception包定义了项目所需的异常。

proxy包定义了两种动态代理的方式，一种是Jdk的动态代理实现，另一种是CGlib方式。

utils包定义了一些工具类。

注解扫描

在相关注解的定义完成之后，需要进行扫描，将标记有@Component等注解的类扫描出来，以进行下一步的处理。

整个扫描的过程实际上是对类进行扫描，霍营北大青鸟

认为可以通过Java的ClassLoader来扫描类路径，将类加载进一个集合中。这个过程的部分代码如下，完整代码可以在utils包下的ReflectUtil中查看。

容器的实现

容器这个功能可以说是依赖注入的核心之一了，容器是对所有组件的管理，基本上所有的功能都围绕着容器来开展。

以上就是关于java注解@Resource机制怎么取到注入过的Bean全部的内容，包括:java注解@Resource机制怎么取到注入过的Bean、java 注解处理器(AbstractProcessor) 获取到 指定注解的属性值 javapoet 如何使用这个值生成类、如何用java 程序获取方法上的注释等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！