Comment utiliser Spring Social pour se connecter aux réseaux sociaux

Les réseaux sociaux sont devenus aujourd’hui un élément indispensable de la vie des gens. Les sites de réseaux sociaux populaires, tels que Facebook, LinkedIn, Twitter et Sina Weibo, ont acquis une très grande popularité et sont devenus des sites que de nombreuses personnes doivent visiter chaque jour. Une grande quantité d’informations est partagée sur les réseaux sociaux. Pour une application, il est nécessaire de prévoir un support pour les réseaux sociaux. Les applications peuvent rapidement gagner en popularité grâce à l’intégration aux réseaux sociaux. L'intégration avec les réseaux sociaux a principalement deux fonctions : la première est une intégration de connexion utilisateur relativement simple, qui permet aux utilisateurs de se connecter à l'application en utilisant des comptes existants sur les sites de réseaux sociaux. L'avantage est que cela peut éviter à l'utilisateur le processus de réinscription, et cela peut également établir une connexion avec le réseau social existant de l'utilisateur ; la seconde est une méthode d'intégration profonde, qui permet aux utilisateurs de partager du contenu pertinent dans l'application ; au milieu des réseaux sociaux. L’avantage est que cela permet de maintenir la fidélité de l’utilisateur tout en faisant la promotion de l’application elle-même.

Intégrer les réseaux sociaux dans votre application n'est pas une tâche compliquée. De nombreux services de réseaux sociaux fournissent des API ouvertes qui permettent l'intégration d'applications tierces. Référez-vous simplement à la documentation pertinente pour compléter. Cependant, l’intégration elle-même nécessite un certain travail. Plus il y a de sites Web à intégrer, plus la charge de travail correspondante est importante. Spring Social, en tant que membre de la famille de composants du framework Spring, fournit une abstraction des services de réseaux sociaux et fournit des API associées pour les opérations.

Le plus grand avantage de l'utilisation de Spring Social est qu'il prend déjà en charge les sites de réseaux sociaux grand public et ne nécessite qu'une configuration simple. Pour certains sites de réseaux sociaux moins utilisés, vous pouvez également trouver les composants correspondants de la communauté. Cet article utilise un exemple d'application pour illustrer l'utilisation de Spring Social.

Exemple d'application

Cet exemple permet aux utilisateurs de se connecter à des sites de réseaux sociaux pour afficher des informations sur leurs amis. Il s'agit d'une application Web construite à l'aide du framework Spring MVC. L'application utilise une base de données H2 intégrée pour stocker les données. Le front-end utilise JSP, JSTL et la bibliothèque de balises fournie par Spring, et utilise Apache Tiles pour la mise en page. Gérez l'authentification des utilisateurs à l'aide de Spring Security. La page est stylisée à l'aide de la bibliothèque Twitter Bootstrap. Le projet est construit à l'aide de Gradle. La bibliothèque frontale est gérée via Bower.

Les fonctions fournies par l'exemple sont relativement simples, comprenant principalement les pages de connexion et d'inscription, ainsi que la page d'accueil de l'utilisateur. Lors de la connexion, les utilisateurs peuvent choisir d'utiliser un compte auprès d'un réseau social tiers. Une fois connecté, vous pouvez consulter les informations sur vos amis sur les réseaux sociaux.

Connectez-vous en utilisant des comptes existants sur les réseaux sociaux

La fonction la plus basique intégrée aux réseaux sociaux est de permettre aux utilisateurs de se connecter en utilisant des comptes existants. En plus d'enregistrer un nouveau compte, les utilisateurs peuvent également utiliser des comptes existants sur d'autres sites Web pour se connecter. Cette méthode est souvent appelée connexion à des sites Web tiers. Pour les utilisateurs, le scénario habituel consiste à choisir un réseau social tiers pour se connecter sur la page d'inscription ou de connexion. Accédez ensuite au site Web tiers pour vous connecter et obtenir votre autorisation. Après avoir terminé les étapes ci-dessus, un nouvel utilisateur sera créé. Pendant le processus de connexion, l'application peut obtenir les informations de profil de l'utilisateur auprès du site de réseau social tiers pour finaliser la création de nouveaux utilisateurs. Une fois le nouvel utilisateur créé, l'utilisateur pourra se connecter directement en utilisant le compte du réseau social tiers la prochaine fois.

