「javascope注释」java中常用注解

本篇文章给大家谈谈javascope注释，以及java中常用注解对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、java怎么配置spring的bean
• 2、spring常用注解
• 3、spring注解问题
• 4、java. 问题如下，这是不是spring的注解？如果没有spring的jar来支持的话，下面的代码是不是全错？

java怎么配置spring的bean

众所周知，Spring 框架是控制反转 (IOC) 或依赖性注入 (DI) 模式的推动因素，而这种推动是通过基于容器的配置实现的。过去，Spring 允许开发人员使用基于 XML 的配置，通过利用应用程序上下文 XML 文件来管理 bean 依赖性。此文件处于应用程序的外部，包含 bean 及其与该应用程序的依赖项的定义。尽管使用 XML 配置较为简单和便捷，但仍有另外一种方法可定义 bean 及其依赖项。这种方法也称为基于 Java 的配置。不同于 XML，基于 Java 的配置使您能够以编程方式管理 bean。这可通过运用多种注释来实现。 这篇文章将演示 Java 配置示例，并将其与传统 XML 配置方法相对比。本文将按照如下步骤演示基于 Java 的配置的基本用法：

理解 @Configuration 和 @Bean 注释

使用 AnnotationConfigApplicationContext 注册配置类

配置 Web 应用程序

实现 bean 生命周期回调和范围

我们将使用一所在线大学的 “创建课程” 用例。在创建课程的过程中，还会创建主题或者模块，而各主题可能又有着不同的作业。因此，我们要创建三个 bean，分别为 Course、Module 和 Assignment。Course bean 将包含一个对 Module bean 的引用，后者包含对 Assignment bean 的引用。

理解 @Configuration 和 @Bean 注释

在理想的场景中，您可以在表示应用程序上下文的 XML 中定义 bean。以下代码展示了创建课程 用例中的上下文 XML 及 bean 定义：

清单 1. XML 与 bean 定义

beans

bean id="course" class="demo.Course"

property name="module" ref="module"/

/bean

bean id="module" class="demo.Module"

property name="assignment" ref="assignment"/

/bean

bean id="assignment" class="demo.Assignment" /

/beans

以上 XML 就是您在使用 Spring 配置 bean 时通常会编写的代码。这段 XML 代码定义了 Course bean，它引用 Module bean。Module bean 有一个 Assignment bean 的引用。您现在要删除这段 XML，编写同等效果的 Java 代码。您将使用基于 Java 的配置定义上面指定的 bean。我们会将 XML 替换为 Java 类，这个 Java 类现在将用作 bean 配置的平台。我们将这个类命名为 AppContext.java。以下代码展示了 AppContext类。

清单 2. 包含 bean 定义的 AppContext 配置类

@Configuration

public class AppContext {

@Bean

public Course course() {

Course course = new Course();

course.setModule(module());

return course;

}

@Bean

public Module module() {

Module module = new Module();

module.setAssignment(assignment());

return module;

}

@Bean

public Assignment assignment() {

return new Assignment();

}

}

正如您通过以上代码所看到的那样，现在可以以编程的方式将 bean 定义为基于 Java 的配置的一部分。AppContext 类现在就像 XML 一样表示配置类。这是通过利用 @Configuration 注释实现的。@Configuration 注释位于类的顶端。它告知 Spring 容器这个类是一个拥有 bean 定义和依赖项的配置类。@Bean 注释用于定义 bean。上述注释位于实例化 bean 并设置依赖项的方法上方。方法名称与 bean id 或默认名称相同。该方法的返回类型是向 Spring 应用程序上下文注册的 bean。您可使用 bean 的 setter 方法来设置依赖项，容器将调用它们来连接相关项。基于 Java 的配置也被视为基于注释的配置。

使用 AnnotationConfigApplicationContext 注册配置类

在传统 XML 方法中，您可使用 ClassPathXmlApplicationContext 类来加载外部 XML 上下文文件。但在使用基于 Java 的配置时，有一个AnnotationConfigApplicationContext 类。AnnotationConfigApplicationContext 类是 ApplicationContext 接口的一个实现，使您能够注册所注释的配置类。此处的配置类是使用 @Configuration 注释声明的 AppContext。在注册了所述类之后，@Bean 注释的方法返回的所有 bean 类型也会得到注册。以下代码演示了 AnnotationConfigApplicationContext 类的使用：

清单 3. 使用 AnnotationConfigApplicationContext 注册 AppContext 类

public static void main(String[] args) {

ApplicationContext ctx = new AnnotationConfigApplicationContext(AppContext.class);

Course course = ctx.getBean(Course.class);

course.getName();

}

正如以上代码所示，AppContext 配置类的注册方式是将其传递给 AnnotationConfigApplicationContext 构造函数。此外，您还可以使用所述上下文类的 register 方法来注册配置类。以下代码展示了另外一种方法。

清单 4. 注册 AppContext 类：另外一种方法

public static void main(String[] args) {

ApplicationContext ctx = new AnnotationConfigApplicationContext();

ctx.register(AppContext.class)

}

