Android注册时总是出现"验证码不正确"

【背景】在登录注册界面 往往存在验证码 功能，注册或者登录的时候，将手机号码，验证码，密码一并提 交到后台。这个时候会提醒 手机验证码错误，请注意：验证码没有过期。这是怎么回事？

【猜想】如果直接用浏览器去请求第一个获取验证码的接口，紧接着再却请求注册（登录）接口，浏览器返 回的数数据确实“注册成功”！！！（或者 开发经常使用的测试接口工具postman 来测试，得到的结果也是一样的）

【发现】 不过发现后台会返一个叫 “sessionId” 的字段。

image

然而，我们在请求注册（登录）接口的时候， 是不需要 传递 sessionId 这么一个请求参数的，所以就有猜想：是不是跟 “sessionId” 有关？

【网上解决方案】

 OkHttpUtils.post(). url(ServerConfig.REMOTE_BASE_URL +                                
 ServerConfig.REGISTER_URL)
 .addHeader("Cookie", "JSESSIONID="+ ssionId)
 .addParams("account", account)
 .addParams("phoneCode", phoneCode)
 .addParams("password", password)
 .build()
 .execute(newStringCallback() {  .....  }

【总结】
（1） 在 RetrofitServiceManager 类（网络请求类）中使用：

     OkHttpClient.Builder builder = new OkHttpClient.Builder();
     builder.cookieJar(new CookieManger(Application.getInstance()));

（2） CookieManger

public class CookieManger implements CookieJar {
public static String APP_PLATFORM = "app-platform";


private static Context mContext;

private static PersistentCookieStore cookieStore;

public CookieManger(Context context) {
    mContext = context;
    if (cookieStore == null ) {
        cookieStore = new PersistentCookieStore(mContext);
    }

}


@Override
public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
    if (cookies != null && cookies.size() > 0) {
        for (Cookie item : cookies) {
            cookieStore.add(url, item);
        }
    }
}

@Override
public List<Cookie> loadForRequest(HttpUrl url) {
    List<Cookie> cookies =cookieStore.get(url);
    return cookies;
}

static class Customer {

    private String userID;
    private String token;

    public Customer(String userID, String token) {
        this.userID = userID;
        this.token = token;
    }

    public String getUserID() {
        return userID;
    }

    public void setUserID(String userID) {
        this.userID = userID;
    }

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

  }
}

（3）PersistentCookieStore

public class PersistentCookieStore {

private static final String LOG_TAG = "PersistentCookieStore";
public static final String COOKIE_PREFS = "Cookies_Prefs";

private final Map<String, ConcurrentHashMap<String, Cookie>> cookies;
private final SharedPreferences cookiePrefs;


public PersistentCookieStore(Context context) {
    cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0);
    cookies = new HashMap<>();

    //将持久化的cookies缓存到内存中 即map cookies
    Map<String, ?> prefsMap = cookiePrefs.getAll();
    for (Map.Entry<String, ?> entry : prefsMap.entrySet()) {
        String[] cookieNames = TextUtils.split((String) entry.getValue(), ",");
        for (String name : cookieNames) {
            String encodedCookie = cookiePrefs.getString(name, null);
            if (encodedCookie != null) {
                Cookie decodedCookie = decodeCookie(encodedCookie);
                if (decodedCookie != null) {
                    if (!cookies.containsKey(entry.getKey())) {
                        cookies.put(entry.getKey(), new ConcurrentHashMap<String, Cookie>());
                    }
                    cookies.get(entry.getKey()).put(name, decodedCookie);
                }
            }
        }
    }
}

protected String getCookieToken(Cookie cookie) {
    return cookie.name() + "@" + cookie.domain();
}

public void add(HttpUrl url, Cookie cookie) {
    String name = getCookieToken(cookie);

    //将cookies缓存到内存中 如果缓存过期 就重置此cookie
    if (!cookie.persistent()) {
        if (!cookies.containsKey(url.host())) {
            cookies.put(url.host(), new ConcurrentHashMap<String, Cookie>());
        }
        cookies.get(url.host()).put(name, cookie);
    } else {
        if (cookies.containsKey(url.host())) {
            cookies.get(url.host()).remove(name);
        }
    }

    //将cookies持久化到本地
    SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
    prefsWriter.putString(url.host(), TextUtils.join(",", cookies.get(url.host()).keySet()));
    prefsWriter.putString(name, encodeCookie(new OkHttpCookies(cookie)));
    prefsWriter.apply();
}

public List<Cookie> get(HttpUrl url) {
    ArrayList<Cookie> ret = new ArrayList<>();
    if (cookies.containsKey(url.host()))
        ret.addAll(cookies.get(url.host()).values());
    return ret;
}

