Résumé des annotations et introduction simple de l'application au printemps-javaDidacticiel-php.cn

Cet article vous apporte un résumé des annotations et une simple introduction à l'application au printemps. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

1. @Controller

identifie une classe en tant que processeur de contrôleur Spring MVC, qui est utilisé pour créer des objets qui gèrent les requêtes http.

1@Controller
2public class TestController {
3        @RequestMapping("/test")
4        public String test(Map<String,Object> map){
5
6            return "hello";
7        }
8}

Copier après la connexion

2. . @RestController

Une annotation ajoutée après Spring 4. Il s'avère que le retour de json dans @Controller nécessite la coopération de @ResponseBody Si vous utilisez directement @RestController pour remplacer @Controller, vous n'avez pas besoin de configurer @. ResponseBody. Par défaut, le format json est renvoyé.

1@RestController
2public class TestController {
3        @RequestMapping("/test")
4        public String test(Map<String,Object> map){
5
6            return "hello";
7        }
8}

Copier après la connexion

3. @Service

est utilisé pour annoter les composants de la couche métier pour parler franchement, cela signifie ajouter que vous disposez d'une annotation pour injecter cette classe dans la configuration Spring

4. @Autowired

est utilisé pour assembler des beans et peut être écrit sur des champs ou des méthodes.

Par défaut, l'objet dépendant doit exister. Si vous souhaitez autoriser les valeurs nulles, vous pouvez définir son attribut obligatoire sur false, par exemple : @Autowired(required=false)

@RequestMapping<.>

Définition de classe : Fournit des informations préliminaires de mappage de requête, relatives au répertoire racine de l'application WEB.

Méthode : fournit des informations supplémentaires sur le mappage de subdivision, par rapport à l'URL lors de la définition de la classe.

Les étudiants qui ont utilisé RequestMapping savent qu'il a de nombreuses fonctions, donc l'utilisation détaillée

J'en parlerai dans le prochain article Merci de suivre le compte officiel pour ne pas le manquer.

6. @RequestParam

est utilisé pour mapper les données de la zone de paramètres de la requête aux paramètres de la méthode de traitement de la fonction

Par exemple,

Cet identifiant doit être reçu de La valeur du paramètre id transmis par l'interface. Si le nom du paramètre transmis par l'interface est incohérent avec ce que vous recevez, il peut également être comme suit

1public Resp test(@RequestParam Integer id){
2        return Resp.success(customerInfoService.fetch(id));
3    }

Copier après la connexion

où course_id est le paramètre passé par l'interface, et id est le nom du paramètre mappant course_id

1public Resp test(@RequestParam(value="course_id") Integer id){
2        return Resp.success(customerInfoService.fetch(id));
3    }

Copier après la connexion

7 Il existe trois façons d'utiliser @ModelAttribute

:

1. .

est marqué sur la méthode et sera exécuté avant chaque méthode marquée avec @RequestMapping. S'il y a une valeur de retour, la valeur de retour sera automatiquement ajoutée au ModelMap.

A. Sur les méthodes qui renvoient :

Lorsque ModelAttribute est défini sur value, la valeur renvoyée par la méthode utilisera cette valeur comme clé, et utilisera la valeur reçue par le paramètre comme valeur, et stockez-le dans le modèle. Une fois la méthode suivante exécutée, cela équivaut finalement à model.addAttribute("user_name", name); Si @ModelAttribute n'a pas de valeur personnalisée, cela équivaut à

model.addAttribute("name", name);

B. Sur la méthode :

1@ModelAttribute(value="user_name")
2    public String before2(@RequestParam(required = false) String name, Model model) {
3        System.out.println("进入了2：" + name);
4        return name;
5    }

Copier après la connexion

Besoin de modéliser manuellement.ajouter la méthode

On crée une méthode de requête sous la classe actuelle :

1    @ModelAttribute
2    public void before(@RequestParam(required = false) Integer age, Model model) {
3        model.addAttribute("age", age);
4        System.out.println("进入了1：" + age);
5    }

Copier après la connexion

Entrer l'adresse d'accès dans le navigateur et ajoutez les paramètres ci-dessus :

1@RequestMapping(value="/mod")
 2    public Resp mod(
 3            @RequestParam(required = false) String name,
 4            @RequestParam(required = false) Integer age, 
 5            Model model){
 6        System.out.println("进入mod");
 7        System.out.println("参数接受的数值{name="+name+";age="+age+"}");
 8        System.out.println("model传过来的值:"+model);
 9        return Resp.success("1");
10    }

Copier après la connexion

http://localhost:8081/api/test/mod?name=我是小菜&age=12

Le résultat final est le suivant :

1 entré 1:40

2 entrés 2 : Je suis Xiaocai

3 entrés mod
4 La valeur acceptée par le paramètre {name=I am Xiaocai;age=12}
5La valeur passée par modèle : { age=40, user_name=我是小菜}

2. Marquez les paramètres de la méthode.

Marqués sur les paramètres de la méthode, les paramètres passés par le client seront injectés dans l'objet spécifié par nom, et cet objet sera automatiquement ajouté au ModelMap pour une utilisation facile par le calque View <🎜. > Nous sommes ci-dessus Ajoutez une méthode à la classe comme suit

