qileilove

細(xì)節(jié)優(yōu)化提升資源利用率

posted @ 2011-09-27 09:23 順其自然EVO| 編輯 收藏

抽象工廠模式

posted @ 2011-09-26 11:06 順其自然EVO| 編輯 收藏

JAVA反射機(jī)制的學(xué)習(xí)（2）

posted @ 2011-09-23 17:50 順其自然EVO| 編輯 收藏

Java反射機(jī)制的學(xué)習(xí)

posted @ 2011-09-23 17:14 順其自然EVO| 編輯 收藏

Java內(nèi)存分配、管理小結(jié)

posted @ 2011-09-23 17:02 順其自然EVO| 編輯 收藏

java反射機(jī)制的實(shí)現(xiàn)原理

java反射機(jī)制的實(shí)現(xiàn)原理
反射機(jī)制:
所謂的反射機(jī)制就是java語(yǔ)言在運(yùn)行時(shí)擁有一項(xiàng)自觀的能力。
通過(guò)這種能力可以徹底的了解自身的情況為下一步的動(dòng)作做準(zhǔn)備。
下面具體介紹一下java的反射機(jī)制。這里你將顛覆原來(lái)對(duì)java的理解。
Java的反射機(jī)制的實(shí)現(xiàn)要借助于4個(gè)類：class，Constructor，F(xiàn)ield，Method；
其中class代表的時(shí)類對(duì)象，
Constructor－類的構(gòu)造器對(duì)象，
Field－類的屬性對(duì)象，
Method－類的方法對(duì)象。
通過(guò)這四個(gè)對(duì)象我們可以粗略的看到一個(gè)類的各個(gè)組 成部分。
Class：程序運(yùn)行時(shí)，java運(yùn)行時(shí)系統(tǒng)會(huì)對(duì)所有的對(duì)象進(jìn)行運(yùn)行時(shí)類型的處理。
這項(xiàng)信息記錄了每個(gè)對(duì)象所屬的類，虛擬機(jī)通常使用運(yùn)行時(shí)類型信息選擇正 確的方法來(lái)執(zhí)行（摘自：白皮書(shū)）。
但是這些信息我們?cè)趺吹玫桨。鸵柚赾lass類對(duì)象了啊。
在Object類中定義了getClass()方法。我 們可以通過(guò)這個(gè)方法獲得指定對(duì)象的類對(duì)象。然后我們通過(guò)分析這個(gè)對(duì)象就可以得到我們要的信息了。

比如：ArrayList arrayList;

Class clazz = arrayList.getClass();

然后我來(lái)處理這個(gè)對(duì)象clazz。

當(dāng)然了Class類具有很多的方法，這里重點(diǎn)將和Constructor，F(xiàn)ield，Method類有關(guān)系的方法。
Reflection 是 Java 程序開(kāi)發(fā)語(yǔ)言的特征之一，它允許運(yùn)行中的 Java 程序?qū)ψ陨磉M(jìn)行檢查，或者說(shuō)“自審”，并能直接操作程序的內(nèi)部屬性。Java 的這一能力在實(shí)際應(yīng)用中也許用得不是很多，但是個(gè)人認(rèn)為要想對(duì)java有個(gè)更加深入的了解還是應(yīng)該掌握的。

1．檢測(cè)類：

reflection的工作機(jī)制

考慮下面這個(gè)簡(jiǎn)單的例子，讓我們看看 reflection 是如何工作的。

import java.lang.reflect.*;

public class DumpMethods {

public static void main(String args[]) {

try {
//forName("java.lang.String")獲取指定的類的對(duì)象
Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

for (int i = 0; i < m.length; i++)

System.out.println(m[i].toString());

} catch (Throwable e) {

System.err.println(e);

}

}

}

按如下語(yǔ)句執(zhí)行：

java DumpMethods java.util.ArrayList

這個(gè)程序使用 Class.forName 載入指定的類，然后調(diào)用 getDeclaredMethods 來(lái)獲取這個(gè)類中定義了的方法列表。java.lang.reflect.Methods 是用來(lái)描述某個(gè)類中單個(gè)方法的一個(gè)類。

Java類反射中的主要方法

