客观面试题--37.Spring/SpringMVC常用注解有哪些？

朴灿烈づ我的快乐病毒、 2022-05-19 01:04 172阅读 0赞

### ***Spring常用注解：*** ###

## 使用注解来构造IoC容器 ##

**用注解来向****Spring****容器注册****Bean****。需要在****applicationContext.xml****中注册****<context:component-scan base-package=”pagkage1\[,pagkage2,…,pagkageN\]”/>**。

如：在base-package指明一个包

1 <context:component-scan base-package="cn.gacl.java"/>

表明**cn.gacl.java**包及其子包中，如果某个类的头上带有特定的注解【@Component/@Repository/@Service/@Controller】，就会将这个对象作为Bean注册进Spring容器。也可以在<context:component-scan base-package=” ”/>中指定多个包，如：

1 <context:component-scan base-package="cn.gacl.dao.impl,cn.gacl.service.impl,cn.gacl.action"/>

多个包逗号隔开。

## 1、@Component ##

@Component  
是所有受Spring 管理组件的通用形式，@Component注解可以放在类的头上，@Component不推荐使用。

## 2、@Controller ##

@Controller对应表现层的Bean，也就是Action，例如：

>     1 @Controller
>     2 @Scope("prototype")
>     3 public class UserAction extends BaseAction<User>{
>     4 ……
>     5 }

**使用****@Controller****注解标识****UserAction****之后，就表示要把****UserAction****交给****Spring****容器管理，****在****Spring****容器中会存在一个名字为****"userAction"****的****action****，这个名字是根据****UserAction****类名来取的。****注意：如果**@Controller**不指定其**value【@Controller】，**则默认的****bean****名字为这个类的类名首字母小写****，****如果指定**value【@Controller(value="UserAction")】**或者**【@Controller("UserAction")】，**则使用****value****作为****bean****的名字**。

这里的UserAction还使用了@Scope注解，@Scope("prototype")表示将Action的范围声明为原型，**可以利用容器的****scope="prototype"****来保证每一个请求有一个单独的****Action****来处理，避免****struts****中****Action****的线程安全问题。****spring ****默认****scope ****是单例模式****(scope="singleton")****，这样只会创建一个****Action****对象，每次访问都是同一****Action****对象，数据不安全，****struts2 ****是要求****每次次访问****都对应不同的****Action****，****scope="prototype" ****可以保证****当有请求的时候****都创建一个****Action****对象**

## 3、@ Service ##

@Service对应的是业务层Bean，例如：

>     1 @Service("userService")
>     2 public class UserServiceImpl implements UserService {
>     3 ………
>     4 }

@Service("userService")注解是告诉Spring，当Spring要创建UserServiceImpl的的实例时，bean的名字必须叫做"userService"，这样当Action需要使用UserServiceImpl的的实例时,就可以由Spring创建好的"userService"，然后注入给Action：在Action只需要声明一个名字叫“userService”的变量来接收由Spring注入的"userService"即可，具体代码如下：

>     1 // 注入userService
>     2 @Resource(name = "userService")
>     3 private UserService userService;

注意：在Action声明的“userService”变量的类型必须是“UserServiceImpl”或者是其父类“UserService”，否则由于类型不一致而无法注入，由于Action中的声明的“userService”变量使用了@Resource注解去标注，并且指明了其name = "userService"，这就等于告诉Spring，说我Action要实例化一个“userService”，你Spring快点帮我实例化好，然后给我，当Spring看到userService变量上的@Resource的注解时，根据其指明的name属性可以知道，Action中需要用到一个UserServiceImpl的实例，此时Spring就会把自己创建好的名字叫做"userService"的UserServiceImpl的实例注入给Action中的“userService”变量，帮助Action完成userService的实例化，这样在Action中就不用通过“UserService userService = new UserServiceImpl();”这种最原始的方式去实例化userService了。如果没有Spring，那么当Action需要使用UserServiceImpl时，必须通过“UserService userService = new UserServiceImpl();”主动去创建实例对象，但使用了Spring之后，Action要使用UserServiceImpl时，就不用主动去创建UserServiceImpl的实例了，创建UserServiceImpl实例已经交给Spring来做了，Spring把创建好的UserServiceImpl实例给Action，Action拿到就可以直接用了。Action由原来的主动创建UserServiceImpl实例后就可以马上使用，变成了被动等待由Spring创建好UserServiceImpl实例之后再注入给Action，Action才能够使用。这说明Action对“UserServiceImpl”类的“控制权”已经被“反转”了，原来主动权在自己手上，自己要使用“UserServiceImpl”类的实例，自己主动去new一个出来马上就可以使用了，但现在自己不能主动去new“UserServiceImpl”类的实例，new“UserServiceImpl”类的实例的权力已经被Spring拿走了，只有Spring才能够new“UserServiceImpl”类的实例，而Action只能等Spring创建好“UserServiceImpl”类的实例后，再“恳求”Spring把创建好的“UserServiceImpl”类的实例给他，这样他才能够使用“UserServiceImpl”，这就是Spring核心思想“**控制反转**”，也叫“**依赖注入**”，“依赖注入”也很好理解，Action需要使用UserServiceImpl干活，那么就是对UserServiceImpl产生了依赖，Spring把Acion需要依赖的UserServiceImpl注入(也就是“给”)给Action，这就是所谓的“依赖注入”。对Action而言，Action依赖什么东西，就请求Spring注入给他，对Spring而言，Action需要什么，Spring就主动注入给他。

