找不到从方法android java.lang.NoClassDefFoundError引用的类

我正在调用一个单独的类，我在保存我的

MainActivity

类的同一个包中编写了这个类。但是当我运行应用程序时，它会给我

java.lang.NoClassDefFoundError

。我不明白为什么在同一个包中定义的另一个类不能被识别。我尝试了许多方法，但没有一个解决了这个错误

08-26 10:43:27.776: E/dalvikvm(1311): Could not find class 'com.example.hcpandroid.SSLAuthenticate$1', referenced from method com.example.hcpandroid SSLAuthenticate.authenticate
08-26 10:43:27.786: E/AndroidRuntime(1311): FATAL EXCEPTION: main
08-26 10:43:27.786: E/AndroidRuntime(1311): java.lang.NoClassDefFoundError: com.example.hcpandroid.SSLAuthenticate$1
08-26 10:43:27.786: E/AndroidRuntime(1311):     at com.example.hcpandroid.SSLAuthenticate.authenticate(SSLAuthenticate.java:86)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at com.example.hcpandroid.LogIn.LogIn(LogIn.java:48)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at com.example.hcpandroid.LogIn$1.onClick(LogIn.java:29)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at android.view.View.performClick(View.java:4128)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at android.view.View$PerformClick.run(View.java:17142)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at android.os.Handler.handleCallback(Handler.java:615)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at android.os.Handler.dispatchMessage(Handler.java:92)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at android.os.Looper.loop(Looper.java:213)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at android.app.ActivityThread.main(ActivityThread.java:4787)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at java.lang.reflect.Method.invokeNative(Native Method)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at java.lang.reflect.Method.invoke(Method.java:511)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:809)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:576)
08-26 10:43:27.786: E/AndroidRuntime(1311):     at dalvik.system.NativeStart.main(Native Method)

主要活动类别：

package com.example.hcpandroid;

import com.example.hcpandroid.R.id;

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import com.example.hcpandroid.SSLAuthenticate;

public class LogIn extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_log_in);

        Button btnLogIn = (Button) findViewById(id.btnLogIn);

        btnLogIn.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                LogIn();
            }
        });
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.log_in, menu);
        return true;
    }

    public void LogIn(){

        EditText txtUname = (EditText) findViewById(id.txtUsername);
        EditText txtPword = (EditText) findViewById(id.txtPassword);

        SSLAuthenticate ssl = new SSLAuthenticate(txtUname.getText().toString(), txtPword.getText().toString());

        int authCode = ssl.authenticate();

        Toast toast= Toast.makeText(getApplicationContext(), authCode, Toast.LENGTH_LONG);
        toast.show();
    }

}

SSLAuthentication类：

package com.example.hcpandroid;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.io.IOException;
import java.math.BigInteger;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import net.sf.json.JSON;
import net.sf.json.JSONSerializer;
import net.sf.json.xml.XMLSerializer;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.params.ClientPNames;
import org.apache.http.client.params.CookiePolicy;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.json.simple.JSONValue;
import sun.misc.BASE64Encoder;

/**
 * @author sajithru
 */
public class SSLAuthenticate {

    private String username;
    private String password;
    private DefaultHttpClient httpClient;
    private String cookie;

