设计模式之代理模式
一. 概述
代理（Proxy）是一种设计模式， 提供了对目标对象另外的访问方式；即通过代理访问目标对象。 这样好处： 可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。
代理模式的关键点： 代理对象与目标对象。
举例：明星（达康书记）←---经纪人<-------老板
目标 （代理）
1.1 静态代理的实现
静态代理，
1） 代理对象，要实现与目标对象一样的接口；
2） 举例:
保存用户(模拟)
Dao , 直接保存
DaoProxy, 给保存方法添加事务处理
实现静态代理的步骤:
1. 创建接口类
2. 代理对象和目标对象实现接口
3. 代理对象要传入目标对象
创建 接口类 IUserDao.java
package com.it.a_static;
public interface IUserDao {
public void save();
}
目标对象类UserDao.java
package com.it.a_static;
public class UserDao implements IUserDao{
@Override
public void save() {
// TODO Auto-generated method stub
System.out.println("---已经保存数据----");
}
}
代理对象类 UserDaoProxy.java
package com.it.a_static;
/*
* 代理对象:静态代理!
* 代理对象要和目标对象一样实现接口
* */
public class UserDaoProxy implements IUserDao{
//接收保存目标对象
private IUserDao target;
public UserDaoProxy(IUserDao userDao) {
// TODO Auto-generated constructor stub
this.target = userDao;
}
@Override
public void save() {//开闭原则
// TODO Auto-generated method stub
System.out.println("开始事务");
this.target.save();
System.out.println("提交事务");
}
}
测试类App.java
package com.it.a_static;
public class App {
public static void main(String[] args) {
//1.静态代理
/*
* 优点:不修改目标对象的功能代码扩展对目标对象功能
* 缺点:代理对象和目标对象实现一样的接口,造成类太多;比较繁琐,需要全部实现代理方法
*
* */
IUserDao userDao = new UserDao();
UserDaoProxy proxy = new UserDaoProxy(userDao);
proxy.save();
}
}
总结静态代理：
1）可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。
2）缺点：
--》 因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。
--》 一旦接口增加方法，目标对象与代理对象都要维护。
解决：
可以使用动态代理。
1.2 动态代理的实现
动态代理，
1）代理对象，不需要实现接口；
2）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；);
3) 动态代理， JDK代理， 接口代理；
JDK中生成代理对象的API：
|-- Proxy
static Object newProxyInstance(
ClassLoader loader, 指定当前目标对象使用类加载器
Class<?>[] interfaces, 目标对象实现的接口的类型
InvocationHandler h 事件处理器
在静态代理的基础上,创建类 ProxyFactory.java
package com.it.b_dynamic;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/*
* 动态代理
* */
public class ProxyFactory {
private Object target;
//维护一个目标对象
public ProxyFactory(Object target) {
// TODO Auto-generated constructor stub
this.target = target;
}
//给目标对象,生成代理对象
public Object getProxyInstance() {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
System.out.println("开始事务");
//执行目标对象的方法
Object retValue = method.invoke(target, args);
System.out.println("提交事务");
return retValue;
}
}
);
}
}
测试动态代理 App.java
package com.it.b_dynamic;
public class App02 {
public static void main(String[] args) {
//动态代理
IUserDao target = new UserDao();
IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
proxy.save();
}
}
结果输出:
开始事务
---已经保存数据----
提交事务
动态代理总结：
代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！
(class $Proxy0 implements IuserDao)
思考：
有一个目标对象，想要功能扩展，但目标对象没有实现接口，怎样功能扩展？
Class UserDao{}
// 子类的方式
Class subclass extends UserDao{}
以子类的方式实现(cglib代理)
1.3 cglib代理的实现
cglid代理
Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩
展。
* JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果
想代理没有实现接口的类，就可以使用Cglib实现。
* Cglib是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java
接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的
interception（拦截）。
* Cglib包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新
的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令
集都很熟悉。
Cglib子类代理：
1) 需要引入cglib – jar文件， 但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-4.1.6.jar即可。
2）引入功能包后，就可以在内存中动态构建子类
3）代理的类不能为final， 否则报错。
4） 目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象
额外的业务方法。
在Spring的AOP编程中，
如果加入容器的目标对象有实现接口，用JDK代理；
如果目标对象没有实现接口，用Cglib代理；
实现Cglib代理代码如下:
UserDao.java
package com.it.c_cglib;
public class UserDao{
public void save() {
// TODO Auto-generated method stub
System.out.println("---已经保存数据----");
}
}
ProxyFactory.java
package com.it.c_cglib;
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
/*
* Cgilb子类代理工厂
* (对UserDao在内存中动态构建一个子类对象!)
* */
public class ProxyFactory implements MethodInterceptor{
private Object target;
public ProxyFactory(Object target) {
// TODO Auto-generated constructor stub
this.target = target;
}
public Object getProxyInstance() {
// TODO Auto-generated method stub
Enhancer en = new Enhancer();
en.setSuperclass(target.getClass());
en.setCallback(this);
//创建子类(代理对象)
Object create = en.create();
return create;
}
@Override
public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
// TODO Auto-generated method stub
System.out.println("开始事务");
Object retValue = method.invoke(target, args);
System.out.println("提交事务");
return retValue;
}
}
测试Cglib代理 App.java
package com.it.c_cglib;
public class App03 {
public static void main(String[] args) {
//Cglib代理
UserDao target = new UserDao();
ProxyFactory proxyFactory = new ProxyFactory(target);
UserDao userDao = (UserDao) proxyFactory.getProxyInstance();
userDao.save();
}
}
至此,Java中的三种代理模式实现,可以根据需要选择不同的实现方式.
