安卓APP注册登录+Tomcat服务器搭建+MySQL数据库建立+加密传输+servlet后端内容编写及部署到Tomcat服务器

最新推荐文章于 2024-05-16 22:44:05 发布
最新推荐文章于 2024-05-16 22:44:05 发布
阅读量1.7w 收藏 75
点赞数 11
分类专栏： 安卓+后端 文章标签： android servlet mysql 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43449246/article/details/106612935
版权

认真学习安卓也有三四个月了，现在记录一下关于用户的各种操作。

1.安卓APP的实现：

先看一下展示动图吧！
在这里插入图片描述
首先是登录界面的xml---------activity_mian.xml
在这里插入图片描述

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_login"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    <!--
    登录页面
    -->
    <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:inputType="textPersonName"
        android:ems="10"
        android:hint="用户名"
        android:textColorHint="#003399"
        android:id="@+id/login_edit_account"
        android:textSize="20dp"
        android:textColor="#003399"
        android:layout_margin="10dp"/>
    <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:inputType="textPersonName"
        android:ems="10"
        android:hint="密码"
        android:textColorHint="#003399"
        android:id="@+id/login_edit_pwd"
        android:textSize="20dp"
        android:textColor="#003399"
        android:layout_margin="10dp"/>
    <Button
        android:text="登录"
        android:textSize="20dp"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/login_btn_login"
        android:layout_marginLeft="20dp"
        android:layout_marginRight="20dp"
        android:background="@color/lavender"/>
    <Button
        android:text="注册"
        android:textSize="20dp"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="5dp"
        android:id="@+id/register"
        android:layout_marginLeft="20dp"
        android:layout_marginRight="20dp"
        android:background="@color/lavender"/>
    <Button
        android:text="找回密码"
        android:textSize="20dp"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/forgetpassword"
        android:layout_marginTop="5dp"
        android:layout_marginLeft="20dp"
        android:layout_marginRight="20dp"
        android:background="@color/lavender"/>
</LinearLayout>

然后是Mainacticity.java

import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.text.method.PasswordTransformationMethod;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import com.android.volley.AuthFailureError;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;
//import com.example.administrator.loginclient.HttpsUtils.HTTPSTrustManager;
import com.example.administrator.loginclient.R;
import com.example.administrator.loginclient.RsaUtils.GenKeyFromString;
import com.example.administrator.loginclient.RsaUtils.MyConstant;
import com.example.administrator.loginclient.RsaUtils.RSAUtil;
import org.bouncycastle.util.encoders.Base64;
import org.json.JSONException;
import org.json.JSONObject;
import java.security.interfaces.RSAPublicKey;
import java.util.HashMap;
import java.util.Map;
/**
 * 登录
 */

public class MainActivity extends BaseActivity {
    public static RequestQueue queue;
    private static Context mContext;
    private static String afterencrypt;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        queue = Volley.newRequestQueue(getApplicationContext());
        mContext = this;
        final EditText AccountNumber = (EditText) findViewById(R.id.login_edit_account);//输入用户名
        final EditText Password = (EditText) findViewById(R.id.login_edit_pwd);//输入密码

        Password.setTransformationMethod(PasswordTransformationMethod.getInstance());//密码不可见
        Intent intent = getIntent();
        String username = intent.getStringExtra("username");
        String password = intent.getStringExtra("password");
        AccountNumber.setText(username);
        Password.setText(password);

        Button login = (Button) findViewById(R.id.login_btn_login);
        Button register = (Button) findViewById(R.id.register);
        Button forget_password = (Button) findViewById(R.id.forgetpassword);
        login.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                final String name = AccountNumber.getText().toString().trim();
                final String psw = Password.getText().toString().trim();
                //接下来是传输加密
                // 获取Rsa 工具类对象
                RSAUtil rsa = new RSAUtil();
                // 获取公钥
                RSAPublicKey pubKey = (RSAPublicKey) GenKeyFromString
                        .getPubKey(MyConstant.pubKey1);
                // 使用公钥加密 数据
                byte[] enRsaByte_psw = new byte[0];
                byte[] enRsaBytes_user = new byte[0];
                try {
                    enRsaByte_psw = rsa.encrypt(pubKey, psw.getBytes());//密码加密
                    enRsaBytes_user = rsa.encrypt(pubKey, name.getBytes());//用户名加密
                } catch (Exception e) {
                    e.printStackTrace();
                }
                /**
                 * base64对byte数组进行编码，进过编码后得到String传输到对服务端解码得出byte数组。
                 */
                String enRsaStr_psw = new String(Base64.encode(enRsaByte_psw));//密码byte数组转成字符串
                String enRsaStr_user = new String(Base64.encode(enRsaBytes_user));//用户名byte数组转成字符串
                LoginRequest(enRsaStr_user,enRsaStr_psw);//提交登录表单
                Toast.makeText(mContext, "请稍等...", Toast.LENGTH_SHORT).show();
            }
        });
        //注册
        register.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(MainActivity.this, RegisterActivity.class);
                startActivity(intent);
            }
        });
        //忘记密码
        forget_password.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(MainActivity.this, ForgetPswActivity.class);
                startActivity(intent);
            }
        });
    }
    public static void LoginRequest(final String accountNumber, final String password) {
        //请求地址
  
        String url = "http://localhost:8083/MyFirstWebAPP/LoginServlet";
        String tag = "Login";
        //取得请求队列l
        RequestQueue requestQueue = queue;
        //防止重复请求，所以先取消tag标识的请求队列
        requestQueue.cancelAll(tag);
     //   HTTPSTrustManager.allowAllSSL();//允许所有https请求
        //创建StringRequest，定义字符串请求的请求方式为POST(省略第一个参数会默认为GET方式)
        final StringRequest request = new StringRequest(Request.Method.POST, url,
                new Response.Listener<String>() {
                    @Override
                    public void onResponse(String response) {
                        try {
                            JSONObject jsonObject = (JSONObject) new JSONObject(response).get("params");
                            String result = jsonObject.getString("Result");
                            if (result.equals("TheUserDoesNotExist")) {
                                Toast.makeText(mContext, "账户不存在", Toast.LENGTH_LONG).show();
                            } else if (result.equals("PasswordError")) {
                                //做自己的登录失败操作，如Toast提示
                                Toast.makeText(mContext, "密码错误", Toast.LENGTH_LONG).show();
                            } else if (result.equals("CorrectPassword")) {
                                Toast.makeText(mContext, "登录成功", Toast.LENGTH_SHORT).show();
                                Intent intent = new Intent(mContext, LoginSuccessActivity.class);
                                intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);//关掉所要到的界面中间的activity
                                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                                mContext.startActivity(intent);
                            }
                        } catch (JSONException e) {
                            //做自己的请求异常操作，如Toast提示（“无网络连接”等）
                            Log.e("TAG", e.getMessage(), e);
                            Toast.makeText(mContext, "无网络连接", Toast.LENGTH_LONG).show();
                        }
                    }
                }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                //做自己的响应错误操作，如Toast提示（“请稍后重试”等）
                Log.e("TAG", error.getMessage(), error);
                Toast.makeText(mContext, "无网络连接", Toast.LENGTH_LONG).show();
            }
        }) {
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                Map<String, String> params = new HashMap<>();
                params.put("AccountNumber", accountNumber);
                params.put("Password", password);
                return params;
            }
        };
        //设置Tag标签
        request.setTag(tag);
        //将请求添加到队列中
        requestQueue.add(request);
    }
}