## 4、@ Repository ##

@Repository对应数据访问层Bean ，例如：

>     1 @Repository(value="userDao")
>     2 public class UserDaoImpl extends BaseDaoImpl<User> {
>     3 ………
>     4 }

@Repository(value="userDao")注解是告诉Spring，让Spring创建一个名字叫“userDao”的UserDaoImpl实例。

当Service需要使用Spring创建的名字叫“userDao”的UserDaoImpl实例时，就可以使用@Resource(name = "userDao")注解告诉Spring，Spring把创建好的userDao注入给Service即可。

>     1 // 注入userDao，从数据库中根据用户Id取出指定用户时需要用到
>     2 @Resource(name = "userDao")
>     3 private BaseDao<User> userDao;

### ***SpringMVC常用注解*** ###

**1.@Controller**  
@Controller用于标记在一个类上，使用它标记的类就是一个SpringMVCController对象。分发处理器将会扫描使用了该注解的类的 方法，并检测该方法是否使用了@RequestMapping 注解。@Controller只是定义了一个控制器类，而使用@RequestMapping注解的方法才是真正处理请求的处理器。单单使用 @Controller标记在一个类上还不能真正意义上的说它就是SpringMVC的一个控制器类，因为这个时候Spring还不认识它。那么要如何做 Spring才能认识它呢？这个时候就需要我们把这个控制器类交给Spring来管理。有两种方式：  
　　（1）在SpringMVC 的配置文件中定义MyController 的bean 对象。  
　　（2）在SpringMVC 的配置文件中告诉Spring 该到哪里去找标记为@Controller 的Controller 控制器。

>   
>   
> <bean class="com.host.app.web.controller.MyController"/>  
>   
> < context:component-scan base-package = "com.host.app.web" />

**2、@RequestMapping**  
RequestMapping注解有六个属性，下面我们把它分成三类进行说明  
**(1)value，method**  
value：指定请求的实际地址，指定的地址可以是URI Template模式；  
method：指定请求的method类型， GET、POST、PUT、DELETE等；  
value的uri值可以为以下三类：普通的具体值；含有某变量的一类值；含有正则表达式的一类值；

>     @RequestMapping(value="/new", method = RequestMethod.GET)
>     public AppointmentForm getNewForm() {
>         return new AppointmentForm();
>     }
>     @RequestMapping(value="/owners/{ownerId}", method={RequestMethod.GET , RequestMethod.DELETE })
>     public String findOwner(@PathVariable String ownerId, Model model) {
>       Owner owner = ownerService.findOwner(ownerId);  
>       model.addAttribute("owner", owner);  
>       return "displayOwner";
>     }
>     @RequestMapping("/spring-web/{symbolicName:[a-z-]+}-{version:\d\.\d\.\d}.{extension:\.[a-z]}")
>       public void handle(@PathVariable String version, @PathVariable String extension) {    
>         // ...
>       }
>     }

**(2)consumes，produces**  
consumes：指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;  
produces:指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；

>     @Controller
>     @RequestMapping(value = "/pets", method = RequestMethod.POST, consumes="application/json")
>     public void addPet(@RequestBody Pet pet, Model model) {    
>         // implementation omitted
>     }
>     @Controller
>     @RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, produces="application/json")
>     @ResponseBody
>     public Pet getPet(@PathVariable String petId, Model model) {    
>         // implementation omitted
>     }

**(3)params，headers**  
params：指定request中必须包含某些参数值时，才让该方法处理。  
headers：指定request中必须包含某些指定的header值，才能让该方法处理请求。

>     @RequestMapping (value= "testParams" , params={ "param1=value1" , "param2" , "!param3" })
>         public String testParams() {
>            System. out .println( "test Params..........." );
>            return "testParams" ;
>         }

用@RequestMapping的params属性指定了三个参数，这些参数都是针对请求参数而言的，它们分别表示参数param1的值必须等于 value1，参数param2必须存在，值无所谓，参数param3必须不存在，只有当请求/testParams.do并且满足指定的三个参数条件的 时候才能访问到该方法。所以当请求/testParams.do?param1=value1&param2=value2的时候能够正确访问到 该testParams方法，当请求/testParams.do?param1=value1&param2=value2& param3=value3的时候就不能够正常的访问到该方法

