Spring 代理中的静态代理、动态代理

代理模式：

1、代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

2、代理模式的组成：

抽象角色：通过接口或抽象类声明真实角色实现的业务方法。

代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

3、代理模式的优点：

(1).职责清晰

真实的角色就是实现实际的业务逻辑，不用关心其他非本职的事务，通过后期的代理完成一件事务，附带的结果就是编程简洁清晰。

(2).代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了中介的作用和保护了目标对象的作用。

(3).高扩展性

4、代理模式分为静态代理、动态代理。

静态代理是由程序员创建或工具生成代理类的源码，再编译代
4000
理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

动态代理是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。

5、代理模式结构图



实现静态代理的步骤：
1).定义一个抽象的主题接口。

public interface IGetSomething {
void getsomething();
}

2).定义一个真实主题的类，实现抽象主题接口。
public class RealGetSomething implements IGetSomething {
@Override
public void getsomething() {
System.out.println("主人亲自收货并签字了");
}
}
3).定义一个代理主题的类，实现抽象主题接口，但是这个类关联了所代理的主题对象。
public class ProxyGetSomething implements IGetSomething {

private RealGetSomething realGetSomething;//依赖关系
public RealGetSomething getRealGetSomething() {
return realGetSomething;
}
public void setRealGetSomething(RealGetSomething realGetSomething) {
this.realGetSomething = realGetSomething;
}
public ProxyGetSomething(RealGetSomething _realGetSomething){
this.realGetSomething=_realGetSomething;
}
@Override
public void getsomething() {
getbefore();
realGetSomething.getsomething();
getafter();
}
private void getbefore(){
System.out.println("检查快递是否是本小区的");
}
private void getafter(){
System.out.println("快递签收完毕");
}

}
4).编写客户端调用的类（对外部开放）
public class ClientDemo {
private IGetSomething igetsomething;

public IGetSomething getIgetsomething() {
return igetsomething;
}

public void setIgetsomething(IGetSomething igetsomething) {
this.igetsomething = igetsomething;
}
public ClientDemo(IGetSomething _igetsomething){
this.igetsomething=_igetsomething;
}
public void show(){
igetsomething.getsomething();
}
}
5).测试类
public class ProxyStaticTest {
@Test
public void testit(){
RealGetSomething realGetSomething = new RealGetSomething();
IGetSomething igetsomething = new ProxyGetSomething(realGetSomething);
ClientDemo client = new ClientDemo(igetsomething);
client.show();
}
}

结果：



实现动态代理的步骤：
1).定义一个抽象的主题接口。

public interface IData {
public void opdata();
}

2).定义二个真实主题的类，一个查询和删除。实现抽象主题接口。

public class DeleteData implements IData{
@Override
public void opdata() {
System.out.println("这是对于数据库的删除方法");
}
}

public class SelectData implements IData {
@Override
public void opdata() {
System.out.println("这是对于数据库的查询方法");
}
}

3).定义一个动态代理的平台.

public class DataHandler implements InvocationHandler {
private Object obj;

// 添加Set方法
public void setObj(Object obj) {
this.obj = obj;
}

public DataHandler(Object _obj) {
super();
this.obj = _obj;
}

public void getconnection() {
System.out.println("这是动态代理提供的动态代理平台对象的方法的执行开始");
}

public void closeconnection() {
System.out.println("这是动态代理提供的动态代理平台对象的方法的执行完毕");
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// 调用代理对象的方法执行
getconnection();
Object ret = method.invoke(obj, args);
closeconnection();
return ret;
}
} 4).测试类

public class DataTest {
@Test
public void testit() {
// 生成一个动态代理对象，只能针对接口的实现
IData delet = new DeleteData();
// 生成一个动态代理平台
DataHandler dataHandler = new DataHandler(delet);
// 根据动态代理平台实现动态代理对象的生成
IData delete = (IData) Proxy.newProxyInstance(delet.getClass()
.getClassLoader(), delet.getClass().getInterfaces(),
dataHandler);
// 生成一个动态代理对象，只能针对接口的实现
IData selec = new SelectData();
// 生成一个动态代理平台
DataHandler dataHandler2 = new DataHandler(selec);
// 根据动态代理平台实现动态代理对象的生成
IData select = (IData) Proxy.newProxyInstance(selec.getClass()
.getClassLoader(), selec.getClass().getInterfaces(),
dataHandler2);
delete.opdata();
System.out.println("");
select.opdata();
}
}

结果：