Introduction détaillée aux fonctionnalités Java8 prises en charge par Spring 4 (photo)

Spring Framework 4 prend en charge le langage Java 8 et la fonctionnalité API. Dans cet article, nous nous concentrons sur la prise en charge par Spring 4 des nouvelles fonctionnalités de Java 8. Les plus importants sont LambdaExpression, MéthodeRéférence, date et heure JSR-310 et annotations répétables. Jetons un coup d'œil avec l'éditeur ci-dessous

Spring Framework 4 prend en charge le langage Java 8 et les fonctions API. Dans cet article, nous nous concentrons sur la prise en charge par Spring 4 des nouvelles fonctionnalités de Java 8. Les plus importants sont les expressions lambda, les références de méthodes, la date et l'heure JSR-310 et les annotations répétables.

Expressions Lambda

La base de code de Spring utilise un grand nombre d'interfaces fonctionnelles dans Java 8, et les expressions Lambda peuvent être utilisées pour écrire du code plus propre et plus compact. Nous pouvons fournir une expression Lambda chaque fois qu'un objet d'une interface fonctionnelle est attendu. Découvrons d’abord les interfaces fonctionnelles avant de continuer.

Interface fonctionnelle

Une interface avec une seule méthode abstraite est appelée interface fonctionnelle. Voici quelques exemples d'interfaces fonctionnelles dans le JDK :

Le comparateur n'est qu'une abstraction des fonctions de méthodes non-objets. Bien que deux méthodes abstraites soient déclarées, equals est exclue du décompte car il s'agit d'une méthode publique correspondant à l'objet. Une interface qui possède une méthode de classe d’objet et aucune méthode non-objet n’est pas une interface fonctionnelle.

Une interface est appelée interface fonctionnelle si elle possède une méthode de classe non-objet abstraite et s'étend d'une interface non fonctionnelle avec une méthode de classe d'objet unique.

Exemple d'interface fonctionnelle du framework Spring :

@FunctionalInterface Annotations peut être utilisé dans la déclaration supérieure de la déclaration d'interface, mais ce n'est pas obligatoire. Cette annotation est utilisée par le compilateur pour détecter si l'interface est une interface fonctionnelle valide. Si nous essayons de définir plusieurs méthodes abstraites uniques dans une interface, le compilateur générera une erreur.

Descripteur de fonction

Le descripteur de fonction d'une interface est une abstraction de l'interface Le type de méthode. Le type de méthode comprend les types de paramètres, le type de retour et la clause throws.

Exemple :

Comment écrire une expression Lambda

La syntaxe de l'expression Lambda peut être divisée en trois Partie :

• Une flèche (–>)

• Liste de paramètres : Une expression Lambda peut contenir 0 ou plusieurs paramètres. Exemple :

• () → { System.out.println(“ No arguments”); 
  } (String arg) → { System.out.println(“ One argument : ”+arg); 
  } (String arg1, Integer arg2) 
  → { System.out.println(“Two arguments : ”+arg1+” and ”+arg2); }

  Copier après la connexion
• Corps de l'expression : peut être une expression unique ou un bloc de code. Une seule expression sera simplement évaluée et renvoyée. Exemple : (String arg) → { System.out.println(“ One argument : ” arg } S'il y a un bloc d'instructions dans le corps de l'expression (Body), alors il sera déterminé comme corps de méthode et masqué après le Le bloc est exécuté. L'instruction return donne le contrôle à l'appelant.

Voyons maintenant comment utiliser les expressions Lambda :

Exemple 1 :

// Utilisation de l'expression Lambda

Exemple 2 :

//Utiliser l'expression Lambda

Vous pouvez utiliser des expressions Lambda via les fonctions de rappel de Spring. Par exemple, l'utilisation d'un ConnectionCallback pour récupérer la liste des connexions JDBC données peut être écrite comme l'instruction suivante : jdbcTemplate.execute(connection -> connection.getCatalog())

Method Reference

Les interfaces fonctionnelles peuvent également être implémentées à l'aide de références de méthodes, qui font référence à des méthodes ou à des constructeurs mais ne les appellent pas. Les références de méthode sont similaires aux expressions lambda, mais les références de méthode font référence aux méthodes d'une classe existante, tandis que les lambdas définissent une méthode anonyme comme une instance d'une interface fonctionnelle.

Dans Java 8, un nouveau package contient une interface fonctionnelle couramment utilisée pour les expressions Lambda et les références de méthodes : java.util.function.

API Date Time