注册配置类将自动注册 @Bean 注释的方法名称，因而其对应的 bean 就是 Course、Module 和 Assignment。随后您可以使用 getBean 方法来获取相关的 bean，并调用其业务方法。如您所见，编写 Java 的配置类并将其注册到 Spring 上下文非常简单。下一节将讨论如何将基于 Java 的配置与 Web 应用程序配合使用。

配置 Web 应用程序

过去，您通常要利用 XmlWebApplicationContext 上下文来配置 Spring Web 应用程序，即在 Web 部署描述符文件 web.xml 中指定外部 XML 上下文文件的路径。XMLWebApplicationContext 是 Web 应用程序使用的默认上下文类。以下代码描述了 web.xml 中指向将由ContextLoaderListener 监听器类载入的外部 XML 上下文文件的元素。

清单 5. 使用外部 XML 上下文文件的 web.xml

web-app

context-param

param-namecontextConfigLocation/param-name

param-value/WEB-INF/applicationContext.xml/param-value

/context-param

listener

listener-class

org.springframework.web.context.ContextLoaderListener

/listener-class

/listener

servlet

servlet-namesampleServlet/servlet-name

servlet-class

org.springframework.web.servlet.DispatcherServlet

/servlet-class

/servlet

...

/web-app

现在，您要将 web.xml 中的上述代码更改为使用 AnnotationConfigApplicationContext 类。切记，XmlWebApplicationContext 是 Spring 为 Web 应用程序使用的默认上下文实现，因此您永远不必在您的 web.xml 文件中显式指定这个上下文类。现在，您将使用基于 Java 的配置，因此在配置 Web 应用程序时，需要在 web.xml 文件中指定 AnnotationConfigApplicationContext 类。上述代码将修改如下：

清单 6. 修改后的使用 AnnotationConfigApplicationContext 的 web.xml

web-app

context-param

param-namecontextClass/param-name

param-value

org.springframework.web.context.

support.AnnotationConfigWebApplicationContext

/param-value

/context-param

context-param

param-namecontextConfigLocation/param-name

param-value

demo.AppContext

/param-value

/context-param

listener

listener-class

org.springframework.web.context.ContextLoaderListener

/listener-class

/listener

servlet

servlet-namesampleServlet/servlet-name

servlet-class

org.springframework.web.servlet.DispatcherServlet

/servlet-class

init-param

param-namecontextClass/param-name

param-value

org.springframework.web.context.

support.AnnotationConfigWebApplicationContext

/param-value

/init-param

/servlet

...

/web-app

以上修改后的 web.xml 现在定义了 AnnotationConfigWebApplicationContext 上下文类，并将其作为上下文参数和 servlet 元素的一部分。上下文配置位置现在指向 AppContext 配置类。这非常简单。下一节将演示 bean 的生命周期回调和范围的实现。

实现 bean 生命周期回调和范围

生命周期回调

您还可以使用基于 Java 的配置来管理 bean 的生命周期。@Bean 支持两种属性，即 initMethod 和 destroyMethod，这些属性可用于定义生命周期方法。在实例化 bean 或即将销毁它时，容器便可调用生命周期方法。生命周期方法也称为回调方法，因为它将由容器调用。使用 @Bean注释注册的 bean 也支持 JSR-250 规定的标准 @PostConstruct 和 @PreDestroy 注释。如果您正在使用 XML 方法来定义 bean，那么就应该使用 bean 元素来定义生命周期回调方法。以下代码显示了在 XML 配置中通常使用 bean 元素定义回调的方法。

清单 7. 使用 XML 方法实现生命周期回调

bean id="course" class="demo.Course" init-method="setup" destroy-method="cleanup"

property name="module" ref="module"/

/bean

以下代码演示了使用 Java 配置的生命周期方法

清单 8. 使用 AppContext 配置类实现 bean 生命周期方法

@Configuration

public class AppContext {

@Bean(initMethod = "setup", destroyMethod = "cleanup")

public Course course() {

Course course = new Course();

course.setModule(module());

return course;

}

@Bean(initMethod = "setup", destroyMethod = "cleanup")

public Module module() {

Module module = new Module();

module.setAssignment(assignment());

return module;

}

...

}

public class Course {

private Module module;

private String name;

public Course() {

}

public void setup() {

this.name = "M100 Pythagoras Theorems"

}

public void setModule(Module module) {

this.module = module;

}

public void cleanup() {

module = null;

}

}

上面的代码重新访问了 AppContext 配置类。@Bean 注释现在有两个额外的属性，即 initMethod 和 destroyMethod。它们定义了生命周期方法的设置和清除。这些方法是在已经注册的 bean 中实现的，最终由容器在 bean 初始化及其销毁之前调用它。这里以 Course bean 为例，提供了生命周期方法实现。所实现的方法是 setup 和 cleanup。同样，您还可以在 Module 和 Assignment bean 中实现这些方法。

Bean 范围

bean 的方法是使用 @Scope 注释定义的。XML 中实现这一目标的方法是指定 bean 元素中的 scope 属性。

