设计模式学习笔记

/**
*饿汉式
*类加载到内存后，就实例化一个单利，JVM保证是线程安全的
*简单实用 推荐
*唯一缺点：不管你用不用，都会被加载 Class.forName() 因为INSTANCE是静态变量，所以会被执行
**/
public class Mgr01{
    // 虚拟机会保证一个类的<clinit>方法在多线程环境中能够被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程执行<clinit>()方法完毕。
    private static final Mgr01 INSTANCE =new Mgr01();
    private Mgr01(){};
    public static Mgr01 getInstance(){ return INSTANCE; }
}
/**
*懒汉式
*克服了饿汉式，但线程不安全
**/
public class Mgr03{
    private Mgr03(){};
    private static Mgr03 INSTANCE;
    public static Mgr03 getInstance(){
        if(INSTANCE==null)
            INSTANCE=new Mgr03();
        return INSTANCE;
    }
}
/**
*改进懒汉式
*效率降低
**/
public class Mgr04{
    private Mgr04(){};
    private static Mgr04 INSTANCE;
    public static synchronized Mgr04 getInstance(){
        if(INSTANCE==null)
            INSTANCE=new Mgr03();
        return INSTANCE;
    }
}
/**
*尽可能减小同步块，提高运行速度
*较完美的写法
**/
public class Mgr06{
    private Mgr04(){};
    private static Mgr04 INSTANCE;
    public static Mgr04 getInstance(){
        if(INSTANCE==null){ //双锁检查
            synchronized(Mgr04.class){
                if(INSTANCE==null)
                    INSTANCE=new Mgr06;
            }
        }
        return INSTANCE;
    }
}
/**
*静态内部类的写法
*最完美写法
*加载Mgr07时，并不会加载其内部类
**/
public class Mgr07{
    private Mgr07(){};
    private static class Mgr07Holder{
        private final static Mgr07 INSTANCE=new Mgr07();
    }
    public static Mgr07 getInstance(){
        return Mgr07Holder.INSTANCE;
    }
}
/**
*完美中的完美
*枚举单例
**/
public enum Mgr08{
    INSTANCE;
    private Mgr08(){};
}

public interface Comparable<T> {
    int compareTo(T o);
}

public interface Comparator<T> {
    int compare(T o1, T o2);
}

public abstract class Factory {
    public abstract Product factoryMethod();
    public void doSomething() {
        Product product = factoryMethod();
        // do something with the product (产品的使用)
    }
}

public class ConcreteFactory extends Factory{
    @Override
    public Product factoryMethod(){
        return new ConcreteProduct();
    }
}

public interface AbstractFactory{
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

public ConcreteFactory1 implements AbstractFactory{
    AbstractProductA createProductA(){ return new ProductA1(); }
    AbstractProductB createProductB(){ return new ProductB1(); }
}

public interface CommonError {
    public int getErrorCode();
    public String getErrorMsg();
    public CommonError setErrorMsg(String errMsg);
}

public enum EmBusinessError implements CommonError{
    // 通用错误类型00001
    PARAMETER_VALIDATION_ERROR(10001,"参数不合法"),

    UNKNOWN_ERROR(10002,"未知错误"),

    // 10000开头为用户信息相关错误定义
    USER_NOT_EXIST(20001,"用户不存在"),

    STOCK_NOT_ENOUGH(30001,"库存不足"),

    USER_LOGIN_FAIL(20002,"用户手机号或密码不正确");

    private EmBusinessError(int errCode,String errMsg){
        this.errCode=errCode;
        this.errMsg=errMsg;
    }

    private int errCode;
    private String errMsg;
    
    @Override
    public int getErrorCode() {return errCode;}

    @Override
    public String getErrorMsg() {return errMsg;}

    @Override
    public CommonError setErrorMsg(String errMsg) {
        this.errMsg=errMsg;
        return this;
    }
}

public class BusinessException extends Exception implements CommonError {

    private CommonError commonError;

    // 直接接收EmBusinessError的传参用于构造异常异常
    public BusinessException(CommonError commonError){
        super();
        this.commonError=commonError;
    }

    // 接收自定义errMsg的方式构造业务异常
    public BusinessException(CommonError commonError,String errMsg){
        super();
        this.commonError=commonError;
        this.commonError.setErrorMsg(errMsg);
    }

        @Override
    public int getErrorCode() {return this.commonError.getErrorCode();}

    @Override
    public String getErrorMsg() {return this.commonError.getErrorMsg();}

