Android开发常用功能 https://www.2cto.com/kf/201611/561847.html

最新推荐文章于 2021-05-26 19:19:30 发布

getan525

最新推荐文章于 2021-05-26 19:19:30 发布

阅读量790

点赞数

Android开发常用功能

2016-11-03 09:43:58 来源：EvanJames的专栏

收藏我要投稿

1.定时器的实现

(1)采用Handler的postDelayed(Runnable, long)方法

<strong>Handler handler = new Handler();

Runnable runnable = new Runnable() {

@Override

public void run() {

//你要做的事

//......

System.out.println(Thread.currentThread().getName());

handler.postDelayed(runnable, 1000);

}

};</strong>

public final booleanpostDelayed(Runnabler, long delayMillis)Added inAPI level 1

Causes the Runnable r to be added to the message queue, to be run after the specified amount of time elapses. The runnable will be run on the thread to which this handler is attached.The time-base isuptimeMillis().Time spent in deep sleep will add an additional delay to execution.

后调用handler.post(runnable);就能启动定时器,这里是每隔1s打印线程名字，从打印中我们可以知道,他并没有另开线程，而是运行在UI线程当中，当你要取消定时器的时候，只需要调用handler.removeCallbacks(runnable)就可以了。

上面中有一个问题，有时候你会发现removeCallbacks有时候会失效，不能从消息队列中移除，看下面的demo

图：两个按钮，一个将Runnable加到消息队列中，一个将Runnable从消息队列中移除。该Runnable每1秒钟打印一次日志。

public class TimerActivity extends Activity{

Handler handler = new Handler();

Runnable runnable = new Runnable() {

@Override

public void run() {

System.out.println("update...");

handler.postDelayed(runnable, 1000);

}

};

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.timer);

Button mButtonStart = (Button) findViewById(R.id.button1);

Button mButtonStop = (Button) findViewById(R.id.button2);

mButtonStart.setOnClickListener(new OnClickListener() {

@Override

public void onClick(View v) {

handler.post(runnable);

}

});

mButtonStop.setOnClickListener(new OnClickListener() {

@Override

public void onClick(View v) {

handler.removeCallbacks(runnable);

}

});

}

结果：
（1）start –> 输出 –> stop–> 停止输出
（2）start –> 输出 –> Background –> Front –> stop->继续输出

当Activity进入后台运行后再转入前台运行，removeCallbacks无法将updateThread从message queue中移除。
这是为什么呢？
在Activity由前台转后台过程中，线程是一直在运行的，但是当Activity转入前台时会重新定义Runnable runnable；也就是说此时从message queue移除的runnable与原先加入message queue中的runnable并非是同一个对象。如果把runnable定义为静态的则removeCallbacks不会失效,对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配,我们做如下修改就能解决上面的这个问题.

static Handler handler = new Handler();

static Runnable runnable = new Runnable() {

@Override

public void run() {

System.out.println("update...");

handler.postDelayed(runnable, 1000);

}

};

(2)采用Handler与timer及TimerTask结合的方法。

1.定义定时器、定时器任务及Handler句柄

private final Timer timer = new Timer();

private TimerTask task;

Handler handler = new Handler() {

@Override

public void handleMessage(Message msg) {

// TODO Auto-generated method stub

//要做的事情

super.handleMessage(msg);

}

};

2.初始化定时器任务。

task=new TimerTask() {

@Override

public void run () {

// TODO Auto-generated method stub

Message message = new Message();

message.what = 1;

handler.sendMessage(message);

}

};

3.启动定时器

1	`timer.schedule(task,` `2000,` `2000);`

简要说一下上面三步提到的一些内容。
1.定时器任务（TimerTask）顾名思义，就是说当定时器到达指定的时间时要做的工作，这里是想Handler发送一个消息，由Handler类进行处理。
2. java.util.Timer.schedule(TimerTask task, long delay):这个方法是说，dalay/1000秒后执行task.只执行一次。
java.util.Timer.schedule(TimerTask task, long delay, long period)：这个方法是说，delay/1000秒后执行task,然后进过period/1000秒再次执行task，这个用于循环任务，执行无数次，当然，你可以用timer.cancel();取消定时器的执行。

(3)采用Handle与线程的sleep(long )方法

1.定义一个Handler类，用于处理接受到的Message

