设计模式

单例模式

这是在开发中设计最多的一种设计模式，也是最简单的设计模式
主要应用资源的共享以及 应用级别的全局变量
下面来看看它的四个实现方式

1，饿汉式:它在系统加载的时候就已经把对象创建，瑕疵在于如果未使用之前会造成资源的浪费。

public class User(){
    private Static User user = new User();
    private User(){}
    public Static  User getUser(){
        retrun user;
    }
}

2，懒汉式：它在系统加载的时候不创建对象，当需要获取的时候在去创建。因为在方法上加个synchronize，当频繁访问该资源时，性能很差

public class User(){
    private Static User user;
    private User(){}
    public Static synchronized  User getUser(){
        if(user==null){
            user= new User();
        }
        retrun user;
    }
}

3.这个时候需要在懒汉式的基础上进行线程优化，优化方向是缩小同步代码块的影响范围.DCL(双重锁判断机制)，下面可以看到只有在用户第一次访问该资源的时候会触碰到线程安全操作。后期不会走同步代码块极大的优化了该方法的访问效率

public class User(){
    private Static User user;
    private User(){}
    public  Static  User getUser(){
        if(user==null){
            synchronized（User.class）{
                if(user==null){
                    user= new User();
                }
            }
        }
        retrun user;
    }
}

4。第二种优化方案，采用的静态内部类实现模式,因为内部类只会在使用的时候才会加载，并且只会加载一次，因此该方式是实现单例的最好模式。

public class User(){
    private static class Install(){
        private Static User user = new User();
    }
    private User(){}
    public Static User getUser(){
        return Install.user;
    }
}

工厂模式

这个模式是有两种，静态工厂模式和动态工厂模式
静态工厂模式:

public class  StaticFactory{
    public Static User userBean(){
        return new User();
    }
}

在我第一次面对到这篇代码时，我内心不得感慨，有毛病把，为什么写一个这个东西，不直接new。那么这就引除了工厂模式的第一个原则：直接new就可以的对象是不需要工厂模式去封装对象的创建过程。

public class  StaticFactory{
    public static final int TYPE_ONE = 1;
    public static final int TYPE_TWO = 2;
        public static final int TYPE_THREE = 3 
    public Static User userBean(Int type){
        switch(type){
            case TYPE_ONE:
                return new User();
            case TYPE_TWO:
                return new Person();
            case TYPE_THREE:
                return new Man();
            default:
                return Women();
        }
    }
}

当我看到这个代码的时候，我心中想的是工厂模式的作用是什么？

1. 当你面向接口开发的时候，你需要调用接口中的一个方法，对于调用方来说我不关心是由哪个实现类去实现这个接口的，那么可以用工厂模式来选择由那个实现类去完成方法调用
2. 当面对很多需要创建bean的类的时候，如果有用工厂模式封装，当该类在业务规则发生改变的时候导致类的构造方法出现改的，无需去找出每个实例对象的地方去修改，直接修改工厂类就搞定

但是对于上面的工厂模式，不利于扩展,这时候出现了高级的动态工厂模式，它主要利用了java的反射机制来创建对象。实现的效果是一致的

代理模式

1静态代理模式

目标类：
public interface IUserDao(){
    public void save();
}
代理类：
public UserDaoProxy implement IUserDao(){
    private IUserDao userDao;
    public UserDaoProxy(IUserDao userDao){
        this.userDao = userDao;
    }
    public void save(){
        System.out.privateln("-----执行之前---");
        userDao.save();
        System.out.privateln("-----执行之后---");
    }
}

这种代理模式需要一个前提条件：目标类需要实现接口。
缺点：每次需要一个代理，都需要重新写一份代理类。不符合编码的规范

动态代理类：

public ProxyFactory{
    private Object target;
    public ProxyFactory(Object target){
        this.target = target;
    }
    public Object proxyInstall(){
        return Proxy.newProxyInstance( //实现jdk的Proxy的newProxyInstance方法
        target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler(){
             @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开始事务");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("提交事务");
                        return returnValue;
                    }
        }

    }
}