`

设计模式笔记

阅读更多
自己对工厂的练习
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.csdn.net/t/20030611/17/1903991.html
分享到:
评论

相关推荐

    韩顺平_Java设计模式笔记.docx

    "韩顺平_Java设计模式笔记" 本资源摘要信息是对《韩顺平_Java设计模式笔记.docx》的总结和分析,该笔记涵盖了 Java 设计模式的基础知识、设计模式的七大原则、原型设计模式、解释器设计模式、单例设计模式等内容,...

    设计模式笔记(精版)

    以上只是设计模式笔记中的一部分内容,实际上每个模式都有其特定的适用场景和优缺点。理解并熟练运用这些模式,可以提高代码的可读性、可维护性和复用性,降低系统复杂度,提升软件设计的质量。在实际项目中,应根据...

    自己总结的设计模式笔记

    设计模式笔记 设计模式是软件开发中常用的解决方案,能够提高代码的灵活性、可维护性和可扩展性。以下是设计模式的七大原则和两种常用的创建型设计模式。 1. "开-闭"原则 "开-闭"原则是设计模式的核心原则,指...

    设计模式笔记.docx

    设计模式笔记 本文档主要记录了设计模式的笔记,涵盖了UML统一建模语言、用例图、类图、设计模式基本概念、面向对象设计原则、开闭原则等内容。 UML统一建模语言是软件工程中一种标准的建模语言,使用图形化的方法...

    Java设计模式笔记

    以上只是Java设计模式笔记的冰山一角,实际笔记中还会有更多关于每种模式的详细描述、示例代码和应用场景。通过学习和应用这些模式,开发者可以写出更加优雅、可维护的代码,提升团队协作效率和软件质量。

    软件体系结构与设计模式笔记

    软件体系结构与设计模式笔记 软件体系结构是指一个程序或系统的结构,它们之间的相互关系,以及在设计和交付的整个过程中的原则和指导方针。软件体系结构包括构件、连接件和约束三个要素。构件是可预制和可重用的...

    HeadFirst设计模式笔记

    《HeadFirst设计模式笔记》是深入理解软件设计思想的一份宝贵资料,主要涵盖了设计模式的基础理论和实际应用。设计模式是软件开发中的经验总结,它为解决常见的编程问题提供了标准的解决方案,使得代码更具可读性、...

    图解Java设计模式笔记总结word版本.rar

    本资料“图解Java设计模式笔记总结word版本”聚焦于通过图文并茂的方式,深入浅出地解析各种设计模式。以下是基于这个主题的详细知识点讲解: 1. **设计模式的分类** - **创建型模式**:如单例(Singleton)、工厂...

    软件体系结构与设计模式笔记样本.doc

    软件体系结构与设计模式笔记样本 软件体系结构是指软件系统的组织方式和结构,它是软件设计的核心概念。软件体系结构涉及构件、连接件和约束三个要素,构件是可预制和可重用软件部件,是构成体系构造基本计算单元或...

    GOF设计模式笔记

    ### GOF设计模式笔记 #### 一、面向对象设计的基本原则 面向对象设计的原则是指导我们在设计软件系统时遵循的一些准则,这些原则有助于提高代码的可读性、可维护性和可扩展性。 - **SRP (单一职责原则)**: 单一...

Global site tag (gtag.js) - Google Analytics