एक बार एपीआई तय हो गई है, मैं इसे इस तरह से लागू होगी:
डीबी दृष्टिकोण से, मैं 2 टेबल होगा - UserTable और RelationsTable अपने मित्रों के सभी किनारे रखने के लिए ग्राफ़:
आईई विचार उपयोगकर्ताओं को एक तालिका में और संबंध तालिका में उनके संबंधों में रखना है। यह बाद में इसके ऊपर कुछ अतिरिक्त तर्क भी जोड़ने की अनुमति देता है (उदाहरण के लिए, उपयोगकर्ता अपने कनेक्शन को छुपाता है या किसी को ब्लॉक करता है, आदि - ग्राफ के किसी भी संभावित किनारों)। इसके अलावा, यह परिपत्र संदर्भ के साथ समस्याओं को कम करने की अनुमति देता है।
सेवा & पार्स जेसन से डेटा पुनर्प्राप्त करने के लिए एक ढांचे के रूप में, मैं Retrofit का उपयोग करूंगा।
पहले, मैं UserBase और User कक्षाएं निर्धारित करेंगे:
public class UserBase {
public string id;
}
public final class User extends UserBase {
public string name;
public List<UserBase> friends;
// user's "real" friends, not just ids, fills from SQLite
public List<User> userFriends;
}
जहां, जैसा कि आप देख सकते हैं, friendsRetrofit JSON और userFriends से वस्तु को पार्स करने के लिए UserBase वस्तुओं की एक सूची है - सूची, जिसे हम आगे चरणों में SQLite से मैन्युअल रूप से भर देंगे।
public interface Dao<TItem> {
void add(List<TItem> items);
void removeAll();
List<TItem> getAll();
}
....
public abstract class AbstractDao<TItem> implements Dao<TItem> {
protected final SQLiteDatabase database;
protected final SqlUtilities sqlUtilities;
public AbstractDao(SQLiteDatabase database, SqlUtilities sqlUtilities) {
this.database = database;
this.sqlUtilities = sqlUtilities;
}
}
अब हम दाव के RelatedTable के लिए और के लिए UserTable की जरूरत है::
public class UserRelation {
public String mainUserId;
public String relatedUserId;
}
...
public interface UserRelationDao extends Dao<UserRelation> {
...
List<User> getFriends(String userId);
...
}
...
public interface UserDao extends Dao<User> {
...
void addWithIgnore(List<TItem> items);
void update(List<TItem> items);
void upsert(List<TItem> items);
User getById(String userId);
...
}
इसके पूर्ण हो जाने, हम वास्तव में इस लागू कर सकते हैं
अब, चलो कुछ मदद वर्गों डीबीएस के साथ संचालित करने के लिए निर्दिष्ट कर सकते हैं इंटरफेस:
DefaultUserRelationDao वर्ग:
public class DefaultUserRelationDao extends AbstractDao<UserRelation> implements UserRelationDao {
static final String MAIN_USER_COLUMN = "mainuser";
static final String RELATED_USER_COLUMN = "relateduser";
private static final String[] COLUMN_NAMES = new String[]{
MAIN_USER_COLUMN,
RELATED_USER_COLUMN,
};
private static final String[] COLUMN_TYPES = new String[]{
"TEXT",
"TEXT",
};
private static final String TABLE = "userrelation";
static final String CREATE_TABLE = SqlUtilities.getCreateStatement(TABLE, COLUMN_NAMES, COLUMN_TYPES);
static final String ALL_CONNECTED_USERS =
"SELECT " + Joiner.on(",").join(DefaultUserDao.COLUMN_NAMES) +
" FROM " + UserTable.TABLE_NAME + "," + TABLE +
" WHERE " + RELATED_USER_COLUMN + "=" + DefaultUserDao.USER_ID_COLUMN;
public DefaultUserRelationDao(SQLiteDatabase database, SqlUtilities sqlUtilities) {
super(database, sqlUtilities);
}
@Override
public void add(List<UserRelation> userRelations) {
try {
database.beginTransaction();
ContentValues contentValues = new ContentValues();
for (UserRelation relation : userRelations) {
sqlUtilities.setValuesForUsersRelation(contentValues, relation);
database.insertOrThrow(TABLE, null, contentValues);
}
database.setTransactionSuccessful();
} finally {
database.endTransaction();
}
}
@Override
public List<User> getFriends(String userId) {
Cursor cursor = database.rawQuery(ALL_CONNECTED_USERS, new String[]{userId});
return sqlUtilities.getConnectedUsers(cursor);
}
}
और DefaultUserDao वर्ग:
public final class DefaultUserDao extends AbstractUDao<User> implements UserDao {
public static final String USER_ID_COLUMN = "userid";
static final String USER_NAME_COLUMN = "username";
public static final String[] COLUMN_NAMES = new String[]{
USER_ID_COLUMN,
USER_NAME_COLUMN,
};
private static final String TABLE = "users";
private static final String SELECT_BY_ID =
SqlUtilities.getSelectWhereStatement(TABLE, COLUMN_NAMES, new String[]{ USER_ID_COLUMN });
static final String CREATE_TABLE = SqlUtilities.getCreateStatement(TABLE, COLUMN_NAMES, COLUMN_TYPES);
public DefaultUserDao(SQLiteDatabase database, SqlUtilities sqlUtilities) {
super(database, sqlUtilities);
}
@Override
public void add(List<User> users) {
try {
database.beginTransaction();
ContentValues contentValues = new ContentValues();
for (User user : users) {
sqlUtilities.setValuesForUser(contentValues, user);
database.insertOrThrow(UserTable.TABLE_NAME, null, contentValues);
}
database.setTransactionSuccessful();
} finally {
database.endTransaction();
}
}
@Override
public User getById(String userId) {
return getUserBySingleColumn(SELECT_BY_ID, userId);
}
.....
private User getUserBySingleColumn(String selectStatement, String value) {
Cursor cursor = database.rawQuery(selectStatement, new String[]{value});
List<User> users = sqlUtilities.getUsers(cursor);
return (users.size() != 0) ? users.get(0) : null;
}
}
हमारे टेबल बनाने के लिए, हम SQLiteOpenHelper का विस्तार करने और onCreate() वास्तव में बनाने के तालिकाओं में की जरूरत है:
public final class DatabaseHelper extends SQLiteOpenHelper {
static final String DATABASE_NAME = "mysuper.db";
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, SCHEMA_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(DefaultUserDao.CREATE_TABLE);
db.execSQL(DefaultUserRelationDao.CREATE_TABLE);
}
...
}
अब, मैं सभी के साथ LocalStorage इंटरफेस को परिभाषित करने के सुझाव देंगे कैश के साथ संभावित क्रियाएं:
जोड़ने जोड़ सकते हैं और यह कार्यान्वयन है:
public final class SqlLocalStorage implements LocalStorage {
private UserDao userDao;
private UserRelationDao userRelationDao;
private SQLiteDatabase database;
private final Object initializeLock = new Object();
private volatile boolean isInitialized = false;
private SqlUtilities sqlUtilities;
// there database is
// SQLiteOpenHelper helper = new DatabaseHelper(context);
// database = helper.getWritableDatabase();
public SqlLocalStorage(SQLiteDatabase database, SqlUtilities sqlUtilities) {
this.database = database;
this.sqlUtilities = sqlUtilities;
}
@Override
public User getUserById(String userId) {
initialize();
User user = userDao.getById(userId);
if (user == null) {
return null;
}
List<User> relatedUsers = userRelationDao.getFriends(userId);
user.userFriends = relaterUsers;
return user;
}
@Override
public void addUsers(List<User> users) {
initialize();
for (User user : users) {
for (UserBase friend : user) {
UserRelation userRelation = new UserRelation();
userRelation.mainUserId = user.id;
userRelation.relatedUserId = friend.id;
UserRelation userRelationMutual = new UserRelation();
userRelationMutual.mainUserId = friend.id;
userRelationMutual.relatedUserId = user.id;
userRelationDao.add(userRelation);
userRelationMutual.add(userRelation)
}
}
userDao.addWithIgnore(users);
}
void initialize() {
if (isInitialized) {
return;
}
synchronized (initializeLock) {
if (isInitialized) {
return;
}
Log.d(LOG_TAG, "Opens database");
userDao = new DefaultUserDao(database, sqlUtilities);
userRelationDao = new DefaultUserRelationDao(database, sqlUtilities);
isInitialized = true;
}
}
}
अंतिम चरण - वास्तविक इसका उपयोग:
//somewhere in non-UI thread
List<User> users = dataSource.getUsers();
localStorage.addUsers(users);
final User userBob = localStorage.getUserById("42");
एनबी! मैं यहां अपने कस्टम वर्ग एसक्यूएलटीटी का उपयोग कर रहा हूं। दुर्भाग्य से, यह इसे यहाँ पोस्ट करने के लिए जिस तरह से बहुत बड़ा है, लेकिन सिर्फ एक उदाहरण कुछ विचार अंदर क्या है देने के लिए - यहाँ कैसे getUsers (कर्सर कर्सर) वहाँ दिखाई देता है:
.....
public List<User> getUsers(Cursor cursor) {
ArrayList<User> users = new ArrayList<>();
try {
while (cursor.moveToNext()) {
users.add(getUser(cursor));
}
} finally {
cursor.close();
}
return users;
}
private User getUser(Cursor cursor) {
User user = new User(cursor.getString(0));
user.FullName = cursor.getString(1);
....
return user;
}
.....
मुझे आशा है कि, क्या आप मुझे कुछ लंघन माफ कर देंगे विवरण (विशेष रूप से, मामले के संबंध में, जब डीबी को अद्यतन किया जाना है, जब डेटा पूर्ण नहीं होता है और इसे कैश से प्राप्त करने के अलावा, आपको इसे पहले सर्वर से पुनर्प्राप्त करना होगा, और फिर उसे कैश में लोड करना होगा)। यदि कोई महत्वपूर्ण हिस्सा गुम है - कृपया इसे टिप्पणियों में पोस्ट करें और मुझे पोस्ट अपडेट करने में खुशी होगी।
मुझे उम्मीद है कि यह आपकी मदद करेगा।
मैं आईडी, नाम, दोस्तों को पार्स करने के लिए एक विधि बना सकता हूं और इसे आगे की प्रक्रिया के लिए सूची या किसी डेटा संरचना के रूप में वापस कर सकता हूं, क्या इससे मदद मिलेगी? –