静态代理以及JDK动态代理和CGLB动态代理的实现

系统管理员 2024-04-17 17:15 85阅读 0赞

## 主业务接口类 ##

package 静态代理;
    
    public interface Service { 
    	//主业务接口
      public String test();
    }

## 目标类（代理要增强的主业务接口实现类） ##

public class ServiceImpl implements Service { 
    //目标类，代理类要增强的类。
    	@Override
    	public String test() { 
    		// TODO Auto-generated method stub
    		System.out.println("执行test方法，输出小写单词。");
    		return "abcd";
    	}
    
    }

--------------------

### 第一种代理方式：静态代理 ###

**静态代理就类似于公司的法律顾问，管你需要不需要，它都会提前等着你。**

//静态代理类
    public class Proxy implements Service{ //实现要增强的接口
    	public Service target;//在代理这创建要增强的方法的对象
    	public Proxy(Service target) { //传入的是Service的实现类对象，用父接口接受
    		super();
    		this.target = target;
    	}
    
    	public Proxy() { 
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    	@Override
    	public String test() { 
    		// TODO Auto-generated method stub
    		String string = target.test().toUpperCase();
    		return string;
    	}
    
    }

##### 测试静态代理 #####

public class TeststaticProxy { 
    	public static void main(String[] args) { 
    		//Service se= new ServiceImple();向上转
    		//Service s=new Proxy(se);
    		Service s= new Proxy(new ServiceImpl());//面向接口编程
    		System.out.println(s.test());
    	}
    }

### 第二种代理方式：JDK动态代理（当要增强的类有接口时用） ###

**相当于法院的律师，需要的时候才去请。**

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    import 静态代理.Service;
    import 静态代理.ServiceImpl;
    //InvocationHandler 是代理实例的调用处理程序 实现的接口
    /* jdk的动态代理 * 每个代理实例都具有一个关联的调用处理程序。 * 对代理实例调用方法时， * 将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。 */
    public class TestdymicProxy { //ctrl f11 运行
    	public static void main(String[] args) { 
    		final Service target = new ServiceImpl();//向上转
    		Service service=(Service) 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
    				Object result = method.invoke(target, args);//内部类不能使用非静变量
    				if (result!=null) { //alt shift +z 快速转if语句
    					result = ((String) result).toUpperCase();
    					//由于test方法右返回值，所以进行非空判断
    				}
    				return result;
    			}
    		});		
    		//代理对象执行目标方法时，会触发代理中的invoke（最外面的invoke）方法来增强。
    		String result = service.test();//当执行这一步的时候，调用上面的invoke
    		System.out.println(result);
    	}
    }

### 第三种代理方式：CGLB动态代理（当要增强的类无接口时用） ###

#### 要增强的类 ####

public class Service { 
    	public String test() { 
    		return "abc";
    	}
    }

#### 代理类 ####

import java.lang.reflect.Method;
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    public class Mycglbproxy implements MethodInterceptor { 
    	private Service target;
    
    	public Mycglbproxy(Service target) { 
    		super();
    		this.target = target;
    	}
    
    	public Mycglbproxy() { 
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	public Service CreatCglbProxy() { //创建代理:本质就是创建增强类的子类
    		Enhancer enhancer = new Enhancer();//增强器
    		//指定父类，cglb动态代理的原理就是子类增强父类
    		enhancer.setSuperclass(Service.class);
    		//设置回调函数。
    		enhancer.setCallback(this);
    		//creat方法创建动态cglb代理对象，也就是目标类的子类
    		return (Service) enhancer.create();
    	}
    	//回调接口的方法
    	@Override
    	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
    		// TODO Auto-generated method stub
    		Object invoke = method.invoke(target, args);//参数为类对象和原方法参数
    		if(invoke!=null) { //上一步是执行原方法，对返回值进行判断
    			invoke = ((String)invoke).toUpperCase();
    		}
    		return invoke;
    	}
    
    }

#### 测试cglb ####

public class TestCglb { 
    	public static void main(String[] args) { 
    		Service service = new Service();
    		Service proxy = new Mycglbproxy(service).CreatCglbProxy();
    		String test = proxy.test();
    		System.out.println(test);
    	}
    }