Configuration de base

Spring Social fournit la mise en œuvre du contrôleur Spring MVC (Contrôleur) qui gère la connexion et l'enregistrement des utilisateurs de sites Web tiers, qui peuvent automatiquement compléter l'utilisation de comptes de réseaux sociaux Fonctionnalité de connexion et d’enregistrement. Avant d'utiliser ces contrôleurs, une configuration de base est requise. La configuration de Spring Social est complétée par l'implémentation de l'interface org.springframework.social.config.annotation.SocialConfigurer. Une partie de la classe SocialConfig qui implémente l'interface SocialConfigurer est donnée. L'annotation "@EnableSocial" est utilisée pour activer les fonctions liées à Spring Social. L'annotation "@Configuration" indique que cette classe contient également des informations de configuration liées au framework Spring. L'interface SocialConfigurer comporte trois méthodes qui doivent être implémentées :

addConnectionFactories : Cette méthode de rappel est utilisée pour permettre à l'application d'ajouter l'implémentation de la fabrique de connexions correspondant au réseau social qui doit être pris en charge.

getUserIdSource : cette méthode de rappel renvoie un objet d'implémentation de l'interface org.springframework.social.UserIdSource, qui est utilisé pour identifier de manière unique l'utilisateur actuel.

getUsersConnectionRepository : Cette méthode de rappel renvoie un objet d'implémentation de l'interface org.springframework.social.connect.UsersConnectionRepository, qui permet de gérer la correspondance entre les utilisateurs et les fournisseurs de services de réseaux sociaux.

Spécifiquement pour l'exemple d'application, l'implémentation de la méthode addConnectionFactories ajoute l'implémentation de la fabrique de connexions de LinkedIn représentée par la classe org.springframework.social.linkedin.connect.LinkedInConnectionFactory. Dans l'implémentation de la méthode getUserIdSource, Spring Security est utilisé pour obtenir les informations de l'utilisateur actuellement connecté. La méthode getUsersConnectionRepository crée un objet d'implémentation de la classe JdbcUsersConnectionRepository basée sur une base de données. La classe LinkedInConnectionFactory est créée d'une manière qui reflète la puissance de Spring Social. Il vous suffit de fournir la clé API appliquée chez LinkedIn pour utiliser directement les fonctions proposées par LinkedIn. Les détails liés à OAuth sont encapsulés par Spring Social.

1. Utilisez la configuration de base de Spring Social

@Configuration@EnableSocialpublic class SocialConfig implements SocialConfigurer { @Inject
 private DataSource dataSource; @Override
 public void addConnectionFactories(ConnectionFactoryConfigurer cfConfig, Environment env) {
 cfConfig.addConnectionFactory(new LinkedInConnectionFactory(env.getProperty("linkedin.consumerKey"), env.getProperty("linkedin.consumerSecret")));
 } @Override
 public UserIdSource getUserIdSource() { return new UserIdSource() { @Override
 public String getUserId() {
 Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); if (authentication == null) { throw new IllegalStateException("Unable to get a ConnectionRepository: no user signed in");
 } return authentication.getName();
 }
 };
 } @Override
 public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) { return new JdbcUsersConnectionRepository(dataSource, connectionFactoryLocator, Encryptors.noOpText());
 }
}

Contrôleur de connexion

L'étape suivante après la configuration de Spring Social consiste à créer le correspondant Contrôleur Spring MVC pour gérer l’enregistrement et la connexion des utilisateurs. Spring Social fournit déjà l'implémentation du contrôleur correspondante, il vous suffit de créer une interface pour faire des requêtes. La première chose à créer est un contrôleur pour se connecter via un réseau social tiers. Comme indiqué, il vous suffit de créer un Spring Bean pour créer le contrôleur requis. Ce contrôleur est lié par défaut à l'URL "/signin". Chaque prestataire de services tiers dispose d'un identifiant correspondant, tel que l'identifiant de LinkedIn « linkedin ». L'identifiant du fournisseur de services est souvent inclus dans l'URL de différents contrôleurs. Par exemple, lorsqu'un utilisateur doit se connecter via un compte LinkedIn, l'URL correspondante est « /signin/linkedin ». Si vous vous connectez via un compte Twitter, l'URL correspondante est "/signin/twitter".