對(duì)于以下三類組件中的任何一類來(lái)說(shuō)
-- 構(gòu)造函數(shù)、字段和方法
-- java.lang.Class 提供四種獨(dú)立的反射調(diào)用，以不同的方式來(lái)獲得信息。調(diào)用都遵循一種標(biāo)準(zhǔn)格式。以下是用于查找構(gòu)造函數(shù)的一組反射調(diào)用：

Constructor getConstructor(Class[] params) -- 獲得使用特殊的參數(shù)類型的公共構(gòu)造函數(shù)，

Constructor[] getConstructors() -- 獲得類的所有公共構(gòu)造函數(shù)

Constructor getDeclaredConstructor(Class[] params) -- 獲得使用特定參數(shù)類型的構(gòu)造函數(shù)(與接入級(jí)別無(wú)關(guān))

Constructor[] getDeclaredConstructors() -- 獲得類的所有構(gòu)造函數(shù)(與接入級(jí)別無(wú)關(guān))

獲得字段信息的Class 反射調(diào)用不同于那些用于接入構(gòu)造函數(shù)的調(diào)用，在參數(shù)類型數(shù)組中使用了字段名：

Field getField(String name) -- 獲得命名的公共字段

Field[] getFields() -- 獲得類的所有公共字段

Field getDeclaredField(String name) -- 獲得類聲明的命名的字段

Field[] getDeclaredFields() -- 獲得類聲明的所有字段

用于獲得方法信息函數(shù)：

Method getMethod(String name, Class[] params) -- 使用特定的參數(shù)類型，獲得命名的公共方法

Method[] getMethods() -- 獲得類的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特寫(xiě)的參數(shù)類型，獲得類聲明的命名的方法

Method[] getDeclaredMethods() -- 獲得類聲明的所有方法

使用 Reflection：

用于 reflection 的類，如 Method，可以在 java.lang.relfect 包中找到。使用這些類的時(shí)候必須要遵循三個(gè)步驟：
第一步是獲得你想操作的類的 java.lang.Class 對(duì)象。
在運(yùn)行中的 Java 程序中，用 java.lang.Class 類來(lái)描述類和接口等。

下面就是獲得一個(gè) Class 對(duì)象的方法之一：

Class c = Class.forName("java.lang.String");

這條語(yǔ)句得到一個(gè) String 類的類對(duì)象。還有另一種方法，如下面的語(yǔ)句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它們可獲得基本類型的類信息。其中后一種方法中訪問(wèn)的是基本類型的封裝類 (如 Intege ) 中預(yù)先定義好的 TYPE 字段。

第二步是調(diào)用諸如 getDeclaredMethods 的方法，以取得該類中定義的所有方法的列表。

一旦取得這個(gè)信息，就可以進(jìn)行第三步了——使用 reflection API 來(lái)操作這些信息，如下面這段代碼：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它將以文本方式打印出 String 中定義的第一個(gè)方法的原型。

處理對(duì)象：

a.創(chuàng)建一個(gè)Class對(duì)象

b.通過(guò)getField 創(chuàng)建一個(gè)Field對(duì)象

c.調(diào)用Field.getXXX(Object)方法(XXX是Int,Float等，如果是對(duì)象就省略；Object是指實(shí)例).

例如：
import java.lang.reflect.*;

import java.awt.*;

class SampleGet {

public static void main(String[] args) throws Exception {

Rectangle r = new Rectangle(100, 325);

printHeight(r);
printWidth( r);
}

static void printHeight(Rectangle r)throws Exception {
//Field屬性名
Field heightField;
//Integer屬性值
Integer heightValue;
//創(chuàng)建一個(gè)Class對(duì)象
Class c = r.getClass();

//.通過(guò)getField 創(chuàng)建一個(gè)Field對(duì)象
heightField = c.getField("height");
//調(diào)用Field.getXXX(Object)方法(XXX是Int,Float等，如果是對(duì)象就省略；Object是指實(shí)例).
heightValue = (Integer) heightField.get(r);

System.out.println("Height: " + heightValue.toString());

}
static void printWidth(Rectangle r) throws Exception{

 Field widthField;

 Integer widthValue;

 Class c = r.getClass();

 widthField = c.getField("width");

 widthValue = (Integer) widthField.get(r);

 System.out.println("Height: " + widthValue.toString());

 
}

}
安全性和反射：

