Was sind die am häufigsten verwendeten Anmerkungen in springmvc?

Allgemeine SpringMVC-Anmerkungen

1. @Controller

@Controller wird verwendet, um eine Klasse zu markieren. Die damit markierte Klasse ist ein SpringMVC-Controller-Objekt. Der Dispatch-Prozessor scannt die Methode der annotierten Klasse und erkennt, ob die Methode mit @RequestMapping annotiert ist. @Controller definiert lediglich eine Controller-Klasse, und die mit @RequestMapping annotierte Methode ist der Prozessor, der die Anforderung tatsächlich verarbeitet.

Die @Controller-Markierung einer Klasse kann nicht wirklich sagen, dass es sich um eine Controller-Klasse von SpringMVC handelt, da Spring sie derzeit nicht erkennt. Zu diesem Zeitpunkt müssen wir diese Controller-Klasse zur Verwaltung an Spring übergeben. Es gibt zwei Möglichkeiten zur Verwaltung:

<!--方式一-->
<bean class="com.cqvie.handler.HelloWorld"/>
<!--方式二-->
< context:component-scan base-package = "com.cqvie" /> <!-- 路径写到controller的上一层 -->

Darüber hinaus ist der Controller nicht direkt von HttpServlet-Objekten wie HttpServletRequest und HttpServletResponse abhängig. Sie können flexibel über die Methodenparameter des Controllers abgerufen werden. Um einen ersten Eindruck vom Controller zu bekommen, definieren wir einen einfachen Controller:

package com.cqvie.handler;
import org.springframework.stereotype.Controller;
@Controller
public class HelloWorld {
    @RequestMapping("/helloworld")
    public String sayHello() {
        System.out.println("Hello World!");
        return "success";
    }
    
}

2 @RequestMapping

RequestMapping ist eine Annotation Wird zur Verarbeitung der Anforderungsadressenzuordnung verwendet und kann für Klassen oder Methoden verwendet werden. Bei einer Klasse bedeutet dies, dass alle Methoden in der Klasse, die auf Anfragen antworten, diese Adresse als übergeordneten Pfad verwenden.

Der Rückgabewert wird durch den Ansichtsparser in die tatsächliche physische Ansicht geparst. Für den InternalResourceViewResolver-Ansichtsparser wird die folgende Analyse durchgeführt:

Der tatsächliche Wert wird durch Präfix + returnVal erhalten + Suffix. Physische Ansicht und dann Weiterleitungsvorgang durchführen;

<!-- 配置视图解析器：如何把 handler 方法返回值解析为实际的物理视图 -->
     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <property name="prefix" value="/WEB-INF/views/"></property>
         <property name="suffix" value=".jsp"></property>
     </bean>

RequestMapping-Annotation hat sechs Attribute:

1), Wert

Wert: gibt die tatsächliche Adresse der Anfrage an ;

2), Methode

Methode: Geben Sie den Methodentyp der Anfrage an, GET, POST, PUT, DELETE usw., erklärt im folgenden Beispiel von @PathVariable:

/**
     * Rest 风格的 URL（以 CRUD 为例）：
     *         新增：/order POST
     *         修改：/order/1 PUT
     *         获取：/order/1 GET
     *         删除：/order/1 DELETE
     * @param id
     * @return
     */
    @RequestMapping(value = "/testRestPut/{id}", method = RequestMethod.PUT)
    public String testRestPut(@PathVariable int id) {
        System.out.println("testRestPut:" + id);
        return SUCCESS;
    }
    
    @RequestMapping(value = "/testRestDelete/{id}", method = RequestMethod.DELETE)
    public String testRestDelete(@PathVariable int id) {
        System.out.println("testRestDelete:" + id);
        return SUCCESS;
    }
    
    @RequestMapping(value = "/testRestPost/{id}", method = RequestMethod.POST)
    public String testRestPost(@PathVariable int id) {
        System.out.println("testRestPost:" + id);
        return SUCCESS;
    }
    
    @RequestMapping("/testRestGet")
    public String testRestGet() {
        System.out.println("testRestGet");
        return SUCCESS;
    }

3), verbraucht