清单 9. 使用 XML 方法定义 bean 范围

bean id="course" class="demo.Course" scope="prototype"

property name="module" ref="module"/

/bean

以下代码展示了使用 Java 配置的 bean 范围定义：

清单 10. 使用 AppContext 配置类定义 bean 范围

@Configuration

public class AppContext {

@Bean(initMethod = "setup", destroyMethod = "cleanup")

@Scope("prototype")

public Course course() {

Course course = new Course();

course.setModule(module());

return course;

}

...

}

正如您在上面的代码中所看到的那样，在 Java 配置类中定义 bean 的范围非常简单。上面的 AppContext 配置类使用 @Scope 注释为 Coursebean 定义了一个 prototype 范围。默认范围是 singleton。

利用 Java 配置可以做许多事情。本文只触及了一些基础内容。使用 Java 配置并无显著优势，它仅仅是 Spring 提供的 XML 配置的替代方法。对于不喜欢在框架中使用 XML 的人来说，这是实现配置的一种出色方法。但缺点也是显而易见的，如果您对 Java 类中的配置做出了任何更改，就必须重新编译应用程序。

spring常用注解

一、组件注解

1、 @Component(“xxx”)

指定某个类是容器的bean， @Component(value="xx") 相当于 ，其中 value 可以不写。

用于标注类为spring容器bean的注解有四个， 主要用于区别不同的组件类，提高代码的可读性：

a、 @Component, 用于标注一个普通的bean

b、 @Controller 用于标注一个控制器类（控制层 controller）

c、 @Service 用于标注业务逻辑类（业务逻辑层 service）

d、 @Repository 用于标注DAO数据访问类 （数据访问层 dao）

对于上面四种注解的解析可能是相同的，尽量使用不同的注解提高代码可读性。

注解用于修饰类，当不写value属性值时，默认值为类名首字母小写。

2、 @Scope(“prototype”)

该注解和 @Component 这一类注解联合使用，用于标记该类的作用域，默认 singleton 。

也可以和 @Bean 一起使用，此时 @Scope 修饰一个方法。关于@Bean稍后有说明

3、 @Lazy（true）

指定bean是否延时初始化，相当于 ，默认false。@Lazy可以和@Component这一类注解联合使用修饰类，也可以和@Bean一起使用修饰方法

注 ：此处初始化不是指不执行 init-method ，而是不创建bean实例和依赖注入。只有当该bean（被@Lazy修饰的类或方法）被其他bean引用（可以是自动注入的方式）或者执行getBean方法获取，才会真正的创建该bean实例，其实这也是BeanFactory的执行方式。

4、 @DepondsOn({“aa”，“bb”})

该注解也是配合 @Component 这类注解使用，用于强制初始化其他bean

上面的代码指定，初始化bean “userAction"之前需要先初始化“aa”和“bb”两个bean,但是使用了@Lazy(true)所以spring容器初始化时不会初始化"userAction” bean。

5、 @PostConstructor和@PreDestroy

@PostConstructor 和 @PreDestroy 这两个注解是j2ee规范下的注解。这两个注解用于修饰方法，spring用这两个注解管理容器中spring生命周期行为。

a、 @PostConstructor 从名字可以看出构造器之后调用,相当于 。就是在依赖注入之后执行

b、 @PreDestroy 容器销毁之前bean调用的方法，相当于

6、 @Resource（name=“xx”）

@Resource 可以修饰成员变量也可以修饰set方法。当修饰成员变量时可以不写set方法，此时spring会直接使用j2ee规范的Field注入。

@Resource有两个比较重要的属性，name和type

a、 如果指定了name和type，则从Spring容器中找到唯一匹配的bean进行装配，找不到则抛出异常;

b、 如果指定了name，则从spring容器查找名称（id）匹配的bean进行装配，找不到则抛出异常;

c、 如果指定了type，则从spring容器中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常;

d、 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配

如果没有写name属性值时

a、 修饰成员变量，此时name为成员变量名称

b、 修饰set方法，此时name 为set方法的去掉set后首字母小写得到的字符串

7、 @Autowired（required=false）

@Autowired可以修饰构造器，成员变量，set方法，普通方法。@Autowired默认使用byType方式自动装配。required标记该类型的bean是否是必须的，默认为必须存在（true）。

可以配合 @Qualifier(value="xx") ,实现按beanName注入：