接下来是加密算法:GenKeyFromString.java,使用非对称混合加密算法

import java.io.IOException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import Decoder.BASE64Decoder;
import Decoder.BASE64Encoder;

/**
 * Key类型密钥 与 String类型密钥之间自由转换
 */
public class GenKeyFromString {

    /**
     * 根据字符串类型的公钥生成  公钥key
     * @param pubKey   字符串类型的公钥
     * @return 公钥
     */
    public static PublicKey getPubKey(String pubKey) {
        PublicKey publicKey = null;
        try {

            X509EncodedKeySpec bobPubKeySpec = new java.security.spec.X509EncodedKeySpec(
                    new BASE64Decoder().decodeBuffer(pubKey));
            // RSA对称加密算法
            java.security.KeyFactory keyFactory;
            keyFactory = java.security.KeyFactory.getInstance("RSA");
            // 取公钥匙对象
            publicKey = keyFactory.generatePublic(bobPubKeySpec);

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return publicKey;
    }

    /**
     * 根据String形式的私钥     生成私钥Key
     * @param priKey   字符串类型的私钥
     * @return
     */
    public static PrivateKey getPrivateKey(String priKey) {
        PrivateKey privateKey = null;
        PKCS8EncodedKeySpec priPKCS8 = null;
        try {
            priPKCS8 = new PKCS8EncodedKeySpec(
                    new BASE64Decoder().decodeBuffer(priKey));
            KeyFactory keyf = KeyFactory.getInstance("RSA");
            privateKey = keyf.generatePrivate(priPKCS8);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return privateKey;
    }

    /**
     * 根据Key转换成String类型
     *
     * @param key
     *            密钥Key (公或私钥)
     * @return 密钥Key的String类型
     */
    public static String getStringFromKey(Key key) {
        byte[] keyBytes = key.getEncoded();
        String key_String = (new BASE64Encoder()).encode(keyBytes);
        return key_String;
    }
}

密钥对：MyConstant.java

**
 *  字符串类型的密钥对
 * Created by Administrator on 2020/4/29.
 */

public class MyConstant {

    /**
     *  一对测试密钥   1:
     *  pubKey_String ---公钥
     *  pubKey_String ---私钥
     */
    public static final String pubKey_String = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVRiDkEKXy/KBTe+UmkA+feq1zGWIgBxkgbz7aBJGb5+eMKKoiDRoEHzlGndwFKm4mQWNftuMOfNcogzYpGKSEfC7sqfBPDHsGPZixMWzL3J10zkMTWo6MDIXKKqMG1Pgeq1wENfJjcYSU/enYSZkg3rFTOaBSFId+rrPjPo7Y4wIDAQAB";
    public static final String priKey_String = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAJVGIOQQpfL8oFN75SaQD596rXMZYiAHGSBvPtoEkZvn54woqiINGgQfOUad3AUqbiZBY1+24w581yiDNikYpIR8Luyp8E8MewY9mLExbMvcnXTOQxNajowMhcoqowbU+B6rXAQ18mNxhJT96dhJmSDesVM5oFIUh36us+M+jtjjAgMBAAECgYABtnxKIabF0wBD9Pf8KUsEmXPEDlaB55LyPFSMS+Ef2NlfUlgha+UQhwsxND6CEKqS5c0uG/se/2+4l0jXz+CTYBEh+USYB3gxcMKEo5XDFOGaM2Ncbc7FAKJIkYYN2DHmr4voSM5YkVibw5Lerw0kKdYyr0Xd0kmqTok3JLiLgQJBAOGZ1ao9oqWUzCKnpuTmXre8pZLmpWPhm6S1FU0vHjI0pZh/jusc8UXSRPnx1gLsgXq0ux30j968x/DmkESwxX8CQQCpY1+2p1aX2EzYO3UoTbBUTg7lCsopVNVf41xriek7XF1YyXOwEOSokp2SDQcRoKJ2PyPc2FJ/f54pigdsW0adAkAM8JTnydc9ZhZ7WmBhOrFuGnzoux/7ZaJWxSguoCg8OvbQk2hwJd3U4mWgbHWY/1XB4wHkivWBkhRpxd+6gOUjAkBH9qscS52zZzbGiwQsOk1Wk88qKdpXku4QDeUe3vmSuZwC85tNyu+KWrfM6/H74DYFbK/MzK7H8iz80uJye5jVAkAEqEB/LwlpXljFAxTID/SLZBb+bCIoV/kvg+2145F+CSSUjEWRhG/+OH0cQfqomfg36WrvHl0g/Xw06fg31HgK";

    /**
     *  测试密钥  2:
     *  pubKey_String ---公钥
     *  pubKey_String ---私钥
     */
    public static final String pubKey1 = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCokTtKtoiIT8/4dmC3qd0l6m5LWSKkZTeWHbTi7yZ0zHc3Y9PEdHu9LtdzVMJ6z+6kD09bY0lK31gVBBGDqC0pUum9ObqY6HRLHcoHqAT90bpL7+B1ufbLt3S8lJlhTXY9TL4i9i5mI43FrHKxR+c8OAJs0gILzd1x7K+KnQ1pBQIDAQAB";

    public static final String priKey1 = "MIIBNgIBADANBgkqhkiG9w0BAQEFAASCASAwggEcAgEAAoGBAKiRO0q2iIhPz/h2YLep3SXqbktZIqRlN5YdtOLvJnTMdzdj08R0e70u13NUwnrP7qQPT1tjSUrfWBUEEYOoLSlS6b05upjodEsdygeoBP3Rukvv4HW59su3dLyUmWFNdj1MviL2LmYjjcWscrFH5zw4AmzSAgvN3XHsr4qdDWkFAgEAAoGAaRXg+LrCcvgOlr51nQnwK+rxx1dSGVpgRN1QHwkn2Dh/ObCqHBbh7RZ+ig+VDisCgpRozHghAOQrbS6UHJeDTvRWQhvjSkPUKtzT5sVXdpFrQRhOBP2ucxGubZtYNUitm3ilObsT1YZf0OB+Ozs19FJidCgHS88tPsB/W+ukowECAQACAQACAQACAQACAQA=";

}

RSA工具类：RSAUtil.java

import java.io.ByteArrayOutputStream;
import java.math.BigInteger;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import javax.crypto.Cipher;

/**
 * RSA 工具类。
 * 提供加密，解密，生成密钥对等方法。
 * 需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。 RSA加密原理概述
 * RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数（大于100的十进制位）的函数。 据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积
 * =================================================================== *
 * 1.选择两个大素数 p,q ,计算 n=p*q; 2.随机选择加密密钥 e ,要求 e 和 (p-1)*(q-1)互质 3.利用 Euclid
 * 算法计算解密密钥 d , 使其满足 e*d = 1(mod(p-1)*(q-1)) (其中 n,d 也要互质) 4:至此得出公钥为 (n,e) 私钥为
 * (n,d) ===================================================================
 * 加解密方法： 1.首先将要加密的信息 m(二进制表示) 分成等长的数据块 m1,m2,...,mi 块长 s(尽可能大) ,其中 2^s<n
 * 2:对应的密文是： ci = mi^e(mod n) 3:解密时作如下计算： mi = ci^d(mod n)
 * =================================================================== RSA速度
 * 由于进行的都是大数计算，使得RSA最快的情况也比DES慢上100倍，无论 是软件还是硬件实现。 速度一直是RSA的缺陷。一般来说只用于少量数据 加密。
 *
 */
public class RSAUtil {

    /**
     * 密钥对
     */
    private KeyPair keyPair = null;

    /**
     * 初始化密钥对
     */
    public RSAUtil() {
        try {
            this.keyPair = this.generateKeyPair();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 生成密钥对
     *
     * @return KeyPair
     * @throws Exception
     */
    public KeyPair generateKeyPair() throws Exception {
        try {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());
            // 这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低
            final int KEY_SIZE = 1024;
            keyPairGen.initialize(KEY_SIZE, new SecureRandom());
            KeyPair keyPair = keyPairGen.genKeyPair();
            return keyPair;
        } catch (Exception e) {
            throw new Exception("生成密钥对失败");
        }

    }
    /**
     * 生成公钥
     *
     * @param modulus
     * @param publicExponent
     * @return RSAPublicKey
     * @throws Exception
     */
    private RSAPublicKey generateRSAPublicKey(byte[] modulus,
                                              byte[] publicExponent) throws Exception {

        KeyFactory keyFac = null;
        try {
            keyFac = KeyFactory.getInstance("RSA",
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());
        } catch (NoSuchAlgorithmException ex) {
            throw new Exception(ex.getMessage());
        }
        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(
                modulus), new BigInteger(publicExponent));
        try {
            return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);
        } catch (InvalidKeySpecException ex) {
            throw new Exception(ex.getMessage());
        }
    }
    /**
     * 生成私钥
     *
     * @param modulus
     * @param privateExponent
     * @return RSAPrivateKey
     * @throws Exception
     */
    public RSAPrivateKey generateRSAPrivateKey(byte[] modulus,
                                               byte[] privateExponent) throws Exception {
        KeyFactory keyFac = null;
        try {
            keyFac = KeyFactory.getInstance("RSA",
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());
        } catch (NoSuchAlgorithmException ex) {
            throw new Exception(ex.getMessage());
        }
        RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(
                modulus), new BigInteger(privateExponent));
        try {
            return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);
        } catch (InvalidKeySpecException ex) {
            throw new Exception(ex.getMessage());
        }
    }

    /**
     * 获取公钥
     *
     * @return
     * @throws Exception
     */
    public RSAPublicKey getRSAPublicKey() throws Exception {

        // 获取公钥
        RSAPublicKey pubKey = (RSAPublicKey) keyPair.getPublic();
        // 获取公钥系数(字节数组形式)
        byte[] pubModBytes = pubKey.getModulus().toByteArray();
        // 返回公钥公用指数(字节数组形式)
        byte[] pubPubExpBytes = pubKey.getPublicExponent().toByteArray();
        // 生成公钥
        RSAPublicKey recoveryPubKey = this.generateRSAPublicKey(pubModBytes,
                pubPubExpBytes);
        return recoveryPubKey;
    }

    /**
     * 获取私钥
     *
     * @return
     * @throws Exception
     */
    public RSAPrivateKey getRSAPrivateKey() throws Exception {

        // 获取私钥
        RSAPrivateKey priKey = (RSAPrivateKey) keyPair.getPrivate();

        // 返回私钥系数(字节数组形式)
        byte[] priModBytes = priKey.getModulus().toByteArray();
        // 返回私钥专用指数(字节数组形式)
        byte[] priPriExpBytes = priKey.getPrivateExponent().toByteArray();
        // 生成私钥
        RSAPrivateKey recoveryPriKey = this.generateRSAPrivateKey(priModBytes,
                priPriExpBytes);

        return recoveryPriKey;
    }

    /**
     * 加密
     *
     * @param key
     *            加密的密钥
     * @param data
     *            待加密的明文数据
     * @return 加密后的数据
     * @throws Exception
     */
    public byte[] encrypt(Key key, byte[] data) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance("RSA",
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());
            cipher.init(Cipher.ENCRYPT_MODE, key);
            // 获得加密块大小，如:加密前数据为128个byte，而key_size=1024 加密块大小为127
            // byte,加密后为128个byte;
            // 因此共有2个加密块，第一个127 byte第二个为1个byte
            int blockSize = cipher.getBlockSize();
            int outputSize = cipher.getOutputSize(data.length);// 获得加密块加密后块大小
            int leavedSize = data.length % blockSize;
            int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
                    : data.length / blockSize;
            byte[] raw = new byte[outputSize * blocksSize];
            int i = 0;
            while (data.length - i * blockSize > 0) {
                if (data.length - i * blockSize > blockSize)
                    cipher.doFinal(data, i * blockSize, blockSize, raw, i
                            * outputSize);
                else
                    cipher.doFinal(data, i * blockSize, data.length - i
                            * blockSize, raw, i * outputSize);
                // 这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到ByteArrayOutputStream中
                // ，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了OutputSize所以只好用dofinal方法。
                i++;
            }
            return raw;
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }
    /**
     * 解密
     *
     * @param key
     *            解密的密钥
     * @param raw
     *            已经加密的数据
     * @return 解密后的明文
     * @throws Exception
     */
    public byte[] decrypt(Key key, byte[] raw) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance("RSA",
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());
            cipher.init(cipher.DECRYPT_MODE, key);
            int blockSize = cipher.getBlockSize();
            ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
            int j = 0;
            while (raw.length - j * blockSize > 0) {
                bout.write(cipher.doFinal(raw, j * blockSize, blockSize));
                j++;
            }
            return bout.toByteArray();
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

}

