在这篇文章中,我们将为您详细介绍javax.servlet.annotation.WebListener的实例源码的内容,并且讨论关于javawebservlet的相关问题。此外,我们还会涉及一些关于
在这篇文章中,我们将为您详细介绍javax.servlet.annotation.WebListener的实例源码的内容,并且讨论关于java web servlet的相关问题。此外,我们还会涉及一些关于IntelliJ IDEA 出现 "java: 程序包 javax.servlet 不存在、 java: 程序包 javax.servlet.annotation" 等错误、javax.annotation.Generated的实例源码、javax.annotation.meta.TypeQualifierValidator的实例源码、javax.enterprise.inject.spi.AnnotatedParameter的实例源码的知识,以帮助您更全面地了解这个主题。
本文目录一览:- javax.servlet.annotation.WebListener的实例源码(java web servlet)
- IntelliJ IDEA 出现 "java: 程序包 javax.servlet 不存在、 java: 程序包 javax.servlet.annotation" 等错误
- javax.annotation.Generated的实例源码
- javax.annotation.meta.TypeQualifierValidator的实例源码
- javax.enterprise.inject.spi.AnnotatedParameter的实例源码
javax.servlet.annotation.WebListener的实例源码(java web servlet)
private void registerJeeComponents(ConfigurableListablebeanfactory beanfactory,ClassLoader cl,Set<BeanDeFinition> candiates) { for (BeanDeFinition bd : candiates) { try { Class<?> beanClass = ClassUtils.forName(bd.getBeanClassName(),cl); WebServlet webServlet = beanClass.getDeclaredAnnotation(WebServlet.class); WebFilter webFilter = beanClass.getDeclaredAnnotation(WebFilter.class); WebListener webListener = beanClass.getDeclaredAnnotation(WebListener.class); DefaultListablebeanfactory targetbeanfactory = (DefaultListablebeanfactory) beanfactory; if (webServlet != null) { createAndRegisterServletBean(targetbeanfactory,bd,beanClass,webServlet); } else if (webFilter != null) { createAndRegisterServletFilterBean(targetbeanfactory,webFilter); } else if (webListener != null) { createAndRegisterWebListenerBean(targetbeanfactory,webListener); } } catch (ClassNotFoundException e) { e.printstacktrace(); } } }
WebListenerHandler() { super(WebListener.class); }
WebListenerHandler() { super(WebListener.class); }
WebListenerHandler() { super(WebListener.class); }
WebListenerHandler() { super(WebListener.class); }
@Override public boolean matches(final Class<?> type) { return FeatureUtils.is(type,EventListener.class) && FeatureUtils.hasAnnotation(type,WebListener.class) && hasMatch(type,SUPPORTED); }
public void write(ClassName linkers) throws IOException { typespec.Builder typeBuilder = typespec.classBuilder(linkers.className()) .addModifiers(PUBLIC,FINAL) .addSuperinterface(servletcontextlistener.class) .addAnnotation(AnnotationSpec.builder(WebListener.class).build()) .addAnnotation(AnnotationSpec.builder(Generated.class) .addMember("value","$S",LinkerAnnotationProcessor.class.getName()) .build() ) .addField(FieldSpec.builder(String.class,"contextpath",PRIVATE,STATIC) .initializer("\"\"") .build()) .addField(FieldSpec.builder(String.class,"applicationName",STATIC) .initializer("$T.get()",get("fr.vidal.oss.jax_rs_linker","ApplicationName")) .build()) .addMethod(MethodSpec.methodBuilder("contextinitialized") .addModifiers(PUBLIC) .addAnnotation(Override.class) .returns(void.class) .addParameter(ServletContextEvent.class,"sce") .addCode( "$L = $T.contextpath($L.getServletContext(),$L);\n",contextpaths.class,"sce","applicationName") .build()) .addMethod(MethodSpec.methodBuilder("contextDestroyed") .addModifiers(PUBLIC) .addAnnotation(Override.class) .returns(void.class) .addParameter(ServletContextEvent.class,"sce") .build()) .addMethod(MethodSpec.methodBuilder("getcontextpath") .addModifiers(PUBLIC,STATIC) .returns(String.class) .addCode( "return contextpath;\n") .build()); JavaFile.builder(linkers.packageName(),typeBuilder.build()) .indent("\t") .build() .writeto(filer); }
public void findListeners(@Observes @WithAnnotations({WebListener.class}) ProcessAnnotatedType<? extends servletcontextlistener> pat) { listeners.add(pat.getAnnotatedType().getJavaClass()); }
private void createAndRegisterWebListenerBean(DefaultListablebeanfactory beanfactory,BeanDeFinition bd,Class<?> beanClass,WebListener webListener) { BeanDeFinitionBuilder builder = BeanDeFinitionBuilder.rootBeanDeFinition(ServletListenerRegistrationBean.class); builder.addPropertyValue("listener",bd); String beanName = StringUtils.uncapitalize(beanClass.getSimpleName()); beanfactory.registerBeanDeFinition(beanName,builder.getBeanDeFinition()); }
IntelliJ IDEA 出现 "java: 程序包 javax.servlet 不存在、 java: 程序包 javax.servlet.annotation" 等错误