Il existe plusieurs problèmes avec les classes Date et Time existantes en Java. L'un des plus gros problèmes avec les classes Date et Calendar est qu'elles ne sont pas thread-safe. Les développeurs doivent être particulièrement attentifs aux problèmes de concurrence lors de l’écriture du code de gestion des dates. La classe Date ne prend pas non plus en charge l’internationalisation et ne prend donc pas en charge les fuseaux horaires. Les développeurs doivent écrire beaucoup de code pour prendre en charge différents fuseaux horaires.

Les classes Date et Heure présentent également une mauvaise conception de l'API. Le mois dans java.util.Date commence à 0, le jour commence à 1 et l'année commence à 1900. La cohérence manque. Ces problèmes, ainsi que plusieurs autres, liés aux classes Date et Time sont désormais résolus dans les nouvelles API Date et Time de Java 8.

Les classes importantes de la nouvelle API Date et Heure sous le package java.time sont LocalDate, LocalTime et ZonedDateTime.

LocalDate et LocalTime

Le format par défaut de LocalDate lors de la représentation de la date est AAAA-MM-JJ, et il n'y a pas d'heure. C'est une classe immuable. Nous pouvons obtenir la date actuelle en utilisant la méthode now().

Exemple de création d'une nouvelle instance LocalDate :

//Obtenir la date actuelle

On peut également saisir l'année, le mois et day Paramètres pour créer une nouvelle instance LocalDate.

// 1er avril 2016

LocalTime représente une heure sans date et reste inchangée. Le format par défaut de l'heure est hh:mm:ss.zzz.

Exemple de création d'une nouvelle instance LocalTime :

//Obtenir l'heure actuelle

// 18:30:30

Par défaut, les classes LocalDate et LocalTime utilisent l'horloge système dans le fuseau horaire par défaut. Ces classes prennent également en charge la modification des fuseaux horaires via la méthode overloaded new(). Vous pouvez obtenir une date dans un fuseau horaire spécifique en passant zoneid.

Exemple :

// Date locale actuelle à Calcutta (Inde)

De plus, il existe une classe, LocalDateTime qui combine la date et Heure, le format par défaut est aaaa-MM-jjTHH:MM:ss.zzz·.

//Date et heure actuelles

// 01/04/2016 13h30

ZonedDateTime

Il s'agit d'une classe immuable utilisée pour représenter une date et une heure, y compris les informations de fuseau horaire. Nous pouvons utiliser une instance de cette classe pour représenter un événement spécifique, comme une conférence dans une partie du monde.

// L'heure actuelle utilise l'heure système et le fuseau par défaut

// L'heure actuelle utilise l'horloge système dans un fuseau horaire spécifique

Spring 4 fournit un cadre de transformation qui prend en charge toutes les classes qui font partie de l'API de date et d'heure Java 8. Spring 4 peut prendre une String 2016-9-10 et la convertir en une instance de Java 8 LocalDate. Spring 4 prend également en charge le formatage des champs Date-Heure Java 8 via l'annotation @DateTimeFormat. @DateTimeFormat déclare qu'un champ doit être formaté comme une date et une heure.

Annotations en double

Avant Java 8, ajouter plusieurs annotations du même type à une déclaration ou un type (par exemple une classe ou méthode) n’est pas autorisée. Pour contourner le problème, les développeurs ont dû les combiner dans une seule annotation de conteneur.

Exemple :

Les annotations en double nous permettent de réécrire le même code sans utiliser explicitement les annotations du conteneur. Bien que l'annotation du conteneur ne soit pas utilisée ici, le compilateur Java est responsable de l'empaquetage des deux annotations dans un conteneur :

Exemple :

Définir des annotations répétitives

Définissez une annotation répétitive, annotez-la avec l'annotation @Repeatable réutilisable ou créez une annotation avec la série de types d'annotations répétitives attribut .

Étape 1 : Déclarer le type d'annotation répétitive :

Étape 2 Étape : Déclarez le type d'annotation du conteneur.

L'ensemble de l'implémentation est la suivante :

Afin d'obtenir des annotations au moment de l'exécution Pour information, annotez-le simplement avec @Retention(RetentionPolicy.RUNTIME).

Récupérer les annotations

getAnnotationsByType() ou getDeclaredAnnotationsByType() sont de nouvelles méthodes de l'API Reflection pour accéder aux annotations.

Les annotations sont également accessibles via les annotations de leur conteneur en utilisant getAnnotation() ou getDeclaredAnnotation().

Conclusion

Spring 4 fonctionne également sur Java 6 et Java 7. Étant donné que Spring utilise de nombreuses interfaces fonctionnelles, avec Java 8 et Spring 4, vous pourrez utiliser des expressions Lambda et des interfaces fonctionnelles et écrire du code plus propre et plus compact.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!