动态代理

**

一，静态代理

**

1、Count.java

package net.battier.dao;

/**

* 定义一个账户接口

*

* @author Administrator

*

*/

public interface Count {

// 查看账户方法

public void queryCount();

// 修改账户方法
public void updateCount();

}
2、CountImpl.java

package net.battier.dao.impl;

import net.battier.dao.Count;

/**

* 委托类(包含业务逻辑)

*

* @author Administrator

*

*/

public class CountImpl implements Count {

@Override
public void queryCount() {
System.out.println("查看账户方法...");

}

@Override
public void updateCount() {
System.out.println("修改账户方法...");

}

}
、CountProxy.java

package net.battier.dao.impl;

import net.battier.dao.Count;

/**

* 这是一个代理类（增强CountImpl实现类）

*

* @author Administrator

*

*/

public class CountProxy implements Count {

private CountImpl countImpl;

/**
* 覆盖默认构造器
*
* @param countImpl
*/
public CountProxy(CountImpl countImpl) {
this.countImpl = countImpl;
}

@Override
public void queryCount() {
System.out.println("事务处理之前");
// 调用委托类的方法;
countImpl.queryCount();
System.out.println("事务处理之后");
}

@Override
public void updateCount() {
System.out.println("事务处理之前");
// 调用委托类的方法;
countImpl.updateCount();
System.out.println("事务处理之后");

}

}
3、TestCount.java

package net.battier.test;

import net.battier.dao.impl.CountImpl;

import net.battier.dao.impl.CountProxy;

/**

*测试Count类

*

* @author Administrator

*

*/

public class TestCount {

public static void main(String[] args) {

CountImpl countImpl = new CountImpl();

CountProxy countProxy = new CountProxy(countImpl);

countProxy.updateCount();

countProxy.queryCount();

}

}
观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。

再来看一下动态代理：

二，JAVA的动态代理

代理模式

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

按照代理的创建时期，代理类可以分为两种。

静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

动态代理：在程序运行时，运用反射机制动态创建而成。

接口：
public interface IHello {
void hello();
}

类：
public class Hello implements IHello {

@Override
public void hello() {
System.out.println("我是Hello");
}
}

委托类：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {

private Object obj;

public void setObj(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("----------------开始:这可以放置一些别的逻辑");

method.invoke(obj, args);

System.out.println("----------------结束：这也可以放置一些别的逻辑");
return null;
}
}

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

import org.junit.Test;

//通过Proxy实现动态代理
public class HelloTest {
@Test
public void testProxy() throws Exception{

//获得被代理类实例
final IHello hello=new Hello();

//获得委托类，代理类中真的逻辑处理在这个类中
MyInvocationHandler inv=new MyInvocationHandler();

//把被代理类注入委托类，然后在委托类中使用被代理类的实例利用反射动态调用被代理类的方法
//这样动态代理的目的是在动态调用被代理类前后加入一些别的业务逻辑
inv.setObj(hello);

//注入委托类，被代理接口，获得实现了被代理类实现共同接口的代理类
//用代理类调用被代理类的方法
IHello proxyHello=(IHello) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), hello.getClass().getInterfaces(), inv);

proxyHello.hello();
}

从源代码看基于JDK的动态代理的原理看大神博客：/article/7493450.html

还有：/article/1381251.html

=======================================================================================