从设计模式的角度看Java程序优化
一、前言
Java程序优化有很多种渠道，比如jvm优化、数据库优化等等，但都是亡羊补牢的措施，如果能在设计程序架构时利用设计模式就把程序的短板解决，就能使程序更加健壮切容易维护迭代
二、常用的设计模式
1、单例模式
单例模式可以确保一个类只产生一个实例，对于系统中频繁使用的对象建议使用单例模式设计，可以节省创建对象耗费的时间以及减少GC清理的压力，代码如下
public class A { // 实例化一个私有的静态对象 private static A a = new A(); // 构造方法私有，防止其他代码对其实例化 private A() { } // 通过getInstance获取使用该对象 public static A getInstance() { return a; } }
因为对象实例是静态对象，所以JVM在加载这个类时就会把对象创建出来，这样无法做到延时加载（就是用到的时候再加载），所以还有一些写法会将对象设置为null，当有人调用getInstance方法时，先判断对象是否为空，为空再实例化对象，达到延时加载的目的，代码如下
public class A { // 声明对象时赋值为null，加载类时，不会生成对象 private static A a = null; private A() { } // 加入synchronized关键字，将这个办法锁起来，当多线程调用时竞争锁，达到线程安全 public static synchronized A getInstance() { if (a == null) { a = new A(); } return a; } }
以上代码虽然解决了线程安全的问题，但是加入同步锁，会使代码效率降低为代价，所以还需要再改进一下，完美的做法如下
public class A { private A() { } // 声明一个静态内部类 private static class AHolder { private static A a = new A(); } public static A getInstance() { // 直接返回内部类的对象 return AHolder.a; } }
以上代码声明了一个静态内部类，当调用A类时，内部类是不会被初始化的，当调用getInstance方法时，内部类才会被调用，内部类中的对象就会随之实例化，这样使用内部类巧妙的达成了延时加载的目的，同时也不用加锁，性能不会降低
2、代理模式
使用代理模式可以使用一个代理类来间接调用其他类的功能，达到屏蔽主类的效果，在程序优化的角度上，他可以做到：当系统启动时，会做许多初始化的操作，导致系统启动时非常缓慢，可以使用代理类来处理初始化的操作，当系统启动时，加载代理类，而不用做真正的初始化操作，当这个组件真正被用到时，代理类才会真正去调用初始化的操作，这样达到了系统压力的分摊，而加快了系统的启动速度。当然代理类除了应对性能问题，还有很多其他的用途。代码如下
public interface IOperation { // 业务逻辑接口 void doIt(); }
public class TrueOperation implements IOperation { @Override public void doIt() { // 真正的业务逻辑 System.out.println("do it."); } }
public class ProxyOperation implements IOperation { // 聚合真正的实现类 private TrueOperation trueOperation = null; @Override public void doIt() { if (trueOperation == null) { trueOperation = new TrueOperation(); } // 代理执行真正的方法 trueOperation.doIt(); } }
以上代码可以看出，其实代理类就是将真正的业务类聚合到自己，然后代执行，只有当业务方法真正被调用时，业务类才会被初始化，也是延时加载的思想，以上是静态代理模式的写法，存在的问题就是，当业务多了以后，同时还要维护代理类，这样就增加了开发维护的难度，所以进一步优化就是使用动态代理模式，如下代码使用JDK自带的动态代理模式
// 业务逻辑接口 public interface IOperation { void operationA(); void operationB(); }
// 业务逻辑的实现 public class OperationImpl implements IOperation { @Override public void operationA() { System.out.println("do A..."); } @Override public void operationB() { System.out.println("do B..."); } }
// 动态代理实现类 public class OperationHandler implements InvocationHandler { // 需要代理的业务逻辑 private OperationImpl operation = null; @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 延时加载 if (operation == null) { operation = new OperationImpl(); } // 执行一些自定义的逻辑 System.out.println("before work..."); // 代理执行业务逻辑 method.invoke(operation, args); // 执行一些自定义的逻辑 System.out.println("after work..."); return null; } }
public class Main { public static void main(String[] args) { // 生成代理对象 IOperation operation = (IOperation)Proxy .newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{IOperation.class}, new OperationHandler()); // 代理执行业务 operation.operationA(); operation.operationB(); } }
如果需要更好性能的动态代理模式，可以使用第三方库，比如CGLIB、Javassist等
3、享元模式
当系统中存在多个相同的对象，可以优化让大家都是用同一个对象，工厂类中拿着一个对象实例，当需要使用到这个对象时，通过工厂类获取对象实例，不用每次使用都创建一遍对象，从而减少创建开销、GC压力和对象的内存占用。这听起来有点像单例模式和对象池的合体，这与对象池的区别就是：对象池中的每个对象都是等价的，而享元模式中的工厂的对象，则各有各自的用途，如下代码
// 业务逻辑接口 public interface IOperation { void doIt(); }
// 业务逻辑的实现 public class OperationImplA implements IOperation { private String id = null; public OperationImplA(String id) { this.id = id; } @Override public void doIt() { System.out.println("do it A..."); } }
// 业务逻辑的实现 public class OperationImplB implements IOperation { private String id = null; public OperationImplB(String id) { this.id = id; } @Override public void doIt() { System.out.println("do it B..."); } }
// 享元工厂 public class OperationFactory { // 相同ID公用同一个对象 private Map<String, IOperation> operationMapA = new HashMap<>(); private Map<String, IOperation> operationMapB = new HashMap<>(); public IOperation getOperationA(String id) { IOperation operation = operationMapA.get(id); // 延时加载 if (operation == null) { operation = new OperationImplA(id); operationMapA.put(id, operation); } return operation; } public IOperation getOperationB(String id) { IOperation operation = operationMapB.get(id); // 延时加载 if (operation == null) { operation = new OperationImplB(id); operationMapB.put(id, operation); } return operation; } }
public class Main { public static void main(String[] args) { OperationFactory operationFactory = new OperationFactory(); IOperation operationA = operationFactory.getOperationA("A"); IOperation operationB = operationFactory.getOperationB("B"); operationA.doIt(); operationB.doIt(); } }
如上代码看出，每个id会共享一个对象，多次使用时可以复用对象
4、装饰者模式
装饰者模式也是比较常见的模式，他可以将系统中的功能组件进行包装，提升功能增加的能力，对于一些功能组件，我们可以用装饰者模式为其提高性能能力，具有低耦合的特性，最典型的例子就是JDK中的文件操作，平常经常使用FileInputStream来读取文件内容，FileInputStream是基于字节流的输入，不具备缓冲区的功能，JDK就使用装饰者模式将FileInputStream包装增加了缓冲区的性能优化，即BufferedInputStream，这个例子就是增加了功能组件的性能，还有例子比如Collections.synchronizedMap()，这个对HashMap进行了包装，增加了线程安全的特性。下面看一个简易实现代码
// 业务逻辑接口 public interface IOperation { void doIt(); }
// 业务逻辑的实现 public class OperationImpl implements IOperation { @Override public void doIt() { System.out.println("do it..."); } }
public abstract class AbsOperation implements IOperation { IOperation operation = null; public AbsOperation(IOperation operation) { this.operation = operation; } }
public class OperationPlusA extends AbsOperation { public OperationPlusA(IOperation operation) { super(operation); } @Override public void doIt() { System.out.println("增强功能A。。。"); operation.doIt(); } }
public class OperationPlusB extends AbsOperation { public OperationPlusB(IOperation operation) { super(operation); } @Override public void doIt() { System.out.println("增强功能B。。。"); operation.doIt(); } }
public class Main { public static void main(String[] args) { IOperation operation = new OperationPlusA(new OperationPlusB(new OperationImpl())); operation.doIt(); } }
以上代码可以看出，我们对功能组件进行了两次增强，每次增强都是互相独立的，不会互相影响
5、观察者模式
观察者模式对于性能优化主要在“通知”，当程序A依赖于程序B的执行，如果程序A开线程去轮询程序B来监视程序B的状态，那么会增加系统的负担，所以使用观察者模式来优化达成“通知”这个目的，当程序B执行完毕，就会回调程序A的方法，来告诉程序A自己已经执行好了，免去了开线程去监视的负担，JDK已经帮我们提供了观察者模式的接口，下面使用简单的代码去尝试一下观察者模式
// 观察者 public class ObserverA implements Observer { @Override public void update(Observable o, Object arg) { // 观察者的通知回调 System.out.println("收到。。。"); } }
// 被观察者 public class ObservableA extends Observable { @Override protected synchronized void setChanged() { // 改变状态方法 super.setChanged(); } }
public class Main { public static void main(String[] args) { // 实例化观察者和被观察者 ObserverA observerA = new ObserverA(); ObservableA observableA = new ObservableA(); // 将观察者加入到被观察者的观察列表中 observableA.addObserver(observerA); // 改变状态，然后通知观察者自己改变了 observableA.setChanged(); observableA.notifyObservers(); observableA.setChanged(); observableA.notifyObservers(); } }
观察者需要重写update()方法来定义被通知时要做的事，而被观察者需要重写setChanged方法来改变自己的状态，使用时，先将观察者注册到被观察者中，需要通知时，要调用setChanged()方法改变状态，再调用notifyObservers()方法通知观察者，如果不改变状态是无法发出通知的