verbraucht: Geben Sie den Übermittlungsinhaltstyp (Content-Type) für die Verarbeitung von Anforderungen an, z. B. application/json, text/html;

4), produziert

produziert: Gibt den zurückzugebenden Inhaltstyp an. Er wird nur zurückgegeben, wenn der (Accept)-Typ im Anforderungsheader den angegebenen Typ enthält; 🎜>5), params

params: Die angegebene Anfrage muss bestimmte Parameterwerte enthalten, bevor die Methode sie verarbeiten kann.

6), Header

Header: Die angegebene Anfrage muss bestimmte angegebene Headerwerte enthalten, damit diese Methode die Anfrage verarbeiten kann.

@RequestMapping("/helloword/?/aa") Ant-Pfad, passendes Zeichen:

●?: Entspricht einem Zeichen des Dateinamens

● *: Übereinstimmung mit allen Zeichen des Dateinamens

● **: Übereinstimmung mit mehrschichtigen Pfaden

@RequestMapping("/testPojo") POJO-Klassenverwendung:

@RequestMapping("/testPojo")
    public String testPojo(User user) {
        System.out.println("testPojo:" + user);
        return "success";
    }
　　@RequestMapping("/testPojo") Map用法：
　　@RequestMapping("/testMap")
    public String testMap(Map<String, Object> map) {
        map.put("names", Arrays.asList("Tomcat", "Eclipse", "JavaEE"));
        return "success";
    }
　　@RequestMapping("/testPojo") ModelAndView用法：
　　@RequestMapping("/testModelAndView")
    public ModelAndView testModelAndView() {
        String viewName = SUCCESS;
        ModelAndView modelAndView = new ModelAndView(viewName);
        modelAndView.addObject("time", new Date());
        return modelAndView;
    }

3. @Resource und @Autowired

@Resource und @Autowired werden beide für die Bean-Injection verwendet. Tatsächlich ist @Resource keine Annotation von Spring . Das Paket heißt javax.annotation.Resource und muss importiert werden, aber Spring unterstützt die Injektion dieser Annotation.

1), Gemeinsamkeiten

Beide können auf Felder und Setter-Methoden geschrieben werden. Wenn beide in die Felder geschrieben werden, besteht keine Notwendigkeit, Setter-Methoden zu schreiben.

2) Unterschiede

(1) @Autowired

@Autowired ist eine von Spring bereitgestellte Annotation und muss das Paket org.springframework.beans.factory importieren .annotation.Autowired; nur nach byType eingefügt.

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

Die Annotation @Autowired setzt abhängige Objekte nach Typ (byType) zusammen. Standardmäßig muss das abhängige Objekt vorhanden sein. Wenn Nullwerte zulässig sind, kann sein erforderliches Attribut auf false gesetzt werden. Wenn wir nach Namen (byName) assemblieren möchten, können wir ihn in Verbindung mit der Annotation @Qualifier verwenden. Wie folgt:

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

(2) @Resource

@Resource wird standardmäßig automatisch von ByName injiziert, von J2EE bereitgestellt und muss das Paket javax.annotation.Resource importieren. @Resource verfügt über zwei wichtige Attribute: Name und Typ. Spring löst das Namensattribut der @Resource-Annotation in den Namen der Bean auf, und das Typattribut löst sich in den Typ der Bean auf. Wenn daher das Namensattribut verwendet wird, wird die automatische Injektionsstrategie byName verwendet, und wenn das Typattribut verwendet wird, wird die automatische Injektionsstrategie byType verwendet. Wenn weder der Name noch das Typattribut angegeben sind, wird die automatische Injektionsstrategie byName über den Reflexionsmechanismus verwendet.

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

Hinweis: Es ist am besten, @Resource auf die Setter-Methode zu setzen, da dies eher dem objektorientierten Denken entspricht und Attribute über Set und Get verwaltet, anstatt Attribute direkt zu bearbeiten.

4. @PathVariable

wird verwendet, um die Vorlagenvariablen in der Anforderungs-URL den Parametern der Funktionsverarbeitungsmethode zuzuordnen , nehmen Sie die URI-Vorlagenvariablen als Parameter heraus. Zum Beispiel:

@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, @CookieValue

Funktion: wird verwendet, um den Wert im Parameter Cookie

