有关java的动态代理和代理模式

有关java的动态代理和代理模式
 一, 有关设计模式
==设计模式可分为以下三类==
创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
今天说构造型的代理模式,动态代理可以说是代理模式+反射了
 二,代理模式
当我们要去给一段代码最增强并保证低耦合,不破坏原有代码块的情况下代理模式是一个不错的选择
 三,静态代理
###### 接口
我们要拥有一个接口来规定实现类的行为
```java
package staticProxy;

public interface Person {

void eat();

void say();

}
```
###### 实现类
我们还需要一个实现上述接口的实现类

```java
package staticProxy;

public class PersonImp implements Person{

@Override
public void eat() {
System.out.println("调用了"+ this.getClass().getName()+"的eat方法");
}

@Override
public void say() {
System.out.println("调用了"+ this.getClass().getName()+"的say()方法");
}

}
```
###### 代理类
接下来创建代理类,

```java
package staticProxy;

import java.util.Date;

public class Proxy implements Person{

Person zhangsan;

public Proxy(Person zhangsan) {
super();
this.zhangsan = zhangsan;
}

@Override
public void eat() {

//模拟增强代码块
System.out.println(new Date());

zhangsan.eat();
}

@Override
public void say() {

//模拟增强代码块
System.out.println(new Date());

zhangsan.say();
}

}

```
思路很简单就是在代理类(另一个实现类)中调用原本实现类的方法,这样就可以达到增强代码的效果,例如,记录日志等
###### 测试

```java
package staticProxy;

public class Test {
public static void main(String[] args) {

Person zhangsan = new PersonImp();

Proxy lisi = new Proxy(zhangsan);

lisi.eat();

lisi.say();

}
}

```
###### 测试类结果

四,动态代理
要实现动态代理我们要知道一个接口java.lang.reflect.InvocationHandler和一个静态方法java.lang.reflect.Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException,
==上代码吧==
###### 接口
动态代理同样需要一个接口来规范实现类的动作

```java
package dynamicProxy;
// 有关接口名,
// eclipse不让我用Person我也不知道为什么,
// 可能重命名???
public interface Perosn {

void eat();

void say();

}

```
###### 实现类
同样需要一个实现类来做简单实现

```java
package dynamicProxy;

public class PersonImp implements Perosn{

@Override
public void eat() {
System.out.println("调用了"+ this.getClass().getName()+"的eat()方法");
}

@Override
public void say() {
System.out.println("调用了"+ this.getClass().getName()+"的say()方法");
}

}
```
###### 代理类
这里的代理类比较难理解,但是不麻烦
简单讲,就是这个代理类个静态代理实现类不同,它不需要实现原本的Perosn接口,而需要实现java.lang.reflect.InvocationHandler接口,此接口中只有一个抽象类需要实现,public Object invoke(Object proxy,Method method, Object[] args)throws Throwable;
同时还需要一个返回代理对象的方法,具体实现:在返回代理对象的方法中调用java.lang.reflect.Proxy.newProxyInstance()方法,该方法会返还一个Object,这个Object就是代理对象

```java
package dynamicProxy;

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

import javax.xml.bind.DataBindingException;

public class Proxy implements InvocationHandler {

Perosn zhangsan;

public Proxy(Perosn zhangsan) {
super();
this.zhangsan = zhangsan;
}

@Override
/*
* @param Object proxy : 代理对象
*
* @param Method method : 被代理方法
*
* @param Object[] args : 被代理方法的形式参数
*
* @return 返回被代理方法的返回值
*
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

// 模拟增强代码块
System.out.println(new Date());

Object value = method.invoke(zhangsan, args);

return value;
}

//利用该方法得到代理对象
public Object getProxy() {

/*
* 有关java.lang.reflect.Proxy.newProxyInstance(
* ClassLoader loader,
* Class<?>[] interfaces,
* InvocationHandler h) throws IllegalArgumentException方法
*
* @param ClassLoader loader : 被代理类的类加载器,利用反射
* @param Class<?>[] interfaces : 被代理类的实现接口,利用反射
* @param InvocationHandler h : 代理管理器对象,this
*/
Object lisi = java.lang.reflect.Proxy.newProxyInstance(zhangsan.getClass().getClassLoader(),
zhangsan.getClass().getInterfaces(), this);

return lisi;

}
}

```
###### 测试

```java
package dynamicProxy;

public class Test {

public static void main(String[] args) {

//得到被代理对象
Perosn zhangsan = new PersonImp();

//获得代理管理器
Proxy proxy = new Proxy(zhangsan);

//获得代理对象
Perosn lisi = (Perosn) proxy.getProxy();

lisi.eat();

lisi.say();

}

}

```
###### 结果

当然,无论是静态代理还是动态代理,都是有代理对象来调用接口中的方法
# 五,动态代理和静态代理的区别
静态代理:由程序员创建代理类生成源代码再对其编译。整个代理过程其实就是面向对象的运用。

动态代理:在程序运行时运用反射机制动态创建而成,具体代理过程与jvm完成,所以,叫动态代理???
虽然代码写的不怎么样,包名也不规范,**但是**,,,如果需要源码的话可以给我说
**祝大家新年快乐鸭**