2. Contrôleur pour la connexion via des réseaux sociaux tiers

@Beanpublic ProviderSignInController providerSignInController(ConnectionFactoryLocator connectionFactoryLocator, UsersConnectionRepository usersConnectionRepository) { return new ProviderSignInController(connectionFactoryLocator, usersConnectionRepository, new SimpleSignInAdapter(new HttpSessionRequestCache()));
}

Dans ce qui précède, la classe SimpleSignInAdapter implémente l'interface org.springframework.social.connect.web.SignInAdapter, qui Fonctionne comme un pont entre la classe ProviderSignInController et la logique de connexion de l'application elle-même. Une fois que l'utilisateur a terminé de se connecter au site Web tiers, il est automatiquement connecté à l'application via l'interface SignInAdapter. L'implémentation de la classe SimpleSignInAdapter est présentée ci-dessous.

3. Implémentation de la classe SimpleSignInAdapter

public class SimpleSignInAdapter implements SignInAdapter { private final RequestCache requestCache; @Inject
 public SimpleSignInAdapter(RequestCache requestCache) { this.requestCache = requestCache;
 } @Override
 public String signIn(String localUserId, Connection<?> connection, NativeWebRequest request) {
 SignInUtils.signin(localUserId); return extractOriginalUrl(request);
 } private String extractOriginalUrl(NativeWebRequest request) {
 HttpServletRequest nativeReq = request.getNativeRequest(HttpServletRequest.class);
 HttpServletResponse nativeRes = request.getNativeResponse(HttpServletResponse.class);
 SavedRequest saved = requestCache.getRequest(nativeReq, nativeRes); if (saved == null) { return null;
 }
 requestCache.removeRequest(nativeReq, nativeRes);
 removeAutheticationAttributes(nativeReq.getSession(false)); return saved.getRedirectUrl();
 } private void removeAutheticationAttributes(HttpSession session) { if (session == null) { return;
 }
 session.removeAttribute(WebAttributes.AUTHENTICATION_EXCEPTION);
 }
}

Dans la liste de codes 3, la méthode signIn de la classe SimpleSignInAdapter appelle la méthode de connexion de la classe SignInUtils pour se connecter, et sa mise en œuvre Voir le listing de codes 4. La valeur de retour de la méthode signIn est l'URL de saut après une connexion réussie.

4. Implémentation de la méthode signIn de la classe SignInUtils

public class SignInUtils { public static void signin(String userId) {
 SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(userId, null, null));
 }
}

Page Front-end

Il vous suffit de faire une requête POST à ​​l'URL de connexion contrôleur via la page pour le démarrer Le processus de connexion via LinkedIn. Comme le montre la figure, le processus de connexion peut être lancé en soumettant le formulaire. L'utilisateur sera d'abord dirigé vers la page d'autorisation du site Web de LinkedIn pour autoriser l'application. Une fois l'autorisation terminée, l'utilisateur peut s'inscrire.

5. Page de connexion

<form id="linkedin-signin-form" action="signin/linkedin" method="POST" class="form-signin" role="form">
 <h2 class="form-signin-heading">Or Connect by</h2>
 <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"/>
 <button type="submit" class="btn btn-primary">LinkedIn</button>
</form>

Par défaut, lorsque l'autorisation du site tiers est terminée, l'utilisateur sera dirigé vers la page correspondant à l'URL "/signup". Sur cette page, les utilisateurs peuvent ajouter des informations d'inscription pertinentes. Dans le même temps, les informations de profil utilisateur obtenues à partir de sites Web tiers, telles que le nom de l'utilisateur, peuvent être pré-remplies. Les actions de cette page après la soumission du formulaire sont gérées par le contrôleur affiché.

6. Mise en œuvre du contrôleur d'enregistrement des utilisateurs

