设计模式-代理模式

静态代理模式：----代理模式的作⽤是：为其他对象提供⼀种代理 以控制对这个对象的访问。代理模式⼀般涉及到的⻆⾊有：--抽象⻆⾊：声明真实对象和代理对象的共同接⼝。（租房⼦）--代理⻆⾊：代理对象⻆⾊内部含有对真实对象的 引⽤。相当于对真实对象进⾏封装。（中介）---真实⻆⾊：代理⻆⾊所代表的真实对象，是我们 最终要引⽤的对象。（房东）————————————————————————实例：

package com.proxy;

/** 可以是⼀个抽象类，也可以是⼀个接⼜
* 作为代理和真实⾓⾊拥有的共同接⼜
*/
public abstract class Subject
{
public abstract void request();//请求。代理⾓⾊和
真实⾓⾊都要实现这个⽅法
}————————————————package com.proxy;

/*
 * 真实⾓⾊，相当于房主
 */
public class RealSubject extends Subject
{
@Override
public void request()
{
System.out.println("From real subject");
}
}————————————package com.proxy;

/*
 * 最终要⾓⾊，相当于中介
 */
public class ProxySubject extends Subject {
    private RealSubject realSubject; // 代理⾓⾊内部引
    ⽤了真实⾓⾊

    @Override
    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.request();// 真实⾓⾊完成的事情
    }}————————————————————————————package com.proxy;—————————————————————————————————动态代理模式：如果⼤量使⽤静态代理会导致类的急剧膨胀；此外，如果事先并不知道真实⻆⾊，该如何使⽤代 理呢？这个问题可以通过Java的动态代理来解决。---Java动态代理类位于java.lang.reflect包下，⼀般 主要涉及到以下两个类：（1）

    Interface InvocationHandler；该接⼝

    中仅定 义了⼀个⽅法：

public object invoke(Object obj, Method
method,Object[] args)
-在实际使⽤时，第⼀个参数obj⼀般是指代理类，
method是被代理的⽅法，如上例中的request()，
args为该⽅法的参数数组。这个抽象⽅法在代理类
中动态实现。
（2） Proxy： 该 类即为动态代理类，作⽤类似于
上⾯的ProxySubject，其中主要包含以下内容：---Protected Proxy(InvocationHander 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接⼝：
——————————————————————
——————
实例：
package com.dynamic;
/*
* 使⽤动态代理只能使⽤接⼜
*/
    public interface Subject {
        public void request();
    }——————package com.dynamic;

    public class RealSubject implements Subject {
        @Override
        public void request() {
            System.out.println("真实⾓⾊");
        }
}————————package com.dynamic;

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

/**
 * 该代理类的内部属性是Object类型，实际使⽤的时 候通过该类的构造⽅法传递进来⼀个对象
 */
public class DynamicSubject implements InvocationHandler {
    private Object obj;

public DynamicSubject(Object obj) //通过此传进来
⼀个对象
{
this.obj = obj;
}public Object invoke(Object proxy, Method method,
Object[] args)
throws Throwable
{
//method.invoke()其实就是调⽤真实对象将要执⾏的
⽅法
method.invoke(obj, args)； //反射调⽤. arg是⽅
法的参数。相当于静态代理中的
realSubject.request()。不过不同的是，其可以代理各
种不同的对象，没有写死，很灵活。
return null;
}
}——————————————————————————package com.dynamic;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Client {public static void main(String[] args)
{
RealSubject realSubject = new RealSubject();
//每⼀个动态代理类都有⼀个与之对应的
InvocationHandler。
InvocationHandler handler = new
DynamicSubject(realSubject);//代理哪个对象就传⼊哪
个对象
Class<?> classType = handler.getClass(); //反射
// 下⾯的代码⼀次性⽣成代理 。运⾏时动态⽣
成类，⽣成类后⽣成实例（subject），宣称⾃⼰也实
现了这些类的接⼜，所以下⾯才能使
⽤subject.request()
Subject subject = (Subject)
Proxy.newProxyInstance(classType
.getClassLoader(),
realSubject.getClass().getInterfaces(),
handler);
//realSubject.getClass().getInterfaces()表⽰realSubject
实现什么接⼜，代理类就实现什么接⼜
subject.request(); //只是⼀个代理，调⽤时，流程⽴即转到invoke()⽅法上去
}}！！！！再看定义：

    所谓Dynamic Proxy是这样⼀种 class：它是在运⾏时⽣成的class，在⽣

    成它时你必 须提供⼀组interface给它，

    然后该class就宣称它也实 现了这些interface。——————————————————动态代理步骤：1. 创建⼀个实现接⼝InvocationHandler的类，

    它必须 实现invoke⽅法。2. 创建被代理的类以及接⼝3. 通过Proxy的静态⽅法
newProxyInstance(ClassLoader loader , Class[]
interfaces , InvocationHandler h)创建⼀个代理。
4.通过代理调⽤⽅法。
——————————————————————
——————
//⽣成唯⼀实例的类
public class Singleton
{private static Singleton singleton = new Singleton(); //先
把唯⼀对象⽣成好。
private Singleton() //声明为private,只有⾃⼰能够访问.类的
内部才能使⽤
{
}
public static Singleton getInstance()
{
return singleton; //把唯⼀的⼀个实例返回
}
}
——————————
//⽣成唯⼀实例的类
class Singleton
{
private static Singleton singleton; //先不⽣成对象
private Singleton() //声明为private,只有⾃⼰能够访问.类的
内部才能使⽤
{
}
public static Singleton getInstance()
{
if(singleton == null) //在此处判断，如果为null，则⽣成
⼀个对象.{
single = new Singleton();
}
return singleton;
}
}