    public SSLAuthenticate(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public SSLAuthenticate() {
    }

    public DefaultHttpClient getHttpClient() {
        return httpClient;
    }

    public String getCookie() {
        return cookie;
    }

    public String getUsername() {
        return username;
    }

    public int authenticate() {

        HttpResponse responce = null;
        try {
            //Authenticate SSL Certification
            TrustStrategy easyStrategy = new TrustStrategy() {
                @Override
                public boolean isTrusted(X509Certificate[] chain, String authType)
                        throws CertificateException {
                    // eh, why not?
                    return true;
                }
            };

            SchemeRegistry schemeRegistry = new SchemeRegistry();
            SSLContext sslcontext = SSLContext.getInstance("TLS");
            sslcontext.init(null, null, null);
            SSLSocketFactory ssf = new SSLSocketFactory((KeyStore) easyStrategy);
            ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

            Scheme httpsScheme = new Scheme("https", ssf, 443);
            schemeRegistry.register(httpsScheme);

            TrustManager trustMgr = new TrustManager() {
            };
            sslcontext.init(null, new TrustManager[]{trustMgr}, null);

            HttpParams params = new BasicHttpParams();
            ClientConnectionManager connMgr = new ThreadSafeClientConnManager(params, schemeRegistry);
            httpClient = new DefaultHttpClient(connMgr, params);

            //Encode username into BASE64 encode format
            BASE64Encoder base64Encoder = new BASE64Encoder();
            String uname64 = base64Encoder.encode(username.getBytes());

            //Encode password into MD5 Hash encode format
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            messageDigest.update(password.getBytes(), 0, password.length());
            String md5Password = new BigInteger(1, messageDigest.digest()).toString(16);

            //Set HTTPS request header- Authentication
            cookie = "hcp-ns-auth=" + uname64 + ":" + md5Password;
            System.out.println("Username: " + username + " Password: " + password);
            System.out.println(cookie);

            responce = adminAuth(cookie, httpClient);       

        } catch (NoSuchAlgorithmException ex) {
            Logger.getLogger(SSLAuthenticate.class.getName()).log(Level.SEVERE, null, ex);
        } catch (KeyManagementException ex) {
            Logger.getLogger(SSLAuthenticate.class.getName()).log(Level.SEVERE, null, ex);
        } catch (KeyStoreException ex) {
            Logger.getLogger(SSLAuthenticate.class.getName()).log(Level.SEVERE, null, ex);
        } catch (UnrecoverableKeyException ex) {
            Logger.getLogger(SSLAuthenticate.class.getName()).log(Level.SEVERE, null, ex);
        }

        int responceCode = responce.getStatusLine().getStatusCode();

        return responceCode;
    }

    private HttpResponse adminAuth(String cookie, HttpClient hClient) {

        HttpResponse response = null;
        try {
            //Creating HTTP Post object
            String url = "https://millennium-test.hcp.millenniumit.com/query";
            //String url = "https://hitachi.hcp1.hdspoc.com/query";
            HttpPost httpPost = new HttpPost(url);
            httpPost.getParams().setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.BROWSER_COMPATIBILITY);
            //Setting HTTP Post headers for Authentication, Request type, Respond type and Encode type
            httpPost.addHeader("Cookie", cookie);
            httpPost.addHeader("Content-Type", "application/xml");
            httpPost.addHeader("Accept", "application/json");
            //httpPost.addHeader("Content-Encoding", "gzip");
            //httpPost.addHeader("Accept-Encoding", "gzip");

            Map<String, String> obj = new LinkedHashMap<String, String>();
            obj.put("query", "+(namespace:\"data-set1.Millennium-Test\")");
            obj.put("contentProperties", "false");
            obj.put("objectProperties", "shred,retention");
            obj.put("sort", "changeTimeMilliseconds+asc");
            String jsonText = "{\"object\" :" + JSONValue.toJSONString(obj) + "}";
            System.out.println(jsonText);

            XMLSerializer serializer = new XMLSerializer();
            JSON json = JSONSerializer.toJSON(jsonText);
            serializer.setRootName("queryRequest");
            serializer.setTypeHintsEnabled(false);
            String xml = serializer.write(json);

            xml = xml.replaceAll("\\<\\?xml(.+?)\\?\\>", "").trim();
            System.out.println(xml);

            StringEntity stringEntity = new StringEntity(xml, HTTP.UTF_8);
            httpPost.setEntity(stringEntity);
            response = hClient.execute(httpPost);
            System.out.println(response.toString());

            String sJson = EntityUtils.toString(response.getEntity());
            System.out.println(sJson);

            HCP_Logger myLogger = new HCP_Logger();
            myLogger.writeToLog(username, xml, response.toString());

        } catch (IOException ex) {
            Logger.getLogger(SSLAuthenticate.class.getName()).log(Level.SEVERE, null, ex);
        }

        return response;
    }

