Spring注解大全（示例详解）
Controller
标识一个该类是Spring MVC controller处理器，用来创建处理http请求的对象.
@Controller
public class TestController {@RequestMapping("/test")public String test(Map<String,Object> map){return "hello";}
}
RestController
spring4之后加入的注解，原来在 @Controller中返回json需要 @ResponseBody来配合，如果直接用 @RestController替代 @Controller就不需要再配置 @ResponseBody，默认返回json格式。
@RestController
public class TestController {@RequestMapping("/test")public String test(Map<String,Object> map){return "hello";}
}
Service
用于标注业务层组件，以注解的方式把这个类注入到spring配置中
@Service
public class TestService {public String test(Map<String,Object> map){return "hello";}
}
Autowired
用来装配bean，都可以写在字段上，或者方法上。
默认情况下必须要求依赖对象必须存在，如果要允许null值，可以设置它的required属性为false，例如：@Autowired(required=false)
@RestController
public class TestController {@Autowired(required=false)private TestService service;@RequestMapping("/test")public String test(Map<String,Object> map){return "hello";}
}
RequestMapping
类定义处: 提供初步的请求映射信息，相对于 WEB 应用的根目录。
方法处: 提供进一步的细分映射信息，相对于类定义处的 URL。(还有许多属性参数，不细讲，可自行查找)
@RestController
public class TestController {@RequestMapping("/test")public String test(Map<String,Object> map){return "hello";}
}
RequestParam
用于将请求参数区数据映射到功能处理方法的参数上，其中course_id就是接口传递的参数，id就是映射course_id的参数名，也可以不写value属性
public Resp test(@RequestParam(value="course_id") Integer id){return Resp.success(customerInfoService.fetch(id));
}
NonNull
标注在方法、字段、参数上，表示对应的值可以为空。
public class Student {@NonNullprivate Integer age;private String name;public void setAge(Integer age){this.age = age;}public Integer getAge() {return age;}public void setName(String name){this.name = name;}public String getName(){return name;}
}
Nullable
标注在方法、字段、参数上，表示对应的值不能为空。
public class Student {@Nullableprivate Integer age;private String name;public void setAge(Integer age){this.age = age;}public Integer getAge() {return age;}public void setName(String name){this.name = name;}public String getName(){return name;}
}
Resource(等同于@Autowired)
@Autowired 按byType自动注入，而 @Resource默认按 byName自动注入， @Resource有两个属性是比较重要的，分是name和type，Spring将 @Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。
如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常
如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常
如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常
如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配
<bean id="student1" class="com.tutorialspoint.Student"><property name="name" value="Zara" /><property name="age" value="11"/></bean><bean id="student2" class="com.tutorialspoint.Student"><property name="name" value="Nuha" /><property name="age" value="2"/></bean>
@Resource(name= " student1")
private Student student ;
@Resource(type= "student2")
public void setSpellChecker( Studentstudent){ this.Student= student;
}
示例
@Service(value="MyServiceImplA")
public class MyServiceImplA implements MyService@Service(value="MyServiceImplB")
public class MyServiceImplB implements MyService@RestController()
public class MyServiceController {@Resource(name="MyServiceImplB")private MyService myService;
}
Qualifier
当一个接口有多个实现类时，就可以用此注解表明哪个实现类才是我们所需要的，名称为我们之前定义 @Service注解的名称之一。
//接口类
public interface TestService{}
//实现类1
@Service("service1")public class TestServiceImpl1 implements TestService{}
//实现类2@Service("service2")public class TestServiceImpl2 implements TestService{}
//测试
@Autowired
@Qualifier("service1")
private TestService testService;
Component
把普通pojo实例化到spring容器中，相当于配置文件中的
它泛指各种组件，就是说当我们的类不属于各种归类的时候（不属于@Controller、@Services等的时候），我们就可以使用@Component来标注这个类。
此外，被@controller 、@service、@repository 、@component 注解的类，都会把这些类纳入进spring容器中进行管理
@Component
public class TestClass {public String test(Map<String,Object> map){return "hello";}
}
Repository
作用为给bean在容器中命名定义一个接口
public interface UserRepository {void save();
}
两个实现类
package com.proc.bean.repository;import org.springframework.stereotype.Repository;//将此UserRepositoryImps类在容器中命名改为userRepository
@Repository("userRepository")
public class UserRepositoryImps implements UserRepository{@Overridepublic void save() {System.out.println("UserRepositoryImps save");}
}
package com.proc.bean.repository;import org.springframework.stereotype.Repository;//这个实现类则不进行命名
@Repository
public class UserJdbcImps implements UserRepository {@Overridepublic void save() {System.out.println("UserJdbcImps save");}
}
调用接口测试:
@Autowiredprivate UserRepository userRepository;//会找到我们命名为userRepository的bean，并装配到userRepository中
Scope
@Scope注解是springIoc容器中的一个作用域，在 Spring IoC 容器中具有以下几种作用域：基本作用域singleton（单例）、prototype(多例)，Web 作用域（reqeust、session、globalsession），自定义作用域。（@Scope注解默认的singleton单例模式）
prototype原型模式：
@Scope(value=ConfigurableBeanFactory.SCOPE_PROTOTYPE)这个是说在每次注入的时候回自动创建一个新的bean实例
singleton单例模式：
@Scope(value=ConfigurableBeanFactory.SCOPE_SINGLETON)单例模式，在整个应用中只能创建一个实例
globalsession模式：
@Scope(value=WebApplicationContext.SCOPE_GLOBAL_SESSION)全局session中的一般不常用
@Scope(value=WebApplicationContext.SCOPE_APPLICATION)在一个web应用中只创建一个实例
request模式：
@Scope(value=WebApplicationContext.SCOPE_REQUEST)在一个请求中创建一个实例
session模式：
@Scope(value=WebApplicationContext.SCOPE_SESSION)每次创建一个会话中创建一个实例
/*** 定义一个bean对象* @return*/@Scope(value=ConfigurableBeanFactory.SCOPE_SINGLETON)@Bean(value="user0",name="user0",initMethod="initUser",destroyMethod="destroyUser")public User getUser(){System.out.println("创建user实例");return new User("张三",26);}
Bean
产生一个bean的方法，并且交给Spring容器管理，相当于配置文件中的
@Beanpublic class UserTest(){public User getUser(){System.out.println("创建user实例");return new User("张三",26);}}
Transactional
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:tx="http://www.springframework.org/schema/tx"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
JDBC事务
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource" /></bean>
<tx:annotation-driven transaction-manager="transactionManager" />
Hibernate事务
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean>
<tx:annotation-driven transaction-manager="transactionManager" />
JPA事务
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean>
<tx:annotation-driven transaction-manager="transactionManager" />
Java原生API事务
<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"><property name="transactionManagerName" value="java:/TransactionManager" /></bean>
<tx:annotation-driven transaction-manager="transactionManager" />
spring所有的事务管理策略类都继承自org.springframework.transaction.PlatformTransactionManager接口
Aspect
作用是标记一个切面类（spring不会将切面注册为Bean也不会增强，但是需要扫描）
<!-- 扫描Aspect增强的类 -->
<context:component-scan base-package=""><context:include-filter type="annotation"expression="org.aspectj.lang.annotation.Aspect"/>
</context:component-scan><!-- 开启@AspectJ注解支持 -->
<aop:aspectj-autoproxy/>
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"><!--包扫描--> <context:component-scan base-package="com.cn"/><!--开启ioc注解--><context:annotation-config/><!--开启aop注解--><aop:aspectj-autoproxy/></beans>
Pointcut
定义切点，切点表达式(execution(权限访问符 返回值类型 方法所属的类名包路径.方法名(形参类型) 异常类型))
@Aspect@Component
public class AfterThrowingAspect {//全路径execution(public String com.cnblogs.hellxz.test.Test.access(String,String))@Pointcut("execution(* com.cnblogs.hellxz.test.*.*(..))")public void pointcut() {}.......
}
Before
前置增强，配合@Pointcut一起使用
@Aspect@Component
public class AfterThrowingAspect {//全路径execution(public String com.cnblogs.hellxz.test.Test.access(String,String))@Pointcut("execution(* com.cnblogs.hellxz.test.*.*(..))")public void pointcut() {}//前置增强@Before("pointcut()")public void before(JoinPoint jp){System.out.println("我是方法"+jp.getSignature().getName()+"的前置增强！"); }
}
AfterReturning
后置增强，配合@Pointcut一起使用
@Aspect
@Component
public class AfterThrowingAspect {//全路径execution(public String com.cnblogs.hellxz.test.Test.access(String,String))@Pointcut("execution(* com.cnblogs.hellxz.test.*.*(..))")public void pointcut() {}//前置增强@Before("pointcut()")public void before(JoinPoint jp){System.out.println("我是方法"+jp.getSignature().getName()+"的前置增强！"); }//后置增强@AfterReturning(value = "pointcut()",returning = "obj")public void afterReturning(JoinPoint jp,Object obj){System.out.println("我是方法"+jp.getSignature().getName()+"的后置增强！"+",返回值为"+obj);}
}
Around
环绕增强，配合@Pointcut一起使用
@Aspect
@Component
public class AfterThrowingAspect {//全路径execution(public String com.cnblogs.hellxz.test.Test.access(String,String))@Pointcut("execution(* com.cnblogs.hellxz.test.*.*(..))")public void pointcut() {}//前置增强@Before("pointcut()")public void before(JoinPoint jp){System.out.println("我是方法"+jp.getSignature().getName()+"的前置增强！"); }//后置增强@AfterReturning(value = "pointcut()",returning = "obj")public void afterReturning(JoinPoint jp,Object obj){System.out.println("我是方法"+jp.getSignature().getName()+"的后置增强！"+",返回值为"+obj);}//环绕增强@Around("pointcut()")public void around(ProceedingJoinPoint jp) throws Throwable {System.out.println("我是环绕增强中的前置增强！");Object proceed = jp.proceed();//植入目标方法System.out.println("我是环绕增强中的后置增强！");}
}
AfterThrowing
异常抛出增强，配合@Pointcut一起使用
@Aspect
@Component
public class AfterThrowingAspect {//全路径execution(public String com.cnblogs.hellxz.test.Test.access(String,String))@Pointcut("execution(* com.cnblogs.hellxz.test.*.*(..))")public void pointcut() {}//前置增强@Before("pointcut()")public void before(JoinPoint jp){System.out.println("我是方法"+jp.getSignature().getName()+"的前置增强！"); }//后置增强@AfterReturning(value = "pointcut()",returning = "obj")public void afterReturning(JoinPoint jp,Object obj){System.out.println("我是方法"+jp.getSignature().getName()+"的后置增强！"+",返回值为"+obj);}//环绕增强@Around("pointcut()")public void around(ProceedingJoinPoint jp) throws Throwable {System.out.println("我是环绕增强中的前置增强！");Object proceed = jp.proceed();//植入目标方法System.out.println("我是环绕增强中的后置增强！");}//异常抛出增强@AfterThrowing(value = "pointcut()",throwing = "e")public void error(JoinPoint jp,Exception e){System.out.println("我是异常抛出增强"+",异常为："+e.getMessage());}
}
After
最终增强(最后执行)，配合@Pointcut一起使用
@Aspect
@Component
public class AfterThrowingAspect {//全路径execution(public String com.cnblogs.hellxz.test.Test.access(String,String))@Pointcut("execution(* com.cnblogs.hellxz.test.*.*(..))")public void pointcut() {}//前置增强@Before("pointcut()")public void before(JoinPoint jp){System.out.println("我是方法"+jp.getSignature().getName()+"的前置增强！"); }//后置增强@AfterReturning(value = "pointcut()",returning = "obj")public void afterReturning(JoinPoint jp,Object obj){System.out.println("我是方法"+jp.getSignature().getName()+"的后置增强！"+",返回值为"+obj);}//环绕增强@Around("pointcut()")public void around(ProceedingJoinPoint jp) throws Throwable {System.out.println("我是环绕增强中的前置增强！");Object proceed = jp.proceed();//植入目标方法System.out.println("我是环绕增强中的后置增强！");}//异常抛出增强@AfterThrowing(value = "pointcut()",throwing = "e")public void error(JoinPoint jp,Exception e){System.out.println("我是异常抛出增强"+",异常为："+e.getMessage());}//最终增强@After("pointcut()")public void after(JoinPoint jp){System.out.println("我是最终增强");}
}
Cacheable（结合Redis搭建缓存机制）
用来标记缓存查询。可用用于方法或者类中
- 用来标记缓存查询。可用用于方法或者类中。- 当标记在一个方法上时表示该方法是支持缓存的，- 当标记在一个类上时则表示该类所有的方法都是支持缓存的。
参数列表
| 参数 | 解释 | 例子 |
|---|---|---|
| value | 名称 | @Cacheable(value={”c1”,”c2”} |
| key | key | @Cacheable(value=”c1”,key=”#id”) |
| condition | 条件 | @Cacheable(value=”c1”,condition=”#id=1”) |
比如@Cacheable(value=”UserCache”) 标识的是当调用了标记了这个注解的方法时，逻辑默认加上从缓存中获取结果的逻辑，如果缓存中没有数据，则执行用户编写查询逻辑，查询成功之后，同时将结果放入缓存中。
但凡说到缓存，都是key-value的形式的，因此key就是方法中的参数（id），value就是查询的结果，而命名空间UserCache是在spring*.xml中定义.
@Cacheable(value="UserCache")// 使用了一个缓存名叫 accountCache
public Account getUserAge(int id) { //这里不用写缓存的逻辑，直接按正常业务逻辑走即可，//缓存通过切面自动切入 int age=getUser(id); return age;
}
CacheEvict
用来标记要清空缓存的方法，当这个方法被调用后，即会清空缓存。@CacheEvict(value=”UserCache”)
参数列表
| 参数 | 解释 | 例子 |
|---|---|---|
| value | 名称 | @Cacheable(value={”c1”,”c2”} |
| key | key | @Cacheable(value=”c1”,key=”#id”) |
| condition | 缓存的条件，可以为空 | |
| allEntries | 是否清空所有缓存内容 | @CachEvict(value=”c1”，allEntries=true)) |
| beforeInvocation | 是否在方法执行前就清空 | @CachEvict(value=”c1”，beforeInvocation=true) |
Required（注释检查）
适用于bean属性setter方法，并表示受影响的bean属性必须在XML配置文件在配置时进行填充。否则，容器会抛出一个BeanInitializationException异常。
通俗的讲：该注解放在setter方法上，表示当前的setter修饰的属性必须在Spring.xml中进行装配，否则报错BeanInitializationException异常，所以这是个检查注解。
public class Student {private Integer age;private String name;public Integer getAge() {return age;}@Required //该注释放在的是set方法中，如果没有在xml配置文件中配置相关的属性，就会报错public void setAge(Integer age) {this.age = age;}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.0.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"><context:annotation-config/><!-- student bean的定义 --><bean id = "student" class="com.how2java.w3cschool.required.Student"><property name = "name" value="派大星"/><!-- 这里没有装配age属性，所以项目运行会报错 --></bean></beans>
报错：“ Property 'age' is required for bean 'student' ”
ModelAttribute
使用地方有三种：
标记在方法上，会在每一个@RequestMapping标注的方法前执行，如果有返回值，则自动将该返回值加入到ModelMap中。
A.在有返回的方法上:
当ModelAttribute设置了value，方法返回的值会以这个value为key，以参数接受到的值作为value，存入到Model中，如下面的方法执行之后，最终相当于 model.addAttribute(“user_name”, name);假如 @ModelAttribute没有自定义value，则相当于
model.addAttribute(“name”, name);
@ModelAttribute(value="user_name")
public String before2(@RequestParam(required = false) String name, Model model) {System.out.println("进入了2：" + name);return name;
}
B.标注在没有返回值的方法上，需要手动model.add方法
@ModelAttributepublic void before(@RequestParam(required = false) Integer age, Model model){model.addAttribute("age", age);System.out.println("进入了1：" + age);
}
C.标注在方法的参数上
会将客户端传递过来的参数按名称注入到指定对象中，并且会将这个对象自动加入ModelMap中，便于View层使用.
@RequestMapping(value="/mod2")public Resp mod2(@ModelAttribute("user_name") String user_name, @ModelAttribute("name") String name,@ModelAttribute("age") Integer age,Model model){System.out.println("进入mod2");System.out.println("user_name:"+user_name);System.out.println("name："+name);System.out.println("age:"+age);System.out.println("model:"+model);return Resp.success("1");}
Spring注解大全（示例详解）相关推荐
- JavaWeb-Spring中注解大全与详解
常用的spring注解有如下几种: @Controller @Service @Autowired @RequestMapping @RequestParam @ModelAttribute @Cac ...
- Spring注解之@GetMapping详解
params 参数详解 例如:@GetMapping(value = "/service", params = "serviceName=CREATE_PROJECT&q ...
- Spring注解之Service详解
目录 @[TOC](目录) Service注解 Service用法及示例 传统方式是怎么做的呢? @Service注解是怎么体现业务逻辑复用的? 总结 Service注解 @Service 注解是 S ...
- 一文总结Spring 注解及作用详解
文章目录 开启注解扫描配置 @RequestMapping 声明bean的注解 注入bean的注解 spring配置文件中读取properties配置文件 j配置类相关注解 切面(AOP)相关注解 @ ...
- Spring 集成与分片详解
1.Spring集成与分片详解 1.1pom依赖 1.2application.properties 定义配置类和任务类中要用到的参数 1.3创建任务 创建任务类,加上@Component注解 1.4 ...
- Spring EL表达式使用详解
Spring EL表达式使用详解 什么是Spring EL表达式 注入字面值 注入操作系统(OS)的属性 注入properties配置文件中数据 Bean属性调用 Bean方法调用 T运算符 构造器 ...
- php reactphp wss_workerman的基本用法（示例详解）
workerman是什么? Workerman是一个异步事件驱动的PHP框架,具有高性能,可轻松构建快速,可扩展的网络应用程序.支持HTTP,Websocket,SSL和其他自定义协议.支持libev ...
- Spring Cloud限流详解（附源码）
在高并发的应用中,限流往往是一个绕不开的话题.本文详细探讨在Spring Cloud中如何实现限流. 在 Zuul 上实现限流是个不错的选择,只需要编写一个过滤器就可以了,关键在于如何实现限流的算法. ...
- spring框架 AOP核心详解
AOP称为面向切面编程,在程序开发中主要用来解决一些系统层面上的问题,比如日志,事务,权限等待,Struts2的拦截器设计就是基于AOP的思想,是个比较经典的例子. 一 AOP的基本概念 (1)Asp ...
- 源代码下载 第六章 注解式控制器详解
2019独角兽企业重金招聘Python工程师标准>>> 源代码请到附件中下载. 其他下载: 跟着开涛学SpringMVC 第一章源代码下载 第二章 Spring MVC入门 源代码下 ...
最新文章
- BREW 计费模式概览
- 【POJ】3268 Silver Cow Party （将有向图的边反转）
- Selenium之定位浏览器弹窗方法汇总
- 关于onreadystatechange属性（转）
- 【HDU - 2546】饭卡 （dp，0-1背包，贪心思想）
- 咸阳高考成绩查询2021,2021咸阳市地区高考成绩排名查询,咸阳市高考各高中成绩喜报榜单...
- 全连接条件随机场_条件随机场CRF简介
- Android零基础入门第31节：几乎不用但要了解的AbsoluteLayout绝对布局
- POJ 1426 Find The Multiple BFS
- （转）C#中Split用法
- Python3.x：定义一个类并且调用
- 营销数字化转型行业实践
- 清华OS前置知识：80386处理器
- win7旗舰版恢复出厂设置没有修复计算机,教你win7旗舰版怎么恢复出厂设置
- 基于阿里云盘的文件分享系统
- 设计模式笔记--访问者模式
- 理解 Web 3 —— 用户控制的互联网
- WPS格式转换成html代码
- 套接字I/O模型-WSAEventSelect
- python删除空值的行_python如何删除列为空的行