在處理反射時(shí)安全性是一個(gè)較復(fù)雜的問(wèn)題。反射經(jīng)常由框架型代碼使用，由于這一點(diǎn)，我們可能希望框架能夠全面接入代碼，無(wú)需考慮常規(guī)的接入限制。但是，在其它情況下，不受控制的接入會(huì)帶來(lái)嚴(yán)重的安全性風(fēng)險(xiǎn)，例如當(dāng)代碼在不值得信任的代碼共享的環(huán)境中運(yùn)行時(shí)。

由于這些互相矛盾的需求，Java編程語(yǔ)言定義一種多級(jí)別方法來(lái)處理反射的安全性。基本模式是對(duì)反射實(shí)施與應(yīng)用于源代碼接入相同的限制：

從任意位置到類公共組件的接入

類自身外部無(wú)任何到私有組件的接入

受保護(hù)和打包（缺省接入）組件的有限接入

不過(guò)至少有些時(shí)候，圍繞這些限制還有一種簡(jiǎn)單的方法。我們可以在我們所寫(xiě)的類中，擴(kuò)展一個(gè)普通的基本類 java.lang.reflect.AccessibleObject 類。這個(gè)類定義了一種setAccessible方法，使我們能夠啟動(dòng)或關(guān)閉對(duì)這些類中其中一個(gè)類的實(shí)例的接入檢測(cè)。唯一的問(wèn)題在于如果使用了安全性管理 器，它將檢測(cè)正在關(guān)閉接入檢測(cè)的代碼是否許可了這樣做。如果未許可，安全性管理器拋出一個(gè)例外。

下面是一段程序，在TwoString 類的一個(gè)實(shí)例上使用反射來(lái)顯示安全性正在運(yùn)行：

public class ReflectSecurity {

public static void main(String[] args) {

try {

TwoString ts = new TwoString("a", "b");

Field field = clas.getDeclaredField("m_s1");

// field.setAccessible(true);

System.out.println("Retrieved value is " +

field.get(inst));

} catch (Exception ex) {

ex.printStackTrace(System.out);

}

}

}

如果我們編譯這一程序時(shí)，不使用任何特定參數(shù)直接從命令行運(yùn)行，它將在field .get(inst)調(diào)用中拋出一個(gè)IllegalAccessException異常。如果我們不注釋 field.setAccessible(true)代碼行，那么重新編譯并重新運(yùn)行該代碼，它將編譯成功。最后，如果我們?cè)诿钚刑砑恿薐VM參數(shù) -Djava.security.manager以實(shí)現(xiàn)安全性管理器，它仍然將不能通過(guò)編譯，除非我們定義了ReflectSecurity類的許可權(quán) 限。

反射性能：（轉(zhuǎn)錄別人的啊）

反射是一種強(qiáng)大的工具，但也存在一些不足。一個(gè)主要的缺點(diǎn)是對(duì)性能有影響。使用反射基本上是一種解釋操作，我們可以告訴JVM，我們希望做什么并且它滿足我們的要求。這類操作總是慢于只直接執(zhí)行相同的操作。

下面的程序是字段接入性能測(cè)試的一個(gè)例子，包括基本的測(cè)試方法。每種方法測(cè)試字段接入的一種形式 -- accessSame 與同一對(duì)象的成員字段協(xié)作，accessOther 使用可直接接入的另一對(duì)象的字段，accessReflection 使用可通過(guò)反射接入的另一對(duì)象的字段。在每種情況下，方法執(zhí)行相同的計(jì)算 -- 循環(huán)中簡(jiǎn)單的加/乘順序。

程序如下：