>     @Controller
>     @RequestMapping("/owners/{ownerId}")
>     public class RelativePathUriTemplateController {
>     
>     @RequestMapping(value = "/pets", method = RequestMethod.GET, headers="Referer=http://www.ifeng.com/")
>       public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {    
>         // implementation omitted
>       }
>     }

仅处理request的header中包含了指定“Refer”请求头和对应值为“http://www.ifeng.com/”的请求；

**3.@Resource和@Autowired**  
@Resource和@Autowired都是做bean的注入时使用，其实@Resource并不是Spring的注解，它的包是javax.annotation.Resource，需要导入，但是Spring支持该注解的注入。  
(1)共同点  
两者都可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法。  
(2)不同点  
**@Autowired**  
@Autowired为Spring提供的注解，需要导入包org.springframework.beans.factory.annotation.Autowired;只按照byType注入。

>     public class TestServiceImpl {
>         // 下面两种@Autowired只要使用一种即可
>         @Autowired
>         private UserDao userDao; // 用于字段上
>         
>         @Autowired
>         public void setUserDao(UserDao userDao) { // 用于属性的方法上
>             this.userDao = userDao;
>         }
>     }

@Autowired注解是按照类型（byType）装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它的 required属性为false。如果我们想使用按照名称（byName）来装配，可以结合@Qualifier注解一起使用。如下：

>     public class TestServiceImpl {
>         @Autowired
>         @Qualifier("userDao")
>         private UserDao userDao;
>     }

**@Resource**  
@Resource默认按照ByName自动注入，由J2EE提供，需要导入包javax.annotation.Resource。@Resource 有两个重要的属性：name和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的 类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不制定name也不 制定type属性，这时将通过反射机制使用byName自动注入策略。

>     public class TestServiceImpl {
>         // 下面两种@Resource只要使用一种即可
>         @Resource(name="userDao")
>         private UserDao userDao; // 用于字段上
>         
>         @Resource(name="userDao")
>         public void setUserDao(UserDao userDao) { // 用于属性的setter方法上
>             this.userDao = userDao;
>         }
>     }

注：最好是将@Resource放在setter方法上，因为这样更符合面向对象的思想，通过set、get去操作属性，而不是直接去操作属性。

**4.@PathVariable**  
用于将请求URL中的模板变量映射到功能处理方法的参数上，即取出uri模板中的变量作为参数。

>     @Controller  
>     public class TestController {  
>          @RequestMapping(value="/user/{userId}/roles/{roleId}",method = RequestMethod.GET)  
>          public String getLogin(@PathVariable("userId") String userId,  
>              @PathVariable("roleId") String roleId){  
>              System.out.println("User Id : " + userId);  
>              System.out.println("Role Id : " + roleId);  
>              return "hello";  
>          }  
>          @RequestMapping(value="/product/{productId}",method = RequestMethod.GET)  
>          public String getProduct(@PathVariable("productId") String productId){  
>                System.out.println("Product Id : " + productId);  
>                return "hello";  
>          }  
>          @RequestMapping(value="/javabeat/{regexp1:[a-z-]+}",  
>                method = RequestMethod.GET)  
>          public String getRegExp(@PathVariable("regexp1") String regexp1){  
>                System.out.println("URI Part 1 : " + regexp1);  
>                return "hello";  
>          }  
>     }

**5.@ResponseBody**  
作用： 该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。  
使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用

>     @Controller
>     @RequestMapping ( "/test/{variable1}" )
>     public class MyController {
>     
>         @RequestMapping ( "/showView/{variable2}" )
>         public ModelAndView showView( @PathVariable String variable1, @PathVariable ( "variable2" ) int variable2) {
>            ModelAndView modelAndView = new ModelAndView();
>            modelAndView.setViewName( "viewName" );
>            modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );
>            return modelAndView;
>         }
>     }

在上面的代码中我们可以看到在标记variable1 为path 变量的时候我们使用的是@PathVariable ，而在标记variable2 的时候使用的是@PathVariable(“variable2”) 。这两者有什么区别呢？第一种情况就默认去URI 模板中找跟参数名相同的变量，但是这种情况只有在使用debug 模式进行编译的时候才可以，而第二种情况是明确规定使用的就是URI 模板中的variable2 变量。当不是使用debug 模式进行编译，或者是所需要使用的变量名跟参数名不相同的时候，就要使用第二种方式明确指出使用的是URI 模板中的哪个变量。

**6.@RestController**  
我们经常见到一些控制器实现了REST的API，只为服务于JSON，XML或其它自定义的类型内 容，@RestController用来创建REST类型的控制器，与@Controller类型。@RestController就是这样一种类型，它 避免了你重复的写@RequestMapping与@ResponseBody。

>     @RestController
>     public class FavRestfulController {
>     
>         @RequestMapping(value="/getUserName",method=RequestMethod.POST)
>         public String getUserName(@RequestParam(value="name") String name){
>             return name;
>         }
>     }