有关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