abzurufen: value: Parametername erforderlich: Ob erforderlich. defaultValue: Standardwert

Anwendungsfall:

/**
     * 获取 Session
     * JSESSIONID=411A032E02A2594698F6E3F4458B9CE4
     */
    @RequestMapping("/testCookieValue")
    public String testCookieValue(@CookieValue("JSESSIONID") String sessionId) {
        System.out.println("JSESSIONID = " + sessionId);
        return "success";
    }

6、@RequestParam

@RequestParam用于将请求参数区数据映射到功能处理方法的参数上，用例：

/**
     * @RequestParam("id") 带参映射
     * @param id
     * @return
     */
    @RequestMapping("/testRequestParam")
    public String testRequestParam(@RequestParam("id") int id) {
        System.out.println("testRequestParam  " + id);
        return "success";
    }

7、@SessionAttributes

@SessionAttributes即将值放到session作用域中，写在class上面。　　

@SessionAttributes 除了可以通过属性名指定需要放到会话中的属性外（value 属性值），

还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中（types 属性值）,用例：

package com.cqvie.yjq;
import java.util.Map;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttributes;
import com.cqvie.model.User;
@SessionAttributes(value = {"user"}, types = {String.class})
@RequestMapping("/springmvc")
@Controller
public class SessionAttributesTest {
    
    /**
     * @SessionAttributes
     *         除了可以通过属性名指定需要放到会话中的属性外（value 属性值），
     *         还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中（types 属性值）。
     * 注意： 该注解只能放在类的上面，不能放在方法上面
     * 
     * @return
     */
    @RequestMapping("/testSessionAttributes")
    public String testSessionAttributes(Map<String, Object> map) {
        User user = new User(1, "刘邦", "qwe", "123", "辽宁");
        map.put("user", user);
        map.put("school", "重庆");
        return "success";
    }
}

8、@ModelAttribute

代表的是：该Controller的所有方法在调用前，先执行此@ModelAttribute方法，可用于注解和方法参数中，可以把这个@ModelAttribute特性，应用在BaseController当中，所有的Controller继承BaseController，即可实现在调用Controller时，先执行@ModelAttribute方法。

package com.cqvie.yjq;
import java.util.Map;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.cqvie.model.User;
@Controller
@RequestMapping("/springmvc")
public class ModelAttributeTest {
    private static final String SUCCESS = "success";
    
    /**
     * 1.有 @ModelAttribute 标记的方法，会在每个目标方法执行之前被 SpringMVC 调用
     * 2.@ModelAttribute注解也可以修饰目标方法POJO类形的入参，其value的属性值有如下作用：
     *     1）SpringMVC会使用value属性值在implicitModel中查找对应的对象，若存在则直接传入到目标方法的入参中
     *     2）SpringMVC会以value为key,POJO类型的对象为value，存入的request中
     * 
     * @param id
     * @param map
     */
    @ModelAttribute
    public void getUser(@RequestParam(value = "id", required = false) int id,
            Map<String, Object> map) {
        //模拟数据库中获取对象
        User user = new User(1, "刘邦", "123", "023", "重庆");
        System.out.println("从数据库中获取一个对象：" + user);
        map.put("abc", user);
    }
    
    /**
     * 运行流程：
     *         1.执行@ModelAttribute注解修饰的方法，从数据库中取出对象，把对象放入Map中，键为：user；
     *         2.SpringMVC从Map中取出User对象，并把表单的请求参数赋值给该User对象的对应属性；
     *         3.SpringMVC把上述对象传入目标方法的参数。
     * 
     * 注意：在@ModelAttribute修饰的方法中，放入到Map时的键需要和目标方法入参类型的第一个字母小写的字符串一致
     * 
     * @param user
     * @return
     */
    @RequestMapping("/testModelAttribute")
    public String testModelAttribute(@ModelAttribute("abc") User user) {
        System.out.println("修改：" + user);
        return SUCCESS;
    }
}

9、@ResponseBody　

作用： 该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。

使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；

本文来自php中文网，java教程栏目，欢迎学习！

Das obige ist der detaillierte Inhalt vonWas sind die am häufigsten verwendeten Anmerkungen in springmvc?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!