a、 required=true(默认），为true时，从spring容器查找和指定类型匹配的bean，匹配不到或匹配多个则抛出异常

b、 使用 @Qualifier（"xx"） ,则会从spring容器匹配类型和 id 一致的bean，匹配不到则抛出异常

@Autowired会根据修饰的成员选取不同的类型：

a、 修饰成员变量。该类型为成员变量类型

b、 修饰方法，构造器。注入类型为参数的数据类型，当然可以有多个参数

8、demo

业务逻辑层：

数据访问层：

测试类：

输出结果：

可以看到虽然UserDao 使用@Lazy，但是还是在spring容器初始化的时候还是创建了UserDao实例。原因很简单，因为在UserService中需要注入UserDao，所以在此时创建的UserDao实例也属于延时初始化。

在上面我们还使用了两个接口InitializingBean 和DisposableBean，这两个接口用于管理 singleton 作用域的bean的生命周期，类似init-method和destroy-method。不同之处就是调用的循序不一致：

a、 初始化调用顺序 ：@PostConstructor InitializingBean init-method 用于指定bean依赖注入后的行为

b、 销毁调用顺序 @PreDestroy DisposableBean destroy-method 用于定制bean销毁之前的行为

该注解是AspectJ中的注解，并不是spring提供的，所以还需要导入aspectjweaver.jar，aspectjrt.jar，除此之外还需要依赖aopalliance.jar

依赖包：

UserDao.java

配置文件 applicationContext.xml：

测试类：

1、 @Aspect

修饰Java类，指定该类为切面类。当spring容器检测到某个bean被@Aspect修饰时，spring容器不会对该bean做增强处理（bean后处理器增强，代理增强）

2、 @Before

修饰方法，before增强处理。用于对目标方法（切入点表达式表示方法）执行前做增强处理。可以用于权限检查，登陆检查。

常用属性：

value： 指定切入点表达式 或者引用一个切入点

对com.example.aop 包下所有的类的所有方法做 before增强处理：

结果：

如果同一条切入点表达式被使用多次，可以使用更友好的方式。定义一个切入点：

增强方法可以接受一个JoinPoint 类型的参数，用于获取被执行目标方法的一下属性。

结果：

3、 @AfterReturning

修饰方法，afterreturning增强处理。目标方法正常结束后做增强处理。

常用属性：

a、 pointcut/value：指定切入点表达式

b、 returning：指定一个参数名，用于接受目标方法正常结束时返回的值。参数名称需要在增强方法中定义同名的参数。

注意：

a、 如果使用了returning 。那么增强方法中的数据类型必须是返回结果的类型或者父类型，否则不会调用该增强处理。

b、 使用了returning 还可以用来 修改返回结果 。

以上面的例子来说，目标方法返回结果类型应该满足下面的条件

修改返回值：

结果：

可以看到 AfterReturning 修改了返回结果。

4、 @AfterThrowing

修饰方法，afterthrowing增强处理。当目标程序方法抛出 异常或者异常无法捕获时，做增强处理。

常用属性：

a、 pointcut/value ：指定切入点表达式

b、 throwing：指定一个形参，在增强方法中定义同名形参，用于访问目标方法抛出的异常

参数类型必须是 Throwable 的子类，同样也会有上面@AfterReturning 参数类型匹配的问题。

5、 @After

修饰方法 ，after增强处理。无论方法是否正常结束，都会调用该增强处理（@After= @AfterReturning+@AfterThrowing）。但是该增强方式无法获取目标方法的返回结果，也获取目标方法抛出的异常。所以一般用于进行释放资源，功能类似于 finally。

常用属性：

a、 value ：指定切入点表达式

结果：

从上面的结果来看 After 增加处理 ，因为不能接受返回结果作为参数，所以不能修改返回结果。

6、 @Around

修饰方法， around增强处理。该处理可以目标方法执行之前和执行之后织入增强处理（@Before+@AfterReturning）。

Around增强处理通常需要在线程安全的环境下使用，如果@Before和@AfterReturning可以处理就没必要使用@Around。

常用属性：

a、 value ：指定切入点表达式

当定义一个Aound增前处理时，增强方法第一形参需要时ProceedingJoinPoint类型。ProceedingJoinPoint有一个Object proceed()方法，用于执行目标方法。当然也可以为目标方法传递数组参数，来修改目前方法的传入参数。

around小结：

a、 Around增强处理通常需要 在线程安全 的环境下使用

b、 调用 proceed()可以获取返回结果，所以可以修改目标方法的返回值

c、 proceed(Object[] var1) 可以修改入参，修改目标方法的入参

d、 可以进行目标方法执行之前和执行之后织入增强处理

around 和 afterReturning 都可以修改返回结果。不过两者的原理不同：

a、 around：可以任意修改，或者返回不相关的值。这个返回值完全可以自主控制

b、 afterReturning，通过方法参数 ，使用对象引用的方式来修改对象。修改对象引用地址那么修改时无效的

除此之外从输出结果来看，增强处理是有序的：

around 和 afterReturning小结：

a、 只有 around 和 afterReturning 可以获取并修改返回结果。需要注意两种方式修改的区别。

b、 around 需要线程安全

c、 虽然增强处理都需要 切入点表达式，并不是都支持 pointcut 属性，所以最好都是用value 属性指定。当注解只需要value属性时，value可以省略

7、 @Pointcut

修饰方法，定义一个切入点表达式用于被其他增强调用。使用该方式定义切入点方便管理，易复用。

切入点方法定义和测试方法定义类似，具有以下特点：

a、 无返回值 （void）

b、 无参数

c、 方法体为空

d、 方法名就是切入点名称

e、 方法名不能为 execution

切入点表达式

切入点表达式可以通过 、 || 、 ! 连接

1）、execution 表达式：

2）、within 表达式：

a、匹配指定类下的所有方法。

b、匹配执行包及其子包下所有类的所有方法。

所以within可以看做execution的简写，不需要指定返回类型、方法名、参数（ 最小作用单位是类 ）

3）、 @annotation：匹配使用指定注解修饰的目标方法；

匹配使用@CustomMethodAnnotation注解的目标方法。

4）、 @within: 用于匹配使用指定注解修饰的类下的所有方法

within 作用范围是类，@within的作用范围与其一致。不同的是@within 指定的不是类而是注解

匹配使用@ResponseBody 注解的类 下的所有方法。

AOP小结：

1）、 Around增强处理通常需要 在线程安全 的环境下使用

2）、 使用 around 和 afterReturning 可以获取并修改返回结果

3）、 增强处理指定 切入点表达式时，最好使用value 属性

4）、 切入点 名称（方法名）不能为 execution

5）、 AfterReturning 指定了 returning 属性接受目标方法返回结果，注意 参数类型需要和返回结果类型一致（满足 resutType instanceof argsType ）

增强方式的顺序：

1、 @Bean(name=“xxx”)

修饰方法，该方法的返回值为spring容器中管理的bean。当然该注解和上面的@Component效果一样，主要用于做区分。

@Bean 通常使用在 @Configuration 修饰的配置类中，该注解功能相当于 元素

常用的属性：

a、 name：bean id 。name可以省略，省略时bean名称为方法名。也可以指定多个名称（逗号隔开）。

b、 autowire： 是否自动注入，默认Autowire.NO

c、 initMethod：bean的初始化方法。在依赖注入之后执行

d、 destroyMethod: spring容器关闭时bean调用的方法

当然 @Bean 还可以配合 @Scope 指定bean的作用域

2、 @ConfigurationProperties

用于从属性文件中获取值 application.properties 或者 application.yml 。当然了 如果在配置文件中引入其他配置文件，也可以获取到属性值。

包含的属性：

a、 value | prefix 两者互为别名。指定前缀，默认为""

b、 ignoreUnknownFields：默认为true。是否忽略未知字段，当实体中的字段在配置文件中不存在时，是忽略还是抛出异常

c、 ignoreInvalidFields： 默认false。 是否忽略不合法的字段，此处的不合法是指类型不合适，配置文件中存在改配置但是无法转化为指定的字段类型。

Mybatis属性配置

application.properties：

ConfigurationProperties 可以配置前缀，然后会根据实体的变量名拼接前缀，去配置文件中查询配置。

3、 @Configuration

修饰一个Java类，被修饰的类相当于一个xml配置文件。功能类似于 。在springboot中大量使用了该注解，该注解提供了一种使用Java类方式配置bean。

可以发现 @Configuration使用了@Component 注解修饰。

实例 ：

配置Mybatis会话工厂

4、 @Import

功能和 类似，修饰Java类，用于向当前类导入其他配置类。 可以导入多个配置文件，通常用于导入不在包扫描范围内的配置文件。可以被扫描的配置类可以直接访问，没有必要使用@Import 导入。

比如 SpringBoot的启动类指定的包扫描路径为 com.example

数据库的配置文件在 com包下。

在MyBatisConfig 中引入 DataSourceConfig， 就会解析DataSourceConfig。将解析出的Bean交给容器管理

5、 @ImportResource

修饰Java类，用于向类引入xml配置文件。

用于导入包含bean定义的配置文件，功能和 类似。默认情况下可以处理后缀为 .groovy 和.xml 的配置文件

6、 @Value("${expression}")

修饰成员变量或者 方法、构造器的参数，用于属性值注入（在配置文件中配置的值）。

注意: @Value不能对 static 属性注入。

如果的确需要注入到静态变量，可以通过以下方式间接进行注入：

1）、设置一个私有静态 实例

2）、通过构造函数或者 @PostConstruct 注解为 静态实例 赋值，指向本身（this）

3）、对成员属性注入内容

4）、提供静态方法，使用静态实例获取成员属性

7、@PropertySource(value=“classpath:jdbc.properties”)

该注解用来加载属性文件。

常用属性：

a、 ignoreResourceNotFound： 当资源文件找不到的时候是否会忽略该配置，而不是抛出错误。一般用于可选项

b、 encoding ： 资源文件使用什么编码方式

c、 value ： 指定属性文件位置。可以配置多个属性文件，不可以使用通配符。

在 PropertySource 中可以指定多个路径，并且会将属性文件中的值加载到 Environment 中。

@ConfigurationProperties 和 @PropertySource

它们的使用有一些差异：

1）、 @PropertySource 使用该注解加载的是 相对独立的属性文件，可以同时加载多个文件 （xxx.properties），而且 不支持自动注入 ， 不支持前缀注入

2）、 @ConfigurationProperties 用于加载配置文件（application.properties | application.yml）。该注解功能更强大：

a、 支持前缀注入 （ prefix ）

b、 相同属性名的自动注入

c、 $("") 支持EL表达式注入

应用实例：

在以往的开发中通常会将数据库连接信息存放在单独的属性文件中（jdbc.properties）。而在spring boot 中我们会将数据库的信息存放在配置文件中，这会极大便利开发工作。

jdbc.properties：

可以通过 @Value 注解将配置文件的值注入到实体类中

也可以注入Environment ，通过Environment 获取值

1、 @ResponseBody

控制器方法返回值会使用 HttpMessageConverter 进行数据格式化，转化为JSON字符串。

同样的 ResponseBodyAdvice: 针对使用@ResponseBody的注解的类，方法做增强处理。

2、 @RestController

@RestController = @Controller + @ResponseBody ， 所以通常直接使用@RestController 注解

3、 @RequestBody

从Reuqest请求体中获取内容，绑定到方法的指定参数上。 SpringMVC 使用HttpMessageConverter 接口将请求体中的数据转化为方法参数类型。

SpringMVC 给用户对参数的处理提供了很大支配权。 我们可以使用 接口RequestBodyAdvice 来实现对参数进行拦截处理。

注意

1）、 RequestBodyAdvice : 针对所有以@RequestBody的参数做处理

2）、 自定义的处理对象类上必须得加上@ControllerAdvice注解!

利用此功能我们可以做以下处理工作：

1）、参数做解密处理。

2）、修改接受的参数数据。

4、 @RequestParam

从Request请求中获取指定的参数。

可以设置的属性：

1）、 required ： 默认为true 参数必须存在 。参数不存在时抛出异常(MissingServletRequestParameterException). 提示信息

2）、 defaultValue ： 设置参数默认值。 当参数没有提供或者为空值时生效, 包含隐式定义 required=false

3）、 name | value ， 互为别名的属性， 绑定请求中的参数名。 request.getParameter(name);

5、 @RequestMapping

用于设置 请求 和 Method 的映射关系。指明何种请求可以和方法匹配

可配置属性值：

1）、 path、value、 name, 互为别名，设置可以处理的url。

2）、 consumes，字符串数组。 指定可以处理的 媒资类型，仅当请求头中的 Content-Type 与其中一种媒体类型匹配时，才会映射请求。所以该配置会缩小可匹配的请求。 当url 匹配但是consumes不匹配时， 状态码415。 不设置的话，表示不限制媒资类型，参数的具体使用何种方式解析，SpringMVC会选择合适的处理器处理。

3）、 produces，字符串数组。 生成的媒资类型，该属性会影响实际的输出类型。和consumes一样，改配置会缩小匹配的范围。 只有当请求头中的 Accept 与 配置的任意一个媒资类型匹配时，才会映射请求。 当url 匹配与consumes不匹配时， 状态码406 。 比如：为了生成UTF-8编码的JSON响应，应使用 MediaType.APPLICATION_JSON_UTF8_VALUE。

spring注解问题

• @Controller

• @Service

• @Autowired

• @RequestMapping

• @RequestParam

• @ModelAttribute

• @Cacheable

• @CacheFlush

• @Resource

• @PostConstruct

• @PreDestroy

• @Repository

• @Component （不推荐使用）

• @Scope

• @SessionAttributes

• @InitBinder

• @Required

• @Qualifier

@Controller

• 例如

@Controller

public class SoftCreateController extends SimpleBaseController {}

• 或者

@Controller("softCreateController")

• 说明

@Controller 负责注册一个bean 到spring 上下文中，bean 的ID 默认为类名称开头字母小写

@Service

• 例如

@Service

public class SoftCreateServiceImpl implements ISoftCreateService {}

• 或者

@Service("softCreateServiceImpl")

• 说明

@Service 负责注册一个bean 到spring 上下文中，bean 的ID 默认为类名称开头字母小写

@Autowired

• 例如

@Autowired

private ISoftPMService softPMService;

• 或者

@Autowired(required=false)

private ISoftPMService softPMService = new SoftPMServiceImpl();

• 说明

@Autowired 根据bean 类型从spring 上线文中进行查找，注册类型必须唯一，否则报异常。与@Resource 的区别在于，@Resource 允许通过bean 名称或bean 类型两种方式进行查找@Autowired(required=false) 表示，如果spring 上下文中没有找到该类型的bean 时， 才会使用new SoftPMServiceImpl();

@Autowired 标注作用于 Map 类型时，如果 Map 的 key 为 String 类型，则 Spring 会将容器中所有类型符合 Map 的 value 对应的类型的 Bean 增加进来，用 Bean 的 id 或 name 作为 Map 的 key。

@Autowired 还有一个作用就是，如果将其标注在 BeanFactory 类型、ApplicationContext 类型、ResourceLoader 类型、ApplicationEventPublisher 类型、MessageSource 类型上，那么 Spring 会自动注入这些实现类的实例，不需要额外的操作。

@RequestMapping

• 类

@Controller

@RequestMapping("/bbtForum.do")

public class BbtForumController {

@RequestMapping(params = "method=listBoardTopic")

public String listBoardTopic(int topicId,User user) {}

}

• 方法

@RequestMapping("/softpg/downSoftPg.do")

@RequestMapping(value="/softpg/ajaxLoadSoftId.do",method = POST)

@RequestMapping(value = "/osu/product/detail.do", params = { "modify=false" }, method =POST)

• 说明

@RequestMapping 可以声明到类或方法上

• 参数绑定说明

如果我们使用以下的 URL 请求：

;topicId=1userId=10userName=tom

topicId URL 参数将绑定到 topicId 入参上，而 userId 和 userName URL 参数将绑定到 user 对象的 userId 和 userName 属性中。和 URL 请求中不允许没有 topicId 参数不同，虽然 User 的 userId 属性的类型是基本数据类型，但如果 URL 中不存在 userId 参数，Spring 也不会报错，此时 user.userId 值为 0 。如果 User 对象拥有一个 dept.deptId 的级联属性，那么它将和 dept.deptId URL 参数绑定。

@RequestParam

• 参数绑定说明

@RequestParam("id")

;id=1userId=10userName=tom

listBoardTopic(@RequestParam("id")int topicId,User user) 中的 topicId 绑定到 id 这个 URL 参数， 那么可以通过对入参使用 @RequestParam 注解来达到目的

@RequestParam(required=false)：参数不是必须的，默认为true

@RequestParam(value="id",required=false)

请求处理方法入参的可选类型

• Java 基本数据类型和 String

默认情况下将按名称匹配的方式绑定到 URL 参数上，可以通过 @RequestParam 注解改变默认的绑定规则

• request/response/session

既可以是 Servlet API 的也可以是 Portlet API 对应的对象，Spring 会将它们绑定到Servlet 和 Portlet 容器的相应对象上

• org.springframework.web.context.request.WebRequest

内部包含了 request 对象

• java.util.Locale

绑定到 request 对应的 Locale 对象上

• java.io.InputStream/java.io.Reader

可以借此访问 request 的内容

• java.io.OutputStream / java.io.Writer

可以借此操作 response 的内容

• 任何标注了 @RequestParam 注解的入参

被标注 @RequestParam 注解的入参将绑定到特定的 request 参数上。

• java.util.Map / org.springframework.ui.ModelMap

它绑定 Spring MVC 框架中每个请求所创建的潜在的模型对象，它们可以被 Web 视图对象访问（如 JSP ）

• 命令/ 表单对象（注：一般称绑定使用 HTTP GET 发送的 URL 参数的对象为命令对象，而称绑定使用HTTP POST 发送的 URL 参数的对象为表单对象）

它们的属性将以名称匹配的规则绑定到 URL 参数上，同时完成类型的转换。

而类型转换的规则可以通过 @InitBinder 注解或通过 HandlerAdapter 的配置进行调 整

• org.springframework.validation.Errors / org.springframework.validation.BindingResult

为属性列表中的命令/ 表单对象的校验结果，注意检验结果参数必须紧跟在命令/ 表单对象的后面

• org.springframework.web.bind.support.SessionStatus

可以通过该类型 status 对象显式结束表单的处理，这相当于触发 session 清除其中的通过@SessionAttributes 定义的属性

请求处理方法返回值的可选类型

• void

此时逻辑视图名由请求处理方法对应的 URL 确定，如以下的方法：

@RequestMapping("/welcome.do")

public void welcomeHandler() {}

对应的逻辑视图名为 “ welcome ”

• String

此时逻辑视图名为返回的字符，如以下的方法：

@RequestMapping(method = RequestMethod.GET)

public String setupForm(@RequestParam("ownerId") int ownerId, ModelMap model) {

Owner owner = this.clinic.loadOwner(ownerId);

model.addAttribute(owner);

return "ownerForm";

}

对应的逻辑视图名为 “ ownerForm ”

• org.springframework.ui.ModelMap

和返回类型为 void 一样，逻辑视图名取决于对应请求的 URL ，如下面的例子：

@RequestMapping("/vets.do")

public ModelMap vetsHandler() {

return new ModelMap(this.clinic.getVets());

}

对应的逻辑视图名为 “ vets ” ，返回的 ModelMap 将被作为请求对应的模型对象，可以在 JSP 视图页面中访问到。

• ModelAndView

当然还可以是传统的 ModelAndView 。

@ModelAttribute

• 作用域：request

• 例如

@RequestMapping("/base/userManageCooper/init.do")

public String handleInit(@ModelAttribute("queryBean") ManagedUser sUser,Model model,){

• 或者

@ModelAttribute("coopMap")// 将coopMap 返回到页 面

public MapLong,CooperatorInfo coopMapItems(){}

• 说明

@ModelAttribute 声明在属性上，表示该属性的value 来源于model 里"queryBean" ，并被保存到model 里@ModelAttribute 声明在方法上，表示该方法的返回值被保存到model 里

@Cacheable 和@CacheFlush

• @Cacheable ：声明一个方法的返回值应该被缓 存

例如：@Cacheable(modelId = "testCaching")

• @CacheFlush ：声明一个方法是清空缓存的触发器

例如：@CacheFlush(modelId = "testCaching")

• 说明

要配合缓存处理器使用，参考：

@Resource

• 例如

@Resource

private DataSource dataSource; // inject the bean named 'dataSource'

• 或者

@Resource(name="dataSource")

@Resource(type=DataSource.class)

• 说明

@Resource 默认按bean 的name 进行查找，如果没有找到会按type 进行查找，

此时与@Autowired 类 似

在没有为 @Resource 注解显式指定 name 属性的前提下，如果将其标注在 BeanFactory 类型、ApplicationContext 类型、ResourceLoader 类型、ApplicationEventPublisher 类型、MessageSource 类型上，那么 Spring 会自动注入这些实现类的实例，不需要额外的操作。此时 name 属性不需要指定 ( 或者指定为"")，否则注入失败；

@PostConstruct 和@PreDestroy

• @PostConstruct

在方法上加上注解@PostConstruct ，这个方法就会在Bean 初始化之后被Spring 容器执 行

（注：Bean 初始化包括，实例化Bean ，并装配Bean 的属性（依赖注入））。

• @PreDestroy

在方法上加上注解@PreDestroy ，这个方法就会在Bean 被销毁前被Spring 容器执行。

@Repository

• 与@Controller 、@Service 类似，都是向spring 上下文中注册bean ，不在赘述。

@Component （不推荐使用）

• @Component

@Component 是所有受Spring 管理组件的通用形式，Spring 还提供了更加细化的注解形式： @Repository 、@Service 、@Controller ，它们分别对应存储层Bean ，业务层Bean ，和展示层Bean 。

目前版本（2.5 ）中，这些注解与@Component 的语义是一样的，完全通用， 在Spring 以后的版本中可能会给它们追加更多的语义。 所以，我们推荐使用@Repository 、@Service 、@Controller 来替代@Component 。

@Scope

• 例如

@Scope("session")

@Repository()

public class UserSessionBean implementsSerializable {}

• 说明

在使用XML 定义Bean 时，可以通过bean 的scope 属性来定义一个Bean 的作用范围，

同样可以通过@Scope 注解来完成

@Scope中可以指定如下值：

singleton:定义bean的范围为每个spring容器一个实例（默认值）

prototype:定义bean可以被多次实例化（使用一次就创建一次）

request:定义bean的范围是http请求（springMVC中有效）

session:定义bean的范围是http会话（springMVC中有效）

global-session:定义bean的范围是全局http会话（portlet中有效）

@SessionAttributes

• 说明

Spring 允许我们有选择地指定 ModelMap 中的哪些属性需要转存到 session 中，

以便下一个请求属对应的 ModelMap 的属性列表中还能访问到这些属性。

这一功能是通过类定义处标注 @SessionAttributes 注解来实现的。

@SessionAttributes 只能声明在类上，而不能声明在方法上。

• 例如

@SessionAttributes("currUser") // 将ModelMap 中属性名为currUser 的属性

@SessionAttributes({"attr1","attr2"})

@SessionAttributes(types = User.class)

@SessionAttributes(types = {User.class,Dept.class})

@SessionAttributes(types = {User.class,Dept.class},value={"attr1","attr2"})

@InitBinder

• 说明

如果希望某个属性编辑器仅作用于特定的 Controller ，

可以在 Controller 中定义一个标注 @InitBinder 注解的方法，

可以在该方法中向 Controller 了注册若干个属性编辑器

• 例如

@InitBinder

public void initBinder(WebDataBinder binder) {

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

dateFormat.setLenient(false);

binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, false));

}