    private HttpResponse tenantAuth(String cookie, HttpClient hClient) {

        HttpResponse response = null;
        try {
            //Creating HTTP Post object
            String url = "sample url";
            //String url = "sample url";
            HttpPost httpPost = new HttpPost(url);
            httpPost.getParams().setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.BROWSER_COMPATIBILITY);
            //Setting HTTP Post headers for Authentication, Request type, Respond type and Encode type
            httpPost.addHeader("Cookie", cookie);
            httpPost.addHeader("Content-Type", "application/xml");
            httpPost.addHeader("Accept", "application/json");
            //httpPost.addHeader("Content-Encoding", "gzip");
            //httpPost.addHeader("Accept-Encoding", "gzip");

            Map obj = new LinkedHashMap();
            obj.put("query", "+(namespace:\"sample")");
            obj.put("contentProperties", "false");
            obj.put("objectProperties", "shred,retention");
            obj.put("sort", "changeTimeMilliseconds+asc");
            String jsonText = "{\"object\" :" + JSONValue.toJSONString(obj) + "}";
            //System.out.println(jsonText);

            XMLSerializer serializer = new XMLSerializer();
            JSON json = JSONSerializer.toJSON(jsonText);
            serializer.setRootName("queryRequest");
            serializer.setTypeHintsEnabled(false);
            String xml = serializer.write(json);

            xml = xml.replaceAll("\\<\\?xml(.+?)\\?\\>", "").trim();
            //System.out.println(xml);

            //String xmll = "<queryRequest><object><query>namespace:\"data-set1.Millennium-Test\"</query><objectProperties>shred,retention</objectProperties><sort>changeTimeMilliseconds+asc</sort></object></queryRequest>";
            //System.out.println(xmll); 

            StringEntity stringEntity = new StringEntity(xml, HTTP.UTF_8);
            httpPost.setEntity(stringEntity);

            response = hClient.execute(httpPost);
            //System.out.println(response.toString());

//            String sJson = EntityUtils.toString(response.getEntity());
            //System.out.println(sJson);

//            HCP_Logger myLogger = new HCP_Logger();
//            myLogger.writeToLog(username, xml, response.toString());

        } catch (IOException ex) {
            Logger.getLogger(SSLAuthenticate.class.getName()).log(Level.SEVERE, null, ex);
        }

        return response;
    }
}

