本人也是刚学习Seam 3，由于资料太少，所以就翻译起官方出的参考。由于英文功底太差，每次看得都很吃力，就翻译出来大家一起学习。还请指正错误。

1. Annotated Type Builder  注释类型生成器

2. Annotation Instance Provider  注释实例提供器

3. Annotation Inspector  注解检查器

4. Synthetic Qualifiers  组合修饰符

5. Reflection Utilities  反射公共类

Seam Solder provides a number of utilility classes that make working with annotations and AnnotatedTypes easier. This chapter walks you through each utility, and gives you some ideas about how to use it. For more detail, take a look at the JavaDoc on each class.

Seam Solder提供一些公共类让注解和注解类型更加容易工作。本章将通过每个工具类引导您，并为您提供有关如何使用它的一些想法。对于更多的细节，看看每个类的JavaDoc。

1.注释类型生成器

Seam Solder provides an AnnotatedType implementation that should be suitable for the needs of most portable extensions. The AnnotatedType is created from AnnotatedTypeBuilder, typically in an extension's observer method, as follows:

Seam Solder 提供一个AnnotatedType接口来实现大多数的需求扩展。AnnotatedType 是通过 AnnotatedTypeBuilder的一个方法返回得到，如下：

AnnotatedTypeBuilder builder = new AnnotatedTypeBuilder().readFromType(type, true)
/* readFromType can read from an AnnotatedType or a class */
.addToClass(ModelLiteral.INSTANCE); /* add the @Model annotation */

Here we create a new builder, and initialize it using an existing AnnotatedType. We can then add or remove annotations from the class, and its members. When we have finished modifying the type, we call create() to spit out a new, immutable, AnnotatedType.

这里我们有一个新的对象实例，并初始化了它现有的 AnnotatedType。然后我们可以为这个类以及它的成员添加或者移除注解。当 我们完成修改后，我们可以调用create() 来获得一个新的AnnotatedType对象。

AnnotatedType redefinedType = builder.create();

One place this is immensely useful is for replacing the AnnotatedType in an extension that observes the ProcessAnnotatedType event:

对ProcessAnnotatedType进行事件监听对修改AnnotatedType是一个非常有用的扩展：

public <X> void processAnnotatedType(@Observes ProcessAnnotatedType<X> evt) {
AnnotatedTypeBuilder builder = new AnnotatedTypeBuilder()
.readFromType(evt.getAnnotatedType(), true)
.addToClass(ModelLiteral.INSTANCE);
evt.setAnnotatedType(builder.create());
}

This type is now effectively annotated with @Model, even if the annotation is not present on the class definition in the Java source file.

现在这里的注解类型是@Model，即使在Java源文件中对这个类不是这样定义的。

AnnotatedTypeBuilder also allows you to specify a "redefinition", which can be applied to the type, a type of member, or all members. The redefiner will receive a callback for any annotations present which match the annotation type for which the redefinition is applied.

AnnotatedTypeBuilder 还允许你自己定义一个“重定义”，它可以用于类型，类型的成员或所有成员。重新定义的类型可以接受任何使用重新定义的注解的回调。

For example, to remove the qualifier @Unique from the type and any of its members, use this:

例如，对这个类型去掉@Unique修饰符，那么它的所有成员都回改变：

AnnotatedTypeBuilder builder = new AnnotatedTypeBuilder().readFromType(type, true).redefine(Unique.class, new AnnotationRedefiner<Unique>() {
public void redefine(RedefinitionContext<A> ctx) {
ctx.getAnnotationBuilder().remove(Unique.class);
}
});
AnnotatedType redefinedType = builder.create();

No doubt, this is a key blade in Solder's army knife arsenal of tools. You can quite effectively change the picture of the type metadata CDI discovers when it scans and processes the classpath of a bean archive.

毫无疑问，这是打开Solder工具军库的钥匙。当CDI扫描器查找并处理classpath下bean目录的时候，你可以非常有效地改变类型的元数据。

2. Annotation Instance Provider 注解实例提供器

Sometimes you may need an annotation instance for an annotation whose type is not known at development time. Seam Solder provides a AnnotationInstanceProvider class that can create an AnnotationLiteral instance for any annotation at runtime. Annotation attributes are passed in via aMap<String,Object>. For example given the follow annotation:

在开发时，有时你可能需要获得一个不知道其类型注解的注解实例。Seam Solder提供了一个AnnotationInstanceProvider类，它可以在运行时创建一个任何注释AnnotationLiteral的实例。注释属性是通过传递Map<String,Object> 。例如，给定以下注解：

@Retention(RetentionPolicy.RUNTIME)
public @interface MultipleMembers {
int intMember();
long longMember();
short shortMember();
float floatMember();
double doubleMember();
byte byteMember();
char charMember();
boolean booleanMember();
int[] intArrayMember();
}

We can create an annotation instance as follows:

我们可以创建以下注解实例：

