静态变量缓存需要注意的事

在项目过程中，我们有时经常喜欢用静态变量（static）来缓存一些不便的公共数据，但是这么做有一点需要注意：静态变量的保护。

由于一些因素（比如查询数据库），我们无法对静态变量加上final属性，因此如果静态变量暴漏后，如果有对静态变量写操作（即修改变量）的话，很可能会引起意想不到的错误。当然平时我们用缓存几乎都是读取操作，所以这个问题不容易引起我们的注意。

例子说明：

package test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Cache {

	private static List<Student> students;

	static {
		students = new ArrayList<Student>();

		Student student1 = new Student();
		student1.setName("张三");
		student1.setAge(18);
		Student student2 = new Student();
		student2.setName("李四");
		student2.setAge(17);
		Student student3 = new Student();
		student3.setName("王五");
		student3.setAge(20);
		Student student4 = new Student();
		student4.setName("赵六");
		student4.setAge(18);
		Student student5 = new Student();
		student5.setName("刘七");
		student5.setAge(18);

		students.add(student1);
		students.add(student2);
		students.add(student3);
		students.add(student4);
		students.add(student5);
	}

	public static List<Student> findAllStudents() {
		return students;
	}
	
	public static Student getStudentByName(String name) {
		for (Student student : students) {
			if (student.getName().equals(name)) {
				return student;
			}
		}
		return null;
	}

	public static void main(String[] args) {
		List<Student> students1 = Cache.findAllStudents();
		System.out.println(students1.size());
		for (Iterator<Student> iter = students1.iterator(); iter.hasNext();) {
			Student student = iter.next();
			if (student.getName().equals("李四")) {
				iter.remove();
			}
		}

		List<Student> students2 = Cache.findAllStudents();
		System.out.println(students2.size());
	}
}

class Student {

	private String name;

	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}

我们运行代码后，结果发现：第一次打印为5，第二次却为4了。

因为一些业务上的原因，有时我们会对结果进行过滤，虽然大多人都采用如下方式

	public static void main(String[] args) {
		List<Student> students1 = Cache.findAllStudents();
		System.out.println(students1.size());
		List<Student> students1new = new ArrayList<Student>();
		for (Student student : students1) {
			if (student.getName().equals("李四")) {
				continue;
			}
			students1new.add(student);
		}

		List<Student> students2 = Cache.findAllStudents();
		System.out.println(students2.size());
	}

这样确实不会对缓存产生影响，但如果我们编程时需要用到remove或add等操作时，便会对缓存产生影响。

要想了解造成此现象的原因，需要了解java内存机制和指针的相关知识，感兴趣的大家查阅相关资料，此知识不是本篇重点。我们继续看。

其实上述代码中关于缓存获取的方法（findAllStudents）是有问题的，正确的如下：

	public static List<Student> findAllStudents() {
		return new ArrayList<Student>(students);
	}

这样就不会把缓存数据students直接暴漏给外面。

但是getStudentByName方法还是有问题的，运行如下代码

	public static void main(String[] args) {
		List<Student> students1 = Cache.findAllStudents();
		Student studentOld = null;
		for (Student student : students1) {
			if (student.getName().equals("李四")) {
				studentOld = student;
			}
		}
		System.out.println(studentOld.getName());

		Student student = Cache.getStudentByName("李四");
		student.setName("李四李四");

		System.out.println(studentOld.getName());
	}

结果：第一次打印为李四，第二次却变成了李四李四。

虽然我们保护了缓存数据students，但list中数据的指针指向的还是同一份，所以缓存数据students中某一数据发生变化，同样会影响到其他数据list。

那么解决办法是：

	public static Student getStudentByName(String name) {
		for (Student student : students) {
			if (student.getName().equals(name)) {
				Student studentNew = new Student();
				studentNew.setAge(student.getAge());
				studentNew.setName(student.getName());
				return studentNew;
				
//				如果有commons-beanutils-1.8.0.jar包，可以用以下方式
//				try {
//					return (Student) BeanUtils.cloneBean(student);
//				} catch (Exception e) {
//					throw new RuntimeException(e);
//				}
			}
		}
		return null;
	}

 

通过以上改进后，我们就能确保静态变量缓存的安全行了，有时编程稍不注意或者修改静态变量方式不对的话，很容易因改变静态变量而造成系统异常，正确理解new、内存机制、指针的概念才能避免发生意外。

Java有很多需要我们深入理解的地方，停留在表面上的代码，不仅效率低下而且可靠性也无法保障，造成系统又慢又易崩溃，所以打好基础，脚踏实地，不断追求自我提高和代码重构、精进才能有朝一日成为独当一面的程序员。