用到的依赖包：

 implementation files('libs/sun.misc.BASE64Decoder.jar')
 implementation 'com.android.volley:volley:1.1.1'

2.Tomcat服务器搭建：

下载xampp并安装，选择安装，网上有很多教程的，这个算是傻瓜式安装

在这里插入图片描述
建立数据库：要先下载数据化库可视化软件------MySQL-Front在这里插入图片描述
安装完之后打开，点击new
在这里插入图片描述
server填localhost，port填3306
在这里插入图片描述
点击OK，进入这个界面：
在这里插入图片描述
由于已经存在这个相同名称数据了，所以我的OK点击不了
在这里插入图片描述
建好myfirstapp之后，建user表
在这里插入图片描述
在user表新建field--------UserName
在这里插入图片描述
Password和Email的建立方式和UserName的一模一样。这里就不做重复了。
在这里插入图片描述
双击user，点击 Data Browser
在这里插入图片描述
数据库到此就建完啦！

3.Servlet后端的编写：

我是用netbeans编写的，网上有安装教程的。
注意项目名称要和URL的一致， String url = “http://localhost:8083/MyFirstWebAPP/LoginServlet”;
我的项目名称是MyFirstWebAPP。以下是新建web项目的示范操作！
在这里插入图片描述
接下来新建web.xml
在这里插入图片描述
然后在项目里新建一个文件夹lib,以导入外部jar包 提取码：yoa9
在这里插入图片描述
添加jar包依赖
在这里插入图片描述
接下来是建包写代码啦！
在这里插入图片描述
撸代码啦-----------------------------------
在包里新建java类，DBManager.java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.ResultSet;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