Handler handler = new Handler() {

public void handleMessage(Message msg) {

super.handleMessage(msg);

System.out.println("update...");

}

2.新建一个实现Runnable接口的线程类，用一个boolean 来控制线程开始和结束 boolean isLive = true如下：

public class MyThread implements Runnable {

@Override

public void run() {

while (isLive) {

try {

Thread.sleep(1000);// 线程暂停1秒，单位毫秒

Message message = new Message();

message.what = 1;

handler.sendMessage(message);// 发送消息

} catch (InterruptedException e) {

e.printStackTrace();

}

3.在需要启动线程的地方加入下面语句

1	`new` `Thread(new` `MyThread()).start();`

4.取消的话将isLive设置为false就行了

2.Android延时操作

下面是三种方法：

跟上面的定时操作异曲同工

一、线程

new Thread(new Runnable(){

public void run(){

Thread.sleep(XXXX);

handler.sendMessage();----告诉主线程执行任务

}

}).start

二、延时器

TimerTask task = new TimerTask(){

public void run(){

//execute the task

}

};

Timer timer = new Timer();

timer.schedule(task, delay);

三、android消息处理

new Handler().postDelayed(new Runnable(){

public void run() {

//execute the task

}

}, delay);

3.数据加密

参考：

android 隐私数据加密方法

Facebook推出用于android数据加密的开源API

Java常用的加密方法

Android应用安全开发之浅谈加密算法的坑

为了确保数据传输和数据存储的安全，我们可以通过特定的算法，将数据明文加密成复杂的密文。
众多的加密手段大致可以分为单项加密和双向加密。单向加密指通过对数据进行摘要计算生成密文，密文不可逆推还原，比如有Base64、MD5、SHA等；双向加密则相反，指可以把密文逆推还原成明文，其中双向加密又分为对称加密和非对称加密。对称加密是指数据使用者必须拥有同样的密钥才可以进行加密解密，就像大家共同约定了一组暗号一样，对称加密的手段有DES、3DES、AES、IDEA、RC4、RC5等；而非对称加密相对于对称加密而言，无需拥有同一组密钥，它是一种“信息公开的密钥交换协议”。非对称加密需要公开密钥和私有密钥两组密钥，公开密钥和私有密钥是配对起来的，也就是说使用公开密钥进行数据加密，只有对应的私有密钥才能进行解密。此类的加密手段有RSA、DSA等。

【密码学常用术语】
明文：未加密的数据
密文：明文经过加密后的数据
加密：将明文转换为密文的过程
解密：将密文转换为明文的过程
加密算法：将明文转换为密文的转换算法
解密算法：将密文转换为明文的转换算法
加密密钥：用于加密算法进行加密操作的密钥
解密密钥：用于解密算法进行解密操作的密钥

单向加密(信息摘要)

Java一般需要获取对象MessageDigest来实现单项加密(信息摘要)。
1.MD5

即Message-Digest Algorithm 5（信息-摘要算法 5），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD5实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD5的前身有MD2、MD3和MD4。MD5的作用是让大容量信息在用数字签名软件签署私人密钥前被"压缩"成一种保密的格式（就是把一个任意长度的字节串变换成一定长的十六进制数字串）。
除了MD5以外，其中比较有名的还有sha-1、RIPEMD以及Haval等

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

public class EncrypMD5 {

public byte[] eccrypt(String info) throws NoSuchAlgorithmException{

//根据MD5算法生成MessageDigest对象

MessageDigest md5 = MessageDigest.getInstance("MD5");

byte[] srcBytes = info.getBytes();

//使用srcBytes更新摘要

md5.update(srcBytes);

//完成哈希计算，得到result

byte[] resultBytes = md5.digest();

return resultBytes;

}

public static void main(String args[]) throws NoSuchAlgorithmException{

String msg = "郭XX-精品相声技术";

EncrypMD5 md5 = new EncrypMD5();

byte[] resultBytes = md5.eccrypt(msg);

System.out.println("密文是：" + new String(resultBytes));

System.out.println("明文是：" + msg);

}

2.SHA

是一种数据加密算法，该算法经过加密专家多年来的发展和改进已日益完善，现在已成为公认的最安全的散列算法之一，并被广泛使用。该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。散列函数值可以说时对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

public class EncrypSHA {

public byte[] eccrypt(String info) throws NoSuchAlgorithmException{

MessageDigest md5 = MessageDigest.getInstance("SHA");

byte[] srcBytes = info.getBytes();

//使用srcBytes更新摘要

md5.update(srcBytes);

//完成哈希计算，得到result

byte[] resultBytes = md5.digest();

return resultBytes;

}

/**

* @param args

* @throws NoSuchAlgorithmException

*/

public static void main(String[] args) throws NoSuchAlgorithmException {

String msg = "郭XX-精品相声技术";

EncrypSHA sha = new EncrypSHA();

byte[] resultBytes = sha.eccrypt(msg);

System.out.println("明文是：" + msg);

System.out.println("密文是：" + new String(resultBytes));

}

双向加密

(一)、对称加密

采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。需要对加密和解密使用相同密钥的加密算法。由于其速度，对称性加密通常在消息发送方需要加密大量数据时使用。

对称性加密也称为密钥加密。所谓对称，就是采用这种加密方法的双方使用方式用同样的密钥进行加密和解密。密钥是控制加密及解密过程的指令。

算法是一组规则，规定如何进行加密和解密。因此对称式加密本身不是安全的。
常用的对称加密有：DES、IDEA、RC2、RC4、SKIPJACK、RC5、AES算法等

对称加密一般java类中中定义成员

Java代码

//KeyGenerator 提供对称密钥生成器的功能，支持各种算法

private KeyGenerator keygen;

//SecretKey 负责保存对称密钥

private SecretKey deskey;

//Cipher负责完成加密或解密工作

private Cipher c;

//该字节数组负责保存加密的结果

private byte[] cipherByte;

在构造函数中初始化

Java代码

1.Security.addProvider(new com.sun.crypto.provider.SunJCE());

2.//实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)

3.keygen = KeyGenerator.getInstance("DES");//

4.//生成密钥

5.deskey = keygen.generateKey();

6.//生成Cipher对象,指定其支持的DES算法

7.c = Cipher.getInstance("DES");

1.DES算法为密码体制中的对称密码体制，又被成为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。明文按64位进行分组, 密钥长64位，密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位，使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

Java代码

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import java.security.Security;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.KeyGenerator;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.SecretKey;

public class EncrypDES {

//KeyGenerator 提供对称密钥生成器的功能，支持各种算法

private KeyGenerator keygen;

//SecretKey 负责保存对称密钥

private SecretKey deskey;

//Cipher负责完成加密或解密工作

private Cipher c;

//该字节数组负责保存加密的结果

private byte[] cipherByte;

public EncrypDES() throws NoSuchAlgorithmException, NoSuchPaddingException{

Security.addProvider(new com.sun.crypto.provider.SunJCE());

//实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)

keygen = KeyGenerator.getInstance("DES");

//生成密钥

deskey = keygen.generateKey();

//生成Cipher对象,指定其支持的DES算法

c = Cipher.getInstance("DES");

}

/**

* 对字符串加密

*

* @param str

* @return

* @throws InvalidKeyException

* @throws IllegalBlockSizeException

* @throws BadPaddingException

*/

public byte[] Encrytor(String str) throws InvalidKeyException,

IllegalBlockSizeException, BadPaddingException {

// 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式

c.init(Cipher.ENCRYPT_MODE, deskey);

byte[] src = str.getBytes();

// 加密，结果保存进cipherByte

cipherByte = c.doFinal(src);

return cipherByte;

}

/**

* 对字符串解密

*

* @param buff

* @return

* @throws InvalidKeyException

* @throws IllegalBlockSizeException

* @throws BadPaddingException

*/

public byte[] Decryptor(byte[] buff) throws InvalidKeyException,

IllegalBlockSizeException, BadPaddingException {

// 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式

c.init(Cipher.DECRYPT_MODE, deskey);

cipherByte = c.doFinal(buff);

return cipherByte;

}

/**

* @param args

* @throws NoSuchPaddingException

* @throws NoSuchAlgorithmException

* @throws BadPaddingException

* @throws IllegalBlockSizeException

* @throws InvalidKeyException

*/

public static void main(String[] args) throws Exception {

EncrypDES de1 = new EncrypDES();

String msg ="郭XX-搞笑相声全集";

byte[] encontent = de1.Encrytor(msg);

byte[] decontent = de1.Decryptor(encontent);

System.out.println("明文是:" + msg);

System.out.println("加密后:" + new String(encontent));

System.out.println("解密后:" + new String(decontent));

}

2.3DES

3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES指定为过渡的加密标准），是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法，其具体实现如下：
设Ek()和Dk()代表DES算法的加密和解密过程，K代表DES算法使用的密钥，P代表明文，C代表密文，
这样，　　
3DES加密过程为：C=Ek3(Dk2(Ek1(P)))
3DES解密过程为：P=Dk1((EK2(Dk3(C)))

又称Triple DES，是DES加密算法的一种模式，它使用3条56位的密钥对3DES 数据进行三次加密。数据加密标准（DES）是美国的一种由来已久的加密标准，它使用对称密钥加密法，并于1981年被ANSI组织规范为ANSI X.3.92。DES使用56位密钥和密码块的方法，而在密码块的方法中，文本被分成64位大小的文本块然后再进行加密。比起最初的DES，3DES更为安全。　　

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import java.security.Security;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.KeyGenerator;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.SecretKey;

public class EncrypDES3 {

// KeyGenerator 提供对称密钥生成器的功能，支持各种算法

private KeyGenerator keygen;

// SecretKey 负责保存对称密钥

private SecretKey deskey;

// Cipher负责完成加密或解密工作

private Cipher c;

// 该字节数组负责保存加密的结果

private byte[] cipherByte;

public EncrypDES3() throws NoSuchAlgorithmException, NoSuchPaddingException {

Security.addProvider(new com.sun.crypto.provider.SunJCE());

// 实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)

keygen = KeyGenerator.getInstance("DESede");

// 生成密钥

deskey = keygen.generateKey();

// 生成Cipher对象,指定其支持的DES算法

c = Cipher.getInstance("DESede");

}

/**

* 对字符串加密

*

* @param str

* @return

* @throws InvalidKeyException

* @throws IllegalBlockSizeException

* @throws BadPaddingException

*/

public byte[] Encrytor(String str) throws InvalidKeyException,

IllegalBlockSizeException, BadPaddingException {

// 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式

c.init(Cipher.ENCRYPT_MODE, deskey);

byte[] src = str.getBytes();

// 加密，结果保存进cipherByte

cipherByte = c.doFinal(src);

return cipherByte;

}

/**

* 对字符串解密

*

* @param buff

* @return

* @throws InvalidKeyException

* @throws IllegalBlockSizeException

* @throws BadPaddingException

*/

public byte[] Decryptor(byte[] buff) throws InvalidKeyException,

IllegalBlockSizeException, BadPaddingException {

// 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式

c.init(Cipher.DECRYPT_MODE, deskey);

cipherByte = c.doFinal(buff);

return cipherByte;

}

/**

* @param args

* @throws NoSuchPaddingException

* @throws NoSuchAlgorithmException

* @throws BadPaddingException

* @throws IllegalBlockSizeException

* @throws InvalidKeyException

*/

public static void main(String[] args) throws Exception {

EncrypDES3 des = new EncrypDES3();

String msg ="郭XX-搞笑相声全集";

byte[] encontent = des.Encrytor(msg);

byte[] decontent = des.Decryptor(encontent);

System.out.println("明文是:" + msg);

System.out.println("加密后:" + new String(encontent));

System.out.println("解密后:" + new String(decontent));

}

3.AES

密码学中的高级加密标准（Advanced Encryption Standard，AES），又称高级加密标准 Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。　　

该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计，结合两位作者的名字，以Rijndael之命名之，投稿高级加密标准的甄选流程。（Rijdael的发音近于 "Rhinedoll"。）

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import java.security.Security;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.KeyGenerator;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.SecretKey;

public class EncrypAES {

//KeyGenerator 提供对称密钥生成器的功能，支持各种算法

private KeyGenerator keygen;

//SecretKey 负责保存对称密钥

private SecretKey deskey;

//Cipher负责完成加密或解密工作

private Cipher c;

//该字节数组负责保存加密的结果

private byte[] cipherByte;

public EncrypAES() throws NoSuchAlgorithmException, NoSuchPaddingException{

Security.addProvider(new com.sun.crypto.provider.SunJCE());

//实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)

keygen = KeyGenerator.getInstance("AES");

//生成密钥

deskey = keygen.generateKey();

//生成Cipher对象,指定其支持的DES算法

c = Cipher.getInstance("AES");

}

/**

* 对字符串加密

*

* @param str

* @return

* @throws InvalidKeyException

* @throws IllegalBlockSizeException

* @throws BadPaddingException

*/

public byte[] Encrytor(String str) throws InvalidKeyException,

IllegalBlockSizeException, BadPaddingException {

// 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式

c.init(Cipher.ENCRYPT_MODE, deskey);

byte[] src = str.getBytes();

// 加密，结果保存进cipherByte

cipherByte = c.doFinal(src);

return cipherByte;

}

/**

* 对字符串解密

*

* @param buff

* @return

* @throws InvalidKeyException

* @throws IllegalBlockSizeException

* @throws BadPaddingException

*/

public byte[] Decryptor(byte[] buff) throws InvalidKeyException,

IllegalBlockSizeException, BadPaddingException {

// 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式

c.init(Cipher.DECRYPT_MODE, deskey);

cipherByte = c.doFinal(buff);

return cipherByte;

}

/**

* @param args

* @throws NoSuchPaddingException

* @throws NoSuchAlgorithmException

* @throws BadPaddingException

* @throws IllegalBlockSizeException

* @throws InvalidKeyException

*/

public static void main(String[] args) throws Exception {

EncrypAES de1 = new EncrypAES();

String msg ="郭XX-搞笑相声全集";

byte[] encontent = de1.Encrytor(msg);

byte[] decontent = de1.Decryptor(encontent);

System.out.println("明文是:" + msg);

System.out.println("加密后:" + new String(encontent));

System.out.println("解密后:" + new String(decontent));

}

(二)、非对称加密

1976年，美国学者Dime和Henman为解决信息公开传送和密钥管理问题，提出一种新的密钥交换协议，允许在不安全的媒体上的通讯双方交换信息，安全地达成一致的密钥，这就是“公开密钥系统”。相对于“对称加密算法”这种方法也叫做“非对称加密算法”。与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

1.RSA

公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在（美国麻省理工学院）开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准。RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

import java.security.InvalidKeyException;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

public class EncrypRSA {

/**

* 加密

* @param publicKey

* @param srcBytes

* @return

* @throws NoSuchAlgorithmException

* @throws NoSuchPaddingException

* @throws InvalidKeyException

* @throws IllegalBlockSizeException

* @throws BadPaddingException

*/

protected byte[] encrypt(RSAPublicKey publicKey,byte[] srcBytes) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{

if(publicKey!=null){

//Cipher负责完成加密或解密工作，基于RSA

Cipher cipher = Cipher.getInstance("RSA");

//根据公钥，对Cipher对象进行初始化

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

byte[] resultBytes = cipher.doFinal(srcBytes);

return resultBytes;

}

return null;

}

/**

* 解密

* @param privateKey

* @param srcBytes

* @return

* @throws NoSuchAlgorithmException

* @throws NoSuchPaddingException

* @throws InvalidKeyException

* @throws IllegalBlockSizeException

* @throws BadPaddingException

*/

protected byte[] decrypt(RSAPrivateKey privateKey,byte[] srcBytes) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{

if(privateKey!=null){

//Cipher负责完成加密或解密工作，基于RSA

Cipher cipher = Cipher.getInstance("RSA");

//根据公钥，对Cipher对象进行初始化

cipher.init(Cipher.DECRYPT_MODE, privateKey);

byte[] resultBytes = cipher.doFinal(srcBytes);

return resultBytes;

}

return null;

}

/**

* @param args

* @throws NoSuchAlgorithmException

* @throws BadPaddingException

* @throws IllegalBlockSizeException

* @throws NoSuchPaddingException

* @throws InvalidKeyException

*/

public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {

EncrypRSA rsa = new EncrypRSA();

String msg = "郭XX-精品相声";

//KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象

KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");

//初始化密钥对生成器，密钥大小为1024位

keyPairGen.initialize(1024);

//生成一个密钥对，保存在keyPair中

KeyPair keyPair = keyPairGen.generateKeyPair();

//得到私钥

RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();

//得到公钥

RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();

//用公钥加密

byte[] srcBytes = msg.getBytes();

byte[] resultBytes = rsa.encrypt(publicKey, srcBytes);

//用私钥解密

byte[] decBytes = rsa.decrypt(privateKey, resultBytes);

System.out.println("明文是:" + msg);

System.out.println("加密后是:" + new String(resultBytes));

System.out.println("解密后是:" + new String(decBytes));

}

2.DSA

Digital Signature Algorithm (DSA)是Schnorr和ElGamal签名算法的变种，被美国NIST作为DSS(DigitalSignature Standard)。(感觉有点复杂，没有附代码)
详见http://63938525.iteye.com/blog/1051565

参考：
android 隐私数据加密方法
 Facebook推出用于android数据加密的开源API
Java常用的加密方法
 Android应用安全开发之浅谈加密算法的坑

4.设置圆角按钮和边框

圆角的按钮实现扁平化的UI很有美感，但是实现起来也不算太难。

在res目录下的drawable-mdpi建立xml文件shape.xml,如下图所示：

Shapeone.xml(圆角)

<shape android:shape="rectangle" xmlns:android="http://schemas.android.com/apk/res/android">

<solid android:color="#FFFFFF">

<corners android:radius="5dip">

<padding android:bottom="10dp" android:left="10dp" android:right="10dp" android:top="10dp">

</padding></corners></solid></shape>

Shapetwo.xml (边框)

1	`<!--?xml version="1.0" encoding="utf-8"?-->`

2.在要设置边框的控件xml命令里加入：android：background=“@drawable/boder”

main.xml

在android:background="@drawable/shape"就使用了shape.xml资源

<linearlayout android:layout_height="fill_parent" android:layout_width="fill_parent" android:orientation="vertical" xmlns:android="http://schemas.android.com/apk/res/android">

<textview android:layout_height="wrap_content" android:layout_width="fill_parent" android:text="@string/hello"><button android:background="@drawable/shape" android:id="@+id/roundButton" android:layout_height="wrap_content" android:layout_width="wrap_content" android:text=" 圆角按钮 "></button></textview></linearlayout>

strings.xml

<resources>

<string name="hello">Hello World, RoundButtonDemoActivity!</string>

<string name="app_name">RoundButtonDemo</string>

</resources>

5.android studio 设备调试及Logcat查看

现在android的开发工具基本上都改用android studio而慢慢弃用eclipse了，那么android studio的调试设备该怎么设置和查看程序的Logcat呢？

首先点击项目上方app右边的小箭头，然后选择"Edit Configurations..."，如下图：

然后选择

Show chooser dialog : 弹出窗口，可选择真机调试或虚拟机调试。

Use same device for futrue launches ：选中的话，当下次调试时，会使用之前相同的调试方式。

USB device : 使用真机调试。

Emulator : 使用虚拟机调试。

Prefer Android Virtual Device : 可选择已经存在的虚拟机，点击右边"..." 弹出AVD Manager（要在选择Emulator后才可点击）。

当程序运行后，我们需要在调试的时候查看Logcat的信息，点击android studio 底部的Android按钮，会弹出一个调试的窗口。

在Device栏中，可以看到当前连接的可调试的设备，有时候设备连接USB后，并没有显示出来，这个时候可以在这里查看。

当需要查看程序运行的Logcat时，可以点击窗口右上角的android图标，程序运行的信息都在这里。

Android 中的日志工具类是 Log（android.util.Log），这个类中提供了如下几个方法来供我们打印日志。

1. Log.v()这个方法用于打印那些最为琐碎的，意义最小的日志信息。对应级别 verbose，是 Android日志里面级别最低的一种。

2. Log.d()这个方法用于打印一些调试信息，这些信息对你调试程序和分析问题应该是有帮助的。对应级别 debug，比 verbose高一级。

3. Log.i()这个方法用于打印一些比较重要的数据，这些数据应该是你非常想看到的，可以帮你分析用户行为的那种。对应级别 info，比 debug高一级。

4. Log.w()这个方法用于打印一些警告信息，提示程序在这个地方可能会有潜在的风险，最好去修复一下这些出现警告的地方。对应级别 warn，比 info高一级。

5. Log.e()这个方法用于打印程序中的错误信息，比如程序进入到了 catch语句当中。当有错误信息打印出来的时候，一般都代表你的程序出现严重问题了，必须尽快修复。

对应级别 error，比 warn高一级。其实很简单，一共就五个方法，当然每个方法还会有不同的重载，但那对你来说肯定不是什么难理解的地方了。我们现在就在 HelloWorld项目中试一试日志工具好不好用吧。打开 HelloWorldActivity，在 onCreate()方法中添加一行打印日志的语句，如下所示：

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.hello_world_layout);

Log.d("HelloWorldActivity", "onCreate execute");

}

Log.d方法中传入了两个参数，第一个参数是 tag，一般传入当前的类名就好，主要用于对打印信息进行过滤。第二个参数是 msg，即想要打印的具体的内容.

6.双击退出程序

通过计算时间差实现

这里是通过控制时间差来实现功能的，在首次按下返回键时，将会将当期时间赋值给mPressedTime并通过Toast提示用户，在第二次按下返回键时，如果与 mPressedTime记录的时间差值大于2秒则重新刷新mPressedTime的时间，如果小于2秒则执行else的语句退出程序。

private long mPressedTime = 0;

@Override

public void onBackPressed() {

long mNowTime = System.currentTimeMillis();//获取第一次按键时间

if ((mNowTime - mPressedTime) > 2000) {//比较两次按键时间差

Toast.makeText(this, "再按一次退出程序", Toast.LENGTH_SHORT).show();

mPressedTime = mNowTime;

}else{//退出程序

this.finish();

System.exit(0);

}

7.线程

7.1Android中检测当前是否为主线程

如果在Android中判断某个线程是否是主线程？对于这个问题，你可能说根据线程的名字，当然这个可以解决问题，但是这样是最可靠的么？万一某天Google一下子将线程的名字改称其他神马东西呢。

方法揭晓

下面的方法是最可靠的解决方案。

原理都一样：

7.2线程的状态（State）

新生状态（New）：当一个线程的实例被创建即使用new关键字和Thread类或其子类创建一个线程对象后，此时该线程处于新生(new)状态，处于新生状态的线程有自己的内存空间，但该线程并没有运行，此时线程还不是活着的（not alive）；

就绪状态（Runnable）：通过调用线程实例的start()方法来启动线程使线程进入就绪状态(runnable)；处于就绪状态的线程已经具备了运行条件，但还没有被分配到CPU即不一定会被立即执行，此时处于线程就绪队列，等待系统为其分配CPCU，等待状态并不是执行状态；此时线程是活着的（alive）；

运行状态（Running）：一旦获取CPU(被JVM选中)，线程就进入运行(running)状态，线程的run()方法才开始被执行；在运行状态的线程执行自己的run()方法中的操作，直到调用其他的方法而终止、或者等待某种资源而阻塞、或者完成任务而死亡；如果在给定的时间片内没有执行结束，就会被系统给换下来回到线程的等待状态；此时线程是活着的（alive）；

阻塞状态（Blocked）：通过调用join()、sleep()、wait()或者资源被暂用使线程处于阻塞(blocked)状态；处于Blocking状态的线程仍然是活着的（alive）

死亡状态（Dead）：当一个线程的run()方法运行完毕或被中断或被异常退出，该线程到达死亡(dead)状态。此时可能仍然存在一个该Thread的实例对象，当该Thread已经不可能在被作为一个可被独立执行的线程对待了，线程的独立的call stack已经被dissolved。一旦某一线程进入Dead状态，他就再也不能进入一个独立线程的生命周期了。对于一个处于Dead状态的线程调用start()方法，会出现一个运行期(runtime exception)的异常；处于Dead状态的线程不是活着的（not alive）。

线程状态图

7.3线程的方法（Method）、属性（Property）

1）优先级（priority）

每个类都有自己的优先级，一般property用1-10的整数表示，默认优先级是5，优先级最高是10；优先级高的线程并不一定比优先级低的线程执行的机会高，只是执行的机率高；默认一个线程的优先级和创建他的线程优先级相同；

2）Thread.sleep()/sleep(long millis)

当前线程睡眠/millis的时间（millis指定睡眠时间是其最小的不执行时间，因为sleep(millis)休眠到达后，无法保证会被JVM立即调度）；sleep()是一个静态方法(static method) ，所以他不会停止其他的线程也处于休眠状态；线程sleep()时不会失去拥有的对象锁。作用：保持对象锁，让出CPU，调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留一定的时间给其他线程执行的机会；

3）Thread.yield()

让出CPU的使用权，给其他线程执行机会、让同等优先权的线程运行（但并不保证当前线程会被JVM再次调度、使该线程重新进入Running状态），如果没有同等优先权的线程，那么yield()方法将不会起作用。

4）thread.join()

使用该方法的线程会在此之间执行完毕后再往下继续执行。

5）object.wait()

当一个线程执行到wait()方法时，他就进入到一个和该对象相关的等待池(Waiting Pool)中，同时失去了对象的机锁—暂时的，wait后还要返还对象锁。当前线程必须拥有当前对象的锁，如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常,所以wait()必须在synchronized block中调用。

6）object.notify()/notifyAll()

唤醒在当前对象等待池中等待的第一个线程/所有线程。notify()/notifyAll()也必须拥有相同对象锁，否则也会抛出IllegalMonitorStateException异常。

7）Synchronizing Block

Synchronized Block/方法控制对类成员变量的访问；Java中的每一个对象都有唯一的一个内置的锁，每个Synchronized Block/方法只有持有调用该方法被锁定对象的锁才可以访问，否则所属线程阻塞；机锁具有独占性、一旦被一个Thread持有，其他的Thread就不能再拥有（不能访问其他同步方法），方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

对于官方已经弃用不建议使用的方法没有列举，从这些方法中可以看出，目前的java线程生命周期有开始运行、睡眠、等待、中断、暂停，但是没有了重新开始。Java的线程是不能重启的，也就是说，当线程的run()方法执行到最后一行，退出之后，这个线程就结束了，不能再通过start()方法重启启动这个线程，只能重新构造一个线程对象，再调用其start()方法来启动，但这个对象和原来那个对象已经不同了。

线程在建立后并不马上执行run方法中的代码，而是处于等待状态。线程处于等待状态时，可以通过Thread类的方法来设置线程不各种属性，如线程的优先级（setPriority）、线程名(setName)和线程的类型（setDaemon）等。当调用start方法后，线程开始执行run方法中的代码。线程进入运行状态。可以通过Thread类的isAlive方法来判断线程是否处于运行状态。当线程处于运行状态时，isAlive返回true，当isAlive返回false时，可能线程处于等待状态，也可能处于停止状态。

public class LifeCycle extends Thread

{

public void run()

{

int n = 0;

while ((++n) < 1000);

}

public static void main(String[] args) throws Exception

{

LifeCycle thread1 = new LifeCycle();

System.out.println("isAlive: " + thread1.isAlive());

thread1.start();

System.out.println("isAlive: " + thread1.isAlive());

thread1.join(); // 等线程thread1结束后再继续执行

System.out.println("thread1已经结束!");

System.out.println("isAlive: " + thread1.isAlive());

}

要注意一下，在上面的代码中使用了join方法，这个方法的主要功能是保证线程的run方法完成后程序才继续运行，上面代码的运行结果：

isAlive: false
isAlive: true
thread1已经结束!
isAlive: false

一但线程开始执行run方法，就会一直到这个run方法执行完成这个线程才退出。但在线程执行的过程中，可以通过两个方法使线程暂时停止执行。这两个方法是yield和sleep。thread.yield()在多线程程序中,为了防止某线程独占CPU资源(这样其它的线程就得不到"响应"了).可以让当前执行的线程"休息"一下.但是这种thread.yield() 调用,并不保证下一个运行的线程就一定不是该线程.而使用sleep使线程休眠后，只能在设定的时间后使线程处于就绪状态（在线程休眠结束后，线程不一定会马上执行，只是进入了就绪状态，等待着系统进行调度）。在使用sleep时要注意，不能在一个线程中来休眠另一个线程。如main方法中使用thread.sleep(2000)方法是无法使thread线程休眠2秒的，而只能使主线程休眠2秒。在使用sleep方法时有四点需要注意：

1. sleep方法有两个重载形式，其中一个重载形式不仅可以设毫秒，而且还可以设纳秒(1,000,000纳秒等于1毫秒)。但大多数操作系统平台上的Java虚拟机都无法精确到纳秒，因此，如果对sleep设置了纳秒，Java虚拟机将取最接近这个值的毫秒。

2. 在使用sleep方法时必须使用throws或try{...}catch{...}。因为run方法无法使用throws，所以只能使用try{...}catch{...}。当在线程休眠的过程中，使用interrupt方法（这个方法将在2.3.3中讨论）中断线程时sleep会抛出一个InterruptedException异常。

3. sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

4. sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield()只能使同优先级的线程有执行的机会。

class TestThreadMethod extends Thread {

public static int shareVar = 0;

public TestThreadMethod(String name) {

super(name);

}

public void run() {

for (int i = 0; i < 4; i++) {

System.out.print(Thread.currentThread().getName());

System.out.println(" : " + i);

//Thread.yield();　（1）

/* （2） */

try {

Thread.sleep(3000);

} catch (InterruptedException e) {

System.out.println("Interrupted");

}

public class TestThread {

public static void main(String[] args) {

TestThreadMethod t1 = new TestThreadMethod("t1");

TestThreadMethod t2 = new TestThreadMethod("t2");

t1.setPriority(Thread.MAX_PRIORITY);

t2.setPriority(Thread.MIN_PRIORITY);

t1.start();

t2.start();

}

运行结果为：

1.t1:0

2.t1:1

3.t2:0

4.t1:2

5.t2:1

6.t1:3

7.t2:2

8.t2:3

由结果可见，通过sleep()可使优先级较低的线程有执行的机会。注释掉代码（2），并去掉代码（1）的注释，结果为：

1.t1:0

2.t1:1

3.t1:2

4.t1:3

5.t2:0

6.t2:1

7.t2:2

8.t2:3

可见，调用yield()，不同优先级的线程永远不会得到执行机会。yield()的作用：让出CPU的使用权，给其他线程执行机会、让同等优先权的线程运行（但并不保证当前线程会被JVM再次调度、使该线程重新进入Running状态），如果没有同等优先权的线程，那么yield()方法将不会起作用。

介绍一种线程退出的方法：使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

1. 使用退出标志终止线程

当run方法执行完后，线程就会退出。但有时run方法是永远不会结束的。如在服务端程序中使用线程进行监听客户端请求，或是其他的需要循环处理的任务。在这种情况下，一般是将这些任务放在一个循环中，如while循环。如果想让循环永远运行下去，可以使用while(true){...}来处理。但要想使while循环在某一特定条件下退出，最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出。下面给出了一个利用退出标志终止线程的例子。

public class ThreadFlag extends Thread

{

public volatile boolean exit = false;

public void run()

{

while (!exit);

}

public static void main(String[] args) throws Exception

{

ThreadFlag thread = new ThreadFlag();

thread.start();

sleep(5000); // 主线程延迟5秒

thread.exit = true; // 终止线程thread

thread.join();

System.out.println("线程退出!");

}

在上面代码中定义了一个退出标志exit，当exit为true时，while循环退出，exit的默认值为false。在定义exit时，使用了一个Java关键字volatile，这个关键字的目的是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值，

8.数字签名

1.什么是数字签名？

数字签名就是为你的程序打上一种标记，来作为你自己的标识，当别人看到签名的时候会知道它是与你相关的.

2.为什么要数字签名？

最简单直接的回答：系统要求的。

Android系统要求每一个Android应用程序必须要经过数字签名才能够安装到系统中，也就是说如果一个Android应用程序没有经过数字签名，是没有办法安装到系统中的！

Android通过数字签名来标识应用程序的作者和在应用程序之间建立信任关系，不是用来决定最终用户可以安装哪些应用程序。

这个数字签名由应用程序的作者完成，并不需要权威的数字证书签名机构认证，它只是用来让应用程序包自我认证的。

1）.保障应用程序开发者的合法权益

在对应用程序签名后，即表示此应用程序是签名人所开发的，对此程序具有所有权。

2）.预防应用程序替换

应用程序签名可以防止部分人通过使用相同的Package Name来混淆替换已经安装的程序，从而出现一些恶意篡改。

3）.保证应用程序版本的一致性

一般应用程序都会有更新，即版本的升级。如果应用程序的签名不一致，是无法进行更新替代的。所以，应用程序签名是保证当前应用程序顺利进行更新安装的前提。

3.数字证书的机制？

Android使用Java的数字证书相关的机制来给apk加盖数字证书，要理解android的数字证书，需要先了解以下数字证书的概念和java的数字证书机制。

4.程序使用相同的数字证书的好处

(1)有利于程序升级

当新版程序和旧版程序的数字证书相同时，Android系统才会认为这两个程序是同一个程序的不同版本。如果新版程序和旧版程序的数字证书不相同，则Android系统认为他们是不同的程序，并产生冲突，会要求新程序更改包名。

(2)有利于程序的模块化设计和开发。

Android系统允许拥有同一个数字签名的程序运行在一个进程中，Android程序会将他们视为同一个程序。所以开发者可以将自己的程序分模块开发，而用户只需要在需要的时候下载适当的模块。

(3)可以通过权限(permission)的方式在多个程序间共享数据和代码。

Android提供了基于数字证书的权限赋予机制，应用程序可以和其他的程序共享概功能或者数据给那些与自己拥有相同数字证书的程序。如果某个权限(permission)的protectionLevel是signature，则这个权限就只能授予那些跟该权限所在的包拥有同一个数字证书的程序。

5.在签名时，需要考虑数字证书的有效期：

(1)数字证书的有效期要包含程序的预计生命周期，一旦数字证书失效，持有改数字证书的程序将不能正常升级。

(2)如果多个程序使用同一个数字证书，则该数字证书的有效期要包含所有程序的预计生命周期。

(3)Android Market强制要求所有应用程序数字证书的有效期要持续到2033年10月22日以后。

6.数字证书的要点：

Android数字证书包含以下几个要点：

(1)所有的应用程序都必须有数字证书，Android系统不会安装一个没有数字证书的应用程序

(2)Android程序包使用的数字证书可以是自签名的，不需要一个权威的数字证书机构签名认证

(3)如果要正式发布一个Android ，必须使用一个合适的私钥生成的数字证书来给程序签名，而不能使用adt插件或者ant工具生成的调试证书来发布。

(4)数字证书都是有有效期的，Android只是在应用程序安装的时候才会检查证书的有效期。如果程序已经安装在系统中，即使证书过期也不会影响程序的正常功能。

(5)Android使用标准的java工具Keytool and Jarsigner来生成数字证书，并给应用程序包签名。

（6）使用zipalign优化程序。

数字签名的两种模式

我们都知道Android系统不会安装运行任何一款未经数字签名的apk程序，无论是在模拟器上还是在实际的物理设备上。所以我们会有一个疑问，为何在日常开发过程中我没有进行任何签名的操作，程序都会在模拟器和真机上运行？下面我们来讲讲

APK程序的两种模式：　调试模式(debug mode)和发布模式(release mode)

1.调试模式(debug mode)：在调试模式下，ADT会自动的使用debug密钥为应用程序签名，因此我们可以直接运行程序。

debug密钥：一个名为debug.keystore的文件

存放位置：C:\Users\Xiaopeng\.android\debug.keystoreXiaopeng对应替换为自己操作系统的用户名

两个风险：

debug签名的应用程序有这样两个风险：
1）debug签名的应用程序不能在Android Market上架销售，它会强制你使用自己的签名；
2）debug.keystore在不同的机器上所生成的可能都不一样，就意味着如果你换了机器进行apk版本升级，那么将会出现上面那种程序不能覆盖安装的问题。

不要小视这个问题，如果你开发的程序只有你自己使用，当然无所谓，卸载再安装就可以了。但要是你的软件有很多使用客户，这就是大问题了，就相当于软件不具备升级功能！

所以一定要有自己的数字证书来签名;

2.发布模式(release mode)：当要发布程序时，开发者就需要使用自己的数字证书给apk包签名

使用自己的数字证书给APK签名的两种方法：

(1)通过DOS命令来对APK签名。

(2)使用ADT Export Wizard进行签名

应用程序签名打包方法

步骤一进入签名打包界面

打开Android Studio，依次选择菜单栏上“Build”->“Generate Signed APK...”，这样就进入了Android程序签名打包界面。

步骤二新建Key文件

由于我们这里还没有已经存在的Key文件，所以需要先创建一个Key，这里点击“Create new...”。

根据中文提示，填写对应内容创建相应的Key文件，JACK的机器人这里创了一个“MyKey.jks”Key文件。

步骤三导入相应的Key文件签名打包应用

创建完Key文件后，会直接返回之前的Key文件导入界面，默认导入当前创建的Key文件。

“Next”后，确认APK文件的导出路径及“Build Type”。

在弹出提示语“Signed APKs generated successfully.”表示Android应用程序签名打包成功。

找到刚刚创建的APK文件，这个就是可以直接安装在Android系统中的应用程序安装包了。

getan525

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