@Required

• 例如

@required

public setName(String name){}

• 说明

@ required 负责检查一个bean在初始化时其声明的 set方法是否被执行， 当某个被标注了 @Required 的 Setter 方法没有被调用，则 Spring 在解析的时候会抛出异常，以提醒开发者对相应属性进行设置。 @Required 注解只能标注在 Setter 方法之上。因为依赖注入的本质是检查 Setter 方法是否被调用了，而不是真的去检查属性是否赋值了以及赋了什么样的值。如果将该注解标注在非 setXxxx() 类型的方法则被忽略。

@Qualifier

• 例如

@Autowired

@Qualifier("softService")

private ISoftPMService softPMService;

• 说明

使用@Autowired 时，如果找到多个同一类型的bean，则会抛异常，此时可以使用 @Qualifier("beanName")，明确指定bean的名称进行注入，此时与 @Resource指定name属性作用相同。

求采纳为满意回答。

java. 问题如下，这是不是spring的注解？如果没有spring的jar来支持的话，下面的代码是不是全错？

@Service 说明是一个service层，也是这个service的名称，用于自动注解。

@Scope() 这个不是很清楚

@Autowired 是自动实现方法，可以是 service实现层，也可以是dao实现层

这些都是注解。由spring统一管理，很方便。没有jar包肯定错

javascope注释的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java中常用注解、javascope注释的信息别忘了在本站进行查找喔。