开发支持类库

UUID类

  UUID是一个生成无重复字符串的程序类，这个程序类的主要功能是根据时间戳实现一个自动的无重复的字符串定义（千万亿分支一）。
一般在获取UUID时往往都是随机生成一个的内容，可以通过如下方式获取：

• 获取UUID对象：public static UUID randomUUID​()；
• 根据字符串获取UUID内容：public static UUID fromString​(String name)；

import java.util.UUID;
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        UUID uuid=UUID.randomUUID();
        System.out.println(uuid.toString());
    }
}

  在对一些文件进行自动命名处理的情况下，UUID类型非常好用。

Optional类

  Optional类的主要功能是进行null的相关处理，在以前进行程序开发中，为了防止程序中出现空指针异常，往往追加有null的验证。
范例：传统的引用传递问题

public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        MessageUtil.useMessage(MessageUtil.getMessage());
    }
}
class MessageUtil{
    private MessageUtil(){};
    public static IMessage getMessage(){
//        return new MessageImpl();
        return null;
    }
    public static void useMessage(IMessage msg){
        //有可能因为null，导致空指针
//        if(msg!=null){
            System.out.println(msg.getContent());
//        }
    }
}
interface IMessage{
    String getContent();
}
class MessageImpl implements IMessage{
    @Override
    public String getContent() {
        return "www.baidu.com";
    }
}

  在引用接收的一方往往都是被动的进行判断，所以为了解决这种被动的处理操作，Java类中就提供了Optional类，这个类可以实现null的处理操作。

• 返回空数据：public static <T> Optional<T> empty​()；
• 获取数据：public T get​()；
• 保存数据，但是不允许出现null：public static <T> Optional<T> of​(T value)；
    - 如果在保存数据时存在有null，则会抛出NullPointerException异常；
• 保存数据，允许为空：public static <T> Optional<T> ofNullable​(T value)；
• 空的时候返回其他数据：public T orElse​(T other)；
  
  
  范例：使用Optional修改上面程序

import java.util.Optional;
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        MessageUtil.useMessage(MessageUtil.getMessage().get());//获取数据
    }
}
class MessageUtil{
    private MessageUtil(){};
    public static Optional<IMessage> getMessage(){
        IMessage message=new MessageImpl();
        return Optional.of(message);//有对象
    }
    public static void useMessage(IMessage msg){
        //有可能因为null，导致空指针
//        if(msg!=null){
            System.out.println(msg.getContent());
//        }
    }
}
interface IMessage{
    String getContent();
}
class MessageImpl implements IMessage{
    @Override
    public String getContent() {
        return "www.baidu.com";
    }
}

  如果现在数据保存的内容为null，则就会在保存处出现空指针异常：

    public static Optional<IMessage> getMessage(){
        IMessage message=null;
        return Optional.of(message);//有对象
    }

  由于Optional类中也有允许保存null的方法（Optional.ofNullable()），所以在数据获取时也可以进行null的处理，如果为null，则在使用get()获取数据时就会出现“NoSuchElementException”异常，所以此时可以更换为orElse()方法
范例：处理null

import java.util.Optional;
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        IMessage message=MessageUtil.getMessage().orElse(new MessageImpl());//获取数据
        MessageUtil.useMessage(message);
    }
}
class MessageUtil{
    private MessageUtil(){};
    public static Optional<IMessage> getMessage(){
        IMessage message=null;
        return Optional.ofNullable(message);//有对象
    }
    public static void useMessage(IMessage msg){
        //有可能因为null，导致空指针
//        if(msg!=null){
            System.out.println(msg.getContent());
//        }
    }
}
interface IMessage{
    String getContent();
}
class MessageImpl implements IMessage{
    @Override
    public String getContent() {
        return "www.baidu.com";
    }
}

  在所有引用数据类型的操作处理之中，null是一个重要的技术问题，所以来说JDK1.8后提供的Optional类对于null的处理很有帮助，同时也是在日后进行项目开发时常用的程序类。

ThreadLocal类

  为了了解ThreadLocal类作用，先编写一个简单的程序做一个先期的分析。
范例：现在定义这样一个结构

