一、单例模式
概念：
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
应用实例：
- 1、一个班级只有一个班主任。
- 2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
- 3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
优点：
- 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
- 2、避免对资源的多重占用（比如写文件操作）。
缺点：
没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
使用场景：
- 1、要求生产唯一序列号。
- 2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
- 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
实现
我们将创建一个 SingleObject 类。SingleObject 类有它的私有构造函数和本身的一个静态实例。
SingleObject 类提供了一个静态方法，供外界获取它的静态实例。SingletonPatternDemo 类使用 SingleObject 类来获取 SingleObject 对象。
步骤 1
创建一个 Singleton 类。
SingleObject.java
public class SingleObject {
//创建 SingleObject 的一个对象
private static SingleObject instance = new SingleObject();
//让构造函数为 private，这样该类就不会被实例化
private SingleObject(){}
//获取唯一可用的对象
public static SingleObject getInstance(){
return instance;
}
public void showMessage(){
System.out.println("Hello World!");
}
}步骤 2
从 singleton 类获取唯一的对象。
SingletonPatternDemo.java
public class SingletonPatternDemo {
public static void main(String[] args) {
//不合法的构造函数
//编译时错误：构造函数 SingleObject() 是不可见的
//SingleObject object = new SingleObject();
//获取唯一可用的对象
SingleObject object = SingleObject.getInstance();
//显示消息
object.showMessage();
}
}步骤 3
执行程序，输出结果：
Hello World!单例模式的几种实现方式
单例模式的实现有多种方式，如下所示：
1、懒汉式，线程不安全
是否 Lazy 初始化：是
是否多线程安全：否
实现难度：易
描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}接下来介绍的几种实现方式都支持多线程，但是在性能上有所差异。
2、懒汉式，线程安全
是否 Lazy 初始化：是
是否多线程安全：是
实现难度：易
描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}3、饿汉式
是否 Lazy 初始化：否
是否多线程安全：是
实现难度：易
描述：这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}4、双检锁/双重校验锁（DCL，即 double-checked locking）
JDK 版本：JDK1.5 起
是否 Lazy 初始化：是
是否多线程安全：是
实现难度：较复杂
描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
getInstance() 的性能对应用程序很关键。
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}5、登记式/静态内部类
是否 Lazy 初始化：是
是否多线程安全：是
实现难度：一般
描述：这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}6、枚举
JDK 版本：JDK1.5 起
是否 Lazy 初始化：否
是否多线程安全：是
实现难度：易
描述：这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。
不能通过 reflection attack 来调用私有构造方法。
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。
二、反射模式
什么是反射
大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。
Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射，体现了Java的动态性。
每一个类都会在编译之后都会产生.class文件，当这个类在第一次使用的时候类加载器(ClassLoader)会加载.class到jvm中，
加载：由类加载器完成，找到对应的字节码，创建一个Class对象
链接：验证类中的字节码，为静态域分配空间
初始化：如果该类有超类，则对其初始化，执行静态初始化器和静态初始化块（编译器将检查类型向下转型是否合法，如果不合法将抛出异常。向下转换类型前，可以使用instanceof判断。）
怎么使用反射
以下就是简单的方法示例，在测试代码中会详细举例
1：获取类
Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");2：获取构造函数
Constructor<User> constructorsP1 = c3.getConstructor(int.class, String.class);3：获取对象
User user = constructorsP.newInstance();4：获取方法
Method m2 = c3.getDeclaredMethod("add",int.class);
m2.setAccessible(true);//私有需要强制才能执行
m2.invoke(user1,5);//执行方法5：获取字段
Field field = c3.getDeclaredField("id");
field.setAccessible(true);
field.set(user, 1);第一步：首先要有一个目标类（用来验证反射）
//在类中有私有变量和共有变量 私有构造和共有构造
public class User {
public String address;
private int id;
private String name;
public User() {
System.out.println("无参构造");
}
public User(int id, String name) {
System.out.println("全部参数构造");
this.id = id;
this.name = name;
}
private User(int id) {
System.out.println("私有id的构造函数");
this.id = id;
}
private int add(int a){
System.out.println("私有方法");
int i=10;
return a+i;
}
public int add1(int a){
System.out.println("共有方法");
int i=10;
return a+i;
}
public static int add2(int a){
System.out.println("静态方法");
int i=10;
return a+i;
}
@Override
public String toString() {
return "User{" +
"address='" + address + '\'' +
", id=" + id +
", name='" + name + '\'' +
'}';
}
}第二步：我们使用反射得到类（反射得到类有三种方式，第三种实用性强）
@org.junit.Test
public void t1() throws ClassNotFoundException {
System.out.println("第一种获取反射类 new 对象,对象.class");
User user = new User();
Class c1 = user.getClass();
System.out.println(c1);
System.out.println("第二种获取反射类 类.class");
Class c2 = User.class;
System.out.println(c2);
System.out.println("第三种获取反射类 Class.forName(全限定名字)");
Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
System.out.println(c3);
System.out.println("反射类只有一个 所以都相等 但是创建的对象不相等");
System.out.println(c1 == c2);//true
System.out.println(c2 == c3);//true
}第三步：通过得到类获取构造函数创建对象、获取字段、获取方法
/**
* 反射获取类 类通过构造得到对象
*
* @throws ClassNotFoundException
*/
@org.junit.Test
public void t2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
System.out.println("第三种获取反射类");
Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
//获取所有的public的方法
System.out.println("=============getConstructors获取所有public构造=================");
Constructor[] constructors = c3.getConstructors();
for (Constructor constructor : constructors) {
System.out.println("所有的public构造：" + constructor);
}
System.out.println();
//获取指定的public的方法
System.out.println("=============getConstructor获取指定public构造=================");
Constructor<User> constructorsP = c3.getConstructor(null);
Constructor<User> constructorsP1 = c3.getConstructor(int.class, String.class);
//实例化对象 无参构造不能写参数constructorsP.newInstance(1,"22");
User user = constructorsP.newInstance();
System.out.println(user);//输出对对象
System.out.println(user.add1(2));//调用方法
User user1 = constructorsP1.newInstance(1, "郑州");
System.out.println(user1);
System.out.println(user1.add1(3));
System.out.println("公有无参构造：" + constructorsP);
System.out.println("公有两个参数构造：" + constructorsP1);
System.out.println();
//获取所有的public,private的方法
System.out.println("=============getDeclaredConstructors获取所有public，private构造=================");
Constructor[] constructors1 = c3.getDeclaredConstructors();
for (Constructor constructor : constructors1) {
System.out.println("所有的public、peivate构造：" + constructor);
}
System.out.println();
//获取指定的的private的方法
System.out.println("=============getDeclaredConstructor获取private构造=================");
Constructor constructors11 = c3.getDeclaredConstructor(int.class);
System.out.println("私有一个参数构造：" + constructors11);
System.out.println();
System.out.println(c3);
}
/**
* 反射获取类 类获取到字段
*
* @throws ClassNotFoundException
*/
@org.junit.Test
public void t3() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
System.out.println("第三种获取反射类");
Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
//获取无参构造 并且创建对象
Constructor<User> userConstructor = c3.getConstructor(null);
User user = userConstructor.newInstance();
System.out.println("");
System.out.println("===========getFields获取所有的共有字段===========");
Field[] fields = c3.getFields();
for (Field field : fields) {
field.set(user, "北京");
System.out.println(field);
}
System.out.println("私有属性的User:" + user);
System.out.println();
System.out.println("===========getDeclaredFields获取所有的字段(public private)===========");
Field[] fields1 = c3.getDeclaredFields();
for (Field field : fields1) {
System.out.println(field);
}
System.out.println();
System.out.println("===========getDeclaredField获取私有和共有 getField获取共有的指定字段===========");
Field field = c3.getDeclaredField("id");
field.setAccessible(true);
field.set(user, 1);
field = c3.getDeclaredField("name");//获取私有
field.setAccessible(true);//设置true 才能这设置值
field.set(user, "麻子");
field = c3.getDeclaredField("address");//获取共有
field.set(user, "天津");
System.out.println(user);
}
/**
* 反射获取类 类获取到方法
*
* @throws ClassNotFoundException
*/
@org.junit.Test
public void t4() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
System.out.println("第三种获取反射类");
Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
System.out.println("============反射构造函数，然后实例化对象============");
User user = (User) c3.getConstructor(int.class, String.class).newInstance(1, "大大");
User user1 = (User) c3.getConstructor(int.class, String.class).newInstance(1, "大大");
System.out.println(user == user1);
System.out.println();
System.out.println("============getMethods反射获取public方法，包含父类object的方法===========");
Method[] methods = c3.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println();
System.out.println("============getMethod反射获取指定的public方法，包含父类object的方法===========");
Method m1 = c3.getMethod("add2", int.class);
System.out.println("方法返回值+10："+m1.invoke(user, 3));
System.out.println();
System.out.println("============getDeclaredMethods反射获取public和private方法 只有自己的============");
Method[] methods1 = c3.getDeclaredMethods();
for (Method method : methods1) {
System.out.println(method);
}
System.out.println();
System.out.println("============getDeclaredMethod反射获取public和private方法 只有自己的============");
Method m2 = c3.getDeclaredMethod("add",int.class);
m2.setAccessible(true);
System.out.println("方法返回值+10："+m2.invoke(user1,5));
m2=c3.getDeclaredMethod("add1",int.class);
System.out.println("方法返回值+10："+m2.invoke(user1,11));
}反射模式的作用
主要用于框架配置文件加载，反射常常配合工厂模式，代理模式共同作用于框架
假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。
Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。大家都用过Jcreator和eclipse。当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。这就是利用了Java反射的原理，是对我们创建对象的探知、自审。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