Entrez l'adresse d'accès dans le navigateur et ajoutez des paramètres :

http://localhost:8081/api/test/mod2?name =Je m'appelle Xiaocai &age=12

1@RequestMapping(value="/mod2")
 2    public Resp mod2(@ModelAttribute("user_name") String user_name, 
 3            @ModelAttribute("name") String name,
 4            @ModelAttribute("age") Integer age,Model model){
 5        System.out.println("进入mod2");
 6        System.out.println("user_name:"+user_name);
 7        System.out.println("name："+name);
 8        System.out.println("age:"+age);
 9        System.out.println("model:"+model);
10        return Resp.success("1");
11    }

Copier après la connexion

Sortie finale :

Comme le montrent les résultats, l'annotation @ModelAttribute utilisée dans les paramètres de la méthode est en fait un moyen d'accepter les paramètres et automatiquement placez-les dans l’objet Model pour en faciliter l’utilisation.

1进入了1：40
2进入了2：我是小菜
3进入mod2
4user_name:我是小菜
5name：我是小菜
6age:40
7model:{user_name=我是小菜,

Copier après la connexion

org.springframework.validation.BindingResult.user_name=org.springframework.validation.BeanPropertyBindingResult:
 0 errors, name=我是小菜, 
org.springframework.validation.BindingResult.name=org.springframework.validation.BeanPropertyBindingResult:
 0 errors, age=40, 
org.springframework.validation.BindingResult.age=org.springframework.validation.BeanPropertyBindingResult:
 0 errors}

Copier après la connexion

8. @Cacheable

est utilisé pour marquer les requêtes mises en cache. Il peut être utilisé dans des méthodes ou des classes. Lorsque

est marqué sur une méthode, cela signifie que la méthode prend en charge la mise en cache. Lorsque

est marqué sur une classe, cela signifie que toutes les méthodes de la classe prennent en charge la mise en cache. . de.

Liste des paramètres

1@Cacheable(value="UserCache")// 使用了一个缓存名叫 accountCache   
2public Account getUserAge(int id) {  
3     //这里不用写缓存的逻辑，直接按正常业务逻辑走即可，
4     //缓存通过切面自动切入  
5    int age=getUser(id);   
6     return age;   
7}

Copier après la connexion

9. @CacheEvict

用来标记要清空缓存的方法，当这个方法被调用后，即会清空缓存。 @CacheEvict(value=”UserCache”)

参数列表

参数	解释	例子
value	名称	@CachEvict(value={”c1”,”c2”}
key	key	@CachEvict(value=”c1”,key=”#id”)
condition	缓存的条件，可以为空
allEntries	是否清空所有缓存内容	@CachEvict(value=”c1”，allEntries=true)
beforeInvocation	是否在方法执行前就清空	@CachEvict(value=”c1”，beforeInvocation=true)

10. @Resource

@Resource的作用相当于@Autowired
只不过@Autowired按byType自动注入，
而@Resource默认按 byName自动注入罢了。

@Resource有两个属性是比较重要的，分是name和type，Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。

@Resource装配顺序:
如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常

如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常

如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常

如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配；

11. @PostConstruct

用来标记是在项目启动的时候执行这个方法。用来修饰一个非静态的void()方法
也就是spring容器启动时就执行，多用于一些全局配置、数据字典之类的加载

被@PostConstruct修饰的方法会在服务器加载Servlet的时候运行，并且只会被服务器执行一次。PostConstruct在构造函数之后执行,init()方法之前执行。PreDestroy（）方法在destroy()方法执行执行之后执

12. @PreDestroy

被@PreDestroy修饰的方法会在服务器卸载Servlet的时候运行，并且只会被服务器调用一次，类似于Servlet的destroy()方法。被@PreDestroy修饰的方法会在destroy()方法之后运行，在Servlet被彻底卸载之前

13. @Repository

用于标注数据访问组件，即DAO组件

14. @Component

泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注

15. @Scope

用来配置 spring bean 的作用域，它标识 bean 的作用域。
默认值是单例

singleton:单例模式,全局有且仅有一个实例

prototype:原型模式,每次获取Bean的时候会有一个新的实例

request:request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效

session:session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效

global session:只在portal应用中有用，给每一个 global http session 新建一个Bean实例。

16. @SessionAttributes

默认情况下Spring MVC将模型中的数据存储到request域中。当一个请求结束后，数据就失效了。如果要跨页面使用。那么需要使用到session。而@SessionAttributes注解就可以使得模型中的数据存储一份到session域中

参数：

names：这是一个字符串数组。里面应写需要存储到session中数据的名称。
types：根据指定参数的类型，将模型中对应类型的参数存储到session中
value：和names是一样的。

 1@Controller
 2@SessionAttributes(value={"names"},types={Integer.class})
 3public class ScopeService {
 4        @RequestMapping("/testSession")
 5        public String test(Map<String,Object> map){
 6            map.put("names", Arrays.asList("a","b","c"));
 7            map.put("age", 12);
 8            return "hello";
 9        }
10}

Copier après la connexion