public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        Message msg=new Message();//实例化消息主体对象
        msg.setInfo("www.baidu.com");//设置要发送的内容
        Channel.setMessage(msg);//设置要发送的消息
        Channel.send();//发送消息
    }
}
class Channel {//消息的发送通道
    private Channel(){}
    public static Message message;
    public static void setMessage(Message m) {
        message = m;
    }
    public static void send() {//发送消息
        System.out.println("【消息发送】" + message.getInfo());
    }
}
class Message {//要发送的消息体
    private String info;
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
}

  对于当前的程序采用的是一种单线程的模式来进行处理的；那么如果再多线程的状态下能否实现安全一致的操作效果呢？为此将启动三个线程进行处理。
范例：多线程的影响

public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        new Thread(()->{
            Message msg=new Message();//实例化消息主体对象
            msg.setInfo("第1个线程的消息");//设置要发送的内容
            Channel.setMessage(msg);//设置要发送的消息
            Channel.send();//发送消息
        },"消息发送者A").start();
        new Thread(()->{
            Message msg=new Message();//实例化消息主体对象
            msg.setInfo("第2个线程的消息");//设置要发送的内容
            Channel.setMessage(msg);//设置要发送的消息
            Channel.send();//发送消息
        },"消息发送者B").start();
        new Thread(()->{
            Message msg=new Message();//实例化消息主体对象
            msg.setInfo("第3个线程的消息");//设置要发送的内容
            Channel.setMessage(msg);//设置要发送的消息
            Channel.send();//发送消息
        },"消息发送者C").start();
        /**
         * 【消息发送者B、消息发送】第2个线程的消息
         * 【消息发送者C、消息发送】第3个线程的消息
         * 【消息发送者A、消息发送】第2个线程的消息
         */
    }
}
class Channel {//消息的发送通道
    private Channel(){}
    public static Message message;
    public static void setMessage(Message m) {
        message = m;
    }
    public static void send() {//发送消息
        System.out.println("【"+Thread.currentThread().getName()+"、消息发送】" + message.getInfo());
    }
}
class Message {//要发送的消息体
    private String info;
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
}

  这时多线程对消息的发送处理产生了很大的影响。

  在保持Channel（所有的发送通道）核心结构不改变的情况下，需要到考虑到每个线程的独立操作问题。那么这样的情况下，对于Channel类而言，除了要保留有发送的消息之外，还需要存放一个每一个线程的标记（当前线程），这时可以通过ThreadLocal类来实现。在ThreadLocal类中提供有如下操作方法：

• 构造方法：public ThreadLocal​()；
• 设置属性：public void set​(T value)；
• 取出数据：public T get​()；

• 移除数据：public void remove​()；

  
  

class Channel {//消息的发送通道
    private Channel(){}
    public static ThreadLocal<Message> THREADLOCAL=new ThreadLocal();
    public static void setMessage(Message m) {
        THREADLOCAL.set(m);//向ThreadLocal中保存数据
    }
    public static void send() {//发送消息
        Message message=THREADLOCAL.get();
        System.out.println("【"+Thread.currentThread().getName()+"、消息发送】" + message.getInfo());
    }
}
        /**
         * 【消息发送者B、消息发送】第2个线程的消息
         * 【消息发送者C、消息发送】第3个线程的消息
         * 【消息发送者A、消息发送】第1个线程的消息
         */

  每一个线程通过ThreadLocal只允许保存一个数据。

定时器 Timer与TimerTask

  定时器的主要操作就是进行定时任务的处理。在JDK1.3后提供了定时任务的支持，但是这种任务的处理只实现了间隔触发的操作效果。
  如果要实现定时的处理操作主要需要有一个定时操作的主体类，以及一个定时任务的控制。可以使用两个类实现：

• java.util.TimerTask类：实现定时任务处理；
• java.util.Timer类：进行任务的启动，启动的方法：
    - 任务启动：public void schedule​(TimerTask task, long delay)、延迟单位为毫秒；
    - 间隔触发：public void schedule​(TimerTask task, long delay, long period)；
  范例：实现定时任务的处理