原文地址:https://www.cnblogs.com/nrcy/p/12238358.html

时间: 2024-10-16 18:06:05

有关java的动态代理和代理模式的相关文章

代理模式 &amp; Java原生动态代理技术 &amp; CGLib动态代理技术

第一部分.代理模式  代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息.过滤消息.把消息转发给委托类,以及事后处理消息等.代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务.(其实就是在代理类中关联一个委托类的实例,然后在代理类中进行包装). UML图如下: 第二部分.在Java中实现代理模式  按照代理的创建时期,代理类可以分

Java代理/静态代理/动态代理/代理模式

代理模式:即Proxy Pattern,常用的设计模式之一.代理模式的主要作用是为其他对象提供一种代理以控制对这个对象的访问. 代理概念 :为某个对象提供一个代理,以控制对这个对象的访问. 代理类和委托类有共同的父类或父接口,这样在任何使用委托类对象的地方都可以用代理对象替代.代理类负责请求的预处理.过滤.将请求分派给委托类处理.以及委托类执行完请求后的后续处理. 下面以明星为例模拟需求说明静态代理和动态代理. 一.首先看静态代理 看下图:歌迷希望明星许巍唱歌(许巍即是目标对象),但不可能直接找

【转载】Java JDK 动态代理(AOP)使用及实现原理分析

转自:http://blog.csdn.net/jiankunking/article/details/52143504 版权声明:作者:jiankunking 出处:http://blog.csdn.net/jiankunking 本文版权归作者和CSDN共有 一.什么是代理? 代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问.代理类负责为委托类预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理. 代理模式UML图: 简单结构示意图: 为了保持

java的动态代理机制详解

在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于 Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的我们的功能,我们更需要学习的是其底层是怎么样的一个原理,而AOP的原理就是 java的动态代理机制,所以本篇随笔就是对java的动态机制进行一个回顾. 在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface).另一个则是 Proxy(Cla

Java中动态代理技术生成的类与原始类的区别 (转)

用动态代理的时候,对它新生成的类长什么样子感到好奇.有幸通过一些资料消除了心里的疑惑. 平时工作使用的Spring框架里面有一个AOP(面向切面)的机制,只知道它是把类重新生成了一遍,在切面上加上了后来定义的逻辑.这样就达到了动态的在原有类上增加一些功能.比如日志打印,拦截信息等. 这里只关心动态代理技术生成新的类,先不管虚拟机是如何去生成类,用了什么字节码生成技术,怎么产生字节码等这一系列动作.现在只关心最后生成的新类长什么样,它和老类有什么区别.为了获取到生成后的代理类的字节码并且反编译成我

Java中动态代理实现原理深究

一.前言 笔者平时开发使用"动态代理"不多,最近在看设计模式的时候,"动态代理"又在面前晃了几次,所以这次想从源码的角度去分析动态代理的实现原理,以窥探其精妙~ 二.正文 2.1 静态代理  本文源码基于:jdk1.6.0_33 在正式剖析动态代理的源码之前,我们可以先来看看"静态代理"(就是我们普通的代理模式)的UML图: 从上图可以看出,代理类"ProxySubject"和被代理类"RealSubject&quo

从java 反射看延迟加载(代理模式)(二)

代理模式 代理模式使用代理对象完成用户请求,屏蔽用户对真实对象的访问.现实世界的代理人被授权执行当事人的一些事宜,无需当事人出面,从第三方的角度看,似乎当事人并不存在,因为他只和代理人通信.而事实上代理人是要有当事人的授权,并且在核心问题上还需要请示当事人. 在软件设计中,使用代理模式的意图也很多,比如因为安全原因需要屏蔽客户端直接访问真实对象,或者在远程调用中需要使用代理类处理远程方法调用的技术细节 (如 RMI),也可能为了提升系统性能,对真实对象进行封装,从而达到延迟加载的目的. 代理模式

Java特性-动态代理

代理在开发中无处不在: 我们完成一个接口开发A,接口下有很多个实现类,这些类有些共同要处理的部分,比如每一个类都定义了接口A中的方法getXX(String name).我现在想把每次调用某个实现类的getXX方法时传的参数name记录在数据库某个表里,可问题是,,我们总不能在每个实现类里面去添加一个这样的处理模块吧?工作量太大了,把该处理逻辑写到一个static的工具类里面,然后每个实现类再去调用也挺麻烦.况且这个处理是给改接口专门使用的,放在工具类里也不合适啊.. 好办,我再写一个实现接口A

java的动态代理

最近在研究这个java的ssh三大框架,当看到这个spring的aop(aspect-orinted-programming)的时候,其中提到了这个java的动态代理机制,这个动态代理,我以前似乎看过,但是那是设计模式的事情.所以有一次搜索到这个动态代理,对这个动态代理进行一个研究,记录自己的进步. spring的aop编程是一个面向切面的编程思想,和这个面向对象的编程是一个补充的关系,不是一个对立的关系.面向对象强调和使用的从上到下的层次关系,但是aop编程使用的是从左到右的关系.一个是纵的关