我有它使用一个简单的应用程序Backbone.js的JSON-服务器作为后端。我必须登录的功能，即发现从集合中的用户，但我不明白我怎么会救我的会话。我想过以后将在每个重定向进行检查cookies中存储的参数。这里是我的模型：

var User = Backbone.Model.extend({
    defaults: {
        login: '',
        password: '',
        authToken: ''
    }
});

这里是我的收藏：

var UserCollection = Backbone.Collection.extend({
    url: 'http://localhost:3000/users',

    // creates a random token
    setToken: function () {
        var rand = function () {
            return Math.random().toString(36).substr(2)
        }

        var token = rand() + rand();
        this.set({authToken: token});
    }
});

这是与登录功能的看法

var LoginView = Backbone.View.extend({
    initialize: function () {
        this.collection = new UserCollection();
        // template
    }
    // render function omitted

    signIn: function () {
        var login = $('#login').val();
        var password = $('#password').val();

        /** 
           finds a user within with the values from input fields
           inside the collection 
        */
        if (login && password) {
            this.collection.fetch({
                data: {
                    login: login,
                    password: password
                }
            });
        }
    }
});

该函数返回我有一个对象，它是我的请求模型的数组。所有这一切我需要的是用我的setToken方法和保存这个模型authToken中的cookie，这样我可以在其他地方的应用程序使用它，但我真的不知道要怎么弄那个。

使用模型来处理身份验证都会比一集更有意义。保持模型的责任简单和范围的一两件事。模型来处理身份验证，然后一个模型来处理，其需要被验证，不能是两个同时其他对象的调用。

我个人基于认证骨干会话的模式。

// Using CommonJS
var Session = require('backbone-session');

// Extend from Session to implement your API's behaviour
var Account = Session.extend({
    urlRoot: 'http://localhost:3000/users',
    signIn: function(opt) {
        opt = opt || {};
        opt.data = _.extend({}, {
            login: opt.login,
            password: opt.password
        }, opt.data);
        return this.fetch(opt);
    },
    signOut: function(opt) { /** handle logout */ },
    getAuthStatus: function() { /** handle refetching if needed */ }
});

我公开为我的应用程序的服务。在这个session模块，我重写Backbone.Sync确保AUTH每个以下调用任何模型或集合的API。

var mySession = new Account();


Backbone.sync = (function(syncFn) {
    return function(method, model, options) {
        options = options || {};

        var beforeSend = options.beforeSend,
            error = options.error;

        // Add auth headers
        options.beforeSend = function(xhr) {
            xhr.setRequestHeader('Authorization', "Bearer " + mySession.get('authToken'));
            if (beforeSend) return beforeSend.apply(this, arguments);
        };

        // handle unauthorized error (401)
        options.error = function(xhr, textStatus, errorThrown) {
            if (error) error.call(options.context, xhr, textStatus, errorThrown);
            if (xhr.status === 401) {
                mySession.signOut();
            }
        };

        return syncFn.apply(this, arguments);
    };
})(Backbone.sync);

骨干会话的模型使用本地存储作为后端。自己的sync方法重写使用本地存储，而不是默认的sync行为。

 sync: function(method, model, options) { options = options || {}; var url = model.options.url || model.url; var key = _.isFunction(url) ? url() : '' + url; var response; switch (method) { case 'create': case 'update': var data = model.toJSON(); var text = JSON.stringify(data); response = localStorage.setItem(key, text); break; case 'delete': response = localStorage.removeItem(key); break; case 'read': response = JSON.parse(localStorage.getItem(key)); break; } if (_.isFunction(options.success)) { options.success(response); } return Backbone.$.Deferred() .resolve(response) .promise(); },