import java.util.Timer;
import java.util.TimerTask;
class MyTask extends TimerTask {//任务主体
    @Override
    public void run() {//多线程的处理方法
        System.out.println(Thread.currentThread().getName() + "、定时任务执行当前时间：" + System.currentTimeMillis());
    }
}
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        Timer timer=new Timer();//定时任务
//        timer.schedule(new MyTask(),0);//延迟时间为0表示立即启动
//        timer.schedule(new MyTask(),1000);//1秒后启动
        //间隔触发
        timer.scheduleAtFixedRate(new MyTask(),100,1000);//100毫秒后开始执行，每秒执行一次
    }
}

定时任务

  这种定时是由JDK最原始的方式提供的支持，但是实际上开发中一般不会采用此类进行定时处理。

Base64加密工具

  一般来说，加密往往都伴随着解密，所谓的加密或者解密都需要有一些规则。在JDK1.8开始提供有一组新的加密处理操作类，Base64处理。

• java.util.Base64.Encoder：进行加密操作；
    - 加密处理：public byte[] encode​(byte[] src)；
• java.util.Base64.Decoder：进行解密操作；
    - 解密处理：public byte[] decode​(byte[] src)；
  范例：实现加密与解密操作

import java.util.Base64;
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String msg="www.baidu.com";//要发送的信息
        String encMsg=new String(Base64.getEncoder().encode(msg.getBytes()));
        System.out.println("加密的结果："+encMsg);
        String oldMsg=new String(Base64.getDecoder().decode(encMsg));
        System.out.println("解密的结果："+oldMsg);
        /**
         * 加密的结果：d3d3LmJhaWR1LmNvbQ==
         * 解密的结果：www.baidu.com
         */
    }
}

  虽然Base64可以实现加密和解密的处理，但是其由于是一个公版的算法，所以如果直接对数据进行加密并不安全，所以可以对其进行盐值操作。

import java.util.Base64;
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String salt = "salt";//盐值
        String msg = "www.baidu.com" + "{" + salt + "}";//要发送的信息
        String encMsg = new String(Base64.getEncoder().encode(msg.getBytes()));
        System.out.println("加密的结果：" + encMsg);
        String oldMsg = new String(Base64.getDecoder().decode(encMsg));
        System.out.println("解密的结果：" + oldMsg);
        /**
         * 加密的结果：d3d3LmJhaWR1LmNvbXtzYWx0fQ==
         * 解密的结果：www.baidu.com{salt}
         */
    }
}

  即便现在有盐值实际上发现加密的效果也不是很好，更好的做法是多次加密。
范例：复杂加密

import java.util.Base64;
class StringUtil{
    private static final String SALT="{javasalt}";//公共盐值,不对外暴露，一旦使用不可更改
    private static final int REPEAT=5;//重复加密次数：5次
    /**
     * 加密处理
     * @param str 要加密的字符串
     * @return 加密后的数据
     */
    public static String encode(String str){//加密处理
        String temp=str+SALT;
        byte[] data=temp.getBytes();//将字符串变为字节数组
        for (int i = 0; i < REPEAT; i++) {
            data=Base64.getEncoder().encode(data);
        }
        return new String(data);
    }
    /**
     * 解密处理
     * @param str 要解密的内容
     * @return 解密后的原始数据
     */
    public static String decode(String str){//解密处理
        byte[] data=str.getBytes();//将字符串变为字节数组
        for (int i = 0; i < REPEAT; i++) {
            data=Base64.getDecoder().decode(data);
        }
        String decode=new String(data);
        return decode.substring(0,decode.length()-SALT.length());
    }
}
public class JavaApiDemo {
    public static void main(String[] args) throws Exception {
        String encode=StringUtil.encode("www.baid.com{javasalt}");
        System.out.println("加密结果："+encode);
        String decode=StringUtil.decode(encode);
        System.out.println("解密结果："+decode);
        /**
         * 加密结果：VjJ0U1QyRXdNSGRsU0ZKVVlsZG9iMVpxUmtkTlZtUlZVMVJXYTFJeFZqVlpNR1J2WVRKS1ZsZHFXbGhXYlZFd1ZGVmtZVmRYVWtsU2JIQllVbTVDZGxkWWNFdFNNazE1Vld0c1RsSkVRVGs9
         * 解密结果：www.baid.com{javasalt}
         */
    }
}

  最好的做法就是使用2-3种加密程序，同时再找到一些完全不可解密的加密算法。