public boolean removeAll() {
    SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
    prefsWriter.clear();
    prefsWriter.apply();
    cookies.clear();
    return true;
}

public boolean remove(HttpUrl url, Cookie cookie) {
    String name = getCookieToken(cookie);

    if (cookies.containsKey(url.host()) && cookies.get(url.host()).containsKey(name)) {
        cookies.get(url.host()).remove(name);

        SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
        if (cookiePrefs.contains(name)) {
            prefsWriter.remove(name);
        }
        prefsWriter.putString(url.host(), TextUtils.join(",", cookies.get(url.host()).keySet()));
        prefsWriter.apply();

        return true;
    } else {
        return false;
    }
}

public List<Cookie> getCookies() {
    ArrayList<Cookie> ret = new ArrayList<>();
    for (String key : cookies.keySet())
        ret.addAll(cookies.get(key).values());

    return ret;
}

/**
 * cookies 序列化成 string
 *
 * @param cookie 要序列化的cookie
 * @return 序列化之后的string
 */
protected String encodeCookie(OkHttpCookies cookie) {
    if (cookie == null)
        return null;
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    try {
        ObjectOutputStream outputStream = new ObjectOutputStream(os);
        outputStream.writeObject(cookie);
    } catch (IOException e) {
        Log.d(LOG_TAG, "IOException in encodeCookie", e);
        return null;
    }

    return byteArrayToHexString(os.toByteArray());
}

/**
 * 将字符串反序列化成cookies
 *
 * @param cookieString cookies string
 * @return cookie object
 */
protected Cookie decodeCookie(String cookieString) {
    byte[] bytes = hexStringToByteArray(cookieString);
    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
    Cookie cookie = null;
    try {
        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        cookie = ((OkHttpCookies) objectInputStream.readObject()).getCookies();
    } catch (IOException e) {
        Log.d(LOG_TAG, "IOException in decodeCookie", e);
    } catch (ClassNotFoundException e) {
        Log.d(LOG_TAG, "ClassNotFoundException in decodeCookie", e);
    }

    return cookie;
}

/**
 * 二进制数组转十六进制字符串
 *
 * @param bytes byte array to be converted
 * @return string containing hex values
 */
protected String byteArrayToHexString(byte[] bytes) {
    StringBuilder sb = new StringBuilder(bytes.length * 2);
    for (byte element : bytes) {
        int v = element & 0xff;
        if (v < 16) {
            sb.append('0');
        }
        sb.append(Integer.toHexString(v));
    }
    return sb.toString().toUpperCase(Locale.US);
}

/**
 * 十六进制字符串转二进制数组
 *
 * @param hexString string of hex-encoded values
 * @return decoded byte array
 */
protected byte[] hexStringToByteArray(String hexString) {
    int len = hexString.length();
    byte[] data = new byte[len / 2];
    for (int i = 0; i < len; i += 2) {
        data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character.digit(hexString.charAt(i + 1), 16));
    }
    return data;
   }
  }

【3】OkHttpCookies

public class OkHttpCookies implements Serializable {

private transient final Cookie cookies;
private transient Cookie clientCookies;

public OkHttpCookies(Cookie cookies) {
    this.cookies = cookies;
}

public Cookie getCookies() {
    Cookie bestCookies = cookies;
    if (clientCookies != null) {
        bestCookies = clientCookies;
    }
    return bestCookies;
}

private void writeObject(ObjectOutputStream out) throws IOException {
    out.writeObject(cookies.name());
    out.writeObject(cookies.value());
    out.writeLong(cookies.expiresAt());
    out.writeObject(cookies.domain());
    out.writeObject(cookies.path());
    out.writeBoolean(cookies.secure());
    out.writeBoolean(cookies.httpOnly());
    out.writeBoolean(cookies.hostOnly());
    out.writeBoolean(cookies.persistent());
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    String name = (String) in.readObject();
    String value = (String) in.readObject();
    long expiresAt = in.readLong();
    String domain = (String) in.readObject();
    String path = (String) in.readObject();
    boolean secure = in.readBoolean();
    boolean httpOnly = in.readBoolean();
    boolean hostOnly = in.readBoolean();
    boolean persistent = in.readBoolean();
    Cookie.Builder builder = new Cookie.Builder();
    builder = builder.name(name);
    builder = builder.value(value);
    builder = builder.expiresAt(expiresAt);
    builder = hostOnly ? builder.hostOnlyDomain(domain) : builder.domain(domain);
    builder = builder.path(path);
    builder = secure ? builder.secure() : builder;
    builder = httpOnly ? builder.httpOnly() : builder;
    clientCookies =builder.build();
}

}