public int accessSame(int loops) {

m_value = 0;

for (int index = 0; index < loops; index++) {

m_value = (m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return m_value;

}

public int acces

sReference(int loops) {

TimingClass timing = new TimingClass();

for (int index = 0; index < loops; index++) {

timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return timing.m_value;

}

public int accessReflection(int loops) throws Exception {

TimingClass timing = new TimingClass();

try {

Field field = TimingClass.class.

getDeclaredField("m_value");

for (int index = 0; index < loops; index++) {

int value = (field.getInt(timing) +

ADDITIVE_VALUE) * MULTIPLIER_VALUE;

field.setInt(timing, value);

}

return timing.m_value;

} catch (Exception ex) {

System.out.println("Error using reflection");

throw ex;

}

}

在上面的例子中，測(cè)試程序重復(fù)調(diào)用每種方法，使用一個(gè)大循環(huán)數(shù)，從而平均多次調(diào)用的時(shí)間衡量結(jié)果。平均值中不包括每種方法第一次調(diào)用的時(shí)間，因此初始化時(shí)間不是結(jié)果中的一個(gè)因素。下面的圖清楚的向我們展示了每種方法字段接入的時(shí)間：

圖 1：字段接入時(shí)間 ：

我們可以看出：在前兩副圖中(Sun JVM)，使用反射的執(zhí)行時(shí)間超過(guò)使用直接接入的1000倍以上。通過(guò)比較，IBM JVM可能稍好一些，但反射方法仍舊需要比其它方法長(zhǎng)700倍以上的時(shí)間。任何JVM上其它兩種方法之間時(shí)間方面無(wú)任何顯著差異，但I(xiàn)BM JVM幾乎比Sun JVM快一倍。最有可能的是這種差異反映了Sun Hot Spot JVM的專業(yè)優(yōu)化，它在簡(jiǎn)單基準(zhǔn)方面表現(xiàn)得很糟糕。反射性能是Sun開(kāi)發(fā)1.4 JVM時(shí)關(guān)注的一個(gè)方面，它在反射方法調(diào)用結(jié)果中顯示。在這類操作的性能方面，Sun 1.4.1 JVM顯示了比1.3.1版本很大的改進(jìn)。

如果為為創(chuàng)建使用反射的對(duì)象編寫(xiě)了類似的計(jì)時(shí)測(cè)試程序，我們會(huì)發(fā)現(xiàn)這種情況下的差異不象字段和方法調(diào)用情況下那么顯著。使用newInstance()調(diào) 用創(chuàng)建一個(gè)簡(jiǎn)單的java.lang.Object實(shí)例耗用的時(shí)間大約是在Sun 1.3.1 JVM上使用new Object()的12倍，是在IBM 1.4.0 JVM的四倍，只是Sun 1.4.1 JVM上的兩部。使用Array.newInstance(type, size)創(chuàng)建一個(gè)數(shù)組耗用的時(shí)間是任何測(cè)試的JVM上使用new type[size]的兩倍，隨著數(shù)組大小的增加，差異逐步縮小。隨著jdk6.0的推出，反射機(jī)制的性能也有了很大的提升。期待中….

總結(jié)：

Java語(yǔ)言反射提供一種動(dòng)態(tài)鏈接程序組件的多功能方法。它允許程序創(chuàng)建和控制任何類的對(duì)象(根據(jù)安全性限制)，無(wú)需提前硬編碼目標(biāo)類。這些特性使得反射 特別適用于創(chuàng)建以非常普通的方式與對(duì)象協(xié)作的庫(kù)。例如，反射經(jīng)常在持續(xù)存儲(chǔ)對(duì)象為數(shù)據(jù)庫(kù)、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使類和數(shù)據(jù)結(jié)構(gòu)能按名稱動(dòng)態(tài)檢索相關(guān)信息，并允許在運(yùn)行著的程序中操作這些信息。Java 的這一特性非常強(qiáng)大，并且是其它一些常用語(yǔ)言，如 C、C++、Fortran 或者 Pascal 等都不具備的。

但反射有兩個(gè)缺點(diǎn)。第一個(gè)是性能問(wèn)題。用于字段和方法接入時(shí)反射要遠(yuǎn)慢于直接代碼。性能問(wèn)題的程度取決于程序中是如何使用反射的。如果它作為程序運(yùn)行中相 對(duì)很少涉及的部分，緩慢的性能將不會(huì)是一個(gè)問(wèn)題。即使測(cè)試中最壞情況下的計(jì)時(shí)圖顯示的反射操作只耗用幾微秒。僅反射在性能關(guān)鍵的應(yīng)用的核心邏輯中使用時(shí)性 能問(wèn)題才變得至關(guān)重要。

許多應(yīng)用中更嚴(yán)重的一個(gè)缺點(diǎn)是使用反射會(huì)模糊程序內(nèi)部實(shí)際要發(fā)生的事情。程序人員希望在源代碼中看到程序的邏輯，反射等繞過(guò)了源代碼的技術(shù)會(huì)帶來(lái)維護(hù)問(wèn) 題。反射代碼比相應(yīng)的直接代碼更復(fù)雜，正如性能比較的代碼實(shí)例中看到的一樣。解決這些問(wèn)題的最佳方案是保守地使用反射——僅在它可以真正增加靈活性的地方 ——記錄其在目標(biāo)類中的使用。

一下是對(duì)應(yīng)各個(gè)部分的例子：

具體的應(yīng)用：

1、 模仿instanceof 運(yùn)算符號(hào)

class A {}

public class instance1 {

public static void main(String args[])

{

try {

Class cls = Class.forName("A");

boolean b1

= cls.isInstance(new Integer(37));

System.out.println(b1);

boolean b2 = cls.isInstance(new A());

System.out.println(b2);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

2、 在類中尋找指定的方法，同時(shí)獲取該方法的參數(shù)列表，例外和返回值

import java.lang.reflect.*;

public class method1 {

private int f1(

Object p, int x) throws NullPointerException

{

if (p == null)

throw new NullPointerException();

return x;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method1");

Method methlist[]

= cls.getDeclaredMethods();

for (int i = 0; i < methlist.length;

i++)

Method m = methlist[i];

System.out.println("name

= " + m.getName());

System.out.println("decl class = " +

m.getDeclaringClass());

Class pvec[] = m.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("

param #" + j + " " + pvec[j]);

Class evec[] = m.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println("exc #" + j

+ " " + evec[j]);

System.out.println("return type = " +

m.getReturnType());

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

3、 獲取類的構(gòu)造函數(shù)信息，基本上與獲取方法的方式相同

import java.lang.reflect.*;

public class constructor1 {

public constructor1()

{

}

protected constructor1(int i, double d)

{

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor1");

Constructor ctorlist[]

= cls.getDeclaredConstructors();

for (int i = 0; i < ctorlist.length; i++) {

Constructor ct = ctorlist[i];

System.out.println("name

= " + ct.getName());

System.out.println("decl class = " +

ct.getDeclaringClass());

Class pvec[] = ct.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("param #"

+ j + " " + pvec[j]);

Class evec[] = ct.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println(

"exc #" + j + " " + evec[j]);

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

4、 獲取類中的各個(gè)數(shù)據(jù)成員對(duì)象，包括名稱。類型和訪問(wèn)修飾符號(hào)

import java.lang.reflect.*;

public class field1 {

private double d;

public static final int i = 37;

String s = "testing";

public static void main(String args[])

{

try {

Class cls = Class.forName("field1");

Field fieldlist[]

= cls.getDeclaredFields();

for (int i

= 0; i < fieldlist.length; i++) {

Field fld = fieldlist[i];

System.out.println("name

= " + fld.getName());

System.out.println("decl class = " +

fld.getDeclaringClass());

System.out.println("type

= " + fld.getType());

int mod = fld.getModifiers();

System.out.println("modifiers = " +

Modifier.toString(mod));

System.out.println("-----");

}

}

catch (Throwable e) {

System.err.println(e);

}

}

}

5、 通過(guò)使用方法的名字調(diào)用方法

import java.lang.reflect.*;

public class method2 {

public int add(int a, int b)

{

return a + b;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Method meth = cls.getMethod(

"add", partypes);

method2 methobj = new method2();

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj

= meth.invoke(methobj, arglist);

Integer retval = (Integer)retobj;

System.out.println(retval.intValue());

}

catch (Throwable e) {

System.err.println(e);

}

}

}

6、 創(chuàng)建新的對(duì)象

import java.lang.reflect.*;

public class constructor2 {

public constructor2()

{

}

public constructor2(int a, int b)

{

System.out.println(

"a = " + a + " b = " + b);

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Constructor ct

= cls.getConstructor(partypes);

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj = ct.newInstance(arglist);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

7、 變更類實(shí)例中的數(shù)據(jù)的值

import java.lang.reflect.*;

public class field2 {

public double d;

public static void main(String args[])

{

try {

Class cls = Class.forName("field2");

Field fld = cls.getField("d");

field2 f2obj = new field2();

System.out.println("d = " + f2obj.d);

fld.setDouble(f2obj, 12.34);

System.out.println("d = " + f2obj.d);

}

catch (Throwable e) {

System.err.println(e);

}

}

}

使用反射創(chuàng)建可重用代碼：

1、 對(duì)象工廠

Object factory(String p) {

Class c;

Object o=null;

try {

c = Class.forName(p);// get class def

o = c.newInstance(); // make a new one

} catch (Exception e) {

System.err.println("Can't make a " + p);

}

return o;

}

public class ObjectFoundry {

public static Object factory(String p)

throws ClassNotFoundException,

InstantiationException,

IllegalAccessException {

Class c = Class.forName(p);

Object o = c.newInstance();

return o;

}

}

2、 動(dòng)態(tài)檢測(cè)對(duì)象的身份，替代instanceof

public static boolean

isKindOf(Object obj, String type)

throws ClassNotFoundException {

// get the class def for obj and type

Class c = obj.getClass();

Class tClass = Class.forName(type);

while ( c!=null ) {

if ( c==tClass ) return true;

c = c.getSuperclass();

}

return false;

}

posted @ 2011-09-23 14:53 順其自然EVO| 編輯 收藏

java中的工廠模式

posted @ 2011-09-23 13:38 順其自然EVO| 編輯 收藏

簡(jiǎn)單靜態(tài)代理與動(dòng)態(tài)代理

靜態(tài)：
首先需要一個(gè)接口
public interface Neting {

 public void netting();
 
 public String playGame(String name);
}
然后需要一個(gè)實(shí)例去繼承：

public class NetImpl implements Neting {

 @Override
 public void netting() {
  System.out.println("上網(wǎng)中....");
 }

 @Override
 public String playGame(String name) {
  System.out.println("游戲中....");
  return "game over";
 }

}

最后需要一個(gè)同樣實(shí)現(xiàn)了相同接口的類來(lái)做代理，并在每個(gè)方法中加入需要的操作：

public class NetingImplProxy implements Neting {

 private Neting neting;
 
 public NetingImplProxy(Neting neting){
  this.neting=neting;
 }
 @Override
 public void netting() {
  this.up();
  neting.netting();
  this.down();
 }

 @Override
 public String playGame(String name) {
  this.up();
  String str=neting.playGame(name);
  this.down();
  return str;
 }
 
 private void up(){
  System.out.println("撥號(hào)中");
 }
 
 private void down(){
  System.out.println("斷開(kāi)中");
 }

}

這樣產(chǎn)生的結(jié)果是每次更改方法中固定的操作時(shí)，都需要更改類的源代碼，帶來(lái)很多不便，由此產(chǎn)生動(dòng)態(tài)代理。
動(dòng)態(tài)代理需要一個(gè)Proxy類和invocationhandle接口來(lái)支持：

同樣，上述的接口和實(shí)現(xiàn)類都不變，不再需要代理類，而是由下面這個(gè)類動(dòng)態(tài)產(chǎn)生：
public class NetHandle implements InvocationHandler {
 
 //首先需要傳一個(gè)目標(biāo)對(duì)象的引用
 private Object targetObject;
 
//設(shè)置構(gòu)造方法時(shí)，直接將目標(biāo)對(duì)象作為參數(shù)傳入
 public NetHandle(Object targetObject){
  this.targetObject=targetObject;
 }
 
 //這是至關(guān)重要的，由此類實(shí)例的本方法產(chǎn)生一個(gè)$...代理對(duì)象：
 public Object createProxyInstance(){
  return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
           targetObject.getClass().getInterfaces(),
           this);
  
 }
//代理對(duì)象會(huì)自動(dòng)調(diào)用復(fù)寫(xiě)后的invoke方法，類似filter中的dofilter；
 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  up(); //在此加入需要增加的操作
  Object ret=method.invoke(targetObject, args);
  down();//在此加入需要增加的操作
  return ret;// 如果沒(méi)有返回值，則返回null。
 }
 
 private void up(){
  System.out.println("撥號(hào)中");
 }
 
 private void down(){
  System.out.println("斷開(kāi)中");
 }
}
測(cè)試：
 public static void main(String[] args) {
  
  NetHandle n=new NetHandle(new NetImpl());
  Neting net=(Neting) n.createProxyInstance();
  net.netting();
  System.out.println(net.playGame(""));
 }
運(yùn)行結(jié)果：
撥號(hào)中
上網(wǎng)中....
斷開(kāi)中
撥號(hào)中
游戲中....
斷開(kāi)中
game over

posted @ 2011-09-23 11:47 順其自然EVO| 編輯 收藏

singleton模式

這個(gè)單例模式一般是只能創(chuàng)建一個(gè)實(shí)例的實(shí)現(xiàn),如網(wǎng)絡(luò)游戲里每個(gè)特定的地圖,對(duì)于任意一個(gè)玩家,這個(gè)地圖都是唯一的. 其特點(diǎn)是有一個(gè)私有的構(gòu)造器和一個(gè)公開(kāi)的獲取實(shí)例的方法。比如：

//這是第一種,叫餓漢模式,無(wú)論是否需要,都弄一個(gè)出來(lái)


public class Singleton{
 private static final Singleton st=new Singleton();
 private Singleton(){
 
 }
 public static Singleton getInstance(){
  if(st==null)
  {
    return st;

  }
 }
}

//這是另外一種,叫懶漢模式,你不要我就不給弄,你要了再說(shuō).

public class SingleTon{
 private static SingleTon st;
 private SingleTon(){

 }
 public static SingleTon getInstance(){
   if (st==null){
     st=new SingleTon();
   }
   return st;
  }
}

二者在大多數(shù)情況沒(méi)區(qū)別,但是餓漢模式是線程安全的,懶漢模式是要加同步鎖的.不同步的話，在這個(gè)類的實(shí)例還沒(méi)有創(chuàng)建的時(shí)候,多個(gè)線程同時(shí)去調(diào)用getInstance, 這時(shí)，由于沒(méi)有同步鎖，有可能會(huì)創(chuàng)建出多個(gè)實(shí)例來(lái)。 
對(duì)于餓漢式，由于實(shí)例是在load class的時(shí)候創(chuàng)建的，所以就沒(méi)有這個(gè)問(wèn)題。 當(dāng)然，除非2個(gè)線程采用了不同的class loader. 
當(dāng)然， 無(wú)論餓漢還是懶漢， 幾率都不高， 但幾率低不代表不會(huì)出錯(cuò)， 邏輯上也不對(duì)， 因此， 編程者還是應(yīng)該避免。 

package test;

public class Singleton {
 private Singleton s;
 private Singleton()
 {
  
 }
 public static Singleton getSigleton()
 {
  if(s==null)s=new Singleton();
  return s;
 }

 
}
這就是一個(gè)單例模式，我想應(yīng)該不用注釋了，原理就是這個(gè)類的構(gòu)造方法private了，所有在外邊不能調(diào)用，也就不能new Singleton();得到實(shí)例，那么
想得到實(shí)例就得調(diào)用它的靜態(tài)方法getSigleton（）；即Singleton.getSigleton（）；就會(huì)返回一個(gè)Singleton的實(shí)例，注意此方法中的語(yǔ)句，
即如果你是第一次調(diào)用這個(gè)方法那么它會(huì)給你new一個(gè)實(shí)例，以后再調(diào)用得到的都是這個(gè)實(shí)例，也就是說(shuō)從始至終就只有一個(gè)Singleton的實(shí)例，這就是單例模式。
1、禁止掉可被調(diào)用的構(gòu)建方法
2、自動(dòng)初始化一個(gè)實(shí)例
public class EagerSingleton{
  private static final EagerSingletonst = new EagerSingleton();
  private EagerSingleton(){}
  public static EagerSingletongetInstance(){
    return st;
  }
}

public class LazySingleton{
  private static LazySingletonst;
  private LazySingleton(){}
  synchronized public static LazySingleton getInstance(){
    if (st==null){
      st = new LazySingleton();
    }
    return st;
  }
}


EagerSingleton比較適合JAVA 

posted @ 2011-09-23 11:29 順其自然EVO| 編輯 收藏

同步塊

posted @ 2011-09-23 10:36 順其自然EVO| 編輯 收藏