    @Override
    public CommonError setErrorMsg(String errMsg) {
        this.commonError.setErrorMsg(errMsg);
        return this;
    }
}

public class Host{
    public void rent(){
        ...
    }
}

public class Proxy extends Host{
    
    @Override
    public void rent(){
        //增强操作
        xxx;
        super.rent();
    }
}

public interface Rent{
    public void rent();
}

public class Host implements Rent{
    public void rent(){
        ...
    }
}

public class Proxy implements Rent{
    Rent rent;
    public void rent(){
        //增强操作
        xxx;
        rent.rent();
    }
}

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
//loader为一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
//interfaces:为一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
//h为一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

//InvocationHandler中只有一个方法
Object invoke(Object proxy, Method method, Object[] args);
//proxy为调用方法的代理对象
//method是调用方法的一个反射
//args则是调用方法的参数
//InvocationHandler将请求转发给RealSubject,因此实现InvocationHandler的类中应该持有被代理的对象

public class ProxyInvocationHandler implements InvocationHandler {
    
    private Rent rent;
    public void setRent(Rent rent) {
        this.rent = rent;
    }

    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                      rent.getClass().getInterfaces(),this);
    }
    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        fare();
        Object invoke = method.invoke(rent, args);
        return invoke;
    }

    public void seeHouse(){
        System.out.println("中介带看");
    }

    public void fare(){
        System.out.println("收中介费");
    }
}

public class LubanProxy {

	public static Object getInstance(Object target) throws MalformedURLException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//==========================生成代理类内容===============================
		Class clazz = target.getClass().getInterfaces()[0];
		String infName = clazz.getSimpleName();
		String content = "";
		String line = "\n";//换行
		String tab = "\t";//tab
		String packageContent = "package com.baidu;" + line;
		String importContent = "import " + clazz.getName() + ";" + line;
		String clazzFirstLineContent = "public class $ProxyLuban implements " + infName + "{" + line;
		String filedContent = tab + "private " + infName + " target;" + line;

		String constructorContent = tab + "public $ProxyLuban (" + infName + " target){" + line
				+ tab + tab + "this.target =target;"
				+ line + tab + "}" + line;


		String methodContent = "";
		Method[] methods = clazz.getDeclaredMethods();

		for (Method method : methods) {
			//String
			String returnTypeName = method.getReturnType().getSimpleName();
			//query
			String methodName = method.getName();
			// [String.class===class]
			Class args[] = method.getParameterTypes();
			String argsContent = "";
			String paramsContent = "";
			int flag = 0;
			for (Class arg : args) {
				//String
				String temp = arg.getSimpleName();
				//String
				//String p0
				argsContent += temp + " p" + flag + ",";
				//p0
				paramsContent += "p" + flag + ",";
				flag++;
			}
			if (argsContent.length() > 0) {
				argsContent = argsContent.substring(0, argsContent.lastIndexOf(",") - 1);
				paramsContent = paramsContent.substring(0, paramsContent.lastIndexOf(",") - 1);
			}
			//public String query(String p0){
			//		System.out.println("log");
			//		target.query(p0);
			//	}

			methodContent += tab + "public " + returnTypeName + " " + methodName + "(" + argsContent + ") {" + line
					+ tab + tab + "System.out.println(\"log\");" + line
					+ tab + tab + "target." + methodName + "(" + paramsContent + ");" + line
					+ tab + "}" + line;

		}

		content += packageContent + importContent + clazzFirstLineContent + filedContent + constructorContent + methodContent + "}";

//=========================写入到.java文件中===============================
		File file = new File("d:\\com\\baidu\\$ProxyLuban.java");

		try {
			if (!file.exists()) {
				file.createNewFile();
			}

			FileWriter fw = new FileWriter(file);
			fw.write(content);
			fw.flush();
			fw.close();
		} catch (Exception e) {

		}

//=========================动态编译===============================
		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

		StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
		Iterable units = fileMgr.getJavaFileObjects(file);

		JavaCompiler.CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
		t.call();

		//Class.forName()
		//fileMgr.close();
//=========================使用类加载器加载到内存===============================
		URL[] urls = new URL[]{new URL("file:D:\\\\")};
		URLClassLoader urlClassLoader = new URLClassLoader(urls);
		Class cls = urlClassLoader.loadClass("com.baidu.$ProxyLuban");
		Constructor constructor = cls.getConstructor(clazz);
		Object o  = constructor.newInstance(target);

		return  o;

	}
}