/**
 * 数据库管理类，提供连接数据库和拆解链接功能
 *
 */
public class DBManager extends HttpServlet {

    ServletConfig config;                             //定义一个ServletConfig对象
    private static String username;                   //定义的数据库用户名
    private static String password;                   //定义的数据库连接密码
    private static String url;                        //定义数据库连接URL
    private static Connection connection;             //定义连接

    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);                                  //继承父类的init()方法
        this.config = config;                                //获取配置信息
        username = config.getInitParameter("DBUsername");    //获取数据库用户名
        password = config.getInitParameter("DBPassword");    //获取数据库连接密码
        url = config.getInitParameter("ConnectionURL");      //获取数据库连接URL
      
    }

    /**
     * 获得数据库连接对象
     *
     * @return 数据库连接对象
     */
    public static Connection getConnection() {
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            connection = DriverManager.getConnection(url, username, password);
        } catch (ClassNotFoundException | InstantiationException
                | IllegalAccessException | SQLException ex) {
            Logger.getLogger(DBManager.class.getName()).log(Level.SEVERE, null, ex);
        }
        return connection;
    }
    /**
     * 关闭所有的数据库连接资源
     *
     * @param connection Connection 链接
     * @param statement Statement 资源
     * @param resultSet ResultSet 结果集合
     */
    public static void closeAll(Connection connection, Statement statement,
            ResultSet resultSet) {
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            Logger.getLogger(DBManager.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    
     public static void closeTwo(Connection connection, Statement statement) {
        try {
          
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException ex) {
            Logger.getLogger(DBManager.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

User.java

/**
 *
 * @author Administrator
 */
public class User {

    //用户姓名
    private String userName;

    //用户密码
    private String password;
      
    //用户邮箱，用于找回密码、修改密码
    private String email;
    private String loadtimes;
    //用户烧录总次数
    private String loadtimesAll;
    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
    public String getEmail(){
        return email;
    }
    
    public void setEmail(String email){
        this.email=email;
    }
     
}

UserDAO.java

/**
 *
 * @author Administrator
 */
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;

public class UserDAO {
    /**
     * 查询给定用户名的用户的详细信息
     *
     */
    public static Boolean hasemail=false;
    
    public static User queryUser(String userName) {
        //获得数据库的连接对象
        Connection connection = DBManager.getConnection();
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        //生成SQL代码
        StringBuilder sqlStatement = new StringBuilder();
        sqlStatement.append("SELECT * FROM user WHERE UserName=?");

        //设置数据库的字段值
        try {
            preparedStatement = connection.prepareStatement(sqlStatement.toString());
            preparedStatement.setString(1, userName);
            
            resultSet = preparedStatement.executeQuery();
            User user = new User();
            if (resultSet.next()) {
                user.setUserName(resultSet.getString("UserName"));
                user.setPassword(resultSet.getString("Password"));
                return user;
            } else {
                return null;
            }
        } catch (SQLException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        } finally {
            DBManager.closeAll(connection, preparedStatement, resultSet);
        }
    }
  
    /**
     * 注册用户
     *
     * @param userName 给定的用户名
     * @param password
     * @param email
     * @return 
     */
    
      public static Boolean registerUser(String userName,String password,String email){
 
            Boolean flag=false; 
           
           if(!UserDAO.checkUserName(userName)){
               return false;//判断该用户是否存在，若存在，函数返回false
           }
           else if(!UserDAO.checkEmail(email)){
                hasemail=true; //邮箱被注册过
               return false;   //邮箱未被注册
           }
            
                    //获得数据库的连接对象
        Connection connection = DBManager.getConnection();
        PreparedStatement preparedStatement = null;
       
            //生成SQL代码
        StringBuilder sqlStatement = new StringBuilder();
        sqlStatement.append("INSERT INTO user(UserName,Password,Email) VALUES(?,?,?)");
         //设置数据库的字段值
        try {
            preparedStatement = connection.prepareStatement(sqlStatement.toString());
            
               preparedStatement.setString(1, userName);
               preparedStatement.setString(2, password);
                preparedStatement.setString(3, email);
               int row = preparedStatement.executeUpdate(); 
               
            if(row>0){
                    flag=true;
                }
            else {
                return null;
            }
              
        } catch (SQLException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        } finally {
            DBManager.closeTwo(connection, preparedStatement);
           
        }
        return flag;
        }
     /*
      *查询用户是否存在
      *@param userName 给定的用户名
      *
      */
      
      public static Boolean checkUserName(String userName) {
      Connection connection = DBManager.getConnection();
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        //生成SQL代码
        StringBuilder sqlStatement = new StringBuilder();
        sqlStatement.append("SELECT * FROM user WHERE UserName=?");

        try {
             preparedStatement = connection.prepareStatement(sqlStatement.toString());
            preparedStatement.setString(1, userName);
             resultSet = preparedStatement.executeQuery();
              User user = new User();
           
            if (resultSet.next() == true) {
              
               return false;//用户已存在
              
            } else {
                
                return true;//该用户可用
            }
        } catch (SQLException ex) {
             Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        }
        return true;
    }
      
       /*
      *查询邮箱是否存在
      *@param email 给定的用户名
      *
      *
      */
       public static Boolean checkEmail(String email) {
      Connection connection = DBManager.getConnection();
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        //生成SQL代码
        StringBuilder sqlStatement = new StringBuilder();
        sqlStatement.append("SELECT * FROM user WHERE Email=?");

        try {
             preparedStatement = connection.prepareStatement(sqlStatement.toString());
            preparedStatement.setString(1, email);
             resultSet = preparedStatement.executeQuery();
             User user = new User();
           
            if (resultSet.next() == true) {
               return false;//该邮箱已被注册过
            } else {
                
                return true;//该邮箱可用
            }
        } catch (SQLException ex) {
             Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
        }
        return true;
    }
        /**
     * 验证用户名邮箱是否对应
     *
     * @param userName
     * @return 
     * 
     */
        public static User queryEmail(String userName) {
        //获得数据库的连接对象
        Connection connection = DBManager.getConnection();
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        //生成SQL代码
        StringBuilder sqlStatement = new StringBuilder();
        sqlStatement.append("SELECT * FROM user WHERE UserName=?");

        //设置数据库的字段值
        try {
            preparedStatement = connection.prepareStatement(sqlStatement.toString());
            preparedStatement.setString(1, userName);
            
            resultSet = preparedStatement.executeQuery();
            User user = new User();
            if (resultSet.next()) {
                user.setUserName(resultSet.getString("UserName"));
                user.setEmail(resultSet.getString("Email"));
                return user;
            } else {
                return null;
            }
        } catch (SQLException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        } finally {
            DBManager.closeAll(connection, preparedStatement, resultSet);
        }
    }
        /**
         * 通过邮箱查询密码
         * @param email
         * @return 
         */
        public static User queryPasswordByEmail(String email) {
        //获得数据库的连接对象
        Connection connection = DBManager.getConnection();
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        //生成SQL代码
        StringBuilder sqlStatement = new StringBuilder();
        sqlStatement.append("SELECT * FROM user WHERE Email=?");

        //设置数据库的字段值
        try {
            preparedStatement = connection.prepareStatement(sqlStatement.toString());
            preparedStatement.setString(1, email);
            
            resultSet = preparedStatement.executeQuery();
            User user = new User();
            if (resultSet.next()) {
                 user.setEmail(resultSet.getString("Email"));
                  user.setPassword(resultSet.getString("Password"));
                return user;
            } else {
                return null;
            }
        } catch (SQLException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        } finally {
            DBManager.closeAll(connection, preparedStatement, resultSet);
        }
    }
          /**
         * 通过用户查询邮箱
         * @param email
         * @return 
         */
        public static User queryUserByEmail(String email) {
        //获得数据库的连接对象
        Connection connection = DBManager.getConnection();
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        //生成SQL代码
        StringBuilder sqlStatement = new StringBuilder();
        sqlStatement.append("SELECT * FROM user WHERE Email=?");

        //设置数据库的字段值
        try {
            preparedStatement = connection.prepareStatement(sqlStatement.toString());
            preparedStatement.setString(1, email);
            
            resultSet = preparedStatement.executeQuery();
            User user = new User();
            if (resultSet.next()) {
                 user.setEmail(resultSet.getString("Email"));
                 user.setUserName(resultSet.getString("UserName"));
                  user.setPassword(resultSet.getString("Password"));
                return user;
            } else {
                return null;
            }
        } catch (SQLException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        } finally {
            DBManager.closeAll(connection, preparedStatement, resultSet);
        }
    }
        /**
         * 更新密码
         * 
         * @param password
         * @param email
         * @return 
         */
        public static Boolean updatePassword(String password,String email){

            
            //获得数据库的连接对象
        Connection connection = DBManager.getConnection();
        PreparedStatement preparedStatement = null;
       
            //生成SQL代码
        StringBuilder sqlStatement = new StringBuilder();
        sqlStatement.append("UPDATE  user SET Password =? WHERE Email=?");
         //设置数据库的字段值
        try {
               preparedStatement = connection.prepareStatement(sqlStatement.toString());
            
               preparedStatement.setString(1, password);
               preparedStatement.setString(2, email);
                
               int row = preparedStatement.executeUpdate(); 
               
            if(row>0){
                   return true;
                }
            else {
                return null;
            }
              
        } catch (SQLException ex) {
            Logger.getLogger(UserDAO.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        } finally {
            DBManager.closeTwo(connection, preparedStatement);
           
        }
     
        }                                              
}


  接下来是LoginServlet.java，这里要注意，选择的是servlet而不是java！我这里只是示范如何建servlet

在这里插入图片描述

import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import net.sf.json.JSONObject;
import java.security.interfaces.RSAPrivateKey;
import net.jw.MyFirstWebAPP.RSAutil.GenKeyFromString;
import net.jw.MyFirstWebAPP.RSAutil.MyConstant;
import net.jw.MyFirstWebAPP.RSAutil.RSAUtil;
import net.jw.MyFirstWebAPP.User;
import net.jw.MyFirstWebAPP.UserDAO;
import org.bouncycastle.util.encoders.Base64;
/**
 * 登录验证Servlet
 *
 * @author Administrator
 */
public class LoginServlet extends HttpServlet {
    private static int verifyResult;
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 设置响应内容类型  
        response.setContentType("text/html;charset=utf-8");
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");

        try (PrintWriter out = response.getWriter()) {

            //获得请求中传来的用户名和密码
            String accountNumber = request.getParameter("AccountNumber").trim();
            String password = request.getParameter("Password").trim();//加密后的密码
          
            byte[] bytereuser = Base64.decode(accountNumber);//用户名解密BASE64
            byte[] byterepsw = Base64.decode(password);//密码解密BASE64
          //  System.out.println(byteres);
           // System.out.println("字符串转成byte数组:"+new String(byteres));
             // 获取私钥	
            RSAUtil rsa = new RSAUtil();
            RSAPrivateKey priKey = (RSAPrivateKey) GenKeyFromString
				.getPrivateKey(MyConstant.priKey1);
             // 拿着私钥解用户名
            byte[] encRsaByteuser = rsa.decrypt(priKey,
				bytereuser);
            // 拿着私钥解密码
            byte[] encRsaBytepsw = rsa.decrypt(priKey,
				byterepsw);
          //  System.out.println("解密后==" + new String(encRsaBytes));
          
            //验证登录操作
            verifyResult = verifyLogin(new String(encRsaByteuser),new String(encRsaBytepsw));
           
            Map<String, String> params = new HashMap<>();
            JSONObject jsonObject = new JSONObject();

            if (verifyResult == -1) {
                params.put("Result", "TheUserDoesNotExist");//用户不存在
            } 
            else if (verifyResult == 0){
                params.put("Result", "PasswordError");//密码错误
            }
            else if(verifyResult == 1){
                params.put("Result","CorrectPassword");//密码正确
            }
            jsonObject.put("params", params);
            out.write(jsonObject.toString());
        } catch (Exception ex) {
         
            Logger.getLogger(LoginServlet.class.getName()).log(Level.SEVERE, null, ex);
           
        }
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doPost(request, response);
    }

    /**
     * 验证用户名密码是否正确
     *
     * @param userName
     * @param password
     */
    private int verifyLogin(String userName, String password) {
        User user = UserDAO.queryUser(userName);
        
           boolean hasUser = false;
           boolean rightPass = false;
        //账户密码验证
        if(!UserDAO.checkUserName(userName)){
            hasUser = true;
            if(user.getPassword().equals(password)){
                rightPass = true;
            }
        }
       if(!hasUser) return -1;//无该用户
        else if(!rightPass) return 0;//有该用户，但是密码输入错误
        return 1;//有该用户，且密码输入正确
      
    }    
}


  还有修改web.xml，如果包名和我的不同，记得修改成自己的。请仔细阅读web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
 
    <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>net.jw.MyFirstWebAPP.ServletPackage.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/LoginServlet</url-pattern>
    </servlet-mapping>

    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <servlet>
        <servlet-name>DBManager</servlet-name>
        <!-- 下面这行是DBManager这个类的定位，“包名”替换为你在前面创建的包名，区分大小写 -->
        <servlet-class>net.jw.MyFirstWebAPP.DBManager</servlet-class>
        <init-param>
            <param-name>DBUsername</param-name>
            <!-- 这里是数据库用户名，一般情况下是root，无需改变 -->
            <param-value>root</param-value>
        </init-param>
        <init-param>
            <param-name>DBPassword</param-name>
            <!-- 下面这两个标签中间写你的数据库密码，如果没设置就什么也别写，空格也不能有 -->
            <param-value/>
        </init-param>
        <init-param>
            <param-name>ConnectionURL</param-name>
            <!-- myfirstapp数据库的名字 -->
            <param-value>jdbc:mysql://localhost:3306/myfirstapp?characterEncoding=utf8</param-value>
        </init-param>
        <!-- 下面这行很重要，指示服务器在启动时立即加载这个Servlet -->
        <load-on-startup>0</load-on-startup>
    </servlet>
</web-app>

好了，web项目到此就写完啦！最后把项目部署到Tomcat上！
在这里插入图片描述
修改Tomcat的servlet.xml，把端口号8080改成8083。
最后，在xampp的Tomcat点击start就可以测试APP啦！
需要注意的是，servlet如果有以下包导入错误：

import net.jw.MyFirstWebAPP.RSAutil.GenKeyFromString;
import net.jw.MyFirstWebAPP.RSAutil.MyConstant;
import net.jw.MyFirstWebAPP.RSAutil.RSAUtil;

就在项目里加上这三个类的代码即可，代码和上面的安卓端的是一模一样的。

参考文章：https://blog.csdn.net/Mr_Megamind/article/details/71404618

一粒程序米
关注
  • 11
    点赞
  • 踩
  • 75
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 28
    评论
专栏目录
安卓app开发-----服务器端开发
weixin_30724853的博客
05-19 1957
　　首先允许我稍微介绍一下我们的团队背景，我们是一群研究生，互相认可，然后就准备合作做一款安卓app，具体app内容不方便透露，但就我的任务来说，是从事后台开发相关的工作。服务器端的技术其实在搞这个项目之前，我接触过的，就是WINSERVER+IIS+SQLSERVER+.NET，也就是微软那一套。相对于LAMP（linux+apache+mysql+php）或者其他的来说，我对微软比较熟悉，之前...
servlet开发-通过Tomcat部署一个简单的webapp
q322359的博客
09-20 1755
servlet开发-通过Tomcat部署一个简单的webapp
基于springboot+vue+Mysql的大学生心理健康管理系统
最新发布
老卓爱爪哇 的博客
05-16 1001
大学生心理健康管理系统分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理通知信息以及通知的租赁信息，能够与用户进行相互交流等操作，用户可以查看试卷信息，可以查看通知以及查看管理员回复信息等操作。 大学生心理健康管理系统采用的是WEB应用程序开发中最受欢迎的B/S三层结构模式，使用占用空间小但功能齐全的MySQL数据库进行数据的存储操作，系统开发技术使用到了JSP技术。该大学生心理健康管理系统能够解决许多传统手工操作的难题，比如数据查询耽误时间长，数据管理步骤繁琐等问题。总的来说，大学生
Android+Tomcat+MySql登录注册和Socket聊天
07-01
Android+Tomcat+MySql实现远程登录注册以及Socket通信聊天，界面有点类似微信，不过没有太注重界面 提供给大家做个参考
php实时通讯app,以php开发服务器后台的android即时通讯app的一种实现思路
weixin_32476639的博客
03-17 159
作为一名初学者错误疏漏之处在所难免，恳请各位批评指正。即时通讯一般采用TCP/IP协议或者UDP协议进行通信，这两种都涉及终端ip地址的确定，对于PC而言ip地址是容易确定的，但对于android手机端ip地址不容易确定，上述两种协议不太合适。可以使用http协议进行通信，每位用户向服务器发送请求，请求中包含相关信息：如果是一个用户发出消息，这个http请求中应该包含请求的类型(发送消息)消息的发...
【uni-app】使用uni-app实现简单的登录注册功能
SqlloveSyn的博客
06-11 1万+
大家好，今天和大家分享一下如何在uni-app中实现简单的登录注册功能。首先你需要掌握一下知识点：1.网络请求 uni.request2.页面跳转，页面传参 uni.navigateTo3.本地缓存 uni.setStorageSync, uni.getStorageSync我们要使用到登录和注册接口，所以要知道如何进行网络请求。因为还需要进行注册，所以要进行跳转页面，跳转到注册页面所以要使用到页面跳转。
大神们，本人想自己闲余时间开发一个自己的APP，怎么搭建服务器。
xibingting8938的博客
01-01 4880
需要买服务器的空间吗？ 服务器的空间带数据库吗？ 服务器那端怎么部署比较好？
Android搭建本地Tomcat服务器及相关配置
08-30
主要介绍了Android搭建本地Tomcat服务器及相关配置，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于ZigBee+ESP32+MQTT+EMQX+TomCat+Servlet接口+MySQL+安卓app的物联网课设.zip
04-19
MySQL 是一款广受欢迎的开源关系型数据库管理系统（RDBMS），由瑞典MySQL AB公司开发，现隶属于美国甲骨文公司（Oracle）。自1998年首次发布以来，MySQL以其卓越的性能、可靠性和可扩展性，成为全球范围内Web应用...
Tomcat+MySQL为自己的APP打造服务器（4）完结篇Demo
03-05
在本教程中，我们将深入探讨如何使用Tomcat作为应用服务器，与MySQL数据库配合，为自己的Android应用程序构建一个功能完备的后端服务器。这个"Tomcat+MySQL为自己的APP打造服务器（4）完结篇Demo"提供了从客户端...
Android studio 购物系统 and Servlet技术实现后端服务端
奇奇怪怪的Android code的博客
06-25 585
Android 大作业,商城购物系统 and Servlet技术实现后端服务端
快速搭建移动App服务器
01-27
快速搭建移动App服务器
Android学习之完整的注册登录Demo（APP端+服务器端）
Nicholas_hzf的博客
04-23 7059
因比赛或者项目需要，写了几个小打小闹的APP。有的处于“单机”状态，有的处于“半联网”状态，觉得学习有点操之过急，所以先缓一缓，梳理一下之前所学的知识，将之前做的一些小玩意儿，整理出来写成博客。第一篇便是大部分APP都具有的注册登录系统。 一、问题描述 完成简单的注册与登录功能。 二、需求分析 在APP端有注册与登录两个显示界面：点击注册，将用户填写的信息存储到数据库当中；点击登录，查询服务器数据...
安卓Android电子商城/购物商城app源码 【包远程调试有文档】
m0_37916936的博客
11-18 296
1. 登录注册、记住密码、自动登录；3. 商品分类展示、讨论功能、商家简介；4. 添加购物车、下单、付款；5. 订单列表及订单内容；6. 账户充值功能；7. 展示、修改个人信息；8. 数据库设计，使用Android自带数据库sqlite；可从下面链接下载APP安装到手机试用。
搭建自己的服务器，Android端实现登陆注册
qq_41123185的博客
08-22 3219
搭建自己的服务器，Android端实现登陆注册 本文将介绍如何搭建属于自己的服务器，以供android、web等开发的使用。并不会涉及到各种工具的安装与配置，但会记录所遇到的各种Bug,请开始一起踩坑！ 所需工具： 工欲善其事必先利其器,先准备好以下工具。 IntelliJ IDEA：创建web项目 (社区版不可以创建) Android Studio : Android 项目开发 MySq...
基于Android Studio如何实现 购物商城 案例（简单易上手）
热门推荐
编程乐学的博客
12-15 1万+
Android studio期末设计大作业~购物商城App①启动页②.用户登录/注册功能③主页面功能- 顶部轮播图功能- 搜索功能- 商品目录- 商品列表-点击商品列表进入详情页④ 购物车功能- 商品数量的增加减少- 商品支付购买⑤ 我的页面- 修改用户密码⑥详情页面- 显示商品详情信息启动页：应用启动时显示的欢迎页面。用户登录/注册功能：用户可以通过输入用户名和密码进行登录或注册新账户。顶部轮播图功能：展示热门商品或促销活动的轮播图。
安卓项目：基于Android的跳蚤市场-二手商城app
QQ2083558048的博客
09-13 286
随着对跳蚤市场 的要求和对其的管理水平的提高，跳蚤市场的潜能将会得到无穷无尽的拓展，跳蚤市场APP受到了行业的高度重视，本文对该站点以及对其进行了全面的剖析，为跳蚤市场信息管理的发展带来了借鉴。跳蚤市场APP对于跳蚤市场起到了很好的引导作用，特别是对于地方跳蚤市场的处理起到了很大的作用。按照已有的功能，除了管理员外，还可以对系统中的全部资料进行管理；此外， APP还需要：首页，商品信息，朋友圈，我的等功能的协同管理。实现功能：用户管理：登陆、注册、注销、修改密码、上传头像、修改资料。
Java-Servlet技术实现服务端，Android(安卓)平台作为客户端，实现一个个人店铺【个人蛋糕店】
程序员象漂亮的博客
06-25 660
使用Servlet技术实现服务端，使用Android平台作为客户端，实现一个个人店铺，店铺商品不限。功能要求如下：1. 提供登录、注册功能；（10分） 2. 首页面包括“商品列表”子页面、“订单”子页面和“我的”子页面；（20分） 3. 在商品列表页点击某个商品列表项可跳转到该商品的详情页面，在商品详情页面可以实现加入购物车和购买操作；商品数据来自于服务端；（20分） 4. 订单页显示个人的订单历史记录
Android APP 登录 注册 SAE 部署 - [0]
mengwei2275的博客
05-30 421
如果你需要一个自己使用的APP登录和注册的Android demo。 使用的是JAVA Web发布APP需要的信息 JAVA Web获取APP的请求信息后查询外部数据库Mysql，并返回结果。 APP通过Http client获取发布的信息 进行登录或者注册操作 请往下看，不然出门右转：www.baidu.com 等着你。
在android中创建数据库
03-26
在Android中创建数据库可以使用SQLite。下面是创建一个SQLite数据库的步骤： 1. 创建一个继承自SQLiteOpenHelper的类 ```java public class MyDatabaseHelper extends SQLiteOpenHelper { private static final String DATABASE_NAME = "MyDatabase.db"; private static final int DATABASE_VERSION = 1; private static final String TABLE_NAME = "Users"; private static final String COLUMN_ID = "id"; private static final String COLUMN_NAME = "name"; private static final String COLUMN_EMAIL = "email"; public MyDatabaseHelper(Context context) { super(context, DATABASE_NAME, null, DATABASE_VERSION); } @Override public void onCreate(SQLiteDatabase db) { // 创建表格 String createTableQuery = "CREATE TABLE " + TABLE_NAME + " (" + COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + COLUMN_NAME + " TEXT, " + COLUMN_EMAIL + " TEXT" + ")"; db.execSQL(createTableQuery); } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // 删除表格并重新创建 String deleteTableQuery = "DROP TABLE IF EXISTS " + TABLE_NAME; db.execSQL(deleteTableQuery); onCreate(db); } } ``` 2. 在需要创建数据库的地方实例化该类 ```java MyDatabaseHelper dbHelper = new MyDatabaseHelper(context); ``` 3. 获取可写入的数据库对象 ```java SQLiteDatabase db = dbHelper.getWritableDatabase(); ``` 4. 插入数据 ```java ContentValues contentValues = new ContentValues(); contentValues.put(MyDatabaseHelper.COLUMN_NAME, "John"); contentValues.put(MyDatabaseHelper.COLUMN_EMAIL, "john@example.com"); long rowId = db.insert(MyDatabaseHelper.TABLE_NAME, null, contentValues); ``` 5. 查询数据 ```java String[] projection = { MyDatabaseHelper.COLUMN_ID, MyDatabaseHelper.COLUMN_NAME, MyDatabaseHelper.COLUMN_EMAIL }; String selection = MyDatabaseHelper.COLUMN_NAME + " = ?"; String[] selectionArgs = {"John"}; Cursor cursor = db.query( MyDatabaseHelper.TABLE_NAME, projection, selection, selectionArgs, null, null, null ); while (cursor.moveToNext()) { long id = cursor.getLong(cursor.getColumnIndexOrThrow(MyDatabaseHelper.COLUMN_ID)); String name = cursor.getString(cursor.getColumnIndexOrThrow(MyDatabaseHelper.COLUMN_NAME)); String email = cursor.getString(cursor.getColumnIndexOrThrow(MyDatabaseHelper.COLUMN_EMAIL)); // Do something with the data } cursor.close(); ``` 6. 关闭数据库连接 ```java db.close(); ``` 以上是使用SQLite创建数据库的基本步骤。在实际使用中可能还需要进行一些其他的操作，如更新数据、删除数据等。
评论 28
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一粒程序米

你的鼓励是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值