/* Create a new provider */
AnnotationInstanceProvider provider = new AnnotationInstanceProvider();
/* Set the value for each of attributes */
Map<String, Object> values = new HashMap<String, Object>();
values.put("intMember", 1);
values.put("longMember", 1);
values.put("shortMember", 1);
values.put("floatMember", 0);
values.put("doubleMember", 0);
values.put("byteMember", ((byte) 1));
values.put("charMember", 'c');
values.put("booleanMember", true);
values.put("intArrayMember", new int[] { 0, 1 });
/* Generate the instance */
MultipleMembers an = provider.get(MultipleMembers.class, values);

3. Annotation Inspector（注解检查器）

The Annotation Inspector allows you to easily discover annotations which are meta-annotated. For example:

注解检查器可以轻松地发现那些元注解。例如：

/* Discover all annotations on type which are meta-annotated @Constraint */
Set<Annotation> constraints = AnnotationInspector.getAnnotations(type,Constraint.class,beanManager);
/* Load the annotation instance for @FacesValidator the annotation may declared on the type, */
/* or, if the type has any stereotypes, on the stereotypes */
FacesValidator validator = AnnotationInspector.getAnnotation(
type, FacesValidator.class, true, beanManager);

The utility methods work correctly on Stereotypes as well. Let's say you're working with a bean that was decorated @Model, running the following example will still show you the underlying @Named.

这些实用方法也能用于Stereotypes（复合注解）。假如我们有一个bean被赋予了@Model注解，运行下面的例子你就可以或者隐藏的注解@Named

// assuming you have a class..
@Model
public class User {
…
}
// Assume type represents the User class
assert AnnotationInspector.isAnnotationPresent(type, Named.class, beanManager);
// Retrieves the underlying @Named instance on the stereotype
Named name = AnnotationInspector.getAnnotation(type, Named.class, true, beanManager);

The search algorithm will first check to see if the annotation is present directly on the annotated element first, then searches within the stereotype annotations on the element. If you only want to search for Annotations on Stereotypes, then you can use either of the methods AnnotationInspector.getAnnotationFromStereotype.

搜索方法会首先查找这个直接添加的注解元素，然后会对复合类型进行查找。如果你要直接对那些复合注解进行查找，你可以调用另外一个方法，AnnotationInspector.getAnnotationFromStereotype.

There is an overloaded form of isAnnotationPresent and getAnnotation to control whether it will search on Stereotypes or not. For both of these methods, a search is performed first directly on the element before searching in stereotypes.

这是对 isAnnotationPresent 和 getAnnotation 两个方法的重新调用判断它是不是一个复合类型的注解。以上的无论哪个方法都先对直接类型注解进行查找。

4. Synthetic Qualifiers（组合修饰符）

When developing an extension to CDI, it can be useful to detect certain injection points, or bean definitions and based on annotations or other metadata, add qualifiers to further disambiguate the injection point or bean definition for the CDI bean resolver. Solder's synthetic qualifers can be used to easily generate and track such qualifers.

当对CDI进行扩展时，它可以为CDI bean 分析器有效地发现已有的注入点或bean的定义还有基本的注解或其他元数据，添加修饰符来进一步消除这些注入点或bean的定义。（翻译的很不通）Solder的组合修饰符可以用来方便地生产跟踪这些修饰符。

In this example, we will create a synthetic qualifier provider, and use it to create a qualifier. The provider will track the qualifier, and if a qualifier is requested again for the same original annotation, the same instance will be returned.

在这个例子中，我们将创建一个组合修饰符提供器，并用它来创建一个修饰符。这个提供器会跟踪这个qualifier，如果这个qualifier被再次调用，它会返回跟上次相同的实例。

/* Create a provider, giving it a unique namespace */
Synthetic.Provider provider = new Synthetic.Provider("com.acme");
/* Get the a synthetic qualifier for the original annotation instance */
Synthetic synthetic = provider.get(originalAnnotation);
/* Later calls with the same original annotation instance will return the same instance */
/* Alternatively, we can "get and forget" */
Synthetic synthetic2 = provider.get();

5. Reflection Utilities

Seam Solder comes with a number miscellaneous reflection utilities; these extend JDK reflection, and some also work on CDI's Annotated metadata. See the javadoc on Reflections for more.

Seam Solder 提供了一些多方面的反射工具类；这些是对JDK反射机制的扩展，也用于对CDI元数据的处理。更多得请看有关放射机制的java文档。

Solder also includes a simple utility, PrimitiveTypes for converting between primitive and their respective wrapper types, which may be useful when performing data type conversion. Sadly, this is functionality which is missing from the JDK.

Solder 也有一个简单的工具类，在对基本数据类型转化的时候，PrimitiveTypes可以很好地完成对数据在其原始类型跟包装类型之间转化。可悲的是，这是JDK中缺少的功能。

InjectableMethod allows an AnnotatedMethod to be injected with parameter values obtained by following the CDI type safe resolution rules, as well as allowing the default parameter values to be overridden.

InjectableMethod允许AnnotatedMethod被作为一个符合CDI类型安全解决规则的参数值注入，也允许默认的参数值被覆盖重写。