package com.example.hcpandroid；
/*
*要更改此模板，请选择工具|模板
*然后在编辑器中打开模板。
*/
导入java.io.IOException；
导入java.math.biginger；
导入java.security.KeyManagementException；
导入java.security.KeyStore；
导入java.security.KeyStoreException；
导入java.security.MessageDigest；
导入java.security.NoSuchAlgorithmException；
导入java.security.UnrecoverableKeyException；
导入java.security.cert.CertificateException；
导入java.security.cert.x509证书；
导入java.util.LinkedHashMap；
导入java.util.Map；
导入java.util.logging.Level；
导入java.util.logging.Logger；
导入javax.net.ssl.SSLContext；
导入javax.net.ssl.TrustManager；
导入net.sf.json.json；
导入net.sf.json.JSONSerializer；
导入net.sf.json.xml.XMLSerializer；
导入org.apache.http.HttpResponse；
导入org.apache.http.client.HttpClient；
导入org.apache.http.client.methods.HttpPost；
导入org.apache.http.client.params.ClientPNames；
导入org.apache.http.client.params.CookiePolicy；
导入org.apache.http.conn.ClientConnectionManager；
导入org.apache.http.conn.scheme.scheme；
导入org.apache.http.conn.scheme.SchemeRegistry；
导入org.apache.http.conn.ssl.SSLSocketFactory；
导入org.apache.http.conn.ssl.TrustStrategy；
导入org.apache.http.entity.StringEntity；
导入org.apache.http.impl.client.DefaultHttpClient；
导入org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager；
导入org.apache.http.params.BasicHttpParams；
导入org.apache.http.params.HttpParams；
导入org.apache.http.protocol.http；
导入org.apache.http.util.EntityUtils；
导入org.json.simple.JSONValue；
导入sun.misc.base64编码器；
/**
*@作者sajithru
*/
公共类SSLAuthenticate{
私有字符串用户名；
私有字符串密码；
私有默认httpClient httpClient；
私有字符串cookie；
公共SSLAuthenticate（字符串用户名、字符串密码）{
this.username=用户名；
this.password=密码；
}
公共SSLAuthenticate（）{
}
公共默认HttpClient getHttpClient（）{
返回httpClient；
}
公共字符串getCookie（）{
返回cookie；
}
公共字符串getUsername（）{
返回用户名；
}
公共int身份验证（）{
HttpResponse response=null；
试一试{
//验证SSL证书
信任策略easyStrategy=新信任策略（）{
@凌驾
已信任公共布尔值（X509Certificate[]链，字符串authType）
抛出证书异常{
//呃，为什么不呢？
返回true；
}
};
SchemeRegistry SchemeRegistry=新SchemeRegistry（）；
SSLContext SSLContext=SSLContext.getInstance（“TLS”）；
init（null，null，null）；
SSLSocketFactory ssf=新的SSLSocketFactory（（密钥库）easyStrategy）；
ssf.setHostnameVerifier（SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER）；
方案httpsScheme=新方案（“https”，ssf，443）；
注册（httpsScheme）；
TrustManager trustMgr=新的TrustManager（）{
};
init（null，新信任管理器[]{trustMgr}，null）；
HttpParams params=新的BasicHttpParams（）；
ClientConnectionManager connMgr=new-ThreadSafeClientConnManager（参数，schemeRegistry）；
httpClient=新的默认httpClient（connMgr，params）；
//将用户名编码为BASE64编码格式
BASE64Encoder BASE64Encoder=新的BASE64Encoder（）；
字符串uname64=base64Encoder.encode（username.getBytes（））；
//将密码编码为MD5哈希编码格式
MessageDigest=MessageDigest.getInstance（“MD5”）；
update（password.getBytes（），0，password.length（））；
字符串md5Password=new biginger（1，messageDigest.digest（））.toString（16）；
//设置HTTPS请求头-身份验证
cookie=“hcp ns auth=“+uname64+”：“+MD5密码；
System.out.println（“用户名：“+Username+”密码：“+Password”）；
System.out.println（cookie）；
response=adminAuth（cookie，httpClient）；
}捕获（nosuchalgorithmex异常）{
Logger.getLogger（SSLAuthenticate.class.getName（））.log（Level.SEVERE，null，ex）；
}catch（KeyManagementException-ex）{
Logger.getLogger（SSLAuthenticate.class.getName（））.log（Level.SEVERE，null，ex）；
}catch（KeyStoreException ex）{
Logger.getLogger（SSLAuthenticate.class.getName（））.log（Level.SEVERE，null，ex）；
}捕获（不可恢复的KeyException ex）{
Logger.getLogger（SSLAuthenticate.class.getName（））.log（Level.SEVERE，null，ex）；
}
int responceCode=responce.getStatusLine（）.getStatusCode（）；
返回响应代码；
}
私有HttpResponse adminAuth（字符串cookie，HttpClient hClient）{
HttpResponse响应=null；
试一试{
//创建HTTP Post对象
字符串url=”https://millennium-test.hcp.millenniumit.com/query";
//字符串url=”https://hitachi.hcp1.hdspoc.com/query";
HttpPost HttpPost=新的HttpPost（url）；
httpPost.getParams（）.setParameter（ClientPNames.COOKIE_策略，CookiePolic
 project -> Build Path -> Configure Build Path -> Order and Export Tab.