成为Java顶尖程序员，先过了下面问题！（十）

十、设计模式与重构

1.你能举例几个常见的设计模式

1)单例模式 (Spring Bean)
2)抽象工厂模式和工厂模式 (BeanFactory)
3)适配器模式 (Android 中的View Adapter)
4)装饰模式 (java io 中 InputStream/OutputStream/Reader/Writer)
5)观察者模式
6)外观模式
7)代理模式(java动态代理)

2.你在设计一个工厂的包的时候会遵循哪些原则？

3.你能列举一个使用了Visitor/Decorator模式的开源项目/库吗？

4.你在编码时最常用的设计模式有哪些？在什么场景下用？

5.如何实现一个单例？

Hi，我们再来聊一聊Java的单例吧

    //饿汉式单例(Eager initialization) 。缺点：没有真正的lazy loading.
    public static class EagerInitializationSingleton {

        //1.将构造方法私有化，不允许外部直接创建对象
        private EagerInitializationSingleton() {
        }

        //2.创建类的唯一实例，使用private static修饰
        private static EagerInitializationSingleton instance = new EagerInitializationSingleton();

        //3.提供一个用于获取实例的方法，使用public static修饰
        public static EagerInitializationSingleton getInstance() {
            return instance;
        }
    }

    /*
     * 懒汉模式
     * 区别：饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全
     *      懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全
     */
    public static class LazyInitializationSingleton {
        //1.将构造方式私有化，不允许外边直接创建对象
        private LazyInitializationSingleton() {
        }

        //2.声明类的唯一实例，使用private static修饰
        private static LazyInitializationSingleton instance;

        //3.提供一个用于获取实例的方法，使用public static修饰
        public static LazyInitializationSingleton getInstance() {
            if (instance == null) {
                instance = new LazyInitializationSingleton();
            }
            return instance;
        }
    }

    /*
     * 懒汉模式 线程安全写法
     * 99%的时间需要同步，效率非常低下
     */
    public static class LazyInitialization2Singleton {
        private static volatile LazyInitialization2Singleton instance;

        private LazyInitialization2Singleton() {
        }

        public static synchronized LazyInitialization2Singleton getInstance() {
            if (instance == null) {
                instance = new LazyInitialization2Singleton();
            }
            return instance;
        }
    }

    /*
     * 懒汉模式 双重检查（Double-Check）版本
     * volatile为了解决 原子操作 指令重排 会出问题的。
     */
    public static class LazyInitialization3Singleton {
        private static volatile LazyInitialization3Singleton instance;

        private LazyInitialization3Singleton() {
        }

        public static LazyInitialization3Singleton getInstance() {
            if (instance == null) {
                synchronized (LazyInitialization3Singleton.class) {
                    if (instance == null) {
                        instance = new LazyInitialization3Singleton();
                    }
                }
            }
            return instance;
        }
    }

    // Effective Java 第一版推荐写法
    public static class EffectiveJava1Singleton {
        private static class SingletonHolder {
            private static final EffectiveJava1Singleton INSTANCE = new EffectiveJava1Singleton();
        }

        private EffectiveJava1Singleton() {
        }

        public static final EffectiveJava1Singleton getInstance() {
            return SingletonHolder.INSTANCE;
        }
    }

    // Effective Java 第二版推荐写法
    // 使用
    //EffectiveJava2Singleton.INSTANCE.fun1();
    public enum EffectiveJava2Singleton {
        INSTANCE;

        public void fun1() {
            // do something
        }
    }

6.代理模式（动态代理）

public interface UserService {  
    public String getName(int id);  
  
    public Integer getAge(int id);  
}  

public class UserServiceImpl implements UserService {  
    @Override  
    public String getName(int id) {  
        System.out.println("------getName------");  
        return "Tom";  
    }  
  
    @Override  
    public Integer getAge(int id) {  
        System.out.println("------getAge------");  
        return 10;  
    }  
} 

public class MyInvocationHandler implements InvocationHandler {  
    private Object target;  
  
    MyInvocationHandler() {  
        super();  
    }  
  
    MyInvocationHandler(Object target) {  
        super();  
        this.target = target;  
    }  
  
    @Override  
    public Object invoke(Object o, Method method, Object[] args) throws Throwable {  
        if("getName".equals(method.getName())){  
            System.out.println("++++++before " + method.getName() + "++++++");  
            Object result = method.invoke(target, args);  
            System.out.println("++++++after " + method.getName() + "++++++");  
            return result;  
        }else{  
            Object result = method.invoke(target, args);  
            return result;  
        }  
  
    }  
}  

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Proxy;  
  
  
public class Main1 {  
    public static void main(String[] args) {  
        UserService userService = new UserServiceImpl();  
        InvocationHandler invocationHandler = new MyInvocationHandler(userService);  
        UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),  
                userService.getClass().getInterfaces(), invocationHandler);  
        System.out.println(userServiceProxy.getName(1));  
        System.out.println(userServiceProxy.getAge(1));  
    }  
}  

7.单例模式（懒汉模式，并发初始化如何解决，volatile与lock的使用）

8.JDK源码里面都有些什么让你印象深刻的设计模式使用，举例看看？

目录列表
一、数据结构与算法基础
二、Java基础
三、JVM
四、多线程/并发
五、Linux使用与问题分析排查
六、框架使用
七、数据库相关
八、网络协议和网络编程
九、Redis等缓存系统/中间件/NoSQL/一致性Hash等
十、设计模式与重构
本文是针对知乎文章《成为Java顶尖程序员，先过了下面问题》的解答