转:
IntelliJ IDEA 出现 "java: 程序包 javax.servlet 不存在、 java: 程序包 javax.servlet.annotation" 等错误
在 IDEA 中建立 Servlet 使用 javax.servlet.http.HttpServlet 等类时,出现了如下错误:
原因:IntelliJ IDEA 没有导入 servlet-api.jar 这个.jar 包,需要手动导入。
导入步骤如下:选中项目,右击选择 “Open Modules Settings”,选择 “Libraries”,点击 “+”,选 “Java”;在弹出的窗口中选择 tomcat 所在的目录,在 lib 目录下找到 servlet-api.jar 这个 jar 包导入完成即可。
转:
IntelliJ IDEA 出现 "java: 程序包 javax.servlet 不存在、 java: 程序包 javax.servlet.annotation" 等错误
--Posted from Rpc
javax.annotation.Generated的实例源码
/** * @param project * @param itype * @return * @throws JavaModelException */ private static IPath findpathInGeneratedAnnotation(IProject project,IType itype) throws JavaModelException { Icompilationunit cu = itype.getcompilationunit(); List<IAnnotationBinding> annotations = resolveAnnotation(cu,Generated.class).getAnnotations(); if ((annotations != null) && (annotations.size() > 0)) { IAnnotationBinding ab = annotations.get(0); IMemberValuePairBinding[] attributes = ab.getAllMemberValuePairs(); for (int i = 0; i < attributes.length; i++) { IMemberValuePairBinding attribut = attributes[i]; if (attribut.getName().equalsIgnoreCase("value")) { Object[] o = (Object[]) attribut.getValue(); if (o != null && o.length > 0 && String.valueOf(o[0]).trim().length() > 0) { try { IPath p = ResourceManager.find(project,String.valueOf(o[0]).trim()); return p; } catch (Exception e) { ResourceManager.logException(e); return null; } } } } } return null; }
/** * genera classe di test per clazz * * @param clazz * @param prop * @param mongo * @return */ @Override public typespec gettypespec(Class<?> clazz) { Builder classtestBuilder = typespec.classBuilder(clazz.getSimpleName() + TEST); ClassName superClass = ClassName.get( PropertiesUtils.getrequiredProperty(prop,PropertiesUtils.TEST_BASE_PACKAGE),PropertiesUtils.getrequiredProperty(prop,PropertiesUtils.TEST_BASE_CLASS)); classtestBuilder.superclass(superClass); classtestBuilder.addJavadoc("@author \n"); classtestBuilder.addModifiers(Modifier.PUBLIC); AnnotationSpec.Builder annSpecBuilder = AnnotationSpec.builder(Generated.class); annSpecBuilder.addMember("value","\"it.fratta.jerkoff.Generator\""); annSpecBuilder.addMember("date","\"" + Calendar.getInstance().getTime().toString() + "\""); AnnotationSpec annGenSpec = annSpecBuilder.build(); classtestBuilder.addAnnotation(annGenSpec); /* * for spring test */ // FieldSpec.Builder spec = FieldSpec.builder(clazz,// getNewInstanceOfnoparameters(clazz),Modifier.PRIVATE); // spec.addAnnotation(Autowired.class); // classtestBuilder.addField(spec.build()); addClassMethodsToBuilder(classtestBuilder,clazz); return classtestBuilder.build(); }
@SneakyThrows public CamundaRestService(final ModelRepository repository,final Class<?> serviceInterfaceClass,final Class<?> serviceImplClass) { super(repository); if (!serviceInterfaceClass.isAssignableFrom(serviceImplClass)) { throw new IllegalStateException(String.format("%s does not implement %s",serviceImplClass,serviceInterfaceClass)); } this.serviceInterfaceClass = serviceInterfaceClass; this.serviceImplClass = serviceImplClass; this.codemodel = new Jcodemodel(); this.codemodel._package(PACKAGE); this.definedClass = this.codemodel._class(getFullQualifiedname()); this.definedClass.annotate(Generated.class).param("value",GenerateSwaggerServicesMojo.class.getCanonicalName()); // add doc reference restService = new RestService(); getModelRepository().addService(this.serviceInterfaceClass.getName(),restService); }
public JDefinedClass defineClass(AbstractType t,Classtype type) { String fullyQualifiedname = nameGenerator.fullyQualifiedname(t); try { JDefinedClass _class = mdl._class(fullyQualifiedname,type); if (config.addGenerated) { _class.annotate(Generated.class).param("value",JavaWriter.class.getPackage().getName()).param("date",new Date().toString()); } if (t.hasDirectMeta(Description.class)) { String description = t.oneMeta(Description.class).value(); _class.javadoc().add(description); } return _class; } catch (JClassAlreadyExistsException e) { throw new IllegalStateException(e); } }
public JavaFile getJavaFile() { ClassName bsoneerCodecProviderClassName = ClassName.get(basePackage,"BsoneeCodecProvider"); typespec.Builder codecProviderBuilder = typespec.classBuilder(bsoneerCodecProviderClassName.simpleName()) .addJavadoc(ProcessorJavadocs.GENERATED_BY_BSONEER) .addSuperinterface(CodeUtil.bsonCodecProviderTypeName()) .addModifiers(PUBLIC).addAnnotation(AnnotationSpec.builder(Generated.class) .addMember("value","$S",BsonProcessor.class.getCanonicalName()) .build());; addBaseConstructor(codecProviderBuilder); addGetCodecmethod(codecProviderBuilder); return JavaFile.builder(bsoneerCodecProviderClassName.packageName(),codecProviderBuilder.build()) .addFileComment(ProcessorJavadocs.GENERATED_BY_BSONEER) .indent("\t") .build(); }
public static AnnotationSpec getGenerationDetails(Class className) { DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss",Locale.ENGLISH); return AnnotationSpec.builder(Generated.class) .addMember("value",className.getCanonicalName()) .addMember("date",dateFormat.format(new Date())) .addMember("comments","Auto Generated by GreenDAO Migrator. DO NOT EDIT.") .build(); }
@Test public void applyShouldAddGeneratedAnnotation() throws Exception { // setup final typespec.Builder builder = typespec.classBuilder("Test"); // exercise underTest.apply(builder); // verify assertthat(builder.build()) .hasName("Test") .hasAnnotation(AnnotationSpec.builder(Generated.class) .addMember("value",this.getClass().getCanonicalName()) .build()); }
@Override public boolean store(DeFinitionModel model) { String packageName = model.getSourcePackage(); String className = model.getSourceClass() + "_" + FileStore.STANDARD.getPath(); String data = getGson().toJson(model); FieldSpec fieldSpec = FieldSpec.builder(String.class,AptResourceLoader.FIELD_NAME) .addModifiers(Modifier.PRIVATE,Modifier.FINAL) .initializer("$S",data) .addAnnotation(AnnotationSpec.builder(SuppressWarnings.class).addMember("value","unused").build()) .build(); typespec classspec = typespec.classBuilder(className) .addModifiers(Modifier.PUBLIC) .addField(fieldSpec) .addAnnotation(AnnotationSpec.builder(Generated.class).addMember("value","SpringApt").build()) .build(); JavaFile javaFile = JavaFile.builder(packageName,classspec) .build(); try { OutputStream stream = getDeFinitionOutputStreamProvider().store(model); try { stream.write(javaFile.toString().getBytes(StandardCharsets.UTF_8)); } finally { stream.close(); } model.setSha256(bytesToHex(getSha256Digest().digest(data.getBytes(StandardCharsets.UTF_8)))); return true; } catch (IOException ex) { throw new IllegalStateException("Could not store model to class",ex); } }
/** * Gets the value of the isPermaLink property. * * @return * possible object is * {@link Boolean } * */ @Generated(value = "com.sun.tools.internal.xjc.Driver",date = "2017-03-01T09:39:56+01:00",comments = "JAXB RI v2.2.8-b130911.1802") public boolean isIsPermaLink() { if (isPermaLink == null) { return true; } else { return isPermaLink; } }
/** * Gets the value of the version property. * * @return * possible object is * {@link BigDecimal } * */ @Generated(value = "com.sun.tools.internal.xjc.Driver",comments = "JAXB RI v2.2.8-b130911.1802") public BigDecimal getVersion() { if (version == null) { return new BigDecimal("2.0"); } else { return version; } }
private JavaFile createFileSpec() throws Exception { AnnotationSpec generated = AnnotationSpec.builder(Generated.class) .addMember("value","com.vocalabs.egtest.EgTest") .build(); typespec.Builder typespecBuilder = typespec.classBuilder(className) .addModifiers(Modifier.PUBLIC,Modifier.FINAL) .addAnnotation(generated); TestWriter.write(this,typespecBuilder); codeInjector.decorateClass(typespecBuilder); typespec javaFileSpec = typespecBuilder.build(); JavaFile.Builder fileBuilder = JavaFile.builder(codeInjector.getPackageName(),javaFileSpec); return fileBuilder.build(); }
public static AnnotationSpec getGenerationDetails(Class className) { DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss","Auto Generated by GreenDAO Migrator. DO NOT EDIT.") .build(); }
public static void addGeneratedAnnotation(ProcessingEnvironment processingEnvironment,typespec.Builder builder) { Elements elements = processingEnvironment.getElementUtils(); if (elements.getTypeElement(Generated.class.getCanonicalName()) != null) { builder.addAnnotation(AnnotationSpec.builder(Generated.class) .addMember("value",SharedPreferenceProcessor.class.getCanonicalName()).build()); } }
@Generated(value = "com.sun.tools.xjc.Driver",date = "2016-10-02T10:27:12+03:00",comments = "JAXB RI vhudson-jaxb-ri-2.2-147") public List<Topic> getTopics() { if (topics == null) { topics = new ArrayList<Topic>(); } return this.topics; }
@Generated(value = "com.sun.tools.xjc.Driver",date = "2016-10-02T10:27:16+03:00",comments = "JAXB RI vhudson-jaxb-ri-2.2-147") public List<Stage> getStages() { if (stages == null) { stages = new ArrayList<Stage>(); } return this.stages; }
@Generated(value = "com.sun.tools.xjc.Driver",comments = "JAXB RI vhudson-jaxb-ri-2.2-147") public List<Phase> getPhases() { if (phases == null) { phases = new ArrayList<Phase>(); } return this.phases; }
@Generated(value = "com.sun.tools.xjc.Driver",date = "2016-10-02T10:27:18+03:00",comments = "JAXB RI vhudson-jaxb-ri-2.2-147") public List<Object> getContent() { if (content == null) { content = new ArrayList<Object>(); } return this.content; }
@Generated(value = "com.sun.tools.xjc.Driver",date = "2016-10-02T10:27:14+03:00",comments = "JAXB RI vhudson-jaxb-ri-2.2-147") public List<Class> getClazzs() { if (clazzs == null) { clazzs = new ArrayList<Class>(); } return this.clazzs; }
@Generated(value = "com.sun.tools.xjc.Driver",date = "2016-10-02T10:27:19+03:00",comments = "JAXB RI vhudson-jaxb-ri-2.2-147") public List<Period> getPeriods() { if (periods == null) { periods = new ArrayList<Period>(); } return this.periods; }
@Generated(value = "com.sun.tools.xjc.Driver",comments = "JAXB RI vhudson-jaxb-ri-2.2-147") public List<Session> getSessions() { if (sessions == null) { sessions = new ArrayList<Session>(); } return this.sessions; }
@Generated(value = "com.sun.tools.xjc.Driver",date = "2016-10-02T10:27:15+03:00",comments = "JAXB RI vhudson-jaxb-ri-2.2-147") public List<Deputy> getDeputies() { if (deputies == null) { deputies = new ArrayList<Deputy>(); } return this.deputies; }
@Generated(value = "com.sun.tools.xjc.Driver",comments = "JAXB RI vhudson-jaxb-ri-2.2-147") public List<Faction> getFactions() { if (factions == null) { factions = new ArrayList<Faction>(); } return this.factions; }
private typespec createRoute(TypeElement typeElement,ArrayList<MethodSpec> methods) { messager.printMessage(Diagnostic.Kind.NOTE,"Saving route file..."); return typespec.classBuilder(typeElement.getSimpleName() + "Route") .addAnnotation(AnnotationSpec.builder(Generated.class) .addMember("value",this.getClass().getName()) .build()) .addModifiers(Modifier.PUBLIC) .addSuperinterface(org.firezenk.naviganto.processor.interfaces.Routable.class) .addMethods(methods) .build(); }
@Test void singleElementAnnotation() { Class<Generated> type = Generated.class; Annotation tag = Annotation.of(type,"(-:"); assertEquals("@" + type.getCanonicalName() + "(\"(-:\")",tag.list()); Annotation tags = Annotation.of(type,"(","-",":"); assertEquals("@" + type.getCanonicalName() + "({\"(\",\"-\",\":\"})",tags.list()); }
/** * Adds the {@code @Generated} annotation to the given class. * * @param klass * generated Java class */ public void annotateAsGenerated(JDefinedClass klass) { klass.annotate(Generated.class) .param("value","org.ops4j.ramler") .param("date",zoneddatetime.Now().truncatedTo(SECONDS).format(ISO_OFFSET_DATE_TIME)) .param("comments","version " + Version.getRamlerVersion()); }
private typespec classtest(ClassName className,List<MethodSpec> methodSpecs) { String methodName = Introspector .decapitalize(className.simpleName()); MethodSpec abstractMethodInstancetoTest = methodBuilder(methodName) .addModifiers(Modifier.ABSTRACT,Modifier.PROTECTED) .returns(className) .build(); FieldSpec exception = FieldSpec.builder(ExpectedException.class,"exception") .addAnnotation(Rule.class) .addModifiers(Modifier.PUBLIC,Modifier.FINAL) .initializer("$T.none()",ExpectedException.class) .build(); return typespec.classBuilder(className.simpleName() + "Test_") .addModifiers(Modifier.ABSTRACT,Modifier.PUBLIC) .addMethod(abstractMethodInstancetoTest) .addField(exception) .addAnnotation(AnnotationSpec.builder(Generated.class) .addMember("value",MockeryProcessor.class.getCanonicalName()) .addMember("comments",cmessages.codeGenerateWarning()) .build()) .addAnnotation(AnnotationSpec.builder(RunWith.class) .addMember("value","$T.class",OrderedRunner.class) .build()) .addMethods(methodSpecs) .build(); }
private void internalCreateSourceFile(String packageName,ClassName templateQualifiedClassName,ClassName generatedQualifiedClassName,String annotationType,typespec.Builder builder,TypeElement element) { AnnotationSpec generated = AnnotationSpec .builder(Generated.class) .addMember("value","\"" + annotationType + "\"") .build(); builder.addAnnotation(generated); typespec classspec = builder.build(); JavaFile javaFile = JavaFile.builder(packageName,classspec) .addFileComment("Auto generated from $L by Soabase " + annotationType + " annotation processor",templateQualifiedClassName) .indent(" ") .build(); Filer filer = processingEnv.getFiler(); try { JavaFileObject sourceFile = filer.createSourceFile(generatedQualifiedClassName.toString()); try ( Writer writer = sourceFile.openWriter() ) { javaFile.writeto(writer); } } catch ( IOException e ) { String message = "Could not create source file"; if ( e.getMessage() != null ) { message = message + ": " + e.getMessage(); } processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,message,element); } }
@Generated("SparkTools") private compilationunitModificationDomain(Builder builder) { this.listRewrite = builder.listRewrite; this.astRewriter = builder.astRewriter; this.ast = builder.ast; this.originalType = builder.originalType; this.compilationunit = builder.compilationunit; }
@Generated("SparkTools") private ConstructorParameterSetterBuilderField(Builder builder) { this.fieldType = builder.fieldType; this.originalFieldName = builder.originalFieldName; this.builderFieldName = builder.builderFieldName; this.index = builder.index; }
@Generated("SparkTools") private ClassFieldSetterBuilderField(Builder builder) { this.fieldType = builder.fieldType; this.originalFieldName = builder.originalFieldName; this.builderFieldName = builder.builderFieldName; this.fieldDeclaration = builder.fieldDeclaration; }
@Override public Set<String> getSupportedAnnotationTypes() { Set<String> supportedAnnotations = new HashSet<>(); supportedAnnotations.add(Presenter.class.getCanonicalName()); supportedAnnotations.add(View.class.getCanonicalName()); supportedAnnotations.add(Provider.class.getCanonicalName()); supportedAnnotations.add(Generated.class.getCanonicalName()); return supportedAnnotations; }
private typespec.Builder createInjectortypespec(ComponentInfo component,ClassName injectorClassName) { ClassName cn = getInjectorNameOfScope(injectorClassName,component.getScope()); // System.out.println("createPackagedInjectortypespec. name: " + // Utilities.getClassCanonicalName(cn)); typespec.Builder typespecBuilder = typespec.classBuilder(cn.simpleName()) .addModifiers(Modifier.PUBLIC).addAnnotation(AnnotationSpec.builder(Generated.class) .addMember("value",GENERATOR_NAME).build()); // Top level injector. ClassName topLevelInjectorClassName = ClassName.get(topLevelPackageString,getTopLevelInjectorName(component)); typespecBuilder.addField(topLevelInjectorClassName,TOP_LEVEL_INJECTOR_FIELD,Modifier.PRIVATE); MethodSpec.Builder ctorSpec = MethodSpec.constructorBuilder().addModifiers(Modifier.PUBLIC) .addParameter(topLevelInjectorClassName,TOP_LEVEL_INJECTOR_FIELD); ctorSpec.addStatement("this.$N = $N",TOP_LEVEL_INJECTOR_FIELD); // Containing packaged injector. if (componentTree.get(component) != null) { ClassName containingInjectorClassName = getInjectorNameOfScope(injectorClassName,componentTree.get(component).getScope()); typespecBuilder.addField(containingInjectorClassName,CONTAINING_PACKAGED_INJECTOR_FIELD,Modifier.PRIVATE); ctorSpec.addParameter(containingInjectorClassName,CONTAINING_PACKAGED_INJECTOR_FIELD); ctorSpec.addStatement("this.$N = $N",CONTAINING_PACKAGED_INJECTOR_FIELD); } typespecBuilder.addMethod(ctorSpec.build()); return typespecBuilder; }
static PsiElement getAnnotationMemberSuppressedIn(@NotNull PsiModifierListOwner owner,@NotNull String inspectionToolID) { final PsiAnnotation generatedAnnotation = AnnotationUtil.findAnnotation(owner,Generated.class.getName()); if (generatedAnnotation != null) return generatedAnnotation; PsiModifierList modifierList = owner.getModifierList(); Collection<String> suppressedIds = getinspectionIdsSuppressedInAnnotation(modifierList); for (String ids : suppressedIds) { if (SuppressionUtil.isinspectionToolIdMentioned(ids,inspectionToolID)) { return modifierList != null ? AnnotationUtil.findAnnotation(owner,SUPPRESS_inspectionS_ANNOTATION_NAME) : null; } } return null; }
static List<AnnotationSpec> generatedAnnotations(Elements elements) { if (elements.getTypeElement("javax.annotation.Generated") != null) { return singletonList(AnnotationSpec.builder(Generated.class) .addMember("value",ZeroProcessor.class.getName()) .addMember("comments",GENERATED_COMMENTS) .build()); } return Collections.emptyList(); }
@Generated(value = "com.sun.tools.xjc.Driver",date = "2015-11-04T10:30:05+01:00",comments = "JAXB RI v2.2.11") public GBReferenceXref withGBXref(Collection<GBXref> values) { if (values!= null) { getGBXref().addAll(values); } return this; }
@Generated(value = "com.sun.tools.xjc.Driver",comments = "JAXB RI v2.2.11") public GBSeqKeywords withGBKeyword(Collection<GBKeyword> values) { if (values!= null) { getGBKeyword().addAll(values); } return this; }
@Generated(value = "com.sun.tools.xjc.Driver",comments = "JAXB RI v2.2.11") public Object withParam(Collection<Param> values) { if (values!= null) { getparam().addAll(values); } return this; }
@Generated(value = "com.sun.tools.xjc.Driver",date = "2015-11-04T10:30:06+01:00",comments = "JAXB RI v2.2.11") public OtherNames withEquivalentNameOrSynonymOrAcronymOrMisspellingOrAnamorphOrIncludesOrCommonNameOrInpartOrMisnomerOrTeleomorphOrGenbankSynonymOrGenbankAnamorph(Collection<Object> values) { if (values!= null) { getEquivalentNameOrSynonymOrAcronymOrMisspellingOrAnamorphOrIncludesOrCommonNameOrInpartOrMisnomerOrTeleomorphOrGenbankSynonymOrGenbankAnamorph().addAll(values); } return this; }
@Generated(value = "com.sun.tools.xjc.Driver",comments = "JAXB RI v2.2.11") public GBFeatureIntervals withGBInterval(Collection<GBInterval> values) { if (values!= null) { getGBInterval().addAll(values); } return this; }
@NonNull public static AnnotationSpec createGeneratedAnnotation(@NonNull Class<? extends Processor> processorClass) { return AnnotationSpec.builder(Generated.class) .addMember("value","\"$N\"",typespec.classBuilder(processorClass.getCanonicalName()).build()) .build(); }
javax.annotation.meta.TypeQualifierValidator的实例源码
public static <A extends Annotation> When sandBoxedValidation(A proxy,TypeQualifierValidator<A> v,@CheckForNull Object constantValue) { if (performingValidation.get()) throw new IllegalStateException("recursive validation"); try { performingValidation.set(Boolean.TRUE); if (TypeQualifierValue.DEBUG_CLASSLOADING) System.out.println("Performing validation in thread " + Thread.currentThread().getName()); try { When result = v.forConstantValue(proxy,constantValue); if (!performingValidation.get()) throw new IllegalStateException("performingValidation not set when validation completes"); return result; } catch (ClassCastException e) { Class<? extends Annotation> c = proxy.getClass(); System.out.println(c.getName() + " extends " + c.getSuperclass().getName()); for(Class<?> i : c.getInterfaces()) System.out.println(" " + i.getName()); throw e; } } finally { performingValidation.set(Boolean.FALSE); if (TypeQualifierValue.DEBUG_CLASSLOADING) System.out.println("Validation finished in thread " + Thread.currentThread().getName()); } }
private boolean inValidation() { for (Class<?> c : getClassContext()) { if (TypeQualifierValidator.class.isAssignableFrom(c) || c.getClassLoader() == ValidatorClassLoader.INSTANCE) return true; } return false; }
private static <A extends Annotation> TypeQualifierValidator<A> getValidator( Class<? extends TypeQualifierValidator<A>> checkerClass) throws InstantiationException,illegalaccessexception { return checkerClass.newInstance(); }
/** * @param checkerClass * @return * @throws InstantiationException * @throws illegalaccessexception */ @SuppressWarnings("unchecked") private TypeQualifierValidator<A> getValidator(Class<? extends TypeQualifierValidator> checkerClass) throws InstantiationException,illegalaccessexception { return checkerClass.newInstance(); }
javax.enterprise.inject.spi.AnnotatedParameter的实例源码
String getPropertyName(final InjectionPoint point,final String propertyName) { if (!propertyName.isEmpty()) { return propertyName; } Member member = point.getMember(); final String name; if (member instanceof Executable) { Annotated annotated = point.getAnnotated(); int p = ((AnnotatedParameter<?>) annotated).getPosition(); name = member.getName() + ".arg" + p; } else { name = member.getName(); } return name; }
@SuppressWarnings("unchecked") private InjectionPoint mockInjectionPoint(Property property,Type type,Class<? extends Member> memberType,String memberName,int memberPosition) { InjectionPoint injectionPoint = mock(InjectionPoint.class); Member member = mock(memberType); when(injectionPoint.getType()).thenReturn(type); when(injectionPoint.getMember()).thenReturn(member); when(member.getName()).thenReturn(memberName); @SuppressWarnings("rawtypes") Bean mockBean = mock(Bean.class); when(injectionPoint.getBean()).thenReturn(mockBean); when(mockBean.getBeanClass()).thenReturn(getClass()); AnnotatedParameter<?> annotated = mock(AnnotatedParameter.class); when(annotated.getPosition()).thenReturn(memberPosition); when(injectionPoint.getAnnotated()).thenReturn(annotated); when(annotated.getAnnotation(Property.class)).thenReturn(property); return injectionPoint; }
@SuppressWarnings("unchecked") private InjectionPoint mockInjectionPoint(Property property,int memberPosition) { InjectionPoint injectionPoint = mock(InjectionPoint.class); Member member = mock(memberType); when(injectionPoint.getMember()).thenReturn(member); when(member.getName()).thenReturn(memberName); @SuppressWarnings("rawtypes") Bean mockBean = mock(Bean.class); when(injectionPoint.getBean()).thenReturn(mockBean); when(mockBean.getBeanClass()).thenReturn(getClass()); AnnotatedParameter<?> annotated = mock(AnnotatedParameter.class); when(annotated.getPosition()).thenReturn(memberPosition); when(injectionPoint.getAnnotated()).thenReturn(annotated); when(annotated.getAnnotation(Property.class)).thenReturn(property); return injectionPoint; }
/** * Checks if any property resolver method parameter is annotated with * more than one of the following: {@link PropertyKey},{@link PropertyBundle},* {@link PropertyLocale} */ private void checkMultipleAnnotationParameter() { int count; for (final AnnotatedParameter<?> parameter : propertyResolverMethod.getParameters()) { count = 0; if (parameter.isAnnotationPresent(PropertyKey.class)) { count++; } if (parameter.isAnnotationPresent(PropertyBundle.class)) { count++; } if (parameter.isAnnotationPresent(PropertyLocale.class)) { count++; } if (count > 1) { throw new ExtensionInitializationException( "A property resolver method parameter must not be annotated with more than one of the following: " + PropertyKey.class.getSimpleName() + "," + PropertyBundle.class.getSimpleName() + " or " + PropertyLocale.class.getSimpleName()); } } }
/** * Generates a unique string representation of a list of * {@link AnnotatedParameter}s. */ public static <X> String createParameterListId(List<AnnotatedParameter<X>> parameters) { StringBuilder builder = new StringBuilder(); builder.append("("); for (int i = 0; i < parameters.size(); ++i) { AnnotatedParameter<X> ap = parameters.get(i); builder.append(createParameterId(ap)); if (i + 1 != parameters.size()) { builder.append(','); } } builder.append(")"); return builder.toString(); }
/** * Compares two annotated elements to see if they have the same annotations */ private static boolean compareAnnotatedParameters(List<? extends AnnotatedParameter<?>> p1,List<? extends AnnotatedParameter<?>> p2) { if (p1.size() != p2.size()) { return false; } for (int i = 0; i < p1.size(); ++i) { if (!compareAnnotated(p1.get(i),p2.get(i))) { return false; } } return true; }
/** * Remove an annotation from the specified parameter. * * @param parameter the parameter to remove the annotation from * @param annotationType the annotation type to remove * @throws IllegalArgumentException if the annotationType is null,if the * callable which declares the parameter is not currently declared * on the type or if the parameter is not declared on either a * constructor or a method */ public AnnotatedTypeBuilder<X> removeFromParameter(AnnotatedParameter<? super X> parameter,Class<? extends Annotation> annotationType) { if (parameter.getDeclaringCallable().getJavaMember() instanceof Method) { Method method = (Method) parameter.getDeclaringCallable().getJavaMember(); return removeFromMethodParameter(method,parameter.getPosition(),annotationType); } if (parameter.getDeclaringCallable().getJavaMember() instanceof Constructor<?>) { @SuppressWarnings("unchecked") Constructor<X> constructor = (Constructor<X>) parameter.getDeclaringCallable().getJavaMember(); return removeFromConstructorParameter(constructor,annotationType); } else { throw new IllegalArgumentException("Cannot remove from parameter " + parameter + " - cannot operate on member " + parameter.getDeclaringCallable().getJavaMember()); } }
/** * Add an annotation to the specified parameter. If the callable which * declares the parameter is not already present,it will be added. If the * parameter is not already present on the callable,it will be added. * * @param parameter the parameter to add the annotation to * @param annotation the annotation to add * @throws IllegalArgumentException if the annotation is null or if the * parameter is not declared on either a constructor or a method */ public AnnotatedTypeBuilder<X> addToParameter(AnnotatedParameter<? super X> parameter,Annotation annotation) { if (parameter.getDeclaringCallable().getJavaMember() instanceof Method) { Method method = (Method) parameter.getDeclaringCallable().getJavaMember(); return addToMethodParameter(method,annotation); } if (parameter.getDeclaringCallable().getJavaMember() instanceof Constructor<?>) { @SuppressWarnings("unchecked") Constructor<X> constructor = (Constructor<X>) parameter.getDeclaringCallable().getJavaMember(); return addToConstructorParameter(constructor,annotation); } else { throw new IllegalArgumentException("Cannot remove from parameter " + parameter + " - cannot operate on member " + parameter.getDeclaringCallable().getJavaMember()); } }
/** * Override the declared type of a parameter. * * @param parameter the parameter to override the type on * @param type the new type of the parameter * @throws IllegalArgumentException if parameter or type is null */ public AnnotatedTypeBuilder<X> overrideParameterType(AnnotatedParameter<? super X> parameter,Type type) { if (parameter.getDeclaringCallable().getJavaMember() instanceof Method) { Method method = (Method) parameter.getDeclaringCallable().getJavaMember(); return overrideMethodParameterType(method,type); } if (parameter.getDeclaringCallable().getJavaMember() instanceof Constructor<?>) { @SuppressWarnings("unchecked") Constructor<X> constructor = (Constructor<X>) parameter.getDeclaringCallable().getJavaMember(); return overrideConstructorParameterType(constructor,type); } else { throw new IllegalArgumentException("Cannot remove from parameter " + parameter + " - cannot operate on member " + parameter.getDeclaringCallable().getJavaMember()); } }
@Test public void modifyAnnotationsOnConstructorParameter() throws NoSuchMethodException { final AnnotatedTypeBuilder<Cat> builder = new AnnotatedTypeBuilder<Cat>(); builder.readFromType(Cat.class,true); builder.removeFromConstructorParameter(Cat.class.getConstructor(String.class,String.class),1,Default.class); builder.addToConstructorParameter(Cat.class.getConstructor(String.class,new AnyLiteral()); final AnnotatedType<Cat> catannotatedType = builder.create(); Set<AnnotatedConstructor<Cat>> catCtors = catannotatedType.getConstructors(); assertthat(catCtors.size(),is(2)); for (AnnotatedConstructor<Cat> ctor : catCtors) { if (ctor.getParameters().size() == 2) { List<AnnotatedParameter<Cat>> ctorParams = ctor.getParameters(); assertthat(ctorParams.get(1).getAnnotations().size(),is(1)); assertthat((AnyLiteral) ctorParams.get(1).getAnnotations().toArray()[0],is(new AnyLiteral())); } } }
/** * Determines if the given method is a handler by looking for the {@link Handles} annotation on a parameter. * * @param method method to search * @return true if {@link Handles} is found,false otherwise */ public static boolean isHandler(final AnnotatedMethod<?> method) { if (method == null) { throw new IllegalArgumentException("Method must not be null"); } for (AnnotatedParameter<?> param : method.getParameters()) { if (param.isAnnotationPresent(Handles.class) || param.isAnnotationPresent(BeforeHandles.class)) { return true; } } return false; }
public static AnnotatedParameter<?> findHandlerParameter(final AnnotatedMethod<?> method) { if (!isHandler(method)) { throw new IllegalArgumentException("Method is not a valid handler"); } AnnotatedParameter<?> returnParam = null; for (AnnotatedParameter<?> param : method.getParameters()) { if (param.isAnnotationPresent(Handles.class) || param.isAnnotationPresent(BeforeHandles.class)) { returnParam = param; break; } } return returnParam; }
/** * Obtain all the injection points for the handler * * @param bm a BeanManager to use to obtain the beans */ public Set<InjectionPoint> getInjectionPoints(final BeanManager bm) { if (injectionPoints == null) { injectionPoints = new HashSet<InjectionPoint>(handler.getParameters().size() - 1); for (AnnotatedParameter<?> param : handler.getParameters()) { if (!param.equals(handlerParameter)) { injectionPoints.add( new ImmutableInjectionPoint(param,bm,getDeclaringBean(),false,false)); } } } return new HashSet<InjectionPoint>(injectionPoints); }
private Resource getResourceAnnotation(InjectionPoint injectionPoint) { Annotated annotated = injectionPoint.getAnnotated(); if (annotated instanceof AnnotatedParameter<?>) { annotated = ((AnnotatedParameter<?>) annotated).getDeclaringCallable(); } return annotated.getAnnotation(Resource.class); }
public void process(Set<AnnotatedType<?>> discoveredTypes) { for(AnnotatedType<?> at : discoveredTypes) { for(AnnotatedMethod<?> am : at.getmethods()) { boolean hasObserver = am.getParameters().stream().anyMatch(ap -> ap.getAnnotation(ObservesReactor.class) != null); if(hasObserver) { AnnotatedParameter<?> observerType = am.getParameters().stream().filter(ap -> ap.isAnnotationPresent(ObservesReactor.class)).findFirst().orElseThrow(() -> new RuntimeException("No observer found")); Class<?> returnType = null; Type genericReturnType = am.getJavaMember().getGenericReturnType(); boolean returnsPublisher = false; if(genericReturnType instanceof ParameterizedType) { ParameterizedType type = (ParameterizedType)genericReturnType; if(Publisher.class.isAssignableFrom((Class<?>) type.getRawType())) { returnsPublisher = true; returnType = (Class<?>) type.getActualTypeArguments()[0]; } else { throw new RuntimeException("Method "+am+" should either return a concrete type or an instance of "+Publisher.class.getName()); } } else { returnType = (Class)genericReturnType; } Class<?> eventType = observerType.getJavaParameter().getType(); Set<Annotation> annotations = new LinkedHashSet<>(asList(observerType.getJavaParameter().getAnnotations())); methods.add(new ReactorMethod(at,am,returnType,eventType,annotations,returnsPublisher)); } } } }
@Override public Publisher<T> get(Object event) { CDI<Object> cdi = CDI.current(); List<InstanceHolder> instanceHolders = new ArrayList<>(); List<Object> parameters = new ArrayList<>(); for(AnnotatedParameter<?> ap : annotatedMethod.getParameters()) { if(ap.isAnnotationPresent(ObservesReactor.class)) { parameters.add(event); } else { InstanceHolder holder = getReference(cdi,ap.getJavaParameter().getType(),ap.getAnnotations()); instanceHolders.add(holder); parameters.add(holder.instance); } } InstanceHolder eventReceiver = getReference(cdi,annotatedType.getJavaClass(),findQualifiers(annotatedType.getAnnotations())); Object[] params = parameters.toArray(); try { Object result = targetmethod.invoke(eventReceiver.instance,params); if(returnsPublisher) { return (Publisher<T>) result; } else { return Mono.just((T)result).doAfterTerminate(() -> instanceHolders.forEach(InstanceHolder::destroy)); } } catch (illegalaccessexception | InvocationTargetException e) { return Mono.fromsupplier(() -> { throw new RuntimeException(e); }); } finally { eventReceiver.destroy(); } }
@SuppressWarnings("unchecked") protected <T extends Annotation> InjectionPoint mockInjectionPoint(Class<T> annotationType,T annotation,int memberPosition) { InjectionPoint injectionPoint = mock(InjectionPoint.class); Member member = mock(memberType); when(injectionPoint.getType()).thenReturn(type); when(injectionPoint.getMember()).thenReturn(member); when(member.getName()).thenReturn(memberName); @SuppressWarnings("rawtypes") Bean mockBean = mock(Bean.class); when(injectionPoint.getBean()).thenReturn(mockBean); when(mockBean.getBeanClass()).thenReturn(getClass()); AnnotatedParameter<?> annotated = mock(AnnotatedParameter.class); when(annotated.getPosition()).thenReturn(memberPosition); when(injectionPoint.getAnnotated()).thenReturn(annotated); when(annotated.getAnnotation(annotationType)).thenReturn(annotation); return injectionPoint; }
private boolean hasEventParameter(AnnotatedMethod<?> annotatedMethod) { for (AnnotatedParameter<?> param : annotatedMethod.getParameters()) { if (param.isAnnotationPresent(Observes.class)) { return true; } } return false; }
private static boolean hasInjectionPointMetadata(AnnotatedMember<?> member) { if (!(member instanceof AnnotatedMethod)) { return false; } AnnotatedMethod<?> method = (AnnotatedMethod<?>) member; for (AnnotatedParameter<?> parameter : method.getParameters()) { if (parameter.getBaseType().equals(InjectionPoint.class)) { return true; } } return false; }
@Override public String of(InjectionPoint ip) { Annotated annotated = ip.getAnnotated(); if (annotated instanceof AnnotatedMember) { return of((AnnotatedMember<?>) annotated); } else if (annotated instanceof AnnotatedParameter) { return of((AnnotatedParameter<?>) annotated); } else { throw new IllegalArgumentException("Unable to retrieve metric name for injection point [" + ip + "],only members and parameters are supported"); } }
private String of(AnnotatedParameter<?> parameter) { if (parameter.isAnnotationPresent(Metric.class)) { Metric metric = parameter.getAnnotation(Metric.class); String name = (metric.name().isEmpty()) ? getParameterName(parameter) : of(metric.name()); return metric.absolute() | parameters.contains(MetricsParameter.useAbsoluteName) ? name : MetricRegistry.name(parameter.getDeclaringCallable().getJavaMember().getDeclaringClass(),name); } else { return parameters.contains(MetricsParameter.useAbsoluteName) ? getParameterName(parameter) : MetricRegistry.name(parameter.getDeclaringCallable().getJavaMember().getDeclaringClass(),getParameterName(parameter)); } }
private String getParameterName(AnnotatedParameter<?> parameter) { try { Method method = Method.class.getmethod("getParameters"); Object[] parameters = (Object[]) method.invoke(parameter.getDeclaringCallable().getJavaMember()); Object param = parameters[parameter.getPosition()]; Class<?> Parameter = Class.forName("java.lang.reflect.Parameter"); if ((Boolean) Parameter.getmethod("isNamePresent").invoke(param)) { return (String) Parameter.getmethod("getName").invoke(param); } else { throw new UnsupportedOperationException("Unable to retrieve name for parameter [" + parameter + "],activate the -parameters compiler argument or annotate the injected parameter with the @Metric annotation"); } } catch (NoSuchMethodException | illegalaccessexception | InvocationTargetException | ClassNotFoundException cause) { throw new UnsupportedOperationException("Unable to retrieve name for parameter [" + parameter + "],@Metric annotation on injected parameter is required before Java 8"); } }
/** * see {@link ResolverParameterExtractor#extract(AnnotatedParameter)} */ @Override public T extract(AnnotatedParameter<?> parameter) { if (parameter.isAnnotationPresent(parameterType)) { return resolverParameter; } return null; }
/** * See {@link ResolverMethodVerifier#verify()} */ @Override public void verify() { for (final AnnotatedParameter<?> parameter : resolverMethod.getParameters()) { if (checkDependentScope((Class<?>) parameter.getBaseType())) { checkPropertyField((Class<?>) parameter.getBaseType(),(Class<?>) parameter.getBaseType()); } } }
/** * Checks if any property resolver method parameter is annotated with * {@link PropertyLocale} */ private void checkLocaleResolverParameterannotations() { for (final AnnotatedParameter<?> parameter : localeResolverMethod.getParameters()) { if (parameter.isAnnotationPresent(PropertyLocale.class)) { throw new ExtensionInitializationException( "A Locale resolver method parameter must not be annotated with: " + PropertyLocale.class.getSimpleName()); } } }
/** * Checks if there is at least one property resolver method parameter annotated with {@link PropertyKey} */ private void checkPropertyKeyExists() { boolean foundKeyProperty = false; for (final AnnotatedParameter<?> parameter : propertyResolverMethod.getParameters()) { if (parameter.isAnnotationPresent(PropertyKey.class)) { foundKeyProperty = true; break; } } if (!foundKeyProperty) { throw new ExtensionInitializationException( "At least one parameter of the custom property resolver must represent de property key,annotated with " + PropertyKey.class.getName()); } }
/** * Checks if the given parameter type exists in more than a single property resolver * method parameter * @param annotation * The parameter type being checked */ private void checkRepeatedParameterType(Class<? extends Annotation> annotation) { int count = 0; for (final AnnotatedParameter<?> parameter : propertyResolverMethod.getParameters()) { if (parameter.isAnnotationPresent(annotation)) { count++; } } if (count > 1) { throw new ExtensionInitializationException("There must be only a single param annotated with " + annotation.getSimpleName() + " in the property resolver method"); } }
private static boolean hasInjectionPoints(AnnotatedMember<?> member) { if (!(member instanceof AnnotatedMethod)) return false; AnnotatedMethod<?> method = (AnnotatedMethod<?>) member; for (AnnotatedParameter<?> parameter : method.getParameters()) { if (parameter.getBaseType().equals(InjectionPoint.class)) return true; } return false; }
@Override public String of(InjectionPoint ip) { Annotated annotated = ip.getAnnotated(); if (annotated instanceof AnnotatedMember) return of((AnnotatedMember<?>) annotated); else if (annotated instanceof AnnotatedParameter) return of((AnnotatedParameter<?>) annotated); else throw new IllegalArgumentException("Unable to retrieve metric name for injection point [" + ip + "],only members and parameters are supported"); }
private String of(AnnotatedParameter<?> parameter) { if (parameter.isAnnotationPresent(Metric.class)) { Metric metric = parameter.getAnnotation(Metric.class); String name = (metric.name().isEmpty()) ? getParameterName(parameter) : of(metric.name()); return metric.absolute() | parameters.contains(useAbsoluteName) ? name : MetricRegistry.name(parameter.getDeclaringCallable().getJavaMember().getDeclaringClass(),name); } else { return parameters.contains(useAbsoluteName) ? getParameterName(parameter) : MetricRegistry.name(parameter.getDeclaringCallable().getJavaMember().getDeclaringClass(),getParameterName(parameter)); } }
private String getParameterName(AnnotatedParameter<?> parameter) { try { Method method = Method.class.getmethod("getParameters"); Object[] parameters = (Object[]) method.invoke(parameter.getDeclaringCallable().getJavaMember()); Object param = parameters[parameter.getPosition()]; Class<?> Parameter = Class.forName("java.lang.reflect.Parameter"); if ((Boolean) Parameter.getmethod("isNamePresent").invoke(param)) return (String) Parameter.getmethod("getName").invoke(param); else throw new UnsupportedOperationException("Unable to retrieve name for parameter [" + parameter + "],activate the -parameters compiler argument or annotate the injected parameter with the @Metric annotation"); } catch (NoSuchMethodException | illegalaccessexception | InvocationTargetException | ClassNotFoundException cause) { throw new UnsupportedOperationException("Unable to retrieve name for parameter [" + parameter + "],@Metric annotation on injected parameter is required before Java 8"); } }
/** * Creates a deterministic signature for a {@link Method}. * * @param method The method to generate the signature for * @param annotations The annotations to include in the signature * @param parameters The {@link AnnotatedParameter}s to include in the * signature */ public static <X> String createMethodId(Method method,Set<Annotation> annotations,List<AnnotatedParameter<X>> parameters) { StringBuilder builder = new StringBuilder(); builder.append(method.getDeclaringClass().getName()); builder.append('.'); builder.append(method.getName()); builder.append(createAnnotationCollectionId(annotations)); builder.append(createParameterListId(parameters)); return builder.toString(); }
/** * Creates a deterministic signature for a {@link Constructor}. * * @param constructor The constructor to generate the signature for * @param annotations The annotations to include in the signature * @param parameters The {@link AnnotatedParameter}s to include in the * signature */ public static <X> String createConstructorId(Constructor<X> constructor,List<AnnotatedParameter<X>> parameters) { StringBuilder builder = new StringBuilder(); builder.append(constructor.getDeclaringClass().getName()); builder.append('.'); builder.append(constructor.getName()); builder.append(createAnnotationCollectionId(annotations)); builder.append(createParameterListId(parameters)); return builder.toString(); }
private static <X> boolean hasMethodParameters(AnnotatedCallable<X> callable) { for (AnnotatedParameter<X> parameter : callable.getParameters()) { if (!parameter.getAnnotations().isEmpty()) { return true; } } return false; }
/** * Instantiate a new {@link InjectionPoint} based upon an * {@link AnnotatedParameter}. * * @param parameter the parameter for which to create the injection point * @param qualifiers the qualifiers on the injection point * @param declaringBean the declaringBean declaring the injection point * @param isTransient <code>true</code> if the injection point is transient * @param delegate <code>true</code> if the injection point is a delegate * injection point on a decorator */ public ImmutableInjectionPoint(AnnotatedParameter<?> parameter,Set<Annotation> qualifiers,Bean<?> declaringBean,boolean isTransient,boolean delegate) { annotated = parameter; member = parameter.getDeclaringCallable().getJavaMember(); this.qualifiers = new HashSet<Annotation>(qualifiers); this.isTransient = isTransient; this.delegate = delegate; this.declaringBean = declaringBean; type = parameter.getBaseType(); }
/** * Instantiate a new {@link InjectionPoint} based upon an * {@link AnnotatedParameter},reading the qualifiers from the annotations * declared on the parameter. * * @param parameter the parameter for which to create the injection point * @param declaringBean the declaringBean declaring the injection point * @param isTransient <code>true</code> if the injection point is transient * @param delegate <code>true</code> if the injection point is a delegate * injection point on a decorator */ public ImmutableInjectionPoint(AnnotatedParameter<?> parameter,BeanManager beanManager,boolean delegate) { annotated = parameter; member = parameter.getDeclaringCallable().getJavaMember(); qualifiers = BeanUtils.getQualifiers(beanManager,parameter.getAnnotations()); this.isTransient = isTransient; this.delegate = delegate; this.declaringBean = declaringBean; type = parameter.getBaseType(); }
private static <X,Y extends Member> List<AnnotatedParameter<X>> getAnnotatedParameters( AnnotatedCallableImpl<X,Y> callable,Class<?>[] parameterTypes,Type[] genericTypes,Map<Integer,AnnotationStore> parameterannotations,Type> parameterTypeOverrides) { List<AnnotatedParameter<X>> parameters = new ArrayList<AnnotatedParameter<X>>(); int len = parameterTypes.length; for (int i = 0; i < len; ++i) { AnnotationBuilder builder = new AnnotationBuilder(); if (parameterannotations != null && parameterannotations.containsKey(i)) { builder.addAll(parameterannotations.get(i)); } Type over = null; if (parameterTypeOverrides != null) { over = parameterTypeOverrides.get(i); } AnnotatedParameterImpl<X> p = new AnnotatedParameterImpl<X>( callable,parameterTypes[i],i,builder.create(),genericTypes[i],over); parameters.add(p); } return parameters; }
/** * Given a method,and the bean on which the method is declared,create a * collection of injection points representing the parameters of the method. * * @param <X> the type declaring the method * @param method the method * @param declaringBean the bean on which the method is declared * @param beanManager the bean manager to use to create the injection points * @return the injection points */ public static <X> List<InjectionPoint> createInjectionPoints(AnnotatedMethod<X> method,BeanManager beanManager) { List<InjectionPoint> injectionPoints = new ArrayList<InjectionPoint>(); for (AnnotatedParameter<X> parameter : method.getParameters()) { InjectionPoint injectionPoint = new ImmutableInjectionPoint(parameter,beanManager,declaringBean,false); injectionPoints.add(injectionPoint); } return injectionPoints; }
@Override public List<AnnotatedParameter<T>> getParameters() { return wrapped.getParameters(); }
@Override public List<AnnotatedParameter<X>> getParameters() { return decoratedMethod.getParameters(); }
今天关于javax.servlet.annotation.WebListener的实例源码和java web servlet的讲解已经结束,谢谢您的阅读,如果想了解更多关于IntelliJ IDEA 出现 "java: 程序包 javax.servlet 不存在、 java: 程序包 javax.servlet.annotation" 等错误、javax.annotation.Generated的实例源码、javax.annotation.meta.TypeQualifierValidator的实例源码、javax.enterprise.inject.spi.AnnotatedParameter的实例源码的相关知识,请在本站搜索。
本文标签: