Detaillierte Einführung in die SpringMVC-Grundkonfiguration

Dieser Artikel bietet Ihnen eine detaillierte Einführung in die Grundkonfiguration von SpringMVC. Ich hoffe, dass er für Freunde hilfreich ist.

Heute werden wir über die Grundkonfiguration von SpringMVC sprechen. Derzeit unterstützen immer mehr Mainstream-Frameworks Annotationen, und unser unbesiegbarer Spring unterstützt auch eine „Nullkonfiguration“ basierend auf Annotationen.

Vorteile von Annotationen im Vergleich zu XML: Es kann den Reflexionsmechanismus von Java vollständig nutzen, um Strukturinformationen in einer Klasse zu erhalten. Diese Informationen können den Konfigurationsaufwand effektiv reduzieren bequemer für die Wartung.

Hinweis: Anmerkungen können erst nach der Spring 2.5-Version verwendet werden.

Die Annotationsmethode kombiniert die Definitionsinformationen der Bean und die Implementierungsklasse der Bean. Die von Spring bereitgestellten Annotationen sind:

@Component: Deklarieren Sie eine gemeinsame Bean-Klasse

@Repository: Deklarieren Sie eine Persistenzschicht-Dao-Klasse

@Service: Deklarieren Sie eine Business-Schicht-Klasse

@Controller: Deklarieren Sie eine Controller-Klasse

Ich glaube, Sie sind mit diesen vier Anmerkungen bereits sehr vertraut, es besteht also kein Grund, Unsinn zu reden. Wenn wir Anmerkungen verwenden, vergessen Sie nicht, diese im Unterricht zu scannen! ! !

@RequestMapping (eine sehr wichtige Annotation). Diese Annotation wird verwendet, um die Anforderungs-URL des Controllers anzugeben.

Klassendefinition im Controller: Stellen Sie vorläufige Zuordnungsinformationen bereit und fügen Sie allen Anforderungsmethoden unter der Klasse ein Präfix hinzu.

Methodendefinition in der Controller-Klasse: Geben Sie weitere Zuordnungsinformationen und den Anforderungspfad der Methode an

Bestätigen Sie, nachdem DispacherServlet die Anforderung abgefangen hat die der Anforderung entsprechende Verarbeitungsmethode anhand der von @RequestMapping auf dem Controller bereitgestellten Zuordnungsinformationen.

@Controller
@RequestMapping("user")
public class UserController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }
}

Zu diesem Zeitpunkt ist der von uns angeforderte Pfad http://localhost:8080/SpringMvcDemo2/user/hello

@RequestMapping Zusätzlich zu Zuordnungsanfrage-URL-Anfragen können Sie dies tun Verwenden Sie auch Anforderungsmethoden. Für Anforderungsparameter und Anforderungsheader gibt es mehrere Parameter in der Annotation:

1) Wert: Gibt die URL der Anforderung an

2) Methode: Gibt die Anforderungsmethode an (GET/POST)

3) params: Stellt die Parameter der Anforderung dar

4) header: Anforderungsheader

Die Beziehung zwischen ihnen ist und Durch mehrere Anfragen kann die Anfrage genauer werden.

@RequestMapping(value="hello2",method=RequestMethod.POST,params={"username","userpass"},headers="contentType=text/*") 
   public String hello2(){
           return "hello";
    }

Dieser Code gibt an, dass die angeforderte Adresse „Hallo“ ist. Die Anforderungsmethode ist „Post“ und muss zwei Parameter haben: Benutzername und Benutzerpass. Der Anforderungsheader „ContentType“ muss mit „text/“ beginnen. Wir können zwei URLs mit derselben Methode schreiben, eine POST und die andere GET, die streng nach den Einstellungen aufgerufen werden.

@RequestMapping unterstützt auch URLs im Ant-Stil und unterstützt 3 Platzhalter in Ant .

? : Zeigt die Konfiguration eines Zeichens an.

*: Übereinstimmung mit jedem Zeichen

**: Übereinstimmung mit mehrschichtigen Pfaden

Parameterverarbeitung in SpringMVC:

@pathVariable: URL-Vorlagenmethode

Wird zum Zuordnen von Platzhaltern in URLs verwendet. Die zugeordneten Variablennamen müssen mit den Namen in den Platzhaltern übereinstimmen, wie bei uns. Die Anforderungsadresse lautet http: //localhost:8080/SpringMvcDemo2/user/testPathVariable/Miya ist der Parameter, den wir in der traditionellen URL testPathVariable? username=miya, aber dies ist der Aufnahme von Baidu nicht förderlich.

@RequestMapping("/testPathVariable/{username}")
    public String hello3(@PathVariable("username")String username){
        System.out.println("username :  " + username);        
        return "hello";
    }

@RequestParam: Rufen Sie die Anforderungsparameter ab. Wenn der Name des Anforderungsparameters mit dem Namen des Typs übereinstimmt, können wir diese Annotation weglassen und der Wert kann trotzdem empfangen werden .

@RequestMapping("/textParam")
    public String hello4(@RequestParam("username")String username,@RequestParam("userpass")String userpass){
        System.out.println("userpass :  " + userpass);        
        return "hello";
    }

@RequestHeader: Rufen Sie die Parameter des Anforderungsheaders ab

Hier gibt es drei Parameter, Wert: der Name des angegebenen Parameters, Erforderlich: Der angegebene Parameter Ob erforderlich, defaultValue: Gibt den Standardwert des Parameters an.

@RequestMapping("/testRequestHeader")
    public String hello5(@RequestHeader("Accept-Language") String language){
        System.out.println("language=" + language);       
        return "hello";
    }

@CookieValue: Wird verwendet, um Client-Cookie-Informationen zu erhalten.

@RequestMapping("/testCookieValue")    
public String hello6(@CookieValue("JSESSIONID")String sessionid){
        System.out.println("sessionid=" + sessionid);        
        return "hello";
    }

SpringMVC kann ServletAPI als Parameter der Anforderungsmethode verwenden

@RequestMapping("/testServletAPI")    
public String hello7(HttpServletRequest request,HttpServletResponse response,HttpSession session){        
//我们可以在这里使用
        return "hello";
    }

SpringMVC bietet die folgenden Möglichkeiten zur Verarbeitung von Modelldaten.

1) ModelAndView: Legen Sie den Rückgabetyp der Verarbeitungsmethode auf den ModelAndView-Methodenkörper fest, um Modelldaten über das Modellobjekt hinzuzufügen. Enthält sowohl Ansichten als auch Modellinformationen

@RequestMapping("/testModelAndView")
    public ModelAndView hello8(){
        ModelAndView modelAndView = new ModelAndView("hello");
        //添加单个值
        modelAndView.addObject("h","Hello Spring MVC");        
        return modelAndView;
    }

2) Karte und formale Parameter: Wenn die formalen Parameter Map, Model und ModelMap sind und die Verarbeitungsmethode zurückkehrt, Die Daten in der Karte werden automatisch zum Modell hinzugefügt.

Spring MVC verwendet intern eine Modellschnittstelle zum Speichern von Daten und erstellt ein implizites Modellobjekt, das als Speichercontainer dient für das Datenmodell. Wenn die übergebenen Parameter Map, Model, ModelMap sind, speichert SpringMVC sie automatisch im Container

@RequestMapping("/testMap")    
public String hello9(Map<String,Object> map){
        map.put("mapdata", "map data");       
        return "hello";
    }

3）@SessionAttributes：将这个模型中的某个属性存储到Session中，以便多个请求之间共享这个属性，只能用来修饰类。在里面的方法如果参数容器中如map里卖弄保存一个与定义的属性名字相同会保存到容器中共享

4）@ModelAttribute：方法形参标记该注解后，形参对象就会放到模型中。

　　SpringMVC在调用方法之前会逐个调用方法上标注了这个注解的方法。将@ModelAttribute中的属性保存到map中，可在执行表单提交生成对象之前，替换执行方法名相同的参数。

@ModelAttribute
public User getUser(){
    User user = new User();
    System.out.println("调用 getUser 方法");
    //默认保存名字为类名首字母小写的user对象到Request中
    return user;
}
@ModelAttribute
public void getUserById(Integer id,Map<String,Object> map){
    User myuser = new User();
    map.put("myuser", myuser);
    //手动指定user对象的名称，到Request中
    System.out.println("调用 getUser 方法");
}

由@SessionAttributs会引发一个很容易轻视的错误当类使用@SessionAttributes修饰，而方法中使用了和SessionAttributes修饰同名的映射参数，确没有添加@ModelAttribute修饰时，则会报错。

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in die SpringMVC-Grundkonfiguration. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!