设计模式浅谈

1.代理模式proxy

所谓的代理模式就是在原有的服务上加了一个占位，通过这个占位可以控制服务的访问和对一些功能的增强。可举例说明。

1.1动态代理

1.1.1JDK动态代理

/**接口*/
public interface HelloService{
public void sayHello(String name);
}
/**实现类*/
public class HelloServiceImpl implements HelloService{
@Override 
public void sayHello(String name){
	System.out.println("Hello "+name);
	}
}
/**代理类*/
public class HelloServiceProxy implements InvocationHandler{
	/**真实的服务对象*/
	private Object target;
	/**生成代理对象*/
	public Object bind(Object target){
		this.target=target;
		return Proxy.newProxyInstance(target.getClass.getClassLoader(),target.getClass().getInterface,this);
	}
	/**实现InvocationHandler接口的invoke方法*/
	public Object invoke(Object proxy,Method method,Object[]args)throws Throwable{
		Object result=null;
		//通过反射调用实现类的方法
		result=method.invoke(target,args);
		return result;
	}
}
/**测试类*/
public TestJdkProxy{
	public static void main(String[] args){
		HelloServiceProxy helloHandler=new HelloServiceProxy();
		HelloService proxy=(HelloService)helloHandler.bind(new HelloServiceImpl());
		proxy.sayHello("张三");
	}
}

1.编写接口和实现类，jdk动态代理接口是必须要的
2.编写代理类，实现InvocationHandler接口，实现bind方法生成代理对象bind(实现类对象target),Proxy.newProxyInstance(类加载器，接口，代理类this)，实现invoke方法，通过反射调用实现类的方法。

1.1.2CGLIB动态代理

public class HelloServiceCglib implements MethodInterceptor{
	private Object target;
	/**创建代理对象*/
	public Object getInstance(){
		this.target=target;
		Enhancer enhancer=new Enhancer();
		enhancer.setSuperclass(this.target.getClass());
		//回调方法
		enhancer.serCallback(this);
		return enhancer.create();
	}
	@Override
	//回调方法
	public Object intercept(Object obj,Method method,Object[]args,MethodProxy proxy)throws Throwable{
		Object returnObj=proxy.invokeSuper(obj,args);
		return returnObj;
	}
}

1.可以不需要提供接口，实现MethodInterceptor接口，getInstance()方法获取代理对象，实现intercept()方法，通过反射调用实现类的方法。

1.2 使用场景

1.Mybatis的运行原理，mapper接口没有实现，通过动态代理实现接口，嵌套查询的懒加载是用的CGLIB动态代理。
2.spring中的AOP底层也是动态代理。

2.单例模式singleton

1.什么是单例模式？优点是什么？使用场景？
所谓单例模式就是整个程序只有一个实例。
优点：节约内存，减少频繁创建提高效率。
使用场景：Mybatis中SqlSessionFactory对象，applicationContext等。
2.常用的几种模式
懒汉式，饿汉式，双重校验锁，静态内部类，枚举。

/**懒汉式
   如果不加synchronized，出现线程不安全创建多个实例，不是单例模式
*/
public class Singleton {

    private static Singleton instance = null;
    private Singleton(){}

    public static synchronized Singleton getInstance(){
        //如果还没有被实例化过，就实例化一个，然后返回
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}
/**饿汉式*/
public class Singleton {
    //类加载的时候instance就已经指向了一个实例
    private static Singleton instance = new Singleton();
    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}
/**双重校验锁*/
public class Singleton {
    private static Singleton instance = null;
    private Singleton(){}

    public static Singleton getInstance(){
        if(instance == null){
            synchronized (Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
/**静态内部类*/
public class Singleton {

    private static class SingletonHolder{
        private static Singleton instance = new Singleton();
    }

    private Singleton(){}

    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}
/**枚举*/
public enum Singleton {
    INSTANCE;
}