@RequestMapping(value="/signup", method=RequestMethod.POST)
public String signup(@Valid @ModelAttribute("signup") SignupForm form, BindingResult formBinding, WebRequest request) { if (formBinding.hasErrors()) { return null;
 }
 Account account = createAccount(form, formBinding); if (account != null) {
 SignInUtils.signin(account.getUsername());
 ProviderSignInUtils.handlePostSignUp(account.getUsername(), request); return "redirect:/";
 } return null;
}

Une fois que l'utilisateur a soumis le formulaire d'inscription, créez un compte correspondant en fonction des informations renseignées par l'utilisateur, puis connectez-vous au nouveau compte enregistré et revenir en arrière sur la première page.

Utiliser l'API

Spring Social 的另外一个重要的作用在于提供了很多社交网络服务的 API 的封装。当用户通过社交网络的账号登录之后，可以通过相应的 API 获取到相关的信息，或执行一些操作。比如获取到用户的好友信息，或是根据用户的要求发布新的消息。一般来说，很多社交网络服务提供商都有自己的 API 来提供给开发人员使用。不过一般只提供 REST API，并没有 Java 封装。Spring Social 的一个目标是为主流的社交网络提供相应的 Java 封装的 API。对于社区已经有良好的 Java 库的社交网络，如 Twitter，Spring Social 会进行整合与封装；而对于暂时没有 Java 实现的，Spring Social 的组件会提供相应的支持。如示例应用中使用的 LinkedIn 的 Java API 是由 Spring Social 开发的。

在使用 LinkedIn 的 Java API 之前，首先要创建相应的 Spring Bean，如所示。

7. 创建 LinkedIn API 对应的 Bean

@Bean@Scope(value="request", proxyMode=ScopedProxyMode.INTERFACES)public LinkedIn linkedin(ConnectionRepository repository) {
 Connection<LinkedIn> connection = repository.findPrimaryConnection(LinkedIn.class); return connection != null ? connection.getApi() : null;
}

LinkedIn Java API 的核心接口是 org.springframework.social.linkedin.api.LinkedIn。如果当前用户已经连接了 LinkedIn 的账号，就可以通过 ConnectionRepository 接口找到该用户对应的连接的信息，并创建出 API 接口的实现。是展示 LinkedIn 上好友信息的控制器的实现。

8. 展示 LinkedIn 上好友信息的控制器的实现

@Controllerpublic class LinkedInConnectionsController { private LinkedIn linkedIn; @Inject
 public LinkedInConnectionsController(LinkedIn linkedIn) { this.linkedIn = linkedIn;
 } @RequestMapping(value="/connections", method= RequestMethod.GET) public String connections(Model model) {
 model.addAttribute("connections", linkedIn.connectionOperations().getConnections()); return "connections";
 }
}

通过 LinkedIn 接口的 connectionOperations 方法可以获取到 org.springframework.social.linkedin.api.ConnectionOperations 接口的实现，然后就可以再通过 getConnections 方法获取到包含好友信息的 org.springframework.social.linkedin.api.LinkedInProfile 类的对象列表。然后就可以在网页上展示，如所示。

9. 展示 LinkedIn 好友信息的页面

<ul class="media-list">
 <c:forEach items="${connections}" var="connection">
 <li class="media">
 <a href="" class="pull-left">
 <img class="lazy-load" data-original="${connection.profilePictureUrl}" alt="" class="media-object">
 </a>
 <div class="media-body">
 <h4 class="media-heading">${connection.firstName} ${connection.lastName}</h4>
 <p><c:out value="${connection.headline}" /></p>
 </div>
 </li>
 </c:forEach>
</ul>

结束语

在社交网络日益流行的今天，Web 应用都应该考虑增加对社交网络的支持。这样既方便了用户，让他们省去了重新注册的麻烦，又可以增加用户粘性，同时可以通过社交网络进行推广。虽然很多社交网站都提供了开放 API 来让应用使用其服务，但是集成所需的工作量是不小的。Spring Social 作为 Spring 框架中的一部分，为在 Web 应用中集成社交网络提供了良好支持。本文详细介绍了如何通过 Spring Social 来实现通过社交网络账号进行登录以及使用社交网络提供的 API。

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!