1.staicproxy ---静态代理
一）.代理模式（proxy pattern） 核心作用：
1）.通过代理，控制对对象的访问！
2）.可以详细控制访问某个对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理
二）.应用场景
1）.安全代理：屏蔽对真实脚色真实访问
2）.远程代理： 通过代理类处理远程方法调用（RMI）
3）.延迟加载：先加载轻量级的代理对象，真正需要在加载真实对象
三）.分类
1）.静态代理（静态定义代理类）
2）.动态生成代理类（动态生成代理类）
--JDK自带的动态代理
--javaassist字节码操作库实现
--Cglib 类库实现
--ASM (底层使用指令，可维护性较差）
package cn.sxt.service; public interface UserService { public void add(); public void update(); public void delete(); public void search(); }
package cn.sxt.service; public class UserServiceImpl implements UserService { @Override public void add() { //公共的业务----日志，安全，权限，缓存，事务等等 //A.log();---分离的思想--纸质阅读器；osgi--java模块开发-spring--osgi System.out.println("增加用户"); } @Override public void update() { System.out.println("修改用户"); } @Override public void delete() { System.out.println("删除用户"); } @Override public void search() { System.out.println("查询用户"); } }
package cn.sxt.service; public class UserServiceProxy implements UserService{ private UserService userService; public UserServiceProxy(UserService userService) { super(); this.userService = userService; } public UserServiceProxy() { super(); } @Override public void add() { log("add"); userService.add(); } @Override public void delete() { //日志，安全，缓存，事务，异常处理等 log("delete"); userService.delete(); } @Override public void search() { log("search"); userService.search(); } public void update() { log("update"); userService.update(); } public void log(String methodName){ System.out.println("执行"+methodName+"方法"); } }
package cn.sxt.service; public class Test { public static void main(String[] args) { UserServiceProxy proxy=new UserServiceProxy(new UserServiceImpl()); proxy.add(); proxy.update(); proxy.delete(); proxy.search(); } } /*执行add方法 增加用户 执行update方法 修改用户 执行delete方法 删除用户 执行search方法 查询用户 */
2.dynamicproxy动态代理
一）动态代理相比静态代理的优点
1）.抽象角色中（接口）声明的 所以方法都被转移到调用处理器一个集中的地方处理，这样，我们可以更加灵活
和统一的处理众多的方法
2）开发框架中应用场景：
--stuts2 中拦截器的实现
--数据库连接池关闭处理
--hibernate 中延迟加载的实现
-- mybatis中实现拦截器插件
-- Aspect的实现
--spring中AOP 的实现
日志拦截和声明式实物处理
--web service RMI 远程方法调用
二）.JDK动态代理中包含一个类和一个接口：
InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
参数说明：
Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数
可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。
三）.Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
参数说明：
ClassLoader loader：类加载器
Class<?>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例
四）.Ps:类加载器
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器;
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jrelibext目录中的类;
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。
version1
package cn.sxt.dynamicproxy; import java.lang.reflect.Proxy; import java.util.ArrayList; import java.util.List; import cn.sxt.service.UserService; import cn.sxt.service.UserServiceImpl; public class Client { public static void main(String[] args) { System.out.println("userService+++++++++++++++++++++++++++++++"); UserService userService = new UserServiceImpl(); ProxyInovationHandler pih = new ProxyInovationHandler(userService); UserService proxy = (UserService)pih.getProxy(); proxy.delete(); System.out.println("list+++++++++++++++++++++++++++++++"); ProxyInovationHandler ph1 = new ProxyInovationHandler(new ArrayList()); List list = (List)ph1.getProxy(); list.add(1); System.out.println(list.get(0)); } } /*userService+++++++++++++++++++++++++++++++ 执行delete方法 前置 删除用户 后置 list+++++++++++++++++++++++++++++++ 执行add方法 前置 后置 执行get方法 前置 后置 1 */
package cn.sxt.dynamicproxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class ProxyInovationHandler implements InvocationHandler{ private Object target;//目标对象--真实对象 public ProxyInovationHandler() { super(); } public ProxyInovationHandler(Object i) { super(); this.target = i; } public Object getProxy(){ return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); } /** * proxy是代理类 * method 代理类的调用处理程序的方法对象 * */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("执行"+method.getName()+"方法"); System.out.println("前置"); Object result = method.invoke(target, args); System.out.println("后置"); return result; } }
package cn.sxt.service; public interface UserService { public void add(); public void update(); public void delete(); public void search(); }
package cn.sxt.service; public class UserServiceImpl implements UserService { @Override public void add() { System.out.println("增加用户"); } @Override public void update() { System.out.println("修改用户"); } @Override public void delete() { System.out.println("删除用户"); } @Override public void search() { System.out.println("查询用户"); } }
version 2
package com.ndqn.proxy; public interface Start { /** * 面谈 */ void confer(); /** * 签合同 */ void signContract(); /** * 订票 */ void bookTicket(); /** * 唱歌 */ void sing(); /** * 收钱 */ void collectMoney(); }
package com.ndqn.proxy; public class RealStar implements Start { @Override public void bookTicket() { System.out.println("RealStar.bookTicket()"); } @Override public void collectMoney() { System.out.println("RealStar.collectMoney()"); } @Override public void confer() { System.out.println("RealStar.confer()"); } @Override public void signContract() { System.out.println("RealStar.signContract()"); } @Override public void sing() { System.out.println("RealStar(周杰伦sing()"); } }
package com.ndqn.proxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class StarHandle implements InvocationHandler { Start realStart; public StarHandle(Start realStart) { super(); this.realStart = realStart; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object object = null; System.out.println("真正的方法执行前！"); System.out.println("面谈，签合同，预付款，订机票"); if(method.getName().equals("sing")){ object = method.invoke(realStart, args); } System.out.println("真正的方法执行后！"); System.out.println("收尾款"); return object; } }
package com.ndqn.proxy; /** * 妯℃嫙鍔ㄦ�鐢熸垚鐨勪唬鐞嗙殑缁撴瀯 * @author Administrator * */ public class ProxyStar implements Start { StarHandle handler; public ProxyStar(StarHandle handler) { super(); this.handler = handler; } public void bookTicket() { // handler.invoke(this,当前方法 , args); } public void collectMoney() { // handler.invoke(this,当前方法 , args); } public void confer() { // handler.invoke(this,当前方法, args); } public void signContract() { // handler.invoke(this,当前方法 , args); } public void sing() { // handler.invoke(this,当前方法 , args); } }
package com.ndqn.proxy; import java.lang.reflect.Proxy; public class Client { public static void main(String[] args) { Start realStar = new RealStar(); StarHandle handler = new StarHandle(realStar); Start proxy = (Start) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Start.class}, handler); proxy.sing(); } }
3.带有AOP的动态代理模式类图：
从上图中，可以看出有两个相对独立的模块(Subject和InvocationHandler)。动态代理实现代理的职责，业务逻辑Subject实现相关的逻辑功能，两者之间没有必然的相互耦合的关系。然而，通知Advice从另一个切面切入，最终在上层模块就是Client耦合，完成逻辑的封装。
代码清单如下
抽象主题或者接口：
package com.yemaozi.proxy.dynamic_aop; public interface Subject { public void doSomething(String str); //...可以多个逻辑处理方法。。。 }
package com.yemaozi.proxy.dynamic_aop; public class RealSubject implements Subject{ public void doSomething(String str) { //do something... System.out.println("do something..." + str); } }
package com.yemaozi.proxy.dynamic_aop; //通知接口及定义、 public interface IAdvice { public void exec(); }
package com.yemaozi.proxy.dynamic_aop; public class BeforeAdvice implements IAdvice { //在被代理的方法前来执行，从而达到扩展功能。 public void exec() { System.out.println("前置通知被执行！"); } }
package com.yemaozi.proxy.dynamic_aop; public class AfterAdvice implements IAdvice { //在被代理的方法后来执行，从而达到扩展功能。 public void exec() { System.out.println("后置通知被执行！"); } }
package com.yemaozi.proxy.dynamic_aop; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class MyInvocationHandler implements InvocationHandler { //被代理的对象 private Subject realSubject; //通过MyInvocationHandler的构造方法将被代理对象传递过来。 public MyInvocationHandler(Subject realSubject){ this.realSubject = realSubject; } //执行被代理类的方法。 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //在执行方法前，执行前置通知。 IAdvice beforeAdvice = new BeforeAdvice(); beforeAdvice.exec(); Object result = method.invoke(this.realSubject, args); //在执行方法后，执行后置通知。 IAdvice afterAdvice = new AfterAdvice(); afterAdvice.exec(); //前置通知，和后置通知，都是要看具体实际的业务需求来进行添加。 return result; } }
package com.yemaozi.proxy.dynamic_aop; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; public class DynamicProxy { /** * public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler handler) * loader： * 一个ClassLoader对象，定义了由哪个ClassLoader对象，来对生产的代理进行加载。 * interfaces： * 一个Interfaces数组，表示我将要给我所代理的对象提供一组什么样的接口， * 如果提供一组接口给它，那么该代理对象就宣称实现了该接口，从而可以调用接口中的方法。 * 即，查找出真是主题类的所实现的所有的接口。 * handler： * 一个InvocationHandler对象，表示当我这个动态代理对象在调用方法时，会关联到该InvocationHandler对象。 * 该InvocationHandler与主题类有着关联。 */ public static <T> T newProxyInstance(ClassLoader classLoader, Class<?>[] interfaces, InvocationHandler handler){ @SuppressWarnings("unchecked") T t = (T) Proxy.newProxyInstance(classLoader, interfaces, handler); return t; } }
package com.yemaozi.proxy.dynamic_aop; import java.lang.reflect.InvocationHandler; public class AOPClient { public static void main(String[] args) { Subject realSubject = new RealSubject(); InvocationHandler handler = new MyInvocationHandler(realSubject); ClassLoader classLoader = realSubject.getClass().getClassLoader(); Class<?>[] interfaces = realSubject.getClass().getInterfaces(); Subject proxySubect = DynamicProxy.newProxyInstance(classLoader, interfaces, handler); proxySubect.doSomething("这是一个Dynamic AOP示例！！！"); } } 执行结果： 前置通知被执行！ do something...这是一个Dynamic AOP示例！！！ 后置通知被执行！
动态代理在现在用的是非常的多的，如像Spring AOP ，DBCP连接池，AspectJ等。。。
4. Cglib动态代理
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
示例
package com.bdqn.ulist; /** *这个是没有实现接口的实现类 * * @author admin * */ public class BookCadeImpl { public void add() { System.out.println("This is add service"); } public void delete(int id) { System.out.println("This is delete service：delete " + id ); } }
package com.bdqn.ulist; import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; /** * 使用cglib动态代理 */ public class BookFacadeCglib implements MethodInterceptor { Object target; public Object getInstance(Object target){ this.target=target; Enhancer enhancer=new Enhancer(); enhancer.setSuperclass(this.target.getClass()); enhancer.setCallback(this); return enhancer.create(); } //回调方法 public Object intercept(Object obj, Method method, Object[] arg, MethodProxy proxy) throws Throwable { System.out.println("事务开始"); Object ob=proxy.invokeSuper(obj, arg); System.out.println("事务结束"); return ob; } }
package com.bdqn.ulist; import java.beans.Introspector; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; public class TestCglib { public static void main(String[] args) { BookFacadeCglib interceptor=new BookFacadeCglib(); BookCadeImpl cadeImpl=(BookCadeImpl) interceptor.getInstance(new BookCadeImpl()); cadeImpl.add(); cadeImpl.delete(2); } }
