------------------------------ 代理模式(Proxy) -------------------------------
(1)
代理的好处:
--->是可以在间接访问对象的同时,要其前或后,添加其它的逻辑代码.
--->对原来逻辑进行添加其它逻辑,最终生成新的逻辑.即:对类的方法添加一些额外的逻辑,生成新的方法逻辑.
(1)
代理的好处:
--->是可以在间接访问对象的同时,要其前或后,添加其它的逻辑代码.
--->对原来逻辑进行添加其它逻辑,最终生成新的逻辑.即:对类的方法添加一些额外的逻辑,生成新的方法逻辑.
(2)
静态代理:
-->一个原类与一个代理类要一一对应。
-->两者都实现共同的接口或继承相同的抽象类;
-->只是在代理类中,实例化原类,在原类方法的前后添加新的逻辑。
如下:
抽象角色:
abstract public class Subject
{
abstract public void request();
}
静态代理:
-->一个原类与一个代理类要一一对应。
-->两者都实现共同的接口或继承相同的抽象类;
-->只是在代理类中,实例化原类,在原类方法的前后添加新的逻辑。
如下:
抽象角色:
abstract public class Subject
{
abstract public void request();
}
真实角色:
public class RealSubject extends Subject
{
public void request()
{
System.out.println("From real subject.");
}
}
public class RealSubject extends Subject
{
public void request()
{
System.out.println("From real subject.");
}
}
代理角色:
public class ProxySubject extends Subject
public class ProxySubject extends Subject
{
private RealSubject realSubject; //以真实角色作为代理角色的属性
private RealSubject realSubject; //以真实角色作为代理角色的属性
public ProxySubject()
{ realSubject=new RealSubject(); }
{ realSubject=new RealSubject(); }
public void request() //与原方法名相同
{
preRequest();
{
preRequest();
realSubject.request(); //此处执行真实对象的request方法
postRequest();
}
}
private void preRequest()
{
//something you want to do before requesting
}
private void postRequest()
{
//something you want to do after requesting
}
}
{
//something you want to do before requesting
}
private void postRequest()
{
//something you want to do after requesting
}
}
客户端调用:
Subject sub=new ProxySubject();
Sub.request();
Subject sub=new ProxySubject();
Sub.request();
(3)
动态代理类
Java动态代理类位于Java.lang.reflect包下,一般主要涉及到以下两个类:
1)
Interface InvocationHandler:该接口中仅定义了一个方法:invoke(Object obj,Method method, Object[] args)
动态代理类
Java动态代理类位于Java.lang.reflect包下,一般主要涉及到以下两个类:
1)
Interface InvocationHandler:该接口中仅定义了一个方法:invoke(Object obj,Method method, Object[] args)
。在实际使用时,第一个参数obj一般是指代理类,method是被代理的方法,args为该方法的参数数组。这个抽象方法
在代理类中动态实现。
2)
Proxy:该类即为动态代理类,其中主要包含以下内容:
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h):返回代理类
2)
Proxy:该类即为动态代理类,其中主要包含以下内容:
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h):返回代理类
的一个实例,返回后的代理类可以当作被代理类使用。
所谓Dynamic Proxy是这样一种class:它是在运行时生成的class,在生成它时你必须提供一组interface给它,然后
所谓Dynamic Proxy是这样一种class:它是在运行时生成的class,在生成它时你必须提供一组interface给它,然后
该class就宣称它实现了这些 interface。
3)
在使用动态代理类时,我们必须实现InvocationHandler接口,
public interface Subject
{
public void request();
}
3)
在使用动态代理类时,我们必须实现InvocationHandler接口,
public interface Subject
{
public void request();
}
具体角色RealSubject:同上;
代理角色:
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;
public class DynamicSubject implements InvocationHandler {
private Object sub;
public DynamicSubject(Object obj) {
sub = obj;
}
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;
public class DynamicSubject implements InvocationHandler {
private Object sub;
public DynamicSubject(Object obj) {
sub = obj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before calling " + method);
System.out.println("before calling " + method);
method.invoke(sub,args);
System.out.println("after calling " + method);
return null;
}
return null;
}
}
==>
method.invoke(sub,args);
其实就是调用被代理对象的将要被执行的方法,方法参数sub是实际的被代理对象,args为执行被代理对象相应操作所
==>
method.invoke(sub,args);
其实就是调用被代理对象的将要被执行的方法,方法参数sub是实际的被代理对象,args为执行被代理对象相应操作所
需的参数。通过动态代理类,我们可以在调用之前或之后执行一些相关操作。
客户端:
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class Client
{
static public void main(String[] args) throws Throwable
{
RealSubject rs = new RealSubject(); //在这里指定被代理类
InvocationHandler ds = new DynamicSubject(rs); //初始化代理类
Subject subject = (Subject) Proxy.newProxyInstance(rs.getClass().getClassLoader(),rs.getClass
{
static public void main(String[] args) throws Throwable
{
RealSubject rs = new RealSubject(); //在这里指定被代理类
InvocationHandler ds = new DynamicSubject(rs); //初始化代理类
Subject subject = (Subject) Proxy.newProxyInstance(rs.getClass().getClassLoader(),rs.getClass
().getInterfaces(),ds );
subject.request();
}
subject.request();
}
5)
实例二:
package dynamicProxy;
public interface Work {
public void startWork();
}
实例二:
package dynamicProxy;
public interface Work {
public void startWork();
}
package dynamicProxy;
public class JasonWork implements Work {
public void startWork() {
System.out.println("jason start to work...");
}
}
public class JasonWork implements Work {
public void startWork() {
System.out.println("jason start to work...");
}
}
public interface Play {
public void startPlay();
}
public void startPlay();
}
public class JasonPlay implements Play {
public void startPlay() {
System.out.println("jason start to play...");
}
}
public void startPlay() {
System.out.println("jason start to play...");
}
}
public class Test {
public static void main(String[] args)
{
JasonWork work=new JasonWork();
InvocationHandler dynamicProxy=new DynamicProxy(work);
Work jasonproxy=(Work)Proxy.newProxyInstance(work.getClass().getClassLoader(),
public static void main(String[] args)
{
JasonWork work=new JasonWork();
InvocationHandler dynamicProxy=new DynamicProxy(work);
Work jasonproxy=(Work)Proxy.newProxyInstance(work.getClass().getClassLoader(),
work.getClass().getInterfaces(), dynamicProxy);
jasonproxy.startWork();
jasonproxy.startWork();
JasonPlay play=new JasonPlay();
InvocationHandler dynamicProxy=new DynamicProxy(play);
Play jasonproxy=(Play)Proxy.newProxyInstance(play.getClass().getClassLoader(),
InvocationHandler dynamicProxy=new DynamicProxy(play);
Play jasonproxy=(Play)Proxy.newProxyInstance(play.getClass().getClassLoader(),
play.getClass().getInterfaces(), dynamicProxy);
jasonproxy.startPlay();
}
}
===>动态代理类,可以与任何类型的真实类(work/play),进行结合,进行动态的代理.
jasonproxy.startPlay();
}
}
===>动态代理类,可以与任何类型的真实类(work/play),进行结合,进行动态的代理.
相关推荐
java常用设计模式-代理模式
总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元...
Java的一些常用设计模式,包括单例模式、门面模式、策略模式、观察者模式、建造者模式、简单工厂模式、抽象工厂模式、工厂方法模式、代理模式、动态代理模式,适合初学者掌握
JAVA常用设计模式,包括:简单工厂、抽象工厂、单例、外观、桥接、代理等设计模式
java常用的设计模式一个简单总结,如工厂模式、单例模式、代理模式等等。(楼主也是未入门的菜鸟,如有错误请及时联系楼主更正,谢谢!)
java常用设计模式及JDK与CGLIB实现动态代理区别(源码) /** * 使用cglib动态代理 * @author * */ public class BookFacadeProxy implements MethodInterceptor{ private Object target; @Override public...
设计模式中定义: 为其他对象提供一种代理以控制对这个对象的访问. 为什么要使用Proxy? 1.授权机制 不同级别的用户对同一对象拥有不同的访问权利,如Jive论坛系统中,就使用Proxy进行授权机制控制,访问论坛有两种人:...
分类 创建模式 工厂模式;建造模式;原始模型模式;单例模式 结构模式 适配器;桥梁模式;合成模式;装饰模式;门面模式;享元模式;代理模式 行为模式 优点 面向界面编程 降低耦合性 增加灵活性
Java代码积累:并发 设计模式 数据结构 使用容器 实用 类 基础知识 并发性 演示线程的生命周期 生产者-消费者 设计模式参考《大话设计模式》 工厂简单模式 创造型模式 工厂方法模式 抽象工厂模式 原型模式 建造者...
本书使用Java语言详细讲解常用的软件设计模式。全书共26章,内容包括设计模式概述、面向对象设计原则、简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式、适配器模式、桥接模式、组合模式...
培养学生掌握简单工厂模式、工厂方法模式、单例模式、原型模式、桥接模式、适配器模式、装饰模式、代理模式、命令模式、观察者模式等常用设计模式的设计思想,并掌握在实际软件工程领域中的运用,能够把所学的原理...
设计模式:(常用23种-----像内功心法) 1. 设计模式不是一个知识点 2. 设计模式是一种设计经验的总结 3. 设计模式是用来解决某些场景下的某一类问题--------通用的解决方案 4. 有了设计模式之后,可以让代码更容易被...
单例模式、代理模式、工厂模式、适配器模式、策略模式、模板方法模式的java源码实现
java之23中常用设计模式详解 总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观...
1.2 Smalltalk MVC中的设计模式 3 1.3 描述设计模式 4 1.4 设计模式的编目 5 1.5 组织编目 7 1.6 设计模式怎样解决设计问题 8 1.6.1 寻找合适的对象 8 1.6.2 决定对象的粒度 9 1.6.3 指定对象接口 9 1.6.4 描述对象...
用java写的几个常用的设计模式。包括 工厂模式、适配器模式、桥接模式、建造者模式、命令模式、组合模式、装饰模式、外观模式、工厂方法模式、迭代器模式、观察者模式、代理模式、单例模式、状态模式、策略模式、...
几种常用的设计模式实例:单例 工厂 代理 命令 策略
18.Singleton.java java设计模式之单例模式 19.Factory.java 设计模式之工厂模式 20.Swing.java 介绍了java的图形应用 --课程包括了java SE的大部分常用类及其简单用法 如果你对java,android感兴趣,都可以加入...
java常用23种设计模式 模式实例 单态模式、工厂模式、抽象工厂、享元模式、适配器模式、代理模式、桥梁模式、装饰者模式、、、、、
Java 中常用的各种设计模式,如单例模式,工厂模式,代理模式,访问者模式,观察者模式,中介者模式等