文章目录
代理模式
1 什么是代理
代理模式是常用的java设计模式。
代理类 主要负责为委托类(被代理对象)预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。
代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
代理类在执行被代理类的功能方法前后，加入一些业务逻辑：权限的验证，事务的处理，日志的记录
2 代理的分类
{一般代理对象和被代理对象都会实现同一个接口，特别是静态代理}
按照代理对象的创建时期，代理类可以分为两种，静态代理，动态代理。
2.1 静态代理
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
- 定义接口：
public interface Buy {
public void byIphone11();
public void byHouse();
}
- 实现类：
public class Myself implements Buy{
@Override
public void byIphone11() {
System.out.println("-----iphone11------");
}
@Override
public void byHouse() {
System.out.println("--------买房--------");
}
}
// 代理对象
public class ProxyBuy implements Buy{
private Myself myself; //被代理的对象
public ProxyBuy(Myself myself){
this.myself = myself;
}
private void beforeByIphone11(){
System.out.println("---排队---");
}
@Override
public void byIphone11() {
beforeByIphone11();
myself.byIphone11();//5000
afterByIphone11();
}
private void afterByIphone11() {//5500 +500=6000
System.out.println("--收点手续费-----30");
}
@Override
public void byHouse() {
beforeByHouse();
myself.byHouse();
afterByHouse();
}
private void afterByHouse() {
System.out.println("----履行合同-- 收款0.03-- 0.05 0.02 0.03");
}
private void beforeByHouse() {
System.out.println("--筛选适合的房子---");
}
}
- 测试类
public class TestBuy {
public static void main(String[] args) {
//被代理对象
Myself myself = new Myself();
//代理对象
ProxyBuy proxyBuy = new ProxyBuy(myself);
proxyBuy.byIphone11();// myself .buy
proxyBuy.byHouse();
}
}
- 结果
2.2 动态代理
动态代理：在程序运行时，运用反射机制动态创建而成。
1 动态代理的实现方法
- 如果被代理类实现了接口，可以使用jdk提供的Proxy，InvocationHandler实现
- 如果被代理类没有实现接口，可以使用cglib，通过继承来实现动态代理，使用的时候必须导入cglib的包。
2 动态代理的实际使用
Struts2中的拦截器
Spring中的aop
Hibernate中的代理
3 java动态代理demo(JDK）
JDK动态代理中包含一个类和一个接口：
InvocationHandler接口：
public interface InvocationHandler {
/**Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数 */
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
Proxy类：专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h) throws IllegalArgumentException
/**ClassLoader loader：类加载器
Class<?>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例 */
demo：
- 接口
public interface BookFacade {
public void addBook();
}
- 实现类
public class BookFacadeImpl implements BookFacade {
@Override
public void addBook() {
System.out.println("---增加图书的方法-----");
}
}
- JDK动态代理类
public class BookFacadeProxy implements InvocationHandler {
private Object object;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
System.out.println("----事务开始----");
// 执行方法
result = method.invoke(object,args);
System.out.println("------事务结束-----");
return result;
}
/**
* 绑定委托对象并返回一个代理类
*/
public Object bind(Object object) {
this.object = object;
// 取得代理对象
return Proxy.newProxyInstance(object.getClass().getClassLoader(),
object.getClass().getInterfaces(),this);
//要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)
}
}
- 测试类
public class TestProxy {
public static void main(String[] args) {
BookFacadeProxy proxy = new BookFacadeProxy();
BookFacade bookFacade = (BookFacade) proxy.bind(new BookFacadeImpl());
bookFacade.addBook();
}
}
4 java动态代理demo(cglib）
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
idea,spring,maven项目：
- 导入依赖：
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
- 统一代理类
import net.sf.cglib.proxy.InvocationHandler;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ProxyHandler implements InvocationHandler {
private Object obj;
public ProxyHandler (Object obj) {
this.obj = obj;
}
/**
* 他可以监控你正在调用的方法
* @param proxy 产生代理对象
* @param method 正在调用方法
* @param args 方法参数
* @return 方法返回值
* @throws Throwable
*/
@Override
public Object invoke (Object proxy, Method method, Object[] args) throws Throwable {
beforeLog(method);
Object returnValue = null;
try {
returnValue= method.invoke(obj, args); //.reflect.
afterLog(method);
} catch (Exception e){
exceptionLog(method,e);
}
return returnValue;
}
private void exceptionLog(Method method, Exception e) {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())
+ method.getName() +"调用发生了异常"+e);
}
private void beforeLog (Method method) {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())
+ " 正在调用方法："+method.getName());
}
private void afterLog(Method method) {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())
+ method.getName()+"方法调用完毕");
}
}
- 被代理类：
public class UserServiceImpl {
public void add() {
// int i = 1 / 0;
System.out.println("------user新增------");
}
public void delete() {
System.out.println("------user删除------");
}
}
public class AdminServiceImpl {
public void select() {
System.out.println("------admin查询------");
}
public void update() {
System.out.println("------修改admin------");
}
}
- 测试类
public class TestObject {
@Test
public void AdminServiceImpl(){
AdminServiceImpl adminService = null;
//万能的代理对象 控制器
ProxyHandler proxyHandler = new ProxyHandler(new AdminServiceImpl());
// 产生了代理对象
adminService = (AdminServiceImpl)
Enhancer.create(AdminServiceImpl.class,AdminServiceImpl.class.getInterfaces(),proxyHandler);
adminService.select();
}
@Test
public void testUserService() {
UserServiceImpl userService = null;
ProxyHandler proxyHandler = new ProxyHandler(new UserServiceImpl());
userService = (UserServiceImpl)
Enhancer.create(UserServiceImpl.class,UserServiceImpl.class.getInterfaces(),proxyHandler);
userService.add();
}
}
- 结果
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
