设计模式笔记

自己对工厂的练习

package com.yl.other;

import java.lang.reflect.Method;

public class Factory 
{
	private Factory(){}

	public static Factory factory = null;

	public static Object getInstance(Object object)
	{
		if(object == null)
			return null;
		else if(object instanceof SimpleFactory)
			return new SimpleFactory();
		else if(object instanceof BombFactory)
			return new BombFactory();
		else
			return null;
	}
}
class SimpleFactory
{
	public static void showSimple()
	{
		Class c = SimpleFactory.class;
		Method[] m = c.getMethods();
		for (int i = 0; i < m.length; i++) 
		{
			Method method = m[i];
			if(method.getName().equals("showSimple"))
			{
				System.out.println(SimpleFactory.class+"\r\n"+method);
			}
		}
	}
}
class BombFactory
{
	public static void showBomb()
	{
		System.out.println(BombFactory.class+" "+Method.class);
	}
}
class Open
{
	public static final String SimpleFactory = "SimpleFactory";

	public static final String BombFactory = "BombFactory";

	public static void main(String[] args) 
	{
		SimpleFactory f = (SimpleFactory) Factory.getInstance(SimpleFactory);
		f.showSimple();
		BombFactory b = (BombFactory) Factory.getInstance(BombFactory);
		b.showBomb();
	}
}

package com.yl.other;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

interface Proxy //抽象对象
{
	public void addPeople(int i);
}

class People  implements Proxy//真实对象
{
	public void addPeople(int i)
	{
		System.out.println("People:addPeople() "+i);
	}
}

public class ProxyText implements Proxy  //静态代理对象
{
	public static final int SYSTEM_ID = 1;
	public People p = null;

	public ProxyText()
	{
		p = new People();
	}

	public static org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger("");
	/*
	try {
		//Properties pi = new Properties();
		InputStream is = null;
		is = new FileInputStream("E:\\workspace\\YL\\src\\log4j.properties");
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	try {
		pi.load(is);
		PropertyConfigurator.configure(pi);
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}*/

	public void addPeople(int i) 
	{
		logger.info(this.getClass()+"addPeople() starting...");
		if(SYSTEM_ID==i)
		{
			p.addPeople(1);
		}
		else
		{
			System.out.println("您没有权限addPeople()!!!");
		}
		logger.info(this.getClass()+"addPeople() ending...");
	}
}

class DynamicProxyText implements InvocationHandler //动态代理对象
{
	private Object o ;

	public DynamicProxyText()
	{
	}

	public DynamicProxyText(Object o)
	{
		this.o = o;
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
	{
		ProxyText.logger.info(this.getClass()+" starting..."+ this.getClass().getMethods().toString());
		System.out.println(proxy.getClass());
		System.out.println(method.getName());
		System.out.println(args.length);
		method.invoke(o, args);
		ProxyText.logger.info(this.getClass()+" ending..."+ this.getClass().getMethods());
		return null;
	}
}

class Invoke  //客户调用
{
	public static void main(String[] args) 
	{
		new ProxyText().addPeople(1); //静态调用

		People p = new People();  
		InvocationHandler ih = new DynamicProxyText(p);
		Class c = p.getClass();
		//动态调用
		Proxy proxy = (Proxy) java.lang.reflect.Proxy.newProxyInstance(c.getClassLoader(), c.getInterfaces(), ih);
		proxy.addPeople(1);
	}
}

1. 代理模式

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式一般涉及到的角色有：

抽象角色：声明真实对象和代理对象的共同接口；

代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

静态代理缺点：
如果要按照静态代理使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。

.动态代理类

Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：

(1). Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。


(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：

Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。

Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。


所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

在使用动态代理类时，我们必须实现InvocationHandler接口

上面是转载的例子，这几天对 （简单，抽象）工厂，策略，代理，原型，单例，适配器等一些模式有所了解，也在网上看了很多别人的总结，比如对设计模式的理解，设计模式适用于什么样的情况，等等。。。还是贴一些地址方便下次回顾。附件中的资料来自http://www.jdon.com
设计模式解读之一： 策略模式 http://www.iteye.com/topic/328262
设计模式的理解：http://topic.youkuaiyun.com/t/20030611/17/1903991.html